@bian-womp/spark-graph 0.3.19 → 0.3.21

package/lib/esm/index.js

@@ -2764,6 +2764,7 @@ class GraphRuntime {
         this.environment = {};
         this.runMode = null;
         this.pauseRefCount = 0;
+        this.persistentPauseToken = null;
         // Initialize components
         this.graph = new Graph();
         this.eventEmitter = new EventEmitter();
@@ -2914,7 +2915,7 @@ class GraphRuntime {
         const node = this.graph.getNode(nodeId);
         return node?.outputs[output];
     }
-    launch(invalidate = false) {
+    launch(invalidate = false, startPaused = false) {
         this.graph.forEachNode((node) => {
             const effectiveInputs = this.nodeExecutor.getEffectiveInputs(node.nodeId);
             const ctrl = new AbortController();
@@ -2932,6 +2933,9 @@ class GraphRuntime {
                     this.execute(nodeId);
             }
         }
+        if (startPaused) {
+            this.pause();
+        }
     }
     triggerExternal(nodeId, event) {
         const node = this.graph.getNode(nodeId);
@@ -3074,6 +3078,17 @@ class GraphRuntime {
     isPaused() {
         return this.pauseRefCount > 0;
     }
+    pause() {
+        if (!this.persistentPauseToken) {
+            this.persistentPauseToken = this.requestPause();
+        }
+    }
+    resume() {
+        if (this.persistentPauseToken) {
+            this.persistentPauseToken();
+            this.persistentPauseToken = null;
+        }
+    }
     copyOutputs(fromNodeId, toNodeId, options) {
         const fromNode = this.getNodeData(fromNodeId);
         if (!fromNode?.outputs)
@@ -3730,10 +3745,10 @@ class LocalEngine {
     dispose() {
         // this.graphRuntime.dispose();
     }
-    launch(invalidate, runMode) {
+    launch(invalidate, runMode, startPaused) {
         if (runMode)
             this.setRunMode(runMode);
-        this.graphRuntime.launch(invalidate);
+        this.graphRuntime.launch(invalidate, startPaused);
     }
     /**
      * Run only this node, no downstream propagation.
@@ -5421,62 +5436,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;
-                    }
-                }
-                // 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;
+            resolvedHandles: n.resolvedHandles
+                ? {
+                    ...n.resolvedHandles,
+                    inputDefaults: undefined,
                 }
-            }
-        }
-        return transformedNode;
+                : undefined,
+        };
     });
     const importedEdges = source.edges.map((e) => {
         let newEdgeId = e.id;
@@ -5507,6 +5502,8 @@ function mergeGraphDefinitions(target, source, converter) {
             edges: [...target.edges, ...importedEdges],
         },
         nodeIdMap,
+        targetInputDefaults,
+        sourceInputDefaults,
     };
 }
 /**
@@ -5551,149 +5548,251 @@ 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
-    const mergedInputs = {};
-    const mergedOutputs = {};
-    // Copy target inputs/outputs
-    for (const [nodeId, inputs] of Object.entries(targetInputs)) {
-        mergedInputs[nodeId] = { ...inputs };
+function buildTypeMaps(def) {
+    const nodeTypeMap = new Map();
+    const handleTypeMap = new Map();
+    for (const node of def.nodes) {
+        nodeTypeMap.set(node.nodeId, node.typeId);
+        const nodeHandleTypes = 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);
+            }
+        }
+        if (node.resolvedHandles?.outputs) {
+            for (const [handleId, handleDesc] of Object.entries(node.resolvedHandles.outputs)) {
+                const typeId = typeof handleDesc === "string"
+                    ? handleDesc
+                    : Array.isArray(handleDesc)
+                        ? handleDesc[0]
+                        : undefined;
+                if (typeId)
+                    nodeHandleTypes.set(handleId, typeId);
+            }
+        }
+        if (nodeHandleTypes.size > 0) {
+            handleTypeMap.set(node.nodeId, nodeHandleTypes);
+        }
+    }
+    return { nodeTypeMap, handleTypeMap };
+}
+function applyConversion(items, values, converter, 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;
+        }
     }
-    for (const [nodeId, outputs] of Object.entries(targetOutputs)) {
-        mergedOutputs[nodeId] = { ...outputs };
+}
+function collectValuesToConvert(values, nodeTypeMap, handleTypeMap, originalNodeIdMap) {
+    const converted = {};
+    const toConvert = [];
+    for (const [nodeId, nodeValues] of Object.entries(values)) {
+        converted[nodeId] = { ...nodeValues };
+        const originalNodeId = nodeId;
+        const nodeTypeId = nodeTypeMap.get(originalNodeId);
+        for (const [handleId, value] of Object.entries(nodeValues)) {
+            const handleDataType = handleTypeMap.get(originalNodeId)?.get(handleId);
+            const runtimeTypeId = isTypedOutput(value)
+                ? getTypedOutputTypeId(value)
+                : undefined;
+            toConvert.push({
+                nodeId,
+                originalNodeId,
+                handleId,
+                value,
+                nodeTypeId,
+                handleDataType,
+                runtimeTypeId,
+            });
+        }
     }
+    return { converted, toConvert };
+}
+function convertSnapshot(snapshot, converter) {
+    const def = snapshot.def ?? { nodes: [], edges: [] };
+    const { nodeTypeMap, handleTypeMap } = 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);
+    applyConversion(inputsToConvert, convertedInputs, converter, "input");
+    applyConversion(outputsToConvert, convertedOutputs, converter, "output");
+    applyConversion(inputDefaultsToConvert, convertedInputDefaults, converter, "inputDefault");
+    const updatedNodes = def.nodes.map((node) => {
+        const defaults = convertedInputDefaults[node.nodeId];
+        if (!defaults || Object.keys(defaults).length === 0) {
+            if (node.resolvedHandles?.inputDefaults) {
+                const { inputDefaults, ...restHandles } = node.resolvedHandles;
+                return {
+                    ...node,
+                    resolvedHandles: Object.keys(restHandles).length > 0 ? restHandles : undefined,
+                };
+            }
+            return node;
+        }
+        return {
+            ...node,
+            resolvedHandles: {
+                ...node.resolvedHandles,
+                inputDefaults: defaults,
+            },
+        };
+    });
+    return {
+        ...snapshot,
+        def: { ...def, nodes: updatedNodes },
+        inputs: convertedInputs,
+        outputs: convertedOutputs,
+    };
+}
+function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOutputs, targetInputDefaults, sourceInputDefaults, nodeIdMap, nodeTypeMap, handleTypeMap) {
+    const mergedInputs = { ...targetInputs };
+    const mergedOutputs = { ...targetOutputs };
+    const mergedInputDefaults = { ...targetInputDefaults };
+    const inputsToConvert = [];
+    const outputsToConvert = [];
+    const inputDefaultsToConvert = [];
     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;
-                }
-            }
-            // 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];
+                outputsToConvert.push({
+                    nodeId: newId,
+                    originalNodeId: oldId,
+                    handleId,
+                    value,
+                    nodeTypeId,
+                    handleDataType,
+                    runtimeTypeId,
+                });
+                mergedOutputs[newId][handleId] = value;
             }
         }
     }
-    return { mergedInputs, mergedOutputs };
-}
-/**
- * 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) {
-    const nodeTypeMap = new Map();
-    const handleTypeMap = new Map();
-    for (const node of sourceDef.nodes) {
-        nodeTypeMap.set(node.nodeId, node.typeId);
-        const nodeHandleTypes = 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);
+    for (const [oldId, defaults] of Object.entries(sourceInputDefaults)) {
+        const newId = nodeIdMap[oldId];
+        if (newId) {
+            if (!mergedInputDefaults[newId]) {
+                mergedInputDefaults[newId] = {};
             }
-        }
-        if (node.resolvedHandles?.outputs) {
-            for (const [handleId, handleDesc] of Object.entries(node.resolvedHandles.outputs)) {
-                const typeId = typeof handleDesc === "string"
-                    ? handleDesc
-                    : Array.isArray(handleDesc)
-                        ? handleDesc[0]
-                        : undefined;
-                if (typeId)
-                    nodeHandleTypes.set(handleId, typeId);
+            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;
             }
         }
-        if (nodeHandleTypes.size > 0) {
-            handleTypeMap.set(node.nodeId, nodeHandleTypes);
-        }
     }
-    const { mergedInputs, mergedOutputs } = mergeInputsOutputs(targetSnapshot.inputs ?? {}, targetSnapshot.outputs ?? {}, sourceSnapshot.inputs ?? {}, sourceSnapshot.outputs ?? {}, nodeIdMap, converter, nodeTypeMap, handleTypeMap);
     return {
         mergedInputs,
         mergedOutputs,
+        mergedInputDefaults,
+        inputsToConvert,
+        outputsToConvert,
+        inputDefaultsToConvert,
+    };
+}
+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);
+}
+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) {
+        applyConversion(inputDefaultsToConvert, mergedInputDefaults, converter, "inputDefault");
+        applyConversion(inputsToConvert, mergedInputs, converter, "input");
+        applyConversion(outputsToConvert, mergedOutputs, converter, "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 {
+        merged: {
+            def: merged,
+            inputs: mergedInputs,
+            outputs: mergedOutputs,
+            environment: {
+                ...targetSnapshot.environment,
+                ...sourceSnapshot.environment,
+            },
+            extData: { ...targetSnapshot.extData, ...sourceSnapshot.extData },
+        },
+        nodeIdMap,
     };
 }
 /**
@@ -5738,6 +5837,8 @@ 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)
+                continue;
             if (!matchesPattern(handleId, mapping.handleId))
                 continue;
             if (!matchesPattern(nodeId, mapping.nodeId))
@@ -5895,5 +5996,5 @@ function buildValueConverter(config) {
     };
 }
 
-export { BaseCompareOperation, BaseLogicOperation, BaseMathOperation, CompositeCategory, ComputeCategory, GraphBuilder, GraphRuntime, LevelLogger, LocalEngine, Registry, buildValueConverter, computeGraphCenter, createAsyncGraphDef, createAsyncGraphRegistry, createProgressGraphDef, createProgressGraphRegistry, createSimpleGraphDef, createSimpleGraphRegistry, createValidationGraphDef, createValidationGraphRegistry, findMatchingPaths, generateId, getInputHandleMetadata, getInputTypeId, getTypedOutputTypeId, getTypedOutputValue, getValueAtPath, installLogging, isInputPrivate, isTypedOutput, mergeGraphDefinitions, mergeInputHandleDescriptors, mergeInputsOutputs, mergeRuntimeState, mergeSnapshotData, offsetImportedPositions, parseJsonPath, registerDelayNode, registerProgressNodes, setValueAtPath, setValueAtPathWithCreation, typed };
+export { BaseCompareOperation, BaseLogicOperation, BaseMathOperation, CompositeCategory, ComputeCategory, GraphBuilder, GraphRuntime, LevelLogger, LocalEngine, Registry, buildValueConverter, computeGraphCenter, convertSnapshot, createAsyncGraphDef, createAsyncGraphRegistry, createProgressGraphDef, createProgressGraphRegistry, createSimpleGraphDef, createSimpleGraphRegistry, createValidationGraphDef, createValidationGraphRegistry, findMatchingPaths, generateId, getInputHandleMetadata, getInputTypeId, getTypedOutputTypeId, getTypedOutputValue, getValueAtPath, installLogging, isInputPrivate, isTypedOutput, mergeInputHandleDescriptors, mergeRuntimeState, mergeSnapshots, offsetImportedPositions, parseJsonPath, registerDelayNode, registerProgressNodes, setValueAtPath, setValueAtPathWithCreation, typed };
 //# sourceMappingURL=index.js.map