Line data Source code
1 : import { defineStore } from 'pinia'
2 : import { computed, ref } from 'vue'
3 :
4 : import { MODEL_NODE_MAPPINGS } from '@/platform/assets/mappings/modelNodeMappings'
5 : import type { ComfyNodeDefImpl } from '@/core/graph/nodeDef/ComfyNodeDefImpl'
6 : import { useNodeDefStore } from '@/stores/nodeDefStore'
7 : import { matchesWidgetName } from '@/utils/widgetBinding'
8 :
9 : /** Helper class that defines how to construct a node from a model. */
10 2356 : export class ModelNodeProvider {
11 : /** The node definition to use for this model. */
12 : public nodeDef: ComfyNodeDefImpl
13 :
14 : /** The input name or pattern used to select the model widget. */
15 : public key: string | RegExp
16 :
17 : constructor(nodeDef: ComfyNodeDefImpl, key: string | RegExp) {
18 136998 : this.nodeDef = nodeDef
19 136998 : this.key = key
20 : }
21 : }
22 :
23 : /** Service for mapping model types (by folder name) to nodes. */
24 2356 : export const useModelToNodeStore = defineStore('modelToNode', () => {
25 2355 : const modelToNodeMap = ref<Partial<Record<string, ModelNodeProvider[]>>>({})
26 2355 : const nodeDefStore = useNodeDefStore()
27 2355 : const haveDefaultsLoaded = ref(false)
28 :
29 2355 : const registeredNodeTypes = computed<
30 : Partial<Record<string, string | RegExp>>
31 : >(() =>
32 : Object.fromEntries(
33 : Object.values(modelToNodeMap.value)
34 : .filter((providers) => providers !== undefined)
35 : .flat()
36 : .map((provider) => [provider.nodeDef.name, provider.key])
37 : )
38 : )
39 :
40 : /** Internal computed for efficient reverse lookup: nodeType -> category */
41 2355 : const nodeTypeToCategory = computed(() => {
42 2316 : const lookup: Record<string, string> = {}
43 2316 : for (const [category, providers] of Object.entries(modelToNodeMap.value)) {
44 39372 : if (!providers) continue
45 39372 : for (const provider of providers) {
46 : // Only store the first category for each node type (matches current assetService behavior)
47 48636 : if (!lookup[provider.nodeDef.name]) {
48 48636 : lookup[provider.nodeDef.name] = category
49 : }
50 : }
51 : }
52 2316 : return lookup
53 : })
54 :
55 : /** Get set of all registered node types for efficient lookup */
56 5339 : function getRegisteredNodeTypes(): Partial<Record<string, string | RegExp>> {
57 5339 : registerDefaults()
58 5339 : return registeredNodeTypes.value
59 : }
60 :
61 5339 : function isModelWidget(nodeType: string, widgetName: string): boolean {
62 5339 : const key = getRegisteredNodeTypes()[nodeType]
63 5339 : return key !== undefined && matchesWidgetName(widgetName, key)
64 : }
65 :
66 : /**
67 : * Get the category for a given node type.
68 : * Performs efficient O(1) lookup using cached reverse map.
69 : * @param nodeType The node type name to find the category for
70 : * @returns The category name, or undefined if not found
71 : */
72 2973 : function getCategoryForNodeType(nodeType: string): string | undefined {
73 2973 : registerDefaults()
74 :
75 : // Handle invalid input gracefully
76 2973 : if (!nodeType || typeof nodeType !== 'string') {
77 0 : return undefined
78 : }
79 :
80 2973 : return nodeTypeToCategory.value[nodeType]
81 : }
82 :
83 : /**
84 : * Find providers for modelType with hierarchical fallback.
85 : * Tries exact match first, then progressively shorter parent paths.
86 : * e.g., "a/b/c" tries "a/b/c" → "a/b" → "a".
87 : */
88 5 : function findProvidersWithFallback(
89 : modelType: string
90 : ): ModelNodeProvider[] | undefined {
91 5 : if (!modelType || typeof modelType !== 'string') {
92 0 : return undefined
93 : }
94 :
95 5 : const segments = modelType.split('/')
96 5 : for (let i = segments.length; i >= 1; i--) {
97 5 : const path = segments.slice(0, i).join('/')
98 5 : const providers = modelToNodeMap.value[path]
99 5 : if (providers && providers.length > 0) return providers
100 : }
101 :
102 : return undefined
103 : }
104 :
105 : /**
106 : * Get the node provider for the given model type name.
107 : * Supports hierarchical lookups: if "parent/child" has no match, falls back to "parent".
108 : * @param modelType The name of the model type to get the node provider for.
109 : * @returns The node provider for the given model type name.
110 : */
111 4 : function getNodeProvider(modelType: unknown): ModelNodeProvider | undefined {
112 4 : if (typeof modelType !== 'string') return undefined
113 4 : registerDefaults()
114 4 : return findProvidersWithFallback(modelType)?.[0]
115 : }
116 :
117 : /**
118 : * Get the list of all valid node providers for the given model type name.
119 : * Supports hierarchical lookups: if "parent/child" has no match, falls back to "parent".
120 : * @param modelType The name of the model type to get the node providers for.
121 : * @returns The list of all valid node providers for the given model type name.
122 : */
123 1 : function getAllNodeProviders(modelType: unknown): ModelNodeProvider[] {
124 1 : if (typeof modelType !== 'string') return []
125 1 : registerDefaults()
126 1 : return findProvidersWithFallback(modelType) ?? []
127 : }
128 : /**
129 : * Register a node provider for the given model type name.
130 : * @param modelType The name of the model type to register the node provider for.
131 : * @param nodeProvider The node provider to register.
132 : */
133 136998 : function registerNodeProvider(
134 : modelType: string,
135 : nodeProvider:
136 : | ModelNodeProvider
137 : | { nodeDef: undefined; key: string | RegExp }
138 : ) {
139 136998 : registerDefaults()
140 136998 : if (!nodeProvider.nodeDef) return
141 : const providers = (modelToNodeMap.value[modelType] ??= [])
142 48762 : providers.push(nodeProvider)
143 : }
144 : /**
145 : * Register a node provider for the given simple names.
146 : * @param modelType The name of the model type to register the node provider for.
147 : * @param nodeClass The node class name to register.
148 : * @param key The key to use for the node input.
149 : */
150 136998 : function quickRegister(
151 : modelType: string,
152 : nodeClass: string,
153 : key: string | RegExp
154 : ) {
155 136998 : registerNodeProvider(
156 : modelType,
157 : new ModelNodeProvider(nodeDefStore.nodeDefsByName[nodeClass], key)
158 : )
159 : }
160 :
161 145316 : function registerDefaults() {
162 145316 : if (haveDefaultsLoaded.value) {
163 142994 : return
164 : }
165 145316 : if (Object.keys(nodeDefStore.nodeDefsByName).length === 0) {
166 0 : return
167 : }
168 2322 : haveDefaultsLoaded.value = true
169 :
170 145316 : for (const [modelType, nodeClass, key] of MODEL_NODE_MAPPINGS) {
171 136998 : quickRegister(modelType, nodeClass, key)
172 : }
173 : }
174 :
175 2355 : return {
176 : modelToNodeMap,
177 : getRegisteredNodeTypes,
178 : isModelWidget,
179 : getCategoryForNodeType,
180 : getNodeProvider,
181 : getAllNodeProviders,
182 : registerNodeProvider,
183 : quickRegister,
184 : registerDefaults
185 : }
186 : })
|