diff --git a/browser_tests/tests/vueNodes/interactions/node/dragSnapping.spec.ts b/browser_tests/tests/vueNodes/interactions/node/dragSnapping.spec.ts new file mode 100644 index 00000000000..182602be009 --- /dev/null +++ b/browser_tests/tests/vueNodes/interactions/node/dragSnapping.spec.ts @@ -0,0 +1,55 @@ +import { expect } from '@playwright/test' + +import { comfyPageFixture as test } from '../../../../fixtures/ComfyPage' + +test.describe('Vue Node Drag Snapping', { tag: '@ui' }, () => { + test.beforeEach(async ({ comfyPage }) => { + await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Disabled') + await comfyPage.settings.setSetting('Comfy.VueNodes.Enabled', true) + await comfyPage.workflow.loadWorkflow('default') + await comfyPage.canvasOps.resetView() + await comfyPage.vueNodes.waitForNodes(6) + }) + + test('snaps a dragged node to another node in Vue nodes mode', async ({ + comfyPage + }) => { + await comfyPage.settings.setSetting( + 'Comfy.Canvas.AlignNodesWhileDragging', + true + ) + + const ksamplerNode = comfyPage.vueNodes.getNodeByTitle('KSampler').first() + const checkpointNode = comfyPage.vueNodes + .getNodeByTitle('Load Checkpoint') + .first() + const ksamplerHeader = ksamplerNode.locator('.lg-node-header') + + const ksamplerBox = await ksamplerNode.boundingBox() + const checkpointBox = await checkpointNode.boundingBox() + const headerBox = await ksamplerHeader.boundingBox() + + if (!ksamplerBox || !checkpointBox || !headerBox) { + throw new Error('Expected Vue node bounding boxes to be available') + } + + const dragStart = { + x: headerBox.x + headerBox.width / 2, + y: headerBox.y + headerBox.height / 2 + } + const targetLeft = checkpointBox.x + 5 + const dragTarget = { + x: dragStart.x + (targetLeft - ksamplerBox.x), + y: dragStart.y + } + + await comfyPage.canvasOps.dragAndDrop(dragStart, dragTarget) + + await expect + .poll(async () => { + const draggedBox = await ksamplerNode.boundingBox() + return draggedBox ? Math.round(draggedBox.x) : null + }) + .toBe(Math.round(checkpointBox.x)) + }) +}) diff --git a/src/components/rightSidePanel/settings/TabGlobalSettings.vue b/src/components/rightSidePanel/settings/TabGlobalSettings.vue index 8cd5873dbab..5c733da91be 100644 --- a/src/components/rightSidePanel/settings/TabGlobalSettings.vue +++ b/src/components/rightSidePanel/settings/TabGlobalSettings.vue @@ -50,6 +50,12 @@ const snapToGrid = computed({ set: (value) => settingStore.set('pysssss.SnapToGrid', value) }) +const alignNodesWhileDragging = computed({ + get: () => settingStore.get('Comfy.Canvas.AlignNodesWhileDragging'), + set: (value) => + settingStore.set('Comfy.Canvas.AlignNodesWhileDragging', value) +}) + // CONNECTION LINKS settings const linkShape = computed({ get: () => settingStore.get('Comfy.Graph.LinkMarkers'), @@ -160,6 +166,11 @@ function openFullSettings() { :label="t('rightSidePanel.globalSettings.snapNodesToGrid')" :tooltip="t('settings.pysssss_SnapToGrid.tooltip')" /> + diff --git a/src/lib/litegraph/src/LGraphCanvas.ts b/src/lib/litegraph/src/LGraphCanvas.ts index 9815f36cd88..3b6e3d842c0 100644 --- a/src/lib/litegraph/src/LGraphCanvas.ts +++ b/src/lib/litegraph/src/LGraphCanvas.ts @@ -5007,6 +5007,9 @@ export class LGraphCanvas implements CustomEventDispatcher if (!LiteGraph.vueNodesMode || !this.overlayCtx) { this._drawConnectingLinks(ctx) + if (LiteGraph.vueNodesMode) { + this._drawVueDragAlignmentGuides(ctx) + } } else { this._drawOverlayLinks() } @@ -5111,7 +5114,8 @@ export class LGraphCanvas implements CustomEventDispatcher octx.clearRect(0, 0, overlayCanvas.width, overlayCanvas.height) - if (!this.linkConnector.isConnecting) return + const hasDragGuides = layoutStore.vueDragSnapGuides.value.length > 0 + if (!this.linkConnector.isConnecting && !hasDragGuides) return octx.save() @@ -5120,11 +5124,39 @@ export class LGraphCanvas implements CustomEventDispatcher this.ds.toCanvasContext(octx) - this._drawConnectingLinks(octx) + if (this.linkConnector.isConnecting) { + this._drawConnectingLinks(octx) + } + this._drawVueDragAlignmentGuides(octx) octx.restore() } + private _drawVueDragAlignmentGuides(ctx: CanvasRenderingContext2D): void { + const guides = layoutStore.vueDragSnapGuides.value + if (!guides.length) return + + const scale = this.ds.scale || 1 + ctx.save() + ctx.beginPath() + ctx.lineWidth = 1 / scale + ctx.strokeStyle = '#ff4d4f' + ctx.setLineDash([6 / scale, 4 / scale]) + + for (const guide of guides) { + if (guide.axis === 'vertical') { + ctx.moveTo(guide.coordinate, guide.start) + ctx.lineTo(guide.coordinate, guide.end) + } else { + ctx.moveTo(guide.start, guide.coordinate) + ctx.lineTo(guide.end, guide.coordinate) + } + } + + ctx.stroke() + ctx.restore() + } + /** Get the target snap / highlight point in graph space */ private _getHighlightPosition(): Readonly { return LiteGraph.snaps_for_comfy diff --git a/src/locales/en/settings.json b/src/locales/en/settings.json index f80fbfb716c..176c63f1d0f 100644 --- a/src/locales/en/settings.json +++ b/src/locales/en/settings.json @@ -55,6 +55,10 @@ "name": "Show selection toolbox", "tooltip": "Display a floating toolbar when nodes are selected, providing quick access to common actions." }, + "Comfy_Canvas_AlignNodesWhileDragging": { + "name": "Align nodes while dragging", + "tooltip": "When enabled in Nodes 2.0, dragging a node selection near another node will snap matching edges and centers together." + }, "Comfy_ConfirmClear": { "name": "Require confirmation when clearing workflow" }, diff --git a/src/platform/settings/constants/coreSettings.ts b/src/platform/settings/constants/coreSettings.ts index 137dc265010..5329ee0a5c1 100644 --- a/src/platform/settings/constants/coreSettings.ts +++ b/src/platform/settings/constants/coreSettings.ts @@ -996,6 +996,16 @@ export const CORE_SETTINGS: SettingParams[] = [ defaultValue: true, versionAdded: '1.10.5' }, + { + id: 'Comfy.Canvas.AlignNodesWhileDragging', + category: ['LiteGraph', 'Canvas', 'AlignNodesWhileDragging'], + name: 'Align nodes while dragging', + tooltip: + 'When enabled in Nodes 2.0, dragging a node selection near another node will snap matching edges and centers together.', + type: 'boolean', + defaultValue: false, + versionAdded: '1.42.0' + }, { id: 'LiteGraph.Reroute.SplineOffset', name: 'Reroute spline offset', diff --git a/src/renderer/core/layout/store/layoutStore.ts b/src/renderer/core/layout/store/layoutStore.ts index 1cb27b06f3e..5e77ef34d82 100644 --- a/src/renderer/core/layout/store/layoutStore.ts +++ b/src/renderer/core/layout/store/layoutStore.ts @@ -30,6 +30,7 @@ import type { LinkSegmentLayout, MoveNodeOperation, MoveRerouteOperation, + NodeAlignmentGuide, NodeBoundsUpdate, NodeId, NodeLayout, @@ -144,6 +145,7 @@ class LayoutStoreImpl implements LayoutStore { // Vue dragging state for selection toolbox (public ref for direct mutation) public isDraggingVueNodes = ref(false) + public vueDragSnapGuides = ref([]) // Vue resizing state to prevent drag from activating during resize public isResizingVueNodes = ref(false) diff --git a/src/renderer/core/layout/types.ts b/src/renderer/core/layout/types.ts index 42df159cc05..3c541c54b10 100644 --- a/src/renderer/core/layout/types.ts +++ b/src/renderer/core/layout/types.ts @@ -32,6 +32,13 @@ export interface Bounds { height: number } +export interface NodeAlignmentGuide { + axis: 'horizontal' | 'vertical' + coordinate: number + start: number + end: number +} + export interface NodeBoundsUpdate { nodeId: NodeId bounds: Bounds diff --git a/src/renderer/core/layout/utils/geometry.ts b/src/renderer/core/layout/utils/geometry.ts index 131223dfa92..169a67209dd 100644 --- a/src/renderer/core/layout/utils/geometry.ts +++ b/src/renderer/core/layout/utils/geometry.ts @@ -14,6 +14,14 @@ export function isBoundsEqual(a: Bounds, b: Bounds): boolean { ) } +export function translateBounds(bounds: Bounds, delta: Point): Bounds { + return { + ...bounds, + x: bounds.x + delta.x, + y: bounds.y + delta.y + } +} + export function isSizeEqual(a: Size, b: Size): boolean { return a.width === b.width && a.height === b.height } diff --git a/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.test.ts b/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.test.ts index c3410051a08..05cd945360e 100644 --- a/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.test.ts +++ b/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.test.ts @@ -24,11 +24,13 @@ vi.mock('@/renderer/extensions/vueNodes/layout/useNodeDrag', () => { const startDrag = vi.fn() const handleDrag = vi.fn() const endDrag = vi.fn() + const cancelDrag = vi.fn() return { useNodeDrag: () => ({ startDrag, handleDrag, - endDrag + endDrag, + cancelDrag }) } }) @@ -93,6 +95,7 @@ const mockData = vi.hoisted(() => { vi.mock('@/renderer/core/layout/store/layoutStore', () => { const isDraggingVueNodes = ref(false) const isResizingVueNodes = ref(false) + const vueDragSnapGuides = ref([]) const fakeNodeLayoutRef = ref(mockData.fakeNodeLayout) const getNodeLayoutRef = vi.fn(() => fakeNodeLayoutRef) const setSource = vi.fn() @@ -100,6 +103,7 @@ vi.mock('@/renderer/core/layout/store/layoutStore', () => { layoutStore: { isDraggingVueNodes, isResizingVueNodes, + vueDragSnapGuides, getNodeLayoutRef, setSource } @@ -136,6 +140,9 @@ describe('useNodePointerInteractions', () => { vi.resetAllMocks() selectedItemsState.items = [] setActivePinia(createTestingPinia()) + layoutStore.isDraggingVueNodes.value = false + layoutStore.isResizingVueNodes.value = false + layoutStore.vueDragSnapGuides.value = [] }) it('should only start drag on left-click', async () => { @@ -184,6 +191,7 @@ describe('useNodePointerInteractions', () => { it('should handle drag termination via cancel and context menu', async () => { const { handleNodeSelect } = useNodeEventHandlers() + const { cancelDrag } = useNodeDrag() const { pointerHandlers } = useNodePointerInteractions('test-node-123') @@ -229,6 +237,7 @@ describe('useNodePointerInteractions', () => { pointerHandlers.onContextmenu(contextMenuEvent) expect(preventDefaultSpy).toHaveBeenCalled() + expect(cancelDrag).toHaveBeenCalledTimes(1) }) it('should integrate with layout store dragging state', async () => { diff --git a/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.ts b/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.ts index 0dfdae51b16..6f2ce9965b2 100644 --- a/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.ts +++ b/src/renderer/extensions/vueNodes/composables/useNodePointerInteractions.ts @@ -12,7 +12,7 @@ import { useNodeDrag } from '@/renderer/extensions/vueNodes/layout/useNodeDrag' export function useNodePointerInteractions( nodeIdRef: MaybeRefOrGetter ) { - const { startDrag, endDrag, handleDrag } = useNodeDrag() + const { startDrag, endDrag, handleDrag, cancelDrag } = useNodeDrag() // Use canvas interactions for proper wheel event handling and pointer event capture control const { forwardEventToCanvas, shouldHandleNodePointerEvents } = useCanvasInteractions() @@ -102,6 +102,7 @@ export function useNodePointerInteractions( function cleanupDragState() { layoutStore.isDraggingVueNodes.value = false + layoutStore.vueDragSnapGuides.value = [] } function safeDragStart(event: PointerEvent, nodeId: string) { @@ -124,6 +125,17 @@ export function useNodePointerInteractions( } } + function safeDragCancel() { + try { + cancelDrag() + } catch (error) { + console.error('Error during cancelDrag:', error) + } finally { + hasDraggingStarted = false + cleanupDragState() + } + } + function onPointerup(event: PointerEvent) { if (forwardMiddlePointerIfNeeded(event)) return // Don't handle pointer events when canvas is in panning mode - forward to canvas instead @@ -166,12 +178,15 @@ export function useNodePointerInteractions( if (!layoutStore.isDraggingVueNodes.value) return event.preventDefault() - // Simply cleanup state without calling endDrag to avoid synthetic event creation - cleanupDragState() + safeDragCancel() } // Cleanup on unmount to prevent resource leaks onScopeDispose(() => { + if (hasDraggingStarted || layoutStore.isDraggingVueNodes.value) { + safeDragCancel() + return + } cleanupDragState() }) diff --git a/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.test.ts b/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.test.ts new file mode 100644 index 00000000000..04642174569 --- /dev/null +++ b/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.test.ts @@ -0,0 +1,128 @@ +import { describe, expect, it } from 'vitest' + +import { resolveNodeAlignmentSnap } from './nodeAlignmentSnap' + +describe('resolveNodeAlignmentSnap', () => { + const selectionBounds = { + x: 0, + y: 0, + width: 100, + height: 80 + } + + it('snaps matching edges within threshold', () => { + const result = resolveNodeAlignmentSnap({ + selectionBounds, + candidateBounds: [ + { + x: 200, + y: 0, + width: 100, + height: 80 + } + ], + delta: { x: 193, y: 0 }, + zoomScale: 1 + }) + + expect(result.delta).toEqual({ x: 200, y: 0 }) + expect(result.guides).toContainEqual({ + axis: 'vertical', + coordinate: 200, + start: 0, + end: 80 + }) + }) + + it('snaps matching centers within threshold', () => { + const result = resolveNodeAlignmentSnap({ + selectionBounds, + candidateBounds: [ + { + x: 0, + y: 200, + width: 100, + height: 80 + } + ], + delta: { x: 0, y: 196 }, + zoomScale: 1 + }) + + expect(result.delta).toEqual({ x: 0, y: 200 }) + expect(result.guides).toContainEqual({ + axis: 'horizontal', + coordinate: 200, + start: 0, + end: 100 + }) + }) + + it('prefers the nearest candidate correction', () => { + const result = resolveNodeAlignmentSnap({ + selectionBounds, + candidateBounds: [ + { + x: 200, + y: 0, + width: 100, + height: 80 + }, + { + x: 198, + y: 0, + width: 100, + height: 80 + } + ], + delta: { x: 193, y: 0 }, + zoomScale: 1 + }) + + expect(result.delta).toEqual({ x: 198, y: 0 }) + expect(result.guides).toContainEqual({ + axis: 'vertical', + coordinate: 198, + start: 0, + end: 80 + }) + }) + + it('does not snap when outside the zoom-adjusted threshold', () => { + const result = resolveNodeAlignmentSnap({ + selectionBounds, + candidateBounds: [ + { + x: 200, + y: 200, + width: 100, + height: 80 + } + ], + delta: { x: 183, y: 0 }, + zoomScale: 0.5 + }) + + expect(result.delta).toEqual({ x: 183, y: 0 }) + expect(result.guides).toEqual([]) + }) + + it('tightens the canvas threshold as zoom increases', () => { + const result = resolveNodeAlignmentSnap({ + selectionBounds, + candidateBounds: [ + { + x: 200, + y: 200, + width: 100, + height: 80 + } + ], + delta: { x: 195, y: 0 }, + zoomScale: 2 + }) + + expect(result.delta).toEqual({ x: 195, y: 0 }) + expect(result.guides).toEqual([]) + }) +}) diff --git a/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.ts b/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.ts new file mode 100644 index 00000000000..a9377cee030 --- /dev/null +++ b/src/renderer/extensions/vueNodes/layout/nodeAlignmentSnap.ts @@ -0,0 +1,215 @@ +import type { + Bounds, + NodeAlignmentGuide, + Point +} from '@/renderer/core/layout/types' +import { translateBounds } from '@/renderer/core/layout/utils/geometry' + +const DEFAULT_THRESHOLD_PX = 8 + +type HorizontalAnchor = 'bottom' | 'centerY' | 'top' +type VerticalAnchor = 'centerX' | 'left' | 'right' + +export interface NodeAlignmentSnapResult { + delta: Point + guides: NodeAlignmentGuide[] +} + +interface AxisMatch { + axis: 'horizontal' | 'vertical' + anchor: HorizontalAnchor | VerticalAnchor + candidateBounds: Bounds + correction: number +} + +interface ResolveNodeAlignmentSnapOptions { + candidateBounds: Bounds[] + delta: Point + selectionBounds: Bounds + thresholdPx?: number + zoomScale: number +} + +export function resolveNodeAlignmentSnap({ + candidateBounds, + delta, + selectionBounds, + thresholdPx = DEFAULT_THRESHOLD_PX, + zoomScale +}: ResolveNodeAlignmentSnapOptions): NodeAlignmentSnapResult { + if (!candidateBounds.length || zoomScale <= 0) { + return { delta, guides: [] } + } + + const threshold = thresholdPx / zoomScale + const translatedSelectionBounds = translateBounds(selectionBounds, delta) + + const verticalMatch = findBestVerticalMatch( + translatedSelectionBounds, + candidateBounds, + threshold + ) + const horizontalMatch = findBestHorizontalMatch( + translatedSelectionBounds, + candidateBounds, + threshold + ) + + const snappedDelta = { + x: delta.x + (verticalMatch?.correction ?? 0), + y: delta.y + (horizontalMatch?.correction ?? 0) + } + const snappedSelectionBounds = translateBounds(selectionBounds, snappedDelta) + const guides = [ + verticalMatch && + createVerticalGuide( + snappedSelectionBounds, + verticalMatch.candidateBounds + ), + horizontalMatch && + createHorizontalGuide( + snappedSelectionBounds, + horizontalMatch.candidateBounds + ) + ].filter((guide): guide is NodeAlignmentGuide => guide !== undefined) + + return { + delta: snappedDelta, + guides + } +} + +function findBestVerticalMatch( + selectionBounds: Bounds, + candidateBounds: Bounds[], + threshold: number +): AxisMatch | undefined { + return findBestMatch( + 'vertical', + getVerticalAnchorValues(selectionBounds), + candidateBounds, + threshold, + getVerticalAnchorValues + ) +} + +function findBestHorizontalMatch( + selectionBounds: Bounds, + candidateBounds: Bounds[], + threshold: number +): AxisMatch | undefined { + return findBestMatch( + 'horizontal', + getHorizontalAnchorValues(selectionBounds), + candidateBounds, + threshold, + getHorizontalAnchorValues + ) +} + +function findBestMatch( + axis: 'horizontal' | 'vertical', + selectionAnchors: Record, + candidateBounds: Bounds[], + threshold: number, + getCandidateAnchors: (bounds: Bounds) => Record +): AxisMatch | undefined { + let bestMatch: AxisMatch | undefined + + for (const bounds of candidateBounds) { + const candidateAnchors = getCandidateAnchors(bounds) + + for (const anchor of Object.keys(selectionAnchors) as TAnchor[]) { + const correction = candidateAnchors[anchor] - selectionAnchors[anchor] + if (Math.abs(correction) > threshold) { + continue + } + + if (!bestMatch || Math.abs(correction) < Math.abs(bestMatch.correction)) { + bestMatch = { + axis, + anchor, + candidateBounds: bounds, + correction + } + } + } + } + + return bestMatch +} + +function getVerticalAnchorValues( + bounds: Bounds +): Record { + return { + left: bounds.x, + centerX: bounds.x + bounds.width * 0.5, + right: bounds.x + bounds.width + } +} + +function getHorizontalAnchorValues( + bounds: Bounds +): Record { + return { + top: bounds.y, + centerY: bounds.y + bounds.height * 0.5, + bottom: bounds.y + bounds.height + } +} + +function createVerticalGuide( + selectionBounds: Bounds, + candidateBounds: Bounds +): NodeAlignmentGuide { + const candidateAnchors = getVerticalAnchorValues(candidateBounds) + const selectionAnchors = getVerticalAnchorValues(selectionBounds) + const coordinate = getSharedAnchorValue(selectionAnchors, candidateAnchors) + + return { + axis: 'vertical', + coordinate, + start: Math.min(selectionBounds.y, candidateBounds.y), + end: Math.max( + selectionBounds.y + selectionBounds.height, + candidateBounds.y + candidateBounds.height + ) + } +} + +function createHorizontalGuide( + selectionBounds: Bounds, + candidateBounds: Bounds +): NodeAlignmentGuide { + const candidateAnchors = getHorizontalAnchorValues(candidateBounds) + const selectionAnchors = getHorizontalAnchorValues(selectionBounds) + const coordinate = getSharedAnchorValue(selectionAnchors, candidateAnchors) + + return { + axis: 'horizontal', + coordinate, + start: Math.min(selectionBounds.x, candidateBounds.x), + end: Math.max( + selectionBounds.x + selectionBounds.width, + candidateBounds.x + candidateBounds.width + ) + } +} + +function getSharedAnchorValue< + TAnchor extends HorizontalAnchor | VerticalAnchor +>( + selectionAnchors: Record, + candidateAnchors: Record +): number { + const anchors = Object.keys(selectionAnchors) as TAnchor[] + + for (const anchor of anchors) { + if (selectionAnchors[anchor] === candidateAnchors[anchor]) { + return selectionAnchors[anchor] + } + } + + return selectionAnchors[anchors[0]] +} diff --git a/src/renderer/extensions/vueNodes/layout/useNodeDrag.test.ts b/src/renderer/extensions/vueNodes/layout/useNodeDrag.test.ts index 300af9cebaf..bb61671e654 100644 --- a/src/renderer/extensions/vueNodes/layout/useNodeDrag.test.ts +++ b/src/renderer/extensions/vueNodes/layout/useNodeDrag.test.ts @@ -1,21 +1,50 @@ import { beforeEach, describe, expect, it, vi } from 'vitest' import { ref } from 'vue' import type { Ref } from 'vue' -import type { NodeLayout } from '@/renderer/core/layout/types' +import type * as VueUseModule from '@vueuse/core' + +import type { Bounds, NodeLayout } from '@/renderer/core/layout/types' + +function getStoredNodeBounds( + layout: Pick +): Bounds { + return { + x: layout.position.x, + y: layout.position.y, + width: layout.size.width, + height: layout.size.height + } +} + +function boundsIntersect(a: Bounds, b: Bounds): boolean { + return !( + a.x + a.width < b.x || + b.x + b.width < a.x || + a.y + a.height < b.y || + b.y + b.height < a.y + ) +} const testState = vi.hoisted(() => { return { selectedNodeIds: null as unknown as Ref>, selectedItems: null as unknown as Ref, nodeLayouts: new Map>(), + canvas: { + setDirty: vi.fn() + }, + settingValues: { + 'Comfy.Canvas.AlignNodesWhileDragging': false + } as Record, mutationFns: { setSource: vi.fn(), moveNode: vi.fn(), batchMoveNodes: vi.fn() }, batchUpdateNodeBounds: vi.fn(), + vueDragSnapGuides: { value: [] as unknown[] } as Ref, nodeSnap: { - shouldSnap: vi.fn(() => false), + shouldSnap: vi.fn((event: PointerEvent) => event.shiftKey), applySnapToPosition: vi.fn((pos: { x: number; y: number }) => pos) }, cancelAnimationFrame: vi.fn(), @@ -23,6 +52,17 @@ const testState = vi.hoisted(() => { } }) +vi.mock('@vueuse/core', async () => { + const actual = await vi.importActual('@vueuse/core') + + return { + ...actual, + createSharedComposable: ( + composable: (...args: TArgs) => TResult + ) => composable + } +}) + vi.mock('pinia', () => ({ storeToRefs: (store: T) => store })) @@ -30,7 +70,8 @@ vi.mock('pinia', () => ({ vi.mock('@/renderer/core/canvas/canvasStore', () => ({ useCanvasStore: () => ({ selectedNodeIds: testState.selectedNodeIds, - selectedItems: testState.selectedItems + selectedItems: testState.selectedItems, + canvas: testState.canvas }) })) @@ -42,10 +83,23 @@ vi.mock('@/renderer/core/layout/store/layoutStore', () => ({ layoutStore: { getNodeLayoutRef: (nodeId: string) => ref(testState.nodeLayouts.get(nodeId) ?? null), - batchUpdateNodeBounds: testState.batchUpdateNodeBounds + queryNodesInBounds: (bounds: Bounds) => + Array.from(testState.nodeLayouts.entries()) + .filter(([, layout]) => + boundsIntersect(getStoredNodeBounds(layout), bounds) + ) + .map(([nodeId]) => nodeId), + batchUpdateNodeBounds: testState.batchUpdateNodeBounds, + vueDragSnapGuides: testState.vueDragSnapGuides } })) +vi.mock('@/platform/settings/settingStore', () => ({ + useSettingStore: () => ({ + get: (key: string) => testState.settingValues[key] + }) +})) + vi.mock('@/renderer/extensions/vueNodes/composables/useNodeSnap', () => ({ useNodeSnap: () => testState.nodeSnap })) @@ -58,6 +112,7 @@ vi.mock('@/renderer/extensions/vueNodes/composables/useShiftKeySync', () => ({ vi.mock('@/renderer/core/layout/transform/useTransformState', () => ({ useTransformState: () => ({ + camera: { z: 1 }, screenToCanvas: ({ x, y }: { x: number; y: number }) => ({ x, y }) }) })) @@ -66,6 +121,12 @@ vi.mock('@/utils/litegraphUtil', () => ({ isLGraphGroup: () => false })) +vi.mock('@/lib/litegraph/src/litegraph', () => ({ + LiteGraph: { + NODE_TITLE_HEIGHT: 30 + } +})) + import { useNodeDrag } from '@/renderer/extensions/vueNodes/layout/useNodeDrag' describe('useNodeDrag', () => { @@ -73,12 +134,17 @@ describe('useNodeDrag', () => { testState.selectedNodeIds = ref(new Set()) testState.selectedItems = ref([]) testState.nodeLayouts.clear() + testState.canvas.setDirty.mockReset() + testState.settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = false testState.mutationFns.setSource.mockReset() testState.mutationFns.moveNode.mockReset() testState.mutationFns.batchMoveNodes.mockReset() testState.batchUpdateNodeBounds.mockReset() + testState.vueDragSnapGuides.value = [] testState.nodeSnap.shouldSnap.mockReset() - testState.nodeSnap.shouldSnap.mockReturnValue(false) + testState.nodeSnap.shouldSnap.mockImplementation( + (event: PointerEvent) => event.shiftKey + ) testState.nodeSnap.applySnapToPosition.mockReset() testState.nodeSnap.applySnapToPosition.mockImplementation( (pos: { x: number; y: number }) => pos @@ -178,6 +244,55 @@ describe('useNodeDrag', () => { expect(testState.mutationFns.moveNode).not.toHaveBeenCalled() }) + it('uses the latest pointer event when moves arrive before the next frame', () => { + testState.selectedNodeIds.value = new Set(['1']) + testState.nodeLayouts.set('1', { + position: { x: 50, y: 80 }, + size: { width: 180, height: 110 } + }) + + const { startDrag, handleDrag } = useNodeDrag() + + startDrag( + { + clientX: 5, + clientY: 10 + } as PointerEvent, + '1' + ) + + const target = document.createElement('div') + target.hasPointerCapture = vi.fn(() => false) + target.setPointerCapture = vi.fn() + + handleDrag( + { + clientX: 25, + clientY: 30, + target, + pointerId: 1 + } as unknown as PointerEvent, + '1' + ) + + handleDrag( + { + clientX: 45, + clientY: 60, + target, + pointerId: 1 + } as unknown as PointerEvent, + '1' + ) + + testState.requestAnimationFrameCallback?.(0) + + expect(testState.mutationFns.batchMoveNodes).toHaveBeenCalledTimes(1) + expect(testState.mutationFns.batchMoveNodes).toHaveBeenCalledWith([ + { nodeId: '1', position: { x: 90, y: 130 } } + ]) + }) + it('cancels pending RAF and applies snap updates on endDrag', () => { testState.selectedNodeIds.value = new Set(['1']) testState.nodeLayouts.set('1', { @@ -231,4 +346,294 @@ describe('useNodeDrag', () => { } ]) }) + + it('snaps a dragged multi-selection to matching node edges', () => { + testState.settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = true + testState.selectedNodeIds.value = new Set(['1', '2']) + testState.nodeLayouts.set('1', { + position: { x: 0, y: 40 }, + size: { width: 100, height: 60 } + }) + testState.nodeLayouts.set('2', { + position: { x: 40, y: 40 }, + size: { width: 100, height: 60 } + }) + testState.nodeLayouts.set('3', { + position: { x: 200, y: 40 }, + size: { width: 100, height: 60 } + }) + + const { startDrag, handleDrag } = useNodeDrag() + + startDrag({ clientX: 0, clientY: 0 } as PointerEvent, '1') + testState.canvas.setDirty.mockClear() + + const target = document.createElement('div') + target.hasPointerCapture = vi.fn(() => false) + target.setPointerCapture = vi.fn() + + handleDrag( + { + clientX: 193, + clientY: 0, + target, + pointerId: 1 + } as unknown as PointerEvent, + '1' + ) + + testState.requestAnimationFrameCallback?.(0) + + expect(testState.mutationFns.batchMoveNodes).toHaveBeenCalledWith([ + { nodeId: '1', position: { x: 200, y: 40 } }, + { nodeId: '2', position: { x: 240, y: 40 } } + ]) + expect(testState.vueDragSnapGuides.value).toContainEqual({ + axis: 'vertical', + coordinate: 200, + start: 10, + end: 100 + }) + expect(testState.canvas.setDirty).toHaveBeenCalledWith(true) + }) + + it('excludes selected nodes from alignment candidates', () => { + testState.settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = true + testState.selectedNodeIds.value = new Set(['1', '2']) + testState.nodeLayouts.set('1', { + position: { x: 0, y: 40 }, + size: { width: 100, height: 60 } + }) + testState.nodeLayouts.set('2', { + position: { x: 60, y: 40 }, + size: { width: 100, height: 60 } + }) + + const { startDrag, handleDrag } = useNodeDrag() + + startDrag({ clientX: 0, clientY: 0 } as PointerEvent, '1') + + const target = document.createElement('div') + target.hasPointerCapture = vi.fn(() => false) + target.setPointerCapture = vi.fn() + + handleDrag( + { + clientX: 63, + clientY: 0, + target, + pointerId: 1 + } as unknown as PointerEvent, + '1' + ) + + testState.requestAnimationFrameCallback?.(0) + + expect(testState.mutationFns.batchMoveNodes).toHaveBeenCalledWith([ + { nodeId: '1', position: { x: 63, y: 40 } }, + { nodeId: '2', position: { x: 123, y: 40 } } + ]) + expect(testState.vueDragSnapGuides.value).toEqual([]) + }) + + it('only snaps against nearby nodes returned by the spatial query', () => { + testState.settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = true + testState.selectedNodeIds.value = new Set(['1']) + testState.nodeLayouts.set('1', { + position: { x: 0, y: 40 }, + size: { width: 100, height: 60 } + }) + testState.nodeLayouts.set('2', { + position: { x: 200, y: 320 }, + size: { width: 100, height: 60 } + }) + + const { startDrag, handleDrag } = useNodeDrag() + + startDrag({ clientX: 0, clientY: 0 } as PointerEvent, '1') + + const target = document.createElement('div') + target.hasPointerCapture = vi.fn(() => false) + target.setPointerCapture = vi.fn() + + handleDrag( + { + clientX: 193, + clientY: 0, + target, + pointerId: 1 + } as unknown as PointerEvent, + '1' + ) + + testState.requestAnimationFrameCallback?.(0) + + expect(testState.mutationFns.batchMoveNodes).toHaveBeenCalledWith([ + { nodeId: '1', position: { x: 193, y: 40 } } + ]) + expect(testState.vueDragSnapGuides.value).toEqual([]) + }) + + it('suppresses alignment snapping when grid snapping is active', () => { + testState.settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = true + testState.selectedNodeIds.value = new Set(['1']) + testState.nodeLayouts.set('1', { + position: { x: 0, y: 40 }, + size: { width: 100, height: 60 } + }) + testState.nodeLayouts.set('2', { + position: { x: 200, y: 40 }, + size: { width: 100, height: 60 } + }) + + const { startDrag, handleDrag } = useNodeDrag() + + startDrag({ clientX: 0, clientY: 0 } as PointerEvent, '1') + + const target = document.createElement('div') + target.hasPointerCapture = vi.fn(() => false) + target.setPointerCapture = vi.fn() + + handleDrag( + { + clientX: 193, + clientY: 0, + shiftKey: true, + target, + pointerId: 1 + } as unknown as PointerEvent, + '1' + ) + + testState.requestAnimationFrameCallback?.(0) + + expect(testState.mutationFns.batchMoveNodes).toHaveBeenCalledWith([ + { nodeId: '1', position: { x: 193, y: 40 } } + ]) + expect(testState.vueDragSnapGuides.value).toEqual([]) + }) + + it('does not move an unrelated selection when dragging an unselected node', () => { + testState.settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = true + testState.selectedNodeIds.value = new Set(['2']) + testState.nodeLayouts.set('1', { + position: { x: 0, y: 40 }, + size: { width: 100, height: 60 } + }) + testState.nodeLayouts.set('2', { + position: { x: 200, y: 40 }, + size: { width: 100, height: 60 } + }) + + const { startDrag, handleDrag } = useNodeDrag() + + startDrag({ clientX: 0, clientY: 0 } as PointerEvent, '1') + + const target = document.createElement('div') + target.hasPointerCapture = vi.fn(() => false) + target.setPointerCapture = vi.fn() + + handleDrag( + { + clientX: 193, + clientY: 0, + target, + pointerId: 1 + } as unknown as PointerEvent, + '1' + ) + + testState.requestAnimationFrameCallback?.(0) + + expect(testState.mutationFns.batchMoveNodes).toHaveBeenCalledWith([ + { nodeId: '1', position: { x: 200, y: 40 } } + ]) + }) + + it('snaps unselected drags using only the dragged node bounds', () => { + testState.settingValues['Comfy.Canvas.AlignNodesWhileDragging'] = true + testState.selectedNodeIds.value = new Set(['2', '3']) + testState.nodeLayouts.set('1', { + position: { x: 0, y: 40 }, + size: { width: 100, height: 60 } + }) + testState.nodeLayouts.set('2', { + position: { x: -500, y: 40 }, + size: { width: 100, height: 60 } + }) + testState.nodeLayouts.set('3', { + position: { x: 400, y: 40 }, + size: { width: 100, height: 60 } + }) + testState.nodeLayouts.set('4', { + position: { x: 200, y: 40 }, + size: { width: 100, height: 60 } + }) + + const { startDrag, handleDrag } = useNodeDrag() + + startDrag({ clientX: 0, clientY: 0 } as PointerEvent, '1') + + const target = document.createElement('div') + target.hasPointerCapture = vi.fn(() => false) + target.setPointerCapture = vi.fn() + + handleDrag( + { + clientX: 193, + clientY: 0, + target, + pointerId: 1 + } as unknown as PointerEvent, + '1' + ) + + testState.requestAnimationFrameCallback?.(0) + + expect(testState.mutationFns.batchMoveNodes).toHaveBeenCalledWith([ + { nodeId: '1', position: { x: 200, y: 40 } } + ]) + expect(testState.vueDragSnapGuides.value).toContainEqual({ + axis: 'vertical', + coordinate: 200, + start: 10, + end: 100 + }) + }) + + it('skips redraw when clearing already-empty snap guides', () => { + testState.selectedNodeIds.value = new Set(['1']) + testState.nodeLayouts.set('1', { + position: { x: 50, y: 80 }, + size: { width: 180, height: 110 } + }) + + const { startDrag, handleDrag } = useNodeDrag() + + startDrag( + { + clientX: 5, + clientY: 10 + } as PointerEvent, + '1' + ) + + const target = document.createElement('div') + target.hasPointerCapture = vi.fn(() => false) + target.setPointerCapture = vi.fn() + + handleDrag( + { + clientX: 25, + clientY: 30, + target, + pointerId: 1 + } as unknown as PointerEvent, + '1' + ) + + testState.requestAnimationFrameCallback?.(0) + + expect(testState.canvas.setDirty).not.toHaveBeenCalled() + }) }) diff --git a/src/renderer/extensions/vueNodes/layout/useNodeDrag.ts b/src/renderer/extensions/vueNodes/layout/useNodeDrag.ts index d6f0466d760..03765c787c8 100644 --- a/src/renderer/extensions/vueNodes/layout/useNodeDrag.ts +++ b/src/renderer/extensions/vueNodes/layout/useNodeDrag.ts @@ -1,33 +1,45 @@ import { storeToRefs } from 'pinia' import { toValue } from 'vue' +import { LiteGraph } from '@/lib/litegraph/src/litegraph' +import { useSettingStore } from '@/platform/settings/settingStore' import type { LGraphGroup } from '@/lib/litegraph/src/LGraphGroup' import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' import { useLayoutMutations } from '@/renderer/core/layout/operations/layoutMutations' import { layoutStore } from '@/renderer/core/layout/store/layoutStore' import { LayoutSource } from '@/renderer/core/layout/types' import type { + Bounds, + NodeAlignmentGuide, NodeBoundsUpdate, NodeId, Point } from '@/renderer/core/layout/types' +import { translateBounds } from '@/renderer/core/layout/utils/geometry' import { useNodeSnap } from '@/renderer/extensions/vueNodes/composables/useNodeSnap' import { useShiftKeySync } from '@/renderer/extensions/vueNodes/composables/useShiftKeySync' import { useTransformState } from '@/renderer/core/layout/transform/useTransformState' import { isLGraphGroup } from '@/utils/litegraphUtil' import { createSharedComposable } from '@vueuse/core' +import type { NodeAlignmentSnapResult } from './nodeAlignmentSnap' +import { resolveNodeAlignmentSnap } from './nodeAlignmentSnap' + export const useNodeDrag = createSharedComposable(useNodeDragIndividual) +const SNAP_SEARCH_RADIUS_PX = 96 + function useNodeDragIndividual() { + const canvasStore = useCanvasStore() const mutations = useLayoutMutations() - const { selectedNodeIds, selectedItems } = storeToRefs(useCanvasStore()) + const { selectedNodeIds, selectedItems } = storeToRefs(canvasStore) + const settingStore = useSettingStore() // Get transform utilities from TransformPane if available const transformState = useTransformState() // Snap-to-grid functionality - const { shouldSnap, applySnapToPosition } = useNodeSnap() + const { shouldSnap: shouldSnapToGrid, applySnapToPosition } = useNodeSnap() // Shift key sync for LiteGraph canvas preview const { trackShiftKey } = useShiftKeySync() @@ -36,12 +48,15 @@ function useNodeDragIndividual() { let dragStartPos: Point | null = null let dragStartMouse: Point | null = null let otherSelectedNodesStartPositions: Map | null = null + let pendingDragEvent: PointerEvent | null = null let rafId: number | null = null let stopShiftSync: (() => void) | null = null // For groups: track the last applied canvas delta to compute frame delta let lastCanvasDelta: Point | null = null let selectedGroups: LGraphGroup[] | null = null + let draggedSelectionBounds: Bounds | null = null + let draggedSelectionNodeIds: Set | null = null function startDrag(event: PointerEvent, nodeId: NodeId) { const layout = toValue(layoutStore.getNodeLayoutRef(nodeId)) @@ -53,12 +68,15 @@ function useNodeDragIndividual() { dragStartPos = { ...position } dragStartMouse = { x: event.clientX, y: event.clientY } + pendingDragEvent = null const selectedNodes = toValue(selectedNodeIds) - - // capture the starting positions of all other selected nodes - // Only move other selected items if the dragged node is part of the selection - const isDraggedNodeInSelection = selectedNodes?.has(nodeId) + const isDraggedNodeInSelection = selectedNodes.has(nodeId) + draggedSelectionNodeIds = isDraggedNodeInSelection + ? new Set(selectedNodes) + : new Set([nodeId]) + draggedSelectionBounds = getDraggedSelectionBounds(draggedSelectionNodeIds) + updateDragSnapGuides([]) if (isDraggedNodeInSelection && selectedNodes.size > 1) { otherSelectedNodesStartPositions = new Map() @@ -94,23 +112,28 @@ function useNodeDragIndividual() { return } - // Throttle position updates using requestAnimationFrame for better performance - if (rafId !== null) return // Skip if frame already scheduled - const { target, pointerId } = event if (target instanceof HTMLElement && !target.hasPointerCapture(pointerId)) { // Delay capture to drag to allow for the Node cloning target.setPointerCapture(pointerId) } + pendingDragEvent = event + + // Throttle position updates using requestAnimationFrame for better performance + if (rafId !== null) return // Skip if frame already scheduled + rafId = requestAnimationFrame(() => { rafId = null - if (!dragStartPos || !dragStartMouse) return + if (!dragStartPos || !dragStartMouse || !pendingDragEvent) return + + const dragEvent = pendingDragEvent + pendingDragEvent = null // Calculate mouse delta in screen coordinates const mouseDelta = { - x: event.clientX - dragStartMouse.x, - y: event.clientY - dragStartMouse.y + x: dragEvent.clientX - dragStartMouse.x, + y: dragEvent.clientY - dragStartMouse.y } // Convert to canvas coordinates @@ -120,11 +143,15 @@ function useNodeDragIndividual() { x: canvasWithDelta.x - canvasOrigin.x, y: canvasWithDelta.y - canvasOrigin.y } + const snappedCanvasDelta = maybeResolveAlignmentSnap( + dragEvent, + canvasDelta + ) // Calculate new position for the current node const newPosition = { - x: dragStartPos.x + canvasDelta.x, - y: dragStartPos.y + canvasDelta.y + x: dragStartPos.x + snappedCanvasDelta.x, + y: dragStartPos.y + snappedCanvasDelta.y } // Move drag updates in one transaction to avoid per-node notify fan-out. @@ -140,8 +167,8 @@ function useNodeDragIndividual() { startPos ] of otherSelectedNodesStartPositions) { const newOtherPosition = { - x: startPos.x + canvasDelta.x, - y: startPos.y + canvasDelta.y + x: startPos.x + snappedCanvasDelta.x, + y: startPos.y + snappedCanvasDelta.y } updates.push({ nodeId: otherNodeId, position: newOtherPosition }) } @@ -153,8 +180,8 @@ function useNodeDragIndividual() { // This matches LiteGraph's behavior which uses delta-based movement if (selectedGroups && selectedGroups.length > 0 && lastCanvasDelta) { const frameDelta = { - x: canvasDelta.x - lastCanvasDelta.x, - y: canvasDelta.y - lastCanvasDelta.y + x: snappedCanvasDelta.x - lastCanvasDelta.x, + y: snappedCanvasDelta.y - lastCanvasDelta.y } for (const group of selectedGroups) { @@ -162,13 +189,13 @@ function useNodeDragIndividual() { } } - lastCanvasDelta = canvasDelta + lastCanvasDelta = snappedCanvasDelta }) } function endDrag(event: PointerEvent, nodeId: NodeId | undefined) { // Apply snap to final position if snap was active (matches LiteGraph behavior) - if (shouldSnap(event) && nodeId) { + if (shouldSnapToGrid(event) && nodeId) { const boundsUpdates: NodeBoundsUpdate[] = [] // Snap main node @@ -228,26 +255,171 @@ function useNodeDragIndividual() { } } + cleanupDrag() + } + + function cancelDrag() { + cleanupDrag() + } + + return { + startDrag, + handleDrag, + endDrag, + cancelDrag + } + + function maybeResolveAlignmentSnap( + event: PointerEvent, + canvasDelta: Point + ): Point { + if (!settingStore.get('Comfy.Canvas.AlignNodesWhileDragging')) { + updateDragSnapGuides([]) + return canvasDelta + } + + const isGridSnapActive = shouldSnapToGrid(event) + if ( + isGridSnapActive || + !draggedSelectionBounds || + !draggedSelectionNodeIds + ) { + updateDragSnapGuides([]) + return canvasDelta + } + + const translatedSelectionBounds = translateBounds( + draggedSelectionBounds, + canvasDelta + ) + const searchRadius = SNAP_SEARCH_RADIUS_PX / transformState.camera.z + const candidateBounds = getNearbyAlignmentCandidateBounds( + translatedSelectionBounds, + draggedSelectionNodeIds, + searchRadius + ) + + const snapResult: NodeAlignmentSnapResult = resolveNodeAlignmentSnap({ + selectionBounds: draggedSelectionBounds, + candidateBounds, + delta: canvasDelta, + zoomScale: transformState.camera.z + }) + + updateDragSnapGuides(snapResult.guides) + return snapResult.delta + } + + function getDraggedSelectionBounds(nodeIds: Set): Bounds | null { + const bounds = Array.from(nodeIds) + .map((id) => layoutStore.getNodeLayoutRef(id).value) + .filter((layout): layout is NonNullable => layout !== null) + .map(getRenderedNodeBounds) + + return mergeBounds(bounds) + } + + function getNearbyAlignmentCandidateBounds( + translatedSelectionBounds: Bounds, + selectedNodeSet: Set, + searchRadius: number + ): Bounds[] { + const candidateIds = layoutStore.queryNodesInBounds( + expandBounds(translatedSelectionBounds, searchRadius) + ) + const candidates: Bounds[] = [] + + for (const nodeId of candidateIds) { + if (selectedNodeSet.has(nodeId)) { + continue + } + + const layout = layoutStore.getNodeLayoutRef(nodeId).value + if (!layout) { + continue + } + + candidates.push(getRenderedNodeBounds(layout)) + } + + return candidates + } + + function updateDragSnapGuides(guides: NodeAlignmentGuide[]) { + if (!guides.length && !layoutStore.vueDragSnapGuides.value.length) { + return + } + + layoutStore.vueDragSnapGuides.value = guides + canvasStore.canvas?.setDirty(true) + } + + function cleanupDrag() { dragStartPos = null dragStartMouse = null otherSelectedNodesStartPositions = null + pendingDragEvent = null selectedGroups = null lastCanvasDelta = null + draggedSelectionBounds = null + draggedSelectionNodeIds = null + updateDragSnapGuides([]) - // Stop tracking shift key state stopShiftSync?.() stopShiftSync = null - // Cancel any pending animation frame if (rafId !== null) { cancelAnimationFrame(rafId) rafId = null } } +} + +function getRenderedNodeBounds(layout: { + position: Point + size: { width: number; height: number } +}): Bounds { + const titleHeight = LiteGraph.NODE_TITLE_HEIGHT || 0 + + return { + x: layout.position.x, + y: layout.position.y - titleHeight, + width: layout.size.width, + height: layout.size.height + titleHeight + } +} + +function mergeBounds(boundsList: Bounds[]): Bounds | null { + const [firstBounds, ...remainingBounds] = boundsList + if (!firstBounds) { + return null + } + + let left = firstBounds.x + let top = firstBounds.y + let right = firstBounds.x + firstBounds.width + let bottom = firstBounds.y + firstBounds.height + + for (const bounds of remainingBounds) { + left = Math.min(left, bounds.x) + top = Math.min(top, bounds.y) + right = Math.max(right, bounds.x + bounds.width) + bottom = Math.max(bottom, bounds.y + bounds.height) + } return { - startDrag, - handleDrag, - endDrag + x: left, + y: top, + width: right - left, + height: bottom - top + } +} + +function expandBounds(bounds: Bounds, padding: number): Bounds { + return { + x: bounds.x - padding, + y: bounds.y - padding, + width: bounds.width + padding * 2, + height: bounds.height + padding * 2 } } diff --git a/src/schemas/apiSchema.ts b/src/schemas/apiSchema.ts index 6e4b58ea973..907115953c0 100644 --- a/src/schemas/apiSchema.ts +++ b/src/schemas/apiSchema.ts @@ -466,6 +466,7 @@ const zSettings = z.object({ 'Comfy.RightSidePanel.IsOpen': z.boolean(), 'Comfy.RightSidePanel.ShowErrorsTab': z.boolean(), 'Comfy.Node.AlwaysShowAdvancedWidgets': z.boolean(), + 'Comfy.Canvas.AlignNodesWhileDragging': z.boolean(), 'LiteGraph.Group.SelectChildrenOnClick': z.boolean() })