otomato-sdk 2.0.241 → 2.0.242

package/dist/src/constants/version.js

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

package/dist/src/models/Node.js

@@ -5,6 +5,7 @@ const generatedRefs = new Set();
 export class Node {
     constructor(node) {
         this.id = null;
+        this.isOptional = null;
         this.id = null;
         this.blockId = node.blockId;
         this.name = node.name;
@@ -16,6 +17,7 @@ export class Node {
         this.class = node.class;
         this.parentInfo = node.parentInfo;
         this.state = node.state || 'inactive';
+        this.isOptional = node.isOptional || null;
         this.frontendHelpers = node.frontendHelpers || {};
         if (node.ref) {
             this.ref = node.ref;
@@ -58,6 +60,9 @@ export class Node {
     setRef(ref) {
         this.ref = ref;
     }
+    setIsOptional(isOptional) {
+        this.isOptional = isOptional;
+    }
     getParentInfo() {
         return this.parentInfo;
     }
@@ -176,6 +181,7 @@ export class Node {
             blockId: this.blockId,
             type: this.class,
             state: this.state,
+            isOptional: this.isOptional,
             parameters: {
                 ...this.getParameters(),
             },

package/dist/src/utils/WorkflowNodePositioner.js

@@ -232,32 +232,6 @@ export function positionWorkflowNodes(workflow) {
                 }
             });
         });
-        // Additional step: Ensure common children of multiple layer 0 triggers are centered at ROOT_X.
-        // This runs after initial layer placement and before final overlap resolution specific to children groups might occur,
-        // and crucially before parent centering which might pull triggers away.
-        for (const node of workflow.nodes) {
-            const nodeLayer = node.layer;
-            if (nodeLayer === 1) { // Check nodes in the layer immediately following triggers
-                const parents = getParents(node, workflow.edges);
-                if (parents.length > 1) { // Only if it has multiple parents
-                    const allParentsAreLayer0Triggers = parents.every(p => {
-                        const parentLayer = p.layer;
-                        const parentIsStartingNode = getParents(p, workflow.edges).length === 0;
-                        return parentLayer === 0 && parentIsStartingNode;
-                    });
-                    if (allParentsAreLayer0Triggers) {
-                        if (node.position) { // Ensure node.position exists before trying to read node.position.y
-                            node.setPosition(ROOT_X, node.position.y);
-                        }
-                        else {
-                            // This case should ideally not happen if nodes in layer 1 are already positioned by the main loop.
-                            // If it does, assign a default Y based on its layer.
-                            node.setPosition(ROOT_X, (nodeLayer * ySpacing) + ROOT_Y);
-                        }
-                    }
-                }
-            }
-        }
         // Step 4: Bottom-up Parent Centering.
         // Now, we simply set each parent's x to the exact average of its children.
         centerParentXPositions(workflow);
@@ -271,6 +245,42 @@ export function positionWorkflowNodes(workflow) {
                 return Number(a.getRef()) - Number(b.getRef());
             });
         });
+        // FINAL STEP: Center nodes in the main action stack only when there are multiple triggers
+        const triggers = workflow.nodes.filter(n => n.layer === 0 && getParents(n, workflow.edges).length === 0);
+        // Only apply centering if there are multiple triggers
+        if (triggers.length > 1) {
+            const triggerRefs = new Set(triggers.map(t => t.getRef()));
+            const triggerXs = triggers.map(t => t.position.x);
+            const triggerCenter = triggerXs.reduce((a, b) => a + b, 0) / triggerXs.length;
+            function getAllAncestors(node, edges, visited = new Set()) {
+                const parents = getParents(node, edges);
+                for (const parent of parents) {
+                    if (!visited.has(parent.getRef())) {
+                        visited.add(parent.getRef());
+                        getAllAncestors(parent, edges, visited);
+                    }
+                }
+                return visited;
+            }
+            // Helper: is a node a descendant of all triggers?
+            function isDescendantOfAllTriggers(node) {
+                const ancestors = getAllAncestors(node, workflow.edges);
+                return Array.from(triggerRefs).every(ref => ancestors.has(ref));
+            }
+            for (const node of workflow.nodes) {
+                if (node.layer === 0)
+                    continue; // skip triggers
+                if (!isDescendantOfAllTriggers(node))
+                    continue;
+                // Check all non-trigger ancestors
+                const ancestors = Array.from(getAllAncestors(node, workflow.edges))
+                    .map(ref => workflow.nodes.find(n => n.getRef() === ref))
+                    .filter(n => n && n.layer !== 0);
+                if (ancestors.every(isDescendantOfAllTriggers)) {
+                    node.setPosition(triggerCenter, node.position?.y ?? 0);
+                }
+            }
+        }
     }
     catch (e) {
         console.error(e);

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

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

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

@@ -30,6 +30,7 @@ export declare abstract class Node {
     image: string;
     parentInfo?: ParentInfo;
     state: NodeState;
+    isOptional: boolean | null;
     frontendHelpers: Record<string, any>;
     constructor(node: {
         blockId: number;
@@ -46,6 +47,7 @@ export declare abstract class Node {
         parentInfo?: ParentInfo;
         state?: NodeState;
         frontendHelpers?: Record<string, any>;
+        isOptional?: boolean;
     });
     setId(id: string): void;
     setChainId(value: number): void;
@@ -54,6 +56,7 @@ export declare abstract class Node {
     setPosition(x: number, y: number): void;
     getRef(): string;
     setRef(ref: string): void;
+    setIsOptional(isOptional: boolean): void;
     getParentInfo(): ParentInfo | undefined;
     getState(): NodeState;
     protected setParameter(key: string, value: any): void;

package/package.json

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