From c4219d228a72e4f7172d4e426b1ea66d75cc98e3 Mon Sep 17 00:00:00 2001 From: "claude[bot]" <209825114+claude[bot]@users.noreply.github.com> Date: Sun, 27 Sep 2026 00:38:50 -0700 Subject: [PATCH 1/3] fix(nodes): allow shrinking after content growth and tab switches (#18093) --- .../node/resizeContentRatchet.spec.ts | 253 ++++++++++++++++++ .../litegraph/src/LGraphNode.geometry.test.ts | 10 +- .../operations/graphLayoutAttachment.test.ts | 63 ++++- .../operations/graphLayoutAttachment.ts | 7 + src/renderer/core/layout/store/layoutStore.ts | 21 ++ .../useVueNodeResizeTracking.test.ts | 116 +++++++- .../composables/useVueNodeResizeTracking.ts | 2 - 7 files changed, 454 insertions(+), 18 deletions(-) create mode 100644 browser_tests/tests/vueNodes/interactions/node/resizeContentRatchet.spec.ts diff --git a/browser_tests/tests/vueNodes/interactions/node/resizeContentRatchet.spec.ts b/browser_tests/tests/vueNodes/interactions/node/resizeContentRatchet.spec.ts new file mode 100644 index 00000000000..3ebe8170020 --- /dev/null +++ b/browser_tests/tests/vueNodes/interactions/node/resizeContentRatchet.spec.ts @@ -0,0 +1,253 @@ +import { + comfyExpect as expect, + comfyPageFixture as test +} from '@e2e/fixtures/ComfyPage' +import type { ComfyPage } from '@e2e/fixtures/ComfyPage' +import { fitToViewInstant } from '@e2e/fixtures/utils/fitToView' +import { VueNodeFixture } from '@e2e/fixtures/utils/vueNodeFixtures' +import type { NodeId } from '@/types/nodeId' + +/** + * PM-1304 / PM-1312: a Flux2ImageNode (or any node using the autogrow + * dynamic-widget system) can only be resized LARGER, never smaller, once its + * content has required more height. Switching browser tabs away and back + * re-triggers a shared measurement pipeline that re-applies this "can't + * shrink" ratchet to EVERY such node on the canvas at once, not just the one + * touched. + * + * Root cause (see graphLayoutAttachment.ts `refreshNodeGeometry` and + * useVueNodeResizeTracking.ts): the rendered node size is computed as + * `Math.max(explicitSize, contentSize)`, a floor that never decreases, and + * `contentSize` is tracked by a single module-level singleton `ResizeObserver` + * shared by every Vue node. A visibility cycle can repeat those stale + * measurements and re-latch the floor across unrelated nodes. + */ +test.describe( + 'Vue Node resize ratchet on autogrow content growth', + { tag: ['@vue-nodes', '@canvas', '@node'] }, + () => { + test.beforeEach(async ({ comfyPage }) => { + await comfyPage.nodeOps.clearGraph() + }) + + test.afterEach(async ({ comfyPage }) => { + await comfyPage.canvasOps.resetView() + }) + + /** + * Selects the "Flux.2 [pro]" option on a Flux2ImageNode's dynamic-combo + * `model` widget, exposing its `width`/`height`/`images` (autogrow) + * inputs. Mirrors the production widget-value setter interaction path + * (`dynamicComboWidget` in dynamicWidgets.ts), not a test-only shortcut. + */ + async function selectFluxModel( + comfyPage: ComfyPage, + nodeId: NodeId + ): Promise { + await comfyPage.page.evaluate((id) => { + const node = window.app!.canvas.graph!.getNodeById(id) + if (!node) throw new Error(`Node ${id} not found`) + const modelWidget = node.widgets?.find((w) => w.name === 'model') + if (!modelWidget) throw new Error('model widget not found') + modelWidget.value = 'Flux.2 [pro]' + modelWidget.callback?.(modelWidget.value) + }, nodeId) + } + + /** Connects a LoadImage node's IMAGE output to the next empty autogrow + * reference-image slot on a Flux2ImageNode, using the real LiteGraph + * connect() path (exercises the same autogrow onConnectionsChange + * production code a canvas drag would). */ + async function connectNextReferenceImage( + comfyPage: ComfyPage, + fluxNodeId: NodeId, + loadImageNodeId: NodeId + ): Promise { + await comfyPage.page.evaluate( + ({ fluxNodeId, loadImageNodeId }) => { + const graph = window.app!.canvas.graph! + const fluxNode = graph.getNodeById(fluxNodeId) + const loadImage = graph.getNodeById(loadImageNodeId) + if (!fluxNode || !loadImage) throw new Error('Node not found') + const slotIndex = fluxNode.inputs.findIndex( + (input) => + input.name.startsWith('model.images.image_') && !input.link + ) + if (slotIndex === -1) + throw new Error('No empty reference-image slot found') + loadImage.connect(0, fluxNode, slotIndex) + }, + { fluxNodeId, loadImageNodeId } + ) + } + + /** Removes the connected reference image through LiteGraph's production + * disconnect path so the extra autogrow row is no longer intrinsically + * required before attempting to reclaim its height. */ + async function disconnectReferenceImage( + comfyPage: ComfyPage, + fluxNodeId: NodeId + ): Promise { + await comfyPage.page.evaluate((id) => { + const node = window.app!.canvas.graph!.getNodeById(id) + if (!node) throw new Error(`Node ${id} not found`) + const slotIndex = node.inputs.findIndex( + (input) => + input.name.startsWith('model.images.image_') && input.link != null + ) + if (slotIndex === -1) + throw new Error('Connected reference-image slot not found') + node.disconnectInput(slotIndex) + }, fluxNodeId) + } + + test('can shrink a node below a stale content height after it grows (PM-1304)', async ({ + comfyPage + }) => { + const flux = await comfyPage.nodeOps.addNode( + 'Flux2ImageNode', + undefined, + { x: 500, y: 100 } + ) + const loadImage = await comfyPage.nodeOps.addNode( + 'LoadImage', + undefined, + { x: 50, y: 100 } + ) + await comfyPage.nextFrame() + await selectFluxModel(comfyPage, flux.id) + await comfyPage.nextFrame() + + const node = new VueNodeFixture( + comfyPage.vueNodes.getNodeLocator(String(flux.id)) + ) + await expect(node.root).toBeVisible() + + const baseline = (await node.boundingBox())! + + // Connecting the first reference image appends a new empty autogrow + // slot, growing the node's real DOM content beyond its current + // explicit size. + await connectNextReferenceImage(comfyPage, flux.id, loadImage.id) + await comfyPage.nextFrame() + + const getHeight = async () => (await node.boundingBox())?.height ?? -1 + await expect.poll(getHeight).toBeGreaterThan(baseline.height) + const grownHeight = await getHeight() + + // Remove the content that caused the growth. Keeping it connected would + // make grownHeight a real intrinsic minimum rather than a stale floor. + await disconnectReferenceImage(comfyPage, flux.id) + await comfyPage.nextFrame() + + // The user now tries to shrink the node back down via the resize + // handle, dragging well past the original (pre-growth) height. + const handle = node.getResizeHandle('SE') + await handle.hover() + const box = await handle.boundingBox() + if (!box) throw new Error('SE resize handle has no bounding box') + const page = comfyPage.page + await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2) + await page.mouse.down() + await page.mouse.move( + box.x + box.width / 2, + box.y + box.height / 2 - (grownHeight - baseline.height + 60), + { steps: 10 } + ) + await page.mouse.up() + await comfyPage.nextFrame() + + await expect.poll(getHeight).toBeLessThanOrEqual(grownHeight - 20) + }) + + test('a tab-visibility cycle does not block shrinking an untouched node (PM-1312)', async ({ + comfyPage + }) => { + const fluxA = await comfyPage.nodeOps.addNode( + 'Flux2ImageNode', + undefined, + { x: 500, y: 100 } + ) + const fluxB = await comfyPage.nodeOps.addNode( + 'Flux2ImageNode', + undefined, + { x: 500, y: 700 } + ) + const loadImageA = await comfyPage.nodeOps.addNode( + 'LoadImage', + undefined, + { x: 50, y: 100 } + ) + await comfyPage.nextFrame() + await selectFluxModel(comfyPage, fluxA.id) + await selectFluxModel(comfyPage, fluxB.id) + await comfyPage.nextFrame() + await fitToViewInstant(comfyPage) + await comfyPage.nextFrame() + + const nodeA = new VueNodeFixture( + comfyPage.vueNodes.getNodeLocator(String(fluxA.id)) + ) + const nodeB = new VueNodeFixture( + comfyPage.vueNodes.getNodeLocator(String(fluxB.id)) + ) + await expect(nodeA.root).toBeVisible() + await expect(nodeB.root).toBeVisible() + + const getHeightA = async () => (await nodeA.boundingBox())?.height ?? -1 + const getHeightB = async () => (await nodeB.boundingBox())?.height ?? -1 + const baselineB = await getHeightB() + + const resizeBBy = async (deltaY: number) => { + const handle = nodeB.getResizeHandle('SE') + await handle.hover() + const box = await handle.boundingBox() + if (!box) throw new Error('SE resize handle has no bounding box') + const page = comfyPage.page + await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2) + await page.mouse.down() + await page.mouse.move( + box.x + box.width / 2, + box.y + box.height / 2 + deltaY, + { steps: 10 } + ) + await page.mouse.up() + await comfyPage.nextFrame() + } + // Give B explicit room above its intrinsic content floor. The cycle + // below must not prevent reclaiming some of that room. + await resizeBBy(40) + await expect.poll(getHeightB).toBeGreaterThan(baselineB + 20) + + // Only node A is touched: connecting a reference image grows its + // content beyond its current explicit size. + await connectNextReferenceImage(comfyPage, fluxA.id, loadImageA.id) + await comfyPage.nextFrame() + await expect.poll(getHeightA).toBeGreaterThan(0) + + // Simulate switching browser tabs away and back. + await comfyPage.page.evaluate(() => { + Object.defineProperty(document, 'visibilityState', { + configurable: true, + get: () => 'hidden' + }) + document.dispatchEvent(new Event('visibilitychange')) + }) + await comfyPage.nextFrame() + await comfyPage.page.evaluate(() => { + Object.defineProperty(document, 'visibilityState', { + configurable: true, + get: () => 'visible' + }) + document.dispatchEvent(new Event('visibilitychange')) + }) + await comfyPage.nextFrame() + await comfyPage.idleFrames(3) + + const heightBAfterCycle = await getHeightB() + + await resizeBBy(-20) + await expect.poll(getHeightB).toBeLessThan(heightBAfterCycle - 5) + }) + } +) diff --git a/src/lib/litegraph/src/LGraphNode.geometry.test.ts b/src/lib/litegraph/src/LGraphNode.geometry.test.ts index 327811e827f..137464149f9 100644 --- a/src/lib/litegraph/src/LGraphNode.geometry.test.ts +++ b/src/lib/litegraph/src/LGraphNode.geometry.test.ts @@ -179,7 +179,7 @@ describe('layout geometry projection', () => { }) }) - test('keeps measured geometry separate from requested size', () => { + test('lets requested size supersede a stale content measurement', () => { const graph = new LGraph() const node = new LGraphNode('test') node.size = [100, 50] @@ -192,19 +192,19 @@ describe('layout geometry projection', () => { expect([...node.size]).toEqual([100, 50]) expect(node.serialize().size).toEqual([100, 50]) node.setSize([node.size[0] + 90, node.size[1] + 100]) - expect([...node.renderingSize]).toEqual([225, 150]) + expect([...node.renderingSize]).toEqual([190, 150]) const bounds: Rect = [0, 0, 0, 0] node.measure(bounds) expect(bounds).toEqual([ node.pos[0], node.pos[1] - LiteGraph.NODE_TITLE_HEIGHT, - 225, + 190, 150 + LiteGraph.NODE_TITLE_HEIGHT ]) expect(node.serialize().size).toEqual([190, 150]) }) - test('uses the attached graph for geometry and measured content', () => { + test('uses the attached graph when overriding measured content', () => { const attachedGraph = new LGraph() const currentGraph = new LGraph() const node = new LGraphNode('attached') @@ -230,7 +230,7 @@ describe('layout geometry projection', () => { position: { x: 30, y: 40 }, size: { width: 200, height: 80 } }) - expect([...node.renderingSize]).toEqual([225, 90]) + expect([...node.renderingSize]).toEqual([200, 80]) }) }) diff --git a/src/renderer/core/layout/operations/graphLayoutAttachment.test.ts b/src/renderer/core/layout/operations/graphLayoutAttachment.test.ts index 6ca83c90f03..3ac9541a054 100644 --- a/src/renderer/core/layout/operations/graphLayoutAttachment.test.ts +++ b/src/renderer/core/layout/operations/graphLayoutAttachment.test.ts @@ -12,7 +12,9 @@ import { attachNodeLayout, detachGraphLayouts, detachNodeLayout, - setNodePosition + refreshNodeGeometry, + setNodePosition, + setNodeSize } from './graphLayoutAttachment' describe('node layout attachment ownership', () => { @@ -123,3 +125,62 @@ describe('node layout attachment ownership', () => { ]) }) }) + +// PM-1304 / PM-1312: Flux2ImageNode (and any autogrow-widget node) can only be +// resized larger, never smaller, once its content has required more height. +// `refreshNodeGeometry` computes the rendered size as +// `Math.max(explicitSize, contentSize)`, a floor that never decreases even +// when the user explicitly drags the node smaller. Once fixed, the explicit +// size the user set via drag should win over a stale, larger content size. +describe('refreshNodeGeometry non-decreasing content-size floor (PM-1304)', () => { + beforeEach(() => { + layoutStore.resetForTests() + }) + + function nodeFor(graph: LGraph, id: string): LGraphNode { + const node = new LGraphNode(id) + node.id = toNodeId(id) + node.graph = graph + return node + } + + it('lets an explicit resize shrink the node below a previously reported (now stale) content size', () => { + const graph = new LGraph() + const node = nodeFor(graph, 'flux-image-node') + attachNodeLayout(graph, node) + + // Node starts at a small explicit size. + setNodeSize(node, [220, 100]) + expect(refreshNodeGeometry(node)).toEqual([220, 100]) + + // An autogrow widget (e.g. a multiline prompt) reports content that + // needs more height than the explicit size, so the rendered size + // grows to fit it. This part is correct behavior. + layoutStore.reportContentSize(graph.id, node.id, { + width: 220, + height: 400 + }) + expect(refreshNodeGeometry(node)).toEqual([220, 400]) + + // The user now drags the resize handle to shrink the node back down. + // `setNodeSize` is exactly what the resize-drag interaction calls. + setNodeSize(node, [220, 120]) + + // Bug: the rendered size stays pinned to the stale content-size floor + // instead of honoring the user's explicit smaller size. + expect(refreshNodeGeometry(node)).toEqual([220, 120]) + + // ResizeObserver may immediately repeat the pre-resize measurement. It + // must remain suppressed until the content actually changes. + layoutStore.reportContentSize(graph.id, node.id, { + width: 220, + height: 400 + }) + expect(refreshNodeGeometry(node)).toEqual([220, 120]) + layoutStore.reportContentSize(graph.id, node.id, { + width: 220, + height: 401 + }) + expect(refreshNodeGeometry(node)).toEqual([220, 401]) + }) +}) diff --git a/src/renderer/core/layout/operations/graphLayoutAttachment.ts b/src/renderer/core/layout/operations/graphLayoutAttachment.ts index 123a4f57882..d0013f7836a 100644 --- a/src/renderer/core/layout/operations/graphLayoutAttachment.ts +++ b/src/renderer/core/layout/operations/graphLayoutAttachment.ts @@ -225,6 +225,13 @@ function commitNodeSize(node: LGraphNode): void { ) return + // A direct resize is authoritative over the previous DOM measurement. Drop + // that measurement before deriving the rendered size so the node can shrink; + // ResizeObserver reports the content's new size after layout settles. + ;(layoutStore as Partial).clearContentSize?.( + attachment.graphId, + attachment.id + ) resizeNodeLayout(node, { width: projection.size[0], height: projection.size[1] diff --git a/src/renderer/core/layout/store/layoutStore.ts b/src/renderer/core/layout/store/layoutStore.ts index 9dab0ab55f2..fda7184090a 100644 --- a/src/renderer/core/layout/store/layoutStore.ts +++ b/src/renderer/core/layout/store/layoutStore.ts @@ -202,6 +202,7 @@ class LayoutStoreImpl { private linkSegmentLayouts = new Map() // Internal string key: ${linkId}:${rerouteId ?? 'final'} private slotOffsets = new Map() private contentSizes = new Map() + private suppressedContentSizes = new Map() private rerouteLayouts = new Map() // Spatial index managers @@ -409,6 +410,12 @@ class LayoutStoreImpl { reportContentSize(rootGraphId: UUID, nodeId: NodeId, size: Size): void { const key = makeScopedLayoutKey(rootGraphId, nodeId) + const suppressed = this.suppressedContentSizes.get(key) + if (suppressed) { + if (suppressed.width === size.width && suppressed.height === size.height) + return + this.suppressedContentSizes.delete(key) + } const previous = this.contentSizes.get(key) if (previous?.width === size.width && previous.height === size.height) return @@ -416,6 +423,15 @@ class LayoutStoreImpl { this._contentSizeVersion++ } + clearContentSize(rootGraphId: UUID, nodeId: NodeId): void { + const key = makeScopedLayoutKey(rootGraphId, nodeId) + const previous = this.contentSizes.get(key) + if (!previous) return + this.suppressedContentSizes.set(key, previous) + this.contentSizes.delete(key) + this._contentSizeVersion++ + } + /** * Get current version for change detection */ @@ -840,6 +856,9 @@ class LayoutStoreImpl { this.contentSizes.delete(key) this._contentSizeVersion++ } + for (const key of this.suppressedContentSizes.keys()) { + if (key.startsWith(prefix)) this.suppressedContentSizes.delete(key) + } let slotOffsetsDropped = false for (const key of this.slotOffsets.keys()) { if (!key.startsWith(prefix)) continue @@ -964,6 +983,7 @@ class LayoutStoreImpl { this.contentSizes.clear() this._contentSizeVersion++ } + this.suppressedContentSizes.clear() if (this.slotOffsets.size > 0) { this.slotOffsets.clear() this._slotOffsetVersion.value++ @@ -1079,6 +1099,7 @@ class LayoutStoreImpl { this.ynodes.delete(nodeKey) if (this.contentSizes.delete(nodeKey)) this._contentSizeVersion++ + this.suppressedContentSizes.delete(nodeKey) this.slotOffsets.delete(nodeKey) // Link geometry is cleaned up per-link by LLink.disconnect as the node's // connections are severed, so nothing to do here. diff --git a/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts b/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts index a38d4e14f1c..8043430a60e 100644 --- a/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts +++ b/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts @@ -319,7 +319,7 @@ describe('useVueNodeResizeTracking', () => { expect(testState.syncSlotOffsets).toHaveBeenCalledWith(nodeId) }) - it('defers hidden entries and re-observes connected elements when visible', async () => { + it('re-observes hidden elements without re-reporting an unchanged size', async () => { const nodeId = toNodeId('hidden-node') const { entry } = createResizeEntry({ nodeId }) document.body.append(entry.target) @@ -346,18 +346,114 @@ describe('useVueNodeResizeTracking', () => { vi.clearAllMocks() resizeObserverState.callback?.([entry], createObserverMock()) - expect(testState.reportContentSize).toHaveBeenCalledWith( - ROOT_GRAPH_ID, - nodeId, - { - width: 240, - height: 180 - LiteGraph.NODE_TITLE_HEIGHT - } - ) - expect(testState.syncSlotOffsets).toHaveBeenCalledWith(nodeId) + expect(testState.reportContentSize).not.toHaveBeenCalled() + expect(testState.syncSlotOffsets).not.toHaveBeenCalled() entry.target.remove() }) + // PM-1304 / PM-1312: switching tabs away and back re-triggers this shared + // measurement pipeline for every deferred node in one batch, not just the + // node whose content actually grew. This spreads the "can't shrink" + // ratchet from `refreshNodeGeometry` to nodes the user never touched. + it( + "does not re-report an untouched node's unchanged content size after a " + + 'tab-visibility cycle triggered by a different node', + async () => { + const touchedNodeId = toNodeId('touched-node') + const untouchedNodeId = toNodeId('untouched-node') + + const touched = createResizeEntry({ + nodeId: touchedNodeId, + width: 240, + height: 180 + }) + const untouched = createResizeEntry({ + nodeId: untouchedNodeId, + width: 240, + height: 180 + }) + document.body.append(touched.entry.target, untouched.entry.target) + seedNodeLayout({ + nodeId: touchedNodeId, + left: 100, + top: 200, + width: 240, + height: 180 + }) + seedNodeLayout({ + nodeId: untouchedNodeId, + left: 400, + top: 200, + width: 240, + height: 180 + }) + + // Establish a baseline measurement for both nodes. + resizeObserverState.callback?.( + [touched.entry, untouched.entry], + createObserverMock() + ) + vi.clearAllMocks() + + // Tab goes hidden. Both nodes happen to receive a resize-observer + // entry while hidden (e.g. a layout pass unrelated to either node's + // own content), even though only the touched node's autogrow widget + // is actually mid-resize. + vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden') + document.dispatchEvent(new Event('visibilitychange')) + await nextTick() + + const grownTouched = createResizeEntry({ + element: touched.entry.target, + nodeId: touchedNodeId, + width: 240, + height: 500 + }).entry + const unchangedUntouched = createResizeEntry({ + element: untouched.entry.target, + nodeId: untouchedNodeId, + width: 240, + height: 180 + }).entry + resizeObserverState.callback?.( + [grownTouched, unchangedUntouched], + createObserverMock() + ) + expect(testState.reportContentSize).not.toHaveBeenCalled() + vi.clearAllMocks() + + // Tab becomes visible again. + vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('visible') + document.dispatchEvent(new Event('visibilitychange')) + await nextTick() + vi.clearAllMocks() + + // The browser redelivers each node's real, current measurement: the + // touched node genuinely grew; the untouched node's DOM size never + // changed from the baseline measured above. + resizeObserverState.callback?.( + [grownTouched, unchangedUntouched], + createObserverMock() + ) + + expect(testState.reportContentSize).toHaveBeenCalledWith( + ROOT_GRAPH_ID, + touchedNodeId, + { width: 240, height: 500 - LiteGraph.NODE_TITLE_HEIGHT } + ) + + // Bug: the untouched node's identical, already-known measurement is + // re-reported too. The tab-visibility batch cleared its measurement + // cache along with the touched node's, forcing it back through the + // pipeline as if it were a fresh, changed measurement. + expect(testState.reportContentSize).not.toHaveBeenCalledWith( + ROOT_GRAPH_ID, + untouchedNodeId, + expect.anything() + ) + } + ) + it('observes on mount and removes identity before unobserving on unmount', () => { const nodeId = toNodeId('mounted-node') const Component = defineComponent({ diff --git a/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.ts b/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.ts index a97584c22a7..60fdc1dfd65 100644 --- a/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.ts +++ b/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.ts @@ -90,7 +90,6 @@ watch(visibility, (state) => { // Re-observe deferred elements to trigger fresh measurements for (const element of deferredElements) { if (element.isConnected) { - markElementForFreshMeasurement(element) resizeObserver.observe(element) } } @@ -107,7 +106,6 @@ const resizeObserver = new ResizeObserver((entries) => { for (const entry of entries) { if (entry.target instanceof HTMLElement) { deferredElements.add(entry.target) - markElementForFreshMeasurement(entry.target) resizeObserver.unobserve(entry.target) } } From 795c5a9318cc856422fb5ce27d981212b8841cea Mon Sep 17 00:00:00 2001 From: bymyself Date: Sun, 27 Sep 2026 08:02:45 +0000 Subject: [PATCH 2/3] test(nodes): drive mocked visibility on cloud release --- .../vueNodes/composables/useVueNodeResizeTracking.test.ts | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts b/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts index 8043430a60e..f2bff5f94ab 100644 --- a/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts +++ b/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts @@ -399,8 +399,8 @@ describe('useVueNodeResizeTracking', () => { // entry while hidden (e.g. a layout pass unrelated to either node's // own content), even though only the touched node's autogrow widget // is actually mid-resize. - vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden') - document.dispatchEvent(new Event('visibilitychange')) + if (!testState.visibility) throw new Error('visibility ref not initialized') + testState.visibility.value = 'hidden' await nextTick() const grownTouched = createResizeEntry({ @@ -423,8 +423,7 @@ describe('useVueNodeResizeTracking', () => { vi.clearAllMocks() // Tab becomes visible again. - vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('visible') - document.dispatchEvent(new Event('visibilitychange')) + testState.visibility.value = 'visible' await nextTick() vi.clearAllMocks() From e669482acab5726c08754d95a8ea82ffa4e95eb5 Mon Sep 17 00:00:00 2001 From: GitHub Action Date: Sun, 27 Sep 2026 08:04:40 +0000 Subject: [PATCH 3/3] [automated] Apply ESLint and Oxfmt fixes --- .../vueNodes/composables/useVueNodeResizeTracking.test.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts b/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts index f2bff5f94ab..bc139c392bd 100644 --- a/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts +++ b/src/renderer/extensions/vueNodes/composables/useVueNodeResizeTracking.test.ts @@ -399,7 +399,8 @@ describe('useVueNodeResizeTracking', () => { // entry while hidden (e.g. a layout pass unrelated to either node's // own content), even though only the touched node's autogrow widget // is actually mid-resize. - if (!testState.visibility) throw new Error('visibility ref not initialized') + if (!testState.visibility) + throw new Error('visibility ref not initialized') testState.visibility.value = 'hidden' await nextTick()