@bian-womp/spark-workbench 0.3.46 → 0.3.48

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();
         },