@bian-womp/spark-graph 0.3.22 → 0.3.24

package/lib/cjs/index.cjs

@@ -5552,17 +5552,19 @@ function offsetImportedPositions(targetPositions, sourcePositions, sourceDef, no
 }
 function buildTypeMaps(def) {
     const nodeTypeMap = new Map();
-    const handleTypeMap = new Map();
+    const inputHandleTypeMap = new Map();
+    const outputHandleTypeMap = new Map();
     for (const node of def.nodes) {
         nodeTypeMap.set(node.nodeId, node.typeId);
-        const nodeHandleTypes = new Map();
+        const nodeInputTypes = new Map();
+        const nodeOutputTypes = new Map();
         if (node.resolvedHandles?.inputs) {
             for (const [handleId, handleDesc] of Object.entries(node.resolvedHandles.inputs)) {
                 const typeId = typeof handleDesc === "string"
                     ? handleDesc
                     : handleDesc?.typeId;
                 if (typeId)
-                    nodeHandleTypes.set(handleId, typeId);
+                    nodeInputTypes.set(handleId, typeId);
             }
         }
         if (node.resolvedHandles?.outputs) {
@@ -5573,14 +5575,33 @@ function buildTypeMaps(def) {
                         ? handleDesc[0]
                         : undefined;
                 if (typeId)
-                    nodeHandleTypes.set(handleId, typeId);
+                    nodeOutputTypes.set(handleId, typeId);
             }
         }
-        if (nodeHandleTypes.size > 0) {
-            handleTypeMap.set(node.nodeId, nodeHandleTypes);
+        // Also include handles from inputDefaults - they share handle IDs with inputs
+        if (node.resolvedHandles?.inputDefaults) {
+            for (const handleId of Object.keys(node.resolvedHandles.inputDefaults)) {
+                // If not already in map, try to get type from input handles
+                if (!nodeInputTypes.has(handleId) && node.resolvedHandles?.inputs) {
+                    const inputDesc = node.resolvedHandles.inputs[handleId];
+                    if (inputDesc) {
+                        const typeId = typeof inputDesc === "string"
+                            ? inputDesc
+                            : inputDesc?.typeId;
+                        if (typeId)
+                            nodeInputTypes.set(handleId, typeId);
+                    }
+                }
+            }
+        }
+        if (nodeInputTypes.size > 0) {
+            inputHandleTypeMap.set(node.nodeId, nodeInputTypes);
+        }
+        if (nodeOutputTypes.size > 0) {
+            outputHandleTypeMap.set(node.nodeId, nodeOutputTypes);
         }
     }
-    return { nodeTypeMap, handleTypeMap };
+    return { nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap };
 }
 function applyConversion(items, values, converter, type) {
     for (const item of items) {
@@ -5608,21 +5629,21 @@ function applyConversion(items, values, converter, type) {
         }
     }
 }
-function collectValuesToConvert(values, nodeTypeMap, handleTypeMap, originalNodeIdMap) {
+function collectValuesToConvert(values, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, type) {
     const converted = {};
     const toConvert = [];
+    const handleTypeMap = type === "output" ? outputHandleTypeMap : inputHandleTypeMap;
     for (const [nodeId, nodeValues] of Object.entries(values)) {
         converted[nodeId] = { ...nodeValues };
-        const originalNodeId = nodeId;
-        const nodeTypeId = nodeTypeMap.get(originalNodeId);
+        const nodeTypeId = nodeTypeMap.get(nodeId);
         for (const [handleId, value] of Object.entries(nodeValues)) {
-            const handleDataType = handleTypeMap.get(originalNodeId)?.get(handleId);
+            const handleDataType = handleTypeMap.get(nodeId)?.get(handleId);
             const runtimeTypeId = isTypedOutput(value)
                 ? getTypedOutputTypeId(value)
                 : undefined;
             toConvert.push({
                 nodeId,
-                originalNodeId,
+                originalNodeId: nodeId,
                 handleId,
                 value,
                 nodeTypeId,
@@ -5635,16 +5656,16 @@ function collectValuesToConvert(values, nodeTypeMap, handleTypeMap, originalNode
 }
 function convertSnapshot(snapshot, converter) {
     const def = snapshot.def ?? { nodes: [], edges: [] };
-    const { nodeTypeMap, handleTypeMap } = buildTypeMaps(def);
+    const { nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap } = buildTypeMaps(def);
     const inputDefaults = {};
     for (const node of def.nodes) {
         if (node.resolvedHandles?.inputDefaults) {
             inputDefaults[node.nodeId] = { ...node.resolvedHandles.inputDefaults };
         }
     }
-    const { converted: convertedInputs, toConvert: inputsToConvert } = collectValuesToConvert(snapshot.inputs ?? {}, nodeTypeMap, handleTypeMap);
-    const { converted: convertedOutputs, toConvert: outputsToConvert } = collectValuesToConvert(snapshot.outputs ?? {}, nodeTypeMap, handleTypeMap);
-    const { converted: convertedInputDefaults, toConvert: inputDefaultsToConvert, } = collectValuesToConvert(inputDefaults, nodeTypeMap, handleTypeMap);
+    const { converted: convertedInputs, toConvert: inputsToConvert } = collectValuesToConvert(snapshot.inputs ?? {}, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "input");
+    const { converted: convertedOutputs, toConvert: outputsToConvert } = collectValuesToConvert(snapshot.outputs ?? {}, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "output");
+    const { converted: convertedInputDefaults, toConvert: inputDefaultsToConvert, } = collectValuesToConvert(inputDefaults, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap, "inputDefault");
     applyConversion(inputsToConvert, convertedInputs, converter, "input");
     applyConversion(outputsToConvert, convertedOutputs, converter, "output");
     applyConversion(inputDefaultsToConvert, convertedInputDefaults, converter, "inputDefault");
@@ -5675,7 +5696,7 @@ function convertSnapshot(snapshot, converter) {
         outputs: convertedOutputs,
     };
 }
-function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOutputs, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, handleTypeMap) {
+function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOutputs, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap) {
     const mergedInputs = { ...targetInputs };
     const mergedOutputs = { ...targetOutputs };
     const mergedInputDefaults = { ...targetInputDefaults };
@@ -5690,7 +5711,7 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
             }
             const nodeTypeId = nodeTypeMap?.get(oldId);
             for (const [handleId, value] of Object.entries(inputs)) {
-                const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
+                const handleDataType = inputHandleTypeMap?.get(oldId)?.get(handleId);
                 inputsToConvert.push({
                     nodeId: newId,
                     originalNodeId: oldId,
@@ -5711,7 +5732,7 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
             }
             const nodeTypeId = nodeTypeMap?.get(oldId);
             for (const [handleId, value] of Object.entries(outputs)) {
-                const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
+                const handleDataType = outputHandleTypeMap?.get(oldId)?.get(handleId);
                 const runtimeTypeId = isTypedOutput(value)
                     ? getTypedOutputTypeId(value)
                     : undefined;
@@ -5736,7 +5757,7 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
             }
             const nodeTypeId = nodeTypeMap?.get(oldId);
             for (const [handleId, value] of Object.entries(defaults)) {
-                const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
+                const handleDataType = inputHandleTypeMap?.get(oldId)?.get(handleId);
                 inputDefaultsToConvert.push({
                     nodeId: newId,
                     originalNodeId: oldId,
@@ -5760,8 +5781,8 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
 }
 function mergeSnapshotData(targetSnapshot, sourceSnapshot, targetInputDefaults, sourceInputDefaults, nodeIdMap) {
     const sourceDef = sourceSnapshot.def ?? { nodes: []};
-    const { nodeTypeMap, handleTypeMap } = buildTypeMaps(sourceDef);
-    return mergeInputsOutputs(targetSnapshot.inputs ?? {}, targetSnapshot.outputs ?? {}, sourceSnapshot.inputs ?? {}, sourceSnapshot.outputs ?? {}, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, handleTypeMap);
+    const { nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap } = buildTypeMaps(sourceDef);
+    return mergeInputsOutputs(targetSnapshot.inputs ?? {}, targetSnapshot.outputs ?? {}, sourceSnapshot.inputs ?? {}, sourceSnapshot.outputs ?? {}, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, inputHandleTypeMap, outputHandleTypeMap);
 }
 function mergeSnapshots(targetSnapshot, sourceSnapshot, converter) {
     const targetDef = targetSnapshot.def ?? { nodes: [], edges: [] };
@@ -5839,11 +5860,11 @@ function buildValueConverter(config) {
         const { nodeId, handleId, value, type, nodeTypeId, handleDataType, runtimeTypeId, } = converterConfig;
         const isTyped = isTypedOutput(value);
         for (const mapping of config.mappings) {
-            if (mapping.type !== type)
+            if (mapping.type && mapping.type !== type)
                 continue;
-            if (!matchesPattern(handleId, mapping.handleId))
+            if (mapping.handleId && !matchesPattern(handleId, mapping.handleId))
                 continue;
-            if (!matchesPattern(nodeId, mapping.nodeId))
+            if (mapping.nodeId && !matchesPattern(nodeId, mapping.nodeId))
                 continue;
             if (mapping.nodeTypeId && nodeTypeId) {
                 if (!matchesPattern(nodeTypeId, mapping.nodeTypeId))