otomato-sdk 2.0.19 → 2.0.21

package/dist/src/constants/version.js

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

package/dist/src/models/Trigger.js

@@ -97,3 +97,38 @@ export const findTriggerByBlockId = (blockId) => {
     }
     throw new Error(`Trigger with id ${blockId} not found`);
 };
+/**
+ * Searches through the TRIGGERS object to find a sub-object
+ * whose `prototype` property matches `prototypeToMatch`.
+ *
+ * @param prototypeToMatch - The prototype string to find (e.g. "priceMovementAgainstCurrency").
+ * @returns An object of shape { [blockKey]: any } if found, otherwise null.
+ */
+export function findBlockByPrototype(prototypeToMatch) {
+    // Top-level keys are categories like "CORE", "TOKENS", "YIELD", etc.
+    for (const categoryKey in TRIGGERS) {
+        const category = TRIGGERS[categoryKey];
+        // Each category may have multiple blocks: e.g. "EVERY_PERIOD", "TRANSFER", "BALANCE", etc.
+        for (const blockKey in category) {
+            const blockValue = category[blockKey];
+            // If blockValue is not an object, skip it (it might be `description`, `image`, etc.)
+            if (typeof blockValue !== 'object' || blockValue === null) {
+                continue;
+            }
+            // Inside each block, we often see an object with the same name:
+            // e.g. category["TRANSFER"]["TRANSFER"]
+            // We iterate all keys inside blockValue to find the actual block that has `prototype`.
+            for (const subKey in blockValue) {
+                const subValue = blockValue[subKey];
+                if (typeof subValue === 'object' &&
+                    subValue !== null &&
+                    subValue.prototype === prototypeToMatch) {
+                    // Return the found block in the shape { [subKey]: subValue }
+                    return subValue;
+                }
+            }
+        }
+    }
+    // If we never find a matching prototype, return null
+    return null;
+}

package/dist/src/utils/externalVariables.js

@@ -1,4 +1,49 @@
+import { findBlockByPrototype } from "../models/Trigger";
 export function getExternalVariable(prototype, args) {
     return `{{external.functions.${prototype}(${args})}}`;
 }
 ;
+/**
+ * Creates a string of the form:
+ * {{external.functions.[prototype](param1,param2,...)}}
+ *
+ * - It looks up the parameter definitions for the given prototype.
+ * - For each parameter definition (in order), it finds a matching user parameter by key.
+ * - If not found, uses the parameter's default `value` if it exists, otherwise an empty placeholder.
+ * - Removes any trailing empty placeholders, but preserves empty placeholders in the middle.
+ */
+export function getExternalVariableFromParameters(prototype, parameters) {
+    // 1. Find the block in TRIGGERS
+    const block = findBlockByPrototype(prototype);
+    if (!block) {
+        // If we can't find the block definition, just call with user-supplied parameters
+        return `{{external.functions.${prototype}(${parameters.map((p) => p.value).join(",")})}}`;
+    }
+    // 2. Grab the ordered list of parameter definitions
+    const blockParams = block.parameters || [];
+    // 3. Build an array of final values in the same order as blockParams
+    const finalValues = blockParams.map((bp) => {
+        var _a, _b, _c, _d;
+        // 3a. Find a matching user parameter by exact key
+        const userParam = parameters.find((up) => up.key === bp.key);
+        if (userParam) {
+            // Use the user-supplied value
+            return (_b = (_a = userParam.value) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : "";
+        }
+        else if (bp.value != null) {
+            // Use the block's default value, if defined
+            return (_d = (_c = bp.value) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : "";
+        }
+        else {
+            // No user-supplied or default => empty placeholder
+            return "";
+        }
+    });
+    // 4. Remove trailing empty placeholders (e.g., `,,` at the end)
+    while (finalValues.length && finalValues[finalValues.length - 1] === "") {
+        finalValues.pop();
+    }
+    // 5. Join with commas to preserve empty slots in the middle
+    const paramString = finalValues.join(",");
+    return `{{external.functions.${prototype}(${paramString})}}`;
+}

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

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

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

@@ -29,3 +29,13 @@ export declare const findTriggerByBlockId: (blockId: number) => {
     parentInfo: ParentInfo;
     block: any;
 };
+/**
+ * Searches through the TRIGGERS object to find a sub-object
+ * whose `prototype` property matches `prototypeToMatch`.
+ *
+ * @param prototypeToMatch - The prototype string to find (e.g. "priceMovementAgainstCurrency").
+ * @returns An object of shape { [blockKey]: any } if found, otherwise null.
+ */
+export declare function findBlockByPrototype(prototypeToMatch: string): {
+    [blockKey: string]: any;
+} | null;

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

@@ -1 +1,14 @@
 export declare function getExternalVariable(prototype: String, args: Array<any>): string;
+/**
+ * Creates a string of the form:
+ * {{external.functions.[prototype](param1,param2,...)}}
+ *
+ * - It looks up the parameter definitions for the given prototype.
+ * - For each parameter definition (in order), it finds a matching user parameter by key.
+ * - If not found, uses the parameter's default `value` if it exists, otherwise an empty placeholder.
+ * - Removes any trailing empty placeholders, but preserves empty placeholders in the middle.
+ */
+export declare function getExternalVariableFromParameters(prototype: string, parameters: Array<{
+    key: string;
+    value: any;
+}>): string;

package/package.json

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