otomato-sdk 2.0.24 → 2.0.26

package/dist/src/constants/version.js

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

package/dist/src/models/Workflow.js

@@ -11,7 +11,7 @@ import { Node } from './Node.js';
 import { Edge } from './Edge.js';
 import { apiServices } from '../services/ApiService.js';
 import { Note } from './Note.js';
-import { positionWorkflowNodesAvoidOverlap } from '../utils/WorkflowNodePositioner.js';
+import { getEndNodePositions, positionWorkflowNodesAvoidOverlap } from '../utils/WorkflowNodePositioner.js';
 export class Workflow {
     constructor(name = '', nodes = [], edges = []) {
         this.id = null;
@@ -257,7 +257,7 @@ export class Workflow {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             try {
-                const response = yield apiServices.patch(`/workflows/${this.id}`, this.toJSON());
+                const response = yield apiServices.put(`/workflows/${this.id}`, this.toJSON());
                 if (response.status === 200) {
                     this.dateModified = response.data.dateModified;
                     // Assign IDs to the nodes based on the response
@@ -369,4 +369,7 @@ export class Workflow {
             return apiServices.getSessionKeyPermissions(this.id);
         });
     }
+    getEndNodePositions() {
+        return getEndNodePositions(this);
+    }
 }

package/dist/src/services/ApiService.js

@@ -40,6 +40,12 @@ class ApiServices {
             return yield axiosInstance.patch(url, data, { headers });
         });
     }
+    put(url, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = this.auth ? { 'Authorization': this.auth } : {};
+            return yield axiosInstance.put(url, data, { headers });
+        });
+    }
     get(url) {
         return __awaiter(this, void 0, void 0, function* () {
             const headers = this.auth ? { 'Authorization': this.auth } : {};

package/dist/src/utils/WorkflowNodePositioner.js

@@ -1,96 +1,4 @@
 // workflowNodePositioner.ts
-/**
- * Positions nodes in a BFS manner, assuming exactly one root node.
- * - The root is placed at (400, 120) unless it already has a position.
- * - If a parent has exactly 1 child, that child is placed directly below the parent
- *   (same x, with an offset in y).
- * - If a parent has multiple children, they are horizontally spread around the parent's X.
- * - Existing positions are not overwritten.
- */
-/*export function autoPositionNodes(workflow: Workflow): void {
-    // 1. Build adjacency & incoming edge count
-    const adjacency = new Map<string, Node[]>();
-    const incomingCount = new Map<string, number>();
-
-    // Constants you can tweak or increase if you see overlap or crossing edges
-    const ROOT_X = 400;
-    const ROOT_Y = 120;
-    const MIN_SPACING_X = 500;  // Horizontal spacing between siblings
-    const MIN_SPACING_Y = 120;  // Vertical spacing from parent to child
-
-    // Initialize adjacency and incoming counts
-    workflow.nodes.forEach((node) => {
-        adjacency.set(node.getRef(), []);
-        incomingCount.set(node.getRef(), 0);
-    });
-
-    // Fill adjacency list (source -> array of targets) and count incoming edges
-    workflow.edges.forEach((edge: Edge) => {
-        const sourceRef = edge.source.getRef();
-        const targetRef = edge.target.getRef();
-        adjacency.get(sourceRef)?.push(edge.target);
-        incomingCount.set(targetRef, (incomingCount.get(targetRef) ?? 0) + 1);
-    });
-
-    // 2. Find all root nodes (no incoming edges). If multiple, just pick the first.
-    const rootNodes = workflow.nodes.filter(
-        (n) => (incomingCount.get(n.getRef()) || 0) === 0
-    );
-    if (rootNodes.length === 0) {
-        // No root found; nothing to do
-        return;
-    }
-
-    // We'll assume the first root is "the" root for this layout
-    const root = rootNodes[0];
-    if (!hasPosition(root)) {
-        root.setPosition(ROOT_X, ROOT_Y);
-    }
-
-    // 3. BFS from that single root
-    const queue = [root];
-    while (queue.length > 0) {
-        const parent = queue.shift()!;
-        const parentRef = parent.getRef();
-
-        // Identify the children
-        const children = adjacency.get(parentRef) || [];
-
-        // Among those children, find any that do NOT already have positions
-        const unpositionedKids = children.filter((c) => !hasPosition(c));
-
-        if (unpositionedKids.length > 0) {
-            const parentX = parent.position?.x ?? 0;
-            const parentY = parent.position?.y ?? 0;
-
-            if (unpositionedKids.length === 1) {
-                // Single child: place it straight below the parent
-                const onlyChild = unpositionedKids[0];
-                onlyChild.setPosition(parentX, parentY + MIN_SPACING_Y);
-            } else {
-                // Multiple children: spread them horizontally around the parent's X
-                const count = unpositionedKids.length;
-                unpositionedKids.forEach((child, i) => {
-                    const offset = i - (count - 1) / 2;
-                    const childX = parentX + offset * MIN_SPACING_X;
-                    const childY = parentY + MIN_SPACING_Y;
-                    child.setPosition(childX, childY);
-                });
-            }
-        }
-
-        // Decrement incoming edges for each child. Once a child hits 0, enqueue it
-        children.forEach((c) => {
-            const cRef = c.getRef();
-            const oldCount = incomingCount.get(cRef) ?? 0;
-            const newCount = oldCount - 1;
-            incomingCount.set(cRef, newCount);
-            if (newCount === 0) {
-                queue.push(c);
-            }
-        });
-    }
-}*/
 export const xSpacing = 600;
 export const ySpacing = 120;
 export const ROOT_X = 400;
@@ -135,7 +43,6 @@ export function positionNode(node, edges, xSpacing, ySpacing, workflow) {
 }
 export function positionWorkflowNodesAvoidOverlap(workflow) {
     const levels = new Map();
-    // Helper: Add node to its level
     function addToLevel(node) {
         const level = Math.round(node.position.y / ySpacing);
         if (!levels.has(level)) {
@@ -143,28 +50,57 @@ export function positionWorkflowNodesAvoidOverlap(workflow) {
         }
         levels.get(level).push(node);
     }
-    // Step 1: Position nodes using the existing logic
+    // 1) Lay out nodes using existing logic
     positionWorkflowNodes(workflow);
-    // Step 2: Populate levels
+    // 2) Fill the `levels` map
     workflow.nodes.forEach((node) => {
         if (node.position) {
             addToLevel(node);
         }
     });
-    // Step 3: Resolve overlaps for each level
+    // 3) Resolve horizontal overlaps level by level
     levels.forEach((nodes, level) => {
-        // Sort nodes by X position
+        // Sort by x so we can detect collisions
         nodes.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); });
-        // Adjust overlapping nodes
+        // Shift nodes that collide
         for (let i = 1; i < nodes.length; i++) {
-            const prevNode = nodes[i - 1];
-            const currentNode = nodes[i];
-            if (currentNode.position.x - prevNode.position.x < xSpacing) {
-                const shift = xSpacing - (currentNode.position.x - prevNode.position.x);
-                moveNodeAndChildren(currentNode, shift, workflow.edges);
+            const prev = nodes[i - 1];
+            const current = nodes[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 new 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
@@ -200,3 +136,14 @@ export function getParents(node, edges) {
 export function getEdges(node, edges) {
     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 => {
+        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,
+        });
+    });
+}

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

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

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

@@ -86,4 +86,8 @@ export declare class Workflow {
         error?: string;
     }>;
     getSessionKeyPermissions(): Promise<SessionKeyPermission>;
+    getEndNodePositions(): {
+        x: number;
+        y: number;
+    }[];
 }

package/dist/types/src/services/ApiService.d.ts

@@ -4,6 +4,7 @@ declare class ApiServices {
     setUrl(baseUrl: string): void;
     post(url: string, data: any): Promise<import("axios").AxiosResponse<any, any>>;
     patch(url: string, data: any): Promise<import("axios").AxiosResponse<any, any>>;
+    put(url: string, data: any): Promise<import("axios").AxiosResponse<any, any>>;
     get(url: string): Promise<any>;
     delete(url: string): Promise<import("axios").AxiosResponse<any, any>>;
     generateLoginPayload(address: string, chainId: number, referralCode: string): Promise<any>;

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

@@ -1,14 +1,6 @@
 import { Workflow } from '../models/Workflow.js';
 import { Node } from '../models/Node.js';
 import { Edge } from '../models/Edge.js';
-/**
- * Positions nodes in a BFS manner, assuming exactly one root node.
- * - The root is placed at (400, 120) unless it already has a position.
- * - If a parent has exactly 1 child, that child is placed directly below the parent
- *   (same x, with an offset in y).
- * - If a parent has multiple children, they are horizontally spread around the parent's X.
- * - Existing positions are not overwritten.
- */
 export declare const xSpacing = 600;
 export declare const ySpacing = 120;
 export declare const ROOT_X = 400;
@@ -28,3 +20,7 @@ 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[];
+export declare function getEndNodePositions(workflow: Workflow): {
+    x: number;
+    y: number;
+}[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "otomato-sdk",
-  "version": "2.0.24",
+  "version": "2.0.26",
   "description": "An SDK for building and managing automations on Otomato",
   "main": "dist/src/index.js",
   "types": "dist/types/src/index.d.ts",