fig-tree-evaluator 2.7.0 → 2.8.3

package/build/operators/customFunctions.js

@@ -1,57 +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.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, _b, _c, _d;
-    const [functionPath, ...args] = (yield (0, _operatorUtils_1.evaluateArray)([expression.functionPath, ...(expression.args || [])], config));
-    config.typeChecker({ name: 'functionPath', value: functionPath, expectedType: 'string' });
-    const { data, functions } = config.options;
-    const func = ((_b = (_a = (0, object_property_extractor_1.default)(functions, functionPath, null)) !== null && _a !== void 0 ? _a : (0, object_property_extractor_1.default)(data, functionPath, null)) !== null && _b !== void 0 ? _b : (0, object_property_extractor_1.default)(config.options, functionPath));
-    const shouldUseCache = (_d = (_c = expression.useCache) !== null && _c !== void 0 ? _c : config.options.useCache) !== null && _d !== void 0 ? _d : false;
-    const result = yield config.cache.useCache(shouldUseCache, (_, ...args) => __awaiter(void 0, void 0, void 0, function* () {
-        return yield func(...args);
-    }), functionPath, ...args);
-    return result;
-});
-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

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

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/getRequest.d.ts

@@ -1,12 +0,0 @@
-import { BaseOperatorNode, EvaluatorNode, FigTreeConfig, CombinedOperatorNode, GenericObject, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["url"];
-export 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

@@ -1,51 +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.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, _c, _d;
-    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 shouldUseCache = (_d = (_c = expression.useCache) !== null && _c !== void 0 ? _c : config.options.useCache) !== null && _d !== void 0 ? _d : true;
-    const result = yield config.cache.useCache(shouldUseCache, (url, params, headers, returnProperty) => __awaiter(void 0, void 0, void 0, function* () {
-        const response = yield (0, _operatorUtils_1.axiosRequest)({
-            url,
-            params,
-            headers,
-        });
-        return (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty);
-    }), (0, _operatorUtils_1.isFullUrl)(url) ? url : (0, _operatorUtils_1.joinUrlParts)(baseUrl, url), params, httpHeaders, returnProperty);
-    return result;
-});
-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

@@ -1,18 +0,0 @@
-import { BaseOperatorNode, EvaluatorNode, GenericObject, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["query"];
-export 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/greaterThan.d.ts

@@ -1,6 +0,0 @@
-import { OperatorObject } from '../types';
-import { BasicExtendedNode } from './logicalAnd';
-export type ComparatorNode = BasicExtendedNode & {
-    strict?: boolean;
-};
-export declare const GREATER_THAN: 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.d.ts

@@ -1,8 +0,0 @@
-import { EvaluatorNode, BaseOperatorNode, CombinedOperatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["values"];
-export 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/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/match.d.ts

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

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/objectProperties.d.ts

@@ -1,9 +0,0 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
-declare const requiredProperties: string[];
-export type ObjPropNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode & {
-    additionalData: object;
-};
-export declare const OBJECT_PROPERTIES: OperatorObject;
-export {};

package/build/operators/passThru.d.ts

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

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/pgSQL.d.ts

@@ -1,24 +0,0 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["query"];
-export type PGNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode & {
-    values?: EvaluatorNode[];
-    type?: 'string';
-};
-export interface PGConnection {
-    query: (expression: {
-        text: string;
-        values?: any[];
-        rowMode?: string;
-    }) => Promise<QueryResult>;
-}
-interface QueryRowResult {
-    [columns: string]: any;
-}
-export interface QueryResult {
-    rows: QueryRowResult[];
-    error?: string;
-}
-export declare const PG_SQL: OperatorObject;
-export {};

package/build/operators/pgSQL.js

@@ -1,70 +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.PG_SQL = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['query'];
-const operatorAliases = ['pgSql', 'sql', 'postgres', 'pg', 'pgDb'];
-const propertyAliases = { replacements: 'values', queryType: 'type' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const [query, type, ...values] = (yield (0, _operatorUtils_1.evaluateArray)([expression.query, expression.type, ...(expression.values || [])], config));
-    config.typeChecker({ name: 'query', value: query, expectedType: 'string' }, { name: 'values', value: values, expectedType: 'array' }, { name: 'type', value: type, expectedType: ['string', 'undefined'] });
-    if (!((_a = config.options) === null || _a === void 0 ? void 0 : _a.pgConnection))
-        throw new Error('No Postgres database connection provided');
-    const shouldUseCache = (_c = (_b = expression.useCache) !== null && _b !== void 0 ? _b : config.options.useCache) !== null && _c !== void 0 ? _c : true;
-    try {
-        const result = config.cache.useCache(shouldUseCache, (query, type, ...values) => __awaiter(void 0, void 0, void 0, function* () {
-            return yield processPgSQL([query, ...values], config.options.pgConnection, type);
-        }), query, type, ...values);
-        return result;
-    }
-    catch (err) {
-        throw err;
-    }
-});
-const parseChildren = (expression) => {
-    const [query, ...values] = expression.children;
-    return Object.assign(Object.assign({}, expression), { query, values });
-};
-const processPgSQL = (queryArray, connection, queryType) => __awaiter(void 0, void 0, void 0, function* () {
-    const expression = {
-        text: queryArray[0],
-        values: queryArray.slice(1),
-        rowMode: queryType ? 'array' : '',
-    };
-    try {
-        const res = yield connection.query(expression);
-        if (res === null || res === void 0 ? void 0 : res.error)
-            throw new Error(res.error);
-        switch (queryType) {
-            case 'array':
-                return res.rows.flat();
-            case 'string':
-                return res.rows.flat().join(' ');
-            case 'number':
-                const result = res.rows.flat();
-                return Number.isNaN(Number(result)) ? result : Number(result);
-            default:
-                return res.rows;
-        }
-    }
-    catch (err) {
-        throw err;
-    }
-});
-exports.PG_SQL = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
-};

package/build/operators/plus.d.ts

@@ -1,10 +0,0 @@
-import { OperatorObject, EvaluatorNode } from '../types';
-import { BasicExtendedNode } from './logicalAnd';
-declare const requiredProperties: readonly ["values"];
-export type AdditionNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BasicExtendedNode & {
-    type?: 'string' | 'array';
-};
-export declare const PLUS: OperatorObject;
-export {};

package/build/operators/postRequest.d.ts

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

package/build/operators/postRequest.js

@@ -1,43 +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.POST = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const getRequest_1 = require("./getRequest");
-const requiredProperties = ['url'];
-const operatorAliases = ['post'];
-const propertyAliases = { endpoint: 'url', outputProperty: 'returnProperty' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d;
-    const [urlObj, data, returnProperty, headers] = (yield (0, _operatorUtils_1.evaluateArray)([expression.url, expression.parameters, expression.returnProperty, expression.headers], config));
-    const { url, headers: headersObj } = urlObj instanceof Object ? urlObj : { url: urlObj, headers: null };
-    config.typeChecker({ name: 'url', value: url, expectedType: 'string' }, { name: 'headers', value: headersObj, expectedType: ['object', 'null'] }, { name: 'data', value: data, expectedType: ['object', 'undefined'] }, { name: 'returnProperty', value: returnProperty, expectedType: ['string', 'undefined'] });
-    const baseUrl = (_a = config.options.baseEndpoint) !== null && _a !== void 0 ? _a : '';
-    const httpHeaders = Object.assign(Object.assign(Object.assign({}, (_b = config.options) === null || _b === void 0 ? void 0 : _b.headers), headersObj), headers);
-    const shouldUseCache = (_d = (_c = expression.useCache) !== null && _c !== void 0 ? _c : config.options.useCache) !== null && _d !== void 0 ? _d : true;
-    const result = yield config.cache.useCache(shouldUseCache, (url, data, headers, returnProperty) => __awaiter(void 0, void 0, void 0, function* () {
-        const response = yield (0, _operatorUtils_1.axiosRequest)({
-            url,
-            data,
-            headers,
-            method: 'post',
-        });
-        return (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty);
-    }), (0, _operatorUtils_1.isFullUrl)(url) ? url : (0, _operatorUtils_1.joinUrlParts)(baseUrl, url), data, httpHeaders, returnProperty);
-    return result;
-});
-exports.POST = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: getRequest_1.parseChildrenGET,
-};

package/build/operators/regex.d.ts

@@ -1,7 +0,0 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["testString", "pattern"];
-export type RegexNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode;
-export declare const REGEX: OperatorObject;
-export {};

package/build/operators/split.d.ts

@@ -1,11 +0,0 @@
-import { OperatorObject, EvaluatorNode, BaseOperatorNode } from '../types';
-declare const requiredProperties: readonly ["value"];
-export type SplitNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode & {
-    delimiter?: EvaluatorNode;
-    trimWhiteSpace: EvaluatorNode;
-    excludeTrailing: EvaluatorNode;
-};
-export declare const SPLIT: OperatorObject;
-export {};

package/build/operators/stringSubstitution.d.ts

@@ -1,7 +0,0 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["string", "substitutions"];
-export type StringSubNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode;
-export declare const STRING_SUBSTITUTION: OperatorObject;
-export {};

package/build/operators/stringSubstitution.js

@@ -1,40 +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.STRING_SUBSTITUTION = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['string', 'substitutions'];
-const operatorAliases = ['stringSubstitution', 'substitute', 'stringSub', 'replace'];
-const propertyAliases = { replacements: 'substitutions' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const [string, ...substitutions] = (yield (0, _operatorUtils_1.evaluateArray)([expression.string, ...expression.substitutions], config));
-    config.typeChecker({ name: 'string', value: string, expectedType: 'string' });
-    config.typeChecker({ name: 'substitutions', value: substitutions, expectedType: 'array' });
-    const regex = /(%[\d]+)/g;
-    const parameters = (string.match(regex) || []).sort((a, b) => Number(a.slice(1)) - Number(b.slice(1)));
-    const uniqueParameters = new Set(parameters);
-    const replacementsObj = (0, _operatorUtils_1.zipArraysToObject)(Array.from(uniqueParameters), substitutions);
-    return string
-        .split(regex)
-        .map((fragment) => (fragment in replacementsObj ? replacementsObj[fragment] : fragment))
-        .join('');
-});
-const parseChildren = (expression) => {
-    const [string, ...substitutions] = expression.children;
-    return Object.assign(Object.assign({}, expression), { string, substitutions });
-};
-exports.STRING_SUBSTITUTION = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
-};