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 : })
|