diff --git a/browser_tests/assets/inputs/checkpoint_loader.json b/browser_tests/assets/inputs/checkpoint_loader.json new file mode 100644 index 00000000000..d3e6c8ca13a --- /dev/null +++ b/browser_tests/assets/inputs/checkpoint_loader.json @@ -0,0 +1,49 @@ +{ + "last_node_id": 4, + "last_link_id": 0, + "nodes": [ + { + "id": 4, + "type": "CheckpointLoaderSimple", + "pos": [400, 300], + "size": [350, 240], + "flags": {}, + "order": 0, + "mode": 0, + "outputs": [ + { + "name": "MODEL", + "type": "MODEL", + "links": [], + "slot_index": 0 + }, + { + "name": "CLIP", + "type": "CLIP", + "links": [], + "slot_index": 1 + }, + { + "name": "VAE", + "type": "VAE", + "links": [], + "slot_index": 2 + } + ], + "properties": { + "Node name for S&R": "CheckpointLoaderSimple" + }, + "widgets_values": ["sd_xl_base_1.0.safetensors"] + } + ], + "links": [], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 0.8, + "offset": [0, 0] + } + }, + "version": 0.4 +} diff --git a/browser_tests/tests/sidebar/modelLibrary.spec.ts b/browser_tests/tests/sidebar/modelLibrary.spec.ts index de32de68b5f..8e5ff69f297 100644 --- a/browser_tests/tests/sidebar/modelLibrary.spec.ts +++ b/browser_tests/tests/sidebar/modelLibrary.spec.ts @@ -301,3 +301,67 @@ test.describe('Model library sidebar - empty state', () => { }) }) }) + +test.describe('Model library drops on Vue nodes', { tag: '@vue-nodes' }, () => { + test.use({ initialSettings: { 'Comfy.ModelLibrary.UseAssetBrowser': false } }) + + test.beforeEach(async ({ comfyPage }) => { + await comfyPage.modelLibrary.mockFoldersWithFiles(MOCK_FOLDERS) + await comfyPage.workflow.loadWorkflow('inputs/checkpoint_loader') + const tab = comfyPage.menu.modelLibraryTab + await tab.open() + await tab.refreshButton.click() + await tab.getFolderByLabel('checkpoints').click() + await expect(tab.getLeafByLabel('dreamshaper_8')).toBeVisible() + await comfyPage.command.executeCommand('Comfy.Canvas.FitView') + await comfyPage.canvasOps.waitForViewToSettle() + }) + + test.afterEach(async ({ comfyPage }) => { + await comfyPage.modelLibrary.clearMocks() + await comfyPage.canvasOps.resetView() + }) + + test('updates an existing loader without creating another node', async ({ + comfyPage + }) => { + const [loader] = await comfyPage.nodeOps.getNodeRefsByType( + 'CheckpointLoaderSimple' + ) + const filename = await loader.getWidgetByName('ckpt_name') + const node = comfyPage.vueNodes.getNodeByTitle('Load Checkpoint') + const nodeCount = await comfyPage.nodeOps.getGraphNodesCount() + await comfyPage.menu.modelLibraryTab + .getLeafByLabel('dreamshaper_8') + .dragTo(node) + await comfyPage.nextFrame() + await expect(node).toContainText('dreamshaper_8.safetensors') + await expect + .poll(() => filename.getValue()) + .toBe('dreamshaper_8.safetensors') + await expect + .poll(() => comfyPage.nodeOps.getGraphNodesCount()) + .toBe(nodeCount) + }) + + test('still creates a loader when dropped onto empty canvas', async ({ + comfyPage + }) => { + await comfyPage.menu.topbar.newWorkflowButton.click() + await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(0) + const box = (await comfyPage.canvas.boundingBox())! + await comfyPage.menu.modelLibraryTab + .getLeafByLabel('dreamshaper_8') + .dragTo(comfyPage.canvas, { + targetPosition: { x: box.width / 2, y: box.height / 2 } + }) + await comfyPage.nextFrame() + await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(1) + const [loader] = await comfyPage.nodeOps.getNodeRefsByType( + 'CheckpointLoaderSimple' + ) + await expect + .poll(async () => (await loader.getWidgetByName('ckpt_name')).getValue()) + .toBe('dreamshaper_8.safetensors') + }) +}) diff --git a/browser_tests/tests/vueNodes/layout/ecsBridgeHistory.spec.ts b/browser_tests/tests/vueNodes/layout/ecsBridgeHistory.spec.ts index 8f4af0d4a19..58fdc1f716d 100644 --- a/browser_tests/tests/vueNodes/layout/ecsBridgeHistory.spec.ts +++ b/browser_tests/tests/vueNodes/layout/ecsBridgeHistory.spec.ts @@ -2,6 +2,7 @@ import { comfyExpect as expect, comfyPageFixture as test } from '@e2e/fixtures/ComfyPage' +import { TestIds } from '@e2e/fixtures/selectors' import { toNodeId } from '@/types/nodeId' test.describe( @@ -80,6 +81,40 @@ test.describe( }) }) + test('preserves Redo after Undo normalizes a subgraph node size', async ({ + comfyPage + }) => { + await comfyPage.workflow.loadWorkflow( + 'subgraphs/subgraph-with-promoted-text-widget' + ) + await comfyPage.vueNodes.enterSubgraph('11') + await comfyPage.command.executeCommand('Comfy.Canvas.FitView') + + const node = await comfyPage.vueNodes.getFixtureByTitle('KSampler') + const title = 'Sampling with a long descriptive title for this workflow' + const rootBreadcrumb = comfyPage.page.getByTestId( + TestIds.breadcrumb.item('root') + ) + await node.setTitle(title) + await rootBreadcrumb.click() + await comfyPage.vueNodes.enterSubgraph('11') + + const stepsRow = comfyPage.vueNodes.getWidgetRowByLabel(title, 'steps') + const steps = stepsRow.getByRole('spinbutton') + await comfyPage.vueNodes.setInputNumberValue(stepsRow, '21') + await expect(steps).toHaveValue('21') + await rootBreadcrumb.click() + await comfyPage.vueNodes.enterSubgraph('11') + + await comfyPage.command.executeCommand('Comfy.Undo') + await expect(steps).toHaveValue('20') + await rootBreadcrumb.click() + + await comfyPage.command.executeCommand('Comfy.Redo') + await comfyPage.vueNodes.enterSubgraph('11') + await expect(steps).toHaveValue('21') + }) + test('preserves geometry through navigation, renderer toggle, and history', async ({ comfyPage }) => { diff --git a/src/components/graph/GraphCanvas.test.ts b/src/components/graph/GraphCanvas.test.ts index 1ad5246b7cf..ee91bb7206c 100644 --- a/src/components/graph/GraphCanvas.test.ts +++ b/src/components/graph/GraphCanvas.test.ts @@ -1,7 +1,16 @@ +import { fromPartial } from '@total-typescript/shoehorn' import { getActivePinia } from 'pinia' -import { render, screen } from '@testing-library/vue' +import { fireEvent, render, screen } from '@testing-library/vue' import type { RenderOptions } from '@testing-library/vue' -import { beforeEach, describe, expect, it, vi } from 'vitest' +import { + assert, + beforeEach, + describe, + expect, + it, + onTestFinished, + vi +} from 'vitest' import { nextTick } from 'vue' import { createI18n } from 'vue-i18n' @@ -10,6 +19,7 @@ import { useSettingStore } from '@/platform/settings/settingStore' import { useReleaseStore } from '@/platform/updates/common/releaseStore' import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' +import { api } from '@/scripts/api' import { app } from '@/scripts/app' import { useBootstrapStore } from '@/stores/bootstrapStore' import { useExecutionStore } from '@/stores/executionStore' @@ -217,6 +227,34 @@ describe('GraphCanvas first-run tour wiring', () => { }) }) +describe('GraphCanvas canvas parent', () => { + it('keeps title-editor touches within the canvas parent used by extensions', async () => { + vi.spyOn(api, 'getSystemStats').mockResolvedValue( + fromPartial({ devices: [] }) + ) + await mountGraphCanvas({ + TitleEditor: { template: '' } + }) + // eslint-disable-next-line testing-library/no-node-access -- Extensions use this canvas ID. + const canvas = document.getElementById('graph-canvas') + assert.exists(canvas) + // eslint-disable-next-line testing-library/no-node-access -- Canvas-parent listeners are the compatibility contract under test. + const parent = canvas.parentElement + assert.exists(parent) + const receivedTouch = vi.fn() + parent.addEventListener('touchstart', receivedTouch, true) + onTestFinished(() => + parent.removeEventListener('touchstart', receivedTouch, true) + ) + + await fireEvent.touchStart( + screen.getByRole('textbox', { name: 'Node title' }) + ) + + expect(receivedTouch).toHaveBeenCalledOnce() + }) +}) + describe('GraphCanvas execution progress updates', () => { async function mountProgressHarness({ totalNodes = 1_000, diff --git a/src/components/graph/GraphCanvas.vue b/src/components/graph/GraphCanvas.vue index ae8ad7ebddc..d915cd56f52 100644 --- a/src/components/graph/GraphCanvas.vue +++ b/src/components/graph/GraphCanvas.vue @@ -73,6 +73,7 @@ () const canvasRef = ref(null) +const transformPaneRef = + useTemplateRef>('transformPaneRef') +const vueNodeDropTarget = computed(() => { + const element: unknown = transformPaneRef.value?.$el + return element instanceof HTMLElement ? element : null +}) const canvasPanelBoundsRef = useTemplateRef('canvasPanelBoundsRef') const nodeSearchboxPopoverRef = shallowRef { 'checkpoints' ) expect(useNodeDragToCanvas().startDrag).toHaveBeenCalledWith(mockNodeDef, { - widgetValues: { ckpt_name: 'model.safetensors' }, + widgetValues: [{ selector: 'ckpt_name', value: 'model.safetensors' }], source: 'sidebar_drag' }) }) diff --git a/src/composables/node/startModelNodeDragFromAsset.test.ts b/src/composables/node/startModelNodeDragFromAsset.test.ts index 31698664e2b..0605e5aca62 100644 --- a/src/composables/node/startModelNodeDragFromAsset.test.ts +++ b/src/composables/node/startModelNodeDragFromAsset.test.ts @@ -40,7 +40,9 @@ describe('startModelNodeDragFromAsset', () => { expect(error).toBeUndefined() expect(useNodeDragToCanvas().startDrag).toHaveBeenCalledWith(nodeDef, { - widgetValues: { ckpt_name: 'sd_xl_base_1.0.safetensors' }, + widgetValues: [ + { selector: 'ckpt_name', value: 'sd_xl_base_1.0.safetensors' } + ], source: 'sidebar_drag' }) }) @@ -57,7 +59,9 @@ describe('startModelNodeDragFromAsset', () => { startModelNodeDragFromAsset(createAsset(), 'asset_browser') expect(useNodeDragToCanvas().startDrag).toHaveBeenCalledWith(nodeDef, { - widgetValues: { ckpt_name: 'sd_xl_base_1.0.safetensors' }, + widgetValues: [ + { selector: 'ckpt_name', value: 'sd_xl_base_1.0.safetensors' } + ], source: 'asset_browser' }) }) diff --git a/src/composables/node/startModelNodeDragFromAsset.ts b/src/composables/node/startModelNodeDragFromAsset.ts index 7cebf0dab19..2c568f6e04e 100644 --- a/src/composables/node/startModelNodeDragFromAsset.ts +++ b/src/composables/node/startModelNodeDragFromAsset.ts @@ -14,7 +14,9 @@ export function startModelLoaderDrag( filename: string, source: NodeAddSource = 'sidebar_drag' ) { - const widgetValues = provider.key ? { [provider.key]: filename } : undefined + const widgetValues = provider.key + ? [{ selector: provider.key, value: filename }] + : undefined useNodeDragToCanvas().startDrag(provider.nodeDef, { widgetValues, source }) } diff --git a/src/composables/node/useNodeDragToCanvas.test.ts b/src/composables/node/useNodeDragToCanvas.test.ts index b2950f9850d..0fedc3b94a8 100644 --- a/src/composables/node/useNodeDragToCanvas.test.ts +++ b/src/composables/node/useNodeDragToCanvas.test.ts @@ -261,7 +261,7 @@ describe('useNodeDragToCanvas', () => { const { startDrag } = useNodeDragToCanvas() startDrag(mockNodeDef, { - widgetValues: { ckpt_name: 'model.safetensors' } + widgetValues: [{ selector: 'ckpt_name', value: 'model.safetensors' }] }) document.dispatchEvent( @@ -275,6 +275,62 @@ describe('useNodeDragToCanvas', () => { expect(widget.value).toBe('model.safetensors') }) + it('should apply a pattern selection to the first matching widget', () => { + mockCanvas.canvas.getBoundingClientRect.mockReturnValue({ + left: 0, + right: 500, + top: 0, + bottom: 500 + }) + mockConvertEventToCanvasOffset.mockReturnValue([150, 150]) + const placedNode = new LGraphNode('Placed node') + const strength = placedNode.addWidget( + 'number', + 'loras.0.strength', + 0.5, + () => {} + ) + const first = placedNode.addWidget( + 'text', + 'loras.0.lora_name', + 'A.safetensors', + () => {} + ) + const second = placedNode.addWidget( + 'text', + 'loras.1.lora_name', + 'B.safetensors', + () => {} + ) + vi.mocked(useLitegraphService().addNodeOnGraph).mockReturnValue( + placedNode + ) + + const { startDrag } = useNodeDragToCanvas() + startDrag(mockNodeDef, { + widgetValues: [ + { + selector: /^loras\.(?:0|[1-9]\d*)\.lora_name$/, + value: 'C.safetensors' + } + ] + }) + + document.dispatchEvent( + new PointerEvent('pointerup', { + clientX: 250, + clientY: 250, + bubbles: true + }) + ) + + expect([strength.value, first.value, second.value]).toEqual([ + 0.5, + 'C.safetensors', + 'B.safetensors' + ]) + }) + it('should warn but still place the node when a requested widget is missing', () => { mockCanvas.canvas.getBoundingClientRect.mockReturnValue({ left: 0, @@ -293,7 +349,7 @@ describe('useNodeDragToCanvas', () => { const { startDrag } = useNodeDragToCanvas() startDrag(mockNodeDef, { - widgetValues: { ckpt_name: 'model.safetensors' } + widgetValues: [{ selector: 'ckpt_name', value: 'model.safetensors' }] }) document.dispatchEvent( diff --git a/src/composables/node/useNodeDragToCanvas.ts b/src/composables/node/useNodeDragToCanvas.ts index 65a67fe63c8..9b5e9fcf8de 100644 --- a/src/composables/node/useNodeDragToCanvas.ts +++ b/src/composables/node/useNodeDragToCanvas.ts @@ -8,14 +8,15 @@ import { useToastStore } from '@/platform/updates/common/toastStore' import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' import { useLitegraphService } from '@/services/litegraphService' import type { ComfyNodeDefImpl } from '@/stores/nodeDefStore' +import { matchesWidgetName } from '@/utils/widgetBinding' +import type { WidgetValueBinding } from '@/utils/widgetBinding' type DragMode = 'click' | 'native' -type WidgetValues = Record type Position = { x: number; y: number } interface StartDragOptions { mode?: DragMode - widgetValues?: WidgetValues + widgetValues?: readonly WidgetValueBinding[] source?: NodeAddSource } @@ -23,7 +24,7 @@ const isDragging = ref(false) const draggedNode = shallowRef(null) const dragMode = ref('click') const lastNativeDragPosition = shallowRef() -const pendingWidgetValues = shallowRef() +const pendingWidgetValues = shallowRef() const pendingSource = ref('sidebar_drag') let listenersSetup = false @@ -36,11 +37,16 @@ function trackNativeDragPosition(e: DragEvent) { lastNativeDragPosition.value = { x: e.clientX, y: e.clientY } } -function applyWidgetValues(node: LGraphNode, values: WidgetValues) { - for (const [name, value] of Object.entries(values)) { - const widget = node.widgets?.find((w) => w.name === name) +function applyWidgetValues( + node: LGraphNode, + values: readonly WidgetValueBinding[] +) { + for (const { selector, value } of values) { + const widget = node.widgets?.find((w) => + matchesWidgetName(w.name, selector) + ) if (!widget) { - console.error(`Widget ${name} not found on node ${node.type}`) + console.error(`Widget ${selector} not found on node ${node.type}`) useToastStore().add({ severity: 'warn', summary: t('g.warning'), diff --git a/src/composables/useCanvasDrop.test.ts b/src/composables/useCanvasDrop.test.ts index abb59b5d15a..09f01b71b9c 100644 --- a/src/composables/useCanvasDrop.test.ts +++ b/src/composables/useCanvasDrop.test.ts @@ -1,13 +1,18 @@ import { fromPartial } from '@total-typescript/shoehorn' -import { describe, expect, it, vi } from 'vitest' +import { assert, describe, expect, it, onTestFinished, vi } from 'vitest' import { effectScope, ref } from 'vue' import { useCanvasDrop } from '@/composables/useCanvasDrop' import { usePragmaticDroppable } from '@/composables/usePragmaticDragAndDrop' import { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore' import { app } from '@/scripts/app' - -const insertWorkflow = vi.hoisted(() => vi.fn()) +import { LGraphNode } from '@/lib/litegraph/src/litegraph' +import { useLitegraphService } from '@/services/litegraphService' +import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' +import { ComfyModelDef } from '@/stores/modelStore' +import { useModelToNodeStore } from '@/stores/modelToNodeStore' +import { useNodeDefStore } from '@/stores/nodeDefStore' +import type { ComfyNodeDefImpl } from '@/stores/nodeDefStore' vi.mock(import('@/composables/usePragmaticDragAndDrop'), () => ({ usePragmaticDraggable: vi.fn(), @@ -23,21 +28,13 @@ vi.mock( }) ) -vi.mock( - import('@/platform/workflow/core/services/workflowService'), - () => ({ useWorkflowService: () => ({ insertWorkflow }) }) -) - -vi.mock(import('@/services/litegraphService'), () => ({ - useLitegraphService: () => ({ addNodeOnGraph: vi.fn() }) -})) - -vi.mock(import('@/scripts/app'), () => ({ - app: { canvas: { selectOnly: false } } -})) +vi.mock(import('@/platform/workflow/core/services/workflowService')) +vi.mock(import('@/services/litegraphService')) +vi.mock(import('@/scripts/app')) function registerDrop() { const scope = effectScope() + onTestFinished(() => scope.stop()) scope.run(() => useCanvasDrop(ref(document.createElement('canvas')))) const onDrop = vi.mocked(usePragmaticDroppable).mock.lastCall?.[1].onDrop if (!onDrop) throw new Error('canvas drop target was not registered') @@ -45,6 +42,53 @@ function registerDrop() { } describe('useCanvasDrop', () => { + it.for([ + { selector: 'model_a', description: 'exact widget name' }, + { selector: /^model_/, description: 'widget name pattern' } + ])( + 'drops a model into the first widget matching $description', + async ({ selector }) => { + useNodeDefStore().nodeDefsByName = { + TestLoader: fromPartial({ name: 'TestLoader' }) + } + useModelToNodeStore().quickRegister('test-models', 'TestLoader', selector) + const node = new LGraphNode('Test loader') + node.comfyClass = 'TestLoader' + const strength = node.addWidget('number', 'strength', 0.5, () => {}) + const first = node.addWidget('text', 'model_a', 'A.safetensors', () => {}) + const second = node.addWidget( + 'text', + 'model_b', + 'B.safetensors', + () => {} + ) + assert.exists(app.canvas.graph) + vi.spyOn(app.canvas.graph, 'getNodeOnPos').mockReturnValue(node) + const onDrop = registerDrop() + + await onDrop( + fromPartial({ + location: { current: { input: { clientX: 10, clientY: 20 } } }, + source: { + data: { + type: 'tree-explorer-node', + data: { + data: new ComfyModelDef('C.safetensors', 'test-models', 0) + } + } + } + }) + ) + + expect([strength.value, first.value, second.value]).toEqual([ + 0.5, + 'C.safetensors', + 'B.safetensors' + ]) + expect(useLitegraphService().addNodeOnGraph).not.toHaveBeenCalled() + } + ) + it.for([ { selectOnly: false, inserts: 1 }, { selectOnly: true, inserts: 0 } @@ -72,7 +116,7 @@ describe('useCanvasDrop', () => { }) ) - expect(insertWorkflow).toHaveBeenCalledTimes(inserts) + expect(useWorkflowService().insertWorkflow).toHaveBeenCalledTimes(inserts) } ) }) diff --git a/src/composables/useCanvasDrop.ts b/src/composables/useCanvasDrop.ts index 18a1bd2d169..d6b2416cba1 100644 --- a/src/composables/useCanvasDrop.ts +++ b/src/composables/useCanvasDrop.ts @@ -15,13 +15,14 @@ import { useModelToNodeStore } from '@/stores/modelToNodeStore' import { ComfyNodeDefImpl } from '@/stores/nodeDefStore' import type { RenderedTreeExplorerNode } from '@/types/treeExplorerTypes' import { isSelectOnly } from '@/utils/litegraphUtil' +import { matchesWidgetName } from '@/utils/widgetBinding' -export const useCanvasDrop = (canvasRef: Ref) => { +export const useCanvasDrop = (dropTargetRef: Ref) => { const modelToNodeStore = useModelToNodeStore() const litegraphService = useLitegraphService() const workflowService = useWorkflowService() - usePragmaticDroppable(() => canvasRef.value, { + usePragmaticDroppable(() => dropTargetRef.value, { getDropEffect: (args): Exclude => args.source.data.type === 'tree-explorer-node' ? 'copy' : 'move', onDrop: async (event) => { @@ -69,9 +70,10 @@ export const useCanvasDrop = (canvasRef: Ref) => { targetProvider = provider } } - if (targetGraphNode) { - const widget = targetGraphNode.widgets?.find( - (widget) => widget.name === targetProvider?.key + if (targetGraphNode && targetProvider) { + const { key } = targetProvider + const widget = targetGraphNode.widgets?.find((widget) => + matchesWidgetName(widget.name, key) ) if (widget) { widget.value = model.file_name diff --git a/src/composables/usePragmaticDragAndDrop.test.ts b/src/composables/usePragmaticDragAndDrop.test.ts new file mode 100644 index 00000000000..71ace2aaf09 --- /dev/null +++ b/src/composables/usePragmaticDragAndDrop.test.ts @@ -0,0 +1,98 @@ +import { dropTargetForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter' +import { render, screen } from '@testing-library/vue' +import userEvent from '@testing-library/user-event' +import { describe, expect, it, vi } from 'vitest' +import { defineComponent, h, ref } from 'vue' + +import { usePragmaticDroppable } from '@/composables/usePragmaticDragAndDrop' + +vi.mock(import('@atlaskit/pragmatic-drag-and-drop/element/adapter')) + +const DropSurface = defineComponent({ + setup() { + const target = ref(null) + const visible = ref(false) + const version = ref(0) + usePragmaticDroppable(target, {}) + return () => + h('div', [ + h( + 'button', + { + onClick: () => { + visible.value = true + } + }, + 'Show target' + ), + h( + 'button', + { + onClick: () => { + visible.value = false + } + }, + 'Hide target' + ), + h( + 'button', + { + onClick: () => { + version.value++ + } + }, + 'Replace target' + ), + visible.value + ? h('div', { + ref: target, + key: version.value, + role: 'region', + 'aria-label': 'Drop surface' + }) + : null + ]) + } +}) + +describe('usePragmaticDroppable', () => { + it('registers a target that appears after the component mounts', async () => { + const user = userEvent.setup() + vi.mocked(dropTargetForElements).mockReturnValue(vi.fn()) + render(DropSurface) + expect(dropTargetForElements).not.toHaveBeenCalled() + + await user.click(screen.getByRole('button', { name: 'Show target' })) + + expect(dropTargetForElements).toHaveBeenCalledExactlyOnceWith({ + element: screen.getByRole('region', { name: 'Drop surface' }) + }) + }) + + it('releases replaced and removed targets and stops the last target on unmount', async () => { + const user = userEvent.setup() + const firstCleanup = vi.fn() + const secondCleanup = vi.fn() + const thirdCleanup = vi.fn() + vi.mocked(dropTargetForElements) + .mockReturnValueOnce(firstCleanup) + .mockReturnValueOnce(secondCleanup) + .mockReturnValueOnce(thirdCleanup) + const view = render(DropSurface) + await user.click(screen.getByRole('button', { name: 'Show target' })) + await user.click(screen.getByRole('button', { name: 'Replace target' })) + expect(firstCleanup).toHaveBeenCalledOnce() + expect(dropTargetForElements).toHaveBeenCalledTimes(2) + + await user.click(screen.getByRole('button', { name: 'Hide target' })) + expect(secondCleanup).toHaveBeenCalledOnce() + expect(dropTargetForElements).toHaveBeenCalledTimes(2) + await user.click(screen.getByRole('button', { name: 'Show target' })) + expect(dropTargetForElements).toHaveBeenCalledTimes(3) + expect(thirdCleanup).not.toHaveBeenCalled() + + view.unmount() + + expect(thirdCleanup).toHaveBeenCalledOnce() + }) +}) diff --git a/src/composables/usePragmaticDragAndDrop.ts b/src/composables/usePragmaticDragAndDrop.ts index 03788d171e0..bd0752fa9a4 100644 --- a/src/composables/usePragmaticDragAndDrop.ts +++ b/src/composables/usePragmaticDragAndDrop.ts @@ -2,7 +2,7 @@ import { draggable, dropTargetForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter' -import { onBeforeUnmount, onMounted, toValue } from 'vue' +import { onBeforeUnmount, onMounted, toValue, watch } from 'vue' import type { MaybeRefOrGetter } from 'vue' export function usePragmaticDroppable( @@ -12,16 +12,14 @@ export function usePragmaticDroppable( let cleanup = () => {} onMounted(() => { - const element = toValue(dropTargetElement) - - if (!element) { - return - } - - cleanup = dropTargetForElements({ - element, - ...options - }) + cleanup = watch( + () => toValue(dropTargetElement), + (element, _previous, onCleanup) => { + if (!element) return + onCleanup(dropTargetForElements({ element, ...options })) + }, + { immediate: true, flush: 'post' } + ) }) onBeforeUnmount(() => { diff --git a/src/core/graph/widgets/dynamicGroupWidget.test.ts b/src/core/graph/widgets/dynamicGroupWidget.test.ts index 3d26a436204..d4acb8c8035 100644 --- a/src/core/graph/widgets/dynamicGroupWidget.test.ts +++ b/src/core/graph/widgets/dynamicGroupWidget.test.ts @@ -379,7 +379,7 @@ describe('DynamicGroup widgets', () => { ).toBe(true) const outerInput = outerHost.inputs[0] expect(promotedInputWidget(outerInput)?.label).toBe('LoRA #2 strength') - return { widget, innerHost, outerHost, outerSubgraph, outerInput } + return { node, widget, innerHost, outerHost, outerSubgraph, outerInput } } it.for([ @@ -472,6 +472,78 @@ describe('DynamicGroup widgets', () => { await vi.waitFor(() => expect(promotedInputWidget(outerInput)).toBeNull()) }) + it('disconnects the deleted row at the outer host while keeping the next row connected', async () => { + const { node, widget, innerHost, outerHost, outerInput } = + setupTwiceDeepPromotion() + const graph = innerHost.subgraph.rootGraph + widget('loras').value = 3 + widget('loras.2.lora_name').value = 'C' + widget('loras.2.strength').value = 0.37 + expect( + promoteValueWidgetViaSubgraphInput( + innerHost, + node, + widget('loras.2.strength') + ).ok + ).toBe(true) + const innerPromoted = promotedInputWidget(innerHost.inputs[1]) + assert.exists(innerPromoted) + expect( + promoteValueWidgetViaSubgraphInput(outerHost, innerHost, innerPromoted).ok + ).toBe(true) + const survivingInput = outerHost.inputs[1] + const otherHost = createTestSubgraphNode(outerHost.subgraph) + graph.add(otherHost) + const source = new LGraphNode('Strength source') + source.addOutput('strength', 'FLOAT') + graph.add(source) + const removed = source.connect(0, outerHost, 0) + const otherRemoved = source.connect(0, otherHost, 0) + const retained = source.connect(0, outerHost, 1) + assert.exists(removed) + assert.exists(otherRemoved) + assert.exists(retained) + + widget('loras.1').callback?.(undefined) + + await vi.waitFor(() => expect(promotedInputWidget(outerInput)).toBeNull()) + expect(graph.getLink(removed.id)).toBeUndefined() + expect(graph.getLink(otherRemoved.id)).toBeUndefined() + expect(outerInput.link).toBeNull() + expect(otherHost.inputs[0].link).toBeNull() + assert.exists(survivingInput.link) + expect(graph.getLink(survivingInput.link)).toBe(retained) + expect(promotedInputWidget(survivingInput)?.value).toBe(0.37) + expect(promotedInputWidget(survivingInput)?.label).toBe('LoRA #2 strength') + expect(widget('loras.1.lora_name').value).toBe('C') + expect(widget('loras.1.strength').value).toBe(0.37) + }) + + it('keeps the outer connection when another node still consumes the promoted input', () => { + const { widget, innerHost, outerHost, outerInput } = + setupTwiceDeepPromotion() + const graph = innerHost.subgraph.rootGraph + const other = new LGraphNode('Another strength consumer') + const input = other.addInput('strength', 'FLOAT') + innerHost.subgraph.add(other) + const internal = innerHost.subgraph.inputNode.slots[0].connect(input, other) + const source = new LGraphNode('Strength source') + source.addOutput('strength', 'FLOAT') + graph.add(source) + const external = source.connect(0, outerHost, 0) + assert.exists(internal) + assert.exists(external) + + widget('loras.1').callback?.(undefined) + + assert.exists(outerInput.link) + assert.exists(input.link) + expect(graph.getLink(outerInput.link)).toBe(external) + expect(innerHost.subgraph.getLink(input.link)).toBe(internal) + expect(innerHost.subgraph.inputs[0].linkIds).toEqual([internal.id]) + expect(widget('loras').value).toBe(1) + }) + it.for([ { label: 'LoRA #2 strength', expected: 'LoRA 1행 strength' }, { label: 'My strength', expected: 'My strength' } diff --git a/src/core/graph/widgets/dynamicGroupWidget.ts b/src/core/graph/widgets/dynamicGroupWidget.ts index afe7ab3a221..46a34295646 100644 --- a/src/core/graph/widgets/dynamicGroupWidget.ts +++ b/src/core/graph/widgets/dynamicGroupWidget.ts @@ -418,9 +418,10 @@ function disconnectOrphanedPromotion( if (!isSubgraph(graph) || graph.inputs[slot]?.linkIds.length) return for (const host of hosts(graph)) { const link = host.graph && inputLink(host.graph, host.id, slot) - if (link?.origin_id !== SUBGRAPH_INPUT_ID) continue + if (!link) continue host.disconnectInput(slot) - disconnectOrphanedPromotion(host.graph, link.origin_slot, hosts) + if (link.origin_id === SUBGRAPH_INPUT_ID) + disconnectOrphanedPromotion(host.graph, link.origin_slot, hosts) } } diff --git a/src/platform/assets/mappings/modelNodeMappings.ts b/src/platform/assets/mappings/modelNodeMappings.ts index 7510fdaf83d..ee720709f77 100644 --- a/src/platform/assets/mappings/modelNodeMappings.ts +++ b/src/platform/assets/mappings/modelNodeMappings.ts @@ -1,9 +1,11 @@ +const loraStackFilename = /^loras\.(?:0|[1-9]\d*)\.lora_name$/ + /** * Default mappings from model directories to loader nodes. * * Each entry maps a model folder (as it appears in the model browser) * to the node class that loads models from that folder and the - * input key where the model name is inserted. + * input name or pattern used to select the model widget. * * An empty key ('') means the node auto-loads models without a widget * selector, so no widget value is assigned when the node is added. @@ -12,10 +14,13 @@ * "a/b/c" → "a/b" → "a", so registering a parent directory covers * all its children unless a more specific entry exists. * - * Format: [modelDirectory, nodeClass, inputKey] + * Patterns enable the picker on every matching widget. Model drops populate + * the first matching widget. + * + * Format: [modelDirectory, nodeClass, inputNameOrPattern] */ export const MODEL_NODE_MAPPINGS: ReadonlyArray< - readonly [string, string, string] + readonly [string, string, string | RegExp] > = [ // Intentionally unmapped (widget values are model ids / HF repo ids, not // asset filenames): rmbg, florence2, LLM/Qwen-VL/*, qwen-tts, diffusers @@ -33,6 +38,8 @@ export const MODEL_NODE_MAPPINGS: ReadonlyArray< ['checkpoints', 'ImageOnlyCheckpointLoader', 'ckpt_name'], ['loras', 'LoraLoader', 'lora_name'], ['loras', 'LoraLoaderModelOnly', 'lora_name'], + ['loras', 'LoadLoraModel', loraStackFilename], + ['loras', 'LoadLoraTextEncoder', loraStackFilename], ['vae', 'VAELoader', 'vae_name'], ['controlnet', 'ControlNetLoader', 'control_net_name'], ['diffusion_models', 'UNETLoader', 'unet_name'], @@ -158,4 +165,4 @@ export const MODEL_NODE_MAPPINGS: ReadonlyArray< // ---- LTX-Video IC-LoRA (ComfyUI-LTXVideo) ---- ['loras', 'LTXICLoRALoaderModelOnly', 'lora_name'] -] as const satisfies ReadonlyArray +] as const satisfies ReadonlyArray diff --git a/src/platform/assets/services/assetService.test.ts b/src/platform/assets/services/assetService.test.ts index 83653991bbc..f9166c4d132 100644 --- a/src/platform/assets/services/assetService.test.ts +++ b/src/platform/assets/services/assetService.test.ts @@ -1,4 +1,6 @@ -import { useModelToNodeStore } from '@/stores/modelToNodeStore' +import { fromPartial } from '@total-typescript/shoehorn' + +import { useNodeDefStore } from '@/stores/nodeDefStore' import { useAssetsStore } from '@/stores/assetsStore' import { beforeEach, describe, expect, it, vi } from 'vitest' @@ -84,19 +86,13 @@ function validAsset(overrides: Partial = {}): AssetItem { } beforeEach(() => { - const registeredNodeTypes: Record = { - CheckpointLoaderSimple: 'ckpt_name', - LoraLoader: 'lora_name' - } - const nodeTypeCategories: Record = { - CheckpointLoaderSimple: 'checkpoints', - LoraLoader: 'loras' - } - vi.mocked(useModelToNodeStore().getRegisteredNodeTypes).mockImplementation( - () => registeredNodeTypes - ) - vi.mocked(useModelToNodeStore().getCategoryForNodeType).mockImplementation( - (nodeType: string) => nodeTypeCategories[nodeType] + useNodeDefStore().nodeDefsByName = Object.fromEntries( + [ + 'CheckpointLoaderSimple', + 'LoraLoader', + 'LoadLoraModel', + 'LoadLoraTextEncoder' + ].map((name) => [name, fromPartial({ name })]) ) vi.spyOn(useAssetsStore().inputAssets, 'invalidate').mockImplementation( mockInvalidateInputAssets @@ -138,6 +134,41 @@ describe(assetService.shouldUseWidgetAssetPicker, () => { ).toBe(true) }) + it.for([ + ['LoadLoraModel', 'loras.0.lora_name'], + ['LoadLoraModel', 'loras.1.lora_name'], + ['LoadLoraModel', 'loras.19.lora_name'], + ['LoadLoraTextEncoder', 'loras.0.lora_name'], + ['LoadLoraTextEncoder', 'loras.1.lora_name'], + ['LoadLoraTextEncoder', 'loras.19.lora_name'] + ])('uses the asset picker for %s / %s on cloud', ([nodeType, name]) => { + mockDistributionState.isCloud = true + expect(assetService.shouldUseWidgetAssetPicker(nodeType, name)).toBe(true) + }) + + it.for(['LoadLoraModel', 'LoadLoraTextEncoder'])( + 'keeps the combo widget for %s outside cloud', + (nodeType) => { + mockDistributionState.isCloud = false + expect( + assetService.shouldUseWidgetAssetPicker(nodeType, 'loras.1.lora_name') + ).toBe(false) + } + ) + + it.for([ + ['LoadLoraModel', 'loras.1.strength'], + ['LoadLoraModel', 'loras.-1.lora_name'], + ['LoadLoraModel', 'loras.01.lora_name'], + ['LoadLoraModel', 'prefix.loras.1.lora_name'], + ['LoadLoraModel', 'loras.1.lora_name.suffix'], + ['LoraLoader', 'loras.1.lora_name'], + ['UnknownNode', 'loras.1.lora_name'] + ])('does not treat %s / %s as an asset input', ([nodeType, name]) => { + mockDistributionState.isCloud = true + expect(assetService.shouldUseWidgetAssetPicker(nodeType, name)).toBe(false) + }) + it('returns false when nodeType is undefined', () => { mockDistributionState.isCloud = true diff --git a/src/platform/assets/services/assetService.ts b/src/platform/assets/services/assetService.ts index 881654e6d17..49ade3e2016 100644 --- a/src/platform/assets/services/assetService.ts +++ b/src/platform/assets/services/assetService.ts @@ -571,9 +571,7 @@ function createAssetService() { widgetName: string ): boolean { if (!nodeType || !widgetName) return false - return ( - useModelToNodeStore().getRegisteredNodeTypes()[nodeType] === widgetName - ) + return useModelToNodeStore().isModelWidget(nodeType, widgetName) } /** diff --git a/src/platform/workflow/core/services/workflowService.test.ts b/src/platform/workflow/core/services/workflowService.test.ts index beef1ea78d5..31c98a48402 100644 --- a/src/platform/workflow/core/services/workflowService.test.ts +++ b/src/platform/workflow/core/services/workflowService.test.ts @@ -380,6 +380,35 @@ describe('useWorkflowService', () => { ) }) + it('persists the displayed state when Undo fails before graph configuration', async () => { + vi.spyOn(useSettingStore(), 'get').mockImplementation( + (key: string) => key === 'Comfy.Workflow.Persist' + ) + const activeWorkflow = createModeTestWorkflow() + const saved = makeWorkflowData() + const current = makeWorkflowData({ note: 'latest edit' }) + const tracker = new ChangeTracker(activeWorkflow, saved) + activeWorkflow.changeTracker = tracker + tracker.activeState = current + tracker.undoQueue.push(saved) + workflowStore.activeWorkflow = activeWorkflow + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + useWorkflowService().beforeLoadNewGraph(false) + return false + }) + + await tracker.undo() + + expect(useWorkflowDraftStoreV2().saveDraft).toHaveBeenCalledWith( + activeWorkflow.path, + JSON.stringify(current), + { name: activeWorkflow.key, isTemporary: activeWorkflow.isTemporary } + ) + expect(activeWorkflow.activeState).toEqual(current) + expect(tracker.undoQueue).toEqual([saved]) + expect(tracker.redoQueue).toEqual([]) + }) + it('should show an error toast when the V2 draft store cannot save', () => { vi.spyOn(useSettingStore(), 'get').mockImplementation((key: string) => { return key === 'Comfy.Workflow.Persist' diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts index ae96e2459f7..190a493b6fd 100644 --- a/src/platform/workflow/core/services/workflowService.ts +++ b/src/platform/workflow/core/services/workflowService.ts @@ -709,7 +709,9 @@ export const useWorkflowService = () => { workflowData: ComfyWorkflowJSON, shareId?: string ) => { + const graphState = app.rootGraphOrUndefined?.state await activateLoadedWorkflow(value, workflowData, shareId) + if (graphState !== app.rootGraphOrUndefined?.state) return useNodeOutputStore().restorePreviewsForWorkflow( useWorkspaceStore().workflow.activeWorkflow?.path ) @@ -720,6 +722,7 @@ export const useWorkflowService = () => { workflowData: ComfyWorkflowJSON, shareId?: string ) => { + const graphState = app.rootGraphOrUndefined?.state const workflowStore = useWorkspaceStore().workflow const { isAppMode } = useAppMode() const wasAppMode = isAppMode.value @@ -770,6 +773,7 @@ export const useWorkflowService = () => { ) { const loadedWorkflow = await workflowStore.openWorkflow(existingWorkflow) + if (graphState !== app.rootGraphOrUndefined?.state) return activateRunErrors(loadedWorkflow) if (loadedWorkflow.initialMode === undefined) { // Prefer the file's linearMode over the draft's since the file @@ -805,11 +809,13 @@ export const useWorkflowService = () => { } trackIfEnteringApp(tempWorkflow) const loadedWorkflow = await workflowStore.openWorkflow(tempWorkflow) + if (graphState !== app.rootGraphOrUndefined?.state) return activateRunErrors(loadedWorkflow) return } const loadedWorkflow = await workflowStore.openWorkflow(value) + if (graphState !== app.rootGraphOrUndefined?.state) return activateRunErrors(loadedWorkflow) if (shareId) { loadedWorkflow.shareId = shareId diff --git a/src/platform/workflow/management/stores/workflowStore.ts b/src/platform/workflow/management/stores/workflowStore.ts index 025a2a2f8b6..ba98273d0d3 100644 --- a/src/platform/workflow/management/stores/workflowStore.ts +++ b/src/platform/workflow/management/stores/workflowStore.ts @@ -212,7 +212,11 @@ export const useWorkflowStore = defineStore('workflow', () => { if (!openWorkflowPaths.value.includes(workflow.path)) { openWorkflowPaths.value.push(workflow.path) } + const graphState = comfyApp.rootGraphOrUndefined?.state const loadedWorkflow = await workflow.load() + if (graphState !== comfyApp.rootGraphOrUndefined?.state) { + throw new DOMException('Workflow load was replaced', 'AbortError') + } activeWorkflow.value = loadedWorkflow comfyApp.canvas.bg_tint = loadedWorkflow.tintCanvasBg diff --git a/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts b/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts index f8aaa6b297d..ae30c043b5e 100644 --- a/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts +++ b/src/renderer/extensions/vueNodes/components/LGraphNode.test.ts @@ -1,4 +1,4 @@ -import { render, screen } from '@testing-library/vue' +import { fireEvent, render, screen } from '@testing-library/vue' import { getActivePinia } from 'pinia' import { beforeEach, describe, expect, it, vi } from 'vitest' @@ -217,6 +217,7 @@ describe('LGraphNode', () => { mockData.mockExecuting = false mockData.mockLgraphNode = null mockData.resizeCallback = null + app.dragOverNode = null const canvasStore = useCanvasStore() canvasStore.selectedNodeIds.clear() @@ -763,6 +764,24 @@ describe('LGraphNode', () => { }) describe('handleDrop', () => { + it('clears the native file target when another handler already consumed the drop', async () => { + mockData.mockLgraphNode = { + onDragOver: vi.fn(), + isSubgraphNode: () => false + } + app.dragOverNode = { + id: toNodeId('previous-node'), + onDragDrop: vi.fn(() => false) + } + const { container } = renderLGraphNode({ nodeData: mockNodeData }) + const event = new Event('drop', { bubbles: true, cancelable: true }) + event.preventDefault() + + await fireEvent(getNodeRoot(container), event) + + expect(app.dragOverNode).toBeNull() + }) + it('should set app.dragOverNode and let event bubble', async () => { mockData.mockLgraphNode = { onDragOver: vi.fn(), diff --git a/src/renderer/extensions/vueNodes/components/LGraphNode.vue b/src/renderer/extensions/vueNodes/components/LGraphNode.vue index d46b77d8dbf..945dd0c5b45 100644 --- a/src/renderer/extensions/vueNodes/components/LGraphNode.vue +++ b/src/renderer/extensions/vueNodes/components/LGraphNode.vue @@ -770,8 +770,8 @@ function handleDragLeave() { isDraggingOver.value = false } -function handleDrop() { +function handleDrop(event: DragEvent) { isDraggingOver.value = false - app.dragOverNode = resolveLGraphNode() + app.dragOverNode = event.defaultPrevented ? null : resolveLGraphNode() } diff --git a/src/renderer/extensions/vueNodes/components/LGraphNodePreview.test.ts b/src/renderer/extensions/vueNodes/components/LGraphNodePreview.test.ts index e9889098619..c60c662658f 100644 --- a/src/renderer/extensions/vueNodes/components/LGraphNodePreview.test.ts +++ b/src/renderer/extensions/vueNodes/components/LGraphNodePreview.test.ts @@ -9,6 +9,7 @@ import type { WidgetGridItem } from '@/renderer/extensions/vueNodes/types/widget import type { ComfyNodeDef as ComfyNodeDefV2 } from '@/schemas/nodeDef/nodeDefSchemaV2' import LGraphNodePreview from '@/renderer/extensions/vueNodes/components/LGraphNodePreview.vue' import { fromPartial } from '@total-typescript/shoehorn' +import type { WidgetValueBinding } from '@/utils/widgetBinding' const WidgetGridProbe = { props: ['processedWidgets'], @@ -43,7 +44,7 @@ const nodeDef = fromPartial({ function renderedWidgets( def: ComfyNodeDefV2, - props: { widgetValues?: Record } = {} + props: { widgetValues?: readonly WidgetValueBinding[] } = {} ) { render(LGraphNodePreview, { props: { nodeDef: def, ...props }, @@ -63,7 +64,7 @@ function renderedWidgets( } function renderedComboWidget( - props: { widgetValues?: Record } = {} + props: { widgetValues?: readonly WidgetValueBinding[] } = {} ) { return renderedWidgets(nodeDef, props).find((w) => w.name === 'ckpt_name') } @@ -106,7 +107,9 @@ describe('LGraphNodePreview', () => { it('leads the combo options with the provided widget value', () => { const widget = renderedComboWidget({ - widgetValues: { ckpt_name: 'sd_xl_base_1.0.safetensors' } + widgetValues: [ + { selector: 'ckpt_name', value: 'sd_xl_base_1.0.safetensors' } + ] }) expect(widget?.options?.values).toEqual([ @@ -116,6 +119,28 @@ describe('LGraphNodePreview', () => { ]) }) + it('previews a pattern-bound value only on the first matching widget', () => { + const widgets = renderedWidgets( + fromPartial({ + name: 'MultiModel', + inputs: { + strength: { type: 'FLOAT', default: 0.5 }, + model_a: { type: 'COMBO', options: ['A.safetensors'] }, + model_b: { type: 'COMBO', options: ['B.safetensors'] } + } + }), + { + widgetValues: [{ selector: /^model_/, value: 'C.safetensors' }] + } + ) + + expect(widgets.map(({ name, value }) => ({ name, value }))).toEqual([ + { name: 'strength', value: 0.5 }, + { name: 'model_a', value: 'C.safetensors' }, + { name: 'model_b', value: 'B.safetensors' } + ]) + }) + it('keeps the combo options untouched when no value is provided', () => { const widget = renderedComboWidget() @@ -123,7 +148,9 @@ describe('LGraphNodePreview', () => { }) it('leads with an explicitly empty provided value', () => { - const widget = renderedComboWidget({ widgetValues: { ckpt_name: '' } }) + const widget = renderedComboWidget({ + widgetValues: [{ selector: 'ckpt_name', value: '' }] + }) expect(widget?.value).toBe('') expect(widget?.options?.values).toEqual([ diff --git a/src/renderer/extensions/vueNodes/components/LGraphNodePreview.vue b/src/renderer/extensions/vueNodes/components/LGraphNodePreview.vue index 49e6002dfe4..d8869b8a36c 100644 --- a/src/renderer/extensions/vueNodes/components/LGraphNodePreview.vue +++ b/src/renderer/extensions/vueNodes/components/LGraphNodePreview.vue @@ -52,6 +52,8 @@ import { toNodeId } from '@/types/nodeId' import type { NodeState } from '@/types/nodeState' import type { WidgetValue } from '@/types/simplifiedWidget' import { zeroUuid } from '@/utils/uuid' +import { matchesWidgetName } from '@/utils/widgetBinding' +import type { WidgetValueBinding } from '@/utils/widgetBinding' import { cn } from '@comfyorg/tailwind-utils' const { @@ -61,7 +63,7 @@ const { } = defineProps<{ nodeDef: ComfyNodeDefV2 position?: 'absolute' | 'relative' - widgetValues?: Record + widgetValues?: readonly WidgetValueBinding[] }>() const widgetStore = useWidgetStore() @@ -110,12 +112,26 @@ const nodeData = computed(() => ({ properties: {} })) +const widgetInputs = computed(() => + Object.entries(nodeDef.inputs || {}).filter(([, input]) => + widgetStore.inputIsWidget(input) + ) +) + +const resolvedWidgetValues = computed(() => + Object.fromEntries( + (widgetValues ?? []).flatMap(({ selector, value }) => { + const input = widgetInputs.value.find(([name]) => + matchesWidgetName(name, selector) + ) + return input ? [[input[0], value]] : [] + }) + ) +) + const previewWidgets = computed(() => - Object.entries(nodeDef.inputs || {}) - .filter( - ([, input]) => - widgetStore.inputIsWidget(input) && !input.hidden && !input.advanced - ) + widgetInputs.value + .filter(([, input]) => !input.hidden && !input.advanced) .map(([name, input]) => { const isDynamicCombo = input.type === 'COMFY_DYNAMICCOMBO_V3' const comboValues = isDynamicCombo @@ -123,7 +139,7 @@ const previewWidgets = computed(() => : input.type === 'COMBO' && Array.isArray(input.options) ? input.options : undefined - const leadValue = widgetValues?.[name] + const leadValue = resolvedWidgetValues.value[name] const value = (leadValue ?? input.default ?? comboValues?.[0] ?? diff --git a/src/scripts/app.test.ts b/src/scripts/app.test.ts index 226d296a1c3..2e3df9a794e 100644 --- a/src/scripts/app.test.ts +++ b/src/scripts/app.test.ts @@ -20,7 +20,7 @@ import { onTestFinished, vi } from 'vitest' -import { ref } from 'vue' +import { markRaw, ref } from 'vue' import { useLitegraphService } from '@/services/litegraphService' import { useNodeDefStore } from '@/stores/nodeDefStore' import { transformInputSpecV1ToV2 } from '@/schemas/nodeDef/migration' @@ -53,6 +53,7 @@ import type { LoadedComfyWorkflow } from '@/platform/workflow/management/stores/ import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' import type { useWorkflowValidation } from '@/platform/workflow/validation/composables/useWorkflowValidation' import { createMockChangeTracker } from '@/utils/__tests__/litegraphTestUtils' +import { ChangeTracker } from '@/scripts/changeTracker' import { createTestCanvasElement, createTestDragAndScale, @@ -532,19 +533,41 @@ describe('ComfyApp', () => { app.canvasElRef.value = document.createElement('canvas') Reflect.set(app, 'rootGraphInternal', new LGraph()) const showDialog = vi.spyOn(useDialogStore(), 'showDialog') - mockExtensionService.invokeExtensionsAsync.mockImplementation( - async (hook: string) => { - if (hook === 'beforeConfigureGraph') { - throw new Error('bad extension') - } - } + const error = new Error('bad extension') + let releaseErrorHandling!: () => void + const errorHandling = new Promise((resolve) => { + releaseErrorHandling = resolve + }) + vi.when(mockExtensionService.invokeExtensionsAsync) + .calledWith( + 'beforeConfigureGraph', + expect.anything(), + expect.anything() + ) + .thenRejectOnce(error) + vi.when(mockExtensionService.invokeExtensionsAsync) + .calledWith('onGraphLoadError', error) + .thenReturnOnce(errorHandling) + const load = app.loadGraphData( + createWorkflowGraphData(), + false, + true, + null, + { workflowNavigationId: 9 } ) - - await expect( - app.loadGraphData(createWorkflowGraphData(), false, true, null, { - workflowNavigationId: 9 - }) - ).resolves.toBe(false) + try { + await vi.waitFor(() => + expect( + mockExtensionService.invokeExtensionsAsync + ).toHaveBeenCalledWith('onGraphLoadError', error) + ) + expect(ChangeTracker.isLoadingGraph).toBe(true) + } finally { + releaseErrorHandling() + await load + } + await expect(load).resolves.toBe(false) + expect(ChangeTracker.isLoadingGraph).toBe(false) expect(showDialog).toHaveBeenCalledOnce() expect(useSubgraphNavigationStore().updateHash).toHaveBeenCalledWith( @@ -718,6 +741,349 @@ describe('ComfyApp', () => { expect(closed).toHaveLength(opened.length) }) + it('does not assign a newer workflow graph to an Undo load waiting after configuration', async () => { + app.canvasElRef.value = document.createElement('canvas') + Reflect.set(app, 'rootGraphInternal', new LGraph()) + const firstWorkflow = new ComfyWorkflow({ + path: 'workflows/undo.json', + modified: 0, + size: 0 + }) + const saved = createWorkflowGraphData() + saved.extra = { marker: 'saved' } + const changed = structuredClone(saved) + changed.extra = { marker: 'changed' } + const firstTracker = new ChangeTracker(firstWorkflow, saved) + firstTracker.activeState = changed + firstTracker._restoringState = true + firstWorkflow.changeTracker = firstTracker + const secondWorkflow = new ComfyWorkflow({ + path: 'workflows/other.json', + modified: 0, + size: 0 + }) + const other = createWorkflowGraphData() + other.extra = { marker: 'other' } + const secondTracker = new ChangeTracker(secondWorkflow, other) + secondWorkflow.changeTracker = secondTracker + mockWorkflowService.afterLoadNewGraph.mockImplementation( + async ( + workflow: string | ComfyWorkflow | null, + state: ComfyWorkflowJSON + ) => { + assert(workflow instanceof ComfyWorkflow) + workflow.changeTracker?.reset(state) + } + ) + let releasePending!: () => void + const pending = new Promise((resolve) => { + releasePending = resolve + }) + vi.when(mockExtensionService.invokeExtensionsAsync) + .calledWith('afterConfigureGraph', expect.anything()) + .thenReturnOnce(pending) + + const undoLoad = app.loadGraphData(saved, false, false, firstWorkflow, { + skipAssetScans: true + }) + await vi.waitFor(() => + expect(mockExtensionService.invokeExtensionsAsync).toHaveBeenCalledWith( + 'afterConfigureGraph', + expect.anything() + ) + ) + await app.loadGraphData(other, false, false, secondWorkflow, { + skipAssetScans: true + }) + try { + expect(ChangeTracker.isLoadingGraph).toBe(false) + } finally { + releasePending() + await undoLoad + } + await expect(undoLoad).resolves.toBeUndefined() + + expect(firstTracker.activeState).toEqual(changed) + expect(firstTracker.initialState).toEqual(saved) + expect(secondTracker.activeState.extra).toMatchObject({ marker: 'other' }) + expect(app.rootGraph.extra).toMatchObject({ marker: 'other' }) + }) + + it.for(['activation', 'tracker restoration', 'afterLoadGraph'] as const)( + 'cancels an older restore overtaken during %s without replacing the newer workflow', + async (pauseAt) => { + app.canvasElRef.value = document.createElement('canvas') + const graph = new LGraph() + const previousGraph = singletonApp.rootGraphOrUndefined + const previousCanvas = singletonApp.canvas + onTestFinished(() => { + Reflect.set(singletonApp, 'rootGraphInternal', previousGraph) + singletonApp.canvas = previousCanvas + }) + Reflect.set(app, 'rootGraphInternal', graph) + Reflect.set(singletonApp, 'rootGraphInternal', graph) + singletonApp.canvas = mockCanvas + Reflect.set(mockCanvas, 'ds', { scale: 1, offset: [0, 0] }) + await useRealWorkflowService() + const workflowStore = useWorkflowStore() + vi.mocked(workflowStore.openWorkflow).mockRestore() + vi.mocked(workflowStore.isActive).mockRestore() + + const saved = createWorkflowGraphData() + saved.extra = { marker: 'saved' } + const changed = structuredClone(saved) + changed.extra = { marker: 'changed' } + const firstWorkflow = markLoaded( + new ComfyWorkflow({ + path: 'workflows/undo.json', + modified: 0, + size: 0 + }) + ) + const firstTracker = markRaw(new ChangeTracker(firstWorkflow, saved)) + firstTracker.activeState = changed + firstTracker._restoringState = true + firstWorkflow.changeTracker = firstTracker + const other = createWorkflowGraphData() + other.extra = { marker: 'other' } + const secondWorkflow = markLoaded( + new ComfyWorkflow({ + path: 'workflows/other.json', + modified: 0, + size: 0 + }) + ) + const secondTracker = markRaw(new ChangeTracker(secondWorkflow, other)) + secondWorkflow.changeTracker = secondTracker + let releasePause!: () => void + const pause = new Promise((resolve) => { + releasePause = resolve + }) + let reachedPause = false + if (pauseAt === 'activation') { + vi.spyOn(firstWorkflow, 'load').mockImplementationOnce(async () => { + reachedPause = true + await pause + return firstWorkflow + }) + } else if (pauseAt === 'tracker restoration') { + const openWorkflow = vi + .mocked(workflowStore.openWorkflow) + .getMockImplementation() + assert(openWorkflow) + vi.mocked(workflowStore.openWorkflow).mockImplementation( + async (workflow) => { + const loaded = await openWorkflow(workflow) + if (workflow.path === firstWorkflow.path) { + reachedPause = true + await pause + } + return loaded + } + ) + } else { + mockExtensionService.invokeExtensionsAsync.mockImplementation( + async (hook) => { + if (hook === 'afterLoadGraph' && !reachedPause) { + reachedPause = true + await pause + } + } + ) + } + + const olderLoad = app.loadGraphData( + saved, + false, + false, + firstWorkflow, + { + skipAssetScans: true + } + ) + try { + await vi.waitFor(() => expect(reachedPause).toBe(true)) + await app.loadGraphData(other, false, false, secondWorkflow, { + skipAssetScans: true + }) + } finally { + releasePause() + } + const result = await olderLoad + + expect(workflowStore.activeWorkflow?.path).toBe(secondWorkflow.path) + expect(workflowStore.activeWorkflow?.changeTracker).toBe(secondTracker) + expect(secondTracker.activeState.extra).toMatchObject({ + marker: 'other' + }) + expect(secondTracker.initialState.extra).toMatchObject({ + marker: 'other' + }) + expect(firstTracker.initialState).toEqual(saved) + expect(firstTracker.activeState.extra).toMatchObject({ + marker: pauseAt === 'afterLoadGraph' ? 'saved' : 'changed' + }) + expect(graph.extra).toMatchObject({ marker: 'other' }) + expect(ChangeTracker.isLoadingGraph).toBe(false) + expect(result).toBeUndefined() + } + ) + + it('does not assign a cleared canvas to Undo while the newer workflow is still preparing', async () => { + app.canvasElRef.value = document.createElement('canvas') + Reflect.set(app, 'rootGraphInternal', new LGraph()) + const firstWorkflow = new ComfyWorkflow({ + path: 'workflows/undo.json', + modified: 0, + size: 0 + }) + const saved = createWorkflowGraphData() + saved.extra = { marker: 'saved' } + const changed = structuredClone(saved) + changed.extra = { marker: 'changed' } + const tracker = new ChangeTracker(firstWorkflow, saved) + tracker.activeState = changed + tracker._restoringState = true + firstWorkflow.changeTracker = tracker + const secondWorkflow = new ComfyWorkflow({ + path: 'workflows/other.json', + modified: 0, + size: 0 + }) + const other = createWorkflowGraphData() + other.extra = { marker: 'other' } + mockWorkflowService.afterLoadNewGraph.mockImplementation( + async ( + workflow: string | ComfyWorkflow | null, + state: ComfyWorkflowJSON + ) => { + assert(workflow instanceof ComfyWorkflow) + workflow.changeTracker?.reset(state) + } + ) + let releaseAfterConfigure!: () => void + const afterConfigure = new Promise((resolve) => { + releaseAfterConfigure = resolve + }) + vi.when(mockExtensionService.invokeExtensionsAsync) + .calledWith('afterConfigureGraph', expect.anything()) + .thenReturnOnce(afterConfigure) + + const undoLoad = app.loadGraphData(saved, false, false, firstWorkflow, { + skipAssetScans: true + }) + await vi.waitFor(() => + expect(mockExtensionService.invokeExtensionsAsync).toHaveBeenCalledWith( + 'afterConfigureGraph', + expect.anything() + ) + ) + let releaseBeforeConfigure!: () => void + const beforeConfigure = new Promise((resolve) => { + releaseBeforeConfigure = resolve + }) + vi.when(mockExtensionService.invokeExtensionsAsync) + .calledWith( + 'beforeConfigureGraph', + expect.anything(), + expect.anything() + ) + .thenReturnOnce(beforeConfigure) + const newerLoad = app.loadGraphData(other, true, false, secondWorkflow, { + skipAssetScans: true + }) + try { + await vi.waitFor(() => expect(app.rootGraph.extra).toEqual({})) + releaseAfterConfigure() + await expect(undoLoad).resolves.toBeUndefined() + expect(ChangeTracker.isLoadingGraph).toBe(true) + expect(mockExtensionService.invokeExtensionsAsync).toHaveBeenCalledWith( + 'onGraphLoadError', + expect.objectContaining({ name: 'AbortError' }) + ) + + expect(tracker.activeState).toEqual(changed) + expect(tracker.initialState).toEqual(saved) + } finally { + releaseAfterConfigure() + releaseBeforeConfigure() + await Promise.all([undoLoad, newerLoad]) + } + expect(app.rootGraph.extra).toMatchObject({ marker: 'other' }) + expect(ChangeTracker.isLoadingGraph).toBe(false) + }) + + it('allows capture after a newer workflow finishes while old resource scans remain pending', async () => { + app.canvasElRef.value = document.createElement('canvas') + Reflect.set(app, 'rootGraphInternal', new LGraph()) + const oldGraph = createWorkflowGraphData() + oldGraph.extra = { marker: 'old' } + const currentGraph = createWorkflowGraphData() + currentGraph.extra = { marker: 'current' } + let releaseModels!: () => void + const modelsPending = new Promise((resolve) => { + releaseModels = resolve + }) + vi.mocked(runMissingModelPipeline).mockImplementationOnce(async () => { + await modelsPending + return { missingModels: [], confirmedCandidates: [] } + }) + const oldLoad = app.loadGraphData(oldGraph, false, false) + try { + await vi.waitFor(() => + expect(runMissingModelPipeline).toHaveBeenCalledOnce() + ) + await app.loadGraphData(currentGraph, false, false, null, { + skipAssetScans: true + }) + + expect(app.rootGraph.extra).toMatchObject({ marker: 'current' }) + expect(ChangeTracker.isLoadingGraph).toBe(false) + } finally { + releaseModels() + await oldLoad + } + }) + + it('keeps a configured load when a newer configure fails without clearing it', async () => { + app.canvasElRef.value = document.createElement('canvas') + Reflect.set(app, 'rootGraphInternal', new LGraph()) + const graph = createWorkflowGraphData() + graph.extra = { marker: 'configured' } + let releaseFirst!: () => void + const firstPending = new Promise((resolve) => { + releaseFirst = resolve + }) + vi.when(mockExtensionService.invokeExtensionsAsync) + .calledWith('afterConfigureGraph', expect.anything()) + .thenReturnOnce(firstPending) + const firstLoad = app.loadGraphData(graph, false, false, null, { + skipAssetScans: true + }) + try { + await vi.waitFor(() => + expect( + mockExtensionService.invokeExtensionsAsync + ).toHaveBeenCalledWith('afterConfigureGraph', expect.anything()) + ) + vi.spyOn(app.rootGraph, 'configure').mockImplementationOnce(() => { + throw new Error('Configuration failed before clearing') + }) + await expect( + app.loadGraphData(createWorkflowGraphData(), false, false, null, { + skipAssetScans: true + }) + ).resolves.toBe(false) + releaseFirst() + + expect(await firstLoad).toBeTruthy() + expect(app.rootGraph.extra).toMatchObject({ marker: 'configured' }) + } finally { + releaseFirst() + await firstLoad + } + }) + it('lets an older valid load commit when its newer replacement fails', async () => { app.canvasElRef.value = document.createElement('canvas') Reflect.set(app, 'rootGraphInternal', new LGraph()) diff --git a/src/scripts/app.ts b/src/scripts/app.ts index 7c9068c88ce..9621ce32940 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -401,6 +401,7 @@ export class ComfyApp { private configuringGraphLevel: number = 0 private graphLoadSequence = 0 private committedGraphLoadSequence = 0 + private readonly pendingGraphLoads = new Set() private pendingCamera: | { id: number; workflow: string | null | ComfyWorkflow } | undefined @@ -1332,6 +1333,13 @@ export class ComfyApp { useWorkflowService().beforeLoadNewGraph(clean) await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') + this.pendingGraphLoads.add(loadId) + ChangeTracker.isLoadingGraph = true + const releaseGraphLoad = () => { + this.pendingGraphLoads.delete(loadId) + if (this.pendingGraphLoads.size === 0) + ChangeTracker.isLoadingGraph = false + } let reset_invalid_values = false const missingNodeTypes: MissingNodeType[] = [] try { @@ -1484,7 +1492,11 @@ export class ComfyApp { // below. Left unhandled, that would both reject silently and leak any // suppression/loading-state a `beforeLoadGraph` listener opened for // this load, since nothing ever notifies it the load ended. - await this.reportGraphLoadFailure(error) + try { + await this.reportGraphLoadFailure(error) + } finally { + releaseGraphLoad() + } void useSubgraphNavigationStore().updateHash( 'workflow-load', workflowNavigationId @@ -1526,7 +1538,6 @@ export class ComfyApp { } } - ChangeTracker.isLoadingGraph = true let activatedWorkflow: LoadedComfyWorkflow | undefined let reconcileResourceErrors: (() => void) | undefined let resourceScanLoadCompleted = false @@ -1601,6 +1612,16 @@ export class ComfyApp { // Resolves rather than throws: the close/replacement guards read this outcome. return false } + const configuredGraphState = this.rootGraph.state + const configuredLoadId = this.committedGraphLoadSequence + const isCurrentGraphLoad = () => + configuredGraphState === this.rootGraph.state && + configuredLoadId === this.committedGraphLoadSequence + const cancelReplacedLoad = () => + useExtensionService().invokeExtensionsAsync( + 'onGraphLoadError', + new DOMException('Workflow load was replaced', 'AbortError') + ) const snapTo = LiteGraph.alwaysSnapToGrid ? this.rootGraph.getSnapToGridSize() : 0 @@ -1665,6 +1686,10 @@ export class ComfyApp { 'afterConfigureGraph', missingNodeTypes ) + if (!isCurrentGraphLoad()) { + await cancelReplacedLoad() + return undefined + } const effectiveShareId = shareId ?? @@ -1680,12 +1705,29 @@ export class ComfyApp { } useTelemetry()?.trackWorkflowOpened(telemetryPayload) useTelemetry()?.trackWorkflowImported(telemetryPayload) - await useWorkflowService().afterLoadNewGraph( - workflow, - this.rootGraph.serialize() as unknown as ComfyWorkflowJSON, - effectiveShareId - ) + try { + await useWorkflowService().afterLoadNewGraph( + workflow, + this.rootGraph.serialize() as unknown as ComfyWorkflowJSON, + effectiveShareId + ) + } catch (error) { + if (isCurrentGraphLoad()) throw error + } + if (!isCurrentGraphLoad()) { + await cancelReplacedLoad() + return undefined + } await useExtensionService().invokeExtensionsAsync('afterLoadGraph') + if (!isCurrentGraphLoad()) { + await cancelReplacedLoad() + return undefined + } + for (const pendingLoadId of this.pendingGraphLoads) { + if (pendingLoadId <= loadId) + this.pendingGraphLoads.delete(pendingLoadId) + } + ChangeTracker.isLoadingGraph = this.pendingGraphLoads.size > 0 // Capture the workflow this load activated before the asset-scan awaits // below can hand control back and let the user switch to another one. activatedWorkflow = useWorkflowStore().activeWorkflow ?? undefined @@ -1753,7 +1795,7 @@ export class ComfyApp { 'workflow-load', workflowNavigationId ) - ChangeTracker.isLoadingGraph = false + releaseGraphLoad() // The retirement watcher skips transitions made during the load. useExecutionErrorStore().retireResolvedMissingNodePromptError() reconcileResourceErrors?.() diff --git a/src/scripts/changeTracker.test.ts b/src/scripts/changeTracker.test.ts index 6c2b00bff70..b6afb12baa4 100644 --- a/src/scripts/changeTracker.test.ts +++ b/src/scripts/changeTracker.test.ts @@ -2,7 +2,15 @@ import { fromPartial } from '@total-typescript/shoehorn' import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' import { useSubgraphNavigationStore } from '@/stores/subgraphNavigationStore' import { useNodeOutputStore } from '@/stores/nodeOutputStore' -import { beforeEach, describe, expect, it, onTestFinished, vi } from 'vitest' +import { + assert, + beforeEach, + describe, + expect, + it, + onTestFinished, + vi +} from 'vitest' import { markRaw, ref } from 'vue' vi.mock(import('@vueuse/router'), () => ({ useRouteHash: () => ref('') })) @@ -189,6 +197,12 @@ describe('ChangeTracker', () => { () => {} ) app.rootGraph.subgraphs.clear() + vi.mocked(app.loadGraphData).mockImplementation(async (state) => { + const restored = await requireValidWorkflow(state) + useWorkflowStore().activeWorkflow?.changeTracker.reset(restored) + mockCanvasState(restored) + return true + }) }) describe('undoRedo', () => { @@ -1336,6 +1350,535 @@ describe('ChangeTracker', () => { }) describe('undo and redo', () => { + it('keeps Redo after Undo normalizes an interior node size', async () => { + const initial = await createSubgraphState() + const changed = structuredClone(initial) + getSubgraphDefinition(changed).nodes[0].widgets_values = [2] + const normalized = structuredClone(initial) + getSubgraphDefinition(normalized).nodes[0].size = [100, 178] + const tracker = createTracker(changed) + tracker.undoQueue.push(initial) + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(normalized) + mockCanvasState(normalized) + return true + }) + + await tracker.undo() + tracker.captureCanvasState() + + expect(tracker.undoQueue).toEqual([]) + expect(tracker.redoQueue).toEqual([changed]) + expect(tracker.activeState).toEqual(normalized) + await tracker.redo() + expect(tracker.activeState).toEqual(changed) + expect(tracker.undoQueue).toEqual([normalized]) + expect(tracker.redoQueue).toEqual([]) + }) + + it('clears Redo for an intentional resize after normalized Undo', async () => { + const initial = createState(1) + const changed = structuredClone(initial) + changed.nodes[0].widgets_values = [2] + const normalized = structuredClone(initial) + normalized.nodes[0].size = [100, 178] + const tracker = createTracker(changed) + tracker.undoQueue.push(initial) + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(normalized) + mockCanvasState(normalized) + return true + }) + await tracker.undo() + const resized = structuredClone(normalized) + resized.nodes[0].size = [350, 220] + mockCanvasState(resized) + + tracker.captureCanvasState() + + expect(tracker.redoQueue).toEqual([]) + expect(tracker.undoQueue).toEqual([normalized]) + expect(tracker.activeState).toEqual(resized) + await tracker.undo() + expect(tracker.activeState).toEqual(normalized) + await tracker.redo() + expect(tracker.activeState).toEqual(resized) + }) + + it.for(['undo', 'redo'] as const)( + 'keeps the restored workflow snapshot when another graph is configured during %s', + async (direction) => { + const restored = createState(1) + const changed = createState(2) + const normalized = structuredClone(restored) + normalized.nodes[0].size = [100, 178] + const tracker = createTracker(changed) + const history = { undo: tracker.undoQueue, redo: tracker.redoQueue } + history[direction].push(restored) + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(normalized) + mockCanvasState(createState(3)) + return true + }) + + await tracker[direction]() + + expect(tracker.activeState).toEqual(normalized) + expect(tracker.initialState).toEqual(changed) + expect(history[direction]).toEqual([]) + } + ) + + it('keeps the normalized snapshot if another workflow becomes active during Undo', async () => { + const initial = createState(1) + const tracker = createTracker(createState(2)) + tracker.undoQueue.push(initial) + const normalized = structuredClone(initial) + normalized.nodes[0].size = [100, 178] + const otherState = createState(3) + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(normalized) + createTracker(otherState) + mockCanvasState(otherState) + return true + }) + + await tracker.undo() + + expect(tracker.activeState).toEqual(normalized) + expect( + useWorkflowStore().activeWorkflow?.changeTracker.activeState + ).toEqual(otherState) + }) + + it('keeps Redo reachable when a load rejects after committing the normalized Undo state', async () => { + const saved = createState(1) + saved.nodes[0].widgets_values = [1] + const changed = structuredClone(saved) + changed.nodes[0].widgets_values = [2] + const normalized = structuredClone(saved) + normalized.nodes[0].size = [100, 178] + const tracker = createTracker(saved) + tracker.activeState = changed + tracker.undoQueue.push(saved) + const workflow = useWorkflowStore().activeWorkflow + assert.exists(workflow) + workflow.isModified = true + vi.mocked(useWorkflowStore().getWorkflowByPath).mockReturnValue(workflow) + const error = new Error('Post-load asset scan rejected') + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(normalized) + mockCanvasState(normalized) + throw error + }) + + await expect(tracker.undo()).rejects.toThrow(error) + + expect(tracker.activeState).toEqual(normalized) + expect(tracker.initialState).toEqual(normalized) + expect(tracker.undoQueue).toEqual([]) + expect(tracker.redoQueue).toEqual([changed]) + expect(workflow.isModified).toBe(false) + expect(tracker._restoringState).toBe(false) + await tracker.redo() + expect(tracker.activeState).toEqual(changed) + expect(workflow.isModified).toBe(true) + }) + + it('retains the Undo target when a same-workflow reload updates the tracker instead', async () => { + const saved = createState(1) + saved.nodes[0].widgets_values = [1] + const current = structuredClone(saved) + current.nodes[0].widgets_values = [2] + const reloaded = structuredClone(current) + reloaded.nodes[0].size = [100, 178] + const tracker = createTracker(saved) + tracker.activeState = current + tracker.undoQueue.push(saved) + const workflow = useWorkflowStore().activeWorkflow + assert.exists(workflow) + workflow.isModified = true + vi.mocked(useWorkflowStore().getWorkflowByPath).mockReturnValue(workflow) + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(reloaded) + mockCanvasState(reloaded) + return undefined + }) + + await tracker.undo() + + expect(tracker.activeState).toEqual(reloaded) + expect(tracker.initialState).toEqual(saved) + expect(tracker.undoQueue).toEqual([saved]) + expect(tracker.redoQueue).toEqual([]) + expect(workflow.isModified).toBe(true) + expect(tracker._restoringState).toBe(false) + }) + + it('keeps Redo when a late load error follows normalization of an interior node size', async () => { + const saved = await createSubgraphState() + const changed = structuredClone(saved) + getSubgraphDefinition(changed).nodes[0].widgets_values = [2] + const normalized = structuredClone(saved) + getSubgraphDefinition(normalized).nodes[0].size = [100, 178] + const tracker = createTracker(saved) + tracker.activeState = changed + tracker.undoQueue.push(saved) + const error = new Error('Post-load asset scan rejected') + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(normalized) + mockCanvasState(normalized) + throw error + }) + + await expect(tracker.undo()).rejects.toThrow(error) + + expect(tracker.activeState).toEqual(normalized) + expect(tracker.initialState).toEqual(normalized) + expect(tracker.undoQueue).toEqual([]) + expect(tracker.redoQueue).toEqual([changed]) + expect(tracker._restoringState).toBe(false) + }) + + it('retains the Undo target when an unrelated same-workflow reload precedes a late error', async () => { + const saved = createState(1) + saved.nodes[0].widgets_values = [1] + const current = structuredClone(saved) + current.nodes[0].widgets_values = [2] + const reloaded = structuredClone(current) + reloaded.nodes[0].size = [100, 178] + const tracker = createTracker(saved) + tracker.activeState = current + tracker.undoQueue.push(saved) + const workflow = useWorkflowStore().activeWorkflow + assert.exists(workflow) + workflow.isModified = true + vi.mocked(useWorkflowStore().getWorkflowByPath).mockReturnValue(workflow) + const error = new Error('Superseded Undo asset scan rejected') + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(reloaded) + mockCanvasState(reloaded) + throw error + }) + + await expect(tracker.undo()).rejects.toThrow(error) + + expect(tracker.activeState).toEqual(reloaded) + expect(tracker.initialState).toEqual(saved) + expect(tracker.undoQueue).toEqual([saved]) + expect(tracker.redoQueue).toEqual([]) + expect(workflow.isModified).toBe(true) + expect(tracker._restoringState).toBe(false) + }) + + it('retains a resize Undo target when an unrelated reload changes only the node size', async () => { + const saved = createState(1) + const current = structuredClone(saved) + current.nodes[0].size = [400, 220] + const reloaded = structuredClone(current) + reloaded.nodes[0].size = [400, 260] + const tracker = createTracker(saved) + tracker.activeState = current + tracker.undoQueue.push(saved) + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(reloaded) + mockCanvasState(reloaded) + return undefined + }) + + await tracker.undo() + + expect(tracker.activeState).toEqual(reloaded) + expect(tracker.initialState).toEqual(saved) + expect(tracker.undoQueue).toEqual([saved]) + expect(tracker.redoQueue).toEqual([]) + expect(tracker._restoringState).toBe(false) + }) + + it.for([ + { direction: 'undo', reverse: 'redo', start: 3, end: 1 }, + { direction: 'redo', reverse: 'undo', start: 1, end: 3 } + ] as const)( + 'applies both overlapping $direction requests', + async ({ direction, reverse, start, end }) => { + vi.useFakeTimers() + onTestFinished(() => { + vi.useRealTimers() + }) + const current = createState(start) + const intermediate = createState(2) + const final = createState(end) + const tracker = createTracker(current) + const history = { undo: tracker.undoQueue, redo: tracker.redoQueue } + history[direction].push(final, intermediate) + const loadGraphData = vi + .mocked(app.loadGraphData) + .getMockImplementation() + assert.exists(loadGraphData) + vi.mocked(app.loadGraphData).mockImplementationOnce(async (...args) => { + await new Promise((resolve) => setTimeout(resolve, 5)) + return loadGraphData(...args) + }) + + const requests = Promise.all([ + tracker[direction](), + tracker[direction]() + ]) + await vi.advanceTimersByTimeAsync(5) + await requests + + expect(tracker.activeState).toEqual(final) + expect(history[direction]).toEqual([]) + expect(history[reverse]).toEqual([current, intermediate]) + expect(tracker._restoringState).toBe(false) + } + ) + + it.for([ + { first: 'undo', second: 'redo' }, + { first: 'redo', second: 'undo' } + ] as const)( + 'applies overlapping $first then $second requests in order', + async ({ first, second }) => { + vi.useFakeTimers() + onTestFinished(() => { + vi.useRealTimers() + }) + const current = createState(3) + const previous = createState(2) + const tracker = createTracker(current) + const history = { undo: tracker.undoQueue, redo: tracker.redoQueue } + history[first].push(previous) + const loadGraphData = vi + .mocked(app.loadGraphData) + .getMockImplementation() + assert.exists(loadGraphData) + vi.mocked(app.loadGraphData).mockImplementationOnce(async (...args) => { + await new Promise((resolve) => setTimeout(resolve, 5)) + return loadGraphData(...args) + }) + + const requests = Promise.all([tracker[first](), tracker[second]()]) + await vi.advanceTimersByTimeAsync(5) + await requests + + expect(tracker.activeState).toEqual(current) + expect(history[first]).toEqual([previous]) + expect(history[second]).toEqual([]) + expect(tracker._restoringState).toBe(false) + } + ) + + it.for([false, undefined])( + 'processes a queued Undo after the pending restore returns %s', + async (result) => { + vi.useFakeTimers() + onTestFinished(() => { + vi.useRealTimers() + }) + const earlier = createState(1) + const previous = createState(2) + const current = createState(3) + const tracker = createTracker(current) + tracker.undoQueue.push(earlier, previous) + vi.mocked(app.loadGraphData).mockImplementationOnce( + () => new Promise((resolve) => setTimeout(() => resolve(result), 5)) + ) + + const requests = Promise.all([tracker.undo(), tracker.undo()]) + await vi.advanceTimersByTimeAsync(0) + expect(tracker.activeState).toEqual(current) + expect(tracker.undoQueue).toEqual([earlier]) + expect(tracker.redoQueue).toEqual([]) + await vi.advanceTimersByTimeAsync(5) + await requests + + expect(tracker.activeState).toEqual(previous) + expect(tracker.undoQueue).toEqual([earlier]) + expect(tracker.redoQueue).toEqual([current]) + expect(tracker._restoringState).toBe(false) + } + ) + + it.for([ + { direction: 'undo', reverse: 'redo' }, + { direction: 'redo', reverse: 'undo' } + ] as const)( + 'processes a queued $direction after the pending restore rejects', + async ({ direction, reverse }) => { + const current = createState(3) + const previous = createState(2) + const tracker = createTracker(current) + const history = { undo: tracker.undoQueue, redo: tracker.redoQueue } + history[direction].push(previous) + const error = new Error('Workflow load rejected') + vi.mocked(app.loadGraphData).mockRejectedValueOnce(error) + + const results = await Promise.allSettled([ + tracker[direction](), + tracker[direction]() + ]) + + expect(results).toEqual([ + { status: 'rejected', reason: error }, + { status: 'fulfilled', value: undefined } + ]) + expect(tracker.activeState).toEqual(previous) + expect(history[direction]).toEqual([]) + expect(history[reverse]).toEqual([current]) + expect(tracker._restoringState).toBe(false) + } + ) + + it('serializes distinct workflow requests after a pending Undo', async () => { + vi.useFakeTimers() + onTestFinished(() => { + vi.useRealTimers() + }) + const earlier = createState(1) + const previous = createState(2) + const current = createState(3) + const firstSelection = createState(4) + const secondSelection = createState(5) + const firstSource = [firstSelection] + const secondSource = [secondSelection] + const tracker = createTracker(current) + tracker.undoQueue.push(earlier, previous) + let releasePending!: () => void + const pending = new Promise((resolve) => { + releasePending = resolve + }) + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + await pending + tracker.reset(previous) + mockCanvasState(previous) + return true + }) + + const undo = tracker.undo() + let selectionFinished = false + const firstRequest = tracker + .updateState(firstSource, tracker.undoQueue) + .then(() => { + selectionFinished = true + }) + const secondRequest = tracker.updateState(secondSource, tracker.undoQueue) + try { + await vi.advanceTimersByTimeAsync(0) + expect(selectionFinished).toBe(false) + } finally { + releasePending() + await Promise.all([undo, firstRequest, secondRequest]) + } + + expect(tracker.activeState).toEqual(secondSelection) + expect(tracker.undoQueue).toEqual([earlier, previous, firstSelection]) + expect(tracker.redoQueue).toEqual([current]) + expect(firstSource).toEqual([]) + expect(secondSource).toEqual([]) + }) + + it.for([false, undefined])( + 'preserves state and history when restoration returns %s', + async (result) => { + const initial = createState(1) + const current = createState(2) + const tracker = createTracker(current) + tracker.undoQueue.push(initial) + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + expect(tracker.activeState).toEqual(current) + mockCanvasState(createState(3)) + return result + }) + + await tracker.undo() + + expect(tracker.activeState).toEqual(current) + expect(tracker.undoQueue).toEqual([initial]) + expect(tracker.redoQueue).toEqual([]) + expect(api.dispatchCustomEvent).not.toHaveBeenCalled() + expect(tracker._restoringState).toBe(false) + } + ) + + it('preserves state and history when restoration rejects', async () => { + const initial = createState(1) + const current = createState(2) + const tracker = createTracker(current) + tracker.undoQueue.push(initial) + const error = new Error('Workflow load rejected') + vi.mocked(app.loadGraphData).mockRejectedValueOnce(error) + + await expect(tracker.undo()).rejects.toThrow(error) + + expect(tracker.activeState).toEqual(current) + expect(tracker.undoQueue).toEqual([initial]) + expect(tracker.redoQueue).toEqual([]) + expect(api.dispatchCustomEvent).not.toHaveBeenCalled() + expect(tracker._restoringState).toBe(false) + }) + + it.for([ + { + direction: 'undo', + reverse: 'redo', + restoresSaved: true, + restoredValue: 1, + modified: false + }, + { + direction: 'redo', + reverse: 'undo', + restoresSaved: true, + restoredValue: 1, + modified: false + }, + { + direction: 'undo', + reverse: 'redo', + restoresSaved: false, + restoredValue: 3, + modified: true + } + ] as const)( + 'tracks unsaved changes after $direction normalizes a node (saved target: $restoresSaved)', + async ({ direction, reverse, restoredValue, modified }) => { + const saved = createState(1) + saved.nodes[0].widgets_values = [1] + const current = structuredClone(saved) + current.nodes[0].widgets_values = [2] + const restored = structuredClone(saved) + restored.nodes[0].widgets_values = [restoredValue] + const normalized = structuredClone(restored) + normalized.nodes[0].size = [100, 178] + const tracker = createTracker(saved) + tracker.activeState = current + const workflow = useWorkflowStore().activeWorkflow + assert.exists(workflow) + vi.mocked(useWorkflowStore().getWorkflowByPath).mockReturnValue( + workflow + ) + const history = { undo: tracker.undoQueue, redo: tracker.redoQueue } + history[direction].push(restored) + vi.mocked(app.loadGraphData).mockImplementationOnce(async () => { + tracker.reset(normalized) + mockCanvasState(normalized) + return true + }) + + await tracker[direction]() + tracker.captureCanvasState() + + expect(workflow.isModified).toBe(modified) + expect(tracker.activeState).toEqual(normalized) + expect(history[direction]).toEqual([]) + expect(history[reverse]).toEqual([current]) + await tracker[reverse]() + expect(tracker.activeState).toEqual(current) + expect(workflow.isModified).toBe(true) + } + ) + it('dispatches autoQueueGraphChanged for a data change in both directions', async () => { const initial = createState(1) const changed = structuredClone(initial) diff --git a/src/scripts/changeTracker.ts b/src/scripts/changeTracker.ts index e936b33d2b5..64654c6d15d 100644 --- a/src/scripts/changeTracker.ts +++ b/src/scripts/changeTracker.ts @@ -8,6 +8,7 @@ import { LGraphCanvas, LiteGraph } from '@/lib/litegraph/src/litegraph' import type { ComfyWorkflow } from '@/platform/workflow/management/stores/workflowStore' import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/workflowSchema' +import { collectSubgraphDefinitions } from '@/platform/workflow/core/utils/workflowFlattening' import type { ExecutedWsMessage } from '@/platform/remote/comfyui/execution/types' import { useDialogStore } from '@/stores/dialogStore' import { useExecutionStore } from '@/stores/executionStore' @@ -30,6 +31,40 @@ function withoutExecutionOrder(nodes: ComfyWorkflowJSON['nodes']) { return nodes.map((node) => _.omit(node, ['order'])) } +function withNormalizedNodeSizes(state: ComfyWorkflowJSON): ComfyWorkflowJSON { + const comparable = clone(state) + const subgraphs = collectSubgraphDefinitions( + comparable.definitions?.subgraphs ?? [] + ) + const nodes = [ + ...comparable.nodes, + ...subgraphs.flatMap((subgraph) => subgraph.nodes) + ] + for (const node of nodes) { + if ('size' in node) node.size = [0, 0] + } + return comparable +} + +function matchesRestoredTarget( + actual: ComfyWorkflowJSON, + target: ComfyWorkflowJSON, + previous: ComfyWorkflowJSON +): boolean { + if (ChangeTracker.graphEqual(actual, target)) return true + const comparableTarget = withNormalizedNodeSizes(target) + return ( + ChangeTracker.graphEqual( + withNormalizedNodeSizes(actual), + comparableTarget + ) && + !ChangeTracker.graphEqual( + comparableTarget, + withNormalizedNodeSizes(previous) + ) + ) +} + function isActiveTracker(tracker: ChangeTracker): boolean { return useWorkflowStore().activeWorkflow?.changeTracker === tracker } @@ -271,6 +306,7 @@ export class ChangeTracker { * Whether the redo/undo restoring is in progress. */ _restoringState: boolean = false + private restoreChain?: Promise ds?: { scale: number; offset: [number, number] } nodeOutputs?: Partial> @@ -296,10 +332,9 @@ export class ChangeTracker { * Save the current state as the initial state. */ reset(state?: ComfyWorkflowJSON) { - // Do not reset the state if we are restoring. + if (state) this.activeState = clone(state) if (this._restoringState) return - if (state) this.activeState = clone(state) this.initialState = clone(this.activeState) } @@ -469,22 +504,49 @@ export class ChangeTracker { } async updateState(source: ComfyWorkflowJSON[], target: ComfyWorkflowJSON[]) { - const prevState = source.pop() - if (prevState) { - const previousState = this.activeState - target.push(previousState) - this._restoringState = true - try { - await app.loadGraphData(prevState, false, false, this.workflow, { - checkForRerouteMigration: false, - silentAssetErrors: true - }) - this.activeState = prevState - this.updateModified(previousState) - } finally { - this._restoringState = false + const restore = async () => { + if (this._restoringState || source.length === 0) return + const prevState = source.pop() + if (prevState) { + const previousState = this.activeState + const restoresSavedState = ChangeTracker.graphEqual( + prevState, + this.initialState + ) + let restored = false + this._restoringState = true + try { + const result = await app.loadGraphData( + prevState, + false, + false, + this.workflow, + { + checkForRerouteMigration: false, + silentAssetErrors: true + } + ) + restored = result !== false && result !== undefined + } finally { + this._restoringState = false + restored ||= + !ChangeTracker.graphEqual(this.activeState, previousState) && + matchesRestoredTarget(this.activeState, prevState, previousState) + if (restored) { + target.push(previousState) + if (restoresSavedState) this.initialState = clone(this.activeState) + } else { + source.push(prevState) + } + if (restored) this.updateModified(previousState) + } } } + this.restoreChain = (this.restoreChain ?? Promise.resolve()).then( + restore, + restore + ) + return this.restoreChain } async undo() { diff --git a/src/stores/modelToNodeStore.test.ts b/src/stores/modelToNodeStore.test.ts index 22566c61ca9..a2f8cdf6198 100644 --- a/src/stores/modelToNodeStore.test.ts +++ b/src/stores/modelToNodeStore.test.ts @@ -45,6 +45,8 @@ const MOCK_NODE_NAMES = [ 'ImageOnlyCheckpointLoader', 'LoraLoader', 'LoraLoaderModelOnly', + 'LoadLoraModel', + 'LoadLoraTextEncoder', 'VAELoader', 'ControlNetLoader', 'UNETLoader', @@ -242,6 +244,51 @@ describe('useModelToNodeStore', () => { ) }) + it('does not treat an auto-loading provider as an asset widget', () => { + expect(useModelToNodeStore().isModelWidget('FL_ChatterboxVC', '')).toBe( + false + ) + }) + + it('supports repeated model fields registered outside the default mappings', () => { + const store = useModelToNodeStore() + store.registerNodeProvider( + 'vae', + new ModelNodeProvider(createMockNodeDef('MultiVAE'), /^items\.\d+\.file$/) + ) + + expect(store.isModelWidget('MultiVAE', 'items.3.file')).toBe(true) + expect(store.isModelWidget('MultiVAE', 'items.3.strength')).toBe(false) + expect(store.getCategoryForNodeType('MultiVAE')).toBe('vae') + }) + + it('matches string selectors literally, including regex characters', () => { + const store = useModelToNodeStore() + store.quickRegister('vae', 'VAELoader', 'items.*.file') + + expect(store.isModelWidget('VAELoader', 'items.*.file')).toBe(true) + expect(store.isModelWidget('VAELoader', 'items.3.file')).toBe(false) + }) + + it.for(['g', 'y'])( + 'keeps repeated widget checks stable with the %s flag', + (flags) => { + const store = useModelToNodeStore() + store.registerNodeProvider( + 'vae', + new ModelNodeProvider( + createMockNodeDef('MultiVAE'), + new RegExp(/^items\.\d+\.file$/, flags) + ) + ) + + expect(store.isModelWidget('MultiVAE', 'items.1.file')).toBe(true) + expect(store.isModelWidget('MultiVAE', 'items.1.file')).toBe(true) + expect(store.isModelWidget('MultiVAE', 'items.2.file')).toBe(true) + expect(store.isModelWidget('MultiVAE', 'items.2.strength')).toBe(false) + } + ) + describe('getAllNodeProviders', () => { it('should return all providers for model type with multiple nodes', () => { const modelToNodeStore = useModelToNodeStore() @@ -264,7 +311,7 @@ describe('useModelToNodeStore', () => { ) const loraProviders = modelToNodeStore.getAllNodeProviders('loras') - expect(loraProviders).toHaveLength(3) + expect(loraProviders).toHaveLength(5) expect(loraProviders).toEqual( expect.arrayContaining([ expect.objectContaining({ diff --git a/src/stores/modelToNodeStore.ts b/src/stores/modelToNodeStore.ts index 77695de20aa..1c8650687f4 100644 --- a/src/stores/modelToNodeStore.ts +++ b/src/stores/modelToNodeStore.ts @@ -4,16 +4,17 @@ import { computed, ref } from 'vue' import { MODEL_NODE_MAPPINGS } from '@/platform/assets/mappings/modelNodeMappings' import type { ComfyNodeDefImpl } from '@/stores/nodeDefStore' import { useNodeDefStore } from '@/stores/nodeDefStore' +import { matchesWidgetName } from '@/utils/widgetBinding' /** Helper class that defines how to construct a node from a model. */ export class ModelNodeProvider { /** The node definition to use for this model. */ public nodeDef: ComfyNodeDefImpl - /** The node input key for where to insert the model name. */ - public key: string + /** The input name or pattern used to select the model widget. */ + public key: string | RegExp - constructor(nodeDef: ComfyNodeDefImpl, key: string) { + constructor(nodeDef: ComfyNodeDefImpl, key: string | RegExp) { this.nodeDef = nodeDef this.key = key } @@ -25,15 +26,16 @@ export const useModelToNodeStore = defineStore('modelToNode', () => { const nodeDefStore = useNodeDefStore() const haveDefaultsLoaded = ref(false) - /** Internal computed for reactive caching of registered node types */ - const registeredNodeTypes = computed>(() => { - return Object.fromEntries( + const registeredNodeTypes = computed< + Partial> + >(() => + Object.fromEntries( Object.values(modelToNodeMap.value) .filter((providers) => providers !== undefined) .flat() .map((provider) => [provider.nodeDef.name, provider.key]) ) - }) + ) /** Internal computed for efficient reverse lookup: nodeType -> category */ const nodeTypeToCategory = computed(() => { @@ -51,11 +53,16 @@ export const useModelToNodeStore = defineStore('modelToNode', () => { }) /** Get set of all registered node types for efficient lookup */ - function getRegisteredNodeTypes(): Record { + function getRegisteredNodeTypes(): Partial> { registerDefaults() return registeredNodeTypes.value } + function isModelWidget(nodeType: string, widgetName: string): boolean { + const key = getRegisteredNodeTypes()[nodeType] + return key !== undefined && matchesWidgetName(widgetName, key) + } + /** * Get the category for a given node type. * Performs efficient O(1) lookup using cached reverse map. @@ -125,7 +132,9 @@ export const useModelToNodeStore = defineStore('modelToNode', () => { */ function registerNodeProvider( modelType: string, - nodeProvider: ModelNodeProvider | { nodeDef: undefined; key: string } + nodeProvider: + | ModelNodeProvider + | { nodeDef: undefined; key: string | RegExp } ) { registerDefaults() if (!nodeProvider.nodeDef) return @@ -138,7 +147,11 @@ export const useModelToNodeStore = defineStore('modelToNode', () => { * @param nodeClass The node class name to register. * @param key The key to use for the node input. */ - function quickRegister(modelType: string, nodeClass: string, key: string) { + function quickRegister( + modelType: string, + nodeClass: string, + key: string | RegExp + ) { registerNodeProvider( modelType, new ModelNodeProvider(nodeDefStore.nodeDefsByName[nodeClass], key) @@ -162,6 +175,7 @@ export const useModelToNodeStore = defineStore('modelToNode', () => { return { modelToNodeMap, getRegisteredNodeTypes, + isModelWidget, getCategoryForNodeType, getNodeProvider, getAllNodeProviders, diff --git a/src/utils/widgetBinding.ts b/src/utils/widgetBinding.ts new file mode 100644 index 00000000000..13d96408cbd --- /dev/null +++ b/src/utils/widgetBinding.ts @@ -0,0 +1,16 @@ +export interface WidgetValueBinding { + selector: string | RegExp + value: string +} + +export function matchesWidgetName( + name: string, + selector: string | RegExp +): boolean { + return ( + name !== '' && + (typeof selector === 'string' + ? name === selector + : name.search(selector) !== -1) + ) +}