fig-tree-evaluator 2.2.1 → 2.2.2

package/build/operators/_operatorUtils.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,53 +19,88 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.axiosRequest = exports.joinUrlParts = exports.isFullUrl = exports.extractAndSimplify = exports.simplifyObject = exports.singleArrayToObject = exports.zipArraysToObject = exports.evaluateArray = void 0;
-const axios_1 = __importDefault(require("axios"));
-const extract_1 = __importDefault(require("object-property-extractor/build/extract"));
-const evaluate_1 = require("../evaluate");
-const typeCheck_1 = require("../typeCheck");
-const evaluateArray = (nodes, params) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!Array.isArray(nodes))
-        return (yield (0, evaluate_1.evaluatorFunction)(nodes, params));
-    return yield Promise.all(nodes.map((node) => (0, evaluate_1.evaluatorFunction)(node, params)));
-});
+var axios_1 = __importDefault(require("axios"));
+var extract_1 = __importDefault(require("object-property-extractor/build/extract"));
+var evaluate_1 = require("../evaluate");
+var typeCheck_1 = require("../typeCheck");
+var evaluateArray = function (nodes, params) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!!Array.isArray(nodes)) return [3, 2];
+                return [4, (0, evaluate_1.evaluatorFunction)(nodes, params)];
+            case 1: return [2, (_a.sent())];
+            case 2: return [4, Promise.all(nodes.map(function (node) { return (0, evaluate_1.evaluatorFunction)(node, params); }))];
+            case 3: return [2, _a.sent()];
+        }
+    });
+}); };
 exports.evaluateArray = evaluateArray;
-const zipArraysToObject = (keys, values) => {
-    const pairs = keys.map((key, index) => [key, values[index]]);
+var zipArraysToObject = function (keys, values) {
+    var pairs = keys.map(function (key, index) { return [key, values[index]]; });
     return Object.fromEntries(pairs);
 };
 exports.zipArraysToObject = zipArraysToObject;
-const singleArrayToObject = (elements) => {
+var singleArrayToObject = function (elements) {
     if (elements.length % 2 !== 0)
         throw new Error('Even number of children required to make key/value pairs');
-    const keys = elements.filter((_, index) => index % 2 === 0);
-    const result = (0, typeCheck_1.typeCheck)(...keys.map((key) => ({
+    var keys = elements.filter(function (_, index) { return index % 2 === 0; });
+    var result = typeCheck_1.typeCheck.apply(void 0, keys.map(function (key) { return ({
         value: key,
         expectedType: ['string', 'number', 'boolean'],
-    })));
+    }); }));
     if (result !== true)
         throw new Error(result);
-    const values = elements.filter((_, index) => index % 2 === 1);
-    const output = {};
-    keys.forEach((key, index) => {
+    var values = elements.filter(function (_, index) { return index % 2 === 1; });
+    var output = {};
+    keys.forEach(function (key, index) {
         output[key] = values[index];
     });
     return output;
 };
 exports.singleArrayToObject = singleArrayToObject;
-const simplifyObject = (item) => {
+var simplifyObject = function (item) {
     return item instanceof Object && Object.keys(item).length === 1 ? Object.values(item)[0] : item;
 };
 exports.simplifyObject = simplifyObject;
-const extractAndSimplify = (data, returnProperty, fallback = undefined) => {
+var extractAndSimplify = function (data, returnProperty, fallback) {
+    if (fallback === void 0) { fallback = undefined; }
     try {
-        const selectedProperty = returnProperty ? (0, extract_1.default)(data, returnProperty, fallback) : data;
+        var selectedProperty = returnProperty ? (0, extract_1.default)(data, returnProperty, fallback) : data;
         if (Array.isArray(selectedProperty))
-            return selectedProperty.map((item) => (0, exports.simplifyObject)(item));
+            return selectedProperty.map(function (item) { return (0, exports.simplifyObject)(item); });
         if (returnProperty) {
             if (selectedProperty === null)
                 return null;
@@ -67,36 +113,51 @@ const extractAndSimplify = (data, returnProperty, fallback = undefined) => {
     }
 };
 exports.extractAndSimplify = extractAndSimplify;
-const isFullUrl = (url) => /^https?:\/\/.+/.test(url);
+var isFullUrl = function (url) { return /^https?:\/\/.+/.test(url); };
 exports.isFullUrl = isFullUrl;
-const joinUrlParts = (...urls) => {
-    return urls.reduce((acc, curr, index) => {
-        const startSliceIndex = curr[0] === '/' ? 1 : 0;
-        const endSliceIndex = curr.slice(-1) === '/' ? -1 : undefined;
-        const newPart = curr.slice(startSliceIndex, endSliceIndex);
+var joinUrlParts = function () {
+    var urls = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        urls[_i] = arguments[_i];
+    }
+    return urls.reduce(function (acc, curr, index) {
+        var startSliceIndex = curr[0] === '/' ? 1 : 0;
+        var endSliceIndex = curr.slice(-1) === '/' ? -1 : undefined;
+        var newPart = curr.slice(startSliceIndex, endSliceIndex);
         return acc + (index === 0 ? '' : '/') + newPart;
     }, '');
 };
 exports.joinUrlParts = joinUrlParts;
-const axiosRequest = ({ url, params = {}, data = {}, headers = {}, method = 'get', }) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    try {
-        const response = yield (0, axios_1.default)({
-            method,
-            url,
-            headers: Object.assign({ 'Content-Type': 'application/json', Accept: 'application/json' }, headers),
-            params,
-            data,
+var axiosRequest = function (_a) {
+    var url = _a.url, _b = _a.params, params = _b === void 0 ? {} : _b, _c = _a.data, data = _c === void 0 ? {} : _c, _d = _a.headers, headers = _d === void 0 ? {} : _d, _e = _a.method, method = _e === void 0 ? 'get' : _e;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var response, err_1;
+        var _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    _g.trys.push([0, 2, , 3]);
+                    return [4, (0, axios_1.default)({
+                            method: method,
+                            url: url,
+                            headers: __assign({ 'Content-Type': 'application/json', Accept: 'application/json' }, headers),
+                            params: params,
+                            data: data,
+                        })];
+                case 1:
+                    response = _g.sent();
+                    return [2, response.data];
+                case 2:
+                    err_1 = _g.sent();
+                    if (axios_1.default.isAxiosError(err_1)) {
+                        if (!(err_1 === null || err_1 === void 0 ? void 0 : err_1.response))
+                            throw new Error('Network Error');
+                        console.log((_f = err_1.response) === null || _f === void 0 ? void 0 : _f.data);
+                    }
+                    throw err_1;
+                case 3: return [2];
+            }
         });
-        return response.data;
-    }
-    catch (err) {
-        if (axios_1.default.isAxiosError(err)) {
-            if (!(err === null || err === void 0 ? void 0 : err.response))
-                throw new Error('Network Error');
-            console.log((_a = err.response) === null || _a === void 0 ? void 0 : _a.data);
-        }
-        throw err;
-    }
-});
+    });
+};
 exports.axiosRequest = axiosRequest;

package/build/operators/buildObject.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,41 +19,88 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUILD_OBJECT = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['properties'];
-const operatorAliases = ['buildObject', 'build', 'object'];
-const propertyAliases = {
+var _operatorUtils_1 = require("./_operatorUtils");
+var requiredProperties = ['properties'];
+var operatorAliases = ['buildObject', 'build', 'object'];
+var propertyAliases = {
     values: 'properties',
     keyValPairs: 'properties',
     keyValuePairs: 'properties',
 };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const evaluatePair = (nodes) => __awaiter(void 0, void 0, void 0, function* () {
-        const [key, value] = (yield (0, _operatorUtils_1.evaluateArray)(nodes, config));
-        config.typeChecker({ name: 'key', value: key, expectedType: ['string', 'number', 'boolean'] });
-        return [key, value];
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var evaluatePair, evaluated, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                evaluatePair = function (nodes) { return __awaiter(void 0, void 0, void 0, function () {
+                    var _a, key, value;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0: return [4, (0, _operatorUtils_1.evaluateArray)(nodes, config)];
+                            case 1:
+                                _a = (_b.sent()), key = _a[0], value = _a[1];
+                                config.typeChecker({ name: 'key', value: key, expectedType: ['string', 'number', 'boolean'] });
+                                return [2, [key, value]];
+                        }
+                    });
+                }); };
+                config.typeChecker({ name: 'properties', value: expression.properties, expectedType: 'array' });
+                evaluated = expression.properties
+                    .filter(function (element) {
+                    return element instanceof Object && 'key' in element && 'value' in element;
+                })
+                    .map(function (_a) {
+                    var key = _a.key, value = _a.value;
+                    return evaluatePair([key, value]);
+                });
+                _b = (_a = Object).fromEntries;
+                return [4, Promise.all(evaluated)];
+            case 1: return [2, _b.apply(_a, [_c.sent()])];
+        }
     });
-    config.typeChecker({ name: 'properties', value: expression.properties, expectedType: 'array' });
-    const evaluated = expression.properties
-        .filter((element) => element instanceof Object && 'key' in element && 'value' in element)
-        .map(({ key, value }) => evaluatePair([key, value]));
-    return Object.fromEntries(yield Promise.all(evaluated));
-});
-const parseChildren = (expression) => {
-    const elements = expression.children;
+}); };
+var parseChildren = function (expression) {
+    var elements = expression.children;
     if (elements.length % 2 !== 0)
         throw new Error('Even number of children required to make key/value pairs');
-    const keys = elements.filter((_, index) => index % 2 === 0);
-    const values = elements.filter((_, index) => index % 2 === 1);
-    const properties = keys.map((key, index) => ({ key, value: values[index] }));
-    return Object.assign(Object.assign({}, expression), { properties });
+    var keys = elements.filter(function (_, index) { return index % 2 === 0; });
+    var values = elements.filter(function (_, index) { return index % 2 === 1; });
+    var properties = keys.map(function (key, index) { return ({ key: key, value: values[index] }); });
+    return __assign(__assign({}, expression), { properties: properties });
 };
 exports.BUILD_OBJECT = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
+    parseChildren: parseChildren,
 };

package/build/operators/conditional.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,26 +19,67 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONDITIONAL = void 0;
-const evaluate_1 = require("../evaluate");
-const requiredProperties = ['condition', 'valueIfTrue', 'valueIfFalse'];
-const operatorAliases = ['?', 'conditional', 'ifThen'];
-const propertyAliases = { ifTrue: 'valueIfTrue', ifFalse: 'valueIfFalse', ifNot: 'valueIfFalse' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const condition = yield (0, evaluate_1.evaluatorFunction)(expression.condition, config);
-    return !!condition
-        ? yield (0, evaluate_1.evaluatorFunction)(expression.valueIfTrue, config)
-        : yield (0, evaluate_1.evaluatorFunction)(expression.valueIfFalse, config);
-});
-const parseChildren = (expression) => {
-    const [condition, valueIfTrue, valueIfFalse] = expression.children;
-    return Object.assign(Object.assign({}, expression), { condition, valueIfTrue, valueIfFalse });
+var evaluate_1 = require("../evaluate");
+var requiredProperties = ['condition', 'valueIfTrue', 'valueIfFalse'];
+var operatorAliases = ['?', 'conditional', 'ifThen'];
+var propertyAliases = { ifTrue: 'valueIfTrue', ifFalse: 'valueIfFalse', ifNot: 'valueIfFalse' };
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var condition, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4, (0, evaluate_1.evaluatorFunction)(expression.condition, config)];
+            case 1:
+                condition = _b.sent();
+                if (!!!condition) return [3, 3];
+                return [4, (0, evaluate_1.evaluatorFunction)(expression.valueIfTrue, config)];
+            case 2:
+                _a = _b.sent();
+                return [3, 5];
+            case 3: return [4, (0, evaluate_1.evaluatorFunction)(expression.valueIfFalse, config)];
+            case 4:
+                _a = _b.sent();
+                _b.label = 5;
+            case 5: return [2, _a];
+        }
+    });
+}); };
+var parseChildren = function (expression) {
+    var _a = expression.children, condition = _a[0], valueIfTrue = _a[1], valueIfFalse = _a[2];
+    return __assign(__assign({}, expression), { condition: condition, valueIfTrue: valueIfTrue, valueIfFalse: valueIfFalse });
 };
 exports.CONDITIONAL = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
+    parseChildren: parseChildren,
 };

package/build/operators/count.js

@@ -8,22 +8,56 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COUNT = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['values'];
-const operatorAliases = ['count', 'length'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = yield (0, _operatorUtils_1.evaluateArray)(expression.values, config);
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.length;
-});
+var logicalAnd_1 = require("./logicalAnd");
+var _operatorUtils_1 = require("./_operatorUtils");
+var requiredProperties = ['values'];
+var operatorAliases = ['count', 'length'];
+var propertyAliases = {};
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var values;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)(expression.values, config)];
+            case 1:
+                values = _a.sent();
+                config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+                return [2, values.length];
+        }
+    });
+}); };
 exports.COUNT = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
     parseChildren: logicalAnd_1.parseChildren,
 };

package/build/operators/customFunctions.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,15 +19,51 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CUSTOM_FUNCTIONS = void 0;
-const object_property_extractor_1 = __importDefault(require("object-property-extractor"));
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['functionPath'];
-const operatorAliases = [
+var object_property_extractor_1 = __importDefault(require("object-property-extractor"));
+var _operatorUtils_1 = require("./_operatorUtils");
+var requiredProperties = ['functionPath'];
+var operatorAliases = [
     'customFunctions',
     'customFunction',
     'objectFunctions',
@@ -24,7 +71,7 @@ const operatorAliases = [
     'functions',
     'runFunction',
 ];
-const propertyAliases = {
+var propertyAliases = {
     functionsPath: 'functionPath',
     functionName: 'functionPath',
     funcName: 'functionPath',
@@ -32,22 +79,30 @@ const propertyAliases = {
     arguments: 'args',
     variables: 'args',
 };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const [functionPath, ...args] = (yield (0, _operatorUtils_1.evaluateArray)([expression.functionPath, ...(expression.args || [])], config));
-    config.typeChecker({ name: 'functionPath', value: functionPath, expectedType: 'string' });
-    const { objects, functions } = config.options;
-    const func = ((_b = (_a = (0, object_property_extractor_1.default)(functions, functionPath, null)) !== null && _a !== void 0 ? _a : (0, object_property_extractor_1.default)(objects, functionPath, null)) !== null && _b !== void 0 ? _b : (0, object_property_extractor_1.default)(config.options, functionPath));
-    return yield func(...args);
-});
-const parseChildren = (expression) => {
-    const [functionPath, ...args] = expression.children;
-    return Object.assign(Object.assign({}, expression), { functionPath, args });
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, functionPath, args, _b, objects, functions, func;
+    var _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)(__spreadArray([expression.functionPath], (expression.args || []), true), config)];
+            case 1:
+                _a = (_e.sent()), functionPath = _a[0], args = _a.slice(1);
+                config.typeChecker({ name: 'functionPath', value: functionPath, expectedType: 'string' });
+                _b = config.options, objects = _b.objects, functions = _b.functions;
+                func = ((_d = (_c = (0, object_property_extractor_1.default)(functions, functionPath, null)) !== null && _c !== void 0 ? _c : (0, object_property_extractor_1.default)(objects, functionPath, null)) !== null && _d !== void 0 ? _d : (0, object_property_extractor_1.default)(config.options, functionPath));
+                return [4, func.apply(void 0, args)];
+            case 2: return [2, _e.sent()];
+        }
+    });
+}); };
+var parseChildren = function (expression) {
+    var _a = expression.children, functionPath = _a[0], args = _a.slice(1);
+    return __assign(__assign({}, expression), { functionPath: functionPath, args: args });
 };
 exports.CUSTOM_FUNCTIONS = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
+    parseChildren: parseChildren,
 };