fig-tree-evaluator 2.2.1 → 2.2.3

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

@@ -6,6 +6,7 @@ export type GenericObject = {
     [key: string]: any;
 };
 export interface FigTreeOptions {
+    data?: GenericObject;
     objects?: GenericObject;
     functions?: {
         [key: string]: Function;
@@ -20,6 +21,7 @@ export interface FigTreeOptions {
     nullEqualsUndefined?: boolean;
     allowJSONStringInput?: boolean;
     skipRuntimeTypeCheck?: boolean;
+    evaluateFullObject?: boolean;
 }
 export interface FigTreeConfig {
     options: FigTreeOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fig-tree-evaluator",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "Module to evaluate JSON-structured expression trees",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -28,7 +28,7 @@
     "setup": "yarn install && cd demo && yarn install",
     "test": "jest",
     "generate": "ts-node ./codegen/buildOperatorAliasReference.ts",
-    "build": "yarn generate && rimraf ./lib && tsc",
+    "build": "yarn generate && rimraf ./build && tsc",
     "dev": "cp -n src/dev/playground_example.ts src/dev/playground.ts || ts-node src/dev/playground.ts",
     "demo": "cd demo && yarn start",
     "prepublish": "yarn build"

package/build/FigTreeEvaluator.d.ts

@@ -1,13 +0,0 @@
-import { EvaluatorNode, FigTreeOptions } from './types';
-declare class FigTreeEvaluator {
-    private options;
-    private operators;
-    private operatorAliases;
-    constructor(options?: FigTreeOptions);
-    private typeChecker;
-    evaluate(expression: EvaluatorNode, options?: FigTreeOptions): Promise<import("./types").EvaluatorOutput>;
-    getOptions(): FigTreeOptions;
-    updateOptions(options: FigTreeOptions): void;
-}
-export default FigTreeEvaluator;
-export declare const evaluateExpression: (expression: EvaluatorNode, options?: FigTreeOptions) => Promise<import("./types").EvaluatorOutput>;

package/build/FigTreeEvaluator.js

@@ -1,75 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateExpression = 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"));
-class FigTreeEvaluator {
-    constructor(options = {}) {
-        this.typeChecker = (...args) => {
-            const result = (0, typeCheck_1.typeCheck)(...args);
-            if (result === true)
-                return;
-            throw new Error(result);
-        };
-        this.options = options;
-        this.operators = operators;
-        this.operatorAliases = _operatorAliases_json_1.default;
-    }
-    evaluate(expression, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instanceOptions = Object.assign(Object.assign({}, this.options), options);
-            return yield (0, evaluate_1.evaluatorFunction)(expression, {
-                options: instanceOptions,
-                operators: this.operators,
-                operatorAliases: this.operatorAliases,
-                typeChecker: instanceOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
-            });
-        });
-    }
-    getOptions() {
-        return this.options;
-    }
-    updateOptions(options) {
-        this.options = Object.assign(Object.assign({}, this.options), options);
-    }
-}
-exports.default = FigTreeEvaluator;
-const evaluateExpression = (expression, options) => new FigTreeEvaluator(options).evaluate(expression);
-exports.evaluateExpression = evaluateExpression;

package/build/evaluator.d.ts

@@ -1,13 +0,0 @@
-import { EvaluatorNode, EvaluatorOptions } from './types';
-declare class ExpressionEvaluator {
-    private options;
-    private operators;
-    private operatorAliases;
-    constructor(options?: EvaluatorOptions);
-    private typeChecker;
-    evaluate(expression: EvaluatorNode, options?: EvaluatorOptions): Promise<import("./types").EvaluatorOutput>;
-    getOptions(): EvaluatorOptions;
-    updateOptions(options: EvaluatorOptions): void;
-}
-export default ExpressionEvaluator;
-export declare const evaluateExpression: (expression: EvaluatorNode, options?: EvaluatorOptions) => Promise<import("./types").EvaluatorOutput>;

package/build/evaluator.js

@@ -1,75 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateExpression = 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"));
-class ExpressionEvaluator {
-    constructor(options = {}) {
-        this.typeChecker = (...args) => {
-            const result = (0, typeCheck_1.typeCheck)(...args);
-            if (result === true)
-                return;
-            throw new Error(result);
-        };
-        this.options = options;
-        this.operators = operators;
-        this.operatorAliases = _operatorAliases_json_1.default;
-    }
-    evaluate(expression, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instanceOptions = Object.assign(Object.assign({}, this.options), options);
-            return yield (0, evaluate_1.evaluatorFunction)(expression, {
-                options: instanceOptions,
-                operators: this.operators,
-                operatorAliases: this.operatorAliases,
-                typeChecker: instanceOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
-            });
-        });
-    }
-    getOptions() {
-        return this.options;
-    }
-    updateOptions(options) {
-        this.options = Object.assign(Object.assign({}, this.options), options);
-    }
-}
-exports.default = ExpressionEvaluator;
-const evaluateExpression = (expression, options) => new ExpressionEvaluator(options).evaluate(expression);
-exports.evaluateExpression = evaluateExpression;

package/build/operators/objectFunctions.d.ts

@@ -1,9 +0,0 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["functionPath"];
-export declare type ObjFuncNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode & {
-    args: EvaluatorNode[];
-};
-export declare const OBJECT_FUNCTIONS: OperatorObject;
-export {};

package/build/operators/objectFunctions.js

@@ -1,38 +0,0 @@
-"use strict";
-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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OBJECT_FUNCTIONS = void 0;
-const object_property_extractor_1 = __importDefault(require("object-property-extractor"));
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['functionPath'];
-const operatorAliases = ['objectFunctions', 'function', 'functions', 'runFunction'];
-const propertyAliases = { functionsPath: 'functionPath', arguments: 'args', variables: 'args' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const [functionPath, ...args] = (yield _operatorUtils_1.evaluateArray([expression.functionPath, ...expression.args], config));
-    const inputObject = (_b = (_a = config.options) === null || _a === void 0 ? void 0 : _a.objects) !== null && _b !== void 0 ? _b : {};
-    const func = object_property_extractor_1.default(inputObject, functionPath);
-    return yield func(...args);
-});
-const parseChildren = (expression) => {
-    const [functionPath, ...args] = expression.children;
-    return Object.assign(Object.assign({}, expression), { functionPath, args });
-};
-exports.OBJECT_FUNCTIONS = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
-};