@bian-womp/spark-workbench 0.2.64 → 0.2.65

package/lib/cjs/index.cjs

@@ -367,6 +367,142 @@ class InMemoryWorkbench extends AbstractWorkbench {
             for (const h of Array.from(set))
                 h(payload);
     }
+    /**
+     * Copy selected nodes and their internal edges.
+     * Returns data in a format suitable for pasting.
+     * Positions are normalized relative to the selection bounds center.
+     * Uses the same logic as duplicate: copies inputs without bindings and supports copyOutputsFrom.
+     */
+    copySelection(runner, getNodeSize) {
+        const selection = this.getSelection();
+        if (selection.nodes.length === 0)
+            return null;
+        const def = this.export();
+        const positions = this.getPositions();
+        const selectedNodeSet = new Set(selection.nodes);
+        // Collect nodes to copy
+        const nodesToCopy = def.nodes.filter((n) => selectedNodeSet.has(n.nodeId));
+        if (nodesToCopy.length === 0)
+            return null;
+        // Calculate bounds
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        nodesToCopy.forEach((node) => {
+            const pos = positions[node.nodeId] || { x: 0, y: 0 };
+            const size = getNodeSize?.(node.nodeId, node.typeId) || {
+                width: 200,
+                height: 100,
+            };
+            minX = Math.min(minX, pos.x);
+            minY = Math.min(minY, pos.y);
+            maxX = Math.max(maxX, pos.x + size.width);
+            maxY = Math.max(maxY, pos.y + size.height);
+        });
+        const bounds = { minX, minY, maxX, maxY };
+        const centerX = (bounds.minX + bounds.maxX) / 2;
+        const centerY = (bounds.minY + bounds.maxY) / 2;
+        // Get inputs for each node
+        // Include values from inbound edges if those edges are selected
+        const allInputs = runner.getInputs(def);
+        const selectedEdgeSet = new Set(selection.edges);
+        const copiedNodes = nodesToCopy.map((node) => {
+            const pos = positions[node.nodeId] || { x: 0, y: 0 };
+            // Get all inbound edges for this node
+            const inboundEdges = def.edges.filter((e) => e.target.nodeId === node.nodeId);
+            // Build set of handles that have inbound edges
+            // But only exclude handles whose edges are NOT selected
+            const inboundHandlesToExclude = new Set(inboundEdges
+                .filter((e) => !selectedEdgeSet.has(e.id)) // Only exclude if edge is not selected
+                .map((e) => e.target.handle));
+            const allNodeInputs = allInputs[node.nodeId] || {};
+            // Include inputs that either:
+            // 1. Don't have inbound edges (literal values)
+            // 2. Have inbound edges that ARE selected (preserve the value from the edge)
+            const inputsToCopy = Object.fromEntries(Object.entries(allNodeInputs).filter(([handle]) => !inboundHandlesToExclude.has(handle)));
+            return {
+                typeId: node.typeId,
+                params: node.params,
+                resolvedHandles: node.resolvedHandles,
+                position: {
+                    x: pos.x - centerX,
+                    y: pos.y - centerY,
+                },
+                inputs: inputsToCopy,
+                originalNodeId: node.nodeId,
+            };
+        });
+        // Collect edges between copied nodes
+        const copiedEdges = def.edges
+            .filter((edge) => {
+            return (selectedNodeSet.has(edge.source.nodeId) &&
+                selectedNodeSet.has(edge.target.nodeId));
+        })
+            .map((edge) => ({
+            sourceNodeId: edge.source.nodeId,
+            sourceHandle: edge.source.handle,
+            targetNodeId: edge.target.nodeId,
+            targetHandle: edge.target.handle,
+            typeId: edge.typeId,
+        }));
+        return {
+            nodes: copiedNodes,
+            edges: copiedEdges,
+            bounds,
+        };
+    }
+    /**
+     * Paste copied graph data at the specified center position.
+     * Returns the mapping from original node IDs to new node IDs.
+     * Uses copyOutputsFrom to copy outputs from original nodes (like duplicate does).
+     */
+    pasteCopiedData(data, center) {
+        const nodeIdMap = new Map();
+        const edgeIds = [];
+        // Add nodes
+        for (const nodeData of data.nodes) {
+            const newNodeId = this.addNode({
+                typeId: nodeData.typeId,
+                params: nodeData.params,
+                resolvedHandles: nodeData.resolvedHandles,
+                position: {
+                    x: nodeData.position.x + center.x,
+                    y: nodeData.position.y + center.y,
+                },
+            }, {
+                inputs: nodeData.inputs,
+                copyOutputsFrom: nodeData.originalNodeId,
+                dry: true,
+            });
+            nodeIdMap.set(nodeData.originalNodeId, newNodeId);
+        }
+        // Add edges
+        for (const edgeData of data.edges) {
+            const newSourceNodeId = nodeIdMap.get(edgeData.sourceNodeId);
+            const newTargetNodeId = nodeIdMap.get(edgeData.targetNodeId);
+            if (newSourceNodeId && newTargetNodeId) {
+                const edgeId = this.connect({
+                    source: {
+                        nodeId: newSourceNodeId,
+                        handle: edgeData.sourceHandle,
+                    },
+                    target: {
+                        nodeId: newTargetNodeId,
+                        handle: edgeData.targetHandle,
+                    },
+                    typeId: edgeData.typeId,
+                }, { dry: true });
+                edgeIds.push(edgeId);
+            }
+        }
+        // Select the newly pasted nodes
+        this.setSelection({
+            nodes: Array.from(nodeIdMap.values()),
+            edges: edgeIds,
+        });
+        return { nodeIdMap, edgeIds };
+    }
 }
 
 class CLIWorkbench {
@@ -3648,7 +3784,7 @@ function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap,
                 .map((e) => e.target.handle));
             const allInputs = runner.getInputs(def)[nodeId] || {};
             const inputsWithoutBindings = Object.fromEntries(Object.entries(allInputs).filter(([handle]) => !inboundHandles.has(handle)));
-            wb.addNode({
+            const newNodeId = wb.addNode({
                 typeId: n.typeId,
                 params: n.params,
                 position: { x: pos.x + 24, y: pos.y + 24 },
@@ -3658,6 +3794,11 @@ function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap,
                 copyOutputsFrom: nodeId,
                 dry: true,
             });
+            // Select the newly duplicated node
+            wb.setSelection({
+                nodes: [newNodeId],
+                edges: [],
+            });
             onClose();
         },
         onDuplicateWithEdges: async () => {
@@ -3689,6 +3830,11 @@ function createNodeContextMenuHandlers(nodeId, wb, runner, registry, outputsMap,
                     typeId: edge.typeId,
                 }, { dry: true });
             }
+            // Select the newly duplicated node and edges
+            wb.setSelection({
+                nodes: [newNodeId],
+                edges: [],
+            });
             onClose();
         },
         onRunPull: async () => {