otomato-sdk 2.0.35 → 2.0.37

package/dist/src/constants/version.js

@@ -1,4 +1,4 @@
-export const SDK_VERSION = '2.0.35';
+export const SDK_VERSION = '2.0.36';
 export function compareVersions(v1, v2) {
     // Split the version strings into parts
     const v1Parts = v1.split('.').map(Number);

package/dist/src/models/Workflow.js

@@ -10,8 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Node } from './Node.js';
 import { Edge } from './Edge.js';
 import { apiServices } from '../services/ApiService.js';
+import { Action } from './Action.js';
 import { Note } from './Note.js';
-import { getEndNodePositions, positionWorkflowNodesAvoidOverlap } from '../utils/WorkflowNodePositioner.js';
+import { getEndNodePositions, positionWorkflowNodes } from '../utils/WorkflowNodePositioner.js';
+import { ACTIONS } from '../constants/Blocks.js';
 export class Workflow {
     constructor(name = '', nodes = [], edges = []) {
         this.id = null;
@@ -23,18 +25,18 @@ export class Workflow {
         this.nodes = nodes;
         this.edges = edges;
         this.state = 'inactive';
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     setName(name) {
         this.name = name;
     }
     addNode(node) {
         this.nodes.push(node);
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     addNodes(nodes) {
         this.nodes.push(...nodes);
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     deleteNode(nodeToDelete) {
         // Remove the node from the nodes array
@@ -57,68 +59,152 @@ export class Workflow {
         this.edges = this.edges.filter(edge => edge.source !== nodeToDelete && edge.target !== nodeToDelete);
         this.edges.push(...newEdges);
         // Recalculate positions
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     /**
-     * Inserts a new node into the workflow:
-     * - If both nodeBefore and nodeAfter are provided, we expect an existing edge
-     *   from nodeBefore -> nodeAfter, which gets replaced by two edges:
-     *   nodeBefore -> nodeToInsert and nodeToInsert -> nodeAfter.
+     * Inserts a new node into the workflow, potentially splitting an existing edge.
      *
-     * - If nodeAfter is NOT provided, we create a single edge from nodeBefore
-     *   to nodeToInsert. The user can optionally provide `edgeLabel` and `edgeValue`
-     *   in that scenario only.
+     * - If `nodeAfter` is specified, we expect an edge nodeBefore->nodeAfter to exist.
+     *   That edge is removed, and replaced by two new edges:
+     *      nodeBefore->nodeToInsert (with `edgeLabelBefore`, `edgeValueBefore`)
+     *      nodeToInsert->nodeAfter  (with `edgeLabelAfter`, `edgeValueAfter`)
      *
-     * @param nodeToInsert  The node you want to insert
-     * @param nodeBefore    The existing node in the workflow that precedes `nodeToInsert`
-     * @param nodeAfter     (Optional) The existing node that should follow `nodeToInsert`
-     * @param edgeLabel     (Optional) Label for the edge, only allowed if `nodeAfter` is not provided
-     * @param edgeValue     (Optional) Value for the edge, only allowed if `nodeAfter` is not provided
+     * - If `nodeAfter` is not specified, we create only one edge:
+     *      nodeBefore->nodeToInsert (with `edgeLabelBefore`, `edgeValueBefore`)
+     *
+     * @param nodeToInsert      The node to insert
+     * @param nodeBefore        The existing node that precedes `nodeToInsert`
+     * @param nodeAfter         (Optional) The existing node that should follow `nodeToInsert`
+     * @param edgeLabelBefore   (Optional) Label for the edge nodeBefore->nodeToInsert
+     * @param edgeValueBefore   (Optional) Value for the edge nodeBefore->nodeToInsert
+     * @param edgeLabelAfter    (Optional) Label for the edge nodeToInsert->nodeAfter
+     * @param edgeValueAfter    (Optional) Value for the edge nodeToInsert->nodeAfter
      */
-    insertNode(nodeToInsert, nodeBefore, nodeAfter, edgeLabel = null, edgeValue = null) {
+    insertNode(nodeToInsert, nodeBefore, nodeAfter, edgeLabelBefore = null, edgeValueBefore = null, edgeLabelAfter = null, edgeValueAfter = null) {
         // Ensure nodeBefore exists in the workflow
         if (!this.nodes.includes(nodeBefore)) {
             throw new Error('The nodeBefore must exist in the workflow.');
         }
-        // If nodeAfter is provided, disallow edgeLabel/edgeValue
-        if (nodeAfter && (edgeLabel !== null || edgeValue !== null)) {
-            throw new Error('Cannot provide edgeLabel/edgeValue if nodeAfter is specified.');
-        }
-        // If nodeAfter is not provided, insert the new node as a child of nodeBefore
+        // CASE A: If no nodeAfter => we create a single edge from nodeBefore to nodeToInsert
         if (!nodeAfter) {
             // Add the new node to the workflow
             this.addNode(nodeToInsert);
-            // Add a new edge between nodeBefore and nodeToInsert (with optional label/value)
+            // Create the edge nodeBefore->nodeToInsert
             const newEdge = new Edge({
                 source: nodeBefore,
                 target: nodeToInsert,
-                label: edgeLabel !== null && edgeLabel !== void 0 ? edgeLabel : undefined,
-                value: edgeValue !== null && edgeValue !== void 0 ? edgeValue : undefined
+                label: edgeLabelBefore !== null && edgeLabelBefore !== void 0 ? edgeLabelBefore : undefined,
+                value: edgeValueBefore !== null && edgeValueBefore !== void 0 ? edgeValueBefore : undefined
             });
             this.addEdge(newEdge);
             // Recalculate positions
-            positionWorkflowNodesAvoidOverlap(this);
+            positionWorkflowNodes(this);
             return;
         }
-        // If nodeAfter is provided, ensure both nodes exist in the workflow
+        // CASE B: nodeAfter is provided => we expect an edge nodeBefore->nodeAfter to exist
         if (!this.nodes.includes(nodeAfter)) {
             throw new Error('The nodeAfter must exist in the workflow.');
         }
-        // Check if an edge exists between nodeBefore and nodeAfter
-        const edgeBetween = this.edges.find(edge => edge.source === nodeBefore && edge.target === nodeAfter);
+        // Find the existing edge nodeBefore->nodeAfter
+        const edgeBetween = this.edges.find((edge) => edge.source === nodeBefore && edge.target === nodeAfter);
         if (!edgeBetween) {
             throw new Error('No edge exists between nodeBefore and nodeAfter.');
         }
         // Add the new node to the workflow
         this.addNode(nodeToInsert);
         // Remove the existing edge between nodeBefore and nodeAfter
-        this.edges = this.edges.filter(edge => edge !== edgeBetween);
-        // Add new edges
-        const newEdge1 = new Edge({ source: nodeBefore, target: nodeToInsert });
-        const newEdge2 = new Edge({ source: nodeToInsert, target: nodeAfter });
+        this.edges = this.edges.filter((edge) => edge !== edgeBetween);
+        // Create the two new edges:
+        // 1) nodeBefore->nodeToInsert
+        const newEdge1 = new Edge({
+            source: nodeBefore,
+            target: nodeToInsert,
+            label: edgeLabelBefore !== null && edgeLabelBefore !== void 0 ? edgeLabelBefore : undefined,
+            value: edgeValueBefore !== null && edgeValueBefore !== void 0 ? edgeValueBefore : undefined
+        });
+        // 2) nodeToInsert->nodeAfter
+        const newEdge2 = new Edge({
+            source: nodeToInsert,
+            target: nodeAfter,
+            label: edgeLabelAfter !== null && edgeLabelAfter !== void 0 ? edgeLabelAfter : undefined,
+            value: edgeValueAfter !== null && edgeValueAfter !== void 0 ? edgeValueAfter : undefined
+        });
         this.addEdges([newEdge1, newEdge2]);
         // Recalculate positions
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
+    }
+    insertCondition(nodeToInsert, nodeBefore, nodeAfter, addElseCase, addEmptyNodes = true) {
+        if (nodeAfter) {
+            this.insertNode(nodeToInsert, nodeBefore, nodeAfter, null, null, 'true', 'true');
+        }
+        // Otherwise, create both "true" and "false" paths.
+        // 1) "true" path: nodeBefore -> nodeToInsert -> nodeAfter
+        if (!nodeAfter) {
+            this.insertNode(nodeToInsert, nodeBefore, undefined);
+            if (addEmptyNodes) {
+                const emptyNode1 = new Action(ACTIONS.CORE.EMPTYBLOCK.EMPTYBLOCK);
+                this.insertNode(emptyNode1, nodeToInsert, undefined, 'true', 'true');
+            }
+        }
+        // 2) "false" path: nodeBefore -> nodeToInsert, 
+        //    but here we pass no nodeAfter (so nodeAfter=null),
+        //    and label/value are "false".
+        if (addElseCase && addEmptyNodes) {
+            const emptyNode2 = new Action(ACTIONS.CORE.EMPTYBLOCK.EMPTYBLOCK);
+            this.insertNode(emptyNode2, nodeToInsert, undefined, 'false', 'false');
+        }
+    }
+    /**
+     * Inserts a "split" node, creating `numberOfBranches` parallel branches.
+     *
+     * If `nodeAfter` is given, we call `insertNode(...)` to splice the split node
+     * between `nodeBefore` and `nodeAfter`. That yields two edges:
+     *    nodeBefore->nodeToInsert and nodeToInsert->nodeAfter
+     * The first branch is effectively "nodeAfter."
+     * Then we add additional empty blocks for the remaining branches.
+     *
+     * If `nodeAfter` is NOT given, we just insertNode(split, nodeBefore),
+     * which yields an edge: nodeBefore->split.
+     * Then we create `numberOfBranches` empty blocks off the split node.
+     *
+     * @param nodeToInsert     The split node to insert (e.g. type="Split").
+     * @param nodeBefore       The node after which the split is inserted.
+     * @param nodeAfter        (Optional) If we’re splitting in the middle of a flow, the node that was originally after `nodeBefore`.
+     * @param numberOfBranches The total number of branches to create from `nodeToInsert`.
+     */
+    insertSplit(nodeToInsert, nodeBefore, nodeAfter, numberOfBranches) {
+        // Basic validation
+        if (!this.nodes.includes(nodeBefore)) {
+            throw new Error('nodeBefore must exist in the workflow.');
+        }
+        if (numberOfBranches < 2) {
+            throw new Error('numberOfBranches must be at least 2.');
+        }
+        // Step 1: Insert the "split" node via insertNode
+        // - If nodeAfter is defined, it removes nodeBefore->nodeAfter
+        //   and creates nodeBefore->nodeToInsert & nodeToInsert->nodeAfter.
+        // - If nodeAfter is undefined, we simply get nodeBefore->nodeToInsert.
+        this.insertNode(nodeToInsert, nodeBefore, nodeAfter);
+        // Step 2: Create the parallel branches
+        if (nodeAfter) {
+            // The first branch is already nodeToInsert->nodeAfter
+            // So we only need to create the remaining (numberOfBranches - 1) branches
+            const remaining = numberOfBranches - 1;
+            for (let i = 0; i < remaining; i++) {
+                const emptyBlock = new Action(ACTIONS.CORE.EMPTYBLOCK.EMPTYBLOCK);
+                // Insert the emptyBlock after nodeToInsert
+                // => this creates a new edge nodeToInsert->emptyBlock
+                this.insertNode(emptyBlock, nodeToInsert);
+            }
+        }
+        else {
+            // nodeAfter is undefined => all branches must be created
+            // Each branch is nodeToInsert->(new empty block)
+            for (let i = 0; i < numberOfBranches; i++) {
+                const emptyBlock = new Action(ACTIONS.CORE.EMPTYBLOCK.EMPTYBLOCK);
+                this.insertNode(emptyBlock, nodeToInsert);
+            }
+        }
     }
     swapNode(oldNode, newNode) {
         // Find the index of the node to replace
@@ -138,11 +224,11 @@ export class Workflow {
             }
         });
         // Recalculate positions
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     addEdge(edge) {
         this.edges.push(edge);
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     updateEdge(edgeId, newEdge) {
         const edgeToUpdate = this.edges.find(e => e.id === edgeId);
@@ -153,11 +239,11 @@ export class Workflow {
         else {
             throw new Error(`Edge with id ${edgeId} not found`);
         }
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     addEdges(edges) {
         this.edges.push(...edges);
-        positionWorkflowNodesAvoidOverlap(this);
+        positionWorkflowNodes(this);
     }
     getState() {
         return this.state;
@@ -286,7 +372,7 @@ export class Workflow {
                 this.nodes = yield Promise.all(response.nodes.map((nodeData) => __awaiter(this, void 0, void 0, function* () { return yield Node.fromJSON(nodeData); })));
                 this.edges = response.edges.map((edgeData) => Edge.fromJSON(edgeData, this.nodes));
                 this.notes = response.notes.map((noteData) => Note.fromJSON(noteData));
-                positionWorkflowNodesAvoidOverlap(this);
+                positionWorkflowNodes(this);
                 return this;
             }
             catch (error) {

package/dist/src/utils/WorkflowNodePositioner.js

@@ -1,176 +1,85 @@
-// workflowNodePositioner.ts
-export const xSpacing = 500;
-export const ySpacing = 120;
-export const ROOT_X = 400;
+// Note: Using 'dagre' for layered DAG layout
+import dagre from 'dagre';
+// or: import * as dagre from 'dagre';
+export const xSpacing = 700; // used by dagre as node separation
+export const ySpacing = 75;
+export const ROOT_X = 400; // we’ll keep references, but Dagre decides actual positions
 export const ROOT_Y = 120;
+/**
+ * Dagre-based layout for the “top-down” pass. We’re effectively ignoring the old
+ * manual code. Instead, we:
+ *  1) Build a dagre graph
+ *  2) Add all nodes & edges
+ *  3) dagre.layout(g)
+ *  4) Extract positions & write them back to workflow.nodes
+ */
 export function positionWorkflowNodes(workflow) {
-    try {
-        // Step 1: Find the starting nodes using identityStartingNodes function
-        const startingNodes = identityStartingNodes(workflow);
-        // Step 2: Place the starting nodes
-        let xPosition = ROOT_X;
-        startingNodes.forEach((startNode) => {
-            startNode.setPosition(xPosition, ROOT_Y);
-            xPosition += xSpacing;
-        });
-        // Step 3: Place all other nodes relative to their parents
-        const nodesToPosition = workflow.nodes.filter((node) => !startingNodes.includes(node));
-        nodesToPosition.forEach((node) => positionNode(node, workflow.edges, xSpacing, ySpacing, workflow));
-    }
-    catch (e) {
-        console.error(e);
-    }
-}
-export function positionNode(node, edges, xSpacing, ySpacing, workflow) {
-    const parents = getParents(node, edges);
-    // todo: what if we have multiple parents?
-    const children = getChildren(parents[0], edges);
-    const sortedChildren = children.sort((a, b) => {
-        var _a, _b;
-        const edgeA = edges.find(edge => edge.source === parents[0] && edge.target === a);
-        const edgeB = edges.find(edge => edge.source === parents[0] && edge.target === b);
-        const labelA = (_a = edgeA === null || edgeA === void 0 ? void 0 : edgeA.label) !== null && _a !== void 0 ? _a : "";
-        const labelB = (_b = edgeB === null || edgeB === void 0 ? void 0 : edgeB.label) !== null && _b !== void 0 ? _b : "";
-        if (labelA === "true" && labelB !== "true")
-            return -1;
-        if (labelB === "true" && labelA !== "true")
-            return 1;
-        if (labelA === "false" && labelB !== "false")
-            return 1;
-        if (labelB === "false" && labelA !== "false")
-            return -1;
-        return 0;
+    // 1) Create a new directed graph
+    // doc: https://github.com/dagrejs/dagre
+    const g = new dagre.graphlib.Graph({ multigraph: false, compound: false });
+    g.setGraph({
+        // Some layout options:
+        rankdir: 'TB', // "top-bottom" layering
+        nodesep: xSpacing * 0.5, // horizontal spacing 
+        ranksep: ySpacing, // vertical spacing between levels
+        marginx: 20, // how much margin to leave around the left/right
+        marginy: 20, // how much margin to leave around the top/bottom
     });
-    const childrenCountOfParent = sortedChildren.length;
-    const parentX = parents.reduce((sum, parent) => { var _a, _b; return sum + ((_b = (_a = parent.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : ROOT_X); }, 0) / parents.length;
-    const parentY = Math.max(...parents.map(parent => { var _a, _b; return (_b = (_a = parent.position) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : ROOT_Y; }));
-    if (childrenCountOfParent === 1) {
-        node.setPosition(parentX, parentY + ySpacing);
-    }
-    else {
-        const index = sortedChildren.indexOf(node); // Get the position of this node among its siblings
-        const totalChildren = sortedChildren.length;
-        // Compute the x position for this node
-        const offset = index - (totalChildren - 1) / 2; // Center the children around the parent
-        node.setPosition(parentX + offset * xSpacing, parentY + ySpacing);
-    }
-}
-export function positionWorkflowNodesAvoidOverlap(workflow) {
-    const levels = new Map();
-    function addToLevel(node) {
-        const level = Math.round(node.position.y / ySpacing);
-        if (!levels.has(level)) {
-            levels.set(level, []);
-        }
-        levels.get(level).push(node);
-    }
-    // 1) Lay out nodes using existing logic
-    positionWorkflowNodes(workflow);
-    // 2) Fill the `levels` map
+    g.setDefaultEdgeLabel(() => ({}));
+    // 2) Add nodes to the graph
+    // Dagre requires each node have an id and some approximate width/height
     workflow.nodes.forEach((node) => {
-        if (node.position) {
-            addToLevel(node);
-        }
-    });
-    // 3) Resolve horizontal overlaps and enforce parent grouping
-    levels.forEach((nodes, level) => {
-        // Group nodes by their parent
-        const parentGroups = new Map();
-        nodes.forEach((node) => {
-            const parents = getParents(node, workflow.edges);
-            if (parents.length > 0) {
-                const parent = parents[0]; // Assuming single parent for simplicity
-                if (!parentGroups.has(parent)) {
-                    parentGroups.set(parent, []);
-                }
-                parentGroups.get(parent).push(node);
-            }
-        });
-        // Flatten the groups back into a sorted array
-        const groupedNodes = [];
-        parentGroups.forEach((group) => {
-            groupedNodes.push(...group);
+        const nodeId = node.getRef();
+        // For a typical text-based node, approximate width & height
+        g.setNode(nodeId, {
+            label: nodeId,
+            width: 100,
+            height: 50
         });
-        // Sort nodes by x within each group to detect overlaps
-        groupedNodes.sort((a, b) => { var _a, _b; return ((_a = a.position.x) !== null && _a !== void 0 ? _a : 0) - ((_b = b.position.x) !== null && _b !== void 0 ? _b : 0); });
-        // Shift nodes within groups to resolve overlaps
-        for (let i = 1; i < groupedNodes.length; i++) {
-            const prev = groupedNodes[i - 1];
-            const current = groupedNodes[i];
-            if (current.position.x - prev.position.x < xSpacing) {
-                const shift = xSpacing - (current.position.x - prev.position.x);
-                moveNodeAndChildren(current, shift, workflow.edges);
-            }
-        }
     });
-    // 4) **Center each parent over its children** (the existing step)
-    centerParentXPositions(workflow);
-}
-/**
- * Repositions each parent node so that its X is the average of the children’s X.
- * We do a simple bottom-up pass: start with all leaves, then move upward to parents.
- */
-function centerParentXPositions(workflow) {
-    var _a, _b;
-    // Identify the “leaf” nodes
-    const queue = identifyLeafNodes(workflow);
-    while (queue.length > 0) {
-        const child = queue.shift();
-        const parents = getParents(child, workflow.edges);
-        for (const parent of parents) {
-            const children = getChildren(parent, workflow.edges);
-            if (children.length) {
-                // Average x of all children
-                const sumX = children.reduce((acc, c) => { var _a, _b; return acc + ((_b = (_a = c.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 0); }, 0);
-                const avgX = sumX / children.length;
-                // Move parent to that average, keep same y
-                parent.setPosition(avgX, (_b = (_a = parent.position) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : 0);
-            }
-            // Add this parent to the queue so we can recurse upward
-            if (!queue.includes(parent)) {
-                queue.push(parent);
-            }
-        }
-    }
-}
-function moveNodeAndChildren(node, shift, edges) {
-    // Move the node
-    node.setPosition(node.position.x + shift, node.position.y);
-    // Propagate to children
-    edges
-        .filter((edge) => edge.source === node)
-        .forEach((edge) => {
-        moveNodeAndChildren(edge.target, shift, edges);
+    // 3) Add edges
+    // Dagre identifies edges by (sourceId, targetId). We don’t need labels for layout,
+    // but we can store them if we want. If you rely on “true/false” ordering, we can tweak
+    // e.g. use edge label as a tie-break. (See advanced docs.)
+    workflow.edges.forEach((edge) => {
+        var _a;
+        const fromId = edge.source.getRef();
+        const toId = edge.target.getRef();
+        g.setEdge(fromId, toId, { label: (_a = edge.label) !== null && _a !== void 0 ? _a : '' });
+    });
+    // 4) Run Dagre layout
+    dagre.layout(g);
+    // 5) Extract positions from Dagre graph and store them back to your Node objects
+    g.nodes().forEach((nodeId) => {
+        const dagreNode = g.node(nodeId); // { x, y, width, height, ... }
+        const nodeObj = workflow.nodes.find((n) => n.getRef() === nodeId);
+        if (!nodeObj || !dagreNode)
+            return;
+        // Store x,y in your node’s position
+        nodeObj.setPosition(dagreNode.x, dagreNode.y);
     });
-}
-export function identifyLeafNodes(workflow) {
-    const nonLeafNodes = new Set(workflow.edges.map(edge => edge.source.getRef()));
-    return workflow.nodes.filter(node => !nonLeafNodes.has(node.getRef()));
 }
 /**
- * Identifies starting nodes (nodes with no incoming edges).
- * A starting node is defined as one that is not a target of any edge.
- *
- * @param workflow The workflow to analyze.
- * @returns An array of nodes that have no incoming edges.
+ * We keep these helper functions the same for external usage (if your code or tests need them),
+ * but we’re not actively using them in the new Dagre-based layout.
  */
-export function identityStartingNodes(workflow) {
-    const childRefs = new Set(workflow.edges.map((edge) => edge.target.getRef()));
-    return workflow.nodes.filter((node) => !childRefs.has(node.getRef()));
-}
 export function getChildren(node, edges) {
-    return edges.filter(edge => edge.source === node).map(edge => edge.target);
+    return edges
+        .filter((edge) => edge.source === node)
+        .map((edge) => edge.target);
 }
 export function getParents(node, edges) {
-    return edges.filter(edge => edge.target === node).map(edge => edge.source);
+    return edges
+        .filter((edge) => edge.target === node)
+        .map((edge) => edge.source);
 }
 export function getEdges(node, edges) {
-    return edges.filter(edge => edge.source === node || edge.target === node);
+    return edges.filter((edge) => edge.source === node || edge.target === node);
 }
 export function getEndNodePositions(workflow) {
     return workflow.nodes
-        .filter(node => getChildren(node, workflow.edges).length === 0) // node with no children
-        .map(node => {
+        .filter((node) => getChildren(node, workflow.edges).length === 0)
+        .map((node) => {
         var _a, _b, _c, _d;
         return ({
             x: (_b = (_a = node.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 0,
@@ -178,3 +87,16 @@ export function getEndNodePositions(workflow) {
         });
     });
 }
+/**
+ * In Dagre, we no longer do an explicit “identify leaf nodes” or “center parents by average,”
+ * because the layout library handles that.
+ * But here’s your old method if something else depends on it.
+ */
+export function identifyLeafNodes(workflow) {
+    const sources = new Set(workflow.edges.map((edge) => edge.source.getRef()));
+    return workflow.nodes.filter((node) => !sources.has(node.getRef()));
+}
+export function identityStartingNodes(workflow) {
+    const childRefs = new Set(workflow.edges.map((edge) => edge.target.getRef()));
+    return workflow.nodes.filter((node) => !childRefs.has(node.getRef()));
+}

package/dist/types/examples/UseCases/LendingAggregator/lending-aggregator-2-protocols.d.ts

@@ -1,4 +1,4 @@
 /*************************************
- * 4. Main Workflow Builder
+ * 6. Main Workflow Builder
  *************************************/
 export declare function aggregatorWorkflow(): Promise<void>;

package/dist/types/examples/UseCases/LendingAggregator/lending-aggregator-3-protocols.d.ts

@@ -0,0 +1,4 @@
+/*************************************
+ * 5. Main Workflow Builder (No manual edges or pushes)
+ *************************************/
+export declare function lendingAggregatorWorkflow(): Promise<void>;

package/dist/types/examples/UseCases/LendingAggregator/lending-aggregator-v3.d.ts

@@ -0,0 +1,4 @@
+/*************************************
+ * 6. Main Workflow Builder
+ *************************************/
+export declare function aggregatorWorkflow(): Promise<void>;

package/dist/types/examples/test.d.ts

@@ -1 +1,7 @@
-export {};
+/**
+ * Example workflow:
+ *   Trigger -> Delay -> Condition
+ *      ├─(true)─> Split(3)
+ *      └─(false)-> Delay
+ */
+export declare function conditionSplitDemo(): Promise<void>;

package/dist/types/src/constants/version.d.ts

@@ -1,2 +1,2 @@
-export declare const SDK_VERSION = "2.0.35";
+export declare const SDK_VERSION = "2.0.36";
 export declare function compareVersions(v1: string, v2: string): number;

package/dist/types/src/models/Workflow.d.ts

@@ -19,22 +19,45 @@ export declare class Workflow {
     addNodes(nodes: Node[]): void;
     deleteNode(nodeToDelete: Node): void;
     /**
-     * Inserts a new node into the workflow:
-     * - If both nodeBefore and nodeAfter are provided, we expect an existing edge
-     *   from nodeBefore -> nodeAfter, which gets replaced by two edges:
-     *   nodeBefore -> nodeToInsert and nodeToInsert -> nodeAfter.
+     * Inserts a new node into the workflow, potentially splitting an existing edge.
      *
-     * - If nodeAfter is NOT provided, we create a single edge from nodeBefore
-     *   to nodeToInsert. The user can optionally provide `edgeLabel` and `edgeValue`
-     *   in that scenario only.
+     * - If `nodeAfter` is specified, we expect an edge nodeBefore->nodeAfter to exist.
+     *   That edge is removed, and replaced by two new edges:
+     *      nodeBefore->nodeToInsert (with `edgeLabelBefore`, `edgeValueBefore`)
+     *      nodeToInsert->nodeAfter  (with `edgeLabelAfter`, `edgeValueAfter`)
      *
-     * @param nodeToInsert  The node you want to insert
-     * @param nodeBefore    The existing node in the workflow that precedes `nodeToInsert`
-     * @param nodeAfter     (Optional) The existing node that should follow `nodeToInsert`
-     * @param edgeLabel     (Optional) Label for the edge, only allowed if `nodeAfter` is not provided
-     * @param edgeValue     (Optional) Value for the edge, only allowed if `nodeAfter` is not provided
+     * - If `nodeAfter` is not specified, we create only one edge:
+     *      nodeBefore->nodeToInsert (with `edgeLabelBefore`, `edgeValueBefore`)
+     *
+     * @param nodeToInsert      The node to insert
+     * @param nodeBefore        The existing node that precedes `nodeToInsert`
+     * @param nodeAfter         (Optional) The existing node that should follow `nodeToInsert`
+     * @param edgeLabelBefore   (Optional) Label for the edge nodeBefore->nodeToInsert
+     * @param edgeValueBefore   (Optional) Value for the edge nodeBefore->nodeToInsert
+     * @param edgeLabelAfter    (Optional) Label for the edge nodeToInsert->nodeAfter
+     * @param edgeValueAfter    (Optional) Value for the edge nodeToInsert->nodeAfter
+     */
+    insertNode(nodeToInsert: Node, nodeBefore: Node, nodeAfter?: Node, edgeLabelBefore?: string | null, edgeValueBefore?: any | null, edgeLabelAfter?: string | null, edgeValueAfter?: any | null): void;
+    insertCondition(nodeToInsert: Node, nodeBefore: Node, nodeAfter?: Node, addElseCase?: boolean, addEmptyNodes?: boolean): void;
+    /**
+     * Inserts a "split" node, creating `numberOfBranches` parallel branches.
+     *
+     * If `nodeAfter` is given, we call `insertNode(...)` to splice the split node
+     * between `nodeBefore` and `nodeAfter`. That yields two edges:
+     *    nodeBefore->nodeToInsert and nodeToInsert->nodeAfter
+     * The first branch is effectively "nodeAfter."
+     * Then we add additional empty blocks for the remaining branches.
+     *
+     * If `nodeAfter` is NOT given, we just insertNode(split, nodeBefore),
+     * which yields an edge: nodeBefore->split.
+     * Then we create `numberOfBranches` empty blocks off the split node.
+     *
+     * @param nodeToInsert     The split node to insert (e.g. type="Split").
+     * @param nodeBefore       The node after which the split is inserted.
+     * @param nodeAfter        (Optional) If we’re splitting in the middle of a flow, the node that was originally after `nodeBefore`.
+     * @param numberOfBranches The total number of branches to create from `nodeToInsert`.
      */
-    insertNode(nodeToInsert: Node, nodeBefore: Node, nodeAfter?: Node, edgeLabel?: string | null, edgeValue?: any | null): void;
+    insertSplit(nodeToInsert: Node, nodeBefore: Node, nodeAfter: Node | undefined, numberOfBranches: number): void;
     swapNode(oldNode: Node, newNode: Node): void;
     addEdge(edge: Edge): void;
     updateEdge(edgeId: string, newEdge: Edge): void;

package/dist/types/src/utils/WorkflowNodePositioner.d.ts

@@ -1,22 +1,23 @@
 import { Workflow } from '../models/Workflow.js';
 import { Node } from '../models/Node.js';
 import { Edge } from '../models/Edge.js';
-export declare const xSpacing = 500;
-export declare const ySpacing = 120;
+export declare const xSpacing = 700;
+export declare const ySpacing = 75;
 export declare const ROOT_X = 400;
 export declare const ROOT_Y = 120;
+/**
+ * Dagre-based layout for the “top-down” pass. We’re effectively ignoring the old
+ * manual code. Instead, we:
+ *  1) Build a dagre graph
+ *  2) Add all nodes & edges
+ *  3) dagre.layout(g)
+ *  4) Extract positions & write them back to workflow.nodes
+ */
 export declare function positionWorkflowNodes(workflow: Workflow): void;
-export declare function positionNode(node: Node, edges: Edge[], xSpacing: number, ySpacing: number, workflow: Workflow): void;
-export declare function positionWorkflowNodesAvoidOverlap(workflow: Workflow): void;
-export declare function identifyLeafNodes(workflow: Workflow): Node[];
 /**
- * Identifies starting nodes (nodes with no incoming edges).
- * A starting node is defined as one that is not a target of any edge.
- *
- * @param workflow The workflow to analyze.
- * @returns An array of nodes that have no incoming edges.
+ * We keep these helper functions the same for external usage (if your code or tests need them),
+ * but we’re not actively using them in the new Dagre-based layout.
  */
-export declare function identityStartingNodes(workflow: Workflow): Node[];
 export declare function getChildren(node: Node, edges: Edge[]): Node[];
 export declare function getParents(node: Node, edges: Edge[]): Node[];
 export declare function getEdges(node: Node, edges: Edge[]): Edge[];
@@ -24,3 +25,10 @@ export declare function getEndNodePositions(workflow: Workflow): {
     x: number;
     y: number;
 }[];
+/**
+ * In Dagre, we no longer do an explicit “identify leaf nodes” or “center parents by average,”
+ * because the layout library handles that.
+ * But here’s your old method if something else depends on it.
+ */
+export declare function identifyLeafNodes(workflow: Workflow): Node[];
+export declare function identityStartingNodes(workflow: Workflow): Node[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "otomato-sdk",
-  "version": "2.0.35",
+  "version": "2.0.37",
   "description": "An SDK for building and managing automations on Otomato",
   "main": "dist/src/index.js",
   "types": "dist/types/src/index.d.ts",
@@ -31,6 +31,7 @@
   "devDependencies": {
     "@types/axios": "^0.14.0",
     "@types/chai": "^4.3.16",
+    "@types/dagre": "^0.7.52",
     "@types/jsonwebtoken": "^9.0.6",
     "@types/mocha": "^10.0.6",
     "@types/mustache": "^4.2.5",
@@ -43,6 +44,7 @@
   },
   "dependencies": {
     "axios": "^1.7.2",
+    "dagre": "^0.8.5",
     "ethers": "^6.13.1",
     "jsonwebtoken": "^9.0.2",
     "mustache": "^4.2.0"