LCOV - code coverage report
Current view: top level - src/components/searchbox/v2 - NodeSearchListItem.vue Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 100.0 % 13 13
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : <template>
       2        10803 :   <div
       3              :     class="option-container flex w-full items-center justify-between overflow-hidden"
       4              :   >
       5              :     <div class="flex min-w-0 flex-1 flex-col gap-1 overflow-hidden">
       6              :       <!-- Row 1: Name (left) + badges (right) -->
       7              :       <div class="flex items-center gap-2 text-sm">
       8              :         <span
       9              :           v-if="isBookmarked && !hideBookmarkIcon"
      10              :           role="img"
      11              :           :aria-label="$t('g.bookmarked')"
      12              :         >
      13              :           <i aria-hidden="true" class="pi pi-bookmark-fill mr-1 text-sm" />
      14              :         </span>
      15              :         <span class="truncate">
      16              :           <HighlightedText :text="nodeDef.display_name" :query="currentQuery" />
      17              :         </span>
      18              :         <Badge
      19              :           v-if="showIdName"
      20              :           data-testid="node-id-badge"
      21              :           variant="square"
      22              :           severity="secondary"
      23              :           class="text-muted-foreground"
      24              :         >
      25              :           <HighlightedText :text="nodeDef.name" :query="currentQuery" />
      26              :         </Badge>
      27              : 
      28              :         <template v-if="showDescription">
      29              :           <div class="flex-1" />
      30              :           <div class="flex shrink-0 items-center gap-1">
      31              :             <span v-if="showSourceBadge && isCore" :class="badgePillClass">
      32              :               <span class="truncate text-2xs">{{ $t('g.comfy') }}</span>
      33              :             </span>
      34              :             <span
      35              :               v-else-if="
      36              :                 showSourceBadge &&
      37              :                 nodeDef.nodeSource.type !== NodeSourceType.Unknown
      38              :               "
      39              :               :class="badgePillClass"
      40              :             >
      41              :               <span class="truncate text-2xs">
      42              :                 {{ nodeDef.nodeSource.displayText }}
      43              :               </span>
      44              :             </span>
      45              : 
      46              :             <span v-if="isEssential" :class="badgePillClass">
      47              :               <span class="truncate text-2xs">{{ $t('g.essentials') }}</span>
      48              :             </span>
      49              : 
      50              :             <span
      51              :               v-if="nodeDef.api_node && providerName"
      52              :               :class="badgePillClass"
      53              :             >
      54              :               <i
      55              :                 aria-hidden="true"
      56              :                 class="icon-[lucide--coins] size-3 text-credit"
      57              :               />
      58              :               <i
      59              :                 aria-hidden="true"
      60              :                 :class="cn(getProviderIcon(providerName), 'size-3')"
      61              :               />
      62              :             </span>
      63              :           </div>
      64              :         </template>
      65              :         <template v-else>
      66              :           <NodePricingBadge :node-def="nodeDef" />
      67              :           <NodeProviderBadge v-if="nodeDef.api_node" :node-def="nodeDef" />
      68              :         </template>
      69              :       </div>
      70              : 
      71              :       <div
      72              :         v-if="showDescription"
      73              :         class="flex min-w-0 items-center gap-1.5 text-xs text-muted-foreground"
      74              :       >
      75              :         <span v-if="showCategory" class="max-w-2/5 shrink-0 truncate">
      76              :           {{ nodeDef.category.replaceAll('/', ' / ') }}
      77              :         </span>
      78              :         <span
      79              :           v-if="nodeDef.description && showCategory"
      80              :           class="h-3 w-px shrink-0 bg-border"
      81              :         />
      82              :         <TextTicker v-if="nodeDef.description" class="min-w-0 flex-1">
      83              :           {{ nodeDef.description }}
      84              :         </TextTicker>
      85              :       </div>
      86              :     </div>
      87              :     <div
      88              :       v-if="!showDescription"
      89              :       class="flex items-center gap-1 text-xs text-muted-foreground"
      90              :     >
      91              :       <Badge
      92              :         v-if="nodeDef.deprecated"
      93              :         variant="square"
      94              :         class="bg-destructive/20 text-destructive"
      95              :       >
      96              :         {{ $t('g.deprecated') }}
      97              :       </Badge>
      98              :       <Badge v-if="nodeDef.experimental" variant="square" severity="info">
      99              :         {{ $t('g.experimental') }}
     100              :       </Badge>
     101              :       <span
     102              :         v-if="nodeDef.dev_only"
     103              :         class="rounded-sm bg-cyan-500/20 px-1.5 py-0.5 text-cyan-400"
     104              :       >
     105              :         {{ $t('g.devOnly') }}
     106              :       </span>
     107              :       <span
     108              :         v-if="showNodeFrequency && nodeFrequency > 0"
     109              :         data-testid="frequency-badge"
     110              :         class="rounded-sm bg-secondary px-1.5 py-0.5"
     111              :       >
     112              :         {{ formatNumberWithSuffix(nodeFrequency, { roundToInt: true }) }}
     113              :       </span>
     114              :       <span
     115              :         v-if="nodeDef.nodeSource.type !== NodeSourceType.Unknown"
     116              :         class="rounded-sm bg-secondary px-2 py-0.5 text-sm"
     117              :       >
     118              :         {{ nodeDef.nodeSource.displayText }}
     119              :       </span>
     120              :     </div>
     121              :   </div>
     122              : </template>
     123              : 
     124              : <script setup lang="ts">
     125              : import Badge from '@comfyorg/design-system/badge/Badge'
     126              : import { computed } from 'vue'
     127              : 
     128              : import TextTicker from '@comfyorg/design-system/common/TextTicker'
     129              : import NodePricingBadge from '@/components/node/NodePricingBadge.vue'
     130              : import NodeProviderBadge from '@/components/node/NodeProviderBadge.vue'
     131              : import HighlightedText from '@comfyorg/design-system/common/HighlightedText'
     132              : import { NODE_TO_ESSENTIALS_CATEGORY } from '@/constants/essentialsNodes'
     133              : import { useSettingStore } from '@/platform/settings/settingStore'
     134              : import { useNodeBookmarkStore } from '@/stores/nodeBookmarkStore'
     135              : import type { ComfyNodeDefImpl } from '@/core/graph/nodeDef/ComfyNodeDefImpl'
     136              : import { useNodeFrequencyStore } from '@/stores/nodeFrequencyStore'
     137              : import { CORE_NODE_MODULES, NodeSourceType } from '@/types/nodeSource'
     138              : import { getProviderIcon, getProviderName } from '@/utils/categoryUtil'
     139              : import { formatNumberWithSuffix } from '@/utils/formatUtil'
     140              : import { cn } from '@comfyorg/tailwind-utils'
     141              : 
     142              : const {
     143              :   nodeDef,
     144              :   currentQuery,
     145              :   showDescription = false,
     146              :   showSourceBadge = false,
     147              :   hideBookmarkIcon = false
     148              : } = defineProps<{
     149              :   nodeDef: ComfyNodeDefImpl
     150              :   currentQuery: string
     151              :   showDescription?: boolean
     152              :   showSourceBadge?: boolean
     153              :   hideBookmarkIcon?: boolean
     154              : }>()
     155              : 
     156         2355 : const badgePillClass =
     157              :   'flex h-[18px] max-w-28 shrink-0 items-center justify-center gap-1 rounded-full bg-accent/80 px-2'
     158              : 
     159        10617 : const settingStore = useSettingStore()
     160        10617 : const showCategory = computed(() =>
     161              :   settingStore.get('Comfy.NodeSearchBoxImpl.ShowCategory')
     162              : )
     163        10617 : const showIdName = computed(
     164              :   () =>
     165              :     settingStore.get('Comfy.NodeSearchBoxImpl.ShowIdName') &&
     166              :     nodeDef.nodeSource.type !== NodeSourceType.Blueprint
     167              : )
     168        10617 : const showNodeFrequency = computed(() =>
     169              :   settingStore.get('Comfy.NodeSearchBoxImpl.ShowNodeFrequency')
     170              : )
     171        10617 : const nodeFrequencyStore = useNodeFrequencyStore()
     172        10617 : const nodeFrequency = computed(() =>
     173              :   nodeFrequencyStore.getNodeFrequency(nodeDef)
     174              : )
     175              : 
     176        10617 : const nodeBookmarkStore = useNodeBookmarkStore()
     177        10617 : const isBookmarked = computed(() => nodeBookmarkStore.isBookmarked(nodeDef))
     178        10617 : const providerName = computed(() => getProviderName(nodeDef.category))
     179        10617 : const isCore = computed(() =>
     180              :   CORE_NODE_MODULES.includes(nodeDef.python_module.split('.')[0])
     181              : )
     182        10617 : const isEssential = computed(() => !!NODE_TO_ESSENTIALS_CATEGORY[nodeDef.name])
     183              : </script>
        

Generated by: LCOV version 2.0-1