LCOV - code coverage report
Current view: top level - src/stores - nodeDefStore.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 83.3 % 102 85
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { defineStore } from 'pinia'
       2              : import { computed, ref, watchEffect } from 'vue'
       3              : 
       4              : import { ComfyNodeDefImpl } from '@/core/graph/nodeDef/ComfyNodeDefImpl'
       5              : import { t } from '@/i18n'
       6              : import { promotedInputSource } from '@/core/graph/subgraph/promotedInputWidget'
       7              : import { resolveConcretePromotedWidget } from '@/core/graph/subgraph/resolveConcretePromotedWidget'
       8              : import { resolveDynamicInputSpec } from '@/core/graph/widgets/dynamicInputSpec'
       9              : import { LiteGraph } from '@/lib/litegraph/src/litegraph'
      10              : import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
      11              : import { transformInputSpecV1ToV2 } from '@comfyorg/object-info-parser/migration'
      12              : import type { InputSpec as InputSpecV2 } from '@comfyorg/object-info-parser/schemas/nodeDefSchemaV2'
      13              : import type { ComfyNodeDef as ComfyNodeDefV1 } from '@comfyorg/object-info-parser'
      14              : import { useSettingStore } from '@/platform/settings/settingStore'
      15              : import { NodeSearchService } from '@/services/nodeSearchService'
      16              : import { useNodeFrequencyStore } from '@/stores/nodeFrequencyStore'
      17              : import type { TreeNode } from '@/types/treeExplorerTypes'
      18              : import { buildTree } from '@/utils/treeUtil'
      19              : 
      20         2356 : export const SYSTEM_NODE_DEFS: Record<string, ComfyNodeDefV1> = {
      21              :   PrimitiveNode: {
      22              :     name: 'PrimitiveNode',
      23              :     display_name: 'Primitive',
      24              :     category: 'utilities/primitive',
      25              :     input: { required: {}, optional: {} },
      26              :     output: ['*'],
      27              :     output_name: ['connect to widget input'],
      28              :     output_is_list: [false],
      29              :     output_node: false,
      30              :     python_module: 'nodes',
      31              :     description: 'Primitive values like numbers, strings, and booleans.'
      32              :   },
      33              :   Reroute: {
      34              :     name: 'Reroute',
      35              :     display_name: 'Reroute',
      36              :     category: 'utilities',
      37              :     input: { required: { '': ['*', {}] }, optional: {} },
      38              :     output: ['*'],
      39              :     output_name: [''],
      40              :     output_is_list: [false],
      41              :     output_node: false,
      42              :     python_module: 'nodes',
      43              :     description: 'Reroute the connection to another node.'
      44              :   },
      45              :   Note: {
      46              :     name: 'Note',
      47              :     display_name: 'Note',
      48              :     category: 'utilities',
      49              :     input: {
      50              :       required: { text: ['STRING', { multiline: true }] },
      51              :       optional: {}
      52              :     },
      53              :     output: [],
      54              :     output_name: [],
      55              :     output_is_list: [],
      56              :     output_node: false,
      57              :     python_module: 'nodes',
      58              :     description: 'Node that add notes to your project'
      59              :   },
      60              :   MarkdownNote: {
      61              :     name: 'MarkdownNote',
      62              :     display_name: 'Markdown Note',
      63              :     category: 'utilities',
      64              :     input: {
      65              :       required: { text: ['STRING', { multiline: true }] },
      66              :       optional: {}
      67              :     },
      68              :     output: [],
      69              :     output_name: [],
      70              :     output_is_list: [],
      71              :     output_node: false,
      72              :     python_module: 'nodes',
      73              :     description:
      74              :       'Node that add notes to your project. Reformats text as markdown.'
      75              :   }
      76              : }
      77              : 
      78              : interface BuildNodeDefTreeOptions {
      79              :   /**
      80              :    * Custom function to extract the tree path from a node definition.
      81              :    * If not provided, uses the default path based on nodeDef.nodePath.
      82              :    */
      83              :   pathExtractor?: (nodeDef: ComfyNodeDefImpl) => string[]
      84              : }
      85              : 
      86         5259 : export function buildNodeDefTree(
      87              :   nodeDefs: ComfyNodeDefImpl[],
      88              :   options: BuildNodeDefTreeOptions = {}
      89              : ): TreeNode<ComfyNodeDefImpl> {
      90         5259 :   const { pathExtractor } = options
      91         5259 :   const defaultPathExtractor = (nodeDef: ComfyNodeDefImpl) =>
      92              :     nodeDef.nodePath.split('/')
      93         5259 :   return buildTree(nodeDefs, pathExtractor || defaultPathExtractor)
      94              : }
      95              : 
      96           17 : export function createDummyFolderNodeDef(folderPath: string): ComfyNodeDefImpl {
      97           17 :   return new ComfyNodeDefImpl({
      98              :     name: '',
      99              :     display_name: '',
     100              :     category: folderPath.endsWith('/') ? folderPath.slice(0, -1) : folderPath,
     101              :     python_module: 'nodes',
     102              :     description: 'Dummy Folder Node (User should never see this string)',
     103              :     input: {},
     104              :     output: [],
     105              :     output_name: [],
     106              :     output_is_list: [],
     107              :     output_node: false
     108              :   })
     109              : }
     110              : 
     111              : /**
     112              :  * Defines a filter for node definitions in the node library.
     113              :  * Filters are applied in a single pass to determine node visibility.
     114              :  */
     115              : export interface NodeDefFilter {
     116              :   /**
     117              :    * Unique identifier for the filter.
     118              :    * Convention: Use dot notation like 'core.deprecated' or 'extension.myfilter'
     119              :    */
     120              :   id: string
     121              : 
     122              :   /**
     123              :    * Display name for the filter (used in UI/debugging).
     124              :    */
     125              :   name: string
     126              : 
     127              :   /**
     128              :    * Optional description explaining what the filter does.
     129              :    */
     130              :   description?: string
     131              : 
     132              :   /**
     133              :    * The filter function that returns true if the node should be visible.
     134              :    * @param nodeDef - The node definition to evaluate
     135              :    * @returns true if the node should be visible, false to hide it
     136              :    */
     137              :   predicate: (nodeDef: ComfyNodeDefImpl) => boolean
     138              : }
     139              : 
     140              : /**
     141              :  * The selector widget a dynamic-combo child input hangs off, and the widget's
     142              :  * value that selected it.
     143              :  */
     144              : export interface DynamicComboSelection {
     145              :   widget: string
     146              :   value: unknown
     147              : }
     148              : 
     149         2356 : const TOP_NODE_DEF_LIMIT = 64
     150              : 
     151         2356 : export const useNodeDefStore = defineStore('nodeDef', () => {
     152         2355 :   const settingStore = useSettingStore()
     153              : 
     154         2355 :   const nodeDefsByName = ref<Record<string, ComfyNodeDefImpl>>({})
     155         2355 :   const nodeDefsByDisplayName = computed(() =>
     156              :     Object.fromEntries(
     157              :       Object.values(nodeDefsByName.value).map((d) => [d.display_name, d])
     158              :     )
     159              :   )
     160         2355 :   const showDeprecated = ref(false)
     161         2355 :   const showExperimental = ref(false)
     162         2355 :   const showDevOnly = computed(() => settingStore.get('Comfy.DevMode'))
     163         2355 :   const nodeDefFilters = ref<NodeDefFilter[]>([])
     164              : 
     165              :   // Update skip_list on all registered node types when dev mode changes
     166              :   // This ensures LiteGraph's getNodeTypesCategories/getNodeTypesInCategory
     167              :   // correctly filter dev-only nodes from the right-click context menu
     168         2355 :   watchEffect(() => {
     169         4711 :     const devModeEnabled = showDevOnly.value
     170         4711 :     for (const nodeType of Object.values(LiteGraph.registered_node_types)) {
     171         1035 :       if (nodeType.nodeData?.dev_only) {
     172            3 :         nodeType.skip_list = !devModeEnabled
     173              :       }
     174              :     }
     175              :   })
     176              : 
     177         2355 :   const blueprintNodeDefs = ref<Map<string, ComfyNodeDefImpl>>(new Map())
     178         2355 :   const blueprintNodeDefsByName = computed<
     179              :     ReadonlyMap<string, ComfyNodeDefImpl>
     180              :   >(() => blueprintNodeDefs.value)
     181       262883 :   function registerBlueprintNodeDef(nodeDef: ComfyNodeDefImpl) {
     182       262883 :     blueprintNodeDefs.value.set(nodeDef.name, nodeDef)
     183              :   }
     184            0 :   function removeBlueprintNodeDef(name: string) {
     185            0 :     blueprintNodeDefs.value.delete(name)
     186              :   }
     187              :   // Blueprints first for discoverability in the node library sidebar
     188         2355 :   const nodeDefs = computed(() => [
     189              :     ...blueprintNodeDefs.value.values(),
     190              :     ...Object.values(nodeDefsByName.value)
     191              :   ])
     192         2355 :   const nodeDataTypes = computed(() => {
     193         2372 :     const types = new Set<string>()
     194         2372 :     for (const nodeDef of nodeDefs.value) {
     195      7676714 :       for (const type of nodeDef.inputTypes) types.add(type)
     196      3015533 :       for (const type of nodeDef.outputTypes) types.add(type)
     197              :     }
     198         2372 :     return types
     199              :   })
     200         2355 :   const allNodeDefsByName = computed(() => {
     201            2 :     const map: Record<string, ComfyNodeDefImpl> = {}
     202            2 :     for (const nodeDef of nodeDefs.value) {
     203         2305 :       map[nodeDef.name] = nodeDef
     204              :     }
     205            2 :     return map
     206              :   })
     207         2355 :   const allNodeDefsByDisplayName = computed(() => {
     208            2 :     return Object.fromEntries(nodeDefs.value.map((d) => [d.display_name, d]))
     209              :   })
     210              : 
     211         2355 :   const visibleNodeDefs = computed(() => {
     212         7014 :     return nodeDefs.value.filter((nodeDef) =>
     213              :       nodeDefFilters.value.every((filter) => filter.predicate(nodeDef))
     214              :     )
     215              :   })
     216         2355 :   const nodeSearchService = computed(
     217              :     () => new NodeSearchService(visibleNodeDefs.value)
     218              :   )
     219         2355 :   const nodeTree = computed(() => buildNodeDefTree(visibleNodeDefs.value))
     220              : 
     221         2371 :   function updateNodeDefs(nodeDefs: ComfyNodeDefV1[]) {
     222         2371 :     const newNodeDefsByName: Record<string, ComfyNodeDefImpl> = {}
     223              : 
     224         2371 :     for (const nodeDef of nodeDefs) {
     225      2448847 :       const nodeDefImpl =
     226              :         nodeDef instanceof ComfyNodeDefImpl
     227              :           ? nodeDef
     228              :           : new ComfyNodeDefImpl(nodeDef)
     229              : 
     230      2448847 :       newNodeDefsByName[nodeDef.name] = nodeDefImpl
     231              :     }
     232              : 
     233         2371 :     nodeDefsByName.value = newNodeDefsByName
     234              :   }
     235         1130 :   function addNodeDef(nodeDef: ComfyNodeDefV1) {
     236         1130 :     const nodeDefImpl = new ComfyNodeDefImpl(nodeDef)
     237         1130 :     nodeDefsByName.value[nodeDef.name] = nodeDefImpl
     238              :   }
     239            0 :   function removeNodeDef(nodeName: string) {
     240            0 :     delete nodeDefsByName.value[nodeName]
     241              :   }
     242       377728 :   function getNodeDefByName(nodeName: string): ComfyNodeDefImpl | undefined {
     243       377728 :     return nodeDefsByName.value[nodeName]
     244              :   }
     245       143583 :   function fromLGraphNode(node: LGraphNode): ComfyNodeDefImpl | null {
     246       143583 :     const nodeTypeName = node.constructor.nodeData?.name ?? node.type
     247       143583 :     if (!nodeTypeName) return null
     248              :     const nodeDef = nodeDefsByName.value[nodeTypeName] ?? null
     249              :     return nodeDef
     250              :   }
     251              : 
     252        63927 :   function getInputSpecForWidget(
     253              :     node: LGraphNode,
     254              :     widgetName: string
     255              :   ): InputSpecV2 | undefined {
     256        63927 :     if (!node.isSubgraphNode()) {
     257        62851 :       const nodeDef = fromLGraphNode(node)
     258        62851 :       if (!nodeDef) return undefined
     259              : 
     260        62810 :       if (Object.hasOwn(nodeDef.inputs, widgetName))
     261        53020 :         return nodeDef.inputs[widgetName]
     262         9714 :       const resolved = resolveDynamicInputSpec(
     263              :         nodeDef.input,
     264              :         widgetName,
     265              :         (name) => node.widgets?.find((widget) => widget.name === name)?.value
     266              :       )
     267        62851 :       return (
     268              :         resolved &&
     269              :         transformInputSpecV1ToV2(resolved.spec, {
     270              :           name: widgetName,
     271              :           isOptional: resolved.isOptional
     272              :         })
     273              :       )
     274              :     }
     275              :     // A subgraph node's widget is a promoted input named after its slot; resolve
     276              :     // the interior source and read its real spec instead of fabricating one.
     277         1076 :     const input = node.inputs.find((i) => i.name === widgetName)
     278        12097 :     if (!input) return undefined
     279         1075 :     const source = promotedInputSource(node, input)
     280        12097 :     if (!source) return undefined
     281         1075 :     const resolution = resolveConcretePromotedWidget(
     282              :       node,
     283              :       source.nodeId,
     284              :       source.widgetName
     285              :     )
     286        12097 :     if (resolution.status !== 'resolved') return undefined
     287         1075 :     return getInputSpecForWidget(
     288              :       resolution.resolved.node,
     289              :       resolution.resolved.widget.name
     290              :     )
     291              :   }
     292              : 
     293            0 :   function getDynamicComboSelectionForInput(
     294              :     node: LGraphNode,
     295              :     inputName: string
     296              :   ): DynamicComboSelection | undefined {
     297            0 :     const separator = inputName.indexOf('.')
     298            0 :     if (separator <= 0 || inputName.indexOf('.', separator + 1) !== -1)
     299            0 :       return undefined
     300            0 :     const widget = inputName.slice(0, separator)
     301            0 :     const nodeDef = fromLGraphNode(node)
     302            0 :     if (!nodeDef || Object.hasOwn(nodeDef.inputs, inputName)) return undefined
     303            0 :     const getValue = (name: string) =>
     304              :       node.widgets?.find((candidate) => candidate.name === name)?.value
     305            0 :     if (!resolveDynamicInputSpec(nodeDef.input, inputName, getValue))
     306            0 :       return undefined
     307            0 :     return { widget, value: getValue(widget) }
     308              :   }
     309              : 
     310              :   /**
     311              :    * Registers a node definition filter.
     312              :    * @param filter - The filter to register
     313              :    */
     314         9420 :   function registerNodeDefFilter(filter: NodeDefFilter) {
     315         9420 :     nodeDefFilters.value = [...nodeDefFilters.value, filter]
     316              :   }
     317              : 
     318              :   /**
     319              :    * Unregisters a node definition filter by ID.
     320              :    * @param id - The ID of the filter to remove
     321              :    */
     322            0 :   function unregisterNodeDefFilter(id: string) {
     323            0 :     nodeDefFilters.value = nodeDefFilters.value.filter((f) => f.id !== id)
     324              :   }
     325              : 
     326              :   /**
     327              :    * Register the core node definition filters.
     328              :    */
     329         2355 :   function registerCoreNodeDefFilters() {
     330              :     // Deprecated nodes filter
     331         2355 :     registerNodeDefFilter({
     332              :       id: 'core.deprecated',
     333              :       name: t('nodeFilters.hideDeprecated'),
     334              :       description: t('nodeFilters.hideDeprecatedDescription'),
     335              :       predicate: (nodeDef) => showDeprecated.value || !nodeDef.deprecated
     336              :     })
     337              : 
     338              :     // Experimental nodes filter
     339         2355 :     registerNodeDefFilter({
     340              :       id: 'core.experimental',
     341              :       name: t('nodeFilters.hideExperimental'),
     342              :       description: t('nodeFilters.hideExperimentalDescription'),
     343              :       predicate: (nodeDef) => showExperimental.value || !nodeDef.experimental
     344              :     })
     345              : 
     346              :     // Dev-only nodes filter
     347         2355 :     registerNodeDefFilter({
     348              :       id: 'core.dev_only',
     349              :       name: t('nodeFilters.hideDevOnly'),
     350              :       description: t('nodeFilters.hideDevOnlyDescription'),
     351              :       predicate: (nodeDef) => showDevOnly.value || !nodeDef.dev_only
     352              :     })
     353              : 
     354              :     // Subgraph nodes filter
     355              :     // Filter out litegraph typed subgraphs, saved blueprints are added in separately
     356         2355 :     registerNodeDefFilter({
     357              :       id: 'core.subgraph',
     358              :       name: t('nodeFilters.hideSubgraph'),
     359              :       description: t('nodeFilters.hideSubgraphDescription'),
     360              :       predicate: (nodeDef) => {
     361              :         // Hide subgraph nodes (identified by category='subgraph' and python_module='nodes')
     362      7289876 :         return !(
     363              :           nodeDef.category === 'subgraph' && nodeDef.python_module === 'nodes'
     364              :         )
     365              :       }
     366              :     })
     367              :   }
     368              : 
     369              :   // Register core filters on store initialization
     370         2355 :   registerCoreNodeDefFilters()
     371              : 
     372         2355 :   const nodeFrequencyStore = useNodeFrequencyStore()
     373              :   const topNodeDefs = computed<ComfyNodeDefImpl[]>(() =>
     374              :     nodeFrequencyStore.nodeNamesByFrequency
     375              :       .flatMap((nodeName) => {
     376       377718 :         const nodeDef = getNodeDefByName(nodeName)
     377       377718 :         return nodeDef ? [nodeDef] : []
     378              :       })
     379              :       .slice(0, TOP_NODE_DEF_LIMIT)
     380              :   )
     381              : 
     382         2355 :   return {
     383              :     nodeDefsByName,
     384              :     blueprintNodeDefsByName,
     385              :     nodeDefsByDisplayName,
     386              :     allNodeDefsByName,
     387              :     allNodeDefsByDisplayName,
     388              :     showDeprecated,
     389              :     showExperimental,
     390              :     showDevOnly,
     391              :     nodeDefFilters,
     392              : 
     393              :     nodeDefs,
     394              :     nodeDataTypes,
     395              :     visibleNodeDefs,
     396              :     nodeSearchService,
     397              :     nodeTree,
     398              : 
     399              :     updateNodeDefs,
     400              :     addNodeDef,
     401              :     removeNodeDef,
     402              :     registerBlueprintNodeDef,
     403              :     removeBlueprintNodeDef,
     404              :     getNodeDefByName,
     405              :     fromLGraphNode,
     406              :     getInputSpecForWidget,
     407              :     getDynamicComboSelectionForInput,
     408              :     registerNodeDefFilter,
     409              :     unregisterNodeDefFilter,
     410              :     topNodeDefs
     411              :   }
     412              : })
        

Generated by: LCOV version 2.0-1