otomato-sdk 2.0.66 → 2.0.67

package/dist/src/constants/version.js

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

package/dist/src/utils/WorkflowNodePositioner.js

@@ -1,48 +1,11 @@
+// workflowNodePositioner.ts
 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);
-}
-/**
- * Lays out the workflow nodes in a rough top-down manner,
- * then positions each node relative to its parent.
- */
 export function positionWorkflowNodes(workflow) {
     try {
-        // Step 1: Find the starting nodes
+        // Step 1: Find the starting nodes using identityStartingNodes function
         const startingNodes = identityStartingNodes(workflow);
         // Step 2: Place the starting nodes
         let xPosition = ROOT_X;
@@ -50,7 +13,7 @@ export function positionWorkflowNodes(workflow) {
             startNode.setPosition(xPosition, ROOT_Y);
             xPosition += xSpacing;
         });
-        // Step 3: For all other nodes, position them based on their parent(s)
+        // 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));
     }
@@ -60,13 +23,12 @@ export function positionWorkflowNodes(workflow) {
 }
 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) => {
+    // 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 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")
@@ -79,25 +41,78 @@ export function positionNode(node, edges, xSpacing, ySpacing, workflow) {
             return -1;
         return 0;
     });
-    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) {
+    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 {
-        // This node’s index among siblings
-        const index = children.indexOf(node);
-        const offset = index - (children.length - 1) / 2;
+        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
+    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);
+        });
+        // 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 = average of its children’s X.
+ * 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 to start a bottom-up pass
+    // Identify the “leaf” nodes
     const queue = identifyLeafNodes(workflow);
     while (queue.length > 0) {
         const child = queue.shift();
@@ -105,59 +120,57 @@ function centerParentXPositions(workflow) {
         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);
             }
-            // Push this parent upward in the queue to continue up the chain
+            // Add this parent to the queue so we can recurse upward
             if (!queue.includes(parent)) {
                 queue.push(parent);
             }
         }
     }
 }
-/**
- * Recursively shifts a node and all its descendants by `shift` in the x-direction.
- */
 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);
     });
 }
-/**
- * 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()));
+    const nonLeafNodes = new Set(workflow.edges.map(edge => edge.source.getRef()));
+    return workflow.nodes.filter(node => !nonLeafNodes.has(node.getRef()));
 }
 /**
- * Identify starting nodes (no incoming edges).
+ * 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.
  */
 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)
-        .map((node) => {
+        .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,

package/dist/types/examples/UseCases/NFTs/blur.d.ts

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

package/dist/types/examples/UseCases/X/x.d.ts

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

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

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

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

@@ -5,19 +5,16 @@ 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;
-/**
- * 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;
-/**
- * A "leaf" node is one that has no children (it’s never the source of an edge).
- */
+export declare function positionWorkflowNodesAvoidOverlap(workflow: Workflow): void;
 export declare function identifyLeafNodes(workflow: Workflow): Node[];
 /**
- * Identify starting nodes (no incoming edges).
+ * 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.
  */
 export declare function identityStartingNodes(workflow: Workflow): Node[];
 export declare function getChildren(node: Node, edges: Edge[]): Node[];

package/package.json

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