fig-tree-evaluator 1.9.0

package/build/operators/buildObject.js

@@ -0,0 +1,48 @@
+"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.BUILD_OBJECT = void 0;
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['properties'];
+const operatorAliases = ['buildObject', 'build', 'object'];
+const propertyAliases = {
+    values: 'properties',
+    keyValPairs: 'properties',
+    keyValuePairs: 'properties',
+};
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const evaluatePair = (nodes) => __awaiter(void 0, void 0, void 0, function* () {
+        const [key, value] = (yield (0, _operatorUtils_1.evaluateArray)(nodes, config));
+        config.typeChecker({ name: 'key', value: key, expectedType: 'string' });
+        return [key, value];
+    });
+    config.typeChecker({ name: 'properties', value: expression.properties, expectedType: 'array' });
+    const evaluated = expression.properties
+        .filter((element) => element instanceof Object && 'key' in element && 'value' in element)
+        .map(({ key, value }) => evaluatePair([key, value]));
+    return Object.fromEntries(yield Promise.all(evaluated));
+});
+const parseChildren = (expression) => {
+    const elements = expression.children;
+    if (elements.length % 2 !== 0)
+        throw new Error('Even number of children required to make key/value pairs');
+    const keys = elements.filter((_, index) => index % 2 === 0);
+    const values = elements.filter((_, index) => index % 2 === 1);
+    const properties = keys.map((key, index) => ({ key, value: values[index] }));
+    return Object.assign(Object.assign({}, expression), { properties });
+};
+exports.BUILD_OBJECT = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/conditional.d.ts

@@ -0,0 +1,7 @@
+import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
+declare const requiredProperties: readonly ["condition", "valueIfTrue", "valueIfFalse"];
+export declare type ConditionalNode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode;
+} & BaseOperatorNode;
+export declare const CONDITIONAL: OperatorObject;
+export {};

package/build/operators/conditional.js

@@ -0,0 +1,31 @@
+"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.CONDITIONAL = void 0;
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['condition', 'valueIfTrue', 'valueIfFalse'];
+const operatorAliases = ['?', 'conditional', 'ifThen'];
+const propertyAliases = { ifTrue: 'valueIfTrue', ifFalse: 'valueIfFalse', ifNot: 'valueIfFalse' };
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const [condition, valueIfTrue, valueIfFalse] = yield (0, _operatorUtils_1.evaluateArray)([expression.condition, expression.valueIfTrue, expression.valueIfFalse], config);
+    return !!condition ? valueIfTrue : valueIfFalse;
+});
+const parseChildren = (expression) => {
+    const [condition, valueIfTrue, valueIfFalse] = expression.children;
+    return Object.assign(Object.assign({}, expression), { condition, valueIfTrue, valueIfFalse });
+};
+exports.CONDITIONAL = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/count.d.ts

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

package/build/operators/count.js

@@ -0,0 +1,29 @@
+"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/customFunctions.d.ts

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

package/build/operators/customFunctions.js

@@ -0,0 +1,53 @@
+"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.CUSTOM_FUNCTIONS = void 0;
+const object_property_extractor_1 = __importDefault(require("object-property-extractor"));
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['functionPath'];
+const operatorAliases = [
+    'customFunctions',
+    'customFunction',
+    'objectFunctions',
+    'function',
+    'functions',
+    'runFunction',
+];
+const propertyAliases = {
+    functionsPath: 'functionPath',
+    functionName: 'functionPath',
+    funcName: 'functionPath',
+    path: 'functionPath',
+    arguments: 'args',
+    variables: 'args',
+};
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const [functionPath, ...args] = (yield (0, _operatorUtils_1.evaluateArray)([expression.functionPath, ...(expression.args || [])], config));
+    config.typeChecker({ name: 'functionPath', value: functionPath, expectedType: 'string' });
+    const { objects, functions } = config.options;
+    const func = ((_a = (0, object_property_extractor_1.default)(functions, functionPath, null)) !== null && _a !== void 0 ? _a : (0, object_property_extractor_1.default)(objects, functionPath));
+    return yield func(...args);
+});
+const parseChildren = (expression) => {
+    const [functionPath, ...args] = expression.children;
+    return Object.assign(Object.assign({}, expression), { functionPath, args });
+};
+exports.CUSTOM_FUNCTIONS = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/divide.d.ts

@@ -0,0 +1,11 @@
+import { BasicExtendedNode } from './logicalAnd';
+import { EvaluatorNode, OperatorObject, BaseOperatorNode } from '../types';
+interface DivisionNodeWithProps extends BaseOperatorNode {
+    dividend: EvaluatorNode;
+    divisor: EvaluatorNode;
+}
+export declare type DivisionNode = BasicExtendedNode & DivisionNodeWithProps & {
+    output?: 'quotient' | 'remainder';
+};
+export declare const DIVIDE: OperatorObject;
+export {};

package/build/operators/divide.js

@@ -0,0 +1,42 @@
+"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 __1 = require("..");
+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 = (yield (0, _operatorUtils_1.evaluateArray)((_a = expression.values) !== null && _a !== void 0 ? _a : [expression.dividend, expression.divisor], config));
+    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+    if (values.length < 2)
+        throw new Error('- Not enough values provided');
+    if (!values[1])
+        throw new Error('Division by zero!');
+    switch (yield (0, __1.evaluateExpression)(expression.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

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

package/build/operators/equal.js

@@ -0,0 +1,29 @@
+"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.EQUAL = void 0;
+const logicalAnd_1 = require("./logicalAnd");
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['values'];
+const operatorAliases = ['=', 'eq', 'equal', 'equals'];
+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.every((value) => value == values[0]);
+});
+exports.EQUAL = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren: logicalAnd_1.parseChildren,
+};

package/build/operators/getRequest.d.ts

@@ -0,0 +1,12 @@
+import { BaseOperatorNode, EvaluatorNode, FigTreeConfig, CombinedOperatorNode, GenericObject, OperatorObject } from '../types';
+declare const requiredProperties: readonly ["url"];
+export declare type APINode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode;
+} & BaseOperatorNode & {
+    parameters?: EvaluatorNode;
+    returnProperty?: EvaluatorNode;
+    headers?: GenericObject;
+};
+export declare const parseChildrenGET: (expression: CombinedOperatorNode, config: FigTreeConfig) => Promise<APINode>;
+export declare const GET: OperatorObject;
+export {};

package/build/operators/getRequest.js

@@ -0,0 +1,47 @@
+"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.GET = exports.parseChildrenGET = void 0;
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['url'];
+const operatorAliases = ['get', 'api'];
+const propertyAliases = { endpoint: 'url', outputProperty: 'returnProperty' };
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const [urlObj, params, 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: 'headers', value: headers, expectedType: ['object', 'undefined'] }, { name: 'parameters', value: params, 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),
+        params,
+        headers: httpHeaders,
+    });
+    return (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty);
+});
+const parseChildren = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const [url = '', fieldNames, ...rest] = (yield (0, _operatorUtils_1.evaluateArray)(expression.children, config));
+    const values = rest.slice(0, fieldNames.length);
+    const parameters = (0, _operatorUtils_1.zipArraysToObject)(fieldNames, values);
+    const output = Object.assign(Object.assign({}, expression), { url, parameters });
+    if (rest.length > fieldNames.length)
+        output.returnProperty = rest.pop();
+    return output;
+});
+exports.parseChildrenGET = parseChildren;
+exports.GET = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/graphQL.d.ts

@@ -0,0 +1,18 @@
+import { BaseOperatorNode, EvaluatorNode, GenericObject, OperatorObject } from '../types';
+declare const requiredProperties: readonly ["query"];
+export declare type GraphQLNode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode;
+} & BaseOperatorNode & {
+    url?: EvaluatorNode;
+    variables?: EvaluatorNode;
+    returnNode?: EvaluatorNode;
+    headers?: GenericObject;
+};
+export interface GraphQLConnection {
+    endpoint: string;
+    headers?: {
+        [key: string]: string;
+    };
+}
+export declare const GRAPHQL: OperatorObject;
+export {};

package/build/operators/graphQL.js

@@ -0,0 +1,55 @@
+"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.GRAPHQL = void 0;
+const _operatorUtils_1 = require("./_operatorUtils");
+const requiredProperties = ['query'];
+const operatorAliases = ['graphQl', 'graphql', 'gql'];
+const propertyAliases = { endpoint: 'url', outputNode: 'returnNode', returnPropery: 'returnNode' };
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e;
+    const [query, urlObj, variables, returnNode, headers] = (yield (0, _operatorUtils_1.evaluateArray)([
+        expression.query,
+        expression.url,
+        expression.variables,
+        expression.returnNode,
+        expression.headers,
+    ], config));
+    const { url, headers: headersObj } = urlObj instanceof Object ? urlObj : { url: urlObj, headers: null };
+    config.typeChecker({ name: 'url', value: url, expectedType: ['string', 'undefined', 'null'] }, { name: 'query', value: query, expectedType: 'string' }, { name: 'headers', value: headersObj, expectedType: ['object', 'null'] }, { name: 'variables', value: variables, expectedType: ['object', 'undefined'] }, { name: 'returnNode', value: returnNode, expectedType: ['string', 'undefined'] });
+    const endpoint = !url || url.toLowerCase() === 'graphqlendpoint' ? '' : url;
+    const baseEndpoint = (_c = (_b = (_a = config.options.graphQLConnection) === null || _a === void 0 ? void 0 : _a.endpoint) !== null && _b !== void 0 ? _b : config.options.baseEndpoint) !== null && _c !== void 0 ? _c : '';
+    const fullUrl = (0, _operatorUtils_1.isFullUrl)(endpoint) ? endpoint : (0, _operatorUtils_1.joinUrlParts)(baseEndpoint, endpoint);
+    const data = { query, variables };
+    const response = yield (0, _operatorUtils_1.axiosRequest)({
+        url: fullUrl,
+        method: 'post',
+        data,
+        headers: Object.assign(Object.assign(Object.assign(Object.assign({}, (_d = config.options.graphQLConnection) === null || _d === void 0 ? void 0 : _d.headers), (_e = config.options) === null || _e === void 0 ? void 0 : _e.headers), headersObj), headers),
+    });
+    return (0, _operatorUtils_1.extractAndSimplify)(response.data, returnNode);
+});
+const parseChildren = (expression) => __awaiter(void 0, void 0, void 0, function* () {
+    const [query, url = '', fieldNames, ...rest] = expression.children;
+    const values = rest.slice(0, fieldNames.length);
+    const variables = (0, _operatorUtils_1.zipArraysToObject)(fieldNames, values);
+    const output = Object.assign(Object.assign({}, expression), { query, url, variables });
+    if (rest.length > fieldNames.length)
+        output.returnNode = rest.pop();
+    return output;
+});
+exports.GRAPHQL = {
+    requiredProperties,
+    operatorAliases,
+    propertyAliases,
+    evaluate,
+    parseChildren,
+};

package/build/operators/greaterThan.d.ts

@@ -0,0 +1,6 @@
+import { OperatorObject } from '../types';
+import { BasicExtendedNode } from './logicalAnd';
+export declare type ComparatorNode = BasicExtendedNode & {
+    strict?: boolean;
+};
+export declare const GREATER_THAN: OperatorObject;

package/build/operators/greaterThan.js

@@ -0,0 +1,35 @@
+"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/index.d.ts

@@ -0,0 +1,23 @@
+export * from './logicalOr';
+export * from './logicalAnd';
+export * from './equal';
+export * from './notEqual';
+export * from './plus';
+export * from './subtract';
+export * from './multiply';
+export * from './divide';
+export * from './greaterThan';
+export * from './lessThan';
+export * from './conditional';
+export * from './regex';
+export * from './objectProperties';
+export * from './stringSubstitution';
+export * from './count';
+export * from './split';
+export * from './pgSQL';
+export * from './graphQL';
+export * from './getRequest';
+export * from './postRequest';
+export * from './buildObject';
+export * from './customFunctions';
+export * from './passThru';

package/build/operators/index.js

@@ -0,0 +1,39 @@
+"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 __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 });
+__exportStar(require("./logicalOr"), exports);
+__exportStar(require("./logicalAnd"), exports);
+__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);
+__exportStar(require("./getRequest"), exports);
+__exportStar(require("./postRequest"), exports);
+__exportStar(require("./buildObject"), exports);
+__exportStar(require("./customFunctions"), exports);
+__exportStar(require("./passThru"), exports);

package/build/operators/lessThan.d.ts

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

package/build/operators/lessThan.js

@@ -0,0 +1,35 @@
+"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.d.ts

@@ -0,0 +1,8 @@
+import { EvaluatorNode, BaseOperatorNode, CombinedOperatorNode, OperatorObject } from '../types';
+declare const requiredProperties: readonly ["values"];
+export declare type BasicExtendedNode = {
+    [key in typeof requiredProperties[number]]: EvaluatorNode[];
+} & BaseOperatorNode;
+export declare const parseChildren: (expression: CombinedOperatorNode) => BasicExtendedNode;
+export declare const AND: OperatorObject;
+export {};

package/build/operators/logicalAnd.js

@@ -0,0 +1,33 @@
+"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

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

package/build/operators/logicalOr.js

@@ -0,0 +1,29 @@
+"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,
+};