fig-tree-evaluator 2.8.0 → 2.8.3

package/build/operators/PG_SQL/data.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyAliases = exports.requiredProperties = void 0;
+exports.propertyAliases = void 0;
 const _operatorUtils_1 = require("../_operatorUtils");
 const description = 'Query a Postgres database using node-postgres';
 const aliases = ['pgSql', 'sql', 'postgres', 'pg', 'pgDb'];
@@ -24,10 +24,16 @@ const parameters = [
         description: 'Determines the shape of the resulting data (see documentation)',
         aliases: ['queryType'],
         required: false,
-        type: 'string',
+        type: { literal: ['array', 'string', 'number'] },
+    },
+    {
+        name: 'useCache',
+        description: 'Whether or not the FigTree cache is used',
+        aliases: [],
+        required: false,
+        type: 'boolean',
     },
 ];
-exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
 exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
 const operatorData = {
     description,

package/build/operators/PG_SQL/operator.d.ts

@@ -1,24 +1,2 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../../types';
-import { requiredProperties } from './data';
-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;
-}
+import { OperatorObject } from '../../types';
 export declare const PG_SQL: OperatorObject;
-export {};

package/build/operators/PG_SQL/operator.js

@@ -37,53 +37,45 @@ const _operatorUtils_1 = require("../_operatorUtils");
 const data_1 = __importStar(require("./data"));
 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(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { query, type, values }));
+    const [query, type, values, useCache] = (yield (0, _operatorUtils_1.evaluateArray)([expression.query, expression.type, expression.values || [], expression.useCache], config));
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { query, type, values, useCache }));
     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);
+    {
+        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 processPgSQL = (query, values, connection, queryType) => __awaiter(void 0, void 0, void 0, function* () {
     const expression = {
-        text: queryArray[0],
-        values: queryArray.slice(1),
+        text: query,
+        values: values,
         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;
+    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);
         }
-    }
-    catch (err) {
-        throw err;
+        default:
+            return res.rows;
     }
 });
 exports.PG_SQL = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/PLUS/data.d.ts

@@ -1,5 +1,4 @@
 import { OperatorData } from '../../types';
-export declare const requiredProperties: string[];
 export declare const propertyAliases: Record<string, string>;
 declare const operatorData: OperatorData;
 export default operatorData;

package/build/operators/PLUS/data.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyAliases = exports.requiredProperties = void 0;
+exports.propertyAliases = void 0;
 const _operatorUtils_1 = require("../_operatorUtils");
 const description = 'Add, concatenate or merge multiple values';
 const aliases = ['+', 'plus', 'add', 'concat', 'join', 'merge'];
@@ -17,10 +17,9 @@ const parameters = [
         description: 'Data type to coerce input values to before addition',
         aliases: [],
         required: false,
-        type: 'string',
+        type: { literal: ['string', 'array', 'number', 'boolean', 'bool'] },
     },
 ];
-exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
 exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
 const operatorData = {
     description,

package/build/operators/PLUS/operator.d.ts

@@ -1,9 +1,2 @@
-import { BasicExtendedNode } from '../AND/operator';
-import { OperatorObject, EvaluatorNode } from '../../types';
-import { requiredProperties } from './data';
-export type AdditionNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BasicExtendedNode & {
-    type?: 'string' | 'array';
-};
+import { OperatorObject } from '../../types';
 export declare const PLUS: OperatorObject;

package/build/operators/PLUS/operator.js

@@ -36,26 +36,26 @@ exports.PLUS = void 0;
 const operator_1 = require("../AND/operator");
 const _operatorUtils_1 = require("../_operatorUtils");
 const data_1 = __importStar(require("./data"));
+const helpers_1 = require("../../helpers");
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    if (expression.values.length === 0)
-        return expression.values;
     const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
-    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, {
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, {
         values,
         type: expression.type,
     }));
+    if (values.length === 0)
+        return values;
     if ((expression === null || expression === void 0 ? void 0 : expression.type) === 'string')
         return values.reduce((acc, child) => acc.concat(child), '');
     if ((expression === null || expression === void 0 ? void 0 : expression.type) === 'array')
         return values.reduce((acc, child) => acc.concat(child), []);
     if (values.every((child) => typeof child === 'string' || Array.isArray(child)))
         return values.reduce((acc, child) => acc.concat(child));
-    if (values.every((child) => child instanceof Object && !Array.isArray(child)))
+    if (values.every((child) => (0, helpers_1.isObject)(child)))
         return values.reduce((acc, child) => (Object.assign(Object.assign({}, acc), child)), {});
     return values.reduce((acc, child) => acc + child);
 });
 exports.PLUS = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/POST/data.d.ts

@@ -1,5 +1,4 @@
 import { OperatorData } from '../../types';
-export declare const requiredProperties: string[];
 export declare const propertyAliases: Record<string, string>;
 declare const operatorData: OperatorData;
 export default operatorData;

package/build/operators/POST/data.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyAliases = exports.requiredProperties = void 0;
+exports.propertyAliases = void 0;
 const _operatorUtils_1 = require("../_operatorUtils");
 const description = 'HTTP POST Request';
 const aliases = ['post'];
@@ -41,7 +41,6 @@ const parameters = [
         type: 'boolean',
     },
 ];
-exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
 exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
 const operatorData = {
     description,

package/build/operators/POST/operator.js

@@ -37,14 +37,23 @@ const _operatorUtils_1 = require("../_operatorUtils");
 const operator_1 = require("../GET/operator");
 const data_1 = __importStar(require("./data"));
 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));
+    var _a, _b, _c;
+    const [urlObj, data, returnProperty, headers, useCache] = (yield (0, _operatorUtils_1.evaluateArray)([
+        expression.url,
+        expression.parameters,
+        expression.returnProperty,
+        expression.headers,
+        expression.useCache,
+    ], config));
     const { url, headers: headersObj } = urlObj instanceof Object ? urlObj : { url: urlObj, headers: null };
-    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { url, headers, data, returnProperty }), { name: 'headers', value: headersObj, expectedType: ['object', 'null'] });
+    config.typeChecker([
+        ...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { url, headers, data, returnProperty, useCache }),
+        { name: 'headers', value: headersObj, expectedType: ['object', 'null'] },
+    ]);
     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 shouldUseCache = (_c = useCache !== null && useCache !== void 0 ? useCache : config.options.useCache) !== null && _c !== void 0 ? _c : true;
+    const result = yield config.cache.useCache(shouldUseCache, () => __awaiter(void 0, void 0, void 0, function* () {
         const response = yield (0, _operatorUtils_1.axiosRequest)({
             url,
             data,
@@ -56,7 +65,6 @@ const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, funct
     return result;
 });
 exports.POST = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/REGEX/data.d.ts

@@ -1,5 +1,4 @@
 import { OperatorData } from '../../types';
-export declare const requiredProperties: string[];
 export declare const propertyAliases: Record<string, string>;
 declare const operatorData: OperatorData;
 export default operatorData;

package/build/operators/REGEX/data.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyAliases = exports.requiredProperties = void 0;
+exports.propertyAliases = void 0;
 const _operatorUtils_1 = require("../_operatorUtils");
 const description = 'Compare a string against a regex pattern';
 const aliases = ['regex', 'patternMatch', 'regexp', 'matchPattern'];
@@ -20,7 +20,6 @@ const parameters = [
         type: 'string',
     },
 ];
-exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
 exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
 const operatorData = {
     description,

package/build/operators/REGEX/operator.d.ts

@@ -1,6 +1,2 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../../types';
-import { requiredProperties } from './data';
-export type RegexNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode;
+import { OperatorObject } from '../../types';
 export declare const REGEX: OperatorObject;

package/build/operators/REGEX/operator.js

@@ -38,7 +38,7 @@ const helpers_1 = require("../../helpers");
 const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     const [testString, pattern] = (yield (0, _operatorUtils_1.evaluateArray)([expression.testString, expression.pattern], config));
-    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { testString, pattern }));
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { testString, pattern }));
     try {
         const re = new RegExp(pattern);
         return re.test(testString);
@@ -52,7 +52,6 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { testString, pattern });
 };
 exports.REGEX = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/SPLIT/data.d.ts

@@ -1,5 +1,4 @@
 import { OperatorData } from '../../types';
-export declare const requiredProperties: string[];
 export declare const propertyAliases: Record<string, string>;
 declare const operatorData: OperatorData;
 export default operatorData;

package/build/operators/SPLIT/data.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyAliases = exports.requiredProperties = void 0;
+exports.propertyAliases = void 0;
 const _operatorUtils_1 = require("../_operatorUtils");
 const description = 'Split a string into an array';
 const aliases = ['split', 'arraySplit'];
@@ -34,7 +34,6 @@ const parameters = [
         type: 'boolean',
     },
 ];
-exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
 exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
 const operatorData = {
     description,

package/build/operators/SPLIT/operator.d.ts

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

package/build/operators/SPLIT/operator.js

@@ -44,7 +44,7 @@ const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, funct
         (_b = expression.trimWhiteSpace) !== null && _b !== void 0 ? _b : true,
         (_c = expression.excludeTrailing) !== null && _c !== void 0 ? _c : true,
     ], config));
-    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, {
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, {
         value,
         delimiter,
         trimWhiteSpace,
@@ -62,7 +62,6 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { value, delimiter });
 };
 exports.SPLIT = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/STRING_SUBSTITUTION/data.d.ts

@@ -1,5 +1,4 @@
 import { OperatorData } from '../../types';
-export declare const requiredProperties: string[];
 export declare const propertyAliases: Record<string, string>;
 declare const operatorData: OperatorData;
 export default operatorData;

package/build/operators/STRING_SUBSTITUTION/data.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyAliases = exports.requiredProperties = void 0;
+exports.propertyAliases = void 0;
 const _operatorUtils_1 = require("../_operatorUtils");
 const description = 'Replace values in a string using simple parameter substitution';
 const aliases = ['stringSubstitution', 'substitute', 'stringSub', 'replace'];
@@ -20,7 +20,6 @@ const parameters = [
         type: 'array',
     },
 ];
-exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
 exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
 const operatorData = {
     description,

package/build/operators/STRING_SUBSTITUTION/operator.d.ts

@@ -1,6 +1,2 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../../types';
-import { requiredProperties } from './data';
-export type StringSubNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode;
+import { OperatorObject } from '../../types';
 export declare const STRING_SUBSTITUTION: OperatorObject;

package/build/operators/STRING_SUBSTITUTION/operator.js

@@ -36,14 +36,14 @@ exports.STRING_SUBSTITUTION = void 0;
 const _operatorUtils_1 = require("../_operatorUtils");
 const data_1 = __importStar(require("./data"));
 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(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { string, substitutions }));
-    const regex = /(%[\d]+)/g;
-    const parameters = (string.match(regex) || []).sort((a, b) => Number(a.slice(1)) - Number(b.slice(1)));
+    const [string, substitutions] = (yield (0, _operatorUtils_1.evaluateArray)([expression.string, expression.substitutions], config));
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { string, substitutions }));
+    const parameterPattern = /(%[\d]+)/g;
+    const parameters = (string.match(parameterPattern) || []).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)
+        .split(parameterPattern)
         .map((fragment) => (fragment in replacementsObj ? replacementsObj[fragment] : fragment))
         .join('');
 });
@@ -52,7 +52,6 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { string, substitutions });
 };
 exports.STRING_SUBSTITUTION = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/SUBTRACT/data.d.ts

@@ -1,5 +1,4 @@
 import { OperatorData } from '../../types';
-export declare const requiredProperties: string[];
 export declare const propertyAliases: Record<string, string>;
 declare const operatorData: OperatorData;
 export default operatorData;

package/build/operators/SUBTRACT/data.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyAliases = exports.requiredProperties = void 0;
+exports.propertyAliases = void 0;
 const _operatorUtils_1 = require("../_operatorUtils");
 const description = 'Subtract one numerical value from another';
 const aliases = ['-', 'subtract', 'minus', 'takeaway'];
@@ -27,7 +27,6 @@ const parameters = [
         type: 'number',
     },
 ];
-exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
 exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
 const operatorData = {
     description,

package/build/operators/SUBTRACT/operator.d.ts

@@ -1,9 +1,2 @@
-import { BasicExtendedNode } from '../AND/operator';
-import { EvaluatorNode, OperatorObject, BaseOperatorNode } from '../../types';
-interface SubtractionNodeWithProps extends BaseOperatorNode {
-    subtract: EvaluatorNode;
-    from: EvaluatorNode;
-}
-export type SubtractionNode = BasicExtendedNode & SubtractionNodeWithProps;
+import { OperatorObject } from '../../types';
 export declare const SUBTRACT: OperatorObject;
-export {};

package/build/operators/SUBTRACT/operator.js

@@ -38,14 +38,15 @@ const _operatorUtils_1 = require("../_operatorUtils");
 const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     const [values, from, subtract] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.from, expression.subtract], config));
-    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values, from, subtract }));
-    const vals = values !== null && values !== void 0 ? values : [from, subtract];
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values, from, subtract }));
+    const vals = values !== null && values !== void 0 ? values : [from, subtract].filter((e) => e !== undefined);
     if (vals.length < 2)
         throw new Error('- Not enough values provided');
+    if (vals.some((e) => typeof e !== 'number'))
+        throw new Error('- Not all values are numbers');
     return vals[0] - vals[1];
 });
 exports.SUBTRACT = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/_operatorUtils.d.ts

@@ -1,25 +1,24 @@
-import { ExpectedType } from '../typeCheck';
-import { GenericObject, EvaluatorNode, EvaluatorOutput, FigTreeConfig, Parameter } from '../types';
-export declare const getRequiredProperties: (parameters: Parameter[]) => string[];
+import { AxiosRequestConfig } from 'axios';
+import { EvaluatorNode, EvaluatorOutput, FigTreeConfig, Parameter } from '../types';
 export declare const getPropertyAliases: (parameters: Parameter[]) => Record<string, string>;
-export declare const getTypeCheckInput: (parameterDefinitions: Parameter[], params: Record<string, unknown>) => {
+export declare const getTypeCheckInput: (parameterDefinitions: Parameter[], params: Record<string, unknown>) => ({
     name: string;
     value: unknown;
-    expectedType: ExpectedType | ExpectedType[];
-}[];
-export declare const evaluateArray: (nodes: EvaluatorNode[], params: FigTreeConfig) => Promise<EvaluatorOutput[]>;
+    expectedType: {
+        literal: (string | undefined)[];
+    };
+} | {
+    name: string;
+    value: unknown;
+    expectedType: import("../typeCheck").BasicType | import("../typeCheck").BasicType[];
+})[];
+export declare const evaluateArray: (nodes: EvaluatorNode[] | EvaluatorNode, params: FigTreeConfig) => Promise<EvaluatorOutput[]>;
 export declare const zipArraysToObject: <T>(keys: string[], values: T[]) => {
     [x: string]: T;
 };
-export declare const singleArrayToObject: (elements: any[]) => any;
-export declare const simplifyObject: (item: number | string | boolean | GenericObject) => any;
-export declare const extractAndSimplify: (data: GenericObject | GenericObject[], returnProperty: string | undefined, fallback?: any) => any;
+export declare const singleArrayToObject: <T>(elements: unknown[]) => Record<string, T>;
+export declare const simplifyObject: (item: unknown) => any;
+export declare const extractAndSimplify: (data: object | object[], returnProperty: string | undefined, fallback?: unknown) => any;
 export declare const isFullUrl: (url: string) => boolean;
 export declare const joinUrlParts: (...urls: string[]) => string;
-export declare const axiosRequest: ({ url, params, data, headers, method, }: {
-    url: string;
-    params?: GenericObject | undefined;
-    data?: GenericObject | undefined;
-    headers?: GenericObject | undefined;
-    method?: "get" | "post" | undefined;
-}) => Promise<any>;
+export declare const axiosRequest: ({ url, params, data, headers, method, }: AxiosRequestConfig) => Promise<any>;

package/build/operators/_operatorUtils.js

@@ -12,13 +12,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.axiosRequest = exports.joinUrlParts = exports.isFullUrl = exports.extractAndSimplify = exports.simplifyObject = exports.singleArrayToObject = exports.zipArraysToObject = exports.evaluateArray = exports.getTypeCheckInput = exports.getPropertyAliases = exports.getRequiredProperties = void 0;
+exports.axiosRequest = exports.joinUrlParts = exports.isFullUrl = exports.extractAndSimplify = exports.simplifyObject = exports.singleArrayToObject = exports.zipArraysToObject = exports.evaluateArray = exports.getTypeCheckInput = exports.getPropertyAliases = void 0;
 const axios_1 = __importDefault(require("axios"));
 const extract_1 = __importDefault(require("object-property-extractor/build/extract"));
 const evaluate_1 = require("../evaluate");
+const helpers_1 = require("../helpers");
 const typeCheck_1 = require("../typeCheck");
-const getRequiredProperties = (parameters) => parameters.filter((p) => p.required).map((p) => p.name);
-exports.getRequiredProperties = getRequiredProperties;
 const getPropertyAliases = (parameters) => {
     const propertyAliases = {};
     parameters.forEach((param) => {
@@ -28,6 +27,12 @@ const getPropertyAliases = (parameters) => {
 };
 exports.getPropertyAliases = getPropertyAliases;
 const getTypeCheckInput = (parameterDefinitions, params) => parameterDefinitions.map(({ name, required, type }) => {
+    if ((0, typeCheck_1.isLiteralType)(type)) {
+        const literal = [...type.literal];
+        if (!required)
+            literal.push(undefined);
+        return { name, value: params[name], expectedType: { literal } };
+    }
     const allTypes = Array.isArray(type) ? type : [type];
     if (!required)
         allTypes.push('undefined');
@@ -65,24 +70,19 @@ const singleArrayToObject = (elements) => {
 };
 exports.singleArrayToObject = singleArrayToObject;
 const simplifyObject = (item) => {
-    return item instanceof Object && Object.keys(item).length === 1 ? Object.values(item)[0] : item;
+    return (0, helpers_1.isObject)(item) && Object.keys(item).length === 1 ? Object.values(item)[0] : item;
 };
 exports.simplifyObject = simplifyObject;
 const extractAndSimplify = (data, returnProperty, fallback = undefined) => {
-    try {
-        const selectedProperty = returnProperty ? (0, extract_1.default)(data, returnProperty, fallback) : data;
-        if (Array.isArray(selectedProperty))
-            return selectedProperty.map((item) => (0, exports.simplifyObject)(item));
-        if (returnProperty) {
-            if (selectedProperty === null)
-                return null;
-            return (0, exports.simplifyObject)(selectedProperty);
-        }
-        return selectedProperty;
-    }
-    catch (err) {
-        throw err;
+    const selectedProperty = returnProperty ? (0, extract_1.default)(data, returnProperty, fallback) : data;
+    if (Array.isArray(selectedProperty))
+        return selectedProperty.map((item) => (0, exports.simplifyObject)(item));
+    if (returnProperty) {
+        if (selectedProperty === null)
+            return null;
+        return (0, exports.simplifyObject)(selectedProperty);
     }
+    return selectedProperty;
 };
 exports.extractAndSimplify = extractAndSimplify;
 const isFullUrl = (url) => /^https?:\/\/.+/.test(url);

package/build/shorthandSyntax.js

@@ -7,7 +7,7 @@ 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 functionStringRegex = /(\$[^()]+)\((.*)\)/;
 const preProcessShorthand = (expression, fragments = {}, useShorthand = true) => {
     if (!useShorthand)
         return expression;

package/build/typeCheck.d.ts

@@ -1,8 +1,12 @@
-export type ExpectedType = 'string' | 'boolean' | 'number' | 'array' | 'undefined' | 'null' | 'object' | 'any';
+export type BasicType = 'any' | 'string' | 'boolean' | 'number' | 'array' | 'object' | 'null' | 'undefined';
+export type LiteralType = {
+    literal: (string | undefined)[];
+};
+export type ExpectedType = BasicType | LiteralType | BasicType[];
 export type TypeCheckInput = {
-    value: unknown;
     name?: string;
-    not?: boolean;
-    expectedType: ExpectedType | ExpectedType[];
+    value: unknown;
+    expectedType: ExpectedType;
 };
+export declare const isLiteralType: (typeDefinition: ExpectedType) => typeDefinition is LiteralType;
 export declare const typeCheck: (...args: TypeCheckInput[]) => true | string;