LCOV - code coverage report
Current view: top level - src/platform/workflow/templates/utils - templateModelRequirements.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 0.0 % 38 0
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type {
       2              :   FlattenableWorkflowGraph,
       3              :   FlattenableWorkflowNode
       4              : } from '@/platform/workflow/core/utils/workflowFlattening'
       5              : import { flattenWorkflowNodes } from '@/platform/workflow/core/utils/workflowFlattening'
       6              : import {
       7              :   getModelFileKey,
       8              :   getSelectedModelsMetadata,
       9              :   isNodeAndAncestorsActive
      10              : } from '@/platform/workflow/core/utils/modelRequirements'
      11              : import type { ModelFile } from '@comfyorg/graph-model/workflowSchema'
      12              : import { zModelFile } from '@comfyorg/graph-model/workflowSchema'
      13              : 
      14            0 : function toModelFile(value: unknown): ModelFile | undefined {
      15            0 :   const result = zModelFile.safeParse(value)
      16            0 :   return result.success ? result.data : undefined
      17              : }
      18              : 
      19            0 : function getDeclaredModels(value: unknown): ModelFile[] {
      20            0 :   if (!Array.isArray(value)) return []
      21              : 
      22            0 :   return value.flatMap((candidate) => {
      23            0 :     const model = toModelFile(candidate)
      24            0 :     return model ? [model] : []
      25              :   })
      26              : }
      27              : 
      28            0 : function getSelectedNodeModels(
      29              :   node: FlattenableWorkflowNode,
      30              :   workflowModels: readonly ModelFile[]
      31              : ): ModelFile[] {
      32            0 :   const nodeModels = getDeclaredModels(node.properties?.models)
      33              : 
      34              :   // Selection keeps whatever a node declared, down to a bare name. A template
      35              :   // download needs the url and directory, so narrow back to the strict shape
      36              :   // here rather than widening what this module promises.
      37              :   const selected =
      38              :     getSelectedModelsMetadata({
      39              :       type: node.type,
      40              :       widgets_values: node.widgets_values,
      41              :       properties: { models: [...nodeModels, ...workflowModels] }
      42              :     }) ?? []
      43              : 
      44            0 :   return selected.flatMap((model) => {
      45            0 :     const strict = toModelFile(model)
      46            0 :     return strict ? [strict] : []
      47              :   })
      48              : }
      49              : 
      50              : export type TemplateModelRequirementDetail = {
      51              :   model: ModelFile
      52              :   usedBy: readonly string[]
      53              : }
      54              : 
      55            0 : function getNodeDisplayName(
      56              :   node: FlattenableWorkflowNode & { title?: unknown }
      57              : ): string {
      58            0 :   const title = node.title
      59            0 :   if (typeof title === 'string' && title.trim()) return title.trim()
      60              : 
      61            0 :   return node.type
      62              : }
      63              : 
      64            0 : function getSelectedNodeModelDetails(
      65              :   node: FlattenableWorkflowNode,
      66              :   workflowModels: readonly ModelFile[]
      67              : ): TemplateModelRequirementDetail[] {
      68            0 :   const usedBy = getNodeDisplayName(node)
      69            0 :   return getSelectedNodeModels(node, workflowModels).map((model) => ({
      70              :     model,
      71              :     usedBy: [usedBy]
      72              :   }))
      73              : }
      74              : 
      75            0 : function mergeModelRequirementDetails(
      76              :   details: readonly TemplateModelRequirementDetail[]
      77              : ): TemplateModelRequirementDetail[] {
      78            0 :   const aggregates = new Map<
      79              :     string,
      80              :     {
      81              :       model: ModelFile
      82              :       usedBy: string[]
      83              :       seenUsedBy: Set<string>
      84              :     }
      85              :   >()
      86              : 
      87            0 :   for (const { model, usedBy } of details) {
      88            0 :     const key = getModelFileKey(model)
      89            0 :     const existing = aggregates.get(key)
      90            0 :     if (!existing) {
      91            0 :       aggregates.set(key, {
      92              :         model,
      93              :         usedBy: [...usedBy],
      94              :         seenUsedBy: new Set(usedBy)
      95              :       })
      96            0 :       continue
      97              :     }
      98              : 
      99            0 :     for (const nodeName of usedBy) {
     100            0 :       if (existing.seenUsedBy.has(nodeName)) continue
     101              : 
     102            0 :       existing.seenUsedBy.add(nodeName)
     103            0 :       existing.usedBy.push(nodeName)
     104              :     }
     105              :   }
     106              : 
     107            0 :   return [...aggregates.values()].map(({ model, usedBy }) => ({
     108              :     model,
     109              :     usedBy
     110              :   }))
     111              : }
     112              : 
     113              : /**
     114              :  * Preserves declaration precedence and stable usage order while merging the
     115              :  * same model selected by multiple nodes.
     116              :  */
     117            0 : export function extractTemplateModelRequirementDetails(
     118              :   workflow: FlattenableWorkflowGraph & { models?: unknown }
     119              : ): readonly TemplateModelRequirementDetail[] {
     120            0 :   const workflowModels = getDeclaredModels(workflow.models)
     121            0 :   const nodes = flattenWorkflowNodes(workflow)
     122            0 :   const nodesById = new Map(nodes.map((node) => [String(node.id), node]))
     123              :   const nodeDetails = nodes
     124              :     .filter((node) => isNodeAndAncestorsActive(node, nodesById))
     125              :     .flatMap((node) => getSelectedNodeModelDetails(node, workflowModels))
     126              : 
     127            0 :   return mergeModelRequirementDetails(nodeDetails)
     128              : }
        

Generated by: LCOV version 2.0-1