@bian-womp/spark-workbench 0.2.84 → 0.2.85

package/lib/cjs/index.cjs

@@ -159,9 +159,11 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const defNodeIds = new Set(this._def.nodes.map((n) => n.nodeId));
         const defEdgeIds = new Set(this._def.edges.map((e) => e.id));
         const filteredPositions = Object.fromEntries(Object.entries(this.positions).filter(([id]) => defNodeIds.has(id)));
+        const filteredSizes = Object.fromEntries(Object.entries(this.sizes).filter(([id]) => defNodeIds.has(id)));
         const filteredNodes = this.selection.nodes.filter((id) => defNodeIds.has(id));
         const filteredEdges = this.selection.edges.filter((id) => defEdgeIds.has(id));
         this.positions = filteredPositions;
+        this.sizes = filteredSizes;
         this.selection = { nodes: filteredNodes, edges: filteredEdges };
         this.emit("graphChanged", { def: this._def });
         this.refreshValidation();
@@ -218,8 +220,10 @@ class InMemoryWorkbench extends AbstractWorkbench {
             params: node.params,
             resolvedHandles: node.resolvedHandles,
         });
-        if (node.position)
-            this.positions[id] = node.position;
+        if (options?.position)
+            this.positions[id] = options.position;
+        if (options?.size)
+            this.sizes[id] = options.size;
         this.emit("graphChanged", {
             def: this._def,
             change: {
@@ -237,6 +241,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
         this._def.nodes = this._def.nodes.filter((n) => n.nodeId !== nodeId);
         this._def.edges = this._def.edges.filter((e) => e.source.nodeId !== nodeId && e.target.nodeId !== nodeId);
         delete this.positions[nodeId];
+        delete this.sizes[nodeId];
         delete this.nodeNames[nodeId];
         this.emit("graphChanged", {
             def: this._def,
@@ -303,14 +308,16 @@ class InMemoryWorkbench extends AbstractWorkbench {
         return { ...this.positions };
     }
     setSizes(sizes, options) {
+        const updatedSizes = { ...this.sizes };
         for (const [nodeId, size] of Object.entries(sizes)) {
             if (size) {
-                this.sizes = { ...this.sizes, [nodeId]: size };
+                updatedSizes[nodeId] = size;
             }
             else {
-                this.sizes = lod.omit(this.sizes, nodeId);
+                delete updatedSizes[nodeId];
             }
         }
+        this.sizes = updatedSizes;
         this.emit("graphUiChanged", {
             change: { type: "resizeNodes" },
             ...options,
@@ -468,6 +475,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
         if (selection.nodes.length === 0)
             return null;
         const positions = this.getPositions();
+        const sizes = this.getSizes();
         const selectedNodeSet = new Set(selection.nodes);
         // Collect nodes to copy
         const nodesToCopy = this.def.nodes.filter((n) => selectedNodeSet.has(n.nodeId));
@@ -479,15 +487,16 @@ class InMemoryWorkbench extends AbstractWorkbench {
         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 pos = positions[node.nodeId];
+            const size = sizes[node.nodeId] || getNodeSize?.(node.nodeId, node.typeId);
+            if (pos) {
+                minX = Math.min(minX, pos.x);
+                minY = Math.min(minY, pos.y);
+                if (size) {
+                    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;
@@ -497,7 +506,8 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const allInputs = runner.getInputs(this.def);
         const selectedEdgeSet = new Set(selection.edges);
         const copiedNodes = nodesToCopy.map((node) => {
-            const pos = positions[node.nodeId] || { x: 0, y: 0 };
+            const pos = positions[node.nodeId];
+            const size = sizes[node.nodeId];
             // Get all inbound edges for this node
             const inboundEdges = this.def.edges.filter((e) => e.target.nodeId === node.nodeId);
             // Build set of handles that have inbound edges
@@ -514,10 +524,13 @@ class InMemoryWorkbench extends AbstractWorkbench {
                 typeId: node.typeId,
                 params: node.params,
                 resolvedHandles: node.resolvedHandles,
-                position: {
-                    x: pos.x - centerX,
-                    y: pos.y - centerY,
-                },
+                position: pos
+                    ? {
+                        x: pos.x - centerX,
+                        y: pos.y - centerY,
+                    }
+                    : undefined,
+                size,
                 inputs: inputsToCopy,
                 originalNodeId: node.nodeId,
             };
@@ -552,6 +565,7 @@ class InMemoryWorkbench extends AbstractWorkbench {
         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) || {};
@@ -560,7 +574,8 @@ class InMemoryWorkbench extends AbstractWorkbench {
             const n = this.def.nodes.find((n) => n.nodeId === nodeId);
             if (!n)
                 continue;
-            const pos = positions[nodeId] || { x: 0, y: 0 };
+            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));
@@ -568,10 +583,11 @@ class InMemoryWorkbench extends AbstractWorkbench {
             const newNodeId = this.addNode({
                 typeId: n.typeId,
                 params: n.params,
-                position: { x: pos.x + 24, y: pos.y + 24 },
                 resolvedHandles: n.resolvedHandles,
             }, {
                 inputs: inputsWithoutBindings,
+                position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
+                size,
                 copyOutputsFrom: nodeId,
                 dry: true,
             });
@@ -618,8 +634,10 @@ class InMemoryWorkbench extends AbstractWorkbench {
                 const coerced = await coerceIfNeeded(outputTypeId, inType, unwrap(outputValue));
                 newNodeId = this.addNode({
                     typeId: singleTarget.nodeTypeId,
+                }, {
+                    inputs: { [singleTarget.inputHandle]: coerced },
                     position: { x: pos.x + 180, y: pos.y },
-                }, { inputs: { [singleTarget.inputHandle]: coerced } });
+                });
             }
             else if (isArray && arrTarget) {
                 const nodeDesc = registry.nodes.get(arrTarget.nodeTypeId);
@@ -627,8 +645,10 @@ class InMemoryWorkbench extends AbstractWorkbench {
                 const coerced = await coerceIfNeeded(outputTypeId, inType, unwrap(outputValue));
                 newNodeId = this.addNode({
                     typeId: arrTarget.nodeTypeId,
+                }, {
                     position: { x: pos.x + 180, y: pos.y },
-                }, { inputs: { [arrTarget.inputHandle]: coerced } });
+                    inputs: { [arrTarget.inputHandle]: coerced },
+                });
             }
             else if (isArray && elemTarget) {
                 const nodeDesc = registry.nodes.get(elemTarget.nodeTypeId);
@@ -644,8 +664,10 @@ class InMemoryWorkbench extends AbstractWorkbench {
                     const row = Math.floor(idx / COLS);
                     newNodeId = this.addNode({
                         typeId: elemTarget.nodeTypeId,
+                    }, {
                         position: { x: pos.x + (col + 1) * DX, y: pos.y + row * DY },
-                    }, { inputs: { [elemTarget.inputHandle]: coercedItems[idx] } });
+                        inputs: { [elemTarget.inputHandle]: coercedItems[idx] },
+                    });
                 }
             }
             if (newNodeId) {
@@ -667,7 +689,8 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const n = this.def.nodes.find((n) => n.nodeId === nodeId);
         if (!n)
             return undefined;
-        const pos = this.getPositions()[nodeId] || { x: 0, y: 0 };
+        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
@@ -677,10 +700,11 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const newNodeId = this.addNode({
             typeId: n.typeId,
             params: n.params,
-            position: { x: pos.x + 24, y: pos.y + 24 },
             resolvedHandles: n.resolvedHandles,
         }, {
             inputs: inputsWithoutBindings,
+            position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
+            size,
             copyOutputsFrom: nodeId,
             dry: true,
         });
@@ -698,17 +722,19 @@ class InMemoryWorkbench extends AbstractWorkbench {
         const n = this.def.nodes.find((n) => n.nodeId === nodeId);
         if (!n)
             return undefined;
-        const pos = this.getPositions()[nodeId] || { x: 0, y: 0 };
+        const pos = this.getPositions()[nodeId];
+        const size = this.getSizes()[nodeId];
         // Get all inputs (including those with bindings, since edges will be duplicated)
         const inputs = runner.getInputs(this.def)[nodeId] || {};
         // Add the duplicated node
         const newNodeId = this.addNode({
             typeId: n.typeId,
             params: n.params,
-            position: { x: pos.x + 24, y: pos.y + 24 },
             resolvedHandles: n.resolvedHandles,
         }, {
             inputs,
+            position: pos ? { x: pos.x + 24, y: pos.y + 24 } : undefined,
+            size,
             copyOutputsFrom: nodeId,
             dry: true,
         });
@@ -742,12 +768,15 @@ class InMemoryWorkbench extends AbstractWorkbench {
                 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,
+                position: nodeData.position
+                    ? {
+                        x: nodeData.position.x + center.x,
+                        y: nodeData.position.y + center.y,
+                    }
+                    : undefined,
+                size: nodeData.size,
                 copyOutputsFrom: nodeData.originalNodeId,
                 dry: true,
             });
@@ -5160,7 +5189,7 @@ const WorkbenchCanvas = React.forwardRef(({ showValues, toString, toElement, get
         setNodeMenuOpen(false);
         setSelectionMenuOpen(false);
     };
-    const addNodeAt = React.useCallback(async (typeId, opts) => wb.addNode({ typeId, position: opts.position }, { inputs: opts.inputs, commit: true }), [wb]);
+    const addNodeAt = React.useCallback(async (typeId, opts) => wb.addNode({ typeId }, { inputs: opts.inputs, position: opts.position, commit: true }), [wb]);
     const onCloseMenu = React.useCallback(() => {
         setMenuOpen(false);
     }, []);