@bizone-ai/json-transform 1.10.0

package/dist/functions/TransformerFunctionLong.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TransformerFunction_1 = __importDefault(require("./common/TransformerFunction"));
+class TransformerFunctionLong extends TransformerFunction_1.default {
+    constructor() {
+        super({});
+    }
+    async apply(context) {
+        return context.getLong(null);
+    }
+}
+exports.default = TransformerFunctionLong;
+//# sourceMappingURL=TransformerFunctionLong.js.map

package/dist/functions/TransformerFunctionLong.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionLong.js","sourceRoot":"","sources":["../../src/functions/TransformerFunctionLong.ts"],"names":[],"mappings":";;;;;AAAA,uFAA+D;AAG/D,MAAM,uBAAwB,SAAQ,6BAAmB;IACvD;QACE,KAAK,CAAC,EAAE,CAAC,CAAC;IACZ,CAAC;IAEQ,KAAK,CAAC,KAAK,CAAC,OAAwB;QAC3C,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;CACF;AAED,kBAAe,uBAAuB,CAAC"}

package/dist/functions/TransformerFunctionLookup.d.ts

@@ -0,0 +1,8 @@
+import TransformerFunction from "./common/TransformerFunction";
+import FunctionContext from "./common/FunctionContext";
+declare class TransformerFunctionLookup extends TransformerFunction {
+    constructor();
+    apply(context: FunctionContext): Promise<any>;
+}
+export default TransformerFunctionLookup;
+//# sourceMappingURL=TransformerFunctionLookup.d.ts.map

package/dist/functions/TransformerFunctionLookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionLookup.d.ts","sourceRoot":"","sources":["../../src/functions/TransformerFunctionLookup.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,8BAA8B,CAAC;AAE/D,OAAO,eAAe,MAAM,0BAA0B,CAAC;AAUvD,cAAM,yBAA0B,SAAQ,mBAAmB;;IAY1C,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC;CAoE7D;AAED,eAAe,yBAAyB,CAAC"}

package/dist/functions/TransformerFunctionLookup.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TransformerFunction_1 = __importDefault(require("./common/TransformerFunction"));
+const ArgType_1 = require("./common/ArgType");
+const JsonHelpers_1 = require("../JsonHelpers");
+const JsonElementStreamer_1 = __importDefault(require("../JsonElementStreamer"));
+class TransformerFunctionLookup extends TransformerFunction_1.default {
+    constructor() {
+        super({
+            argsSets: [
+                [
+                    { name: "using", type: ArgType_1.ArgType.Array },
+                    { name: "to", type: ArgType_1.ArgType.Any },
+                ],
+            ],
+        });
+    }
+    async apply(context) {
+        const streamer = await context.getJsonElementStreamer(null);
+        if (streamer == null)
+            return null;
+        const usingArray = await context.getJsonArray("using", false);
+        if (usingArray == null)
+            return null;
+        // prepare matches map (this will be used in each iteration to create the merged item)
+        const matches = {};
+        const usingMap = {};
+        const usingArraySize = usingArray.length;
+        for (let w = 0; w < usingArraySize; w++) {
+            // prepare matches map
+            const using = usingArray[w];
+            const asDef = using.as;
+            if ((0, JsonHelpers_1.isNullOrUndefined)(asDef))
+                continue; // as - null
+            const as = (0, JsonHelpers_1.getAsString)(asDef);
+            delete matches["##" + as];
+            // collect using
+            const withDef = using.with;
+            if ((0, JsonHelpers_1.isNullOrUndefined)(withDef))
+                continue; // with - null
+            const $with = await context.transform(context.getPathFor("with"), withDef);
+            if (!Array.isArray($with))
+                continue; // with - not array
+            usingMap[w] = { with: $with, as, on: using.on };
+        }
+        const to = context.has("to") ? await context.getJsonElement("to", false) : null; // we don't transform definitions to prevent premature evaluation
+        const index = 0;
+        return JsonElementStreamer_1.default.fromTransformedStream(context, streamer.stream().map(async (item1) => {
+            const i = index;
+            for (let w = 0; w < usingArraySize; w++) {
+                if (!Object.prototype.hasOwnProperty.call(usingMap, w))
+                    continue;
+                const e = usingMap[w];
+                let match = null;
+                const withSize = e.with.length;
+                for (let j = 0; j < withSize; j++) {
+                    const item2 = e.with[j];
+                    const conditionResult = await context.transformItem(e.on, item1, i, "##" + e.as, item2);
+                    if ((0, JsonHelpers_1.isTruthy)(conditionResult)) {
+                        match = item2;
+                        break;
+                    }
+                }
+                matches["##" + e.as] = match;
+            }
+            if (to == null) {
+                if ((0, JsonHelpers_1.isMap)(item1)) {
+                    let merged = item1;
+                    for (let val of Object.values(matches)) {
+                        if (!(0, JsonHelpers_1.isMap)(val))
+                            continue; // edge case - tried to merge with an item which is not an object
+                        merged = (0, JsonHelpers_1.merge)(merged, val);
+                    }
+                    return merged;
+                }
+                else {
+                    // edge case - tried to merge to an item which is not an object
+                    return item1;
+                }
+            }
+            else {
+                return context.transformItem(to, item1, i, matches);
+            }
+        }));
+    }
+}
+exports.default = TransformerFunctionLookup;
+//# sourceMappingURL=TransformerFunctionLookup.js.map

package/dist/functions/TransformerFunctionLookup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionLookup.js","sourceRoot":"","sources":["../../src/functions/TransformerFunctionLookup.ts"],"names":[],"mappings":"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"}

package/dist/functions/TransformerFunctionLower.d.ts

@@ -0,0 +1,8 @@
+import TransformerFunction from "./common/TransformerFunction";
+import FunctionContext from "./common/FunctionContext";
+declare class TransformerFunctionLower extends TransformerFunction {
+    constructor();
+    apply(context: FunctionContext): Promise<any>;
+}
+export default TransformerFunctionLower;
+//# sourceMappingURL=TransformerFunctionLower.d.ts.map

package/dist/functions/TransformerFunctionLower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionLower.d.ts","sourceRoot":"","sources":["../../src/functions/TransformerFunctionLower.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,8BAA8B,CAAC;AAC/D,OAAO,eAAe,MAAM,0BAA0B,CAAC;AAEvD,cAAM,wBAAyB,SAAQ,mBAAmB;;IAKzC,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC;CAI7D;AAED,eAAe,wBAAwB,CAAC"}

package/dist/functions/TransformerFunctionLower.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TransformerFunction_1 = __importDefault(require("./common/TransformerFunction"));
+class TransformerFunctionLower extends TransformerFunction_1.default {
+    constructor() {
+        super({});
+    }
+    async apply(context) {
+        const result = await context.getString(null);
+        return result == null ? null : result.toLowerCase();
+    }
+}
+exports.default = TransformerFunctionLower;
+//# sourceMappingURL=TransformerFunctionLower.js.map

package/dist/functions/TransformerFunctionLower.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionLower.js","sourceRoot":"","sources":["../../src/functions/TransformerFunctionLower.ts"],"names":[],"mappings":";;;;;AAAA,uFAA+D;AAG/D,MAAM,wBAAyB,SAAQ,6BAAmB;IACxD;QACE,KAAK,CAAC,EAAE,CAAC,CAAC;IACZ,CAAC;IAEQ,KAAK,CAAC,KAAK,CAAC,OAAwB;QAC3C,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC7C,OAAO,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;IACtD,CAAC;CACF;AAED,kBAAe,wBAAwB,CAAC"}

package/dist/functions/TransformerFunctionMap.d.ts

@@ -0,0 +1,8 @@
+import TransformerFunction from "./common/TransformerFunction";
+import FunctionContext from "./common/FunctionContext";
+declare class TransformerFunctionMap extends TransformerFunction {
+    constructor();
+    apply(context: FunctionContext): Promise<any>;
+}
+export default TransformerFunctionMap;
+//# sourceMappingURL=TransformerFunctionMap.d.ts.map

package/dist/functions/TransformerFunctionMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionMap.d.ts","sourceRoot":"","sources":["../../src/functions/TransformerFunctionMap.ts"],"names":[],"mappings":"AACA,OAAO,mBAAmB,MAAM,8BAA8B,CAAC;AAE/D,OAAO,eAAe,MAAM,0BAA0B,CAAC;AAGvD,cAAM,sBAAuB,SAAQ,mBAAmB;;IAOvC,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC;CAyB7D;AAED,eAAe,sBAAsB,CAAC"}

package/dist/functions/TransformerFunctionMap.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequency_1 = require("@wortise/sequency");
+const TransformerFunction_1 = __importDefault(require("./common/TransformerFunction"));
+const ArgType_1 = require("./common/ArgType");
+const JsonElementStreamer_1 = __importDefault(require("../JsonElementStreamer"));
+class TransformerFunctionMap extends TransformerFunction_1.default {
+    constructor() {
+        super({
+            argsSets: [[{ name: "to", type: ArgType_1.ArgType.Any }]],
+        });
+    }
+    async apply(context) {
+        let inputStream;
+        let to;
+        if (context.has("to")) {
+            const streamer = await context.getJsonElementStreamer(null);
+            if (streamer == null)
+                return null;
+            inputStream = streamer.stream();
+            to = await context.getJsonElement("to", false); // we don't transform definitions to prevent premature evaluation
+        }
+        else {
+            // [ input, to ]
+            const arr = await context.getJsonArray(null, false); // we don't transform definitions to prevent premature evaluation
+            if (arr == null)
+                return null;
+            const inputEl = await context.transform(context.getPathFor(0), arr[0]);
+            if (!Array.isArray(inputEl)) {
+                console.warn(`${context.getAlias()} was not specified with an array of items`);
+                return null;
+            }
+            inputStream = (0, sequency_1.asAsyncSequence)(inputEl);
+            to = arr[1];
+        }
+        return JsonElementStreamer_1.default.fromTransformedStream(context, inputStream.mapIndexed((i, x) => context.transformItem(to, x, i)));
+    }
+}
+exports.default = TransformerFunctionMap;
+//# sourceMappingURL=TransformerFunctionMap.js.map

package/dist/functions/TransformerFunctionMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionMap.js","sourceRoot":"","sources":["../../src/functions/TransformerFunctionMap.ts"],"names":[],"mappings":";;;;;AAAA,gDAAmE;AACnE,uFAA+D;AAC/D,8CAA2C;AAE3C,iFAAyD;AAEzD,MAAM,sBAAuB,SAAQ,6BAAmB;IACtD;QACE,KAAK,CAAC;YACJ,QAAQ,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,iBAAO,CAAC,GAAG,EAAE,CAAC,CAAC;SAChD,CAAC,CAAC;IACL,CAAC;IAEQ,KAAK,CAAC,KAAK,CAAC,OAAwB;QAC3C,IAAI,WAA+B,CAAC;QACpC,IAAI,EAAO,CAAC;QACZ,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACtB,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;YAC5D,IAAI,QAAQ,IAAI,IAAI;gBAAE,OAAO,IAAI,CAAC;YAClC,WAAW,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC;YAChC,EAAE,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,iEAAiE;QACnH,CAAC;aAAM,CAAC;YACN,gBAAgB;YAChB,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,iEAAiE;YACtH,IAAI,GAAG,IAAI,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC7B,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACvE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC5B,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,QAAQ,EAAE,2CAA2C,CAAC,CAAC;gBAC/E,OAAO,IAAI,CAAC;YACd,CAAC;YACD,WAAW,GAAG,IAAA,0BAAe,EAAC,OAAO,CAAC,CAAC;YACvC,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QACd,CAAC;QACD,OAAO,6BAAmB,CAAC,qBAAqB,CAC9C,OAAO,EACP,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAClE,CAAC;IACJ,CAAC;CACF;AAED,kBAAe,sBAAsB,CAAC"}

package/dist/functions/TransformerFunctionMatch.d.ts

@@ -0,0 +1,8 @@
+import TransformerFunction from "./common/TransformerFunction";
+import FunctionContext from "./common/FunctionContext";
+declare class TransformerFunctionMatch extends TransformerFunction {
+    constructor();
+    apply(context: FunctionContext): Promise<any>;
+}
+export default TransformerFunctionMatch;
+//# sourceMappingURL=TransformerFunctionMatch.d.ts.map

package/dist/functions/TransformerFunctionMatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionMatch.d.ts","sourceRoot":"","sources":["../../src/functions/TransformerFunctionMatch.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,8BAA8B,CAAC;AAE/D,OAAO,eAAe,MAAM,0BAA0B,CAAC;AAEvD,cAAM,wBAAyB,SAAQ,mBAAmB;;IAYzC,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC;CAe7D;AAED,eAAe,wBAAwB,CAAC"}

package/dist/functions/TransformerFunctionMatch.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TransformerFunction_1 = __importDefault(require("./common/TransformerFunction"));
+const ArgType_1 = require("./common/ArgType");
+class TransformerFunctionMatch extends TransformerFunction_1.default {
+    constructor() {
+        super({
+            argsSets: [
+                [
+                    { name: "pattern", type: ArgType_1.ArgType.String },
+                    { name: "group", type: ArgType_1.ArgType.Number, defaultValue: 0 },
+                ],
+            ],
+        });
+    }
+    async apply(context) {
+        const str = await context.getString(null);
+        if (str == null) {
+            return null;
+        }
+        const patternString = await context.getString("pattern");
+        if (patternString == null) {
+            return null;
+        }
+        const matcher = new RegExp(patternString);
+        const result = str.match(matcher);
+        if (!result)
+            return null; // not found
+        const group = await context.getInteger("group");
+        return result[group ?? 0];
+    }
+}
+exports.default = TransformerFunctionMatch;
+//# sourceMappingURL=TransformerFunctionMatch.js.map

package/dist/functions/TransformerFunctionMatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionMatch.js","sourceRoot":"","sources":["../../src/functions/TransformerFunctionMatch.ts"],"names":[],"mappings":";;;;;AAAA,uFAA+D;AAC/D,8CAA2C;AAG3C,MAAM,wBAAyB,SAAQ,6BAAmB;IACxD;QACE,KAAK,CAAC;YACJ,QAAQ,EAAE;gBACR;oBACE,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,iBAAO,CAAC,MAAM,EAAE;oBACzC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,iBAAO,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,EAAE;iBACzD;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAEQ,KAAK,CAAC,KAAK,CAAC,OAAwB;QAC3C,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACzD,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,aAAa,CAAC,CAAC;QAC1C,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,CAAC,YAAY;QACtC,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAChD,OAAO,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC;IAC5B,CAAC;CACF;AAED,kBAAe,wBAAwB,CAAC"}

package/dist/functions/TransformerFunctionMatchAll.d.ts

@@ -0,0 +1,8 @@
+import TransformerFunction from "./common/TransformerFunction";
+import FunctionContext from "./common/FunctionContext";
+declare class TransformerFunctionMatchAll extends TransformerFunction {
+    constructor();
+    apply(context: FunctionContext): Promise<any>;
+}
+export default TransformerFunctionMatchAll;
+//# sourceMappingURL=TransformerFunctionMatchAll.d.ts.map

package/dist/functions/TransformerFunctionMatchAll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionMatchAll.d.ts","sourceRoot":"","sources":["../../src/functions/TransformerFunctionMatchAll.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,8BAA8B,CAAC;AAE/D,OAAO,eAAe,MAAM,0BAA0B,CAAC;AAEvD,cAAM,2BAA4B,SAAQ,mBAAmB;;IAY5C,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC;CAkB7D;AAED,eAAe,2BAA2B,CAAC"}

package/dist/functions/TransformerFunctionMatchAll.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TransformerFunction_1 = __importDefault(require("./common/TransformerFunction"));
+const ArgType_1 = require("./common/ArgType");
+class TransformerFunctionMatchAll extends TransformerFunction_1.default {
+    constructor() {
+        super({
+            argsSets: [
+                [
+                    { name: "pattern", type: ArgType_1.ArgType.String },
+                    { name: "group", type: ArgType_1.ArgType.Number, defaultValue: 0 },
+                ],
+            ],
+        });
+    }
+    async apply(context) {
+        const str = await context.getString(null);
+        if (str == null) {
+            return null;
+        }
+        const patternString = await context.getString("pattern");
+        if (patternString == null) {
+            return null;
+        }
+        const matcher = new RegExp(patternString, "g");
+        const allMatches = [];
+        const group = await context.getInteger("group");
+        for (const match of str.matchAll(matcher)) {
+            allMatches.push(match[group ?? 0]);
+        }
+        return allMatches.length == 0 ? null : allMatches;
+    }
+}
+exports.default = TransformerFunctionMatchAll;
+//# sourceMappingURL=TransformerFunctionMatchAll.js.map

package/dist/functions/TransformerFunctionMatchAll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionMatchAll.js","sourceRoot":"","sources":["../../src/functions/TransformerFunctionMatchAll.ts"],"names":[],"mappings":";;;;;AAAA,uFAA+D;AAC/D,8CAA2C;AAG3C,MAAM,2BAA4B,SAAQ,6BAAmB;IAC3D;QACE,KAAK,CAAC;YACJ,QAAQ,EAAE;gBACR;oBACE,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,iBAAO,CAAC,MAAM,EAAE;oBACzC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,iBAAO,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,EAAE;iBACzD;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAEQ,KAAK,CAAC,KAAK,CAAC,OAAwB;QAC3C,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACzD,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;QAE/C,MAAM,UAAU,GAAa,EAAE,CAAC;QAChC,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAChD,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,UAAU,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC;IACpD,CAAC;CACF;AAED,kBAAe,2BAA2B,CAAC"}

package/dist/functions/TransformerFunctionMath.d.ts

@@ -0,0 +1,35 @@
+import BigNumber from "bignumber.js";
+import TransformerFunction from "./common/TransformerFunction";
+import FunctionContext from "./common/FunctionContext";
+declare enum MathOp {
+    ADDITION = 1,
+    SUBTRACTION = 2,
+    MULTIPLICATION = 3,
+    DIVISION = 4,
+    INTEGER_DIVISION = 5,
+    MODULU = 6,
+    POWER = 7,
+    SQUARE_ROOT = 8,
+    MIN = 9,
+    MAX = 10,
+    ROUND = 11,
+    FLOOR = 12,
+    CEIL = 13,
+    ABSOLUTE = 14,
+    NEGATION = 15,
+    SIGNUM = 16,
+    BITAND = 17,
+    BITOR = 18,
+    BITXOR = 19,
+    SHIFT_LEFT = 20,
+    SHIFT_RIGHT = 21,
+    UNKNOWN = 22
+}
+declare class TransformerFunctionMath extends TransformerFunction {
+    constructor();
+    apply(context: FunctionContext): Promise<any>;
+    static parseMathOp(value: string | null): MathOp;
+    static eval(op: MathOp, op1: BigNumber, op2: BigNumber): BigNumber | null;
+}
+export default TransformerFunctionMath;
+//# sourceMappingURL=TransformerFunctionMath.d.ts.map

package/dist/functions/TransformerFunctionMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransformerFunctionMath.d.ts","sourceRoot":"","sources":["../../src/functions/TransformerFunctionMath.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,mBAAmB,MAAM,8BAA8B,CAAC;AAE/D,OAAO,eAAe,MAAM,0BAA0B,CAAC;AAIvD,aAAK,MAAM;IACT,QAAQ,IAAI;IACZ,WAAW,IAAA;IACX,cAAc,IAAA;IACd,QAAQ,IAAA;IACR,gBAAgB,IAAA;IAChB,MAAM,IAAA;IACN,KAAK,IAAA;IACL,WAAW,IAAA;IACX,GAAG,IAAA;IACH,GAAG,KAAA;IACH,KAAK,KAAA;IACL,KAAK,KAAA;IACL,IAAI,KAAA;IACJ,QAAQ,KAAA;IACR,QAAQ,KAAA;IACR,MAAM,KAAA;IACN,MAAM,KAAA;IACN,KAAK,KAAA;IACL,MAAM,KAAA;IACN,UAAU,KAAA;IACV,WAAW,KAAA;IACX,OAAO,KAAA;CACR;AAMD,cAAM,uBAAwB,SAAQ,mBAAmB;;IAoBxC,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC;IAiE5D,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM;IAqEhD,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;CAsD1E;AAED,eAAe,uBAAuB,CAAC"}

package/dist/functions/TransformerFunctionMath.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const TransformerFunction_1 = __importDefault(require("./common/TransformerFunction"));
+const ArgType_1 = require("./common/ArgType");
+const JsonHelpers_1 = require("../JsonHelpers");
+const FunctionHelpers_1 = require("./common/FunctionHelpers");
+var MathOp;
+(function (MathOp) {
+    MathOp[MathOp["ADDITION"] = 1] = "ADDITION";
+    MathOp[MathOp["SUBTRACTION"] = 2] = "SUBTRACTION";
+    MathOp[MathOp["MULTIPLICATION"] = 3] = "MULTIPLICATION";
+    MathOp[MathOp["DIVISION"] = 4] = "DIVISION";
+    MathOp[MathOp["INTEGER_DIVISION"] = 5] = "INTEGER_DIVISION";
+    MathOp[MathOp["MODULU"] = 6] = "MODULU";
+    MathOp[MathOp["POWER"] = 7] = "POWER";
+    MathOp[MathOp["SQUARE_ROOT"] = 8] = "SQUARE_ROOT";
+    MathOp[MathOp["MIN"] = 9] = "MIN";
+    MathOp[MathOp["MAX"] = 10] = "MAX";
+    MathOp[MathOp["ROUND"] = 11] = "ROUND";
+    MathOp[MathOp["FLOOR"] = 12] = "FLOOR";
+    MathOp[MathOp["CEIL"] = 13] = "CEIL";
+    MathOp[MathOp["ABSOLUTE"] = 14] = "ABSOLUTE";
+    MathOp[MathOp["NEGATION"] = 15] = "NEGATION";
+    MathOp[MathOp["SIGNUM"] = 16] = "SIGNUM";
+    MathOp[MathOp["BITAND"] = 17] = "BITAND";
+    MathOp[MathOp["BITOR"] = 18] = "BITOR";
+    MathOp[MathOp["BITXOR"] = 19] = "BITXOR";
+    MathOp[MathOp["SHIFT_LEFT"] = 20] = "SHIFT_LEFT";
+    MathOp[MathOp["SHIFT_RIGHT"] = 21] = "SHIFT_RIGHT";
+    MathOp[MathOp["UNKNOWN"] = 22] = "UNKNOWN";
+})(MathOp || (MathOp = {}));
+const BigZero = (0, FunctionHelpers_1.BigDecimal)(0);
+const toBigInt = (value) => BigInt((0, FunctionHelpers_1.BigDecimal)(value).toFixed(0, bignumber_js_1.default.ROUND_DOWN));
+class TransformerFunctionMath extends TransformerFunction_1.default {
+    constructor() {
+        super({
+            allowsArgumentsAsInput: true,
+            argsSets: [
+                [
+                    { name: "op1", type: ArgType_1.ArgType.Number, defaultValue: FunctionHelpers_1.BigDecimal_ZERO },
+                    { name: "op", type: ArgType_1.ArgType.String, defaultValue: FunctionHelpers_1.BigDecimal_ZERO },
+                    { name: "op2", type: ArgType_1.ArgType.Number, defaultValue: FunctionHelpers_1.BigDecimal_ZERO },
+                ],
+                /* No real value in adding this
+                [
+                  { name: "op", type: ArgType.String, defaultValue: BigDecimal_ZERO },
+                  { name: "op1", type: ArgType.Number, defaultValue: BigDecimal_ZERO },
+                  { name: "op2", type: ArgType.Number, defaultValue: BigDecimal_ZERO },
+                ],*/
+            ],
+        });
+    }
+    async apply(context) {
+        var value = await context.getJsonArray(null);
+        let parsedOp = null;
+        let op;
+        let op1 = null;
+        let op2 = null;
+        if (value != null) {
+            const size = value.length;
+            if (size <= 1)
+                return null; // invalid input
+            const arg0 = value[0];
+            const arg1 = value[1];
+            parsedOp = (0, JsonHelpers_1.getAsString)(arg0);
+            op = TransformerFunctionMath.parseMathOp(parsedOp);
+            if (size > 2 && op == MathOp.UNKNOWN) {
+                // [ op1, op, [op2] ]
+                parsedOp = (0, JsonHelpers_1.getAsString)(arg1);
+                op = TransformerFunctionMath.parseMathOp(parsedOp);
+                op1 = (0, FunctionHelpers_1.BigDecimal)(arg0);
+            }
+            else {
+                // [ op, op1, [op2] ]
+                op1 = (0, FunctionHelpers_1.BigDecimal)(arg1);
+            }
+            op2 = size < 3 ? (0, FunctionHelpers_1.BigDecimal)(0) : (0, FunctionHelpers_1.BigDecimal)(value[2]);
+        }
+        else {
+            // order of arguments ( op1, op, op2 )
+            parsedOp = await context.getEnum("op1");
+            op = TransformerFunctionMath.parseMathOp(parsedOp);
+            if (op == MathOp.UNKNOWN) {
+                // op was not detected as the first argument, so we assume it is in the second argument
+                // -> op1, op, [op2]
+                parsedOp = await context.getEnum("op");
+                op = TransformerFunctionMath.parseMathOp(parsedOp);
+                op1 = await context.getBigDecimal("op1");
+                op2 = await context.getBigDecimal("op2");
+            }
+            else {
+                const mainArgValue = await context.getUnwrapped(null);
+                if (mainArgValue != null) {
+                    // we set operand 1 as main argument value for the sake of functions with only one operand
+                    // -> op, [op2] : op1
+                    op1 = (0, FunctionHelpers_1.BigDecimal)(mainArgValue.toString());
+                    op2 = await context.getBigDecimal("op");
+                }
+                else {
+                    // -> op, op1, [op2]
+                    op1 = await context.getBigDecimal("op");
+                    op2 = await context.getBigDecimal("op2");
+                }
+            }
+        }
+        if (op == MathOp.UNKNOWN) {
+            console.warn("{} was specified with an unknown op ({})", context.getAlias(), parsedOp);
+            return null;
+        }
+        let result = TransformerFunctionMath.eval(op, op1 ?? BigZero, op2 ?? BigZero);
+        if (result == null) {
+            return null;
+        }
+        // cap scale at max
+        if ((result.decimalPlaces() ?? 0) > FunctionHelpers_1.MAX_SCALE) {
+            result = result.decimalPlaces(FunctionHelpers_1.MAX_SCALE, FunctionHelpers_1.MAX_SCALE_ROUNDING);
+        }
+        return result;
+    }
+    static parseMathOp(value) {
+        switch (value?.toUpperCase()) {
+            case "+":
+            case "ADD":
+                return MathOp.ADDITION;
+            case "-":
+            case "SUB":
+            case "SUBTRACT":
+                return MathOp.SUBTRACTION;
+            case "*":
+            case "MUL":
+            case "MULTIPLY":
+                return MathOp.MULTIPLICATION;
+            case "/":
+            case "DIV":
+            case "DIVIDE":
+                return MathOp.DIVISION;
+            case "//":
+            case "INTDIV":
+                return MathOp.INTEGER_DIVISION;
+            case "%":
+            case "MOD":
+            case "REMAINDER":
+                return MathOp.MODULU;
+            case "^":
+            case "**":
+            case "POW":
+            case "POWER":
+                return MathOp.POWER;
+            case "&":
+            case "AND":
+                return MathOp.BITAND;
+            case "|":
+            case "OR":
+                return MathOp.BITOR;
+            case "~":
+            case "XOR":
+                return MathOp.BITXOR;
+            case "<<":
+            case "SHL":
+                return MathOp.SHIFT_LEFT;
+            case ">>":
+            case "SHR":
+                return MathOp.SHIFT_RIGHT;
+            case "MIN":
+                return MathOp.MIN;
+            case "MAX":
+                return MathOp.MAX;
+            case "SQRT":
+                return MathOp.SQUARE_ROOT;
+            case "ROUND":
+                return MathOp.ROUND;
+            case "FLOOR":
+                return MathOp.FLOOR;
+            case "CEIL":
+                return MathOp.CEIL;
+            case "ABS":
+                return MathOp.ABSOLUTE;
+            case "NEG":
+            case "NEGATE":
+                return MathOp.NEGATION;
+            case "SIG":
+            case "SIGNUM":
+                return MathOp.SIGNUM;
+            default:
+                return MathOp.UNKNOWN;
+        }
+    }
+    static eval(op, op1, op2) {
+        switch (op) {
+            // 2 operands
+            case MathOp.ADDITION:
+                return op1.plus(op2);
+            case MathOp.SUBTRACTION:
+                return op1.minus(op2);
+            case MathOp.MULTIPLICATION:
+                return op1.multipliedBy(op2);
+            case MathOp.DIVISION:
+                return op1.dividedBy(op2);
+            case MathOp.INTEGER_DIVISION:
+                return op1.dividedToIntegerBy(op2);
+            case MathOp.MODULU:
+                return op1.mod(op2);
+            case MathOp.POWER:
+                return op1.pow(op2);
+            case MathOp.MIN:
+                return bignumber_js_1.default.min(op1, op2);
+            case MathOp.MAX:
+                return bignumber_js_1.default.max(op1, op2);
+            // only one operand
+            case MathOp.SQUARE_ROOT:
+                return op1.sqrt();
+            case MathOp.ROUND:
+                return op1.decimalPlaces(op2.integerValue().toNumber(), bignumber_js_1.default.ROUND_HALF_UP);
+            case MathOp.FLOOR:
+                return op1.decimalPlaces(op2.integerValue().toNumber(), bignumber_js_1.default.ROUND_FLOOR);
+            case MathOp.CEIL:
+                return op1.decimalPlaces(op2.integerValue().toNumber(), bignumber_js_1.default.ROUND_CEIL);
+            case MathOp.ABSOLUTE:
+                return op1.abs();
+            case MathOp.NEGATION:
+                return op1.negated();
+            case MathOp.SIGNUM:
+                return (0, FunctionHelpers_1.BigDecimal)(op1.isZero() ? 0 : op1.isPositive() ? 1 : -1);
+            // bitwise
+            case MathOp.BITAND:
+                return (0, FunctionHelpers_1.BigDecimal)((toBigInt(op1) & toBigInt(op2)).toString());
+            case MathOp.BITOR:
+                return (0, FunctionHelpers_1.BigDecimal)((toBigInt(op1) | toBigInt(op2)).toString());
+            // special case where only 1 op (~x) acts as NOT (op2 acts like ~0)
+            case MathOp.BITXOR:
+                return (0, JsonHelpers_1.isNullOrUndefined)(op2)
+                    ? (0, FunctionHelpers_1.BigDecimal)(~toBigInt(op1).toString())
+                    : (0, FunctionHelpers_1.BigDecimal)((toBigInt(op1) ^ toBigInt(op2)).toString());
+            case MathOp.SHIFT_LEFT:
+                return (0, FunctionHelpers_1.BigDecimal)((toBigInt(op1) << toBigInt(op2)).toString());
+            case MathOp.SHIFT_RIGHT:
+                return (0, FunctionHelpers_1.BigDecimal)((toBigInt(op1) >> toBigInt(op2)).toString());
+            default:
+                return null;
+        }
+    }
+}
+exports.default = TransformerFunctionMath;
+//# sourceMappingURL=TransformerFunctionMath.js.map