From c6f07f53ec2bf417641988030fa5bd4bf6049fd8 Mon Sep 17 00:00:00 2001 From: Arthur R Longbottom Date: Thu, 26 Feb 2026 21:16:10 -0800 Subject: [PATCH 1/9] fix: add visual feedback for subgraph IO drag interactions Bridge canvas-initiated subgraph IO drags to Vue slot drag state and vice versa, restoring slot dimming, proximity snap, dot highlights, and drop-to-connect across the canvas/Vue rendering boundary. Fixes #9010 --- src/components/graph/GraphCanvas.vue | 2 + src/lib/litegraph/src/canvas/LinkConnector.ts | 7 +- .../infrastructure/LinkConnectorEventMap.ts | 5 + .../litegraph/src/subgraph/SubgraphInput.ts | 10 + .../src/subgraph/SubgraphInputNode.ts | 11 + .../core/canvas/links/linkConnectorAdapter.ts | 1 - .../canvas/links/useSubgraphDragBridge.ts | 353 ++++++++++++++++++ .../vueNodes/components/SlotConnectionDot.vue | 2 +- .../composables/useSlotLinkInteraction.ts | 47 ++- 9 files changed, 428 insertions(+), 10 deletions(-) create mode 100644 src/renderer/core/canvas/links/useSubgraphDragBridge.ts diff --git a/src/components/graph/GraphCanvas.vue b/src/components/graph/GraphCanvas.vue index 967b8f00f32..e70cbb9f90a 100644 --- a/src/components/graph/GraphCanvas.vue +++ b/src/components/graph/GraphCanvas.vue @@ -185,6 +185,7 @@ import { useWorkflowAutoSave } from '@/platform/workflow/persistence/composables import { useWorkflowPersistenceV2 as useWorkflowPersistence } from '@/platform/workflow/persistence/composables/useWorkflowPersistenceV2' import { useNodeDataStore } from '@/stores/nodeDataStore' import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' +import { useSubgraphDragBridge } from '@/renderer/core/canvas/links/useSubgraphDragBridge' import { useCanvasInteractions } from '@/renderer/core/canvas/useCanvasInteractions' import { arrangeForLegacyRender } from '@/renderer/core/canvas/litegraph/arrangeForLegacyRender' import { notifyLayoutChanges } from '@/renderer/core/canvas/litegraph/notifyLayoutChanges' @@ -487,6 +488,7 @@ useGroupContextMenu() useCopy() usePaste() useWorkflowAutoSave() +useSubgraphDragBridge() // Start watching for locale change after the initial value is loaded. watch( diff --git a/src/lib/litegraph/src/canvas/LinkConnector.ts b/src/lib/litegraph/src/canvas/LinkConnector.ts index e04e9de202a..976b42e6b90 100644 --- a/src/lib/litegraph/src/canvas/LinkConnector.ts +++ b/src/lib/litegraph/src/canvas/LinkConnector.ts @@ -489,6 +489,7 @@ export class LinkConnector { this.state.connectingTo = 'input' this._setLegacyLinks(false) + this.events.dispatch('connecting', { connectingTo: 'input' }) } dragNewFromSubgraphOutput( @@ -513,6 +514,7 @@ export class LinkConnector { this.state.connectingTo = 'output' this._setLegacyLinks(true) + this.events.dispatch('connecting', { connectingTo: 'output' }) } /** @@ -948,7 +950,10 @@ export class LinkConnector { (link: RenderLink) => !!link.disconnectOnDrop ).forEach((link) => (link as { disconnect(): void }).disconnect()) if (this.renderLinks.length === 0) return - // For external event only. + + const intercepted = this.events.dispatch('before-drop-on-canvas', event) + if (intercepted === false) return + const mayContinue = this.events.dispatch('dropped-on-canvas', event) if (mayContinue === false) return diff --git a/src/lib/litegraph/src/infrastructure/LinkConnectorEventMap.ts b/src/lib/litegraph/src/infrastructure/LinkConnectorEventMap.ts index 837c131dedc..cc87bdd20b1 100644 --- a/src/lib/litegraph/src/infrastructure/LinkConnectorEventMap.ts +++ b/src/lib/litegraph/src/infrastructure/LinkConnectorEventMap.ts @@ -15,6 +15,10 @@ import type { IWidget } from '@/lib/litegraph/src/types/widgets' export interface LinkConnectorEventMap { reset: boolean + connecting: { + connectingTo: 'input' | 'output' + } + 'before-drop-links': { renderLinks: RenderLink[] event: CanvasPointerEvent @@ -44,6 +48,7 @@ export interface LinkConnectorEventMap { node: SubgraphInputNode | SubgraphOutputNode event: CanvasPointerEvent } + 'before-drop-on-canvas': CanvasPointerEvent 'dropped-on-canvas': CanvasPointerEvent 'dropped-on-widget': { diff --git a/src/lib/litegraph/src/subgraph/SubgraphInput.ts b/src/lib/litegraph/src/subgraph/SubgraphInput.ts index e5c7f97673f..9b80dbc4e08 100644 --- a/src/lib/litegraph/src/subgraph/SubgraphInput.ts +++ b/src/lib/litegraph/src/subgraph/SubgraphInput.ts @@ -133,6 +133,16 @@ export class SubgraphInput extends SubgraphSlot { return } + if (slot.widget) { + subgraph.trigger('node:slot-links:changed', { + nodeId: node.id, + slotType: NodeSlotType.INPUT, + slotIndex: inputIndex, + connected: true, + linkId: link.id + }) + } + node.onConnectionsChange?.(NodeSlotType.INPUT, inputIndex, true, link, slot) if (subgraph.getLink(link.id) !== link) { subgraph.afterChange() diff --git a/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts b/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts index 75d6ff7e5aa..4b0159cb5db 100644 --- a/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts +++ b/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts @@ -188,6 +188,17 @@ export class SubgraphInputNode subgraph.removeFloatingLink(floatingLink) } + const linkId = input.link + input.link = null + if (input.widget) { + subgraph.trigger('node:slot-links:changed', { + nodeId: node.id, + slotType: NodeSlotType.INPUT, + slotIndex: node.inputs.indexOf(input), + connected: false, + linkId: linkId + }) + } subgraph.setDirtyCanvas(false, true) if (!link) return diff --git a/src/renderer/core/canvas/links/linkConnectorAdapter.ts b/src/renderer/core/canvas/links/linkConnectorAdapter.ts index a03d07f87b4..7c317d12c9a 100644 --- a/src/renderer/core/canvas/links/linkConnectorAdapter.ts +++ b/src/renderer/core/canvas/links/linkConnectorAdapter.ts @@ -142,7 +142,6 @@ export class LinkConnectorAdapter { /** Drops moving links onto the canvas (no target). */ dropOnCanvas(event: CanvasPointerEvent): void { - //Add extra check for connection to subgraphInput/subgraphOutput if (isSubgraph(this.network)) { const { canvasX, canvasY } = event const ioNode = this.network.getIoNodeOnPos?.(canvasX, canvasY) diff --git a/src/renderer/core/canvas/links/useSubgraphDragBridge.ts b/src/renderer/core/canvas/links/useSubgraphDragBridge.ts new file mode 100644 index 00000000000..ee14fc2f4e9 --- /dev/null +++ b/src/renderer/core/canvas/links/useSubgraphDragBridge.ts @@ -0,0 +1,353 @@ +import { tryOnScopeDispose, whenever } from '@vueuse/core' +import { storeToRefs } from 'pinia' + +import type { LGraphCanvas } from '@/lib/litegraph/src/LGraphCanvas' +import type { LGraphNode, NodeId } from '@/lib/litegraph/src/LGraphNode' +import type { LinkConnector } from '@/lib/litegraph/src/canvas/LinkConnector' +import type { RenderLink } from '@/lib/litegraph/src/canvas/RenderLink' +import type { SlotDropCandidate } from '@/renderer/core/canvas/links/slotLinkDragUIState' +import { LinkDirection } from '@/lib/litegraph/src/types/globalEnums' +import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' +import { createLinkConnectorAdapter } from '@/renderer/core/canvas/links/linkConnectorAdapter' +import { + resolveNodeSurfaceSlotCandidate, + resolveSlotTargetCandidate +} from '@/renderer/core/canvas/links/linkDropOrchestrator' +import { useSlotLinkDragUIState } from '@/renderer/core/canvas/links/slotLinkDragUIState' +import { getSlotKey } from '@/renderer/core/layout/slots/slotIdentifier' +import { layoutStore } from '@/renderer/core/layout/store/layoutStore' +import { createSlotLinkDragContext } from '@/renderer/extensions/vueNodes/composables/slotLinkDragContext' +import { resolvePointerTarget } from '@/renderer/extensions/vueNodes/composables/useSlotLinkInteraction' +import { useNodeSlotRegistryStore } from '@/renderer/extensions/vueNodes/stores/nodeSlotRegistryStore' +import { app } from '@/scripts/app' +import { createRafBatch } from '@/utils/rafBatch' + +const SNAP_CLASS = 'lg-slot--snap-target' + +/** + * Bridges canvas-initiated subgraph IO drags to Vue slot drag state. + * + * When a drag starts from a SubgraphInput or SubgraphOutput node + * (canvas-drawn), the Vue slot components need to know about it so they + * can dim incompatible slots, snap links, and highlight compatible targets. + */ +export function useSubgraphDragBridge() { + const canvasStore = useCanvasStore() + const { canvas } = storeToRefs(canvasStore) + const { + state: dragState, + beginDrag, + endDrag, + setCandidate, + setCompatibleForKey + } = useSlotLinkDragUIState() + let cleanup: (() => void) | undefined + + whenever(canvas, (lgCanvas) => { + cleanup?.() + cleanup = setupBridge(lgCanvas) + }) + + tryOnScopeDispose(() => { + cleanup?.() + cleanup = undefined + }) + + /** Wires up LinkConnector event listeners and returns a cleanup function. */ + function setupBridge(lgCanvas: LGraphCanvas): () => void { + const linkConnector: LinkConnector = lgCanvas.linkConnector + let teardownDrag: (() => void) | undefined + let isBridgeDrag = false + + const onConnecting = ( + event: CustomEvent<{ connectingTo: 'input' | 'output' }> + ) => { + teardownDrag?.() + teardownDrag = undefined + + const { connectingTo } = event.detail + + const adapter = createLinkConnectorAdapter() + if (!adapter) return + + const renderLink = adapter.renderLinks[0] + if (!renderLink) return + + const sourceType: 'input' | 'output' = + connectingTo === 'input' ? 'output' : 'input' + + isBridgeDrag = true + beginDrag( + { + nodeId: String(renderLink.node.id), + slotIndex: renderLink.fromSlotIndex, + type: sourceType, + direction: renderLink.fromDirection ?? LinkDirection.RIGHT, + position: { + x: renderLink.fromPos[0], + y: renderLink.fromPos[1] + } + }, + -1 + ) + + const allKeys = layoutStore.getAllSlotKeys() + for (const key of allKeys) { + const slotLayout = layoutStore.getSlotLayout(key) + if (!slotLayout) continue + if (slotLayout.type !== connectingTo) continue + + const ok = + connectingTo === 'input' + ? adapter.isInputValidDrop(slotLayout.nodeId, slotLayout.index) + : adapter.isOutputValidDrop(slotLayout.nodeId, slotLayout.index) + + setCompatibleForKey(key, ok) + } + + teardownDrag = startPointerTracking(lgCanvas, linkConnector) + } + + const onBeforeDropOnCanvas = (event: CustomEvent) => { + if (!isBridgeDrag) return + + const candidate = dragState.candidate + if (!candidate?.compatible) return + + const adapter = createLinkConnectorAdapter() + if (!adapter) return + + const connected = connectToCandidate( + adapter.renderLinks, + adapter.network, + candidate, + linkConnector + ) + if (connected) event.preventDefault() + } + + const onReset = () => { + if (!isBridgeDrag) return + teardownDrag?.() + teardownDrag = undefined + isBridgeDrag = false + endDrag() + } + + linkConnector.events.addEventListener('connecting', onConnecting) + linkConnector.events.addEventListener( + 'before-drop-on-canvas', + onBeforeDropOnCanvas + ) + linkConnector.events.addEventListener('reset', onReset) + + return () => { + linkConnector.events.removeEventListener('connecting', onConnecting) + linkConnector.events.removeEventListener( + 'before-drop-on-canvas', + onBeforeDropOnCanvas + ) + linkConnector.events.removeEventListener('reset', onReset) + teardownDrag?.() + teardownDrag = undefined + if (isBridgeDrag) { + isBridgeDrag = false + endDrag() + } + } + } + + /** + * Tracks pointer movement during a bridge drag to resolve Vue slot + * candidates, update snap positions, and toggle snap-target highlights. + * Returns a cleanup function that removes the listener and RAF batch. + */ + function startPointerTracking( + lgCanvas: LGraphCanvas, + linkConnector: LinkConnector + ): () => void { + const ownerDoc = lgCanvas.getCanvasWindow().document + const session = createSlotLinkDragContext() + const slotRegistry = useNodeSlotRegistryStore() + let pendingMove: { clientX: number; clientY: number } | null = null + let highlightedSlotEl: HTMLElement | null = null + + const processFrame = () => { + const data = pendingMove + if (!data) return + pendingMove = null + + const adapter = createLinkConnectorAdapter() + if (!adapter) return + const graph = adapter.network + + const target = resolvePointerTarget(data.clientX, data.clientY, null) + + let hoveredSlotKey: string | null = null + let hoveredNodeId: NodeId | null = null + if (target === session.lastPointerEventTarget) { + hoveredSlotKey = session.lastPointerTargetSlotKey + hoveredNodeId = session.lastPointerTargetNodeId + } else if (target instanceof HTMLElement) { + const elWithSlot = target + .closest('.lg-slot, .lg-node-widget') + ?.querySelector('[data-slot-key]') + const elWithNode = target.closest('[data-node-id]') + hoveredSlotKey = elWithSlot?.dataset['slotKey'] ?? null + hoveredNodeId = elWithNode?.dataset['nodeId'] ?? null + session.lastPointerEventTarget = target + session.lastPointerTargetSlotKey = hoveredSlotKey + session.lastPointerTargetNodeId = hoveredNodeId + } + + const hoverChanged = + hoveredSlotKey !== session.lastHoverSlotKey || + hoveredNodeId !== session.lastHoverNodeId + + let candidate = dragState.candidate + + if (hoverChanged) { + const context = { adapter, graph, session } + const slotCandidate = resolveSlotTargetCandidate(target, context) + const nodeCandidate = resolveNodeSurfaceSlotCandidate(target, context) + candidate = slotCandidate?.compatible ? slotCandidate : nodeCandidate + session.lastHoverSlotKey = hoveredSlotKey + session.lastHoverNodeId = hoveredNodeId + + if (slotCandidate) { + const key = getSlotKey( + slotCandidate.layout.nodeId, + slotCandidate.layout.index, + slotCandidate.layout.type === 'input' + ) + setCompatibleForKey(key, !!slotCandidate.compatible) + } + if (nodeCandidate && !slotCandidate?.compatible) { + const key = getSlotKey( + nodeCandidate.layout.nodeId, + nodeCandidate.layout.index, + nodeCandidate.layout.type === 'input' + ) + setCompatibleForKey(key, !!nodeCandidate.compatible) + } + } + + const newCandidate = candidate?.compatible ? candidate : null + const newCandidateKey = newCandidate + ? getSlotKey( + newCandidate.layout.nodeId, + newCandidate.layout.index, + newCandidate.layout.type === 'input' + ) + : null + + const candidateChanged = newCandidateKey !== session.lastCandidateKey + if (candidateChanged) { + setCandidate(newCandidate) + session.lastCandidateKey = newCandidateKey + updateSnapTargetHighlight(newCandidate) + } + + const snapPos = newCandidate + ? ([newCandidate.layout.position.x, newCandidate.layout.position.y] as [ + number, + number + ]) + : undefined + const currentSnap = linkConnector.state.snapLinksPos + const snapPosChanged = snapPos + ? !currentSnap || + currentSnap[0] !== snapPos[0] || + currentSnap[1] !== snapPos[1] + : !!currentSnap + if (snapPosChanged) { + linkConnector.state.snapLinksPos = snapPos + } + + if (candidateChanged || snapPosChanged) { + app.canvas?.setDirty(true, true) + } + } + + /** Toggles the `lg-slot--snap-target` CSS class on the candidate's slot element. */ + function updateSnapTargetHighlight(candidate: SlotDropCandidate | null) { + if (highlightedSlotEl) { + highlightedSlotEl.classList.remove(SNAP_CLASS) + highlightedSlotEl = null + } + if (!candidate) return + const key = getSlotKey( + candidate.layout.nodeId, + candidate.layout.index, + candidate.layout.type === 'input' + ) + const entry = slotRegistry + .getNode(candidate.layout.nodeId) + ?.slots.get(key) + const groupEl = entry?.el?.parentElement + if (groupEl) { + groupEl.classList.add(SNAP_CLASS) + highlightedSlotEl = groupEl + } + } + + const raf = createRafBatch(processFrame) + + const onPointerMove = (e: PointerEvent) => { + pendingMove = { clientX: e.clientX, clientY: e.clientY } + raf.schedule() + } + + ownerDoc.addEventListener('pointermove', onPointerMove, { capture: true }) + + return () => { + ownerDoc.removeEventListener('pointermove', onPointerMove, { + capture: true + }) + raf.cancel() + if (highlightedSlotEl) { + highlightedSlotEl.classList.remove(SNAP_CLASS) + highlightedSlotEl = null + } + session.dispose() + } + } +} + +/** + * Connects render links to the snapped Vue slot candidate. + * Returns `true` if at least one link was connected. + */ +function connectToCandidate( + links: ReadonlyArray, + network: { getNodeById(id: NodeId): LGraphNode | null }, + candidate: SlotDropCandidate, + linkConnector: LinkConnector +): boolean { + const node = network.getNodeById(candidate.layout.nodeId) + if (!node) return false + + let connected = false + + if (candidate.layout.type === 'input') { + const input = node.inputs?.[candidate.layout.index] + if (!input) return false + for (const link of links) { + if (link.toType !== 'input') continue + if (!link.canConnectToInput(node, input)) continue + link.connectToInput(node, input, linkConnector.events) + connected = true + } + } else { + const output = node.outputs?.[candidate.layout.index] + if (!output) return false + for (const link of links) { + if (link.toType !== 'output') continue + if (!link.canConnectToOutput(node, output)) continue + link.connectToOutput(node, output, linkConnector.events) + connected = true + } + } + + return connected +} diff --git a/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue b/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue index f1df51b7eed..fd5407070f0 100644 --- a/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue +++ b/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue @@ -48,7 +48,7 @@ const slotClass = computed(() => 'border border-solid border-node-component-slot-dot-outline', props.multi ? 'h-5 w-2' - : 'size-2 cursor-crosshair group-hover/slot:scale-125 group-hover/slot:[--node-component-slot-dot-outline-opacity-mult:5]' + : 'size-2 cursor-crosshair group-hover/slot:scale-125 group-hover/slot:[--node-component-slot-dot-outline-opacity-mult:5] group-[.lg-slot--snap-target]/slot:[--node-component-slot-dot-outline-opacity-mult:5] group-[.lg-slot--snap-target]/slot:scale-125' ) ) diff --git a/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts b/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts index ebac19f96f9..682e8974602 100644 --- a/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts +++ b/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts @@ -12,6 +12,7 @@ import type { INodeInputSlot, INodeOutputSlot } from '@/lib/litegraph/src/interfaces' +import type { CanvasPointerEvent } from '@/lib/litegraph/src/types/events' import { LinkDirection } from '@/lib/litegraph/src/types/globalEnums' import { clearCanvasPointerHistory, @@ -40,6 +41,7 @@ import { graphScopeOf } from '@/types/graphScopeId' import { UNASSIGNED_NODE_ID, toNodeId } from '@/types/nodeId' import type { NodeId } from '@/types/nodeId' import { createRafBatch } from '@/utils/rafBatch' +import { isSubgraph } from '@/utils/typeGuardUtil' interface SlotInteractionOptions { nodeId?: NodeId @@ -413,14 +415,44 @@ export function useSlotLinkInteraction({ dragContext.lastCandidateKey = newCandidateKey } + let subgraphIOSnapPos: [number, number] | null = null + let subgraphIOHoverChanged = false + + const graph = app.canvas?.graph + if (isSubgraph(graph)) { + const pointerEvent = { canvasX, canvasY } as CanvasPointerEvent + + for (const node of [graph.inputNode, graph.outputNode]) { + if (!node) continue + + const wasPointerOver = node.isPointerOver + node.onPointerMove(pointerEvent) + + if (wasPointerOver !== node.isPointerOver || node.isPointerOver) { + subgraphIOHoverChanged = true + } + + if (node.isPointerOver) { + const slot = node.getSlotInPosition(canvasX, canvasY) + if (slot && slot.isPointerOver) { + subgraphIOSnapPos = slot.pos + } + } + } + } + let snapPosChanged = false if (activeAdapter) { - const snapX = newCandidate - ? newCandidate.layout.position.x - : state.pointer.canvas.x - const snapY = newCandidate - ? newCandidate.layout.position.y - : state.pointer.canvas.y + const snapX = subgraphIOSnapPos + ? subgraphIOSnapPos[0] + : newCandidate + ? newCandidate.layout.position.x + : state.pointer.canvas.x + const snapY = subgraphIOSnapPos + ? subgraphIOSnapPos[1] + : newCandidate + ? newCandidate.layout.position.y + : state.pointer.canvas.y const currentSnap = activeAdapter.linkConnector.state.snapLinksPos snapPosChanged = !currentSnap || currentSnap[0] !== snapX || currentSnap[1] !== snapY @@ -429,7 +461,8 @@ export function useSlotLinkInteraction({ } } - const shouldRedraw = candidateChanged || snapPosChanged + const shouldRedraw = + candidateChanged || snapPosChanged || subgraphIOHoverChanged if (shouldRedraw) app.canvas?.setDirty(true, true) } const raf = createRafBatch(processPointerMoveFrame) From 3958959ae758cb33ef8b7b2687f9d7282c466b48 Mon Sep 17 00:00:00 2001 From: Arthur R Longbottom Date: Thu, 26 Feb 2026 21:35:37 -0800 Subject: [PATCH 2/9] test: add unit tests for subgraph IO slot link events - SubgraphInput.connect() fires node:slot-links:changed for widget inputs - SubgraphInputNode._disconnectNodeInput() fires on disconnect - LinkConnector.dropOnNothing() dispatches before-drop-on-canvas before dropped-on-canvas, and skips downstream when intercepted - Remove duplicate raf.flush() in finishInteraction --- .../canvas/LinkConnectorDropEvents.test.ts | 87 +++++++++++++++ .../src/subgraph/SubgraphIOSlotLinks.test.ts | 102 ++++++++++++++++++ 2 files changed, 189 insertions(+) create mode 100644 src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts create mode 100644 src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts diff --git a/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts b/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts new file mode 100644 index 00000000000..7ab58106657 --- /dev/null +++ b/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts @@ -0,0 +1,87 @@ +import { beforeEach, describe, expect, test, vi } from 'vitest' + +import { LinkConnector } from '@/lib/litegraph/src/litegraph' +import { + createMockCanvasPointerEvent, + createMockLGraphNode, + createMockLinkNetwork, + createMockNodeOutputSlot +} from '@/utils/__tests__/litegraphTestUtils' + +const mockSetConnectingLinks = vi.fn() + +type RenderLinkItem = LinkConnector['renderLinks'][number] + +function createMockRenderLink(): RenderLinkItem { + const partial: Partial = { + toType: 'input', + fromPos: [0, 0], + fromSlotIndex: 0, + fromDirection: 0, + network: createMockLinkNetwork(), + node: createMockLGraphNode(), + fromSlot: createMockNodeOutputSlot(), + dragDirection: 0, + canConnectToInput: vi.fn().mockReturnValue(false), + canConnectToOutput: vi.fn().mockReturnValue(false), + canConnectToReroute: vi.fn().mockReturnValue(false), + connectToInput: vi.fn(), + connectToOutput: vi.fn(), + connectToSubgraphInput: vi.fn(), + connectToRerouteOutput: vi.fn(), + connectToSubgraphOutput: vi.fn(), + connectToRerouteInput: vi.fn() + } + return partial as RenderLinkItem +} + +describe('LinkConnector.dropOnNothing event dispatch', () => { + let connector: LinkConnector + + beforeEach(() => { + connector = new LinkConnector(mockSetConnectingLinks) + vi.clearAllMocks() + }) + + test('dispatches before-drop-on-canvas before dropped-on-canvas', () => { + connector.renderLinks.push(createMockRenderLink()) + + const callOrder: string[] = [] + connector.events.addEventListener('before-drop-on-canvas', () => { + callOrder.push('before-drop-on-canvas') + }) + connector.events.addEventListener('dropped-on-canvas', () => { + callOrder.push('dropped-on-canvas') + }) + + connector.dropOnNothing(createMockCanvasPointerEvent(100, 100)) + + expect(callOrder).toEqual(['before-drop-on-canvas', 'dropped-on-canvas']) + }) + + test('skips dropped-on-canvas when before-drop-on-canvas is intercepted', () => { + connector.renderLinks.push(createMockRenderLink()) + + const droppedListener = vi.fn() + connector.events.addEventListener('before-drop-on-canvas', (e) => { + e.preventDefault() + }) + connector.events.addEventListener('dropped-on-canvas', droppedListener) + + connector.dropOnNothing(createMockCanvasPointerEvent(100, 100)) + + expect(droppedListener).not.toHaveBeenCalled() + }) + + test('does not dispatch events when renderLinks is empty', () => { + const beforeListener = vi.fn() + const droppedListener = vi.fn() + connector.events.addEventListener('before-drop-on-canvas', beforeListener) + connector.events.addEventListener('dropped-on-canvas', droppedListener) + + connector.dropOnNothing(createMockCanvasPointerEvent(100, 100)) + + expect(beforeListener).not.toHaveBeenCalled() + expect(droppedListener).not.toHaveBeenCalled() + }) +}) diff --git a/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts b/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts new file mode 100644 index 00000000000..ef5c102bcd6 --- /dev/null +++ b/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts @@ -0,0 +1,102 @@ +import { describe, expect, vi } from 'vitest' + +import { LGraphNode } from '@/lib/litegraph/src/litegraph' +import { NodeSlotType } from '@/lib/litegraph/src/types/globalEnums' + +import { subgraphTest } from './__fixtures__/subgraphFixtures' + +describe('SubgraphInput.connect triggers node:slot-links:changed', () => { + subgraphTest( + 'fires connected event when connecting to a widget input', + ({ simpleSubgraph }) => { + const subgraph = simpleSubgraph + const triggerSpy = vi.spyOn(subgraph, 'trigger') + + const node = new LGraphNode('Target') + node.addInput('prompt', 'STRING') + node.inputs[0].widget = { name: 'prompt' } + subgraph.add(node) + + subgraph.inputNode.slots[0].connect(node.inputs[0], node) + + expect(triggerSpy).toHaveBeenCalledWith('node:slot-links:changed', { + nodeId: node.id, + slotType: NodeSlotType.INPUT, + slotIndex: 0, + connected: true, + linkId: expect.any(Number) + }) + } + ) + + subgraphTest( + 'does not fire event when connecting to a non-widget input', + ({ simpleSubgraph }) => { + const subgraph = simpleSubgraph + const triggerSpy = vi.spyOn(subgraph, 'trigger') + + const node = new LGraphNode('Target') + node.addInput('in', 'number') + subgraph.add(node) + + subgraph.inputNode.slots[0].connect(node.inputs[0], node) + + expect(triggerSpy).not.toHaveBeenCalledWith( + 'node:slot-links:changed', + expect.anything() + ) + } + ) +}) + +describe('SubgraphInputNode._disconnectNodeInput triggers node:slot-links:changed', () => { + subgraphTest( + 'fires disconnected event when disconnecting a widget input', + ({ simpleSubgraph }) => { + const subgraph = simpleSubgraph + + const node = new LGraphNode('Target') + node.addInput('prompt', 'STRING') + node.inputs[0].widget = { name: 'prompt' } + subgraph.add(node) + + const link = subgraph.inputNode.slots[0].connect(node.inputs[0], node) + expect(link).toBeDefined() + + const triggerSpy = vi.spyOn(subgraph, 'trigger') + + subgraph.inputNode._disconnectNodeInput(node, node.inputs[0], link!) + + expect(triggerSpy).toHaveBeenCalledWith('node:slot-links:changed', { + nodeId: node.id, + slotType: NodeSlotType.INPUT, + slotIndex: 0, + connected: false, + linkId: link!.id + }) + } + ) + + subgraphTest( + 'does not fire event when disconnecting a non-widget input', + ({ simpleSubgraph }) => { + const subgraph = simpleSubgraph + + const node = new LGraphNode('Target') + node.addInput('in', 'number') + subgraph.add(node) + + const link = subgraph.inputNode.slots[0].connect(node.inputs[0], node) + expect(link).toBeDefined() + + const triggerSpy = vi.spyOn(subgraph, 'trigger') + + subgraph.inputNode._disconnectNodeInput(node, node.inputs[0], link!) + + expect(triggerSpy).not.toHaveBeenCalledWith( + 'node:slot-links:changed', + expect.anything() + ) + } + ) +}) From 95c164312a88ad1d18e140c1c92dfa2c0f4e3cb1 Mon Sep 17 00:00:00 2001 From: Arthur R Longbottom Date: Fri, 27 Feb 2026 07:14:27 -0800 Subject: [PATCH 3/9] fix: strengthen test assertions and add missing docstrings Replace weak negative assertions with explicit call-name filtering to catch false passes. Add docstrings to inner bridge functions. --- .../litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts | 10 ++++------ .../core/canvas/links/useSubgraphDragBridge.ts | 2 ++ 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts b/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts index ef5c102bcd6..a52c80b9918 100644 --- a/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts +++ b/src/lib/litegraph/src/subgraph/SubgraphIOSlotLinks.test.ts @@ -41,9 +41,8 @@ describe('SubgraphInput.connect triggers node:slot-links:changed', () => { subgraph.inputNode.slots[0].connect(node.inputs[0], node) - expect(triggerSpy).not.toHaveBeenCalledWith( - 'node:slot-links:changed', - expect.anything() + expect(triggerSpy.mock.calls.map((c) => c[0])).not.toContain( + 'node:slot-links:changed' ) } ) @@ -93,9 +92,8 @@ describe('SubgraphInputNode._disconnectNodeInput triggers node:slot-links:change subgraph.inputNode._disconnectNodeInput(node, node.inputs[0], link!) - expect(triggerSpy).not.toHaveBeenCalledWith( - 'node:slot-links:changed', - expect.anything() + expect(triggerSpy.mock.calls.map((c) => c[0])).not.toContain( + 'node:slot-links:changed' ) } ) diff --git a/src/renderer/core/canvas/links/useSubgraphDragBridge.ts b/src/renderer/core/canvas/links/useSubgraphDragBridge.ts index ee14fc2f4e9..22fc4f7ea7e 100644 --- a/src/renderer/core/canvas/links/useSubgraphDragBridge.ts +++ b/src/renderer/core/canvas/links/useSubgraphDragBridge.ts @@ -172,6 +172,7 @@ export function useSubgraphDragBridge() { let pendingMove: { clientX: number; clientY: number } | null = null let highlightedSlotEl: HTMLElement | null = null + /** Resolves the Vue slot under the pointer and updates snap/highlight state. */ const processFrame = () => { const data = pendingMove if (!data) return @@ -293,6 +294,7 @@ export function useSubgraphDragBridge() { const raf = createRafBatch(processFrame) + /** Buffers the latest pointer position and schedules a RAF frame. */ const onPointerMove = (e: PointerEvent) => { pendingMove = { clientX: e.clientX, clientY: e.clientY } raf.schedule() From 724165c755e83dea146a58bf016f675a1a56437f Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Thu, 12 Mar 2026 15:06:35 -0700 Subject: [PATCH 4/9] fix: address CodeRabbit review feedback - Remove unconditional canvas dirty during stable hover (perf) The `|| node.isPointerOver` condition caused setDirty on every pointer-move frame while hovering, even when state hadn't changed. --- .../extensions/vueNodes/composables/useSlotLinkInteraction.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts b/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts index 682e8974602..b706cb0e6f7 100644 --- a/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts +++ b/src/renderer/extensions/vueNodes/composables/useSlotLinkInteraction.ts @@ -428,7 +428,7 @@ export function useSlotLinkInteraction({ const wasPointerOver = node.isPointerOver node.onPointerMove(pointerEvent) - if (wasPointerOver !== node.isPointerOver || node.isPointerOver) { + if (wasPointerOver !== node.isPointerOver) { subgraphIOHoverChanged = true } From a4f0ed971b100a6f160eac73d3e6afb51f044373 Mon Sep 17 00:00:00 2001 From: GitHub Action Date: Thu, 12 Mar 2026 22:10:53 +0000 Subject: [PATCH 5/9] [automated] Apply ESLint and Oxfmt fixes --- .../extensions/vueNodes/components/SlotConnectionDot.vue | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue b/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue index fd5407070f0..d1917669736 100644 --- a/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue +++ b/src/renderer/extensions/vueNodes/components/SlotConnectionDot.vue @@ -48,7 +48,7 @@ const slotClass = computed(() => 'border border-solid border-node-component-slot-dot-outline', props.multi ? 'h-5 w-2' - : 'size-2 cursor-crosshair group-hover/slot:scale-125 group-hover/slot:[--node-component-slot-dot-outline-opacity-mult:5] group-[.lg-slot--snap-target]/slot:[--node-component-slot-dot-outline-opacity-mult:5] group-[.lg-slot--snap-target]/slot:scale-125' + : 'size-2 cursor-crosshair group-hover/slot:scale-125 group-hover/slot:[--node-component-slot-dot-outline-opacity-mult:5] group-[.lg-slot--snap-target]/slot:scale-125 group-[.lg-slot--snap-target]/slot:[--node-component-slot-dot-outline-opacity-mult:5]' ) ) From a5dbe3329a25d44489c63eb8a36fbffdca6a14c3 Mon Sep 17 00:00:00 2001 From: fleet-lane-act-fe-9838 Date: Wed, 2 Sep 2026 11:47:32 +0000 Subject: [PATCH 6/9] fix: adapt to post-rebase API changes on main - NodeId now lives at @/types/nodeId (moved from LGraphNode.ts); use toNodeId() where a raw string needs to become a NodeId. - layoutStore.getAllSlotKeys()/getSlotLayout() and nodeSlotRegistryStore were removed by 40bb3f5660 (#16001, 'remove Vue slot dirty tracking'). Enumerate compatible slots via adapter.network.nodes (same pattern useSlotLinkInteraction.ts uses post-refactor) and resolve the snap-target highlight element via the [data-slot-key] DOM attribute instead of the deleted registry. - input.link = null is now a deprecated setter that calls node.disconnectInput(), which re-enters _disconnectNodeInput -- writing to it here caused infinite recursion (RangeError: Maximum call stack size exceeded) in SubgraphIOSlotLinks.test.ts. Read the link id from the already-available link param instead of the (now recursive) input.link getter/setter. --- .../src/subgraph/SubgraphInputNode.ts | 6 +-- .../canvas/links/useSubgraphDragBridge.ts | 47 +++++++++++-------- 2 files changed, 29 insertions(+), 24 deletions(-) diff --git a/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts b/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts index 4b0159cb5db..e4112f87300 100644 --- a/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts +++ b/src/lib/litegraph/src/subgraph/SubgraphInputNode.ts @@ -188,15 +188,13 @@ export class SubgraphInputNode subgraph.removeFloatingLink(floatingLink) } - const linkId = input.link - input.link = null if (input.widget) { subgraph.trigger('node:slot-links:changed', { nodeId: node.id, slotType: NodeSlotType.INPUT, - slotIndex: node.inputs.indexOf(input), + slotIndex: inputIndex, connected: false, - linkId: linkId + linkId: link?.id ?? null }) } subgraph.setDirtyCanvas(false, true) diff --git a/src/renderer/core/canvas/links/useSubgraphDragBridge.ts b/src/renderer/core/canvas/links/useSubgraphDragBridge.ts index 22fc4f7ea7e..6a6c88ede60 100644 --- a/src/renderer/core/canvas/links/useSubgraphDragBridge.ts +++ b/src/renderer/core/canvas/links/useSubgraphDragBridge.ts @@ -2,7 +2,7 @@ import { tryOnScopeDispose, whenever } from '@vueuse/core' import { storeToRefs } from 'pinia' import type { LGraphCanvas } from '@/lib/litegraph/src/LGraphCanvas' -import type { LGraphNode, NodeId } from '@/lib/litegraph/src/LGraphNode' +import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode' import type { LinkConnector } from '@/lib/litegraph/src/canvas/LinkConnector' import type { RenderLink } from '@/lib/litegraph/src/canvas/RenderLink' import type { SlotDropCandidate } from '@/renderer/core/canvas/links/slotLinkDragUIState' @@ -15,11 +15,11 @@ import { } from '@/renderer/core/canvas/links/linkDropOrchestrator' import { useSlotLinkDragUIState } from '@/renderer/core/canvas/links/slotLinkDragUIState' import { getSlotKey } from '@/renderer/core/layout/slots/slotIdentifier' -import { layoutStore } from '@/renderer/core/layout/store/layoutStore' import { createSlotLinkDragContext } from '@/renderer/extensions/vueNodes/composables/slotLinkDragContext' import { resolvePointerTarget } from '@/renderer/extensions/vueNodes/composables/useSlotLinkInteraction' -import { useNodeSlotRegistryStore } from '@/renderer/extensions/vueNodes/stores/nodeSlotRegistryStore' import { app } from '@/scripts/app' +import type { NodeId } from '@/types/nodeId' +import { toNodeId } from '@/types/nodeId' import { createRafBatch } from '@/utils/rafBatch' const SNAP_CLASS = 'lg-slot--snap-target' @@ -79,7 +79,7 @@ export function useSubgraphDragBridge() { isBridgeDrag = true beginDrag( { - nodeId: String(renderLink.node.id), + nodeId: renderLink.node.id, slotIndex: renderLink.fromSlotIndex, type: sourceType, direction: renderLink.fromDirection ?? LinkDirection.RIGHT, @@ -91,18 +91,24 @@ export function useSubgraphDragBridge() { -1 ) - const allKeys = layoutStore.getAllSlotKeys() - for (const key of allKeys) { - const slotLayout = layoutStore.getSlotLayout(key) - if (!slotLayout) continue - if (slotLayout.type !== connectingTo) continue - - const ok = + for (const candidateNode of adapter.network.nodes) { + const slots = connectingTo === 'input' - ? adapter.isInputValidDrop(slotLayout.nodeId, slotLayout.index) - : adapter.isOutputValidDrop(slotLayout.nodeId, slotLayout.index) + ? candidateNode.inputs + : candidateNode.outputs + for (const [slotIndex] of slots.entries()) { + const key = getSlotKey( + candidateNode.id, + slotIndex, + connectingTo === 'input' + ) + const ok = + connectingTo === 'input' + ? adapter.isInputValidDrop(candidateNode.id, slotIndex) + : adapter.isOutputValidDrop(candidateNode.id, slotIndex) - setCompatibleForKey(key, ok) + setCompatibleForKey(key, ok) + } } teardownDrag = startPointerTracking(lgCanvas, linkConnector) @@ -168,7 +174,6 @@ export function useSubgraphDragBridge() { ): () => void { const ownerDoc = lgCanvas.getCanvasWindow().document const session = createSlotLinkDragContext() - const slotRegistry = useNodeSlotRegistryStore() let pendingMove: { clientX: number; clientY: number } | null = null let highlightedSlotEl: HTMLElement | null = null @@ -195,7 +200,9 @@ export function useSubgraphDragBridge() { ?.querySelector('[data-slot-key]') const elWithNode = target.closest('[data-node-id]') hoveredSlotKey = elWithSlot?.dataset['slotKey'] ?? null - hoveredNodeId = elWithNode?.dataset['nodeId'] ?? null + hoveredNodeId = elWithNode?.dataset['nodeId'] + ? toNodeId(elWithNode.dataset['nodeId']) + : null session.lastPointerEventTarget = target session.lastPointerTargetSlotKey = hoveredSlotKey session.lastPointerTargetNodeId = hoveredNodeId @@ -282,10 +289,10 @@ export function useSubgraphDragBridge() { candidate.layout.index, candidate.layout.type === 'input' ) - const entry = slotRegistry - .getNode(candidate.layout.nodeId) - ?.slots.get(key) - const groupEl = entry?.el?.parentElement + const dotEl = ownerDoc.querySelector( + `[data-slot-key="${key}"]` + ) + const groupEl = dotEl?.closest('.lg-slot') if (groupEl) { groupEl.classList.add(SNAP_CLASS) highlightedSlotEl = groupEl From a15b3fda35578a9d1fa1aa917de46b5dbf120716 Mon Sep 17 00:00:00 2001 From: bymyself Date: Wed, 2 Sep 2026 19:48:56 +0000 Subject: [PATCH 7/9] test(GraphCanvas): stub linkConnector on mocked app.canvas useSubgraphDragBridge wires LinkConnector event listeners the moment useCanvasStore().canvas resolves. The @/scripts/app mock in this file supplies a plain canvas object with no linkConnector, so mounting GraphCanvas under test threw "Cannot read properties of undefined (reading 'events')" and failed 12/14 tests in this file (matching the red unit CI job and DrJKL's review on fe #9838). Stub the shape setupBridge actually touches (events.add/removeEventListener, state) so the mount succeeds without changing behavior. --- src/components/graph/GraphCanvas.test.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/components/graph/GraphCanvas.test.ts b/src/components/graph/GraphCanvas.test.ts index b498fd32f5a..7c872a40998 100644 --- a/src/components/graph/GraphCanvas.test.ts +++ b/src/components/graph/GraphCanvas.test.ts @@ -73,7 +73,10 @@ vi.mock('@/scripts/app', () => { graph: null, onSelectionChange: null, setDirty: mocks.setDirty, - canvas: document.createElement('canvas') + canvas: document.createElement('canvas'), + // useSubgraphDragBridge wires listeners onto this the moment the store's + // canvas ref resolves; without it, mounting GraphCanvas throws. + linkConnector: { events: new EventTarget(), state: {} } } return { app: { From 1a71ad132615aeb89d7692f0eaef4588b8bdbd93 Mon Sep 17 00:00:00 2001 From: christian-byrne Date: Fri, 11 Sep 2026 06:59:42 -0700 Subject: [PATCH 8/9] test: cover useSubgraphDragBridge directly GraphCanvas.test.ts only needs the bridge's mount-time dependency to exist; nothing there notices if the bridge stops wiring itself up. Test the composable in isolation against an LGraphCanvas double so the drag mirroring, per-slot compatibility, reset handling, and scope-dispose teardown each fail on their own. Dropping getCanvasWindow from the double reproduces the TypeError reported in review, confirming the pointer-tracking path is reached rather than stubbed silent. Addresses review feedback: https://github.com/Comfy-Org/ComfyUI_frontend/pull/9838#discussion_r3912784982 --- .../links/useSubgraphDragBridge.test.ts | 151 ++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 src/renderer/core/canvas/links/useSubgraphDragBridge.test.ts diff --git a/src/renderer/core/canvas/links/useSubgraphDragBridge.test.ts b/src/renderer/core/canvas/links/useSubgraphDragBridge.test.ts new file mode 100644 index 00000000000..6f469a5f863 --- /dev/null +++ b/src/renderer/core/canvas/links/useSubgraphDragBridge.test.ts @@ -0,0 +1,151 @@ +import { fromPartial } from '@total-typescript/shoehorn' +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { effectScope, nextTick } from 'vue' + +import { LGraph } from '@/lib/litegraph/src/LGraph' +import type { LGraphCanvas } from '@/lib/litegraph/src/LGraphCanvas' +import { LGraphNode } from '@/lib/litegraph/src/LGraphNode' +import type { LinkConnector } from '@/lib/litegraph/src/canvas/LinkConnector' +import type { LinkConnectorEventMap } from '@/lib/litegraph/src/infrastructure/LinkConnectorEventMap' +import { CustomEventTarget } from '@/lib/litegraph/src/infrastructure/CustomEventTarget' +import { LinkDirection } from '@/lib/litegraph/src/types/globalEnums' +import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' +import { useSlotLinkDragUIState } from '@/renderer/core/canvas/links/slotLinkDragUIState' +import { getSlotKey } from '@/renderer/core/layout/slots/slotIdentifier' +import { toNodeId } from '@/types/nodeId' + +import { useSubgraphDragBridge } from './useSubgraphDragBridge' + +/** + * The bridge is the only listener that turns a canvas-drawn subgraph IO drag + * into Vue slot drag state. GraphCanvas mounts it against the live + * `LGraphCanvas`, so its collaborators (`linkConnector.events` and + * `getCanvasWindow()`) are exercised here against a canvas double rather than + * through a component mount. + */ +const appMock = vi.hoisted(() => ({ + app: { canvas: null as LGraphCanvas | null } +})) + +vi.mock('@/scripts/app', () => appMock) + +const SOURCE_NODE_ID = toNodeId(1) +const TARGET_NODE_ID = toNodeId(2) + +function createTargetGraph() { + const graph = new LGraph() + const target = new LGraphNode('Target') + target.id = TARGET_NODE_ID + target.addInput('value', 'INT') + graph.add(target) + return graph +} + +function createCanvasDouble(isInputValidDrop: () => boolean) { + const events = new CustomEventTarget() + + const linkConnector = fromPartial({ + events, + state: {}, + renderLinks: [ + { + node: { id: SOURCE_NODE_ID }, + fromSlotIndex: 3, + fromDirection: LinkDirection.RIGHT, + fromPos: [120, 240] + } + ], + isInputValidDrop: vi.fn(isInputValidDrop) + }) + + const canvas = fromPartial({ + graph: createTargetGraph(), + linkConnector, + setDirty: vi.fn(), + getCanvasWindow: () => window + }) + + return { canvas, linkConnector } +} + +function startBridge(canvas: LGraphCanvas) { + const scope = effectScope() + scope.run(() => useSubgraphDragBridge()) + useCanvasStore().canvas = canvas + return scope +} + +describe('useSubgraphDragBridge', () => { + const { state, endDrag } = useSlotLinkDragUIState() + + beforeEach(() => { + endDrag() + appMock.app.canvas = null + }) + + it('mirrors a canvas-initiated drag into Vue slot drag state', async () => { + const { canvas, linkConnector } = createCanvasDouble(() => true) + appMock.app.canvas = canvas + const scope = startBridge(canvas) + await nextTick() + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + + expect(state.active).toBe(true) + expect(state.source).toMatchObject({ + nodeId: SOURCE_NODE_ID, + slotIndex: 3, + type: 'output', + direction: LinkDirection.RIGHT, + position: { x: 120, y: 240 } + }) + + scope.stop() + }) + + it('records per-slot compatibility for the slots being dragged toward', async () => { + const { canvas, linkConnector } = createCanvasDouble(() => false) + appMock.app.canvas = canvas + const scope = startBridge(canvas) + await nextTick() + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + + expect(state.compatible.get(getSlotKey(TARGET_NODE_ID, 0, true))).toBe( + false + ) + expect(linkConnector.isInputValidDrop).toHaveBeenCalled() + + scope.stop() + }) + + it('ends the drag when the connector resets', async () => { + const { canvas, linkConnector } = createCanvasDouble(() => true) + appMock.app.canvas = canvas + const scope = startBridge(canvas) + await nextTick() + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + linkConnector.events.dispatch('reset', true) + + expect(state.active).toBe(false) + + scope.stop() + }) + + it('ends an in-flight drag and stops listening when its scope is disposed', async () => { + const { canvas, linkConnector } = createCanvasDouble(() => true) + appMock.app.canvas = canvas + const scope = startBridge(canvas) + await nextTick() + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + scope.stop() + + expect(state.active).toBe(false) + + linkConnector.events.dispatch('connecting', { connectingTo: 'input' }) + + expect(state.active).toBe(false) + }) +}) From 9dce47beb875518ccf47bafcafec40ced7d95286 Mon Sep 17 00:00:00 2001 From: christian-byrne Date: Fri, 11 Sep 2026 07:00:00 -0700 Subject: [PATCH 9/9] test: drop redundant vi.clearAllMocks in LinkConnectorDropEvents The project test setup resets mocks between tests, so the hook call trips comfy/no-redundant-vitest-cleanup and fails lint-and-format. --- src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts b/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts index 7ab58106657..4df83b66b77 100644 --- a/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts +++ b/src/lib/litegraph/src/canvas/LinkConnectorDropEvents.test.ts @@ -40,7 +40,6 @@ describe('LinkConnector.dropOnNothing event dispatch', () => { beforeEach(() => { connector = new LinkConnector(mockSetConnectingLinks) - vi.clearAllMocks() }) test('dispatches before-drop-on-canvas before dropped-on-canvas', () => {