@bian-womp/spark-workbench 0.3.87 → 0.3.89

package/lib/cjs/index.cjs

@@ -4475,125 +4475,94 @@ function WorkbenchProvider({ wb, runner, overrides, uiVersion, children, }) {
         const offWbGraphUiChangedForLog = wb.on("graphUiChanged", add("workbench", "graphUiChanged"));
         const offWbValidationChanged = wb.on("validationChanged", add("workbench", "validationChanged"));
         // Ensure newly added nodes start as invalidated until first evaluation
-        const offWbGraphChangedForUpdate = wb.on("graphChanged", async (event) => {
-            // Handle batched compound operations (duplicate, paste, delete, bake)
-            if (event.change?.type === "batch") {
-                const { changes } = event.change;
-                const isDry = !!event.dry;
-                const batchReason = event.reason ?? "batch";
-                try {
-                    if (runner.isRunning()) {
-                        const hasNodeOps = changes.some((c) => c.type === "addNode" && (c.inputs || c.copyOutputsFrom));
-                        await runner.update(event.def, { dry: isDry || hasNodeOps });
-                        for (const change of changes) {
-                            if (change.type === "addNode") {
-                                if (change.inputs) {
-                                    await runner.setInputs(change.nodeId, change.inputs, { dry: isDry });
-                                }
-                                if (change.copyOutputsFrom) {
-                                    await runner.copyOutputs(change.copyOutputsFrom, change.nodeId, { dry: isDry });
-                                }
-                            }
-                            if (change.type === "setInputs") {
-                                await runner.setInputs(change.nodeId, change.inputs, { dry: isDry });
-                            }
-                        }
-                    }
-                    if (event.commit) {
-                        await saveUiRuntimeMetadata(wb, runner);
-                        const history = await runner.commit(batchReason).catch((err) => {
-                            console.error("[WorkbenchContext] Error committing batch:", err);
-                            return undefined;
-                        });
-                        if (history)
-                            wb.setHistory(history);
-                    }
-                }
-                catch (err) {
-                    console.error("[WorkbenchContext] Error processing batch:", err);
-                }
+        const GRAPH_REASON_BY_CHANGE = {
+            addNode: "add-node",
+            removeNode: "remove-node",
+            connect: "connect-edge",
+            disconnect: "disconnect-edge",
+            updateParams: "update-node-params",
+            updateEdgeType: "update-edge-type",
+            setInputs: "set-inputs",
+            updateResolvedHandles: "update-resolved-handles",
+        };
+        const getGraphReason = (event) => {
+            const changeType = event.change?.type;
+            return (changeType && GRAPH_REASON_BY_CHANGE[changeType]) || "graph-changed";
+        };
+        const commitGraphChange = async (shouldCommit, reason, errorPrefix) => {
+            if (!shouldCommit)
                 return;
+            await saveUiRuntimeMetadata(wb, runner);
+            const history = await runner.commit(reason).catch((err) => {
+                console.error(errorPrefix, err);
+                return undefined;
+            });
+            if (history)
+                wb.setHistory(history);
+        };
+        const applyAddNodeEffects = async (nodeId, inputs, copyOutputsFrom, dry) => {
+            if (inputs) {
+                await runner.setInputs(nodeId, inputs, { dry });
             }
-            // Build detailed reason from change type
-            let reason = "graph-changed";
-            if (event.change) {
-                const changeType = event.change.type;
-                if (changeType === "addNode") {
-                    reason = "add-node";
-                }
-                else if (changeType === "removeNode") {
-                    reason = "remove-node";
-                }
-                else if (changeType === "connect") {
-                    reason = "connect-edge";
-                }
-                else if (changeType === "disconnect") {
-                    reason = "disconnect-edge";
-                }
-                else if (changeType === "updateParams") {
-                    reason = "update-node-params";
-                }
-                else if (changeType === "updateEdgeType") {
-                    reason = "update-edge-type";
-                }
-                else if (changeType === "setInputs") {
-                    reason = "set-inputs";
+            if (copyOutputsFrom) {
+                await runner.copyOutputs(copyOutputsFrom, nodeId, { dry });
+            }
+        };
+        const applyBatchGraphChange = async (event) => {
+            if (event.change?.type !== "batch")
+                return;
+            const { changes } = event.change;
+            const dry = !!event.dry;
+            if (!runner.isRunning())
+                return;
+            const hasNodeOps = changes.some((c) => c.type === "addNode" && (c.inputs || c.copyOutputsFrom));
+            await runner.update(event.def, { dry: dry || hasNodeOps });
+            for (const change of changes) {
+                if (change.type === "addNode") {
+                    await applyAddNodeEffects(change.nodeId, change.inputs, change.copyOutputsFrom, dry);
                 }
-                else if (changeType === "updateResolvedHandles") {
-                    reason = "update-resolved-handles";
+                else if (change.type === "setInputs") {
+                    await runner.setInputs(change.nodeId, change.inputs, { dry });
                 }
             }
+        };
+        const applySingleGraphChange = async (event) => {
+            if (event.change?.type === "batch")
+                return;
             if (event.change?.type === "setInputs") {
                 const { nodeId, inputs } = event.change;
                 await runner.setInputs(nodeId, inputs, { dry: event.dry });
             }
-            if (!runner.isRunning()) {
-                if (event.commit) {
-                    await saveUiRuntimeMetadata(wb, runner);
-                    const history = await runner.commit(reason).catch((err) => {
-                        console.error("[WorkbenchContext] Error committing:", err);
-                        return undefined;
-                    });
-                    if (history)
-                        wb.setHistory(history);
+            if (!runner.isRunning())
+                return;
+            if (event.change?.type === "addNode") {
+                const { nodeId, inputs, copyOutputsFrom } = event.change;
+                if (event.dry) {
+                    await runner.update(event.def, { dry: true });
+                    await applyAddNodeEffects(nodeId, inputs, copyOutputsFrom, true);
+                    return;
                 }
+                await runner.update(event.def, { dry: !!inputs });
+                await applyAddNodeEffects(nodeId, inputs, undefined, false);
                 return;
             }
+            if (event.change?.type !== "setInputs" && event.change?.type !== "updateResolvedHandles") {
+                await runner.update(event.def, { dry: event.dry });
+            }
+        };
+        const offWbGraphChangedForUpdate = wb.on("graphChanged", async (event) => {
             try {
-                if (event.change?.type === "addNode") {
-                    const { nodeId, inputs, copyOutputsFrom } = event.change;
-                    if (event.dry) {
-                        await runner.update(event.def, { dry: true });
-                        if (inputs) {
-                            await runner.setInputs(nodeId, inputs, { dry: true });
-                        }
-                        if (copyOutputsFrom) {
-                            await runner.copyOutputs(copyOutputsFrom, nodeId, { dry: true });
-                        }
-                    }
-                    else {
-                        await runner.update(event.def, { dry: !!inputs });
-                        if (inputs) {
-                            await runner.setInputs(nodeId, inputs, { dry: false });
-                        }
-                    }
-                }
-                else if (event.change?.type !== "setInputs" && event.change?.type !== "updateResolvedHandles") {
-                    await runner.update(event.def, { dry: event.dry });
-                }
-                if (event.commit) {
-                    await saveUiRuntimeMetadata(wb, runner);
-                    const history = await runner.commit(event.reason ?? reason).catch((err) => {
-                        console.error("[WorkbenchContext] Error committing after update:", err);
-                        return undefined;
-                    });
-                    if (history) {
-                        wb.setHistory(history);
-                    }
+                if (event.change?.type === "batch") {
+                    await applyBatchGraphChange(event);
+                    await commitGraphChange(event.commit, event.reason ?? "batch", "[WorkbenchContext] Error committing batch:");
+                    return;
                 }
+                const reason = getGraphReason(event);
+                await applySingleGraphChange(event);
+                await commitGraphChange(event.commit, event.reason ?? reason, "[WorkbenchContext] Error committing:");
             }
             catch (err) {
-                console.error("[WorkbenchContext] Error updating graph:", err);
+                console.error("[WorkbenchContext] Error processing graph change:", err);
             }
         });
         const offWbSetValidation = wb.on("validationChanged", (r) => setValidation(r));