@bian-womp/spark-graph 0.2.54 → 0.2.56

package/lib/cjs/index.cjs

@@ -3260,6 +3260,20 @@ function registerProgressNodes(registry) {
         },
     });
 }
+function generateId(prefix, used = new Set()) {
+    let id;
+    let attempts = 0;
+    do {
+        id = `${prefix}${Math.random().toString(36).slice(2, 8)}`;
+        attempts++;
+        if (attempts > 1000) {
+            id = `${prefix}${Date.now().toString(36)}${Math.random()
+                .toString(36)
+                .slice(2, 4)}`;
+        }
+    } while (used.has(id));
+    return id;
+}
 
 function installLogging(engine) {
     engine.on("value", (e) => {
@@ -3475,6 +3489,562 @@ function createValidationGraphRegistry() {
     return registry;
 }
 
+function parseJsonPath(path) {
+    if (typeof path === "string") {
+        return path.split(".").flatMap((segment) => {
+            const arrayMatch = segment.match(/^(.+)\[(\d+)\]$/);
+            if (arrayMatch) {
+                const index = parseInt(arrayMatch[2], 10);
+                return arrayMatch[1] ? [arrayMatch[1], index] : [index];
+            }
+            return [segment];
+        });
+    }
+    return path;
+}
+function getValueAtPath(obj, pathSegments) {
+    if (pathSegments.length === 0) {
+        return { value: obj, parent: null, key: "" };
+    }
+    let current = obj;
+    for (let i = 0; i < pathSegments.length - 1; i++) {
+        const segment = pathSegments[i];
+        if (current === null ||
+            current === undefined ||
+            typeof current !== "object") {
+            return null;
+        }
+        if (typeof segment === "string") {
+            if (Array.isArray(current)) {
+                const index = parseInt(segment, 10);
+                if (isNaN(index))
+                    return null;
+                current = current[index];
+            }
+            else {
+                current = current[segment];
+            }
+        }
+        else if (typeof segment === "number") {
+            if (Array.isArray(current)) {
+                if (segment >= 0 && segment < current.length) {
+                    current = current[segment];
+                }
+                else {
+                    return null;
+                }
+            }
+            else {
+                return null;
+            }
+        }
+        else if (segment instanceof RegExp) {
+            if (Array.isArray(current)) {
+                return null;
+            }
+            const obj = current;
+            const matchingKey = Object.keys(obj).find((key) => segment.test(key));
+            if (!matchingKey)
+                return null;
+            current = obj[matchingKey];
+        }
+        else {
+            return null;
+        }
+    }
+    const lastSegment = pathSegments[pathSegments.length - 1];
+    if (typeof lastSegment === "string") {
+        if (Array.isArray(current)) {
+            const index = parseInt(lastSegment, 10);
+            if (isNaN(index))
+                return null;
+            return { value: current[index], parent: current, key: index };
+        }
+        else if (current !== null &&
+            current !== undefined &&
+            typeof current === "object") {
+            return {
+                value: current[lastSegment],
+                parent: current,
+                key: lastSegment,
+            };
+        }
+    }
+    else if (typeof lastSegment === "number") {
+        if (Array.isArray(current)) {
+            if (lastSegment >= 0 && lastSegment < current.length) {
+                return {
+                    value: current[lastSegment],
+                    parent: current,
+                    key: lastSegment,
+                };
+            }
+        }
+        return null;
+    }
+    else if (lastSegment instanceof RegExp) {
+        if (Array.isArray(current)) {
+            return null;
+        }
+        const obj = current;
+        const matchingKey = Object.keys(obj).find((key) => lastSegment.test(key));
+        if (!matchingKey)
+            return null;
+        return { value: obj[matchingKey], parent: current, key: matchingKey };
+    }
+    return null;
+}
+function setValueAtPath(obj, pathSegments, newValue) {
+    const result = getValueAtPath(obj, pathSegments);
+    if (!result || result.parent === null)
+        return false;
+    if (Array.isArray(result.parent)) {
+        result.parent[result.key] = newValue;
+    }
+    else {
+        result.parent[result.key] = newValue;
+    }
+    return true;
+}
+function findMatchingPaths(obj, pathSegments, currentPath = []) {
+    if (pathSegments.length === 0) {
+        return [{ path: currentPath, value: obj }];
+    }
+    const [currentSegment, ...remainingSegments] = pathSegments;
+    const results = [];
+    if (currentSegment === undefined) {
+        return results;
+    }
+    if (typeof currentSegment === "string") {
+        if (Array.isArray(obj)) {
+            const index = parseInt(currentSegment, 10);
+            if (!isNaN(index) && index >= 0 && index < obj.length) {
+                results.push(...findMatchingPaths(obj[index], remainingSegments, [
+                    ...currentPath,
+                    index,
+                ]));
+            }
+        }
+        else if (obj !== null && obj !== undefined && typeof obj === "object") {
+            const objRecord = obj;
+            if (currentSegment in objRecord) {
+                results.push(...findMatchingPaths(objRecord[currentSegment], remainingSegments, [
+                    ...currentPath,
+                    currentSegment,
+                ]));
+            }
+        }
+    }
+    else if (typeof currentSegment === "number") {
+        if (Array.isArray(obj)) {
+            if (currentSegment >= 0 && currentSegment < obj.length) {
+                results.push(...findMatchingPaths(obj[currentSegment], remainingSegments, [
+                    ...currentPath,
+                    currentSegment,
+                ]));
+            }
+        }
+    }
+    else if (currentSegment instanceof RegExp) {
+        if (Array.isArray(obj)) {
+            for (let i = 0; i < obj.length; i++) {
+                results.push(...findMatchingPaths(obj[i], remainingSegments, [...currentPath, i]));
+            }
+        }
+        else if (obj !== null && obj !== undefined && typeof obj === "object") {
+            const objRecord = obj;
+            for (const key of Object.keys(objRecord)) {
+                if (currentSegment.test(key)) {
+                    results.push(...findMatchingPaths(objRecord[key], remainingSegments, [
+                        ...currentPath,
+                        key,
+                    ]));
+                }
+            }
+        }
+    }
+    return results;
+}
+
+function mergeGraphDefinitions(target, source, converter) {
+    const existingNodeIds = new Set(target.nodes.map((n) => n.nodeId));
+    const existingEdgeIds = new Set(target.edges.map((e) => e.id));
+    const nodeIdMap = {};
+    const importedNodes = source.nodes.map((n) => {
+        let newId = n.nodeId;
+        if (existingNodeIds.has(newId)) {
+            newId = generateId("n", existingNodeIds);
+        }
+        else {
+            existingNodeIds.add(newId);
+        }
+        nodeIdMap[n.nodeId] = newId;
+        const transformedNode = {
+            ...n,
+            nodeId: newId,
+        };
+        if (converter) {
+            const nodeTypeId = transformedNode.typeId;
+            if (transformedNode.initialInputs) {
+                const transformedInitialInputs = {};
+                for (const [handleId, value] of Object.entries(transformedNode.initialInputs)) {
+                    const handleDataType = transformedNode.resolvedHandles?.inputs?.[handleId]
+                        ? typeof transformedNode.resolvedHandles.inputs[handleId] ===
+                            "string"
+                            ? transformedNode.resolvedHandles.inputs[handleId]
+                            : transformedNode.resolvedHandles.inputs[handleId]?.typeId
+                        : undefined;
+                    transformedInitialInputs[handleId] = converter(newId, handleId, value, "initialInput", nodeTypeId, handleDataType);
+                }
+                transformedNode.initialInputs = transformedInitialInputs;
+            }
+            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;
+                    transformedInputDefaults[handleId] = converter(newId, handleId, value, "inputDefault", nodeTypeId, handleDataType);
+                }
+                transformedNode.resolvedHandles = {
+                    ...transformedNode.resolvedHandles,
+                    inputDefaults: transformedInputDefaults,
+                };
+            }
+        }
+        return transformedNode;
+    });
+    const importedEdges = source.edges.map((e) => {
+        let newEdgeId = e.id;
+        if (existingEdgeIds.has(newEdgeId)) {
+            newEdgeId = generateId("e", existingEdgeIds);
+        }
+        else {
+            existingEdgeIds.add(newEdgeId);
+        }
+        const sourceNodeId = nodeIdMap[e.source.nodeId] ?? e.source.nodeId;
+        const targetNodeId = nodeIdMap[e.target.nodeId] ?? e.target.nodeId;
+        return {
+            ...e,
+            id: newEdgeId,
+            source: {
+                ...e.source,
+                nodeId: sourceNodeId,
+            },
+            target: {
+                ...e.target,
+                nodeId: targetNodeId,
+            },
+        };
+    });
+    return {
+        merged: {
+            nodes: [...target.nodes, ...importedNodes],
+            edges: [...target.edges, ...importedEdges],
+        },
+        nodeIdMap,
+    };
+}
+/**
+ * Compute the center point of a graph based on node positions.
+ */
+function computeGraphCenter(positions, nodeIds) {
+    const validPositions = nodeIds
+        .map((id) => positions[id])
+        .filter((pos) => pos !== undefined);
+    if (validPositions.length === 0) {
+        return { x: 0, y: 0 };
+    }
+    const minX = Math.min(...validPositions.map((p) => p.x));
+    const maxX = Math.max(...validPositions.map((p) => p.x));
+    const minY = Math.min(...validPositions.map((p) => p.y));
+    const maxY = Math.max(...validPositions.map((p) => p.y));
+    return {
+        x: (minX + maxX) / 2,
+        y: (minY + maxY) / 2,
+    };
+}
+/**
+ * Offset positions of imported nodes based on an anchor point.
+ * Preserves relative layout of imported nodes while positioning them at the anchor.
+ */
+function offsetImportedPositions(targetPositions, sourcePositions, sourceDef, nodeIdMap, anchorPos) {
+    const sourceNodeIds = sourceDef.nodes.map((n) => n.nodeId);
+    const sourceCenter = computeGraphCenter(sourcePositions, sourceNodeIds);
+    const dx = anchorPos.x - sourceCenter.x;
+    const dy = anchorPos.y - sourceCenter.y;
+    const newPositions = {
+        ...targetPositions,
+    };
+    for (const node of sourceDef.nodes) {
+        const oldId = node.nodeId;
+        const newId = nodeIdMap[oldId];
+        const srcPos = sourcePositions[oldId] ?? { x: 0, y: 0 };
+        newPositions[newId] = {
+            x: srcPos.x + dx,
+            y: srcPos.y + dy,
+        };
+    }
+    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) {
+    const mergedInputs = { ...targetInputs };
+    const mergedOutputs = { ...targetOutputs };
+    for (const [oldId, inputs] of Object.entries(sourceInputs)) {
+        const newId = nodeIdMap[oldId];
+        if (newId) {
+            const transformedInputs = {};
+            const nodeTypeId = nodeTypeMap?.get(oldId);
+            for (const [handleId, value] of Object.entries(inputs)) {
+                const handleDataType = handleTypeMap?.get(oldId)?.get(handleId);
+                transformedInputs[handleId] = converter
+                    ? converter(newId, handleId, value, "input", nodeTypeId, handleDataType)
+                    : value;
+            }
+            mergedInputs[newId] = mergedInputs[newId]
+                ? { ...mergedInputs[newId], ...transformedInputs }
+                : transformedInputs;
+        }
+    }
+    for (const [oldId, outputs] of Object.entries(sourceOutputs)) {
+        const newId = nodeIdMap[oldId];
+        if (newId) {
+            const transformedOutputs = {};
+            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;
+                transformedOutputs[handleId] = converter
+                    ? converter(newId, handleId, value, "output", nodeTypeId, handleDataType, runtimeTypeId)
+                    : value;
+            }
+            mergedOutputs[newId] = mergedOutputs[newId]
+                ? { ...mergedOutputs[newId], ...transformedOutputs }
+                : transformedOutputs;
+        }
+    }
+    return { mergedInputs, mergedOutputs };
+}
+/**
+ * Merge snapshot data (inputs, outputs, UI positions) from source into target.
+ * Graph definition merging should be done separately using mergeGraphDefinitions.
+ */
+function mergeSnapshotData(targetSnapshot, sourceSnapshot, sourceDef, nodeIdMap, anchorPos, 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);
+            }
+        }
+        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 { mergedInputs, mergedOutputs } = mergeInputsOutputs(targetSnapshot.inputs ?? {}, targetSnapshot.outputs ?? {}, sourceSnapshot.inputs ?? {}, sourceSnapshot.outputs ?? {}, nodeIdMap, converter, nodeTypeMap, handleTypeMap);
+    const targetUI = targetSnapshot.extData?.ui || {};
+    const sourceUI = sourceSnapshot.extData?.ui || {};
+    const mergedPositions = offsetImportedPositions(targetUI.positions ?? {}, sourceUI.positions ?? {}, sourceDef, nodeIdMap, anchorPos);
+    return {
+        mergedInputs,
+        mergedOutputs,
+        mergedPositions,
+    };
+}
+function matchesPattern(value, pattern) {
+    if (!pattern)
+        return true;
+    if (typeof pattern === "string") {
+        return value === pattern;
+    }
+    return pattern.test(value);
+}
+/**
+ * Build a converter function from a configuration that maps values based on handle/node matching.
+ * The converter will replace values when:
+ * - handleId matches (if specified)
+ * - nodeId matches (if specified)
+ * - nodeTypeId matches (if specified)
+ * - handleDataType matches (if specified)
+ * - runtimeTypeId matches (if specified, for typed outputs)
+ * - value exists in valueMap
+ */
+function buildValueConverter(config) {
+    return (nodeId, handleId, value, type, nodeTypeId, handleDataType, runtimeTypeId) => {
+        const isTyped = isTypedOutput(value);
+        for (const mapping of config.mappings) {
+            if (!matchesPattern(handleId, mapping.handleId))
+                continue;
+            if (!matchesPattern(nodeId, mapping.nodeId))
+                continue;
+            if (mapping.nodeTypeId && nodeTypeId) {
+                if (!matchesPattern(nodeTypeId, mapping.nodeTypeId))
+                    continue;
+            }
+            if (mapping.handleDataType && handleDataType) {
+                if (!matchesPattern(handleDataType, mapping.handleDataType))
+                    continue;
+            }
+            if (mapping.runtimeTypeId && runtimeTypeId) {
+                if (!matchesPattern(runtimeTypeId, mapping.runtimeTypeId))
+                    continue;
+            }
+            if (mapping.transformTypedValue && isTyped) {
+                const innerValue = getTypedOutputValue(value);
+                const typedTypeId = getTypedOutputTypeId(value);
+                if (!typedTypeId)
+                    continue;
+                if (mapping.path !== undefined) {
+                    const pathSegments = parseJsonPath(mapping.path);
+                    const matches = findMatchingPaths(innerValue, pathSegments);
+                    if (matches.length > 0) {
+                        const transformedInner = JSON.parse(JSON.stringify(innerValue));
+                        let changed = false;
+                        for (const match of matches) {
+                            const matchValue = match.value;
+                            if (matchValue !== null && matchValue !== undefined) {
+                                let newValue = matchValue;
+                                if (mapping.valueMap instanceof Map) {
+                                    if (mapping.valueMap.has(matchValue)) {
+                                        newValue = mapping.valueMap.get(matchValue);
+                                        changed = true;
+                                    }
+                                }
+                                else {
+                                    if (typeof matchValue === "string" ||
+                                        typeof matchValue === "number") {
+                                        if (matchValue in mapping.valueMap) {
+                                            newValue = mapping.valueMap[matchValue];
+                                            changed = true;
+                                        }
+                                    }
+                                }
+                                if (changed && newValue !== matchValue) {
+                                    setValueAtPath(transformedInner, match.path, newValue);
+                                }
+                            }
+                        }
+                        return changed ? typed(typedTypeId, transformedInner) : value;
+                    }
+                }
+                else {
+                    if (innerValue !== null && innerValue !== undefined) {
+                        let newValue = innerValue;
+                        if (mapping.valueMap instanceof Map) {
+                            if (mapping.valueMap.has(innerValue)) {
+                                newValue = mapping.valueMap.get(innerValue);
+                                return typed(typedTypeId, newValue);
+                            }
+                        }
+                        else {
+                            if (typeof innerValue === "string" ||
+                                typeof innerValue === "number") {
+                                if (innerValue in mapping.valueMap) {
+                                    newValue = mapping.valueMap[innerValue];
+                                    return typed(typedTypeId, newValue);
+                                }
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            if (mapping.path !== undefined) {
+                let pathSegments = parseJsonPath(mapping.path);
+                if (isTyped) {
+                    const typedTypeId = getTypedOutputTypeId(value);
+                    if (typedTypeId) {
+                        const firstSegment = pathSegments[0];
+                        const firstSegmentStr = typeof firstSegment === "string"
+                            ? firstSegment
+                            : firstSegment instanceof RegExp
+                                ? null
+                                : String(firstSegment);
+                        if (firstSegmentStr !== "__spark_value" &&
+                            firstSegmentStr !== "__spark_type") {
+                            pathSegments = ["__spark_value", ...pathSegments];
+                        }
+                    }
+                }
+                const matches = findMatchingPaths(value, pathSegments);
+                if (matches.length > 0) {
+                    const transformedValue = JSON.parse(JSON.stringify(value));
+                    let changed = false;
+                    for (const match of matches) {
+                        const matchValue = match.value;
+                        if (matchValue !== null && matchValue !== undefined) {
+                            let newValue = matchValue;
+                            if (mapping.valueMap instanceof Map) {
+                                if (mapping.valueMap.has(matchValue)) {
+                                    newValue = mapping.valueMap.get(matchValue);
+                                    changed = true;
+                                }
+                            }
+                            else {
+                                if (typeof matchValue === "string" ||
+                                    typeof matchValue === "number") {
+                                    if (matchValue in mapping.valueMap) {
+                                        newValue = mapping.valueMap[matchValue];
+                                        changed = true;
+                                    }
+                                }
+                            }
+                            if (changed && newValue !== matchValue) {
+                                setValueAtPath(transformedValue, match.path, newValue);
+                            }
+                        }
+                    }
+                    return changed ? transformedValue : value;
+                }
+            }
+            else {
+                if (value !== null && value !== undefined) {
+                    if (mapping.valueMap instanceof Map) {
+                        if (mapping.valueMap.has(value)) {
+                            return mapping.valueMap.get(value);
+                        }
+                    }
+                    else {
+                        if (typeof value === "string" || typeof value === "number") {
+                            if (value in mapping.valueMap) {
+                                return mapping.valueMap[value];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return value;
+    };
+}
+
 exports.BatchedEngine = BatchedEngine;
 exports.CompositeCategory = CompositeCategory;
 exports.ComputeCategory = ComputeCategory;
@@ -3485,6 +4055,8 @@ exports.PullEngine = PullEngine;
 exports.PushEngine = PushEngine;
 exports.Registry = Registry;
 exports.StepEngine = StepEngine;
+exports.buildValueConverter = buildValueConverter;
+exports.computeGraphCenter = computeGraphCenter;
 exports.createAsyncGraphDef = createAsyncGraphDef;
 exports.createAsyncGraphRegistry = createAsyncGraphRegistry;
 exports.createEngine = createEngine;
@@ -3494,13 +4066,22 @@ exports.createSimpleGraphDef = createSimpleGraphDef;
 exports.createSimpleGraphRegistry = createSimpleGraphRegistry;
 exports.createValidationGraphDef = createValidationGraphDef;
 exports.createValidationGraphRegistry = createValidationGraphRegistry;
+exports.findMatchingPaths = findMatchingPaths;
+exports.generateId = generateId;
 exports.getInputTypeId = getInputTypeId;
 exports.getTypedOutputTypeId = getTypedOutputTypeId;
 exports.getTypedOutputValue = getTypedOutputValue;
+exports.getValueAtPath = getValueAtPath;
 exports.installLogging = installLogging;
 exports.isInputPrivate = isInputPrivate;
 exports.isTypedOutput = isTypedOutput;
+exports.mergeGraphDefinitions = mergeGraphDefinitions;
+exports.mergeInputsOutputs = mergeInputsOutputs;
+exports.mergeSnapshotData = mergeSnapshotData;
+exports.offsetImportedPositions = offsetImportedPositions;
+exports.parseJsonPath = parseJsonPath;
 exports.registerDelayNode = registerDelayNode;
 exports.registerProgressNodes = registerProgressNodes;
+exports.setValueAtPath = setValueAtPath;
 exports.typed = typed;
 //# sourceMappingURL=index.cjs.map