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

            Line data    Source code
       1              : <template>
       2         3547 :   <div
       3              :     ref="dialogRef"
       4              :     class="flex h-[min(80vh,750px)] w-full flex-col overflow-hidden rounded-lg border bg-background"
       5              :   >
       6              :     <!-- Search input row -->
       7              :     <NodeSearchInput
       8              :       ref="searchInputRef"
       9              :       v-model:search-query="searchQuery"
      10              :       :filters="filters"
      11              :       @remove-filter="emit('removeFilter', $event)"
      12              :       @navigate-down="navigateResults(1)"
      13              :       @navigate-up="navigateResults(-1)"
      14              :       @select-current="selectCurrentResult"
      15              :       @focusin="onSearchFocus"
      16              :     />
      17              : 
      18              :     <!-- Filter header row -->
      19              :     <div class="flex items-center">
      20              :       <NodeSearchFilterBar
      21              :         v-model:is-sidebar-open="isSidebarOpen"
      22              :         class="flex-1"
      23              :         :filters="filters"
      24              :         :active-category="rootFilter"
      25              :         :has-favorites="nodeBookmarkStore.bookmarks.length > 0"
      26              :         :has-essential-nodes="nodeAvailability.essential"
      27              :         :has-blueprint-nodes="nodeAvailability.blueprint"
      28              :         :has-partner-nodes="nodeAvailability.partner"
      29              :         :has-custom-nodes="nodeAvailability.custom"
      30              :         @toggle-filter="onToggleFilter"
      31              :         @clear-filter-group="onClearFilterGroup"
      32              :         @focus-search="nextTick(() => searchInputRef?.focus())"
      33              :         @select-category="onSelectCategory"
      34              :       />
      35              :     </div>
      36              : 
      37              :     <!-- Content area -->
      38              :     <div class="relative flex min-h-0 flex-1 overflow-hidden">
      39              :       <NodeSearchCategorySidebar
      40              :         v-show="isSidebarOpen"
      41              :         id="node-search-category-sidebar"
      42              :         v-model:selected-category="sidebarCategory"
      43              :         :aria-label="isMobile ? t('g.categories') : undefined"
      44              :         class="w-52 shrink-0 max-md:absolute max-md:inset-y-0 max-md:left-0 max-md:z-20 max-md:bg-background max-md:shadow-md"
      45              :         :hide-chevrons="!anyTreeCategoryHasChildren"
      46              :         :hide-presets="rootFilter !== null"
      47              :         :node-defs="rootFilteredNodeDefs"
      48              :         :root-label="rootFilterLabel"
      49              :         :root-key="rootFilter ?? undefined"
      50              :         @auto-expand="selectedCategory = $event"
      51              :       />
      52              : 
      53              :       <!-- Mobile overlay backdrop to close sidebar on outside click -->
      54              :       <div
      55              :         v-if="isMobile && isSidebarOpen"
      56              :         data-testid="sidebar-backdrop"
      57              :         class="absolute inset-0 z-10 md:hidden"
      58              :         @click="isSidebarOpen = false"
      59              :       />
      60              : 
      61              :       <!-- Results list -->
      62              :       <div
      63              :         id="results-list"
      64              :         role="listbox"
      65              :         tabindex="-1"
      66              :         class="flex-1 overflow-y-auto py-2 pr-3 pl-1 select-none"
      67              :         @pointermove="onPointerMove"
      68              :       >
      69       156095 :         <div
      70              :           v-for="(node, index) in displayedResults"
      71              :           :id="`result-item-${index}`"
      72              :           :key="node.name"
      73              :           role="option"
      74              :           data-testid="result-item"
      75              :           :tabindex="index === selectedIndex ? 0 : -1"
      76              :           :aria-selected="index === selectedIndex"
      77              :           :class="
      78              :             cn(
      79              :               'flex h-14 cursor-pointer items-center rounded-lg px-4 outline-none focus-visible:ring-2 focus-visible:ring-primary',
      80              :               index === selectedIndex && 'bg-secondary'
      81              :             )
      82              :           "
      83              :           @click="emit('addNode', node, $event)"
      84              :           @keydown.down.prevent="navigateResults(1, true)"
      85              :           @keydown.up.prevent="navigateResults(-1, true)"
      86              :           @keydown.enter.prevent="selectCurrentResult"
      87              :         >
      88              :           <NodeSearchListItem
      89              :             :node-def="node"
      90              :             :current-query="searchQuery"
      91              :             show-description
      92              :             :show-source-badge="rootFilter !== RootCategory.Essentials"
      93              :             :hide-bookmark-icon="selectedCategory === RootCategory.Favorites"
      94              :           />
      95              :         </div>
      96              :         <div
      97              :           v-if="displayedResults.length === 0"
      98              :           data-testid="no-results"
      99              :           class="px-4 py-8 text-center text-muted-foreground"
     100              :         >
     101              :           {{ $t('g.noResults') }}
     102              :         </div>
     103              :       </div>
     104              :     </div>
     105              :   </div>
     106              : </template>
     107              : 
     108              : <script setup lang="ts">
     109              : import { breakpointsTailwind, useBreakpoints } from '@vueuse/core'
     110              : import { computed, nextTick, ref, watch } from 'vue'
     111              : import { useI18n } from 'vue-i18n'
     112              : 
     113              : import NodeSearchFilterBar from '@/components/searchbox/v2/NodeSearchFilterBar.vue'
     114              : import NodeSearchCategorySidebar, {
     115              :   DEFAULT_CATEGORY
     116              : } from '@/components/searchbox/v2/NodeSearchCategorySidebar.vue'
     117              : import NodeSearchInput from '@/components/searchbox/v2/NodeSearchInput.vue'
     118              : import NodeSearchListItem from '@/components/searchbox/v2/NodeSearchListItem.vue'
     119              : import { RootCategory } from '@/components/searchbox/v2/rootCategories'
     120              : import type { RootCategoryId } from '@/components/searchbox/v2/rootCategories'
     121              : import { useSearchQueryTracking } from '@/platform/telemetry/searchQuery/useSearchQueryTracking'
     122              : import { useNodeBookmarkStore } from '@/stores/nodeBookmarkStore'
     123              : import type { ComfyNodeDefImpl } from '@/core/graph/nodeDef/ComfyNodeDefImpl'
     124              : import { useNodeDefStore } from '@/stores/nodeDefStore'
     125              : import { useFeatureFlags } from '@/composables/useFeatureFlags'
     126              : import {
     127              :   BLUEPRINT_CATEGORY,
     128              :   isCustomNode,
     129              :   isEssentialNode,
     130              :   NodeSourceType
     131              : } from '@/types/nodeSource'
     132              : import type { FuseFilter, FuseFilterWithValue } from '@/utils/fuseUtil'
     133              : import { cn } from '@comfyorg/tailwind-utils'
     134              : 
     135          109 : const sourceCategoryFilters: Record<string, (n: ComfyNodeDefImpl) => boolean> =
     136              :   {
     137              :     [RootCategory.Essentials]: isEssentialNode,
     138              :     [RootCategory.Comfy]: (n) => n.nodeSource.type === NodeSourceType.Core,
     139              :     [RootCategory.Custom]: isCustomNode
     140              :   }
     141              : 
     142              : const { filters } = defineProps<{
     143              :   filters: FuseFilterWithValue<ComfyNodeDefImpl, string>[]
     144              : }>()
     145              : 
     146          109 : const emit = defineEmits<{
     147              :   addNode: [nodeDef: ComfyNodeDefImpl, dragEvent?: MouseEvent]
     148              :   addFilter: [filter: FuseFilterWithValue<ComfyNodeDefImpl, string>]
     149              :   removeFilter: [filter: FuseFilterWithValue<ComfyNodeDefImpl, string>]
     150              :   hoverNode: [nodeDef: ComfyNodeDefImpl | null]
     151              : }>()
     152              : 
     153          109 : const { t } = useI18n()
     154          109 : const { flags } = useFeatureFlags()
     155          109 : const nodeDefStore = useNodeDefStore()
     156          109 : const nodeBookmarkStore = useNodeBookmarkStore()
     157              : 
     158          109 : const nodeAvailability = computed(() => {
     159         3310 :   let essential = false
     160         3310 :   let blueprint = false
     161         3310 :   let partner = false
     162         3310 :   let custom = false
     163         3310 :   for (const n of nodeDefStore.visibleNodeDefs) {
     164      3464220 :     if (!essential && flags.nodeLibraryEssentialsEnabled && isEssentialNode(n))
     165            0 :       essential = true
     166      3464220 :     if (!blueprint && n.category.startsWith(BLUEPRINT_CATEGORY))
     167         3300 :       blueprint = true
     168      3464220 :     if (!partner && n.api_node) partner = true
     169      3464220 :     if (!custom && isCustomNode(n)) custom = true
     170      3464220 :     if (essential && blueprint && partner && custom) break
     171              :   }
     172         3310 :   return { essential, blueprint, partner, custom }
     173              : })
     174              : 
     175          109 : const dialogRef = ref<HTMLElement>()
     176          109 : const searchInputRef = ref<InstanceType<typeof NodeSearchInput>>()
     177              : 
     178          109 : const searchQuery = ref('')
     179          109 : const selectedCategory = ref(DEFAULT_CATEGORY)
     180          109 : const selectedIndex = ref(0)
     181              : 
     182          109 : const isMobile = useBreakpoints(breakpointsTailwind).smaller('md')
     183          109 : const isSidebarOpen = ref(!isMobile.value)
     184          109 : watch(isMobile, (mobile) => {
     185              :   // On transitioning to mobile state, close the sidebar
     186            4 :   if (mobile) isSidebarOpen.value = false
     187              : })
     188              : 
     189          115 : function onSearchFocus() {
     190          115 :   if (isMobile.value) isSidebarOpen.value = false
     191              : }
     192              : 
     193              : // Root filter from filter bar category buttons (radio toggle)
     194          109 : const rootFilter = ref<RootCategoryId | null>(null)
     195              : 
     196          109 : const rootFilterLabel = computed(() => {
     197          113 :   switch (rootFilter.value) {
     198              :     case RootCategory.Favorites:
     199            1 :       return t('g.bookmarked')
     200              :     case RootCategory.Blueprint:
     201            1 :       return t('g.blueprints')
     202              :     case RootCategory.PartnerNodes:
     203            0 :       return t('g.partner')
     204              :     case RootCategory.Essentials:
     205            0 :       return t('g.essentials')
     206              :     case RootCategory.Comfy:
     207            2 :       return t('g.comfy')
     208              :     case RootCategory.Custom:
     209            0 :       return t('g.extensions')
     210              :     default:
     211          109 :       return undefined
     212              :   }
     213              : })
     214              : 
     215          109 : const rootFilteredNodeDefs = computed(() => {
     216         3314 :   if (!rootFilter.value) return nodeDefStore.visibleNodeDefs
     217            4 :   const allNodes = nodeDefStore.visibleNodeDefs
     218            4 :   const sourceFilter = sourceCategoryFilters[rootFilter.value]
     219          213 :   if (sourceFilter) return allNodes.filter(sourceFilter)
     220         3314 :   switch (rootFilter.value) {
     221              :     case RootCategory.Favorites:
     222            1 :       return allNodes.filter((n) => nodeBookmarkStore.isBookmarked(n))
     223              :     case RootCategory.Blueprint:
     224            1 :       return allNodes.filter((n) => n.category.startsWith(BLUEPRINT_CATEGORY))
     225              :     case RootCategory.PartnerNodes:
     226            0 :       return allNodes.filter((n) => n.api_node)
     227              :     default:
     228            0 :       return allNodes
     229              :   }
     230              : })
     231              : 
     232            9 : function onToggleFilter(
     233              :   filterDef: FuseFilter<ComfyNodeDefImpl, string>,
     234              :   value: string
     235              : ) {
     236            9 :   const existing = filters.find(
     237              :     (f) => f.filterDef.id === filterDef.id && f.value === value
     238              :   )
     239            9 :   if (existing) {
     240            0 :     emit('removeFilter', existing)
     241              :   } else {
     242            9 :     emit('addFilter', { filterDef, value })
     243              :   }
     244              : }
     245              : 
     246            0 : function onClearFilterGroup(filterId: string) {
     247            0 :   for (const f of filters.filter((f) => f.filterDef.id === filterId)) {
     248            0 :     emit('removeFilter', f)
     249              :   }
     250              : }
     251              : 
     252            4 : function onSelectCategory(category: RootCategoryId) {
     253            4 :   if (rootFilter.value === category) {
     254            0 :     rootFilter.value = null
     255              :   } else {
     256            4 :     rootFilter.value = category
     257              :   }
     258            4 :   selectedCategory.value = DEFAULT_CATEGORY
     259            4 :   nextTick(() => searchInputRef.value?.focus())
     260              : }
     261              : 
     262          109 : const searchResults = computed(() => {
     263          209 :   if (!searchQuery.value && filters.length === 0) {
     264            0 :     return nodeDefStore.topNodeDefs
     265              :   }
     266          209 :   return nodeDefStore.nodeSearchService.searchNode(searchQuery.value, filters, {
     267              :     limit: 64
     268              :   })
     269              : })
     270              : 
     271          109 : const sidebarCategory = computed({
     272              :   get: () => selectedCategory.value,
     273              :   set: (category: string) => {
     274           14 :     selectedCategory.value = category
     275              :   }
     276              : })
     277              : 
     278              : // Check if any tree category has children (for chevron visibility)
     279          109 : const anyTreeCategoryHasChildren = computed(() =>
     280              :   rootFilteredNodeDefs.value.some((n) => n.category.includes('/'))
     281              : )
     282              : 
     283         3520 : function getMostRelevantResults(baseNodes: ComfyNodeDefImpl[]) {
     284         3520 :   if (searchQuery.value || filters.length > 0) {
     285          210 :     const searched = searchResults.value
     286          210 :     if (!rootFilter.value) return searched
     287            1 :     const rootSet = new Set(baseNodes.map((n) => n.name))
     288            1 :     return searched.filter((n) => rootSet.has(n.name))
     289              :   }
     290         3520 :   return rootFilter.value ? baseNodes : nodeDefStore.topNodeDefs
     291              : }
     292              : 
     293           15 : function getCategoryResults(baseNodes: ComfyNodeDefImpl[], category: string) {
     294           15 :   if (rootFilter.value && category === rootFilter.value) return baseNodes
     295           15 :   const rootPrefix = rootFilter.value ? rootFilter.value + '/' : ''
     296           15 :   const categoryPath = category.startsWith(rootPrefix)
     297              :     ? category.slice(rootPrefix.length)
     298              :     : category
     299           15 :   return baseNodes.filter((n) => {
     300        14035 :     const nodeCategory = n.category.startsWith(rootPrefix)
     301              :       ? n.category.slice(rootPrefix.length)
     302              :       : n.category
     303        14035 :     return (
     304              :       nodeCategory === categoryPath ||
     305              :       nodeCategory.startsWith(categoryPath + '/')
     306              :     )
     307              :   })
     308              : }
     309              : 
     310          109 : const displayedResults = computed<ComfyNodeDefImpl[]>(() => {
     311         3537 :   const baseNodes = rootFilteredNodeDefs.value
     312         3537 :   const category = selectedCategory.value
     313              : 
     314         3537 :   if (category === DEFAULT_CATEGORY) return getMostRelevantResults(baseNodes)
     315              : 
     316         3537 :   const hasSearch = searchQuery.value || filters.length > 0
     317         3537 :   let source: ComfyNodeDefImpl[]
     318         3537 :   if (hasSearch) {
     319            1 :     const searched = searchResults.value
     320            1 :     if (rootFilter.value) {
     321            1 :       const rootSet = new Set(baseNodes.map((n) => n.name))
     322            1 :       source = searched.filter((n) => rootSet.has(n.name))
     323              :     } else {
     324            0 :       source = searched
     325              :     }
     326              :   } else {
     327           16 :     source = baseNodes
     328              :   }
     329              : 
     330           17 :   const sourceFilter = sourceCategoryFilters[category]
     331          683 :   if (sourceFilter) return source.filter(sourceFilter)
     332           15 :   return getCategoryResults(source, category)
     333              : })
     334              : 
     335          109 : const hoveredNodeDef = computed(
     336              :   () => displayedResults.value[selectedIndex.value] ?? null
     337              : )
     338              : 
     339          109 : useSearchQueryTracking('node_modal', searchQuery, displayedResults)
     340              : 
     341          109 : watch(
     342              :   hoveredNodeDef,
     343              :   (newVal) => {
     344          230 :     emit('hoverNode', newVal)
     345              :   },
     346              :   { immediate: true }
     347              : )
     348              : 
     349          109 : watch([selectedCategory, searchQuery, rootFilter, () => filters.length], () => {
     350          115 :   selectedIndex.value = 0
     351              : })
     352              : 
     353            4 : function onPointerMove(event: PointerEvent) {
     354            4 :   const item = (event.target as HTMLElement).closest('[role=option]')
     355            4 :   if (!item) return
     356            4 :   const index = Number(item.id.replace('result-item-', ''))
     357            4 :   if (!isNaN(index) && index !== selectedIndex.value)
     358            0 :     selectedIndex.value = index
     359              : }
     360              : 
     361            2 : function navigateResults(direction: number, focusItem = false) {
     362            2 :   const newIndex = selectedIndex.value + direction
     363            2 :   if (newIndex >= 0 && newIndex < displayedResults.value.length) {
     364            2 :     selectedIndex.value = newIndex
     365            2 :     nextTick(() => {
     366            2 :       const el = dialogRef.value?.querySelector(
     367              :         `#result-item-${newIndex}`
     368              :       ) as HTMLElement | null
     369            2 :       el?.scrollIntoView({ block: 'nearest' })
     370            2 :       if (focusItem) el?.focus()
     371              :     })
     372              :   }
     373              : }
     374              : 
     375           64 : function selectCurrentResult() {
     376           64 :   const node = displayedResults.value[selectedIndex.value]
     377           64 :   if (node) emit('addNode', node)
     378              : }
     379              : </script>
        

Generated by: LCOV version 2.0-1