LCOV - code coverage report
Current view: top level - src/platform/workflowErrors/missingModel/composables - useMissingModelInteractions.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 28.1 % 64 18
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { resolveNodeDisplayName } from '@/utils/nodeTitleUtil'
       2              : import type { UploadModelSuccess } from '@/platform/assets/composables/useUploadModelWizard'
       3              : import { useMissingModelStore } from '@/platform/workflowErrors/missingModel/missingModelStore'
       4              : import { useAssetsStore } from '@/stores/assetsStore'
       5              : import { useAssetDownloadStore } from '@/stores/assetDownloadStore'
       6              : import { useModelToNodeStore } from '@/stores/modelToNodeStore'
       7              : import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore'
       8              : import { app } from '@/scripts/app'
       9              : import { getNodeByExecutionId } from '@/utils/graphTraversalUtil'
      10              : import type { MissingModelViewModel } from '@/platform/workflowErrors/missingModel/types'
      11              : 
      12           37 : export function getModelStateKey(
      13              :   modelName: string,
      14              :   directory: string | null,
      15              :   isAssetSupported: boolean
      16              : ): string {
      17              :   const prefix = isAssetSupported ? 'supported' : 'unsupported'
      18           37 :   return `${prefix}::${directory ?? ''}::${modelName}`
      19              : }
      20              : 
      21            2 : export function getNodeDisplayLabel(
      22              :   nodeId: string | number,
      23              :   fallback: string
      24              : ): string {
      25            2 :   const graph = app.rootGraphOrUndefined
      26            2 :   if (!graph) return fallback
      27            2 :   const node = getNodeByExecutionId(graph, String(nodeId))
      28            2 :   return resolveNodeDisplayName(node, {
      29              :     emptyLabel: fallback,
      30              :     untitledLabel: fallback
      31              :   })
      32              : }
      33              : 
      34           35 : export function useMissingModelInteractions() {
      35           35 :   const store = useMissingModelStore()
      36           35 :   const assetsStore = useAssetsStore()
      37           35 :   const assetDownloadStore = useAssetDownloadStore()
      38           35 :   const modelToNodeStore = useModelToNodeStore()
      39           35 :   const workflowStore = useWorkflowStore()
      40              : 
      41            0 :   function toggleModelExpand(key: string) {
      42            0 :     store.modelExpandState[key] = !isModelExpanded(key)
      43              :   }
      44              : 
      45            0 :   function isModelExpanded(key: string): boolean {
      46            0 :     return store.modelExpandState[key] ?? false
      47              :   }
      48              : 
      49              :   /** Apply selected model to referencing nodes, removing only that model from the error list. */
      50            0 :   function confirmLibrarySelect(
      51              :     key: string,
      52              :     modelName: string,
      53              :     referencingNodes: MissingModelViewModel['referencingNodes'],
      54              :     directory: string | null
      55              :   ) {
      56            0 :     const value = store.selectedLibraryModel[key]
      57            0 :     if (!value || !app.rootGraphOrUndefined) return
      58              : 
      59            0 :     if (directory) {
      60            0 :       const providers = modelToNodeStore.getAllNodeProviders(directory)
      61            0 :       void Promise.allSettled(
      62              :         providers.map((provider) =>
      63              :           assetsStore.updateModelsForNodeType(provider.nodeDef.name)
      64              :         )
      65              :       ).then((results) => {
      66            0 :         for (const r of results) {
      67            0 :           if (r.status === 'rejected') {
      68            0 :             console.warn(
      69              :               '[Missing Model] Failed to refresh model cache:',
      70              :               r.reason
      71              :             )
      72              :           }
      73              :         }
      74              :       })
      75              :     }
      76              : 
      77            0 :     delete store.selectedLibraryModel[key]
      78            0 :     delete store.importTaskIds[key]
      79            0 :     replaceModelOnNodes(modelName, referencingNodes, value)
      80              :   }
      81              : 
      82            0 :   function replaceModelOnNodes(
      83              :     modelName: string,
      84              :     referencingNodes: MissingModelViewModel['referencingNodes'],
      85              :     value: string
      86              :   ) {
      87            0 :     const graph = app.rootGraphOrUndefined
      88            0 :     if (!graph) return
      89              : 
      90            0 :     for (const ref of referencingNodes) {
      91            0 :       const node = getNodeByExecutionId(graph, String(ref.nodeId))
      92            0 :       if (node) {
      93            0 :         const widget = node.widgets?.find((w) => w.name === ref.widgetName)
      94            0 :         if (widget) {
      95            0 :           const oldValue = widget.value
      96            0 :           widget.value = value
      97            0 :           widget.callback?.(value)
      98            0 :           node.onWidgetChanged?.(widget.name, value, oldValue, widget)
      99              :         }
     100            0 :         node.graph?.setDirtyCanvas(true, true)
     101              :       }
     102              :     }
     103            0 :     workflowStore.activeWorkflow?.changeTracker.captureCanvasState()
     104              : 
     105            0 :     const nodeIdSet = new Set(referencingNodes.map((ref) => String(ref.nodeId)))
     106            0 :     store.removeMissingModelByNameOnNodes(modelName, nodeIdSet)
     107              :   }
     108              : 
     109           35 :   function getDownloadStatus(key: string) {
     110           35 :     const taskId = store.importTaskIds[key]
     111           35 :     if (!taskId) return null
     112           35 :     return (
     113              :       assetDownloadStore.downloadList.find((d) => d.taskId === taskId) ?? null
     114              :     )
     115              :   }
     116              : 
     117            0 :   function handleAsyncPending(
     118              :     key: string,
     119              :     taskId: string,
     120              :     modelType: string | undefined,
     121              :     filename: string
     122              :   ) {
     123            0 :     store.importTaskIds[key] = taskId
     124            0 :     if (modelType) {
     125            0 :       assetDownloadStore.trackDownload(taskId, modelType, filename)
     126              :     }
     127              :   }
     128              : 
     129            0 :   function handleAsyncCompleted(modelType: string | undefined) {
     130            0 :     if (modelType) {
     131            0 :       assetsStore.invalidateModelsForCategory(modelType)
     132            0 :       void assetsStore.updateModelsForTag(modelType)
     133              :     }
     134              :   }
     135              : 
     136            0 :   function handleUploadedModelImport(key: string, result: UploadModelSuccess) {
     137            0 :     if (result.taskId) {
     138            0 :       handleAsyncPending(key, result.taskId, result.modelType, result.filename)
     139            0 :     } else if (result.status === 'success') {
     140            0 :       handleAsyncCompleted(result.modelType)
     141              :     }
     142              : 
     143            0 :     store.selectedLibraryModel[key] = result.filename
     144              :   }
     145              : 
     146           35 :   return {
     147              :     toggleModelExpand,
     148              :     isModelExpanded,
     149              :     confirmLibrarySelect,
     150              :     replaceModelOnNodes,
     151              :     getDownloadStatus,
     152              :     handleUploadedModelImport
     153              :   }
     154              : }
        

Generated by: LCOV version 2.0-1