fig-tree-evaluator 2.2.0 → 2.2.2

package/build/operators/postRequest.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,32 +19,68 @@ 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.POST = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const getRequest_1 = require("./getRequest");
-const requiredProperties = ['url'];
-const operatorAliases = ['post'];
-const propertyAliases = { endpoint: 'url', outputProperty: 'returnProperty' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const [urlObj, data, returnProperty, headers] = (yield (0, _operatorUtils_1.evaluateArray)([expression.url, expression.parameters, expression.returnProperty, expression.headers], config));
-    const { url, headers: headersObj } = urlObj instanceof Object ? urlObj : { url: urlObj, headers: null };
-    config.typeChecker({ name: 'url', value: url, expectedType: 'string' }, { name: 'headers', value: headersObj, expectedType: ['object', 'null'] }, { name: 'data', value: data, expectedType: ['object', 'undefined'] }, { name: 'returnProperty', value: returnProperty, expectedType: ['string', 'undefined'] });
-    const baseUrl = (_a = config.options.baseEndpoint) !== null && _a !== void 0 ? _a : '';
-    const httpHeaders = Object.assign(Object.assign(Object.assign({}, (_b = config.options) === null || _b === void 0 ? void 0 : _b.headers), headersObj), headers);
-    const response = yield (0, _operatorUtils_1.axiosRequest)({
-        url: (0, _operatorUtils_1.isFullUrl)(url) ? url : (0, _operatorUtils_1.joinUrlParts)(baseUrl, url),
-        data,
-        headers: httpHeaders,
-        method: 'post',
+var _operatorUtils_1 = require("./_operatorUtils");
+var getRequest_1 = require("./getRequest");
+var requiredProperties = ['url'];
+var operatorAliases = ['post'];
+var propertyAliases = { endpoint: 'url', outputProperty: 'returnProperty' };
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, urlObj, data, returnProperty, headers, _b, url, headersObj, baseUrl, httpHeaders, response;
+    var _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)([expression.url, expression.parameters, expression.returnProperty, expression.headers], config)];
+            case 1:
+                _a = (_e.sent()), urlObj = _a[0], data = _a[1], returnProperty = _a[2], headers = _a[3];
+                _b = urlObj instanceof Object ? urlObj : { url: urlObj, headers: null }, url = _b.url, headersObj = _b.headers;
+                config.typeChecker({ name: 'url', value: url, expectedType: 'string' }, { name: 'headers', value: headersObj, expectedType: ['object', 'null'] }, { name: 'data', value: data, expectedType: ['object', 'undefined'] }, { name: 'returnProperty', value: returnProperty, expectedType: ['string', 'undefined'] });
+                baseUrl = (_c = config.options.baseEndpoint) !== null && _c !== void 0 ? _c : '';
+                httpHeaders = __assign(__assign(__assign({}, (_d = config.options) === null || _d === void 0 ? void 0 : _d.headers), headersObj), headers);
+                return [4, (0, _operatorUtils_1.axiosRequest)({
+                        url: (0, _operatorUtils_1.isFullUrl)(url) ? url : (0, _operatorUtils_1.joinUrlParts)(baseUrl, url),
+                        data: data,
+                        headers: httpHeaders,
+                        method: 'post',
+                    })];
+            case 2:
+                response = _e.sent();
+                return [2, (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty)];
+        }
     });
-    return (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty);
-});
+}); };
 exports.POST = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
     parseChildren: getRequest_1.parseChildrenGET,
 };

package/build/operators/regex.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,13 +19,40 @@ 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.REGEX = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const helpers_1 = require("../helpers");
-const requiredProperties = ['testString', 'pattern'];
-const operatorAliases = ['regex', 'patternMatch', 'regexp', 'matchPattern'];
-const propertyAliases = {
+var _operatorUtils_1 = require("./_operatorUtils");
+var helpers_1 = require("../helpers");
+var requiredProperties = ['testString', 'pattern'];
+var operatorAliases = ['regex', 'patternMatch', 'regexp', 'matchPattern'];
+var propertyAliases = {
     string: 'testString',
     value: 'testString',
     regex: 'pattern',
@@ -22,25 +60,33 @@ const propertyAliases = {
     regExp: 'pattern',
     re: 'pattern',
 };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const [testString, pattern] = (yield (0, _operatorUtils_1.evaluateArray)([expression.testString, expression.pattern], config));
-    config.typeChecker({ name: 'testString', value: testString, expectedType: 'string' }, { name: 'pattern', value: pattern, expectedType: 'string' });
-    try {
-        const re = new RegExp(pattern);
-        return re.test(testString);
-    }
-    catch (err) {
-        throw new Error('Regex error:' + (0, helpers_1.errorMessage)(err));
-    }
-});
-const parseChildren = (expression) => {
-    const [testString, pattern] = expression.children;
-    return Object.assign(Object.assign({}, expression), { testString, pattern });
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, testString, pattern, re;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)([expression.testString, expression.pattern], config)];
+            case 1:
+                _a = (_b.sent()), testString = _a[0], pattern = _a[1];
+                config.typeChecker({ name: 'testString', value: testString, expectedType: 'string' }, { name: 'pattern', value: pattern, expectedType: 'string' });
+                try {
+                    re = new RegExp(pattern);
+                    return [2, re.test(testString)];
+                }
+                catch (err) {
+                    throw new Error('Regex error:' + (0, helpers_1.errorMessage)(err));
+                }
+                return [2];
+        }
+    });
+}); };
+var parseChildren = function (expression) {
+    var _a = expression.children, testString = _a[0], pattern = _a[1];
+    return __assign(__assign({}, expression), { testString: testString, pattern: pattern });
 };
 exports.REGEX = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
+    parseChildren: parseChildren,
 };

package/build/operators/split.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,12 +19,39 @@ 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.SPLIT = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['value'];
-const operatorAliases = ['split', 'arraySplit'];
-const propertyAliases = {
+var _operatorUtils_1 = require("./_operatorUtils");
+var requiredProperties = ['value'];
+var operatorAliases = ['split', 'arraySplit'];
+var propertyAliases = {
     string: 'value',
     separator: 'delimiter',
     trim: 'trimWhiteSpace',
@@ -21,31 +59,38 @@ const propertyAliases = {
     removeTrailing: 'excludeTrailing',
     excludeTrailingDelimiter: 'excludeTrailing',
 };
-const DEFAULT_DELIMITER = ' ';
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const [value, delimiter, trimWhiteSpace, excludeTrailing] = (yield (0, _operatorUtils_1.evaluateArray)([
-        expression.value,
-        (_a = expression.delimiter) !== null && _a !== void 0 ? _a : DEFAULT_DELIMITER,
-        (_b = expression.trimWhiteSpace) !== null && _b !== void 0 ? _b : true,
-        (_c = expression.excludeTrailing) !== null && _c !== void 0 ? _c : true,
-    ], config));
-    config.typeChecker({ name: 'value', value: value, expectedType: 'string' }, { name: 'delimiter', value: delimiter, expectedType: 'string' }, { name: 'trimWhiteSpace', value: trimWhiteSpace, expectedType: 'boolean' }, { name: 'excludeTrailing', value: excludeTrailing, expectedType: 'boolean' });
-    let splitValues = value.split(delimiter);
-    if (trimWhiteSpace)
-        splitValues = splitValues.map((val) => val.trim());
-    if (excludeTrailing && splitValues[splitValues.length - 1] === '')
-        splitValues.pop();
-    return splitValues;
-});
-const parseChildren = (expression) => {
-    const [value, delimiter = DEFAULT_DELIMITER] = expression.children;
-    return Object.assign(Object.assign({}, expression), { value, delimiter });
+var DEFAULT_DELIMITER = ' ';
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, value, delimiter, trimWhiteSpace, excludeTrailing, splitValues;
+    var _b, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)([
+                    expression.value,
+                    (_b = expression.delimiter) !== null && _b !== void 0 ? _b : DEFAULT_DELIMITER,
+                    (_c = expression.trimWhiteSpace) !== null && _c !== void 0 ? _c : true,
+                    (_d = expression.excludeTrailing) !== null && _d !== void 0 ? _d : true,
+                ], config)];
+            case 1:
+                _a = (_e.sent()), value = _a[0], delimiter = _a[1], trimWhiteSpace = _a[2], excludeTrailing = _a[3];
+                config.typeChecker({ name: 'value', value: value, expectedType: 'string' }, { name: 'delimiter', value: delimiter, expectedType: 'string' }, { name: 'trimWhiteSpace', value: trimWhiteSpace, expectedType: 'boolean' }, { name: 'excludeTrailing', value: excludeTrailing, expectedType: 'boolean' });
+                splitValues = value.split(delimiter);
+                if (trimWhiteSpace)
+                    splitValues = splitValues.map(function (val) { return val.trim(); });
+                if (excludeTrailing && splitValues[splitValues.length - 1] === '')
+                    splitValues.pop();
+                return [2, splitValues];
+        }
+    });
+}); };
+var parseChildren = function (expression) {
+    var _a = expression.children, value = _a[0], _b = _a[1], delimiter = _b === void 0 ? DEFAULT_DELIMITER : _b;
+    return __assign(__assign({}, expression), { value: value, delimiter: delimiter });
 };
 exports.SPLIT = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
+    parseChildren: parseChildren,
 };

package/build/operators/stringSubstitution.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,33 +19,76 @@ 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));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STRING_SUBSTITUTION = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['string', 'substitutions'];
-const operatorAliases = ['stringSubstitution', 'substitute', 'stringSub', 'replace'];
-const propertyAliases = { replacements: 'substitutions' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const [string, ...substitutions] = (yield (0, _operatorUtils_1.evaluateArray)([expression.string, ...expression.substitutions], config));
-    config.typeChecker({ name: 'string', value: string, expectedType: 'string' });
-    config.typeChecker({ name: 'substitutions', value: substitutions, expectedType: 'array' });
-    const regex = /(%[\d]+)/g;
-    const parameters = (string.match(regex) || []).sort((a, b) => Number(a.slice(1)) - Number(b.slice(1)));
-    const uniqueParameters = new Set(parameters);
-    const replacementsObj = (0, _operatorUtils_1.zipArraysToObject)(Array.from(uniqueParameters), substitutions);
-    return string
-        .split(regex)
-        .map((fragment) => (fragment in replacementsObj ? replacementsObj[fragment] : fragment))
-        .join('');
-});
-const parseChildren = (expression) => {
-    const [string, ...substitutions] = expression.children;
-    return Object.assign(Object.assign({}, expression), { string, substitutions });
+var _operatorUtils_1 = require("./_operatorUtils");
+var requiredProperties = ['string', 'substitutions'];
+var operatorAliases = ['stringSubstitution', 'substitute', 'stringSub', 'replace'];
+var propertyAliases = { replacements: 'substitutions' };
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, string, substitutions, regex, parameters, uniqueParameters, replacementsObj;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)(__spreadArray([expression.string], expression.substitutions, true), config)];
+            case 1:
+                _a = (_b.sent()), string = _a[0], substitutions = _a.slice(1);
+                config.typeChecker({ name: 'string', value: string, expectedType: 'string' });
+                config.typeChecker({ name: 'substitutions', value: substitutions, expectedType: 'array' });
+                regex = /(%[\d]+)/g;
+                parameters = (string.match(regex) || []).sort(function (a, b) { return Number(a.slice(1)) - Number(b.slice(1)); });
+                uniqueParameters = new Set(parameters);
+                replacementsObj = (0, _operatorUtils_1.zipArraysToObject)(Array.from(uniqueParameters), substitutions);
+                return [2, string
+                        .split(regex)
+                        .map(function (fragment) { return (fragment in replacementsObj ? replacementsObj[fragment] : fragment); })
+                        .join('')];
+        }
+    });
+}); };
+var parseChildren = function (expression) {
+    var _a = expression.children, string = _a[0], substitutions = _a.slice(1);
+    return __assign(__assign({}, expression), { string: string, substitutions: substitutions });
 };
 exports.STRING_SUBSTITUTION = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
+    parseChildren: parseChildren,
 };

package/build/operators/subtract.js

@@ -8,25 +8,59 @@ 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.SUBTRACT = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = [];
-const operatorAliases = ['-', 'subtract', 'minus', 'takeaway'];
-const propertyAliases = { subtractFrom: 'from' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+var logicalAnd_1 = require("./logicalAnd");
+var _operatorUtils_1 = require("./_operatorUtils");
+var requiredProperties = [];
+var operatorAliases = ['-', 'subtract', 'minus', 'takeaway'];
+var propertyAliases = { subtractFrom: 'from' };
+var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
+    var values;
     var _a;
-    const values = (yield (0, _operatorUtils_1.evaluateArray)((_a = expression.values) !== null && _a !== void 0 ? _a : [expression.from, expression.subtract], config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    if (values.length < 2)
-        throw new Error('- Not enough values provided');
-    return values[0] - values[1];
-});
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)((_a = expression.values) !== null && _a !== void 0 ? _a : [expression.from, expression.subtract], config)];
+            case 1:
+                values = (_b.sent());
+                config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+                if (values.length < 2)
+                    throw new Error('- Not enough values provided');
+                return [2, values[0] - values[1]];
+        }
+    });
+}); };
 exports.SUBTRACT = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
+    requiredProperties: requiredProperties,
+    operatorAliases: operatorAliases,
+    propertyAliases: propertyAliases,
+    evaluate: evaluate,
     parseChildren: logicalAnd_1.parseChildren,
 };

package/build/typeCheck.js

@@ -1,48 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typeCheck = void 0;
-const helpers_1 = require("./helpers");
-const typeCheckItem = ({ value, name, not = false, expectedType, }) => {
-    let result;
+var helpers_1 = require("./helpers");
+var typeCheckItem = function (_a) {
+    var value = _a.value, name = _a.name, _b = _a.not, not = _b === void 0 ? false : _b, expectedType = _a.expectedType;
+    var result;
     if (Array.isArray(expectedType)) {
-        result = expectedType.some((type) => typeCheckItem({ value, name, expectedType: type }) === true);
+        result = expectedType.some(function (type) { return typeCheckItem({ value: value, name: name, expectedType: type }) === true; });
         if (not)
             result = !result;
         return result ? true : makeErrorString(name, value, expectedType.join('|'), not);
     }
     else {
-        const checker = typeCheckMap[expectedType];
+        var checker = typeCheckMap[expectedType];
         result = checker(value);
         if (not)
             result = !result;
         return result ? true : makeErrorString(name, value, expectedType, not);
     }
 };
-const typeCheck = (...args) => {
-    const errorStrings = [];
-    args.forEach((item) => {
-        const result = typeCheckItem(item);
+var typeCheck = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var errorStrings = [];
+    args.forEach(function (item) {
+        var result = typeCheckItem(item);
         if (result !== true)
             errorStrings.push(result);
     });
     return errorStrings.length > 0 ? errorStrings.join('\n') : true;
 };
 exports.typeCheck = typeCheck;
-const typeCheckMap = {
-    string: (value) => typeof value === 'string',
-    number: (value) => typeof value === 'number',
-    boolean: (value) => typeof value === 'boolean',
-    array: (value) => Array.isArray(value),
-    undefined: (value) => value === undefined,
-    null: (value) => value === null,
-    object: (value) => typeof value === 'object' && !Array.isArray(value) && value !== null,
+var typeCheckMap = {
+    string: function (value) { return typeof value === 'string'; },
+    number: function (value) { return typeof value === 'number'; },
+    boolean: function (value) { return typeof value === 'boolean'; },
+    array: function (value) { return Array.isArray(value); },
+    undefined: function (value) { return value === undefined; },
+    null: function (value) { return value === null; },
+    object: function (value) { return typeof value === 'object' && !Array.isArray(value) && value !== null; },
 };
-const makeErrorString = (name, value, type, not) => {
+var makeErrorString = function (name, value, type, not) {
     if (name !== undefined)
-        return `- Property "${name}" (value: ${stringifyValue(value)}) is not of type: ${not ? `!(${type})` : type}`;
-    return `- ${stringifyValue(value)} is not of type: ${not ? `!(${type})` : type}`;
+        return "- Property \"".concat(name, "\" (value: ").concat(stringifyValue(value), ") is not of type: ").concat(not ? "!(".concat(type, ")") : type);
+    return "- ".concat(stringifyValue(value), " is not of type: ").concat(not ? "!(".concat(type, ")") : type);
 };
-const stringifyValue = (value) => {
-    const stringValue = value === undefined || Number.isNaN(value) ? String(value) : JSON.stringify(value);
+var stringifyValue = function (value) {
+    var stringValue = value === undefined || Number.isNaN(value) ? String(value) : JSON.stringify(value);
     return (0, helpers_1.truncateString)(stringValue, 50);
 };

package/build/types.d.ts

@@ -20,6 +20,7 @@ export interface FigTreeOptions {
     nullEqualsUndefined?: boolean;
     allowJSONStringInput?: boolean;
     skipRuntimeTypeCheck?: boolean;
+    evaluateFullObject?: boolean;
 }
 export interface FigTreeConfig {
     options: FigTreeOptions;