From 792dc9b6f8cc28dfdd94aebd2ac1f738d90770c0 Mon Sep 17 00:00:00 2001 From: Terry Jia Date: Tue, 25 Aug 2026 23:22:57 -0400 Subject: [PATCH 1/3] refactor(compositor): make compositorWidgets a typed store boundary --- .../composables/compositorSave.test.ts | 61 ++++++------ .../composables/compositorWidgets.test.ts | 94 +++++++++++-------- .../composables/compositorWidgets.ts | 31 +++--- .../composables/useCompositorAutoSave.test.ts | 66 +++++++------ 4 files changed, 145 insertions(+), 107 deletions(-) diff --git a/src/renderer/extensions/compositor/composables/compositorSave.test.ts b/src/renderer/extensions/compositor/composables/compositorSave.test.ts index ef6c8623de0..fc8eddc62ab 100644 --- a/src/renderer/extensions/compositor/composables/compositorSave.test.ts +++ b/src/renderer/extensions/compositor/composables/compositorSave.test.ts @@ -3,8 +3,10 @@ import { beforeEach, describe, expect, it, vi } from 'vitest' import { defaultMode } from '@/renderer/extensions/layerEditor/engine/mode' import type { RasterData } from '@/renderer/extensions/layerEditor/engine/node' import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode' -import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets' +import { useWidgetValueStore } from '@/stores/widgetValueStore' import { toNodeId } from '@/types/nodeId' +import { widgetId } from '@/types/widgetId' +import { createMockLGraphNode } from '@/utils/__tests__/litegraphTestUtils' import type { CompositorLayerState } from './compositorLayerState' import { @@ -48,24 +50,29 @@ function makeSession() { } } -function makeNode() { - const compositorWidget = { - name: 'compositor', - value: {}, - callback: vi.fn() - } as unknown as IBaseWidget - const node = { - id: toNodeId(7), - widgets: [compositorWidget], - widgets_values: [{}] - } as unknown as LGraphNode - return { node, compositorWidget } +const GRAPH_ID = 'compositor-save-test' +const NODE_ID = toNodeId(7) + +function makeNode(): { node: LGraphNode } { + useWidgetValueStore().registerWidget( + widgetId(GRAPH_ID, NODE_ID, 'compositor'), + { type: 'compositor', value: {}, options: {} } + ) + const node = createMockLGraphNode({ + id: NODE_ID, + graph: { rootGraph: { id: GRAPH_ID } } + }) + return { node } } -function widgetValue(widget: IBaseWidget): CompositorLayerState { - return widget.value as CompositorLayerState +function storedValue(): CompositorLayerState { + return useWidgetValueStore().getWidget( + widgetId(GRAPH_ID, NODE_ID, 'compositor') + )?.value as CompositorLayerState } +const setValueSpy = () => vi.mocked(useWidgetValueStore().setValue) + const cacheNode = { id: toNodeId(7) } as unknown as LGraphNode beforeEach(() => { @@ -84,14 +91,11 @@ describe('saveCompositorLayerState', () => { it('writes the layer state recipe to the compositor widget', () => { cacheFingerprint() const session = makeSession() - const { node, compositorWidget } = makeNode() + const { node } = makeNode() expect(saveCompositorLayerState(session, node)).toBe(true) - const savedState = widgetValue(compositorWidget) - expect(compositorWidget.callback).toHaveBeenCalledWith(savedState) - expect(node.widgets_values?.[0]).toBe(compositorWidget.value) - + const savedState = storedValue() expect(savedState.canvas).toEqual({ w: 64, h: 48 }) expect(savedState.layers).toHaveLength(1) expect(savedState.layers[0]).toMatchObject({ @@ -109,20 +113,20 @@ describe('saveCompositorLayerState', () => { [{ filename: 'a.png', subfolder: '', type: 'temp' }], ['hash-a', 'hash-b'] ) - const { node, compositorWidget } = makeNode() + const { node } = makeNode() saveCompositorLayerState(makeSession(), node) - expect(widgetValue(compositorWidget).inputs).toEqual(['hash-a', 'hash-b']) + expect(storedValue().inputs).toEqual(['hash-a', 'hash-b']) }) it('refuses to save when no fingerprint is cached', () => { - const { node, compositorWidget } = makeNode() + const { node } = makeNode() expect(saveCompositorLayerState(makeSession(), node)).toBe(false) - expect(compositorWidget.callback).not.toHaveBeenCalled() - expect(node.widgets_values).toEqual([{}]) + expect(setValueSpy()).not.toHaveBeenCalled() + expect(storedValue()).toEqual({}) }) it('keeps widgets untouched when extraction fails', () => { @@ -131,13 +135,12 @@ describe('saveCompositorLayerState', () => { session.layerFlips = () => { throw new Error('boom') } - const { node, compositorWidget } = makeNode() + const { node } = makeNode() expect(saveCompositorLayerState(session, node)).toBe(false) - expect(compositorWidget.callback).not.toHaveBeenCalled() - expect(compositorWidget.value).toEqual({}) - expect(node.widgets_values).toEqual([{}]) + expect(setValueSpy()).not.toHaveBeenCalled() + expect(storedValue()).toEqual({}) }) }) diff --git a/src/renderer/extensions/compositor/composables/compositorWidgets.test.ts b/src/renderer/extensions/compositor/composables/compositorWidgets.test.ts index 4273ea394c5..d8ac9dbf655 100644 --- a/src/renderer/extensions/compositor/composables/compositorWidgets.test.ts +++ b/src/renderer/extensions/compositor/composables/compositorWidgets.test.ts @@ -1,7 +1,10 @@ -import { describe, expect, it, vi } from 'vitest' +import { describe, expect, it } from 'vitest' import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode' -import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets' +import { useWidgetValueStore } from '@/stores/widgetValueStore' +import { toNodeId } from '@/types/nodeId' +import { widgetId } from '@/types/widgetId' +import { createMockLGraphNode } from '@/utils/__tests__/litegraphTestUtils' import { getCompositorWidgetValue, @@ -9,73 +12,88 @@ import { setCompositorWidgetValue } from './compositorWidgets' -function makeNode() { - const compositorWidget = { - name: 'compositor', - value: { layers: [] }, - callback: vi.fn() - } as unknown as IBaseWidget - const otherWidget = { - name: 'other', - value: 42, - callback: vi.fn() - } as unknown as IBaseWidget - const node = { - widgets: [otherWidget, compositorWidget], - widgets_values: [42, { layers: [] }] - } as unknown as LGraphNode - return { node, compositorWidget, otherWidget } +const GRAPH_ID = 'compositor-test-graph' + +let nodeCounter = 0 + +function makeNode({ registered = true } = {}): LGraphNode { + nodeCounter += 1 + const nodeId = toNodeId(nodeCounter) + if (registered) { + useWidgetValueStore().registerWidget( + widgetId(GRAPH_ID, nodeId, 'compositor'), + { type: 'compositor', value: { layers: [] }, options: {} } + ) + } + return createMockLGraphNode({ + id: nodeId, + graph: { rootGraph: { id: GRAPH_ID } } + }) +} + +function storedValue(node: LGraphNode): unknown { + return useWidgetValueStore().getWidget( + widgetId(GRAPH_ID, node.id, 'compositor') + )?.value } describe('setCompositorWidgetValue', () => { - it('writes the widget value, fires its callback, and syncs widgets_values', () => { - const { node, compositorWidget } = makeNode() + it('writes the widget value to the store', () => { + const node = makeNode() const next = { canvas: { w: 8, h: 8 }, layers: [] } setCompositorWidgetValue(node, next) - expect(compositorWidget.value).toEqual(next) - expect(compositorWidget.callback).toHaveBeenCalledWith(next) - expect(node.widgets_values?.[1]).toEqual(next) + expect(storedValue(node)).toEqual(next) }) - it('is a no-op when the compositor widget is missing', () => { - const { node, otherWidget } = makeNode() - node.widgets = [otherWidget] - node.widgets_values = [42] + it('falls back to the widget object when the store has no entry (detached node)', () => { + const node = makeNode({ registered: false }) + const widget = { name: 'compositor', value: { layers: [] } } + node.widgets = [widget as never] + const next = { canvas: { w: 4, h: 4 }, layers: [] } + + setCompositorWidgetValue(node, next) + + expect(widget.value).toEqual(next) + expect(getCompositorWidgetValue(node)).toEqual(next) + }) + + it('is a no-op when the widget exists nowhere', () => { + const node = makeNode({ registered: false }) setCompositorWidgetValue(node, { layers: [] }) - expect(otherWidget.value).toBe(42) - expect(node.widgets_values).toEqual([42]) + expect(storedValue(node)).toBeUndefined() }) }) describe('getCompositorWidgetValue', () => { it('returns the widget value when it has the expected shape', () => { - const { node } = makeNode() + const node = makeNode() expect(getCompositorWidgetValue(node)).toEqual({ layers: [] }) }) it('returns null for missing widgets or malformed values', () => { - const { node, compositorWidget } = makeNode() - compositorWidget.value = 'legacy-string' + const node = makeNode() + useWidgetValueStore().setValue( + widgetId(GRAPH_ID, node.id, 'compositor'), + 'legacy-string' + ) expect(getCompositorWidgetValue(node)).toBeNull() - node.widgets = [] - expect(getCompositorWidgetValue(node)).toBeNull() + expect(getCompositorWidgetValue(makeNode({ registered: false }))).toBeNull() }) }) describe('resetCompositorStateWidgets', () => { it('resets the compositor widget to the empty value durably', () => { - const { node, compositorWidget } = makeNode() + const node = makeNode() + setCompositorWidgetValue(node, { canvas: { w: 8, h: 8 }, layers: [] }) resetCompositorStateWidgets(node) - expect(compositorWidget.value).toEqual({}) - expect(compositorWidget.callback).toHaveBeenCalledWith({}) - expect(node.widgets_values).toEqual([42, {}]) + expect(storedValue(node)).toEqual({}) }) }) diff --git a/src/renderer/extensions/compositor/composables/compositorWidgets.ts b/src/renderer/extensions/compositor/composables/compositorWidgets.ts index e6b661514c3..83f90955843 100644 --- a/src/renderer/extensions/compositor/composables/compositorWidgets.ts +++ b/src/renderer/extensions/compositor/composables/compositorWidgets.ts @@ -1,29 +1,38 @@ +import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode' import { emptyCompositorWidgetValue, isCompositorWidgetValue } from '@/renderer/extensions/compositor/components/types' import type { CompositorWidgetValue } from '@/renderer/extensions/compositor/components/types' -import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode' +import { useWidgetValueStore } from '@/stores/widgetValueStore' +import type { WidgetId } from '@/types/widgetId' +import { widgetId } from '@/types/widgetId' + +const COMPOSITOR_WIDGET = 'compositor' + +function compositorWidgetId(node: LGraphNode): WidgetId | null { + const graphId = node.graph?.rootGraph?.id + return graphId ? widgetId(graphId, node.id, COMPOSITOR_WIDGET) : null +} export function setCompositorWidgetValue( node: LGraphNode, value: CompositorWidgetValue ): void { - const widget = node.widgets?.find((w) => w.name === 'compositor') - if (!widget) return - widget.value = value - widget.callback?.(value) - if (node.widgets_values && node.widgets) { - const index = node.widgets.indexOf(widget) - if (index >= 0) node.widgets_values[index] = value - } + const id = compositorWidgetId(node) + if (id && useWidgetValueStore().setValue(id, value)) return + const widget = node.widgets?.find((w) => w.name === COMPOSITOR_WIDGET) + if (widget) widget.value = value } export function getCompositorWidgetValue( node: LGraphNode ): CompositorWidgetValue | null { - const widget = node.widgets?.find((w) => w.name === 'compositor') - return isCompositorWidgetValue(widget?.value) ? widget.value : null + const id = compositorWidgetId(node) + const value = + (id ? useWidgetValueStore().getWidget(id)?.value : undefined) ?? + node.widgets?.find((w) => w.name === COMPOSITOR_WIDGET)?.value + return isCompositorWidgetValue(value) ? value : null } export function resetCompositorStateWidgets(node: LGraphNode): void { diff --git a/src/renderer/extensions/compositor/composables/useCompositorAutoSave.test.ts b/src/renderer/extensions/compositor/composables/useCompositorAutoSave.test.ts index 8d6e9e58239..c6fd6165397 100644 --- a/src/renderer/extensions/compositor/composables/useCompositorAutoSave.test.ts +++ b/src/renderer/extensions/compositor/composables/useCompositorAutoSave.test.ts @@ -1,15 +1,20 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' -import { Dirty } from '@/renderer/extensions/layerEditor/engine/history' import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode' -import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets' +import { Dirty } from '@/renderer/extensions/layerEditor/engine/history' +import { useWidgetValueStore } from '@/stores/widgetValueStore' import { toNodeId } from '@/types/nodeId' +import { widgetId } from '@/types/widgetId' +import { createMockLGraphNode } from '@/utils/__tests__/litegraphTestUtils' +import { useCompositorAutoSave } from './useCompositorAutoSave' import { clearCompositorLayers, setCompositorLayers } from './useCompositorLayers' -import { useCompositorAutoSave } from './useCompositorAutoSave' + +const GRAPH_ID = 'compositor-autosave-test' +const NODE_ID = toNodeId(7) function makeSession() { const listeners = new Set<(mask: number) => void>() @@ -32,21 +37,24 @@ function makeSession() { } } -function makeNode() { - const compositorWidget = { - name: 'compositor', - value: {}, - callback: vi.fn() - } as unknown as IBaseWidget - const node = { - id: toNodeId(7), - widgets: [compositorWidget], - widgets_values: [{}] - } as unknown as LGraphNode - return { node, compositorWidget } +function makeNode(): LGraphNode { + useWidgetValueStore().registerWidget( + widgetId(GRAPH_ID, NODE_ID, 'compositor'), + { type: 'compositor', value: {}, options: {} } + ) + return createMockLGraphNode({ + id: NODE_ID, + graph: { rootGraph: { id: GRAPH_ID } } + }) } -const cacheNode = { id: toNodeId(7) } as unknown as LGraphNode +const storedValue = () => + useWidgetValueStore().getWidget(widgetId(GRAPH_ID, NODE_ID, 'compositor')) + ?.value + +const setValueSpy = () => vi.mocked(useWidgetValueStore().setValue) + +const cacheNode = { id: NODE_ID } as unknown as LGraphNode beforeEach(() => { setCompositorLayers( @@ -64,34 +72,34 @@ describe('useCompositorAutoSave', () => { it('leaves the widget untouched when no fingerprint is cached', () => { clearCompositorLayers(cacheNode) const session = makeSession() - const { node, compositorWidget } = makeNode() + const node = makeNode() useCompositorAutoSave(session, node) session.emitHistoryChange() vi.advanceTimersByTime(2000) - expect(compositorWidget.callback).not.toHaveBeenCalled() - expect(node.widgets_values).toEqual([{}]) + expect(setValueSpy()).not.toHaveBeenCalled() + expect(storedValue()).toEqual({}) }) it('debounces history changes into a single widget write', () => { const session = makeSession() - const { node, compositorWidget } = makeNode() + const node = makeNode() useCompositorAutoSave(session, node) session.emitHistoryChange() session.emitHistoryChange() session.emitHistoryChange() - expect(compositorWidget.callback).not.toHaveBeenCalled() + expect(setValueSpy()).not.toHaveBeenCalled() vi.advanceTimersByTime(300) - expect(compositorWidget.callback).toHaveBeenCalledTimes(1) - expect(compositorWidget.value).toMatchObject({ canvas: { w: 8, h: 8 } }) + expect(setValueSpy()).toHaveBeenCalledTimes(1) + expect(storedValue()).toMatchObject({ canvas: { w: 8, h: 8 } }) }) it('saves again for edits after the debounce window', () => { const session = makeSession() - const { node, compositorWidget } = makeNode() + const node = makeNode() useCompositorAutoSave(session, node) session.emitHistoryChange() @@ -99,23 +107,23 @@ describe('useCompositorAutoSave', () => { session.emitHistoryChange() vi.advanceTimersByTime(300) - expect(compositorWidget.callback).toHaveBeenCalledTimes(2) + expect(setValueSpy()).toHaveBeenCalledTimes(2) }) it('ignores selection-only history changes', () => { const session = makeSession() - const { node, compositorWidget } = makeNode() + const node = makeNode() useCompositorAutoSave(session, node) session.emitHistoryChange(Dirty.SELECTION) vi.advanceTimersByTime(300) - expect(compositorWidget.callback).not.toHaveBeenCalled() + expect(setValueSpy()).not.toHaveBeenCalled() }) it('stop() cancels pending saves and unsubscribes', () => { const session = makeSession() - const { node, compositorWidget } = makeNode() + const node = makeNode() const autoSave = useCompositorAutoSave(session, node) session.emitHistoryChange() @@ -125,6 +133,6 @@ describe('useCompositorAutoSave', () => { session.emitHistoryChange() vi.advanceTimersByTime(300) - expect(compositorWidget.callback).not.toHaveBeenCalled() + expect(setValueSpy()).not.toHaveBeenCalled() }) }) From 6d5982e33dd8778aa826ac699c8ea4cf30634b3c Mon Sep 17 00:00:00 2001 From: Amp Date: Fri, 28 Aug 2026 17:19:25 +0000 Subject: [PATCH 2/3] test: align compositor stale-state expectations Amp-Thread-ID: https://ampcode.com/threads/T-01a046a2-8a22-70ea-b2d8-5b30abda8862 --- src/extensions/core/imageCompositor.test.ts | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/extensions/core/imageCompositor.test.ts b/src/extensions/core/imageCompositor.test.ts index 5d3bc8247ff..680312fe3e6 100644 --- a/src/extensions/core/imageCompositor.test.ts +++ b/src/extensions/core/imageCompositor.test.ts @@ -32,8 +32,7 @@ function makeNode() { const savedValue = { layers: [] } const compositorWidget = { name: 'compositor', - value: savedValue, - callback: vi.fn() + value: savedValue } as unknown as IBaseWidget const priorOnExecuted = vi.fn() const priorOnRemoved = vi.fn() @@ -45,7 +44,6 @@ function makeNode() { onRemoved: priorOnRemoved, constructor: { comfyClass: 'ImageCompositor' }, widgets: [compositorWidget], - widgets_values: [savedValue], graph: { setDirtyCanvas: vi.fn() } } as unknown as LGraphNode return { node, compositorWidget, priorOnExecuted, priorOnRemoved } @@ -144,8 +142,6 @@ describe('ImageCompositor extension', () => { }) expect(compositorWidget.value).toEqual({}) - expect(compositorWidget.callback).toHaveBeenCalledWith({}) - expect(node.widgets_values).toEqual([{}]) expect(node.graph?.setDirtyCanvas).toHaveBeenCalled() }) From 773c39b7f762a1f2a3f0523dd9d5d52ad8c2527f Mon Sep 17 00:00:00 2001 From: Amp Date: Fri, 28 Aug 2026 17:23:20 +0000 Subject: [PATCH 3/3] test: tighten compositor widget fixtures Amp-Thread-ID: https://ampcode.com/threads/T-01a046a2-8a22-70ea-b2d8-5b30abda8862 --- .../composables/compositorSave.test.ts | 35 +++++++++---------- .../composables/compositorWidgets.test.ts | 12 +++++-- .../composables/useCompositorAutoSave.test.ts | 16 ++++----- 3 files changed, 33 insertions(+), 30 deletions(-) diff --git a/src/renderer/extensions/compositor/composables/compositorSave.test.ts b/src/renderer/extensions/compositor/composables/compositorSave.test.ts index fc8eddc62ab..faa72b909d1 100644 --- a/src/renderer/extensions/compositor/composables/compositorSave.test.ts +++ b/src/renderer/extensions/compositor/composables/compositorSave.test.ts @@ -8,7 +8,6 @@ import { toNodeId } from '@/types/nodeId' import { widgetId } from '@/types/widgetId' import { createMockLGraphNode } from '@/utils/__tests__/litegraphTestUtils' -import type { CompositorLayerState } from './compositorLayerState' import { saveCompositorLayerState, saveCompositorPreview @@ -65,15 +64,13 @@ function makeNode(): { node: LGraphNode } { return { node } } -function storedValue(): CompositorLayerState { +function storedValue(): unknown { return useWidgetValueStore().getWidget( widgetId(GRAPH_ID, NODE_ID, 'compositor') - )?.value as CompositorLayerState + )?.value } -const setValueSpy = () => vi.mocked(useWidgetValueStore().setValue) - -const cacheNode = { id: toNodeId(7) } as unknown as LGraphNode +const cacheNode = createMockLGraphNode({ id: NODE_ID }) beforeEach(() => { clearCompositorLayers(cacheNode) @@ -95,15 +92,17 @@ describe('saveCompositorLayerState', () => { expect(saveCompositorLayerState(session, node)).toBe(true) - const savedState = storedValue() - expect(savedState.canvas).toEqual({ w: 64, h: 48 }) - expect(savedState.layers).toHaveLength(1) - expect(savedState.layers[0]).toMatchObject({ - name: 'Background', - opacity: 0.5, - blend: 'multiply', - flipH: true, - flipV: false + expect(storedValue()).toMatchObject({ + canvas: { w: 64, h: 48 }, + layers: [ + { + name: 'Background', + opacity: 0.5, + blend: 'multiply', + flipH: true, + flipV: false + } + ] }) }) @@ -117,7 +116,7 @@ describe('saveCompositorLayerState', () => { saveCompositorLayerState(makeSession(), node) - expect(storedValue().inputs).toEqual(['hash-a', 'hash-b']) + expect(storedValue()).toMatchObject({ inputs: ['hash-a', 'hash-b'] }) }) it('refuses to save when no fingerprint is cached', () => { @@ -125,7 +124,7 @@ describe('saveCompositorLayerState', () => { expect(saveCompositorLayerState(makeSession(), node)).toBe(false) - expect(setValueSpy()).not.toHaveBeenCalled() + expect(useWidgetValueStore().setValue).not.toHaveBeenCalled() expect(storedValue()).toEqual({}) }) @@ -139,7 +138,7 @@ describe('saveCompositorLayerState', () => { expect(saveCompositorLayerState(session, node)).toBe(false) - expect(setValueSpy()).not.toHaveBeenCalled() + expect(useWidgetValueStore().setValue).not.toHaveBeenCalled() expect(storedValue()).toEqual({}) }) }) diff --git a/src/renderer/extensions/compositor/composables/compositorWidgets.test.ts b/src/renderer/extensions/compositor/composables/compositorWidgets.test.ts index d8ac9dbf655..45ce64aeebf 100644 --- a/src/renderer/extensions/compositor/composables/compositorWidgets.test.ts +++ b/src/renderer/extensions/compositor/composables/compositorWidgets.test.ts @@ -1,6 +1,8 @@ +import { fromPartial } from '@total-typescript/shoehorn' import { describe, expect, it } from 'vitest' import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode' +import type { ICompositorWidget } from '@/lib/litegraph/src/types/widgets' import { useWidgetValueStore } from '@/stores/widgetValueStore' import { toNodeId } from '@/types/nodeId' import { widgetId } from '@/types/widgetId' @@ -47,10 +49,14 @@ describe('setCompositorWidgetValue', () => { expect(storedValue(node)).toEqual(next) }) - it('falls back to the widget object when the store has no entry (detached node)', () => { + it('falls back to the widget object when the store has no entry', () => { const node = makeNode({ registered: false }) - const widget = { name: 'compositor', value: { layers: [] } } - node.widgets = [widget as never] + const widget = fromPartial({ + name: 'compositor', + type: 'compositor', + value: { layers: [] } + }) + node.widgets = [widget] const next = { canvas: { w: 4, h: 4 }, layers: [] } setCompositorWidgetValue(node, next) diff --git a/src/renderer/extensions/compositor/composables/useCompositorAutoSave.test.ts b/src/renderer/extensions/compositor/composables/useCompositorAutoSave.test.ts index c6fd6165397..53f64c6aecf 100644 --- a/src/renderer/extensions/compositor/composables/useCompositorAutoSave.test.ts +++ b/src/renderer/extensions/compositor/composables/useCompositorAutoSave.test.ts @@ -52,9 +52,7 @@ const storedValue = () => useWidgetValueStore().getWidget(widgetId(GRAPH_ID, NODE_ID, 'compositor')) ?.value -const setValueSpy = () => vi.mocked(useWidgetValueStore().setValue) - -const cacheNode = { id: NODE_ID } as unknown as LGraphNode +const cacheNode = createMockLGraphNode({ id: NODE_ID }) beforeEach(() => { setCompositorLayers( @@ -78,7 +76,7 @@ describe('useCompositorAutoSave', () => { session.emitHistoryChange() vi.advanceTimersByTime(2000) - expect(setValueSpy()).not.toHaveBeenCalled() + expect(useWidgetValueStore().setValue).not.toHaveBeenCalled() expect(storedValue()).toEqual({}) }) @@ -90,10 +88,10 @@ describe('useCompositorAutoSave', () => { session.emitHistoryChange() session.emitHistoryChange() session.emitHistoryChange() - expect(setValueSpy()).not.toHaveBeenCalled() + expect(useWidgetValueStore().setValue).not.toHaveBeenCalled() vi.advanceTimersByTime(300) - expect(setValueSpy()).toHaveBeenCalledTimes(1) + expect(useWidgetValueStore().setValue).toHaveBeenCalledTimes(1) expect(storedValue()).toMatchObject({ canvas: { w: 8, h: 8 } }) }) @@ -107,7 +105,7 @@ describe('useCompositorAutoSave', () => { session.emitHistoryChange() vi.advanceTimersByTime(300) - expect(setValueSpy()).toHaveBeenCalledTimes(2) + expect(useWidgetValueStore().setValue).toHaveBeenCalledTimes(2) }) it('ignores selection-only history changes', () => { @@ -118,7 +116,7 @@ describe('useCompositorAutoSave', () => { session.emitHistoryChange(Dirty.SELECTION) vi.advanceTimersByTime(300) - expect(setValueSpy()).not.toHaveBeenCalled() + expect(useWidgetValueStore().setValue).not.toHaveBeenCalled() }) it('stop() cancels pending saves and unsubscribes', () => { @@ -133,6 +131,6 @@ describe('useCompositorAutoSave', () => { session.emitHistoryChange() vi.advanceTimersByTime(300) - expect(setValueSpy()).not.toHaveBeenCalled() + expect(useWidgetValueStore().setValue).not.toHaveBeenCalled() }) })