otomato-sdk 2.0.64 → 2.0.65

package/dist/src/utils/WorkflowNodePositioner.js

@@ -1,60 +1,158 @@
-// Import necessary functions from d3-dag
-import { graphStratify, sugiyama, layeringLongestPath, decrossTwoLayer, coordCenter } from 'd3-dag';
-export const xSpacing = 400; // used for horizontal spacing between nodes
-export const ySpacing = 120; // used for vertical spacing between layers
-export const ROOT_X = 400; // x-offset for the entire layout
-export const ROOT_Y = 120; // y-offset for the entire layout
+export const xSpacing = 500;
+export const ySpacing = 120;
+export const ROOT_X = 400;
+export const ROOT_Y = 120;
+export function positionWorkflowNodesAvoidOverlap(workflow) {
+    // 1) Lay out nodes using existing logic
+    positionWorkflowNodes(workflow);
+    // 2) Group nodes by 'level' based on vertical position
+    const levels = new Map();
+    workflow.nodes.forEach((node) => {
+        if (node.position) {
+            const level = Math.round(node.position.y / ySpacing);
+            if (!levels.has(level)) {
+                levels.set(level, []);
+            }
+            levels.get(level).push(node);
+        }
+    });
+    // 3) Resolve horizontal overlaps among *all* nodes in each level
+    levels.forEach((levelNodes) => {
+        // Sort the nodes in this level by X
+        levelNodes.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); });
+        // Walk left-to-right, shifting nodes that would collide with the previous one
+        for (let i = 1; i < levelNodes.length; i++) {
+            const prev = levelNodes[i - 1];
+            const current = levelNodes[i];
+            // Compute how close they are
+            const dx = current.position.x - prev.position.x;
+            // If they are too close, shift the current node (and its children) to the right
+            if (dx < xSpacing) {
+                const shift = xSpacing - dx;
+                moveNodeAndChildren(current, shift, workflow.edges);
+            }
+        }
+    });
+    // 4) Re-center parents above their children in a bottom-up pass
+    centerParentXPositions(workflow);
+}
 /**
- * d3-dag based layout for the “top-down” pass.
- *
- * This function transforms the workflow into a DAG format for d3-dag,
- * runs the Sugiyama layout algorithm, and updates the positions of workflow nodes.
+ * Lays out the workflow nodes in a rough top-down manner,
+ * then positions each node relative to its parent.
  */
 export function positionWorkflowNodes(workflow) {
-    const nodeMap = new Map();
-    // 1) Transform workflow into data for stratification
-    const data = workflow.nodes.map((node) => {
-        const id = node.getRef();
-        nodeMap.set(id, node);
-        const parents = workflow.edges
-            .filter(edge => edge.target === node)
-            .map(edge => edge.source.getRef());
-        return { id, parentIds: parents };
+    try {
+        // Step 1: Find the starting nodes
+        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: For all other nodes, position them based on their parent(s)
+        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);
+    if (!parents.length)
+        return; // Edge case: no parents?
+    // Sort children of the first parent by edge labels (true/false) so "true" is left, "false" is right
+    const children = getChildren(parents[0], edges).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;
     });
-    // 2) Build the DAG using graphStratify
-    // Cast to 'any' so we can access .each(...) etc. at runtime
-    const dag = graphStratify()(data);
-    // 3) Create and configure the Sugiyama layout
-    // Note the calls to the operator factories: layeringLongestPath(), decrossTwoLayer(), coordCenter()
-    const layout = sugiyama()
-        .layering(layeringLongestPath())
-        .decross(decrossTwoLayer())
-        .coord(coordCenter())
-        // Instead of .size, we use .nodeSize for spacing between nodes
-        .nodeSize([xSpacing, ySpacing]);
-    // 4) Run layout
-    layout(dag);
-    // 5) Update workflow node positions
-    for (const node of dag.nodes()) {
-        const id = node.data.id;
-        const wfNode = nodeMap.get(id);
-        if (wfNode && typeof node.x === 'number' && typeof node.y === 'number') {
-            wfNode.setPosition(node.x + ROOT_X, node.y + ROOT_Y);
+    const parentX = parents.reduce((sum, p) => { var _a, _b; return sum + ((_b = (_a = p.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((p) => { var _a, _b; return (_b = (_a = p.position) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : ROOT_Y; }));
+    if (children.length <= 1) {
+        node.setPosition(parentX, parentY + ySpacing);
+    }
+    else {
+        // This node’s index among siblings
+        const index = children.indexOf(node);
+        const offset = index - (children.length - 1) / 2;
+        node.setPosition(parentX + offset * xSpacing, parentY + ySpacing);
+    }
+}
+/**
+ * Repositions each parent node so that its X = average of its children’s X.
+ */
+function centerParentXPositions(workflow) {
+    var _a, _b;
+    // Identify the leaf nodes to start a bottom-up pass
+    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) {
+                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;
+                parent.setPosition(avgX, (_b = (_a = parent.position) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : 0);
+            }
+            // Push this parent upward in the queue to continue up the chain
+            if (!queue.includes(parent)) {
+                queue.push(parent);
+            }
         }
     }
-    ;
 }
 /**
- * Helper functions (unchanged).
+ * Recursively shifts a node and all its descendants by `shift` in the x-direction.
+ */
+function moveNodeAndChildren(node, shift, edges) {
+    node.setPosition(node.position.x + shift, node.position.y);
+    edges
+        .filter((edge) => edge.source === node)
+        .forEach((edge) => {
+        moveNodeAndChildren(edge.target, shift, edges);
+    });
+}
+/**
+ * A "leaf" node is one that has no children (it’s never the source of an edge).
  */
+export function identifyLeafNodes(workflow) {
+    const sources = new Set(workflow.edges.map((edge) => edge.source.getRef()));
+    return workflow.nodes.filter((node) => !sources.has(node.getRef()));
+}
+/**
+ * Identify starting nodes (no incoming edges).
+ */
+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
@@ -63,15 +161,7 @@ export function getEndNodePositions(workflow) {
         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,
-            y: ((_d = (_c = node.position) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : 0) + ySpacing * 2,
+            y: ((_d = (_c = node.position) === null || _c === void 0 ? void 0 : _c.y) !== null && _d !== void 0 ? _d : 0) + ySpacing,
         });
     });
 }
-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/src/utils/WorkflowNodePositioner.d.ts

@@ -1,20 +1,25 @@
 import { Workflow } from '../models/Workflow.js';
 import { Node } from '../models/Node.js';
 import { Edge } from '../models/Edge.js';
-export declare const xSpacing = 400;
+export declare const xSpacing = 500;
 export declare const ySpacing = 120;
 export declare const ROOT_X = 400;
 export declare const ROOT_Y = 120;
+export declare function positionWorkflowNodesAvoidOverlap(workflow: Workflow): void;
 /**
- * d3-dag based layout for the “top-down” pass.
- *
- * This function transforms the workflow into a DAG format for d3-dag,
- * runs the Sugiyama layout algorithm, and updates the positions of workflow nodes.
+ * Lays out the workflow nodes in a rough top-down manner,
+ * then positions each node relative to its parent.
  */
 export declare function positionWorkflowNodes(workflow: Workflow): void;
+export declare function positionNode(node: Node, edges: Edge[], xSpacing: number, ySpacing: number, workflow: Workflow): void;
 /**
- * Helper functions (unchanged).
+ * A "leaf" node is one that has no children (it’s never the source of an edge).
  */
+export declare function identifyLeafNodes(workflow: Workflow): Node[];
+/**
+ * Identify starting nodes (no incoming edges).
+ */
+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[];
@@ -22,5 +27,3 @@ export declare function getEndNodePositions(workflow: Workflow): {
     x: number;
     y: number;
 }[];
-export declare function identifyLeafNodes(workflow: Workflow): Node[];
-export declare function identityStartingNodes(workflow: Workflow): Node[];

package/dist/types/test/nodePositioning.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "otomato-sdk",
-  "version": "2.0.64",
+  "version": "2.0.65",
   "description": "An SDK for building and managing automations on Otomato",
   "main": "dist/src/index.js",
   "types": "dist/types/src/index.d.ts",
@@ -44,7 +44,6 @@
   },
   "dependencies": {
     "axios": "^1.7.2",
-    "d3-dag": "^1.1.0",
     "ethers": "^6.13.1",
     "jsonwebtoken": "^9.0.2",
     "mustache": "^4.2.0"