@bian-womp/spark-graph 0.2.63 → 0.2.64

package/lib/cjs/index.cjs

@@ -3757,7 +3757,7 @@ function mergeGraphDefinitions(target, source, converter) {
                             ? transformedNode.resolvedHandles.inputs[handleId]
                             : transformedNode.resolvedHandles.inputs[handleId]?.typeId
                         : undefined;
-                    transformedInputDefaults[handleId] = converter({
+                    const convertedValue = converter({
                         nodeId: newId,
                         handleId,
                         value,
@@ -3765,11 +3765,23 @@ function mergeGraphDefinitions(target, source, converter) {
                         nodeTypeId,
                         handleDataType,
                     });
+                    // If converter returns null, skip this input default (delete it)
+                    if (convertedValue !== null) {
+                        transformedInputDefaults[handleId] = convertedValue;
+                    }
+                }
+                // 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;
                 }
-                transformedNode.resolvedHandles = {
-                    ...transformedNode.resolvedHandles,
-                    inputDefaults: transformedInputDefaults,
-                };
             }
         }
         return transformedNode;
@@ -3852,16 +3864,28 @@ function offsetImportedPositions(targetPositions, sourcePositions, sourceDef, no
  * Source values override target when merging.
  */
 function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOutputs, nodeIdMap, converter, nodeTypeMap, handleTypeMap) {
-    const mergedInputs = { ...targetInputs };
-    const mergedOutputs = { ...targetOutputs };
+    // Deep copy target inputs/outputs to avoid mutating the original
+    const mergedInputs = {};
+    const mergedOutputs = {};
+    // Copy target inputs/outputs
+    for (const [nodeId, inputs] of Object.entries(targetInputs)) {
+        mergedInputs[nodeId] = { ...inputs };
+    }
+    for (const [nodeId, outputs] of Object.entries(targetOutputs)) {
+        mergedOutputs[nodeId] = { ...outputs };
+    }
     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] = {};
+            }
             for (const [handleId, value] of Object.entries(inputs)) {
                 const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
-                transformedInputs[handleId] = converter
+                const convertedValue = converter
                     ? converter({
                         nodeId: newId,
                         handleId,
@@ -3871,10 +3895,23 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
                         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];
             }
-            mergedInputs[newId] = mergedInputs[newId]
-                ? { ...mergedInputs[newId], ...transformedInputs }
-                : transformedInputs;
         }
     }
     for (const [oldId, outputs] of Object.entries(sourceOutputs)) {
@@ -3882,12 +3919,16 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
         if (newId) {
             const transformedOutputs = {};
             const nodeTypeId = nodeTypeMap?.get(oldId);
+            // Ensure mergedOutputs[newId] exists
+            if (!mergedOutputs[newId]) {
+                mergedOutputs[newId] = {};
+            }
             for (const [handleId, value] of Object.entries(outputs)) {
                 const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
                 const runtimeTypeId = isTypedOutput(value)
                     ? getTypedOutputTypeId(value)
                     : undefined;
-                transformedOutputs[handleId] = converter
+                const convertedValue = converter
                     ? converter({
                         nodeId: newId,
                         handleId,
@@ -3898,10 +3939,26 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
                         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;
+                }
+            }
+            // Merge transformed outputs
+            if (Object.keys(transformedOutputs).length > 0) {
+                mergedOutputs[newId] = {
+                    ...mergedOutputs[newId],
+                    ...transformedOutputs,
+                };
+            }
+            // Clean up empty node output objects
+            if (Object.keys(mergedOutputs[newId]).length === 0) {
+                delete mergedOutputs[newId];
             }
-            mergedOutputs[newId] = mergedOutputs[newId]
-                ? { ...mergedOutputs[newId], ...transformedOutputs }
-                : transformedOutputs;
         }
     }
     return { mergedInputs, mergedOutputs };
@@ -4020,10 +4077,14 @@ function buildValueConverter(config) {
                                     }
                                 }
                                 if (changed && newValue !== matchValue) {
+                                    // If mapped to null, set null at the path (which may delete nested property)
                                     setValueAtPath(transformedInner, match.path, newValue);
                                 }
                             }
                         }
+                        // If the entire typed output should be deleted (all paths mapped to null),
+                        // we'd need to check if the whole inner value is null/empty, but for now
+                        // we'll return the transformed value or original
                         return changed ? typed(typedTypeId, transformedInner) : value;
                     }
                 }
@@ -4033,6 +4094,10 @@ function buildValueConverter(config) {
                         if (mapping.valueMap instanceof Map) {
                             if (mapping.valueMap.has(innerValue)) {
                                 newValue = mapping.valueMap.get(innerValue);
+                                // If mapped to null, return null to delete the output
+                                if (newValue === null) {
+                                    return null;
+                                }
                                 return typed(typedTypeId, newValue);
                             }
                         }
@@ -4041,6 +4106,10 @@ function buildValueConverter(config) {
                                 typeof innerValue === "number") {
                                 if (innerValue in mapping.valueMap) {
                                     newValue = mapping.valueMap[innerValue];
+                                    // If mapped to null, return null to delete the output
+                                    if (newValue === null) {
+                                        return null;
+                                    }
                                     return typed(typedTypeId, newValue);
                                 }
                             }