LCOV - code coverage report
Current view: top level - src/stores - modelToNodeStore.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 94.8 % 58 55
Test Date: 2026-11-17 04:17:53

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

Generated by: LCOV version 2.0-1