From 837c025a27c1164919e8affd6f9ec95f7f3d755f Mon Sep 17 00:00:00 2001 From: 0-Soliton-O Date: Wed, 16 Sep 2026 15:08:43 -0700 Subject: [PATCH] fix: keep legacy widget host geometry transient --- .../tests/vueNodes/widgets/legacy.spec.ts | 133 ++++++++++++--- .../widgets/components/WidgetLegacy.vue | 161 +++++++++++++----- 2 files changed, 227 insertions(+), 67 deletions(-) diff --git a/browser_tests/tests/vueNodes/widgets/legacy.spec.ts b/browser_tests/tests/vueNodes/widgets/legacy.spec.ts index f1200f71026..637b7167699 100644 --- a/browser_tests/tests/vueNodes/widgets/legacy.spec.ts +++ b/browser_tests/tests/vueNodes/widgets/legacy.spec.ts @@ -64,7 +64,7 @@ test.describe( } ) -test('@vue-nodes In App Mode, widget width updates with panel size', async ({ +test('@vue-nodes In App Mode, legacy widget host geometry stays transient', async ({ comfyPage, comfyMouse }) => { @@ -80,53 +80,130 @@ test('@vue-nodes In App Mode, widget width updates with panel size', async ({ } ) legacyNodeId = legacyNode.id - await comfyPage.appMode.enterAppModeWithInputs([ - [String(legacyNodeId), 'legacy_widget'] - ]) }) - const getRenderedWidth = async () => - (await comfyPage.appMode.linearWidgets.locator('canvas').boundingBox()) - ?.width ?? 0 - const getWidgetWidth = () => + const getGeometry = () => comfyPage.page.evaluate((nodeId) => { - const widget = window - .app!.rootGraph.getNodeById(nodeId) - ?.widgets?.find((widget) => widget.name === 'legacy_widget') - return widget?.width ?? 0 + const node = window.app!.rootGraph.getNodeById(nodeId) + const widget = node?.widgets?.find( + (widget) => widget.name === 'legacy_widget' + ) + return { + hasOwnWidth: widget ? Object.hasOwn(widget, 'width') : false, + width: widget?.width ?? null, + y: widget?.y ?? null, + canvasHeight: + (node as typeof node & { canvasHeight?: number }).canvasHeight ?? null + } }, legacyNodeId) - await test.step('Mouse clicks resolve to button regions', async () => { - const legacyWidget = comfyPage.appMode.linearWidgets.locator('canvas') + const initialGeometry = await getGeometry() + + await comfyPage.appMode.enterAppModeWithInputs([ + [String(legacyNodeId), 'legacy_widget'] + ]) + + const legacyWidget = comfyPage.appMode.linearWidgets.locator('canvas') + const nodeRef = await comfyPage.nodeOps.getNodeRefById(legacyNodeId) + const legacyWidgetRef = await nodeRef.getWidget(0) + + await test.step('Mouse clicks resolve to host button regions', async () => { await expect(legacyWidget).toBeVisible() const { width, height } = (await legacyWidget.boundingBox())! - const nodeRef = await comfyPage.nodeOps.getNodeRefById(legacyNodeId) - const legacyWidgetRef = await nodeRef.getWidget(0) expect(await legacyWidgetRef.getValue()).toBe(0) + await legacyWidget.click({ position: { x: 20, y: height / 2 } }) await expect.poll(() => legacyWidgetRef.getValue()).toBe(-1) + await legacyWidget.click({ position: { x: width - 20, y: height / 2 } }) await expect.poll(() => legacyWidgetRef.getValue()).toBe(0) - }) - await test.step('Resize to update width', async () => { - await expect.poll(getRenderedWidth).toBeGreaterThan(0) - await expect.poll(getWidgetWidth).toBeGreaterThan(0) - const initialRenderedWidth = await getRenderedWidth() - const initialWidgetWidth = await getWidgetWidth() + await expect.poll(getGeometry).toEqual(initialGeometry) + }) + await test.step('Panel resize changes host geometry without persisting it', async () => { + const initialRenderedWidth = (await legacyWidget.boundingBox())!.width const gutter = comfyPage.page.getByRole('separator') await expect(gutter).toBeVisible() await comfyMouse.dragElementBy(gutter, { x: -200 }) - await expect.poll(getRenderedWidth).toBeGreaterThan(initialRenderedWidth) - await expect.poll(getWidgetWidth).toBeGreaterThan(initialWidgetWidth) - const intermediateRenderedWidth = await getRenderedWidth() - const intermediateWidgetWidth = await getWidgetWidth() + + await expect + .poll(async () => (await legacyWidget.boundingBox())?.width ?? 0) + .toBeGreaterThan(initialRenderedWidth) + + await expect.poll(getGeometry).toEqual(initialGeometry) + + const intermediateRenderedWidth = (await legacyWidget.boundingBox())!.width + const { width, height } = (await legacyWidget.boundingBox())! + + await legacyWidget.click({ position: { x: width - 20, y: height / 2 } }) + await expect.poll(() => legacyWidgetRef.getValue()).toBe(1) + await expect.poll(getGeometry).toEqual(initialGeometry) await comfyMouse.dragElementBy(gutter, { x: 100 }) - await expect.poll(getRenderedWidth).toBeLessThan(intermediateRenderedWidth) - await expect.poll(getWidgetWidth).toBeLessThan(intermediateWidgetWidth) + + await expect + .poll(async () => (await legacyWidget.boundingBox())?.width ?? 0) + .toBeLessThan(intermediateRenderedWidth) + + await expect.poll(getGeometry).toEqual(initialGeometry) + }) +}) + +test('@vue-nodes Properties panel does not persist legacy widget host geometry', async ({ + comfyPage +}) => { + let legacyNodeId = toNodeId(10) + + await test.step('setup', async () => { + const legacyNode = await comfyPage.nodeOps.addNode( + 'DevToolsNodeWithLegacyWidget', + undefined, + { + x: 0, + y: 0 + } + ) + legacyNodeId = legacyNode.id }) + + const getGeometry = () => + comfyPage.page.evaluate((nodeId) => { + const node = window.app!.rootGraph.getNodeById(nodeId) + const widget = node?.widgets?.find( + (widget) => widget.name === 'legacy_widget' + ) + return { + hasOwnWidth: widget ? Object.hasOwn(widget, 'width') : false, + width: widget?.width ?? null, + y: widget?.y ?? null, + canvasHeight: + (node as typeof node & { canvasHeight?: number }).canvasHeight ?? null + } + }, legacyNodeId) + + const initialGeometry = await getGeometry() + const nodeRef = await comfyPage.nodeOps.getNodeRefById(legacyNodeId) + const legacyWidgetRef = await nodeRef.getWidget(0) + + await comfyPage.actionbar.propertiesButton.click() + await comfyPage.nodeOps.selectNodes(['Node With Legacy Widget']) + + const legacyWidget = comfyPage.page + .getByTestId(TestIds.propertiesPanel.root) + .locator('canvas') + + await expect(legacyWidget).toBeVisible() + await expect.poll(getGeometry).toEqual(initialGeometry) + + const { width, height } = (await legacyWidget.boundingBox())! + + expect(await legacyWidgetRef.getValue()).toBe(0) + + await legacyWidget.click({ position: { x: width - 20, y: height / 2 } }) + await expect.poll(() => legacyWidgetRef.getValue()).toBe(1) + + await expect.poll(getGeometry).toEqual(initialGeometry) }) diff --git a/src/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue b/src/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue index 893b5d40270..37dd645fc2f 100644 --- a/src/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue +++ b/src/renderer/extensions/vueNodes/widgets/components/WidgetLegacy.vue @@ -29,6 +29,8 @@ let widgetInstance: IBaseWidget | undefined let pointer: CanvasPointer | undefined const scaleFactor = 2 +type LegacyWidgetNode = LGraphNode & { canvasHeight?: number } + function findLegacyWidget(): | { node: LGraphNode @@ -76,54 +78,135 @@ onBeforeUnmount(() => { whenever(() => !canvasStore.linearMode, bindWidget) watch(() => canvasStore.currentGraph, bindWidget) -function draw() { - if (!widgetInstance || !node) return +function withHostWidgetGeometry( + widget: IBaseWidget, + hostNode: LGraphNode, + callback: (width: number, legacyNode: LegacyWidgetNode) => T, + hostHeight?: number +): T | undefined { + const parent = canvasEl.value?.parentElement + if (!parent) return + + const legacyNode = hostNode as LegacyWidgetNode + const hadWidth = Object.hasOwn(widget, 'width') + const previousWidth = widget.width + const previousY = widget.y + const hadCanvasHeight = Object.hasOwn(legacyNode, 'canvasHeight') + const previousCanvasHeight = legacyNode.canvasHeight const width = - canvasEl.value.getBoundingClientRect().width || - canvasEl.value.parentElement.clientWidth - // Priority: computedHeight (from litegraph) > computeLayoutSize > computeSize - let height = 20 - if (widgetInstance.computedHeight) { - height = widgetInstance.computedHeight - } else if (widgetInstance.computeLayoutSize) { - height = widgetInstance.computeLayoutSize(node).minHeight - } else if (widgetInstance.computeSize) { - height = widgetInstance.computeSize(width)[1] + canvasEl.value.getBoundingClientRect().width || parent.clientWidth + + // Host geometry is ephemeral renderer-local state, not authoritative graph + // layout. Borrow it only for this synchronous operation and restore it below. + widget.width = width + widget.y = 0 + if (hostHeight !== undefined) legacyNode.canvasHeight = hostHeight + + try { + return callback(width, legacyNode) + } finally { + if (hadWidth) widget.width = previousWidth + else delete widget.width + widget.y = previousY + if (hadCanvasHeight) legacyNode.canvasHeight = previousCanvasHeight + else delete legacyNode.canvasHeight } - containerHeight.value = height - // Set node.canvasHeight for legacy widgets that use it (e.g., Impact Pack) - // @ts-expect-error canvasHeight is a custom property used by some extensions - node.canvasHeight = height - widgetInstance.y = 0 - widgetInstance.width = width - canvasEl.value.height = (height + 2) * scaleFactor - canvasEl.value.width = width * scaleFactor - const ctx = canvasEl.value?.getContext('2d') - if (!ctx) return - ctx.scale(scaleFactor, scaleFactor) - widgetInstance.draw?.(ctx, node, width, 1, height) } + +function draw() { + const currentWidget = widgetInstance + const currentNode = node + if (!currentWidget || !currentNode) return + + withHostWidgetGeometry(currentWidget, currentNode, (width, legacyNode) => { + // Priority: computedHeight (from litegraph) > computeLayoutSize > computeSize + let height = 20 + if (currentWidget.computedHeight) { + height = currentWidget.computedHeight + } else if (currentWidget.computeLayoutSize) { + height = currentWidget.computeLayoutSize(currentNode).minHeight + } else if (currentWidget.computeSize) { + height = currentWidget.computeSize(width)[1] + } + containerHeight.value = height + // Legacy custom widgets such as Impact Pack read this during drawing. + legacyNode.canvasHeight = height + canvasEl.value.height = (height + 2) * scaleFactor + canvasEl.value.width = width * scaleFactor + const ctx = canvasEl.value?.getContext('2d') + if (!ctx) return + ctx.scale(scaleFactor, scaleFactor) + currentWidget.draw?.(ctx, currentNode, width, 1, height) + }) +} + //See LGraphCanvas.processWidgetClick function handleDown(e: PointerEvent) { - if (!node || !widgetInstance || !pointer) return - augmentToCanvasPointerEvent(e, node, canvas) - pointer.down(e) - if (widgetInstance.mouse) - pointer.onDrag = (e) => - widgetInstance!.mouse?.(e, [e.offsetX, e.offsetY], node!) - //NOTE: a mouseUp event is already registed under pointer.finally - canvas.processWidgetClick(e, node, widgetInstance, pointer) + const currentNode = node + const currentWidget = widgetInstance + const currentPointer = pointer + if (!currentNode || !currentWidget || !currentPointer) return + + withHostWidgetGeometry( + currentWidget, + currentNode, + () => { + augmentToCanvasPointerEvent(e, currentNode, canvas) + currentPointer.down(e) + if (currentWidget.mouse) + currentPointer.onDrag = (e) => + withHostWidgetGeometry( + currentWidget, + currentNode, + () => currentWidget.mouse?.(e, [e.offsetX, e.offsetY], currentNode), + containerHeight.value + ) + //NOTE: a mouseUp event is already registed under pointer.finally + canvas.processWidgetClick(e, currentNode, currentWidget, currentPointer) + }, + containerHeight.value + ) } + function handleUp(e: PointerEvent) { - if (!pointer || !node) return - augmentToCanvasPointerEvent(e, node, canvas) - e.click_time = e.timeStamp - (pointer.eDown?.timeStamp ?? 0) - pointer.up(e) + const currentPointer = pointer + const currentNode = node + const currentWidget = widgetInstance + if (!currentPointer || !currentNode) return + + augmentToCanvasPointerEvent(e, currentNode, canvas) + e.click_time = e.timeStamp - (currentPointer.eDown?.timeStamp ?? 0) + + if (currentWidget) { + withHostWidgetGeometry( + currentWidget, + currentNode, + () => currentPointer.up(e), + containerHeight.value + ) + } else { + currentPointer.up(e) + } } + function handleMove(e: PointerEvent) { - if (!pointer || !node) return - augmentToCanvasPointerEvent(e, node, canvas) - pointer.move(e) + const currentPointer = pointer + const currentNode = node + const currentWidget = widgetInstance + if (!currentPointer || !currentNode) return + + augmentToCanvasPointerEvent(e, currentNode, canvas) + + if (currentWidget) { + withHostWidgetGeometry( + currentWidget, + currentNode, + () => currentPointer.move(e), + containerHeight.value + ) + } else { + currentPointer.move(e) + } }