diff --git a/browser_tests/assets/missing/node_replacement_dynamic.json b/browser_tests/assets/missing/node_replacement_dynamic.json new file mode 100644 index 00000000000..213bb4c313f --- /dev/null +++ b/browser_tests/assets/missing/node_replacement_dynamic.json @@ -0,0 +1,176 @@ +{ + "last_node_id": 6, + "last_link_id": 4, + "nodes": [ + { + "id": 1, + "type": "LoadImage", + "pos": [50, 100], + "size": [315, 314], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [1], + "slot_index": 0 + }, + { + "name": "MASK", + "type": "MASK", + "links": null + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": ["example.png", "image"] + }, + { + "id": 2, + "type": "E2E_OldImageBatch", + "pos": [450, 100], + "size": [210, 46], + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [ + { + "name": "image1", + "type": "IMAGE", + "link": 1 + }, + { + "name": "image2", + "type": "IMAGE", + "link": 2 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [3], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "E2E_OldImageBatch" + }, + "widgets_values": [] + }, + { + "id": 3, + "type": "E2E_OldImageScaleBy", + "pos": [750, 100], + "size": [315, 82], + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 3 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [4], + "slot_index": 0 + } + ], + "properties": { + "Node name for S&R": "E2E_OldImageScaleBy" + }, + "widgets_values": ["lanczos", 1.5] + }, + { + "id": 4, + "type": "SaveImage", + "pos": [1150, 100], + "size": [315, 270], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 4 + } + ], + "outputs": [], + "properties": {}, + "widgets_values": ["ComfyUI"] + }, + { + "id": 5, + "type": "E2E_OldAdapterLoader", + "pos": [450, 400], + "size": [315, 58], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "CONTROL_NET", + "type": "CONTROL_NET", + "links": null + } + ], + "properties": { + "Node name for S&R": "E2E_OldAdapterLoader" + }, + "widgets_values": ["t2iadapter_model.safetensors"] + }, + { + "id": 6, + "type": "LoadImage", + "pos": [50, 500], + "size": [315, 314], + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [2], + "slot_index": 0 + }, + { + "name": "MASK", + "type": "MASK", + "links": null + } + ], + "properties": { + "Node name for S&R": "LoadImage" + }, + "widgets_values": ["example.png", "image"] + } + ], + "links": [ + [1, 1, 0, 2, 0, "IMAGE"], + [2, 6, 0, 2, 1, "IMAGE"], + [3, 2, 0, 3, 0, "IMAGE"], + [4, 3, 0, 4, 0, "IMAGE"] + ], + "groups": [], + "config": {}, + "extra": { + "ds": { + "scale": 1, + "offset": [0, 0] + } + }, + "version": 0.4 +} diff --git a/browser_tests/fixtures/data/nodeReplacements.ts b/browser_tests/fixtures/data/nodeReplacements.ts index 6fb79bfde05..b88cc11102b 100644 --- a/browser_tests/fixtures/data/nodeReplacements.ts +++ b/browser_tests/fixtures/data/nodeReplacements.ts @@ -41,6 +41,50 @@ export const mockNodeReplacements: NodeReplacementResponse = { ] } +/** + * Mirrors ComfyUI's built-in replacements whose targets use Autogrow and + * DynamicCombo inputs, or that omit `old_widget_ids`. + */ +export const mockDynamicInputReplacements: NodeReplacementResponse = { + E2E_OldImageBatch: [ + { + new_node_id: 'BatchImagesNode', + old_node_id: 'E2E_OldImageBatch', + old_widget_ids: null, + input_mapping: [ + { new_id: 'images.image0', old_id: 'image1' }, + { new_id: 'images.image1', old_id: 'image2' } + ], + output_mapping: null + } + ], + E2E_OldImageScaleBy: [ + { + new_node_id: 'ResizeImageMaskNode', + old_node_id: 'E2E_OldImageScaleBy', + old_widget_ids: ['upscale_method', 'scale_by'], + input_mapping: [ + { new_id: 'input', old_id: 'image' }, + { new_id: 'resize_type', set_value: 'scale by multiplier' }, + { new_id: 'resize_type.multiplier', old_id: 'scale_by' }, + { new_id: 'scale_method', old_id: 'upscale_method' } + ], + output_mapping: null + } + ], + E2E_OldAdapterLoader: [ + { + new_node_id: 'ControlNetLoader', + old_node_id: 'E2E_OldAdapterLoader', + old_widget_ids: null, + input_mapping: [ + { new_id: 'control_net_name', old_id: 't2i_adapter_name' } + ], + output_mapping: null + } + ] +} + /** Subset containing only the E2E_OldSampler replacement. */ export const mockNodeReplacementsSingle: NodeReplacementResponse = { E2E_OldSampler: mockNodeReplacements.E2E_OldSampler diff --git a/browser_tests/tests/nodeReplacement.spec.ts b/browser_tests/tests/nodeReplacement.spec.ts index 55f536987a9..0247dc11e5f 100644 --- a/browser_tests/tests/nodeReplacement.spec.ts +++ b/browser_tests/tests/nodeReplacement.spec.ts @@ -3,6 +3,7 @@ import { comfyExpect as expect } from '@e2e/fixtures/ComfyPage' import { + mockDynamicInputReplacements, mockNodeReplacements, mockNodeReplacementsSingle } from '@e2e/fixtures/data/nodeReplacements' @@ -12,6 +13,7 @@ import { setupNodeReplacement } from '@e2e/fixtures/helpers/NodeReplacementHelper' import { TestIds } from '@e2e/fixtures/selectors' +import { getInputNames } from '@e2e/fixtures/utils/nodeInputLinks' import { toNodeId } from '@comfyorg/graph-model/nodeId' const renderModes = [ @@ -51,6 +53,50 @@ test.describe('Node replacement', { tag: ['@node', '@ui'] }, () => { }) }) + test.describe('Dynamic input replacement', () => { + test.beforeEach(async ({ comfyPage }) => { + await setupNodeReplacement(comfyPage, mockDynamicInputReplacements) + await loadWorkflowAndOpenErrorsTab( + comfyPage, + 'missing/node_replacement_dynamic' + ) + }) + + test('Replacing into Autogrow and DynamicCombo inputs keeps links and values', async ({ + comfyPage + }) => { + const swapGroup = getSwapNodesGroup(comfyPage.page) + await swapGroup + .getByRole('button', { name: 'Replace All', exact: true }) + .click() + await expect(swapGroup).toBeHidden() + + const prompt = await comfyPage.workflow.getExportedWorkflow({ api: true }) + expect(prompt['2']).toMatchObject({ + class_type: 'BatchImagesNode', + inputs: { 'images.image0': ['1', 0], 'images.image1': ['6', 0] } + }) + await expect + .poll(() => getInputNames(comfyPage, '2', 'images.'), { + message: 'Autogrow should offer an empty slot after the moved links' + }) + .toEqual(['images.image0', 'images.image1', 'images.image2']) + expect(prompt['3']).toMatchObject({ + class_type: 'ResizeImageMaskNode', + inputs: { + input: ['2', 0], + resize_type: 'scale by multiplier', + 'resize_type.multiplier': 1.5, + scale_method: 'lanczos' + } + }) + expect(prompt['5']).toMatchObject({ + class_type: 'ControlNetLoader', + inputs: { control_net_name: 't2iadapter_model.safetensors' } + }) + }) + }) + for (const mode of renderModes) { test.describe( `(${mode.name})`, diff --git a/src/platform/workflowErrors/nodeReplacement/useNodeReplacement.test.ts b/src/platform/workflowErrors/nodeReplacement/useNodeReplacement.test.ts index 1907851d606..5a1fbb2b00b 100644 --- a/src/platform/workflowErrors/nodeReplacement/useNodeReplacement.test.ts +++ b/src/platform/workflowErrors/nodeReplacement/useNodeReplacement.test.ts @@ -728,6 +728,140 @@ describe('useNodeReplacement', () => { ).toHaveBeenCalledTimes(1) }) + it('assigns a dynamic child value mapped before the value that creates it', () => { + const placeholder = createPlaceholderNode(1, 'OldScaler') + placeholder.last_serialization!.widgets_values = [1.5, 'multiplier'] + const graph = createMockGraph([placeholder]) + placeholder.graph = graph + Object.assign(app, { rootGraph: graph }) + vi.mocked(collectAllNodes).mockReturnValue([placeholder]) + + const newNode = createNewNode( + [], + [], + [{ name: 'resize_type', value: '' }] + ) + const resizeType = newNode.widgets![0] + let resizeTypeValue: unknown = '' + Object.defineProperty(resizeType, 'value', { + get: () => resizeTypeValue, + set(value) { + resizeTypeValue = value + newNode.widgets!.splice(1, Infinity, { + ...resizeType, + name: 'resize_type.multiplier', + value: 1 + }) + } + }) + vi.mocked(LiteGraph.createNode).mockReturnValue(newNode) + + useNodeReplacement().replaceNodesInPlace([ + makeMissingNodeType('OldScaler', { + new_node_id: 'NewScaler', + old_node_id: 'OldScaler', + old_widget_ids: ['scale_by', 'mode'], + input_mapping: [ + { new_id: 'resize_type.multiplier', old_id: 'scale_by' }, + { new_id: 'resize_type', old_id: 'mode' } + ], + output_mapping: null + }) + ]) + + expect( + graph.getNodeById(toNodeId(1))!.widgets!.map((widget) => widget.value) + ).toEqual(['multiplier', 1.5]) + }) + + it('lets the later mapping win when two mappings target one widget', () => { + const placeholder = createPlaceholderNode(1, 'OldScaler') + placeholder.last_serialization!.widgets_values = ['saved'] + const graph = createMockGraph([placeholder]) + placeholder.graph = graph + Object.assign(app, { rootGraph: graph }) + vi.mocked(collectAllNodes).mockReturnValue([placeholder]) + + const newNode = createNewNode([], [], [{ name: 'mode', value: '' }]) + vi.mocked(LiteGraph.createNode).mockReturnValue(newNode) + + useNodeReplacement().replaceNodesInPlace([ + makeMissingNodeType('OldScaler', { + new_node_id: 'NewScaler', + old_node_id: 'OldScaler', + old_widget_ids: ['mode'], + input_mapping: [ + { new_id: 'mode', old_id: 'mode' }, + { new_id: 'mode', set_value: 'forced' } + ], + output_mapping: null + }) + ]) + + expect(graph.getNodeById(toNodeId(1))!.widgets![0].value).toBe('forced') + }) + + it('keeps a restored value that an earlier widget callback resets', () => { + const placeholder = createPlaceholderNode(1, 'OldSampler') + placeholder.last_serialization!.widgets_values = ['portrait', 7] + const graph = createMockGraph([placeholder]) + placeholder.graph = graph + Object.assign(app, { rootGraph: graph }) + vi.mocked(collectAllNodes).mockReturnValue([placeholder]) + + const newNode = createNewNode( + [], + [], + [ + { name: 'preset', value: '' }, + { name: 'steps', value: 0 } + ] + ) + newNode.widgets![0].callback = () => { + newNode.widgets![1].value = 20 + } + vi.mocked(LiteGraph.createNode).mockReturnValue(newNode) + + useNodeReplacement().replaceNodesInPlace([ + makeMissingNodeType('OldSampler', { + new_node_id: 'NewSampler', + old_node_id: 'OldSampler', + old_widget_ids: ['preset', 'steps'], + input_mapping: [ + { new_id: 'preset', old_id: 'preset' }, + { new_id: 'steps', old_id: 'steps' } + ], + output_mapping: null + }) + ]) + + expect( + graph.getNodeById(toNodeId(1))!.widgets!.map((widget) => widget.value) + ).toEqual(['portrait', 7]) + }) + + it('replaces a node reached through two instances of one subgraph once', () => { + const placeholder = createPlaceholderNode(1, 'OldType') + const graph = createMockGraph([placeholder]) + placeholder.graph = graph + Object.assign(app, { rootGraph: graph }) + vi.mocked(collectAllNodes).mockReturnValue([placeholder, placeholder]) + vi.mocked(LiteGraph.createNode).mockReturnValue(createNewNode()) + + const result = useNodeReplacement().replaceNodesInPlace([ + makeMissingNodeType('OldType', { + new_node_id: 'NewType', + old_node_id: 'OldType', + old_widget_ids: null, + input_mapping: null, + output_mapping: null + }) + ]) + + expect(result).toEqual(['OldType']) + expect(useToast().error).not.toHaveBeenCalled() + }) + it('should transfer widget values using old_widget_ids', () => { const placeholder = createPlaceholderNode(1, 'ResizeImagesByLongerEdge') // Set widget values in serialized data @@ -1089,19 +1223,26 @@ describe('useNodeReplacement', () => { expect(newNode.widgets![0].value).toBe(0.75) }) - it('should skip dot-notation input connections but still transfer widget values', () => { - const placeholder = createPlaceholderNode(1, 'ImageBatch') - const graph = createMockGraph([placeholder]) + it('moves input links onto dotted dynamic input names', () => { + const firstLink = createMockLink(30, 5, 0, 1, 0) + const secondLink = createMockLink(31, 6, 0, 1, 1) + const placeholder = createPlaceholderNode(1, 'ImageBatch', [ + { name: 'image1', link: 30 }, + { name: 'image2', link: 31 } + ]) + const graph = createMockGraph([placeholder], [firstLink, secondLink]) placeholder.graph = graph Object.assign(app, { rootGraph: graph }) vi.mocked(collectAllNodes).mockReturnValue([placeholder]) - const newNode = createNewNode([], []) + const newNode = createNewNode([ + { name: 'images.image1', link: null }, + { name: 'images.image0', link: null } + ]) vi.mocked(LiteGraph.createNode).mockReturnValue(newNode) - const { replaceNodesInPlace } = useNodeReplacement() - const result = replaceNodesInPlace([ + const result = useNodeReplacement().replaceNodesInPlace([ makeMissingNodeType('ImageBatch', { new_node_id: 'BatchImagesNode', old_node_id: 'ImageBatch', @@ -1114,8 +1255,11 @@ describe('useNodeReplacement', () => { }) ]) - // Should still succeed (dot-notation skipped gracefully) expect(result).toEqual(['ImageBatch']) + expect(graph.links.has(toLinkId(30))).toBe(true) + expect(graph.links.has(toLinkId(31))).toBe(true) + expect(firstLink.target_slot).toBe(1) + expect(secondLink.target_slot).toBe(0) }) }) @@ -1791,38 +1935,86 @@ describe('useNodeReplacement', () => { expect(newNode.widgets![0].value).toBe('bilinear') }) - it('skips set_value mapping when the new_id uses dot-notation', () => { - const placeholder = createPlaceholderNode(1, 'OldType') - placeholder.onRemoved = vi.fn() - const graph = createMockGraph([placeholder]) - placeholder.graph = graph - Object.assign(app, { rootGraph: graph }) - - vi.mocked(collectAllNodes).mockReturnValue([placeholder]) - - const newNode = createNewNode( - [{ name: 'input', link: null }], - [], - [{ name: 'resize_type', value: '' }] - ) - vi.mocked(LiteGraph.createNode).mockReturnValue(newNode) - - const { replaceNodesInPlace } = useNodeReplacement() - replaceNodesInPlace([ - makeMissingNodeType('OldType', { - new_node_id: 'NewType', - old_node_id: 'OldType', - old_widget_ids: null, - input_mapping: [ - // Dot-notation target — the set_value should NOT be applied. - { new_id: 'resize_type.multiplier', set_value: 'dot-notation-skip' } - ], - output_mapping: null + it.for([ + { + name: 'saved names without old_widget_ids', + inputs: [], + widgetsValues: ['a.safetensors', 0.4], + widgetsValuesNamed: { model_name: 'a.safetensors', strength: 0.4 }, + oldWidgetIds: null, + expected: ['a.safetensors', 0.4] + }, + { + name: 'saved names over disagreeing old_widget_ids', + inputs: [], + widgetsValues: ['a.safetensors', 0.4], + widgetsValuesNamed: { model_name: 'a.safetensors', strength: 0.4 }, + oldWidgetIds: ['strength', 'model_name'], + expected: ['a.safetensors', 0.4] + }, + { + name: 'a lone positional value for the lone mapped widget', + inputs: [{ name: 'strength', link: null }], + widgetsValues: ['a.safetensors'], + widgetsValuesNamed: undefined, + oldWidgetIds: null, + expected: ['a.safetensors', 1] + }, + { + name: 'no values when positional values are ambiguous', + inputs: [], + widgetsValues: ['a.safetensors', 0.4], + widgetsValuesNamed: undefined, + oldWidgetIds: null, + expected: ['', 1] + } + ])( + 'transfers widget values from $name', + ({ + inputs, + widgetsValues, + widgetsValuesNamed, + oldWidgetIds, + expected + }) => { + const placeholder = createPlaceholderNode(1, 'OldLoader', inputs) + Object.assign(placeholder.last_serialization!, { + widgets_values: widgetsValues, + widgets_values_named: widgetsValuesNamed }) - ]) + const graph = createMockGraph([placeholder]) + placeholder.graph = graph + Object.assign(app, { rootGraph: graph }) + vi.mocked(collectAllNodes).mockReturnValue([placeholder]) - expect(newNode.widgets![0].value).toBe('') - }) + const newNode = createNewNode( + [], + [], + [ + { name: 'model', value: '' }, + { name: 'strength', value: 1 } + ] + ) + vi.mocked(LiteGraph.createNode).mockReturnValue(newNode) + + useNodeReplacement().replaceNodesInPlace([ + makeMissingNodeType('OldLoader', { + new_node_id: 'NewLoader', + old_node_id: 'OldLoader', + old_widget_ids: oldWidgetIds, + input_mapping: [ + { new_id: 'model', old_id: 'model_name' }, + { new_id: 'strength', old_id: 'strength' } + ], + output_mapping: null + }) + ]) + + expect( + graph.getNodeById(toNodeId(1))!.widgets!.map((widget) => widget.value) + ).toEqual(expected) + } + ) it('invokes nodeGraph.onNodeAdded for each replaced node so VueNode data refreshes', () => { const placeholder = createPlaceholderNode(1, 'OldType') diff --git a/src/platform/workflowErrors/nodeReplacement/useNodeReplacement.ts b/src/platform/workflowErrors/nodeReplacement/useNodeReplacement.ts index d3fe0676275..fa76452af5d 100644 --- a/src/platform/workflowErrors/nodeReplacement/useNodeReplacement.ts +++ b/src/platform/workflowErrors/nodeReplacement/useNodeReplacement.ts @@ -2,9 +2,14 @@ import { canTransferReplacementOwnership, transferReplacementOwnership } from '@/core/graph/nodeShell/nodeShellState' +import { growAutogrowInput } from '@/core/graph/widgets/dynamicWidgets' import type { LGraph, LGraphNode } from '@/lib/litegraph/src/litegraph' import { LiteGraph } from '@/lib/litegraph/src/litegraph' -import { inputLinkId, outputLinks } from '@/lib/litegraph/src/node/slotLinks' +import { + inputLink, + inputLinkId, + outputLinks +} from '@/lib/litegraph/src/node/slotLinks' import type { LLink } from '@/lib/litegraph/src/LLink' import type { ISerialisedNode } from '@comfyorg/graph-model/serialisation' import { NodeSlotType } from '@comfyorg/graph-model/globalEnums' @@ -31,6 +36,11 @@ import type { LinkId } from '@comfyorg/graph-model/linkId' import type { LinkTopology } from '@comfyorg/graph-model/linkTopology' import { collectAllNodes } from '@/utils/graphTraversalUtil' +interface WidgetAssignment { + name: string + value: TWidgetValue +} + interface ReplacementGroup { type: string nodeTypes: MissingNodeType[] @@ -83,7 +93,7 @@ function planReplacementTopology( } for (const inputMap of replacement.input_mapping ?? []) { - if (!('old_id' in inputMap) || isDotNotation(inputMap.new_id)) continue + if (!('old_id' in inputMap)) continue const oldSlot = oldNode.inputs.findIndex( (input) => input.name === inputMap.old_id ) @@ -150,51 +160,72 @@ function planReplacementTopology( return { error, updates: [...updates.values()], removals } } -/** Uses old_widget_ids as name→index lookup into widgets_values. */ -function transferWidgetValue( +function savedWidgetValues( serialized: ISerialisedNode, - oldWidgetIds: string[] | null, - oldInputName: string, - newNode: LGraphNode, - newInputName: string -): void { - if (!oldWidgetIds || !serialized.widgets_values) return - - const oldWidgetIdx = oldWidgetIds.indexOf(oldInputName) - if (oldWidgetIdx === -1) return + replacement: NodeReplacement +): Record { + if (serialized.widgets_values_named) return serialized.widgets_values_named + const values = serialized.widgets_values ?? [] + const names = + replacement.old_widget_ids ?? + soleMappedWidgetName(serialized, replacement, values.length) + return Object.fromEntries( + names.flatMap((name, idx) => + values[idx] === undefined ? [] : [[name, values[idx]]] + ) + ) +} - const oldValue = serialized.widgets_values[oldWidgetIdx] - if (oldValue === undefined) return +function soleMappedWidgetName( + serialized: ISerialisedNode, + replacement: NodeReplacement, + valueCount: number +): string[] { + if (valueCount !== 1) return [] + const socketOnlyInputs = new Set( + serialized.inputs?.flatMap((input) => (input.widget ? [] : [input.name])) + ) + const widgetIds = (replacement.input_mapping ?? []).flatMap((inputMap) => + 'old_id' in inputMap && !socketOnlyInputs.has(inputMap.old_id) + ? [inputMap.old_id] + : [] + ) + return widgetIds.length === 1 ? widgetIds : [] +} - const newWidget = newNode.widgets?.find((w) => w.name === newInputName) - if (newWidget) { - try { - newWidget.value = oldValue - newWidget.callback?.(oldValue) - } catch (error) { - console.error(`Failed to transfer widget ${newInputName}`, error) - } - } +function mappingDepth(inputMap: { new_id: string }): number { + return inputMap.new_id.split('.').length } -function applySetValue( +function assignMappedInputs( newNode: LGraphNode, - inputName: string, - value: unknown -): void { - const widget = newNode.widgets?.find((w) => w.name === inputName) - if (widget) { + replacement: NodeReplacement, + savedValues: Record +): WidgetAssignment[] { + const assigned: WidgetAssignment[] = [] + function assign(name: string, value: unknown) { + const widget = newNode.widgets?.find((w) => w.name === name) + if (!widget) return try { widget.value = value as TWidgetValue - widget.callback?.(widget.value) + assigned.push({ name, value: widget.value }) } catch (error) { - console.error(`Failed to set widget ${inputName}`, error) + console.error(`Failed to set widget ${name}`, error) } } -} - -function isDotNotation(id: string): boolean { - return id.includes('.') + const inputMaps = [...(replacement.input_mapping ?? [])].sort( + (a, b) => mappingDepth(a) - mappingDepth(b) + ) + for (const inputMap of inputMaps) { + if ('set_value' in inputMap) { + assign(inputMap.new_id, inputMap.set_value) + continue + } + growAutogrowInput(newNode, inputMap.new_id) + if (Object.hasOwn(savedValues, inputMap.old_id)) + assign(inputMap.new_id, savedValues[inputMap.old_id]) + } + return assigned } /** Auto-generates identity mapping by name for same-structure replacements without backend mapping. */ @@ -266,6 +297,11 @@ function replaceWithMapping( newNode.properties['Node name for S&R'] = replacement.new_node_id } } + const assignedWidgets = assignMappedInputs( + newNode, + replacement, + savedWidgetValues(serialized, replacement) + ) const topologyPlan = planReplacementTopology( node, @@ -363,20 +399,14 @@ function replaceWithMapping( node.graph = null nodeGraph._nodes_by_id[newNode.id] = newNode - if (replacement.input_mapping) { - for (const inputMap of replacement.input_mapping) { - if ('old_id' in inputMap) { - if (isDotNotation(inputMap.new_id)) continue - transferWidgetValue( - serialized, - replacement.old_widget_ids, - inputMap.old_id, - newNode, - inputMap.new_id - ) - } else if (!isDotNotation(inputMap.new_id)) { - applySetValue(newNode, inputMap.new_id, inputMap.set_value) - } + for (const { name, value } of assignedWidgets) { + const widget = newNode.widgets?.find((w) => w.name === name) + if (!widget) continue + try { + if (widget.value !== value) widget.value = value + widget.callback?.(value) + } catch (error) { + console.error(`Failed to set widget ${name}`, error) } } for (const widget of newNode.widgets ?? []) { @@ -387,6 +417,23 @@ function replaceWithMapping( console.error(`Failed to bind replacement widget ${widget.name}`, error) } } + const connectedInputs = newNode.inputs.flatMap((input, slot) => { + const link = inputLink(nodeGraph, newNode.id, slot) + return link ? [{ input, link }] : [] + }) + for (const { input, link } of connectedInputs) { + try { + newNode.onConnectionsChange?.( + NodeSlotType.INPUT, + newNode.inputs.indexOf(input), + true, + link, + input + ) + } catch (error) { + console.error(`Failed to notify connected link ${link.id}`, error) + } + } try { nodeGraph.onNodeAdded?.(newNode) @@ -466,7 +513,7 @@ export function useNodeReplacement() { return !!originalType && targetTypes.has(originalType) }) - for (const node of placeholders) { + for (const node of new Set(placeholders)) { const match = findMatchingType(node, selectedTypes) if (!match?.replacement) continue