@bian-womp/spark-graph 0.3.18 → 0.3.20

package/lib/cjs/index.cjs

@@ -2255,6 +2255,15 @@ class NodeExecutor {
             runId,
             abortSignal,
             reportProgress,
+            setCustomData: (data) => {
+                this.eventEmitter.emit("stats", {
+                    kind: "node-custom-data",
+                    nodeId,
+                    typeId: node.typeId,
+                    runId,
+                    data,
+                });
+            },
             log,
         };
     }
@@ -5414,62 +5423,42 @@ function findMatchingPaths(obj, pathSegments, currentPath = []) {
     return results;
 }
 
-function mergeGraphDefinitions(target, source, converter) {
+function mergeGraphDefinitions(target, source) {
     const existingNodeIds = new Set(target.nodes.map((n) => n.nodeId));
     const existingEdgeIds = new Set(target.edges.map((e) => e.id));
     const nodeIdMap = {};
+    const targetInputDefaults = {};
+    const sourceInputDefaults = {};
+    for (const node of target.nodes) {
+        if (node.resolvedHandles?.inputDefaults) {
+            targetInputDefaults[node.nodeId] = {
+                ...node.resolvedHandles.inputDefaults,
+            };
+        }
+    }
     const importedNodes = source.nodes.map((n) => {
         let newId = n.nodeId;
-        if (existingNodeIds.has(newId)) {
+        const isExistingNode = existingNodeIds.has(newId);
+        if (isExistingNode) {
             newId = generateId("n", existingNodeIds);
         }
         else {
             existingNodeIds.add(newId);
         }
         nodeIdMap[n.nodeId] = newId;
-        const transformedNode = {
+        if (n.resolvedHandles?.inputDefaults) {
+            sourceInputDefaults[n.nodeId] = { ...n.resolvedHandles.inputDefaults };
+        }
+        return {
             ...n,
             nodeId: newId,
-        };
-        if (converter) {
-            const nodeTypeId = transformedNode.typeId;
-            if (transformedNode.resolvedHandles?.inputDefaults) {
-                const transformedInputDefaults = {};
-                for (const [handleId, value] of Object.entries(transformedNode.resolvedHandles.inputDefaults)) {
-                    const handleDataType = transformedNode.resolvedHandles?.inputs?.[handleId]
-                        ? typeof transformedNode.resolvedHandles.inputs[handleId] ===
-                            "string"
-                            ? transformedNode.resolvedHandles.inputs[handleId]
-                            : transformedNode.resolvedHandles.inputs[handleId]?.typeId
-                        : undefined;
-                    const convertedValue = converter({
-                        nodeId: newId,
-                        handleId,
-                        value,
-                        type: "inputDefault",
-                        nodeTypeId,
-                        handleDataType,
-                    });
-                    // If converter returns null, skip this input default (delete it)
-                    if (convertedValue !== null) {
-                        transformedInputDefaults[handleId] = convertedValue;
-                    }
+            resolvedHandles: n.resolvedHandles
+                ? {
+                    ...n.resolvedHandles,
+                    inputDefaults: undefined,
                 }
-                // Only set inputDefaults if there are any remaining after conversion
-                if (Object.keys(transformedInputDefaults).length > 0) {
-                    transformedNode.resolvedHandles = {
-                        ...transformedNode.resolvedHandles,
-                        inputDefaults: transformedInputDefaults,
-                    };
-                }
-                else if (transformedNode.resolvedHandles) {
-                    // Remove inputDefaults if all were deleted
-                    const { inputDefaults, ...restHandles } = transformedNode.resolvedHandles;
-                    transformedNode.resolvedHandles = restHandles;
-                }
-            }
-        }
-        return transformedNode;
+                : undefined,
+        };
     });
     const importedEdges = source.edges.map((e) => {
         let newEdgeId = e.id;
@@ -5500,6 +5489,8 @@ function mergeGraphDefinitions(target, source, converter) {
             edges: [...target.edges, ...importedEdges],
         },
         nodeIdMap,
+        targetInputDefaults,
+        sourceInputDefaults,
     };
 }
 /**
@@ -5544,116 +5535,100 @@ function offsetImportedPositions(targetPositions, sourcePositions, sourceDef, no
     }
     return newPositions;
 }
-/**
- * Merge inputs and outputs from source into target, remapping node IDs.
- * Source values override target when merging.
- */
-function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOutputs, nodeIdMap, converter, nodeTypeMap, handleTypeMap) {
-    // Deep copy target inputs/outputs to avoid mutating the original
+function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOutputs, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, handleTypeMap) {
     const mergedInputs = {};
     const mergedOutputs = {};
-    // Copy target inputs/outputs
+    const mergedInputDefaults = {};
+    const inputsToConvert = [];
+    const outputsToConvert = [];
+    const inputDefaultsToConvert = [];
     for (const [nodeId, inputs] of Object.entries(targetInputs)) {
         mergedInputs[nodeId] = { ...inputs };
     }
     for (const [nodeId, outputs] of Object.entries(targetOutputs)) {
         mergedOutputs[nodeId] = { ...outputs };
     }
+    for (const [nodeId, defaults] of Object.entries(targetInputDefaults)) {
+        mergedInputDefaults[nodeId] = { ...defaults };
+    }
     for (const [oldId, inputs] of Object.entries(sourceInputs)) {
         const newId = nodeIdMap[oldId];
         if (newId) {
-            const transformedInputs = {};
-            const nodeTypeId = nodeTypeMap?.get(oldId);
-            // Ensure mergedInputs[newId] exists
             if (!mergedInputs[newId]) {
                 mergedInputs[newId] = {};
             }
+            const nodeTypeId = nodeTypeMap?.get(oldId);
             for (const [handleId, value] of Object.entries(inputs)) {
                 const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
-                const convertedValue = converter
-                    ? converter({
-                        nodeId: newId,
-                        handleId,
-                        value,
-                        type: "input",
-                        nodeTypeId,
-                        handleDataType,
-                    })
-                    : value;
-                // If converter returns null, delete this input
-                if (convertedValue === null) {
-                    delete mergedInputs[newId][handleId];
-                }
-                else {
-                    // Otherwise, set the converted value
-                    transformedInputs[handleId] = convertedValue;
-                }
-            }
-            // Merge transformed inputs
-            if (Object.keys(transformedInputs).length > 0) {
-                mergedInputs[newId] = { ...mergedInputs[newId], ...transformedInputs };
-            }
-            // Clean up empty node input objects
-            if (Object.keys(mergedInputs[newId]).length === 0) {
-                delete mergedInputs[newId];
+                inputsToConvert.push({
+                    nodeId: newId,
+                    originalNodeId: oldId,
+                    handleId,
+                    value,
+                    nodeTypeId,
+                    handleDataType,
+                });
+                mergedInputs[newId][handleId] = value;
             }
         }
     }
     for (const [oldId, outputs] of Object.entries(sourceOutputs)) {
         const newId = nodeIdMap[oldId];
         if (newId) {
-            const transformedOutputs = {};
-            const nodeTypeId = nodeTypeMap?.get(oldId);
-            // Ensure mergedOutputs[newId] exists
             if (!mergedOutputs[newId]) {
                 mergedOutputs[newId] = {};
             }
+            const nodeTypeId = nodeTypeMap?.get(oldId);
             for (const [handleId, value] of Object.entries(outputs)) {
                 const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
                 const runtimeTypeId = isTypedOutput(value)
                     ? getTypedOutputTypeId(value)
                     : undefined;
-                const convertedValue = converter
-                    ? converter({
-                        nodeId: newId,
-                        handleId,
-                        value,
-                        type: "output",
-                        nodeTypeId,
-                        handleDataType,
-                        runtimeTypeId,
-                    })
-                    : value;
-                // If converter returns null, delete this output
-                if (convertedValue === null) {
-                    delete mergedOutputs[newId][handleId];
-                }
-                else {
-                    // Otherwise, set the converted value
-                    transformedOutputs[handleId] = convertedValue;
-                }
+                outputsToConvert.push({
+                    nodeId: newId,
+                    originalNodeId: oldId,
+                    handleId,
+                    value,
+                    nodeTypeId,
+                    handleDataType,
+                    runtimeTypeId,
+                });
+                mergedOutputs[newId][handleId] = value;
             }
-            // Merge transformed outputs
-            if (Object.keys(transformedOutputs).length > 0) {
-                mergedOutputs[newId] = {
-                    ...mergedOutputs[newId],
-                    ...transformedOutputs,
-                };
+        }
+    }
+    for (const [oldId, defaults] of Object.entries(sourceInputDefaults)) {
+        const newId = nodeIdMap[oldId];
+        if (newId) {
+            if (!mergedInputDefaults[newId]) {
+                mergedInputDefaults[newId] = {};
             }
-            // Clean up empty node output objects
-            if (Object.keys(mergedOutputs[newId]).length === 0) {
-                delete mergedOutputs[newId];
+            const nodeTypeId = nodeTypeMap?.get(oldId);
+            for (const [handleId, value] of Object.entries(defaults)) {
+                const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
+                inputDefaultsToConvert.push({
+                    nodeId: newId,
+                    originalNodeId: oldId,
+                    handleId,
+                    value,
+                    nodeTypeId,
+                    handleDataType,
+                });
+                mergedInputDefaults[newId][handleId] = value;
             }
         }
     }
-    return { mergedInputs, mergedOutputs };
+    return {
+        mergedInputs,
+        mergedOutputs,
+        mergedInputDefaults,
+        inputsToConvert,
+        outputsToConvert,
+        inputDefaultsToConvert,
+    };
 }
-/**
- * Merge snapshot data (inputs, outputs) from source into target.
- * Graph definition merging should be done separately using mergeGraphDefinitions.
- * UI positions are handled separately by mergeUIState.
- */
-function mergeSnapshotData(targetSnapshot, sourceSnapshot, sourceDef, nodeIdMap, converter) {
+function mergeSnapshotData(targetSnapshot, sourceSnapshot, targetInputDefaults, sourceInputDefaults, nodeIdMap) {
+    const sourceDef = sourceSnapshot.def ?? { nodes: []};
     const nodeTypeMap = new Map();
     const handleTypeMap = new Map();
     for (const node of sourceDef.nodes) {
@@ -5683,10 +5658,66 @@ function mergeSnapshotData(targetSnapshot, sourceSnapshot, sourceDef, nodeIdMap,
             handleTypeMap.set(node.nodeId, nodeHandleTypes);
         }
     }
-    const { mergedInputs, mergedOutputs } = mergeInputsOutputs(targetSnapshot.inputs ?? {}, targetSnapshot.outputs ?? {}, sourceSnapshot.inputs ?? {}, sourceSnapshot.outputs ?? {}, nodeIdMap, converter, nodeTypeMap, handleTypeMap);
+    return mergeInputsOutputs(targetSnapshot.inputs ?? {}, targetSnapshot.outputs ?? {}, sourceSnapshot.inputs ?? {}, sourceSnapshot.outputs ?? {}, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, handleTypeMap);
+}
+function mergeSnapshots(targetSnapshot, sourceSnapshot, converter) {
+    const targetDef = targetSnapshot.def ?? { nodes: [], edges: [] };
+    const sourceDef = sourceSnapshot.def ?? { nodes: [], edges: [] };
+    const { merged, nodeIdMap, targetInputDefaults, sourceInputDefaults } = mergeGraphDefinitions(targetDef, sourceDef);
+    const { mergedInputs, mergedOutputs, mergedInputDefaults, inputsToConvert, outputsToConvert, inputDefaultsToConvert, } = mergeSnapshotData(targetSnapshot, sourceSnapshot, targetInputDefaults, sourceInputDefaults, nodeIdMap);
+    if (converter) {
+        const applyConversion = (items, values, type) => {
+            for (const item of items) {
+                const convertedValue = converter({
+                    nodeId: item.nodeId,
+                    handleId: item.handleId,
+                    value: item.value,
+                    type,
+                    nodeTypeId: item.nodeTypeId,
+                    handleDataType: item.handleDataType,
+                    runtimeTypeId: item.runtimeTypeId,
+                });
+                if (convertedValue === null) {
+                    delete values[item.nodeId]?.[item.handleId];
+                    if (values[item.nodeId] &&
+                        Object.keys(values[item.nodeId]).length === 0) {
+                        delete values[item.nodeId];
+                    }
+                }
+                else {
+                    if (!values[item.nodeId]) {
+                        values[item.nodeId] = {};
+                    }
+                    values[item.nodeId][item.handleId] = convertedValue;
+                }
+            }
+        };
+        applyConversion(inputDefaultsToConvert, mergedInputDefaults, "inputDefault");
+        applyConversion(inputsToConvert, mergedInputs, "input");
+        applyConversion(outputsToConvert, mergedOutputs, "output");
+    }
+    const nodeMap = new Map(merged.nodes.map((n) => [n.nodeId, n]));
+    for (const nodeId in mergedInputDefaults) {
+        const node = nodeMap.get(nodeId);
+        if (node && Object.keys(mergedInputDefaults[nodeId]).length > 0) {
+            if (!node.resolvedHandles) {
+                node.resolvedHandles = {};
+            }
+            node.resolvedHandles.inputDefaults = mergedInputDefaults[nodeId];
+        }
+    }
     return {
-        mergedInputs,
-        mergedOutputs,
+        merged: {
+            def: merged,
+            inputs: mergedInputs,
+            outputs: mergedOutputs,
+            environment: {
+                ...targetSnapshot.environment,
+                ...sourceSnapshot.environment,
+            },
+            extData: { ...targetSnapshot.extData, ...sourceSnapshot.extData },
+        },
+        nodeIdMap,
     };
 }
 /**
@@ -5918,11 +5949,9 @@ exports.getValueAtPath = getValueAtPath;
 exports.installLogging = installLogging;
 exports.isInputPrivate = isInputPrivate;
 exports.isTypedOutput = isTypedOutput;
-exports.mergeGraphDefinitions = mergeGraphDefinitions;
 exports.mergeInputHandleDescriptors = mergeInputHandleDescriptors;
-exports.mergeInputsOutputs = mergeInputsOutputs;
 exports.mergeRuntimeState = mergeRuntimeState;
-exports.mergeSnapshotData = mergeSnapshotData;
+exports.mergeSnapshots = mergeSnapshots;
 exports.offsetImportedPositions = offsetImportedPositions;
 exports.parseJsonPath = parseJsonPath;
 exports.registerDelayNode = registerDelayNode;