LCOV - code coverage report
Current view: top level - src/components/sidebar/tabs - NodeLibrarySidebarTabV2.vue Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 73.4 % 109 80
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : <template>
       2           22 :   <SidebarTabTemplate :title="$t('sideToolbar.nodes')">
       3              :     <template #header>
       4              :       <div class="overflow-x-auto px-4 pt-2 pb-px">
       5              :         <TabList v-model="selectedTab">
       6           30 :           <Tab v-for="{ value, label } in tabs" :key="value" :value>
       7              :             {{ label }}
       8              :           </Tab>
       9              :         </TabList>
      10              :       </div>
      11              :       <SidebarTopArea>
      12              :         <SearchInput
      13              :           ref="searchBoxRef"
      14              :           v-model="searchQuery"
      15              :           :clear-label="$t('g.clear')"
      16              :           :accessible-label="
      17              :             $t('g.searchPlaceholder', { subject: $t('g.nodes') })
      18              :           "
      19              :           :placeholder="$t('g.searchPlaceholder', { subject: $t('g.nodes') })"
      20              :           @search="handleSearch"
      21              :         />
      22              :         <template #actions>
      23              :           <FilterDropdown
      24              :             v-if="selectedTab === 'essentials'"
      25              :             v-model="essentialsFilters"
      26              :             :filter-labels="essentialsFilterLabels"
      27              :           />
      28              :           <FilterDropdown
      29              :             v-else
      30              :             v-model="nodeFilters"
      31              :             :filter-labels="nodeFilterLabels"
      32              :           />
      33              :           <Menu
      34              :             v-if="selectedTab === 'essentials'"
      35              :             :items="jumpMenuEntries"
      36              :             :label="$t('essentials.jumpTo')"
      37              :           >
      38              :             <template #trigger>
      39              :               <Button
      40              :                 size="icon"
      41              :                 :aria-label="$t('essentials.jumpTo')"
      42              :                 icon="icon-[lucide--list-tree]"
      43              :               />
      44              :             </template>
      45              :           </Menu>
      46              :           <Menu v-else>
      47              :             <template #trigger>
      48              :               <Button
      49              :                 size="icon"
      50              :                 :aria-label="$t('g.sort')"
      51              :                 icon="icon-[lucide--settings-2]"
      52              :               />
      53              :             </template>
      54              :             <MenuRadioGroup v-model="sortOrder" :options="sortingOptions" />
      55              :           </Menu>
      56              :         </template>
      57              :       </SidebarTopArea>
      58              :     </template>
      59              :     <template #body>
      60              :       <div class="flex h-full flex-col">
      61              :         <div
      62              :           ref="scrollContainerRef"
      63              :           class="scrollbar-custom min-h-0 flex-1 scrollbar-gutter-stable overscroll-none pb-2"
      64              :         >
      65              :           <TabPanel
      66              :             v-if="flags.nodeLibraryEssentialsEnabled"
      67              :             :model-value="selectedTab"
      68              :             value="essentials"
      69              :           >
      70              :             <EssentialNodesPanel
      71              :               :media-filters="essentialsFilters"
      72              :               :search-query
      73              :             />
      74              :           </TabPanel>
      75              :           <TabPanel :model-value="selectedTab" value="all">
      76              :             <div
      77              :               v-if="hasNoMatches"
      78              :               class="flex min-h-0 flex-1 items-center justify-center px-6 py-8 text-center text-sm text-muted-foreground"
      79              :             >
      80              :               {{
      81              :                 $t('sideToolbar.nodeLibraryTab.noMatchingNodes', {
      82              :                   query: searchQuery
      83              :                 })
      84              :               }}
      85              :             </div>
      86              :             <AllNodesPanel
      87              :               v-else
      88              :               v-model:expanded-keys="expandedKeys"
      89              :               :sections="renderedSections"
      90              :               :fill-node-info="fillNodeInfo"
      91              :               :sort-order="sortOrder"
      92              :               @node-click="handleNodeClick"
      93              :             />
      94              :           </TabPanel>
      95              :         </div>
      96              :       </div>
      97              :     </template>
      98              :   </SidebarTabTemplate>
      99              : </template>
     100              : 
     101              : <script setup lang="ts">
     102              : import { useLocalStorage } from '@vueuse/core'
     103              : import { mapValues } from 'es-toolkit'
     104              : import type { MenuItem } from '@comfyorg/design-system/lib/menu/types'
     105              : import {
     106              :   computed,
     107              :   nextTick,
     108              :   onMounted,
     109              :   ref,
     110              :   useTemplateRef,
     111              :   watchEffect
     112              : } from 'vue'
     113              : import { useI18n } from 'vue-i18n'
     114              : 
     115              : import FilterDropdown from '@/components/common/FilterDropdown.vue'
     116              : import Tab from '@comfyorg/design-system/tab/Tab'
     117              : import TabList from '@comfyorg/design-system/tab/TabList'
     118              : import TabPanel from '@comfyorg/design-system/tab/TabPanel'
     119              : import SearchInput from '@comfyorg/design-system/search-input/SearchInput'
     120              : import Button from '@comfyorg/design-system/button/Button'
     121              : import Menu from '@comfyorg/design-system/menu/Menu'
     122              : import MenuRadioGroup from '@comfyorg/design-system/menu/MenuRadioGroup'
     123              : import { useFeatureFlags } from '@/composables/useFeatureFlags'
     124              : import { useNodeDragToCanvas } from '@/composables/node/useNodeDragToCanvas'
     125              : import { usePerTabState } from '@/composables/usePerTabState'
     126              : import { ESSENTIAL_SECTIONS } from '@/constants/essentialsNodes'
     127              : import { useSearchQueryTracking } from '@/platform/telemetry/searchQuery/useSearchQueryTracking'
     128              : import {
     129              :   DEFAULT_SORTING_ID,
     130              :   DEFAULT_TAB_ID,
     131              :   nodeOrganizationService
     132              : } from '@/services/nodeOrganizationService'
     133              : import type { ComfyNodeDefImpl } from '@/core/graph/nodeDef/ComfyNodeDefImpl'
     134              : import { buildNodeDefTree, useNodeDefStore } from '@/stores/nodeDefStore'
     135              : import type {
     136              :   NodeCategoryId,
     137              :   NodeLibrarySection,
     138              :   NodeSection,
     139              :   SortingStrategyId,
     140              :   TabId
     141              : } from '@/types/nodeOrganizationTypes'
     142              : import type {
     143              :   RenderedTreeExplorerNode,
     144              :   TreeNode
     145              : } from '@/types/treeExplorerTypes'
     146              : import { getProviderIcon } from '@/utils/categoryUtil'
     147              : import { flattenTree, sortedTree, unwrapTreeRoot } from '@/utils/treeUtil'
     148              : 
     149              : import AllNodesPanel from './nodeLibrary/AllNodesPanel.vue'
     150              : import EssentialNodesPanel from './nodeLibrary/EssentialNodesPanel.vue'
     151              : import SidebarTabTemplate from './SidebarTabTemplate.vue'
     152              : import SidebarTopArea from '@comfyorg/design-system/navigation/SidebarTopArea'
     153              : 
     154           22 : const { flags } = useFeatureFlags()
     155              : 
     156           22 : const scrollContainerRef = useTemplateRef('scrollContainerRef')
     157              : 
     158           22 : const selectedTab = useLocalStorage<TabId>(
     159              :   'Comfy.NodeLibrary.Tab',
     160              :   DEFAULT_TAB_ID
     161              : )
     162              : 
     163           22 : watchEffect(() => {
     164           25 :   if (selectedTab.value === 'blueprints') selectedTab.value = DEFAULT_TAB_ID
     165           25 :   if (
     166              :     !flags.nodeLibraryEssentialsEnabled &&
     167              :     selectedTab.value === 'essentials'
     168              :   ) {
     169            0 :     selectedTab.value = DEFAULT_TAB_ID
     170              :   }
     171              : })
     172              : 
     173              : const sortOrderByTab = useLocalStorage<Record<TabId, SortingStrategyId>>(
     174              :   'Comfy.NodeLibrary.SortByTab',
     175              :   {
     176              :     essentials: DEFAULT_SORTING_ID,
     177              :     all: DEFAULT_SORTING_ID,
     178              :     blueprints: 'alphabetical'
     179              :   }
     180              : )
     181           22 : const sortOrder = usePerTabState(selectedTab, sortOrderByTab)
     182              : 
     183           22 : const sortingOptions = computed(() =>
     184              :   nodeOrganizationService.getSortingStrategies().map((strategy) => ({
     185              :     value: strategy.id,
     186              :     label: t(strategy.label)
     187              :   }))
     188              : )
     189              : 
     190           22 : const nodeFilterLabels: Record<NodeCategoryId, string> = {
     191              :   blueprints: 'sideToolbar.nodeLibraryTab.filterOptions.blueprints',
     192              :   comfyNodes: 'sideToolbar.nodeLibraryTab.filterOptions.comfyNodes',
     193              :   partnerNodes: 'sideToolbar.nodeLibraryTab.filterOptions.partnerNodes',
     194              :   extensions: 'sideToolbar.nodeLibraryTab.filterOptions.extensions'
     195              : } as const
     196           22 : const nodeFilters = ref(mapValues(nodeFilterLabels, () => true))
     197           22 : const essentialsFilterLabels = {
     198              :   image: 'sideToolbar.mediaAssets.filterImage',
     199              :   video: 'sideToolbar.mediaAssets.filterVideo',
     200              :   text: 'sideToolbar.mediaAssets.filterText',
     201              :   audio: 'sideToolbar.mediaAssets.filterAudio',
     202              :   '3d': 'sideToolbar.mediaAssets.filter3D'
     203              : } as const
     204           22 : const essentialsFilters = ref(mapValues(essentialsFilterLabels, () => true))
     205              : 
     206           22 : const { t } = useI18n()
     207              : 
     208           22 : const searchBoxRef = useTemplateRef('searchBoxRef')
     209           22 : const searchQuery = ref('')
     210              : const expandedKeysByTab = ref<Record<TabId, string[]>>({
     211              :   essentials: [],
     212              :   all: [],
     213              :   blueprints: []
     214              : })
     215           22 : const expandedKeys = usePerTabState(selectedTab, expandedKeysByTab)
     216              : 
     217           22 : const nodeDefStore = useNodeDefStore()
     218           22 : const { startDrag } = useNodeDragToCanvas()
     219              : 
     220           22 : const filteredNodeDefs = computed(() => {
     221            4 :   if (searchQuery.value.length === 0) {
     222            0 :     return []
     223              :   }
     224            4 :   return nodeDefStore.nodeSearchService.searchNode(
     225              :     searchQuery.value,
     226              :     [],
     227              :     { limit: 64 },
     228              :     { matchWildcards: false }
     229              :   )
     230              : })
     231              : 
     232           22 : const activeNodes = computed(() =>
     233              :   searchQuery.value.length === 0
     234              :     ? nodeDefStore.visibleNodeDefs
     235              :     : filteredNodeDefs.value
     236              : )
     237              : 
     238           22 : useSearchQueryTracking('node_sidebar', searchQuery, filteredNodeDefs)
     239              : 
     240           22 : const hasNoMatches = computed(
     241              :   () => searchQuery.value.length > 0 && filteredNodeDefs.value.length === 0
     242              : )
     243              : 
     244           22 : const sections = computed(() => {
     245          252 :   return nodeOrganizationService.organizeNodesTab(activeNodes.value)
     246              : })
     247              : 
     248        70244 : function getFolderIcon(node: TreeNode<ComfyNodeDefImpl>): string {
     249        70244 :   const firstLeaf = findFirstLeaf(node)
     250        70244 :   if (
     251              :     firstLeaf?.data?.api_node &&
     252              :     firstLeaf.key?.replace(`${node.key}/`, '') === firstLeaf.label
     253              :   ) {
     254        15872 :     return getProviderIcon(node.label ?? '')
     255              :   }
     256        54372 :   return 'icon-[lucide--folder]'
     257              : }
     258              : 
     259       149451 : function findFirstLeaf(
     260              :   node: TreeNode<ComfyNodeDefImpl>
     261              : ): TreeNode<ComfyNodeDefImpl> | undefined {
     262       149451 :   if (node.leaf) return node
     263       149451 :   for (const child of node.children ?? []) {
     264        79207 :     const leaf = findFirstLeaf(child)
     265        79207 :     if (leaf) return leaf
     266              :   }
     267              :   return undefined
     268              : }
     269              : 
     270       336085 : function fillNodeInfo(
     271              :   node: TreeNode<ComfyNodeDefImpl>
     272              : ): RenderedTreeExplorerNode<ComfyNodeDefImpl> {
     273       336085 :   const children = node.children?.map(fillNodeInfo)
     274       336085 :   const totalLeaves = node.leaf
     275              :     ? 1
     276              :     : (children?.reduce((acc, child) => acc + child.totalLeaves, 0) ?? 0)
     277              : 
     278       336085 :   return {
     279              :     key: node.key,
     280              :     label: node.leaf ? (node.data?.display_name ?? node.label) : node.label,
     281              :     leaf: node.leaf,
     282              :     data: node.data,
     283              :     icon: node.leaf ? 'icon-[comfy--node]' : getFolderIcon(node),
     284              :     type: node.leaf ? 'node' : 'folder',
     285              :     totalLeaves,
     286              :     children
     287              :   }
     288              : }
     289              : 
     290          996 : function applySorting(
     291              :   tree: TreeNode<ComfyNodeDefImpl>
     292              : ): TreeNode<ComfyNodeDefImpl> {
     293          996 :   if (sortOrder.value === 'alphabetical') {
     294            0 :     return sortedTree(tree, { groupLeaf: true })
     295              :   }
     296          996 :   return tree
     297              : }
     298              : 
     299          252 : function renderSections(
     300              :   nodeSections: NodeSection[],
     301              :   filter?: (section: NodeSection) => boolean
     302              : ): NodeLibrarySection<ComfyNodeDefImpl>[] {
     303          252 :   const filtered = filter ? nodeSections.filter(filter) : nodeSections
     304              : 
     305          252 :   if (sortOrder.value === 'alphabetical') {
     306            0 :     const allNodes = filtered.flatMap((section) =>
     307              :       flattenTree<ComfyNodeDefImpl>(section.tree)
     308              :     )
     309              :     const mergedTree = unwrapTreeRoot(buildNodeDefTree(allNodes))
     310            0 :     return [{ root: fillNodeInfo(applySorting(mergedTree)) }]
     311              :   }
     312              : 
     313          252 :   return filtered.map((section) => ({
     314              :     category: section.category,
     315              :     title: section.title,
     316              :     root: fillNodeInfo(applySorting(section.tree))
     317              :   }))
     318              : }
     319              : 
     320           22 : const renderedSections = computed(() =>
     321              :   renderSections(
     322              :     sections.value,
     323              :     (section) => !section.category || nodeFilters.value[section.category]
     324              :   )
     325              : )
     326              : 
     327           44 : function collectFolderKeys(node: TreeNode<ComfyNodeDefImpl>): string[] {
     328           44 :   if (node.leaf) return []
     329           18 :   const keys = [node.key]
     330           44 :   for (const child of node.children ?? []) {
     331           40 :     keys.push(...collectFolderKeys(child))
     332              :   }
     333           18 :   return keys
     334              : }
     335              : 
     336           16 : function handleNodeClick(node: RenderedTreeExplorerNode<ComfyNodeDefImpl>) {
     337           16 :   if (node.type === 'node' && node.data) {
     338            1 :     startDrag(node.data)
     339              :   }
     340              : }
     341              : 
     342            4 : async function handleSearch() {
     343            4 :   await nextTick()
     344              : 
     345            4 :   if (selectedTab.value === 'essentials') return
     346              : 
     347            4 :   if (filteredNodeDefs.value.length === 0) {
     348            0 :     expandedKeys.value = []
     349            0 :     return
     350              :   }
     351              : 
     352            4 :   const allKeys: string[] = []
     353            4 :   for (const section of sections.value) {
     354            4 :     allKeys.push(...collectFolderKeys(section.tree))
     355              :   }
     356            4 :   expandedKeys.value = allKeys
     357              : }
     358              : 
     359            0 : function smoothScrollTo(
     360              :   container: HTMLElement,
     361              :   target: number,
     362              :   duration = 300
     363              : ) {
     364            0 :   const start = container.scrollTop
     365            0 :   const distance = target - start
     366            0 :   if (Math.abs(distance) < 1) return
     367            0 :   const startTime = performance.now()
     368            0 :   function step(now: number) {
     369            0 :     const elapsed = now - startTime
     370            0 :     const progress = Math.min(elapsed / duration, 1)
     371            0 :     const eased = 1 - Math.pow(1 - progress, 3)
     372            0 :     container.scrollTop = start + distance * eased
     373            0 :     if (progress < 1) requestAnimationFrame(step)
     374              :   }
     375            0 :   requestAnimationFrame(step)
     376              : }
     377              : 
     378            0 : async function scrollToId(id: string, marginTop = 0) {
     379            0 :   await nextTick()
     380            0 :   const container = scrollContainerRef.value
     381            0 :   const el = document.getElementById(id)
     382            0 :   if (!container || !el) return
     383              :   const top =
     384              :     el.getBoundingClientRect().top -
     385              :     container.getBoundingClientRect().top +
     386              :     container.scrollTop -
     387              :     marginTop
     388            0 :   smoothScrollTo(container, top)
     389              : }
     390              : 
     391         2355 : const STICKY_SECTION_HEADER_HEIGHT = 56
     392            0 : async function jumpToSection(sectionKey: string) {
     393            0 :   await scrollToId(`essentials-section-${sectionKey}`)
     394              : }
     395              : 
     396            0 : async function jumpToSubgroup(subgroupKey: string) {
     397            0 :   await scrollToId(
     398              :     `essentials-subgroup-${subgroupKey}`,
     399              :     STICKY_SECTION_HEADER_HEIGHT
     400              :   )
     401              : }
     402              : 
     403           22 : const jumpMenuEntries = computed<MenuItem[]>(() => {
     404            2 :   return ESSENTIAL_SECTIONS.map((section) => {
     405            8 :     if (!section.subgroups)
     406            2 :       return {
     407              :         label: t(`essentials.${section.key}`),
     408              :         command: () => jumpToSection(section.key)
     409              :       }
     410              : 
     411            6 :     const items = section.subgroups.map((subgroup) => ({
     412              :       label: t(`essentials.${subgroup.key}`),
     413              :       command: () => jumpToSubgroup(subgroup.key)
     414              :     }))
     415            6 :     return { label: t(`essentials.${section.key}`), items }
     416              :   })
     417              : })
     418              : 
     419           22 : const tabs = computed<Array<{ value: TabId; label: string }>>(() => {
     420           22 :   const allNodesTab = {
     421              :     value: 'all',
     422              :     label: t('sideToolbar.nodeLibraryTab.allNodes')
     423              :   } as const
     424           22 :   if (!flags.nodeLibraryEssentialsEnabled) return [allNodesTab]
     425            2 :   return [
     426              :     {
     427              :       value: 'essentials',
     428              :       label: t('sideToolbar.nodeLibraryTab.essentials')
     429              :     },
     430              :     allNodesTab
     431              :   ]
     432              : })
     433              : 
     434           22 : onMounted(() => {
     435           22 :   searchBoxRef.value?.focus()
     436              : })
     437              : </script>
        

Generated by: LCOV version 2.0-1