fig-tree-evaluator 2.4.1 → 2.4.3

package/README.md

@@ -1500,8 +1500,9 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 
 ## Changelog
 
-*Trivial upgrades (e.g. documentation only) not included*
+*Trivial upgrades (e.g. documentation, small re-factors, types, etc.) not included*
 
+- **v2.4.1**: Small bug fix for Fragments edge case
 - **v2.4.0**: Implement [Fragments](#fragments) (#74)
 - **v2.3.2**: Bug fix: alias nodes not working with `evaluateFullObject` (#72)
 - **v2.3.0**: Implement [caching/memoization](#caching-memoization) (#68)

package/build/FigTreeEvaluator.d.ts

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

package/build/FigTreeEvaluator.js

@@ -0,0 +1,134 @@
+"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 __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 = void 0;
+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 cache_1 = __importDefault(require("./cache"));
+var pkg = require('../package.json');
+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);
+        };
+        this.getVersion = function () { return pkg.version; };
+        this.options = standardiseOptionNames(options);
+        this.operators = operators;
+        this.operatorAliases = _operatorAliases_json_1.default;
+        this.cache = new cache_1.default(options.maxCacheSize);
+    }
+    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, standardiseOptionNames(options));
+                        if (currentOptions.maxCacheSize && currentOptions.maxCacheSize !== this.cache.getMax())
+                            this.cache.setMax(currentOptions.maxCacheSize);
+                        return [4, (0, evaluate_1.evaluatorFunction)(expression, {
+                                options: currentOptions,
+                                operators: this.operators,
+                                operatorAliases: this.operatorAliases,
+                                typeChecker: currentOptions.skipRuntimeTypeCheck ? function () { } : this.typeChecker,
+                                resolvedAliasNodes: {},
+                                cache: this.cache,
+                            })];
+                    case 1: return [2, _a.sent()];
+                }
+            });
+        });
+    };
+    FigTreeEvaluator.prototype.getOptions = function () {
+        return this.options;
+    };
+    FigTreeEvaluator.prototype.updateOptions = function (options) {
+        this.options = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
+    };
+    return FigTreeEvaluator;
+}());
+exports.default = FigTreeEvaluator;
+var evaluateExpression = function (expression, options) {
+    return new FigTreeEvaluator(options).evaluate(expression);
+};
+exports.evaluateExpression = evaluateExpression;
+var standardiseOptionNames = function (options) {
+    if ('objects' in options) {
+        options.data = options.objects;
+        delete options.objects;
+    }
+    return options;
+};

package/build/index.d.ts

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

package/build/index.js

@@ -22,113 +22,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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 __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 = void 0;
-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 cache_1 = __importDefault(require("./cache"));
-var pkg = require('../package.json');
-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);
-        };
-        this.getVersion = function () { return pkg.version; };
-        this.options = standardiseOptionNames(options);
-        this.operators = operators;
-        this.operatorAliases = _operatorAliases_json_1.default;
-        this.cache = new cache_1.default(options.maxCacheSize);
-    }
-    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, standardiseOptionNames(options));
-                        if (currentOptions.maxCacheSize && currentOptions.maxCacheSize !== this.cache.getMax())
-                            this.cache.setMax(currentOptions.maxCacheSize);
-                        return [4, (0, evaluate_1.evaluatorFunction)(expression, {
-                                options: currentOptions,
-                                operators: this.operators,
-                                operatorAliases: this.operatorAliases,
-                                typeChecker: currentOptions.skipRuntimeTypeCheck ? function () { } : this.typeChecker,
-                                resolvedAliasNodes: {},
-                                cache: this.cache,
-                            })];
-                    case 1: return [2, _a.sent()];
-                }
-            });
-        });
-    };
-    FigTreeEvaluator.prototype.getOptions = function () {
-        return this.options;
-    };
-    FigTreeEvaluator.prototype.updateOptions = function (options) {
-        this.options = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
-    };
-    return FigTreeEvaluator;
-}());
-exports.default = FigTreeEvaluator;
-var evaluateExpression = function (expression, options) {
-    return new FigTreeEvaluator(options).evaluate(expression);
-};
-exports.evaluateExpression = evaluateExpression;
-var standardiseOptionNames = function (options) {
-    if ('objects' in options) {
-        options.data = options.objects;
-        delete options.objects;
-    }
-    return options;
-};
+var FigTreeEvaluator_1 = __importStar(require("./FigTreeEvaluator"));
+Object.defineProperty(exports, "evaluateExpression", { enumerable: true, get: function () { return FigTreeEvaluator_1.evaluateExpression; } });
+exports.default = FigTreeEvaluator_1.default;

package/build/operators/divide.d.ts

@@ -4,8 +4,9 @@ interface DivisionNodeWithProps extends BaseOperatorNode {
     dividend: EvaluatorNode;
     divisor: EvaluatorNode;
 }
+type DivisionOutput = 'quotient' | 'remainder';
 export type DivisionNode = BasicExtendedNode & DivisionNodeWithProps & {
-    output?: 'quotient' | 'remainder';
+    output?: DivisionOutput;
 };
 export declare const DIVIDE: OperatorObject;
 export {};

package/build/operators/divide.js

@@ -39,26 +39,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DIVIDE = void 0;
 var logicalAnd_1 = require("./logicalAnd");
 var _operatorUtils_1 = require("./_operatorUtils");
-var __1 = require("..");
 var requiredProperties = [];
 var operatorAliases = ['/', 'divide', '÷'];
 var propertyAliases = { divide: 'dividend', by: 'divisor', divideBy: 'divisor' };
 var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var values;
-    var _a;
-    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.dividend, expression.divisor], config)];
+    var _a, values, output;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)([(_b = expression.values) !== null && _b !== void 0 ? _b : [expression.dividend, expression.divisor], expression.output], config)];
             case 1:
-                values = (_b.sent());
-                config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+                _a = (_c.sent()), values = _a[0], output = _a[1];
+                config.typeChecker({ name: 'values', value: values, expectedType: 'array' }, { name: 'output', value: output, expectedType: ['string', 'undefined'] });
                 if (values.length < 2)
                     throw new Error('- Not enough values provided');
                 if (!values[1])
                     throw new Error('Division by zero!');
-                return [4, (0, __1.evaluateExpression)(expression.output)];
-            case 2:
-                switch (_b.sent()) {
+                switch (output) {
                     case 'quotient':
                         return [2, Math.floor(values[0] / values[1])];
                     case 'remainder':

package/build/operators/index.d.ts

@@ -1,5 +1,5 @@
 export * from './logicalOr';
-export * from './logicalAnd';
+export { AND, type BasicExtendedNode } from './logicalAnd';
 export * from './equal';
 export * from './notEqual';
 export * from './plus';
@@ -16,7 +16,7 @@ export * from './count';
 export * from './split';
 export * from './pgSQL';
 export * from './graphQL';
-export * from './getRequest';
+export { GET, type APINode } from './getRequest';
 export * from './postRequest';
 export * from './buildObject';
 export * from './match';

package/build/operators/index.js

@@ -14,8 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = exports.AND = void 0;
 __exportStar(require("./logicalOr"), exports);
-__exportStar(require("./logicalAnd"), exports);
+var logicalAnd_1 = require("./logicalAnd");
+Object.defineProperty(exports, "AND", { enumerable: true, get: function () { return logicalAnd_1.AND; } });
 __exportStar(require("./equal"), exports);
 __exportStar(require("./notEqual"), exports);
 __exportStar(require("./plus"), exports);
@@ -32,7 +34,8 @@ __exportStar(require("./count"), exports);
 __exportStar(require("./split"), exports);
 __exportStar(require("./pgSQL"), exports);
 __exportStar(require("./graphQL"), exports);
-__exportStar(require("./getRequest"), exports);
+var getRequest_1 = require("./getRequest");
+Object.defineProperty(exports, "GET", { enumerable: true, get: function () { return getRequest_1.GET; } });
 __exportStar(require("./postRequest"), exports);
 __exportStar(require("./buildObject"), exports);
 __exportStar(require("./match"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fig-tree-evaluator",
-  "version": "2.4.1",
+  "version": "2.4.3",
   "description": "Module to evaluate JSON-structured expression trees",
   "main": "build/index.js",
   "types": "build/index.d.ts",