@bian-womp/spark-workbench 0.3.45 → 0.3.47

package/lib/cjs/index.cjs

@@ -609,51 +609,6 @@ class InMemoryWorkbench extends AbstractWorkbench {
             bounds,
         };
     }
-    /**
-     * Duplicate all selected nodes.
-     * Returns the list of newly created node IDs.
-     * Each duplicated node is offset by 24px in both x and y directions.
-     * Copies inputs without bindings and uses copyOutputsFrom to copy outputs.
-     */
-    duplicateSelection(runner, options) {
-        const selection = this.getSelection();
-        if (selection.nodes.length === 0)
-            return [];
-        const positions = this.getPositions();
-        const sizes = this.getSizes();
-        const newNodes = [];
-        // Get inputs without bindings (literal values only)
-        const allInputs = runner.getInputs(this.def) || {};
-        // Duplicate each selected node
-        for (const nodeId of selection.nodes) {
-            const n = this.def.nodes.find((n) => n.nodeId === nodeId);
-            if (!n)
-                continue;
-            const pos = positions[nodeId];
-            const size = sizes[nodeId];
-            const inboundHandles = new Set(this.def.edges
-                .filter((e) => e.target.nodeId === nodeId)
-                .map((e) => e.target.handle));
-            const inputsWithoutBindings = Object.fromEntries(Object.entries(allInputs).filter(([handle]) => !inboundHandles.has(handle)));
-            const newNodeId = this.addNode({
-                typeId: n.typeId,
-                params: n.params,
-                resolvedHandles: n.resolvedHandles,
-            }, {
-                inputs: inputsWithoutBindings,
-                position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
-                size,
-                copyOutputsFrom: nodeId,
-                dry: true,
-            });
-            newNodes.push(newNodeId);
-        }
-        // Select all newly duplicated nodes
-        if (newNodes.length > 0) {
-            this.setSelectionInternal({ nodes: newNodes, edges: [] }, options || { commit: true, reason: "duplicate-selection" });
-        }
-        return newNodes;
-    }
     /**
      * Bake an output value from a node into a new node.
      * Creates a new node based on the output type's bakeTarget configuration.
@@ -747,37 +702,97 @@ class InMemoryWorkbench extends AbstractWorkbench {
         }
     }
     /**
-     * Duplicate a single node.
-     * Returns the ID of the newly created node.
-     * The duplicated node is offset by 24px in both x and y directions.
+     * Duplicate all selected nodes.
+     * Returns the list of newly created node IDs.
+     * Each duplicated node is offset by 24px in both x and y directions.
      * Copies inputs without bindings and uses copyOutputsFrom to copy outputs.
      */
-    duplicateNode(nodeId, runner, options) {
-        const n = this.def.nodes.find((n) => n.nodeId === nodeId);
-        if (!n)
-            return undefined;
-        const pos = this.getPositions()[nodeId];
-        const size = this.getSizes()[nodeId];
-        // Get inputs without bindings (literal values only)
-        const allInputs = runner.getInputs(this.def)[nodeId] || {};
-        const inboundHandles = new Set(this.def.edges
-            .filter((e) => e.target.nodeId === nodeId)
-            .map((e) => e.target.handle));
-        const inputsWithoutBindings = Object.fromEntries(Object.entries(allInputs).filter(([handle]) => !inboundHandles.has(handle)));
-        const newNodeId = this.addNode({
-            typeId: n.typeId,
-            params: n.params,
-            resolvedHandles: n.resolvedHandles,
-        }, {
-            inputs: inputsWithoutBindings,
-            position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
-            size,
-            copyOutputsFrom: nodeId,
-            dry: true,
-        });
-        // Select the newly duplicated node
-        this.setSelectionInternal({ nodes: [newNodeId], edges: [] }, options || { commit: true, reason: "duplicate-node" });
-        return newNodeId;
+    duplicateSelection(runner, options) {
+        const selection = this.getSelection();
+        if (selection.nodes.length === 0)
+            return [];
+        const positions = this.getPositions();
+        const sizes = this.getSizes();
+        const newNodes = [];
+        const nodeIdMap = new Map(); // Map from original nodeId to new nodeId
+        const processedNodes = new Set(); // Track which nodes have been duplicated
+        const selectedNodeSet = new Set(selection.nodes);
+        const allInputs = runner.getInputs(this.def) || {};
+        // Build a map of incoming edges for each selected node
+        const incomingEdgesByNode = new Map();
+        for (const nodeId of selection.nodes) {
+            const incomingEdges = this.def.edges.filter((e) => e.target.nodeId === nodeId);
+            incomingEdgesByNode.set(nodeId, incomingEdges);
+        }
+        // Helper function to check if a node is ready to be processed
+        // (all its dependencies from selected nodes have been processed)
+        const isNodeReady = (nodeId) => {
+            const incomingEdges = incomingEdgesByNode.get(nodeId) || [];
+            for (const edge of incomingEdges) {
+                // If the source is a selected node, it must have been processed
+                if (selectedNodeSet.has(edge.source.nodeId)) {
+                    if (!processedNodes.has(edge.source.nodeId)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        };
+        // Process nodes in topological order
+        let remainingNodes = new Set(selection.nodes);
+        while (remainingNodes.size > 0) {
+            // Find nodes that are ready to be processed (no unprocessed dependencies)
+            const readyNodes = Array.from(remainingNodes).filter((nodeId) => isNodeReady(nodeId));
+            if (readyNodes.length === 0) {
+                // If no nodes are ready, there might be a cycle. Process remaining nodes anyway.
+                // This shouldn't happen in a DAG, but handle it gracefully.
+                readyNodes.push(...remainingNodes);
+            }
+            // Process each ready node
+            for (const nodeId of readyNodes) {
+                const n = this.def.nodes.find((n) => n.nodeId === nodeId);
+                if (!n) {
+                    remainingNodes.delete(nodeId);
+                    continue;
+                }
+                const pos = positions[nodeId];
+                const size = sizes[nodeId];
+                // Get all inputs (including those with bindings, since edges will be duplicated)
+                const inputs = allInputs[nodeId] || {};
+                // Create the duplicated node
+                const newNodeId = this.addNode({
+                    typeId: n.typeId,
+                    params: n.params,
+                    resolvedHandles: n.resolvedHandles,
+                }, {
+                    inputs,
+                    position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
+                    size,
+                    copyOutputsFrom: nodeId,
+                    dry: true,
+                });
+                newNodes.push(newNodeId);
+                nodeIdMap.set(nodeId, newNodeId);
+                processedNodes.add(nodeId);
+                // Connect incoming edges for this node
+                const incomingEdges = incomingEdgesByNode.get(nodeId) || [];
+                for (const edge of incomingEdges) {
+                    // Determine the source node: use duplicated node if it was duplicated, otherwise use original
+                    const sourceNodeId = nodeIdMap.get(edge.source.nodeId) || edge.source.nodeId;
+                    this.connect({
+                        source: { nodeId: sourceNodeId, handle: edge.source.handle },
+                        target: { nodeId: newNodeId, handle: edge.target.handle },
+                        typeId: edge.typeId,
+                    }, { dry: true });
+                }
+                remainingNodes.delete(nodeId);
+            }
+        }
+        // Select all newly duplicated nodes
+        if (newNodes.length > 0) {
+            this.setSelectionInternal({ nodes: newNodes, edges: [] }, options || { commit: true, reason: "duplicate-selection" });
+        }
+        return newNodes;
     }
     /**
      * Duplicate a node and all its incoming edges.
@@ -785,7 +800,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
      * The duplicated node is offset by 24px in both x and y directions.
      * All incoming edges are duplicated to point to the new node.
      */
-    duplicateNodeWithEdges(nodeId, runner, options) {
+    duplicateNode(nodeId, runner, options) {
         const n = this.def.nodes.find((n) => n.nodeId === nodeId);
         if (!n)
             return undefined;
@@ -817,7 +832,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
         }
         // Select the newly duplicated node
         if (newNodeId) {
-            this.setSelectionInternal({ nodes: [newNodeId], edges: [] }, options || { commit: true, reason: "duplicate-node-with-edges" });
+            this.setSelectionInternal({ nodes: [newNodeId], edges: [] }, options || { commit: true, reason: "duplicate-node" });
         }
         return newNodeId;
     }
@@ -5091,9 +5106,9 @@ function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap,
             onClose();
         },
         onDuplicate: async () => {
-            wb.duplicateNodeWithEdges(nodeId, runner, {
+            wb.duplicateNode(nodeId, runner, {
                 commit: true,
-                reason: "duplicate-node-with-edges",
+                reason: "duplicate-node",
             });
             onClose();
         },
@@ -5331,6 +5346,13 @@ function Inspector({ debug, autoScroll, hideWorkbench, onAutoScrollChange, onHid
             return String(value ?? "");
         }
     };
+    const unwrapForDisplay = (declaredTypeId, value) => {
+        if (sparkGraph.isTyped(value)) {
+            const t = sparkGraph.unwrapTypeId(value) ?? declaredTypeId;
+            return { typeId: t, value: sparkGraph.unwrapValue(value) };
+        }
+        return { typeId: declaredTypeId, value };
+    };
     const { wb, registryVersion, selectedNodeId, selectedEdgeId, inputsMap, inputDefaultsMap, outputsMap, outputTypesMap, nodeStatus, edgeStatus, validationByNode, validationByEdge, validationGlobal, valuesTick, updateEdgeType, systemErrors, registryErrors, inputValidationErrors, clearSystemErrors, clearRegistryErrors, clearInputValidationErrors, removeSystemError, removeRegistryError, removeInputValidationError, handlesMap, } = useWorkbenchContext();
     const nodeValidationIssues = validationByNode.issues;
     const edgeValidationIssues = validationByEdge.issues;
@@ -5460,7 +5482,8 @@ function Inspector({ debug, autoScroll, hideWorkbench, onAutoScrollChange, onHid
         for (const h of handles) {
             const typeId = sparkGraph.getInputTypeId(effectiveHandles.inputs, h);
             const current = nodeInputs[h];
-            const display = safeToString(typeId, current);
+            const { typeId: displayTypeId, value: displayValue } = unwrapForDisplay(typeId, current);
+            const display = safeToString(displayTypeId, displayValue);
             const wasOriginal = originals[h];
             const isDirty = drafts[h] !== undefined &&
                 wasOriginal !== undefined &&
@@ -5512,18 +5535,19 @@ function Inspector({ debug, autoScroll, hideWorkbench, onAutoScrollChange, onHid
                                                 .filter((e) => e.target.nodeId === selectedNodeId &&
                                                 e.target.handle === h)
                                                 .map((e) => e.target.handle));
+                                            const { typeId: defaultTypeId, value: defaultValue } = unwrapForDisplay(typeId, nodeInputsDefaults[h]);
                                             const hasDefault = !inbound.has(h) && nodeInputsDefaults[h] !== undefined;
                                             const defaultStr = hasDefault
-                                                ? safeToString(typeId, nodeInputsDefaults[h])
+                                                ? safeToString(defaultTypeId, defaultValue)
                                                 : undefined;
                                             const commonProps = {
                                                 style: { flex: 1 },
                                                 disabled: isLinked,
                                             };
                                             const current = nodeInputs[h];
-                                            const hasValue = current !== undefined && current !== null;
-                                            const value = drafts[h] ?? safeToString(typeId, current);
-                                            const displayValue = value;
+                                            const { typeId: displayTypeId, value: displayValue } = unwrapForDisplay(typeId, current);
+                                            const hasValue = displayValue !== undefined && displayValue !== null;
+                                            const value = drafts[h] ?? safeToString(displayTypeId, displayValue);
                                             const placeholder = hasDefault ? defaultStr : undefined;
                                             const onChangeText = (text) => setDrafts((d) => ({ ...d, [h]: text }));
                                             const commit = () => {
@@ -5549,7 +5573,7 @@ function Inspector({ debug, autoScroll, hideWorkbench, onAutoScrollChange, onHid
                                                 setDrafts((d) => ({ ...d, [h]: "" }));
                                                 setOriginals((o) => ({ ...o, [h]: "" }));
                                             };
-                                            const isEnum = typeId?.startsWith("enum:");
+                                            const isEnum = displayTypeId?.startsWith("enum:");
                                             const inIssues = selectedNodeHandleValidation.inputs.filter((m) => m.handle === h);
                                             const hasValidation = inIssues.length > 0;
                                             const hasErr = inIssues.some((m) => m.level === "error");
@@ -5570,9 +5594,9 @@ function Inspector({ debug, autoScroll, hideWorkbench, onAutoScrollChange, onHid
                                                                             ? `Default: ${placeholder}`
                                                                             : "(select)" }), wb.registry.enums
                                                                         .get(typeId)
-                                                                        ?.options.map((opt) => (jsxRuntime.jsx("option", { value: String(opt.value), children: opt.label }, opt.value)))] }), hasValue && !isLinked && (jsxRuntime.jsx("button", { className: "flex-shrink-0 p-1 hover:bg-gray-100 rounded text-gray-500 hover:text-gray-700", onClick: clearInput, title: "Clear input value", children: jsxRuntime.jsx(react$1.XCircleIcon, { size: 16 }) }))] })) : isLinked ? (jsxRuntime.jsx("div", { className: "flex items-center gap-1 flex-1", children: jsxRuntime.jsx("div", { className: "flex-1 min-w-0", children: renderLinkedInputDisplay(typeId, current) }) })) : (jsxRuntime.jsxs("div", { className: "flex items-center gap-1 flex-1", children: [jsxRuntime.jsx("input", { className: "border border-gray-300 rounded px-2 py-1 focus:outline-none focus:ring-2 focus:ring-blue-500 flex-1 select-text", placeholder: placeholder
+                                                                        ?.options.map((opt) => (jsxRuntime.jsx("option", { value: String(opt.value), children: opt.label }, opt.value)))] }), hasValue && !isLinked && (jsxRuntime.jsx("button", { className: "flex-shrink-0 p-1 hover:bg-gray-100 rounded text-gray-500 hover:text-gray-700", onClick: clearInput, title: "Clear input value", children: jsxRuntime.jsx(react$1.XCircleIcon, { size: 16 }) }))] })) : isLinked ? (jsxRuntime.jsx("div", { className: "flex items-center gap-1 flex-1", children: jsxRuntime.jsx("div", { className: "flex-1 min-w-0", children: renderLinkedInputDisplay(displayTypeId, displayValue) }) })) : (jsxRuntime.jsxs("div", { className: "flex items-center gap-1 flex-1", children: [jsxRuntime.jsx("input", { className: "border border-gray-300 rounded px-2 py-1 focus:outline-none focus:ring-2 focus:ring-blue-500 flex-1 select-text", placeholder: placeholder
                                                                     ? `Default: ${placeholder}`
-                                                                    : undefined, value: displayValue, onChange: (e) => onChangeText(e.target.value), onBlur: commit, onKeyDown: (e) => {
+                                                                    : undefined, value: value, onChange: (e) => onChangeText(e.target.value), onBlur: commit, onKeyDown: (e) => {
                                                                     if (e.key === "Enter")
                                                                         commit();
                                                                     if (e.key === "Escape")