LCOV - code coverage report
Current view: top level - src/composables - useCanvasDrop.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 100.0 % 41 41
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { Ref } from 'vue'
       2              : 
       3              : import { useSharedCanvasPositionConversion } from '@/composables/element/useCanvasPositionConversion'
       4              : import { usePragmaticDroppable } from '@/composables/usePragmaticDragAndDrop'
       5              : import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
       6              : import type { PointTuple as Point } from '@comfyorg/shared-frontend-utils/geometry'
       7              : import { LiteGraph } from '@/lib/litegraph/src/litegraph'
       8              : import { withNodeAddSource } from '@/platform/telemetry/nodeAdded/nodeAddSource'
       9              : import { useWorkflowService } from '@/platform/workflow/core/services/workflowService'
      10              : import { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore'
      11              : import { app as comfyApp } from '@/scripts/app'
      12              : import { useLitegraphService } from '@/services/litegraphService'
      13              : import { ComfyModelDef } from '@/stores/modelStore'
      14              : import type { ModelNodeProvider } from '@/stores/modelToNodeStore'
      15              : import { useModelToNodeStore } from '@/stores/modelToNodeStore'
      16              : import { ComfyNodeDefImpl } from '@/core/graph/nodeDef/ComfyNodeDefImpl'
      17              : import type { RenderedTreeExplorerNode } from '@/types/treeExplorerTypes'
      18              : import { isSelectOnly } from '@/utils/litegraphUtil'
      19              : import { matchesWidgetName } from '@/utils/widgetBinding'
      20              : 
      21         2355 : export const useCanvasDrop = (dropTargetRef: Ref<HTMLElement | null>) => {
      22         4710 :   const modelToNodeStore = useModelToNodeStore()
      23         4710 :   const litegraphService = useLitegraphService()
      24         4710 :   const workflowService = useWorkflowService()
      25              : 
      26         4710 :   usePragmaticDroppable(() => dropTargetRef.value, {
      27              :     getDropEffect: (args): Exclude<DataTransfer['dropEffect'], 'none'> =>
      28              :       args.source.data.type === 'tree-explorer-node' ? 'copy' : 'move',
      29              :     onDrop: async (event) => {
      30            5 :       if (isSelectOnly(comfyApp.canvas)) return
      31            5 :       const loc = event.location.current.input
      32            5 :       const dndData = event.source.data
      33              : 
      34            5 :       if (dndData.type === 'tree-explorer-node') {
      35            4 :         const node = dndData.data as RenderedTreeExplorerNode
      36              :         const conv = useSharedCanvasPositionConversion()
      37            4 :         const basePos = conv.clientPosToCanvasPos([loc.clientX, loc.clientY])
      38              : 
      39            4 :         if (node.data instanceof ComfyNodeDefImpl) {
      40            1 :           const nodeDef = node.data
      41            1 :           const pos: Point = [...basePos]
      42              :           // Add an offset on y to make sure after adding the node, the cursor
      43              :           // is on the node (top left corner)
      44            1 :           pos[1] += LiteGraph.NODE_TITLE_HEIGHT
      45            1 :           withNodeAddSource('sidebar_drag', () =>
      46              :             litegraphService.addNodeOnGraph(nodeDef, { pos })
      47              :           )
      48            3 :         } else if (node.data instanceof ComfyModelDef) {
      49            2 :           const model = node.data
      50            2 :           const pos = basePos
      51            2 :           const nodeAtPos = comfyApp.canvas.graph?.getNodeOnPos(pos[0], pos[1])
      52            2 :           let targetProvider: ModelNodeProvider | null = null
      53            2 :           let targetGraphNode: LGraphNode | null = null
      54            2 :           if (nodeAtPos) {
      55            1 :             const providers = modelToNodeStore.getAllNodeProviders(
      56              :               model.directory
      57              :             )
      58            1 :             for (const provider of providers) {
      59            2 :               if (provider.nodeDef.name === nodeAtPos.comfyClass) {
      60            1 :                 targetGraphNode = nodeAtPos
      61            1 :                 targetProvider = provider
      62              :               }
      63              :             }
      64              :           }
      65            2 :           if (!targetGraphNode) {
      66            1 :             const provider = modelToNodeStore.getNodeProvider(model.directory)
      67            1 :             if (provider) {
      68            1 :               targetGraphNode = withNodeAddSource('sidebar_drag', () =>
      69              :                 litegraphService.addNodeOnGraph(provider.nodeDef, { pos })
      70              :               )
      71            1 :               targetProvider = provider
      72              :             }
      73              :           }
      74            2 :           if (targetGraphNode && targetProvider) {
      75            2 :             const { key } = targetProvider
      76            2 :             const widget = targetGraphNode.widgets?.find((widget) =>
      77              :               matchesWidgetName(widget.name, key)
      78              :             )
      79            2 :             if (widget) {
      80            2 :               widget.value = model.file_name
      81              :             }
      82              :           }
      83            1 :         } else if (node.data instanceof ComfyWorkflow) {
      84            1 :           const workflow = node.data
      85            1 :           await workflowService.insertWorkflow(workflow, { position: basePos })
      86              :         }
      87              :       }
      88              :     }
      89              :   })
      90              : }
        

Generated by: LCOV version 2.0-1