@bian-womp/spark-graph 0.3.20 → 0.3.22

package/lib/cjs/index.cjs

@@ -2766,6 +2766,7 @@ class GraphRuntime {
         this.environment = {};
         this.runMode = null;
         this.pauseRefCount = 0;
+        this.persistentPauseToken = null;
         // Initialize components
         this.graph = new Graph();
         this.eventEmitter = new EventEmitter();
@@ -2916,7 +2917,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();
@@ -2934,6 +2935,9 @@ class GraphRuntime {
                     this.execute(nodeId);
             }
         }
+        if (startPaused) {
+            this.pause();
+        }
     }
     triggerExternal(nodeId, event) {
         const node = this.graph.getNode(nodeId);
@@ -3076,6 +3080,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)
@@ -3732,10 +3747,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.
@@ -5535,22 +5550,138 @@ function offsetImportedPositions(targetPositions, sourcePositions, sourceDef, no
     }
     return newPositions;
 }
+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;
+        }
+    }
+}
+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 = {};
-    const mergedOutputs = {};
-    const mergedInputDefaults = {};
+    const mergedInputs = { ...targetInputs };
+    const mergedOutputs = { ...targetOutputs };
+    const mergedInputDefaults = { ...targetInputDefaults };
     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) {
@@ -5629,35 +5760,7 @@ function mergeInputsOutputs(targetInputs, targetOutputs, sourceInputs, sourceOut
 }
 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) {
-        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);
-        }
-    }
+    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) {
@@ -5666,35 +5769,9 @@ function mergeSnapshots(targetSnapshot, sourceSnapshot, converter) {
     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");
+        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) {
@@ -5762,6 +5839,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))
@@ -5802,8 +5881,9 @@ function buildValueConverter(config) {
                                 else {
                                     if (typeof matchValue === "string" ||
                                         typeof matchValue === "number") {
-                                        if (matchValue in mapping.valueMap) {
-                                            newValue = mapping.valueMap[matchValue];
+                                        const key = String(matchValue);
+                                        if (key in mapping.valueMap) {
+                                            newValue = mapping.valueMap[key];
                                             changed = true;
                                         }
                                     }
@@ -5836,8 +5916,9 @@ function buildValueConverter(config) {
                         else {
                             if (typeof innerValue === "string" ||
                                 typeof innerValue === "number") {
-                                if (innerValue in mapping.valueMap) {
-                                    newValue = mapping.valueMap[innerValue];
+                                const key = String(innerValue);
+                                if (key in mapping.valueMap) {
+                                    newValue = mapping.valueMap[key];
                                     // If mapped to null, return null to delete the output
                                     if (newValue === null) {
                                         return null;
@@ -5884,8 +5965,9 @@ function buildValueConverter(config) {
                             else {
                                 if (typeof matchValue === "string" ||
                                     typeof matchValue === "number") {
-                                    if (matchValue in mapping.valueMap) {
-                                        newValue = mapping.valueMap[matchValue];
+                                    const key = String(matchValue);
+                                    if (key in mapping.valueMap) {
+                                        newValue = mapping.valueMap[key];
                                         changed = true;
                                     }
                                 }
@@ -5907,8 +5989,9 @@ function buildValueConverter(config) {
                     }
                     else {
                         if (typeof value === "string" || typeof value === "number") {
-                            if (value in mapping.valueMap) {
-                                return mapping.valueMap[value];
+                            const key = String(value);
+                            if (key in mapping.valueMap) {
+                                return mapping.valueMap[key];
                             }
                         }
                     }
@@ -5931,6 +6014,7 @@ exports.LocalEngine = LocalEngine;
 exports.Registry = Registry;
 exports.buildValueConverter = buildValueConverter;
 exports.computeGraphCenter = computeGraphCenter;
+exports.convertSnapshot = convertSnapshot;
 exports.createAsyncGraphDef = createAsyncGraphDef;
 exports.createAsyncGraphRegistry = createAsyncGraphRegistry;
 exports.createProgressGraphDef = createProgressGraphDef;