fig-tree-evaluator 2.7.0 → 2.8.0

package/build/operators/index.js

@@ -14,30 +14,27 @@ 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);
-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);
-__exportStar(require("./subtract"), exports);
-__exportStar(require("./multiply"), exports);
-__exportStar(require("./divide"), exports);
-__exportStar(require("./greaterThan"), exports);
-__exportStar(require("./lessThan"), exports);
-__exportStar(require("./conditional"), exports);
-__exportStar(require("./regex"), exports);
-__exportStar(require("./objectProperties"), exports);
-__exportStar(require("./stringSubstitution"), exports);
-__exportStar(require("./count"), exports);
-__exportStar(require("./split"), exports);
-__exportStar(require("./pgSQL"), exports);
-__exportStar(require("./graphQL"), 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);
-__exportStar(require("./customFunctions"), exports);
-__exportStar(require("./passThru"), exports);
+__exportStar(require("./AND"), exports);
+__exportStar(require("./OR"), exports);
+__exportStar(require("./EQUAL"), exports);
+__exportStar(require("./NOT_EQUAL"), exports);
+__exportStar(require("./PLUS"), exports);
+__exportStar(require("./SUBTRACT"), exports);
+__exportStar(require("./MULTIPLY"), exports);
+__exportStar(require("./DIVIDE"), exports);
+__exportStar(require("./GREATER_THAN"), exports);
+__exportStar(require("./LESS_THAN"), exports);
+__exportStar(require("./CONDITIONAL"), exports);
+__exportStar(require("./REGEX"), exports);
+__exportStar(require("./OBJECT_PROPERTIES"), exports);
+__exportStar(require("./STRING_SUBSTITUTION"), exports);
+__exportStar(require("./COUNT"), exports);
+__exportStar(require("./SPLIT"), exports);
+__exportStar(require("./PG_SQL"), exports);
+__exportStar(require("./GRAPHQL"), exports);
+__exportStar(require("./GET"), exports);
+__exportStar(require("./POST"), exports);
+__exportStar(require("./BUILD_OBJECT"), exports);
+__exportStar(require("./MATCH"), exports);
+__exportStar(require("./CUSTOM_FUNCTIONS"), exports);
+__exportStar(require("./PASSTHRU"), exports);

package/build/shorthandSyntax.d.ts

@@ -0,0 +1,2 @@
+import { EvaluatorNode, Fragments, FragmentNode } from './types';
+export declare const preProcessShorthand: (expression: EvaluatorNode, fragments?: Fragments, useShorthand?: boolean) => EvaluatorNode | FragmentNode;

package/build/shorthandSyntax.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preProcessShorthand = void 0;
+const helpers_1 = require("./helpers");
+const _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
+const operatorAliases = _operatorAliases_json_1.default;
+const functionStringRegex = /(\$[^\(\)]+)\((.*)\)/;
+const preProcessShorthand = (expression, fragments = {}, useShorthand = true) => {
+    if (!useShorthand)
+        return expression;
+    if (typeof expression === 'string')
+        return processString(expression, fragments);
+    if ((0, helpers_1.isObject)(expression))
+        return processObject(expression, fragments);
+    return expression;
+};
+exports.preProcessShorthand = preProcessShorthand;
+const processString = (expString, fragments) => {
+    const match = functionStringRegex.exec(expString);
+    if (!match)
+        return expString;
+    const method = match[1].trim();
+    const params = match[2].split(',').map((p) => (0, exports.preProcessShorthand)(p.trim(), fragments));
+    return buildNodeElements(method, params, fragments);
+};
+const processObject = (expObject, fragments) => {
+    if ((0, helpers_1.isOperatorNode)(expObject) || (0, helpers_1.isFragmentNode)(expObject))
+        return expObject;
+    const keyVals = Object.entries(expObject);
+    const aliasParams = keyVals.filter(([key]) => (0, helpers_1.isAliasString)(key));
+    const otherParams = keyVals.filter(([key]) => !(0, helpers_1.isAliasString)(key));
+    const newKeyVals = aliasParams.reduce((accObj, [alias, params]) => {
+        accObj = Object.assign(Object.assign({}, accObj), buildNodeElements(alias, params, fragments));
+        return accObj;
+    }, {});
+    return Object.assign(Object.assign({}, newKeyVals), Object.fromEntries(otherParams));
+};
+const buildNodeElements = (alias, params, fragments) => {
+    const aliasName = alias.slice(1);
+    const operator = (0, helpers_1.getOperatorName)(aliasName, operatorAliases);
+    if (operator) {
+        if (Array.isArray(params))
+            return { operator, children: params };
+        if ((0, helpers_1.isObject)(params) && !Object.keys(params).some((key) => (0, helpers_1.isAliasString)(key)))
+            return Object.assign({ operator }, params);
+        return { operator, children: [params] };
+    }
+    if (aliasName in fragments) {
+        return { fragment: aliasName, parameters: Object.assign({}, params) };
+    }
+    return { [alias]: params };
+};

package/build/typeCheck.d.ts

@@ -1,4 +1,4 @@
-export type ExpectedType = 'string' | 'boolean' | 'number' | 'array' | 'undefined' | 'null' | 'object';
+export type ExpectedType = 'string' | 'boolean' | 'number' | 'array' | 'undefined' | 'null' | 'object' | 'any';
 export type TypeCheckInput = {
     value: unknown;
     name?: string;

package/build/typeCheck.js

@@ -36,6 +36,7 @@ const typeCheckMap = {
     undefined: (value) => value === undefined,
     null: (value) => value === null,
     object: (value) => typeof value === 'object' && !Array.isArray(value) && value !== null,
+    any: (value) => value !== undefined,
 };
 const makeErrorString = (name, value, type, not) => {
     if (name !== undefined)

package/build/types.d.ts

@@ -1,7 +1,7 @@
 import FigTreeCache from './cache';
 import { BasicExtendedNode, SubtractionNode, DivisionNode, ComparatorNode, ConditionalNode, RegexNode, StringSubNode, SplitNode, ObjPropNode, APINode, PGNode, GraphQLNode, BuildObjectNode, MatchNode, FunctionNode, PassThruNode, PGConnection, GraphQLConnection } from './operators';
 import operatorAliases from './operators/_operatorAliases.json';
-import { TypeCheckInput } from './typeCheck';
+import { ExpectedType, TypeCheckInput } from './typeCheck';
 export declare const Operators: readonly ["AND", "OR", "EQUAL", "NOT_EQUAL", "PLUS", "SUBTRACT", "MULTIPLY", "DIVIDE", "GREATER_THAN", "LESS_THAN", "CONDITIONAL", "REGEX", "OBJECT_PROPERTIES", "STRING_SUBSTITUTION", "SPLIT", "COUNT", "GET", "POST", "PG_SQL", "GRAPHQL", "BUILD_OBJECT", "MATCH", "CUSTOM_FUNCTIONS", "PASSTHRU"];
 export type Operator = typeof Operators[number];
 export type GenericObject = {
@@ -9,15 +9,13 @@ export type GenericObject = {
 };
 export type OperatorAlias = keyof typeof operatorAliases;
 export type OperatorAliases = Record<OperatorAlias, Operator>;
+export type Fragments = Record<string, Fragment>;
+export type Functions = Record<string, Function>;
 export interface FigTreeOptions {
     data?: GenericObject;
     objects?: GenericObject;
-    functions?: {
-        [key: string]: Function;
-    };
-    fragments?: {
-        [key: string]: EvaluatorNode;
-    };
+    functions?: Functions;
+    fragments?: Fragments;
     pgConnection?: PGConnection;
     graphQLConnection?: GraphQLConnection;
     baseEndpoint?: string;
@@ -27,6 +25,7 @@ export interface FigTreeOptions {
     returnErrorAsString?: boolean;
     nullEqualsUndefined?: boolean;
     allowJSONStringInput?: boolean;
+    noShorthand?: boolean;
     skipRuntimeTypeCheck?: boolean;
     evaluateFullObject?: boolean;
     excludeOperators?: string[];
@@ -60,19 +59,38 @@ export interface FragmentNode {
     };
     [key: string]: EvaluatorNode;
 }
+export type Fragment = (EvaluatorNode & {
+    metadata?: {
+        description?: string;
+        parameters?: Record<string, {
+            type: string | string[];
+            required: boolean;
+        }>;
+    };
+}) | null;
 export type CombinedOperatorNode = BaseOperatorNode & BasicExtendedNode & SubtractionNode & DivisionNode & ComparatorNode & ConditionalNode & RegexNode & StringSubNode & SplitNode & ObjPropNode & APINode & PGNode & GraphQLNode & BuildObjectNode & MatchNode & FunctionNode & PassThruNode;
-export type OperatorNodeUnion = BasicExtendedNode | SubtractionNode | DivisionNode | ComparatorNode | ConditionalNode | RegexNode | StringSubNode | SplitNode | ObjPropNode | PGNode | GraphQLNode | APINode | BuildObjectNode | MatchNode | FunctionNode | PassThruNode;
+export type OperatorNodeUnion = BasicExtendedNode | SubtractionNode | DivisionNode | ComparatorNode | ConditionalNode | RegexNode | StringSubNode | SplitNode | ObjPropNode | APINode | PGNode | GraphQLNode | BuildObjectNode | MatchNode | FunctionNode | PassThruNode;
 export type EvaluatorOutput = string | boolean | number | GenericObject | null | undefined | any[];
 export type EvaluatorNode = CombinedOperatorNode | FragmentNode | EvaluatorOutput;
 export type OperatorObject = {
     requiredProperties: readonly string[];
-    operatorAliases: string[];
-    propertyAliases: {
-        [key: string]: string;
-    };
+    propertyAliases: Record<string, string>;
+    operatorData: OperatorData;
     evaluate: (expression: CombinedOperatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;
     parseChildren: (expression: CombinedOperatorNode, config: FigTreeConfig) => OperatorNodeUnion | Promise<OperatorNodeUnion>;
 };
 export type OperatorReference = {
     [key in Operator]: OperatorObject;
 };
+export type Parameter = {
+    name: string;
+    description: string;
+    aliases: string[];
+    required: boolean;
+    type: ExpectedType | ExpectedType[];
+};
+export interface OperatorData {
+    description: string;
+    aliases: string[];
+    parameters: Parameter[];
+}

package/package.json

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

package/build/operators/count.d.ts

@@ -1,2 +0,0 @@
-import { OperatorObject } from '../types';
-export declare const COUNT: OperatorObject;

package/build/operators/count.js

@@ -1,29 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COUNT = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['values'];
-const operatorAliases = ['count', 'length'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = yield (0, _operatorUtils_1.evaluateArray)(expression.values, config);
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.length;
-});
-exports.COUNT = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
-};

package/build/operators/divide.js

@@ -1,41 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIVIDE = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = [];
-const operatorAliases = ['/', 'divide', '÷'];
-const propertyAliases = { divide: 'dividend', by: 'divisor', divideBy: 'divisor' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const [values, output] = (yield (0, _operatorUtils_1.evaluateArray)([(_a = expression.values) !== null && _a !== void 0 ? _a : [expression.dividend, expression.divisor], expression.output], config));
-    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!');
-    switch (output) {
-        case 'quotient':
-            return Math.floor(values[0] / values[1]);
-        case 'remainder':
-            return values[0] % values[1];
-        default:
-            return values[0] / values[1];
-    }
-});
-exports.DIVIDE = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
-};

package/build/operators/equal.d.ts

@@ -1,2 +0,0 @@
-import { OperatorObject } from '../types';
-export declare const EQUAL: OperatorObject;

package/build/operators/greaterThan.js

@@ -1,35 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GREATER_THAN = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const logicalAnd_1 = require("./logicalAnd");
-const requiredProperties = ['values'];
-const operatorAliases = ['>', 'greaterThan', 'higher', 'larger'];
-const aliasExtensions = [{ '>=': { strict: false } }];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const [values, strict = true] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.strict], config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    if (values.length < 2)
-        throw new Error('- Not enough values provided');
-    const [first, second] = values;
-    if (first === second && !strict)
-        return true;
-    return first > second;
-});
-exports.GREATER_THAN = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
-};

package/build/operators/lessThan.js

@@ -1,35 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LESS_THAN = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const logicalAnd_1 = require("./logicalAnd");
-const requiredProperties = ['values'];
-const operatorAliases = ['<', 'lessThan', 'lower', 'smaller'];
-const aliasExtensions = [{ '<=': { strict: false } }];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const [values, strict = true] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.strict], config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    if (values.length < 2)
-        throw new Error('- Not enough values provided');
-    const [first, second] = values;
-    if (first === second && !strict)
-        return true;
-    return first < second;
-});
-exports.LESS_THAN = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
-};

package/build/operators/logicalAnd.js

@@ -1,33 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AND = exports.parseChildren = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['values'];
-const operatorAliases = ['and', '&', '&&'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.reduce((acc, val) => acc && !!val, true);
-});
-const parseChildren = (expression) => {
-    const values = expression.children;
-    return Object.assign(Object.assign({}, expression), { values });
-};
-exports.parseChildren = parseChildren;
-exports.AND = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: exports.parseChildren,
-};

package/build/operators/logicalOr.d.ts

@@ -1,2 +0,0 @@
-import { OperatorObject } from '../types';
-export declare const OR: OperatorObject;

package/build/operators/logicalOr.js

@@ -1,29 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OR = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['values'];
-const operatorAliases = ['or', '|', '||'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.reduce((acc, val) => acc || !!val, false);
-});
-exports.OR = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
-};

package/build/operators/multiply.js

@@ -1,29 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MULTIPLY = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['values'];
-const operatorAliases = ['*', 'x', 'multiply', 'times'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.reduce((acc, number) => acc * number);
-});
-exports.MULTIPLY = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
-};

package/build/operators/passThru.js

@@ -1,30 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PASSTHRU = void 0;
-const evaluate_1 = require("../evaluate");
-const requiredProperties = ['value'];
-const operatorAliases = ['_', 'passThru', 'pass', 'ignore', 'coerce', 'convert'];
-const propertyAliases = { _: 'value', data: 'value' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield (0, evaluate_1.evaluatorFunction)(expression.value, config);
-});
-const parseChildren = (expression) => {
-    const [...children] = expression.children;
-    return Object.assign(Object.assign({}, expression), { value: children });
-};
-exports.PASSTHRU = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
-};

package/build/operators/postRequest.d.ts

@@ -1,2 +0,0 @@
-import { OperatorObject } from '../types';
-export declare const POST: OperatorObject;

package/build/operators/subtract.js

@@ -1,32 +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());
-    });
-};
-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 _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];
-});
-exports.SUBTRACT = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
-};