fig-tree-evaluator 2.2.1 → 2.2.2

package/README.md

@@ -4,7 +4,7 @@
 
 **FigTree Evaluator** is a module to evaluate JSON-structured expression trees. 
 
-A typical use case would be for evaluating **configuration** files, where you need to store dynamic values or arbitrary logic without allowing users to inject executable code. For example, a [form-builder app](https://github.com/openmsupply/conforma-web-app) might need to allow complex conditional logic for form element visibility based on previous responses, or for validation beyond what is available in standard validation libraries.
+A typical use case would be for evaluating **configuration** files, where you need to store dynamic values or arbitrary logic without allowing users to inject executable code (perhaps in a .json file, say). For example, a [form-builder app](https://github.com/openmsupply/conforma-web-app) might need to allow complex conditional logic for form element visibility based on previous responses, or for validation beyond what is available in standard validation libraries.
 
 Another example would be to configure a [decision tree](https://en.wikipedia.org/wiki/Decision_tree) to implement branching logic.
 
@@ -143,10 +143,11 @@ The `options` parameter is an object with the following available properties (al
 - `headers` -- A general http headers object that will be passed to *all* http-based operators. Useful for authenticatian headers, for example. Each operator and instance can have its own headers, though, so see specific operator reference for details.
 - `returnErrorAsString` -- by default the evaluator will throw errors with invalid evaluation expressions (with helpful error messages indicating the node which threw the error and what the problem was). But if you have `returnErrorAsString: true` set, the evaluator will never throw, but instead return error messages as a valid string output. (See also the [`fallback`](#other-common-properties) parameter below)
 - `allowJSONStringInput` -- the evaluator is expecting the input expression to be a javascript object. However, it will also accept JSON strings if this option is set to `true`. We have to perform additional logic on every evaluation input to determine if a string is a JSON expression or a standard string, so this is skipped by default for performance reasons. However, if you want to send (for example) user input directly to the evaluator without running it through your own `JSON.parse()`, then enable this option.
-- `skipRuntimeTypeCheck` -- we perform comprehensive type checking at runtime to ensure that each operator only performs its operation on valid inputs. If type checking fails, we throw an error detailing the explicit problem. However, if `skipRuntimeTypeCheck` is set to `true`, then all inputs are passed to the operator regardless, and any errors will come from whatever standard javascript errors might be encoutered (e.g. trying to pass a primitive value when an array is expected => `.map is not a function`)
+- `skipRuntimeTypeCheck` -- we perform comprehensive type checking at runtime to ensure that each operator only performs its operation on valid inputs. If type checking fails, we throw an error detailing the explicit problem. However, if `skipRuntimeTypeCheck` is set to `true`, then all inputs are passed to the operator regardless, and any errors will come from whatever standard javascript errors might be encountered (e.g. trying to pass a primitive value when an array is expected => `.map is not a function`)
 - `nullEqualsUndefined` -- this only affects the [`equal`/`notEqual` operators](#equal) (see there for more detail). 
+- `evaluateFullObject` -- by default, FigTree expects the root of an input expression to be an [Operator Node](#operator-nodes), and if not, will return the input unmodified. However, you may have cases where the evaluation expressions are deep within a larger structure (such as a JSON schema, for example). In this case, you can set `evaluateFullObject` to `true` and the evaluator will find *any* operator nodes within the structure and evaluate them in place.
 
-As mentioned above, `options` can be provided as part of the constructor as part of each seperate evaluation. You can also change the options permanently for a given evaluator instance with:
+As mentioned above, `options` can be provided as part of the constructor as part of each separate evaluation. You can also change the options permanently for a given evaluator instance with:
 
 `exp.updateOptions(options)`
 
@@ -1410,8 +1411,16 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 
 ## Changelog
 
+- **v2.2.2**: Option to evaluate whole object if operator nodes are deep within it (#64)
+- **v2.2.1**: More efficient branch evaluation for condition/match operators (#63)
+- **v2.2.0**:
+  - New "[Match](#match) operator (#61)
+  - Fix for regex incompatibility with Safari (#60)
+- **v2.1.5**: Demo updates (no changes to core evaluator)
+- **v2.1.4**: Upgrade dependencies
+- **v2.1.0**: [Alias nodes](#alias-nodes) (#57)
 - **v2.0.4**: Backwards compatibility for customFunctions (#53)
-- **v2.0.1**: Add deep equality comparison for objects/arrayr in =/!= operators
+- **v2.0.1**: Add deep equality comparison for objects/arrays in `=`/`!=` operators
 - **v2.0.0**: Re-write as stand-alone package. Major improvements include:
   -  more [operators](#operator-reference)
   -  operator (and property) [aliases](#operator--property-aliases)
@@ -1421,7 +1430,7 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
   -  better error handling and error reporting
   -  more flexible output conversion
   -  more well-organised codebase
-- **v1.x.x**: created specifically for [Conforma](https://github.com/openmsupply/conforma-server/wiki/Query-Syntax) application manager by [mSupplyFoundation](https://github.com/openmsupply). v2 is a complete re-write with numerous improvments, but should be 99% backwards compatible.
+- **v1.x.x**: created specifically for [Conforma](https://github.com/openmsupply/conforma-server/wiki/Query-Syntax) application manager by [mSupplyFoundation](https://github.com/openmsupply). v2 is a complete re-write with numerous improvements, but should be 99% backwards compatible.
 
 
 ## Credit

package/build/evaluate.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,57 +19,134 @@ 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.evaluatorFunction = void 0;
-const _operatorUtils_1 = require("./operators/_operatorUtils");
-const helpers_1 = require("./helpers");
-const evaluatorFunction = (input, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const { options, operators, operatorAliases } = config;
-    let expression = (options === null || options === void 0 ? void 0 : options.allowJSONStringInput) ? (0, helpers_1.parseIfJson)(input) : input;
-    if (Array.isArray(expression)) {
-        expression = yield (0, _operatorUtils_1.evaluateArray)(expression, config);
-    }
-    if (!(0, helpers_1.isOperatorNode)(expression))
-        return (0, helpers_1.replaceAliasNodeValues)(expression, config);
-    const { fallback } = expression;
-    const returnErrorAsString = (_a = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _a !== void 0 ? _a : false;
-    try {
-        const operator = (0, helpers_1.getOperatorName)(expression.operator, operatorAliases);
-        if (!operator)
-            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Invalid operator: ${expression.operator}`, returnErrorAsString);
-        const { requiredProperties, propertyAliases, evaluate, parseChildren } = operators[operator];
-        expression = (0, helpers_1.mapPropertyAliases)(propertyAliases, expression);
-        config.resolvedAliasNodes = Object.assign(Object.assign({}, config.resolvedAliasNodes), (yield (0, helpers_1.evaluateNodeAliases)(expression, config)));
-        const validationError = (0, helpers_1.checkRequiredNodes)(requiredProperties, expression);
-        if (validationError)
-            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- ${validationError}`, returnErrorAsString);
-        if ('children' in expression) {
-            if (!Array.isArray(expression.children))
-                expression.children = yield (0, exports.evaluatorFunction)(expression.children, config);
-            if (!Array.isArray(expression.children))
-                return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- Property "children" is not of type: array`, returnErrorAsString);
-            expression = yield parseChildren(expression, config);
-        }
-        let result;
-        try {
-            result = yield evaluate(expression, config);
+var _operatorUtils_1 = require("./operators/_operatorUtils");
+var helpers_1 = require("./helpers");
+var evaluatorFunction = function (input, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var options, operators, operatorAliases, expression, fallback, returnErrorAsString, operator, _a, _b, requiredProperties, propertyAliases, evaluate, parseChildren, _c, _d, validationError, _e, _f, _g, result, err_1, _h, outputType, evaluatedOutputType, _j, err_2, _k;
+    var _l, _m;
+    return __generator(this, function (_o) {
+        switch (_o.label) {
+            case 0:
+                options = config.options, operators = config.operators, operatorAliases = config.operatorAliases;
+                expression = (options === null || options === void 0 ? void 0 : options.allowJSONStringInput) ? (0, helpers_1.parseIfJson)(input) : input;
+                if (!Array.isArray(expression)) return [3, 2];
+                return [4, (0, _operatorUtils_1.evaluateArray)(expression, config)];
+            case 1:
+                expression = _o.sent();
+                _o.label = 2;
+            case 2:
+                if (!(options.evaluateFullObject && !(0, helpers_1.isOperatorNode)(expression))) return [3, 4];
+                return [4, (0, helpers_1.evaluateObject)(expression, config)];
+            case 3: return [2, _o.sent()];
+            case 4:
+                if (!(0, helpers_1.isOperatorNode)(expression))
+                    return [2, (0, helpers_1.replaceAliasNodeValues)(expression, config)];
+                fallback = expression.fallback;
+                returnErrorAsString = (_l = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _l !== void 0 ? _l : false;
+                _o.label = 5;
+            case 5:
+                _o.trys.push([5, 26, , 28]);
+                operator = (0, helpers_1.getOperatorName)(expression.operator, operatorAliases);
+                if (!!operator) return [3, 7];
+                _a = helpers_1.fallbackOrError;
+                return [4, (0, exports.evaluatorFunction)(fallback, config)];
+            case 6: return [2, _a.apply(void 0, [_o.sent(), "Invalid operator: ".concat(expression.operator), returnErrorAsString])];
+            case 7:
+                _b = operators[operator], requiredProperties = _b.requiredProperties, propertyAliases = _b.propertyAliases, evaluate = _b.evaluate, parseChildren = _b.parseChildren;
+                expression = (0, helpers_1.mapPropertyAliases)(propertyAliases, expression);
+                _c = config;
+                _d = [__assign({}, config.resolvedAliasNodes)];
+                return [4, (0, helpers_1.evaluateNodeAliases)(expression, config)];
+            case 8:
+                _c.resolvedAliasNodes = __assign.apply(void 0, _d.concat([(_o.sent())]));
+                validationError = (0, helpers_1.checkRequiredNodes)(requiredProperties, expression);
+                if (!validationError) return [3, 10];
+                _e = helpers_1.fallbackOrError;
+                return [4, (0, exports.evaluatorFunction)(fallback, config)];
+            case 9: return [2, _e.apply(void 0, [_o.sent(), "Operator: ".concat(operator, "\n- ").concat(validationError), returnErrorAsString])];
+            case 10:
+                if (!('children' in expression)) return [3, 16];
+                if (!!Array.isArray(expression.children)) return [3, 12];
+                _f = expression;
+                return [4, (0, exports.evaluatorFunction)(expression.children, config)];
+            case 11:
+                _f.children = _o.sent();
+                _o.label = 12;
+            case 12:
+                if (!!Array.isArray(expression.children)) return [3, 14];
+                _g = helpers_1.fallbackOrError;
+                return [4, (0, exports.evaluatorFunction)(fallback, config)];
+            case 13: return [2, _g.apply(void 0, [_o.sent(), "Operator: ".concat(operator, "\n- Property \"children\" is not of type: array"), returnErrorAsString])];
+            case 14: return [4, parseChildren(expression, config)];
+            case 15:
+                expression = _o.sent();
+                _o.label = 16;
+            case 16:
+                result = void 0;
+                _o.label = 17;
+            case 17:
+                _o.trys.push([17, 19, , 21]);
+                return [4, evaluate(expression, config)];
+            case 18:
+                result = _o.sent();
+                return [3, 21];
+            case 19:
+                err_1 = _o.sent();
+                _h = helpers_1.fallbackOrError;
+                return [4, (0, exports.evaluatorFunction)(fallback, config)];
+            case 20:
+                result = _h.apply(void 0, [_o.sent(), "Operator: ".concat(operator, "\n").concat((0, helpers_1.errorMessage)(err_1)), returnErrorAsString]);
+                return [3, 21];
+            case 21:
+                outputType = (_m = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _m !== void 0 ? _m : expression === null || expression === void 0 ? void 0 : expression.type;
+                if (!outputType)
+                    return [2, result];
+                return [4, (0, exports.evaluatorFunction)(outputType, config)];
+            case 22:
+                evaluatedOutputType = (_o.sent());
+                if (!!(evaluatedOutputType in helpers_1.convertOutputMethods)) return [3, 24];
+                _j = helpers_1.fallbackOrError;
+                return [4, (0, exports.evaluatorFunction)(fallback, config)];
+            case 23: return [2, _j.apply(void 0, [_o.sent(), "Operator: ".concat(operator, "\n- Invalid output type: ").concat(evaluatedOutputType), returnErrorAsString])];
+            case 24: return [2, helpers_1.convertOutputMethods[evaluatedOutputType](result)];
+            case 25: return [3, 28];
+            case 26:
+                err_2 = _o.sent();
+                _k = helpers_1.fallbackOrError;
+                return [4, (0, exports.evaluatorFunction)(fallback, config)];
+            case 27: return [2, _k.apply(void 0, [_o.sent(), (0, helpers_1.errorMessage)(err_2),
+                    returnErrorAsString])];
+            case 28: return [2];
         }
-        catch (err) {
-            result = (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n${(0, helpers_1.errorMessage)(err)}`, returnErrorAsString);
-        }
-        const outputType = (_b = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _b !== void 0 ? _b : expression === null || expression === void 0 ? void 0 : expression.type;
-        if (!outputType)
-            return result;
-        const evaluatedOutputType = (yield (0, exports.evaluatorFunction)(outputType, config));
-        if (!(evaluatedOutputType in helpers_1.convertOutputMethods))
-            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- Invalid output type: ${evaluatedOutputType}`, returnErrorAsString);
-        else {
-            return helpers_1.convertOutputMethods[evaluatedOutputType](result);
-        }
-    }
-    catch (err) {
-        return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), (0, helpers_1.errorMessage)(err), returnErrorAsString);
-    }
-});
+    });
+}); };
 exports.evaluatorFunction = evaluatorFunction;

package/build/helpers.d.ts

@@ -19,3 +19,4 @@ export declare const convertOutputMethods: {
     [key in OutputType]: (value: EvaluatorOutput) => EvaluatorOutput | EvaluatorOutput[];
 };
 export declare const errorMessage: (err: unknown) => string;
+export declare const evaluateObject: (input: EvaluatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;

package/build/helpers.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,16 +19,43 @@ 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.errorMessage = exports.convertOutputMethods = exports.mergeOptions = exports.checkRequiredNodes = exports.replaceAliasNodeValues = exports.evaluateNodeAliases = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.getOperatorName = exports.isOperatorNode = exports.parseIfJson = void 0;
-const change_case_1 = require("change-case");
-const evaluate_1 = require("./evaluate");
-const _operatorUtils_1 = require("./operators/_operatorUtils");
-const parseIfJson = (input) => {
+exports.evaluateObject = exports.errorMessage = exports.convertOutputMethods = exports.mergeOptions = exports.checkRequiredNodes = exports.replaceAliasNodeValues = exports.evaluateNodeAliases = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.getOperatorName = exports.isOperatorNode = exports.parseIfJson = void 0;
+var change_case_1 = require("change-case");
+var evaluate_1 = require("./evaluate");
+var _operatorUtils_1 = require("./operators/_operatorUtils");
+var parseIfJson = function (input) {
     if (typeof input !== 'string')
         return input;
     try {
-        const parsedInput = JSON.parse(input);
+        var parsedInput = JSON.parse(input);
         return (0, exports.isOperatorNode)(parsedInput) ? parsedInput : input;
     }
     catch (err) {
@@ -25,17 +63,25 @@ const parseIfJson = (input) => {
     }
 };
 exports.parseIfJson = parseIfJson;
-const isOperatorNode = (input) => input instanceof Object && 'operator' in input;
+var isOperatorNode = function (input) {
+    return input instanceof Object && 'operator' in input;
+};
 exports.isOperatorNode = isOperatorNode;
-const standardiseOperatorName = (name) => {
-    const camelCaseName = (0, change_case_1.camelCase)(name);
+var standardiseOperatorName = function (name) {
+    var camelCaseName = (0, change_case_1.camelCase)(name);
     return camelCaseName ? camelCaseName : name;
 };
-const getOperatorName = (operator, operatorAliases) => operatorAliases[standardiseOperatorName(operator)];
+var getOperatorName = function (operator, operatorAliases) {
+    return operatorAliases[standardiseOperatorName(operator)];
+};
 exports.getOperatorName = getOperatorName;
-const truncateString = (string, length = 200) => string.length < length ? string : `${string.slice(0, length - 2).trim()}...`;
+var truncateString = function (string, length) {
+    if (length === void 0) { length = 200; }
+    return string.length < length ? string : "".concat(string.slice(0, length - 2).trim(), "...");
+};
 exports.truncateString = truncateString;
-const fallbackOrError = (fallback, errorMessage, returnErrorAsString = false) => {
+var fallbackOrError = function (fallback, errorMessage, returnErrorAsString) {
+    if (returnErrorAsString === void 0) { returnErrorAsString = false; }
     if (fallback !== undefined)
         return fallback;
     if (returnErrorAsString)
@@ -44,65 +90,105 @@ const fallbackOrError = (fallback, errorMessage, returnErrorAsString = false) =>
         throw new Error((0, exports.truncateString)(errorMessage));
 };
 exports.fallbackOrError = fallbackOrError;
-const mapPropertyAliases = (propertyAliases, expression) => mapObjectKeys(expression, (key) => key in propertyAliases ? propertyAliases[key] : key);
+var mapPropertyAliases = function (propertyAliases, expression) {
+    return mapObjectKeys(expression, function (key) {
+        return key in propertyAliases ? propertyAliases[key] : key;
+    });
+};
 exports.mapPropertyAliases = mapPropertyAliases;
-const mapObjectKeys = (inputObj, mapFunction) => {
-    const keyVals = Object.entries(inputObj);
-    const mappedKeys = keyVals.map(([key, value]) => [mapFunction(key), value]);
+var mapObjectKeys = function (inputObj, mapFunction) {
+    var keyVals = Object.entries(inputObj);
+    var mappedKeys = keyVals.map(function (_a) {
+        var key = _a[0], value = _a[1];
+        return [mapFunction(key), value];
+    });
     return Object.fromEntries(mappedKeys);
 };
-const isAliasString = (value) => /^\$.+/.test(value);
-const evaluateNodeAliases = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const aliasKeys = Object.keys(expression).filter(isAliasString);
-    if (aliasKeys.length === 0)
-        return expression;
-    const evaluations = [];
-    aliasKeys.forEach((alias) => evaluations.push((0, evaluate_1.evaluatorFunction)(expression[alias], config)));
-    return (0, _operatorUtils_1.zipArraysToObject)(aliasKeys, yield Promise.all(evaluations));
-});
+var isAliasString = function (value) { return /^\$.+/.test(value); };
+var evaluateNodeAliases = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var aliasKeys, evaluations, _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                aliasKeys = Object.keys(expression).filter(isAliasString);
+                if (aliasKeys.length === 0)
+                    return [2, expression];
+                evaluations = [];
+                aliasKeys.forEach(function (alias) { return evaluations.push((0, evaluate_1.evaluatorFunction)(expression[alias], config)); });
+                _a = _operatorUtils_1.zipArraysToObject;
+                _b = [aliasKeys];
+                return [4, Promise.all(evaluations)];
+            case 1: return [2, _a.apply(void 0, _b.concat([_c.sent()]))];
+        }
+    });
+}); };
 exports.evaluateNodeAliases = evaluateNodeAliases;
-const replaceAliasNodeValues = (value, { resolvedAliasNodes }) => {
-    var _a;
+var replaceAliasNodeValues = function (value, _a) {
+    var _b;
+    var resolvedAliasNodes = _a.resolvedAliasNodes;
     if (typeof value !== 'string' || !isAliasString(value))
         return value;
-    return (_a = resolvedAliasNodes === null || resolvedAliasNodes === void 0 ? void 0 : resolvedAliasNodes[value]) !== null && _a !== void 0 ? _a : value;
+    return (_b = resolvedAliasNodes === null || resolvedAliasNodes === void 0 ? void 0 : resolvedAliasNodes[value]) !== null && _b !== void 0 ? _b : value;
 };
 exports.replaceAliasNodeValues = replaceAliasNodeValues;
-const checkRequiredNodes = (requiredProps, expression) => {
-    const missingProps = requiredProps.filter((prop) => !(prop in expression));
+var checkRequiredNodes = function (requiredProps, expression) {
+    var missingProps = requiredProps.filter(function (prop) { return !(prop in expression); });
     if (missingProps.length === 0)
         return false;
     if (!('children' in expression))
-        return `Missing properties: ${missingProps}`;
+        return "Missing properties: ".concat(missingProps);
     return false;
 };
 exports.checkRequiredNodes = checkRequiredNodes;
-const mergeOptions = (origOptions, newOptions) => {
-    const combinedOptions = Object.assign(Object.assign({}, origOptions), newOptions);
+var mergeOptions = function (origOptions, newOptions) {
+    var combinedOptions = __assign(__assign({}, origOptions), newOptions);
     if (origOptions.objects || newOptions.objects)
-        combinedOptions.objects = Object.assign(Object.assign({}, origOptions.objects), newOptions.objects);
+        combinedOptions.objects = __assign(__assign({}, origOptions.objects), newOptions.objects);
     if (origOptions.functions || newOptions.functions)
-        combinedOptions.functions = Object.assign(Object.assign({}, origOptions.functions), newOptions.functions);
+        combinedOptions.functions = __assign(__assign({}, origOptions.functions), newOptions.functions);
     if (origOptions.headers || newOptions.headers)
-        combinedOptions.headers = Object.assign(Object.assign({}, origOptions.headers), newOptions.headers);
+        combinedOptions.headers = __assign(__assign({}, origOptions.headers), newOptions.headers);
     return combinedOptions;
 };
 exports.mergeOptions = mergeOptions;
 exports.convertOutputMethods = {
-    number: (value) => extractNumber(value),
-    string: (value) => String(value),
-    array: (value) => (Array.isArray(value) ? value : [value]),
-    boolean: (value) => Boolean(value),
-    bool: (value) => Boolean(value),
+    number: function (value) { return extractNumber(value); },
+    string: function (value) { return String(value); },
+    array: function (value) { return (Array.isArray(value) ? value : [value]); },
+    boolean: function (value) { return Boolean(value); },
+    bool: function (value) { return Boolean(value); },
 };
-const errorMessage = (err) => err.message;
+var errorMessage = function (err) { return err.message; };
 exports.errorMessage = errorMessage;
-const extractNumber = (input) => {
+var extractNumber = function (input) {
     if (typeof input !== 'string')
         return Number.isNaN(Number(input)) ? input : Number(input);
-    const pattern = new RegExp(/-?\d*\.?\d+/gm);
-    const numberMatch = input.match(pattern);
+    var pattern = new RegExp(/-?\d*\.?\d+/gm);
+    var numberMatch = input.match(pattern);
     if (!numberMatch)
         return 0;
     return Number(numberMatch[0]);
 };
+var isObject = function (input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+};
+var evaluateObject = function (input, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var newObjectEntries, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!isObject(input))
+                    return [2, input];
+                newObjectEntries = [];
+                Object.entries(input).forEach(function (_a) {
+                    var key = _a[0], value = _a[1];
+                    return newObjectEntries.push(key, (0, evaluate_1.evaluatorFunction)(value, config));
+                });
+                return [4, Promise.all(newObjectEntries)];
+            case 1:
+                result = _a.sent();
+                return [2, (0, _operatorUtils_1.singleArrayToObject)(result)];
+        }
+    });
+}); };
+exports.evaluateObject = evaluateObject;

package/build/index.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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -31,23 +42,55 @@ 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.evaluateExpression = exports.getVersion = void 0;
-const evaluate_1 = require("./evaluate");
-const typeCheck_1 = require("./typeCheck");
-const _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
-const operators = __importStar(require("./operators"));
-const helpers_1 = require("./helpers");
-const pkg = require('../package.json');
-const getVersion = () => pkg.version;
+var evaluate_1 = require("./evaluate");
+var typeCheck_1 = require("./typeCheck");
+var _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
+var operators = __importStar(require("./operators"));
+var helpers_1 = require("./helpers");
+var pkg = require('../package.json');
+var getVersion = function () { return pkg.version; };
 exports.getVersion = getVersion;
-class FigTreeEvaluator {
-    constructor(options = {}) {
-        this.typeChecker = (...args) => {
-            const result = (0, typeCheck_1.typeCheck)(...args);
+var FigTreeEvaluator = (function () {
+    function FigTreeEvaluator(options) {
+        if (options === void 0) { options = {}; }
+        this.typeChecker = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var result = typeCheck_1.typeCheck.apply(void 0, args);
             if (result === true)
                 return;
             throw new Error(result);
@@ -57,25 +100,36 @@ class FigTreeEvaluator {
         this.operators = operators;
         this.operatorAliases = _operatorAliases_json_1.default;
     }
-    evaluate(expression, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentOptions = (0, helpers_1.mergeOptions)(this.options, options);
-            return yield (0, evaluate_1.evaluatorFunction)(expression, {
-                options: currentOptions,
-                operators: this.operators,
-                operatorAliases: this.operatorAliases,
-                typeChecker: currentOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
-                resolvedAliasNodes: {},
+    FigTreeEvaluator.prototype.evaluate = function (expression, options) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var currentOptions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        currentOptions = (0, helpers_1.mergeOptions)(this.options, options);
+                        return [4, (0, evaluate_1.evaluatorFunction)(expression, {
+                                options: currentOptions,
+                                operators: this.operators,
+                                operatorAliases: this.operatorAliases,
+                                typeChecker: currentOptions.skipRuntimeTypeCheck ? function () { } : this.typeChecker,
+                                resolvedAliasNodes: {},
+                            })];
+                    case 1: return [2, _a.sent()];
+                }
             });
         });
-    }
-    getOptions() {
+    };
+    FigTreeEvaluator.prototype.getOptions = function () {
         return this.options;
-    }
-    updateOptions(options) {
-        this.options = Object.assign(Object.assign({}, this.options), options);
-    }
-}
+    };
+    FigTreeEvaluator.prototype.updateOptions = function (options) {
+        this.options = __assign(__assign({}, this.options), options);
+    };
+    return FigTreeEvaluator;
+}());
 exports.default = FigTreeEvaluator;
-const evaluateExpression = (expression, options) => new FigTreeEvaluator(options).evaluate(expression);
+var evaluateExpression = function (expression, options) {
+    return new FigTreeEvaluator(options).evaluate(expression);
+};
 exports.evaluateExpression = evaluateExpression;