LCOV - code coverage report
Current view: top level - src/renderer/core/canvas/links - linkConnectorAdapter.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 87.0 % 54 47
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type { SlotLayout } from '@comfyorg/graph-model/layout'
       2              : import type { PointTuple as Point } from '@comfyorg/shared-frontend-utils/geometry'
       3              : import type { LGraph } from '@/lib/litegraph/src/LGraph'
       4              : import type { RerouteId } from '@/lib/litegraph/src/Reroute'
       5              : import type { LinkConnector } from '@/lib/litegraph/src/canvas/LinkConnector'
       6              : import type { RenderLink } from '@/lib/litegraph/src/canvas/RenderLink'
       7              : import type { CanvasPointerEvent } from '@comfyorg/graph-model/events'
       8              : import { useCanvasStore } from '@/renderer/core/canvas/canvasStore'
       9              : import type { NodeId } from '@comfyorg/graph-model/nodeId'
      10              : import { isSubgraph } from '@/utils/typeGuardUtil'
      11              : 
      12              : // Keep one adapter per graph so rendering and interaction share state.
      13         2355 : const adapterByGraph = new WeakMap<LGraph, LinkConnectorAdapter>()
      14              : 
      15              : /**
      16              :  * Renderer‑agnostic adapter around LiteGraph's LinkConnector.
      17              :  *
      18              :  * - Uses layoutStore for hit‑testing (nodes/reroutes).
      19              :  * - Exposes minimal, imperative APIs to begin link drags and query drop validity.
      20              :  * - Preserves existing Vue composable behavior.
      21              :  */
      22         2355 : export class LinkConnectorAdapter {
      23              :   constructor(
      24              :     /** Network the links belong to (typically `app.canvas.graph`). */
      25           45 :     readonly network: LGraph,
      26           45 :     readonly linkConnector: LinkConnector
      27              :   ) {}
      28              : 
      29              :   /**
      30              :    * The currently rendered/dragged links, typed for consumer use.
      31              :    * Prefer this over accessing `linkConnector.renderLinks` directly.
      32              :    */
      33              :   get renderLinks(): ReadonlyArray<RenderLink> {
      34          606 :     return this.linkConnector.renderLinks
      35              :   }
      36              : 
      37              :   // Drag helpers
      38              : 
      39              :   /**
      40              :    * Begin dragging from an output slot.
      41              :    * @param nodeId Output node id
      42              :    * @param outputIndex Output slot index
      43              :    * @param opts Optional: moveExisting (shift), fromRerouteId
      44              :    */
      45              :   beginFromOutput(
      46              :     nodeId: NodeId,
      47              :     outputIndex: number,
      48              :     opts?: { moveExisting?: boolean; fromRerouteId?: RerouteId }
      49              :   ): void {
      50           48 :     const node = this.network.getNodeById(nodeId)
      51           48 :     const output = node?.outputs[outputIndex]
      52           48 :     if (!node || !output) return
      53              : 
      54           48 :     const fromReroute = this.network.getReroute(opts?.fromRerouteId)
      55              : 
      56           48 :     if (opts?.moveExisting) {
      57            2 :       this.linkConnector.moveOutputLink(this.network, node, output)
      58              :     } else {
      59           46 :       this.linkConnector.dragNewFromOutput(
      60              :         this.network,
      61              :         node,
      62              :         output,
      63              :         fromReroute
      64              :       )
      65              :     }
      66              :   }
      67              : 
      68              :   /**
      69              :    * Begin dragging from an input slot.
      70              :    * @param nodeId Input node id
      71              :    * @param inputIndex Input slot index
      72              :    * @param opts Optional: moveExisting (when a link/floating exists), fromRerouteId
      73              :    */
      74              :   beginFromInput(
      75              :     nodeId: NodeId,
      76              :     inputIndex: number,
      77              :     opts?: {
      78              :       fromRerouteId?: RerouteId
      79              :       layout?: SlotLayout
      80              :       moveExisting?: boolean
      81              :     }
      82              :   ): void {
      83           17 :     const node = this.network.getNodeById(nodeId)
      84           17 :     const input = node?.inputs[inputIndex]
      85           17 :     if (!node || !input) return
      86              : 
      87           17 :     const fromReroute = this.network.getReroute(opts?.fromRerouteId)
      88              : 
      89           17 :     if (opts?.moveExisting) {
      90           10 :       const startPoint: Point | undefined = opts.layout
      91              :         ? [opts.layout.position.x, opts.layout.position.y]
      92              :         : undefined
      93           10 :       this.linkConnector.moveInputLink(this.network, node, input, {
      94              :         startPoint
      95              :       })
      96              :     } else {
      97            7 :       this.linkConnector.dragNewFromInput(
      98              :         this.network,
      99              :         node,
     100              :         input,
     101              :         fromReroute
     102              :       )
     103              :     }
     104              :   }
     105              : 
     106              :   // Validation helpers
     107              : 
     108              :   isNodeValidDrop(nodeId: NodeId): boolean {
     109            0 :     const node = this.network.getNodeById(nodeId)
     110            0 :     if (!node) return false
     111            0 :     return this.linkConnector.isNodeValidDrop(node)
     112              :   }
     113              : 
     114              :   isInputValidDrop(nodeId: NodeId, inputIndex: number): boolean {
     115          684 :     const node = this.network.getNodeById(nodeId)
     116          684 :     const input = node?.inputs[inputIndex]
     117          684 :     if (!node || !input) return false
     118          684 :     return this.linkConnector.isInputValidDrop(node, input)
     119              :   }
     120              : 
     121              :   isOutputValidDrop(nodeId: NodeId, outputIndex: number): boolean {
     122           73 :     const node = this.network.getNodeById(nodeId)
     123           73 :     const output = node?.outputs[outputIndex]
     124           73 :     if (!node || !output) return false
     125           73 :     return this.linkConnector.renderLinks.some((link) =>
     126              :       link.canConnectToOutput(node, output)
     127              :     )
     128              :   }
     129              : 
     130              :   isRerouteValidDrop(rerouteId: RerouteId): boolean {
     131            0 :     const reroute = this.network.getReroute(rerouteId)
     132            0 :     if (!reroute) return false
     133            0 :     return this.linkConnector.isRerouteValidDrop(reroute)
     134              :   }
     135              : 
     136              :   // Drop/cancel helpers for future flows
     137              : 
     138              :   /** Disconnects moving links (drop on canvas/no target). */
     139              :   disconnectMovingLinks(): void {
     140            0 :     this.linkConnector.disconnectLinks()
     141              :   }
     142              : 
     143              :   /** Drops moving links onto the canvas (no target). */
     144              :   dropOnCanvas(event: CanvasPointerEvent): void {
     145              :     //Add extra check for connection to subgraphInput/subgraphOutput
     146           17 :     if (isSubgraph(this.network)) {
     147            5 :       const { canvasX, canvasY } = event
     148            5 :       const ioNode = this.network.getIoNodeOnPos(canvasX, canvasY)
     149            5 :       if (ioNode) {
     150            3 :         this.linkConnector.dropOnIoNode(ioNode, event)
     151            3 :         return
     152              :       }
     153              :     }
     154           14 :     this.linkConnector.dropOnNothing(event)
     155              :   }
     156              : 
     157              :   /** Resets connector state and clears any temporary flags. */
     158              :   reset(): void {
     159           65 :     this.linkConnector.reset()
     160              :   }
     161              : }
     162              : 
     163              : /** Convenience creator using the current app canvas graph. */
     164           66 : export function createLinkConnectorAdapter(): LinkConnectorAdapter | null {
     165           66 :   const canvas = useCanvasStore().canvas
     166           66 :   const graph = canvas?.graph
     167           66 :   if (!graph) return null
     168           66 :   const connector = canvas.linkConnector
     169              : 
     170           66 :   const adapter = adapterByGraph.get(graph)
     171           66 :   if (adapter && adapter.linkConnector === connector) {
     172           21 :     return adapter
     173              :   }
     174              : 
     175           45 :   const newAdapter = new LinkConnectorAdapter(graph, connector)
     176           45 :   adapterByGraph.set(graph, newAdapter)
     177           45 :   return newAdapter
     178              : }
        

Generated by: LCOV version 2.0-1