fig-tree-evaluator 2.8.0 → 2.8.4

package/README.md

@@ -883,7 +883,7 @@ Aliases: `get`, `api`
 #### Properties
 
 - `url` (or `endpoint`)<sup>*</sup>: (string) -- url to be queried
-- `parameters`: (object) -- key-value pairs for any query parameters for the request
+- `parameters` (or `queryParams`, `queryParameters`, `urlQueries`): (object) -- key-value pairs for any query parameters for the request
 - `headers`: (object) -- any additional headers (such as authentication) required for the request
 - `returnProperty` (or `outputProperty`): (string) -- an object path for which property to extract from the returned data. E.g. if the API returns `{name: {first: "Bruce", last: "Banner"}, age: 35}` and you specify `returnProperty: "name.first`, the operator will return `"Bruce"` (Uses the same logic as the [objectProperties](#object_properties) internally)
 
@@ -946,7 +946,8 @@ The "POST" operator is basically structurally the same as [GET](#get).
 
 #### Properties
 
-- `url`/`endpoint`<sup>*</sup>,`parameters`, `headers`, `returnProperty`/`outputProperty` -- same as "GET" operator (although the `parameters` object will be passed to the Post request as body JSON rather than url query parameters)
+- `url`/`endpoint`<sup>*</sup>, `headers`, `returnProperty`/`outputProperty` -- same as "GET" operator.
+- `parameters` (or `bodyJson`, `data`) -- passed to the Post request as body JSON rather than url query parameters (hence the different aliases)
 
 e.g.
 ```js
@@ -1690,6 +1691,7 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 
 *Trivial upgrades (e.g. documentation, small re-factors, types, etc.) not included*
 
+- **v2.8.4**: Refactor types, better compliance with [ESLint](https://eslint.org/) rules, add more tests
 - **v2.8.0**:
   - [Shorthand syntax](#shorthand-syntax) (#80)
   - Methods to retrieve [metadata](#metadata) about operators, fragments and functions (#82)

package/build/FigTreeEvaluator.d.ts

@@ -1,4 +1,4 @@
-import { EvaluatorNode, FigTreeOptions } from './types';
+import { EvaluatorNode, FigTreeOptions, OperatorMetadata, FragmentMetadata } from './types';
 declare class FigTreeEvaluator {
     private options;
     private operators;
@@ -9,25 +9,15 @@ declare class FigTreeEvaluator {
     evaluate(expression: EvaluatorNode, options?: FigTreeOptions): Promise<import("./types").EvaluatorOutput>;
     getOptions(): FigTreeOptions;
     updateOptions(options: FigTreeOptions): void;
-    getOperators(): {
-        description: string;
-        aliases: string[];
-        parameters: import("./types").Parameter[];
-        operator: string;
-    }[];
-    getFragments(): {
-        description?: string | undefined;
-        parameters?: Record<string, {
-            type: string | string[];
-            required: boolean;
-        }> | undefined;
+    getOperators(): readonly OperatorMetadata[];
+    getFragments(): readonly (FragmentMetadata & {
         name: string;
-    }[];
-    getCustomFunctions(): {
+    })[];
+    getCustomFunctions(): readonly {
         name: string;
         numRequiredArgs: number;
     }[];
-    getVersion: () => any;
+    getVersion: () => string;
 }
 export default FigTreeEvaluator;
 export declare const evaluateExpression: (expression: EvaluatorNode, options?: FigTreeOptions) => Promise<import("./types").EvaluatorOutput>;

package/build/FigTreeEvaluator.js

@@ -42,18 +42,19 @@ const _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAl
 const operators = __importStar(require("./operators"));
 const helpers_1 = require("./helpers");
 const cache_1 = __importDefault(require("./cache"));
-const pkg = require('../package.json');
+const version_1 = require("./version");
 const operatorAliases = _operatorAliases_json_1.default;
 class FigTreeEvaluator {
     constructor(options = {}) {
         var _a, _b;
         this.typeChecker = (...args) => {
-            const result = (0, typeCheck_1.typeCheck)(...args);
+            const inputArgs = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+            const result = (0, typeCheck_1.typeCheck)(...inputArgs);
             if (result === true)
                 return;
             throw new Error(result);
         };
-        this.getVersion = () => pkg.version;
+        this.getVersion = () => version_1.version;
         this.options = standardiseOptionNames(options);
         this.operators = (0, helpers_1.filterOperators)(operators, (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.excludeOperators) !== null && _b !== void 0 ? _b : [], operatorAliases);
         this.operatorAliases = operatorAliases;
@@ -70,7 +71,10 @@ class FigTreeEvaluator {
                     ? (0, helpers_1.filterOperators)(operators, options.excludeOperators, operatorAliases)
                     : this.operators,
                 operatorAliases: this.operatorAliases,
-                typeChecker: currentOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
+                typeChecker: currentOptions.skipRuntimeTypeCheck
+                    ? () => {
+                    }
+                    : this.typeChecker,
                 resolvedAliasNodes: {},
                 cache: this.cache,
             });

package/build/cache.d.ts

@@ -1,10 +1,12 @@
+import { EvaluatorOutput, UnknownFunction } from './types';
 declare class FigTreeCache {
     private store;
     private queue;
     private maxSize;
     constructor(maxSize?: number);
-    useCache: (shouldUseCache: boolean, action: Function, ...args: unknown[]) => Promise<any>;
+    useCache: (shouldUseCache: boolean, action: UnknownFunction, ...args: unknown[]) => Promise<EvaluatorOutput>;
     getMax: () => number;
     setMax: (size: number) => void;
+    private resizeCache;
 }
 export default FigTreeCache;

package/build/cache.js

@@ -23,17 +23,21 @@ class FigTreeCache {
             }
             const result = yield action(...args);
             this.store[key] = result;
-            if (this.queue.length >= this.maxSize) {
-                const keysToRemove = this.queue.slice(this.maxSize - 1);
-                keysToRemove.forEach((key) => delete this.store[key]);
-                this.queue = this.queue.slice(0, this.maxSize - 1);
-            }
             this.queue.unshift(key);
+            this.resizeCache();
             return result;
         });
         this.getMax = () => this.maxSize;
         this.setMax = (size) => {
             this.maxSize = size;
+            this.resizeCache();
+        };
+        this.resizeCache = () => {
+            if (this.queue.length > this.maxSize) {
+                const keysToRemove = this.queue.slice(this.maxSize);
+                keysToRemove.forEach((key) => delete this.store[key]);
+                this.queue = this.queue.slice(0, this.maxSize);
+            }
         };
         this.store = {};
         this.queue = [];
@@ -41,9 +45,4 @@ class FigTreeCache {
     }
 }
 exports.default = FigTreeCache;
-const stringifyInput = (args) => {
-    return args.reduce((outputString, arg, index) => {
-        const part = typeof arg === 'object' ? JSON.stringify(arg) : arg;
-        return index === 0 ? `${part}` : `${outputString}_${part}`;
-    }, '');
-};
+const stringifyInput = (args) => args.map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : arg)).join('_');

package/build/evaluate.js

@@ -41,7 +41,6 @@ const evaluatorFunction = (input, config) => __awaiter(void 0, void 0, void 0, f
             return (0, helpers_1.replaceAliasNodeValues)(fragmentReplacement, config);
         expression = Object.assign(Object.assign(Object.assign({}, expression), fragmentReplacement), parameters);
         delete expression.fragment;
-        delete expression.parameters;
     }
     try {
         const operator = (0, helpers_1.getOperatorName)(expression.operator, operatorAliases);
@@ -49,29 +48,27 @@ const evaluatorFunction = (input, config) => __awaiter(void 0, void 0, void 0, f
             return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Invalid operator: ${expression.operator}`, returnErrorAsString);
         if (!config.operators[operator])
             return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Excluded operator: ${expression.operator}`, returnErrorAsString);
-        const { requiredProperties, propertyAliases, evaluate, parseChildren } = operators[operator];
+        const { propertyAliases, evaluate, parseChildren } = operators[operator];
         expression = (0, helpers_1.mapPropertyAliases)(propertyAliases, expression);
         const newAliasNodes = yield (0, helpers_1.evaluateNodeAliases)(expression, config);
         if (!isFragment)
             Object.entries(newAliasNodes).forEach(([alias, result]) => (config.resolvedAliasNodes[alias] = result));
         const childConfig = isFragment
             ? Object.assign(Object.assign({}, config), { resolvedAliasNodes: Object.assign(Object.assign({}, config.resolvedAliasNodes), newAliasNodes) }) : config;
-        const validationError = (0, helpers_1.checkRequiredNodes)(requiredProperties, expression);
-        if (validationError)
-            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, childConfig), `Operator: ${operator}\n- ${validationError}`, returnErrorAsString);
         if ('children' in expression) {
             if (!Array.isArray(expression.children))
                 expression.children = yield (0, exports.evaluatorFunction)(expression.children, childConfig);
             if (!Array.isArray(expression.children))
                 return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- Property "children" is not of type: array`, returnErrorAsString);
             expression = yield parseChildren(expression, childConfig);
+            delete expression.children;
         }
         let result;
         try {
             result = yield evaluate(expression, childConfig);
         }
         catch (err) {
-            result = (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(expression.fallback, config), `Operator: ${operator}\n${(0, helpers_1.errorMessage)(err)}`, returnErrorAsString);
+            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(expression.fallback, config), `Operator: ${operator}\n${(0, helpers_1.errorMessage)(err)}`, returnErrorAsString);
         }
         const outputType = (_d = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _d !== void 0 ? _d : expression === null || expression === void 0 ? void 0 : expression.type;
         if (!outputType)

package/build/helpers.d.ts

@@ -1,49 +1,23 @@
-import { OutputType, EvaluatorNode, CombinedOperatorNode, EvaluatorOutput, FigTreeOptions, OperatorNodeUnion, FigTreeConfig, OperatorReference, OperatorAliases } from './types';
+import { OutputType, EvaluatorNode, EvaluatorOutput, FigTreeOptions, FigTreeConfig, OperatorReference, OperatorAliases, Operator, FragmentNode, OperatorNode } from './types';
 export declare const parseIfJson: (input: EvaluatorNode) => any;
 export declare const isOperatorNode: (input: EvaluatorNode) => boolean;
-export declare const isFragmentNode: (input: EvaluatorNode) => boolean;
-export declare const getOperatorName: (operator: string, operatorAliases: OperatorAliases) => "AND" | "OR" | "EQUAL" | "NOT_EQUAL" | "PLUS" | "SUBTRACT" | "MULTIPLY" | "DIVIDE" | "GREATER_THAN" | "LESS_THAN" | "CONDITIONAL" | "REGEX" | "OBJECT_PROPERTIES" | "STRING_SUBSTITUTION" | "SPLIT" | "COUNT" | "GET" | "POST" | "PG_SQL" | "GRAPHQL" | "BUILD_OBJECT" | "MATCH" | "CUSTOM_FUNCTIONS" | "PASSTHRU";
-export declare const filterOperators: (operators: OperatorReference, exclusions: string[], operatorAliases: OperatorAliases) => {
-    AND: import("./types").OperatorObject;
-    OR: import("./types").OperatorObject;
-    EQUAL: import("./types").OperatorObject;
-    NOT_EQUAL: import("./types").OperatorObject;
-    PLUS: import("./types").OperatorObject;
-    SUBTRACT: import("./types").OperatorObject;
-    MULTIPLY: import("./types").OperatorObject;
-    DIVIDE: import("./types").OperatorObject;
-    GREATER_THAN: import("./types").OperatorObject;
-    LESS_THAN: import("./types").OperatorObject;
-    CONDITIONAL: import("./types").OperatorObject;
-    REGEX: import("./types").OperatorObject;
-    OBJECT_PROPERTIES: import("./types").OperatorObject;
-    STRING_SUBSTITUTION: import("./types").OperatorObject;
-    SPLIT: import("./types").OperatorObject;
-    COUNT: import("./types").OperatorObject;
-    GET: import("./types").OperatorObject;
-    POST: import("./types").OperatorObject;
-    PG_SQL: import("./types").OperatorObject;
-    GRAPHQL: import("./types").OperatorObject;
-    BUILD_OBJECT: import("./types").OperatorObject;
-    MATCH: import("./types").OperatorObject;
-    CUSTOM_FUNCTIONS: import("./types").OperatorObject;
-    PASSTHRU: import("./types").OperatorObject;
-};
+export declare const isFragmentNode: (input: EvaluatorNode) => input is FragmentNode;
+export declare const getOperatorName: (operator: string, operatorAliases: OperatorAliases) => Operator | undefined;
+export declare const filterOperators: (operators: OperatorReference, exclusions: string[], operatorAliases: OperatorAliases) => OperatorReference;
 export declare const truncateString: (string: string, length?: number) => string;
-export declare const fallbackOrError: (fallback: any, errorMessage: string, returnErrorAsString?: boolean) => any;
+export declare const fallbackOrError: (fallback: EvaluatorOutput, errorMessage: string, returnErrorAsString?: boolean) => string | number | boolean | object | null;
 export declare const mapPropertyAliases: (propertyAliases: {
     [key: string]: string;
-}, expression: CombinedOperatorNode) => CombinedOperatorNode;
+}, expression: OperatorNode) => OperatorNode;
 export declare const isAliasString: (value: string) => boolean;
-export declare const evaluateNodeAliases: (expression: OperatorNodeUnion, config: FigTreeConfig) => Promise<{
+export declare const evaluateNodeAliases: (expression: OperatorNode, config: FigTreeConfig) => Promise<{
     [x: string]: EvaluatorOutput;
 }>;
 export declare const replaceAliasNodeValues: (value: EvaluatorOutput, { resolvedAliasNodes }: FigTreeConfig) => EvaluatorOutput;
-export declare const checkRequiredNodes: (requiredProps: readonly string[], expression: CombinedOperatorNode) => string | false;
 export declare const mergeOptions: (origOptions: FigTreeOptions, newOptions: FigTreeOptions) => FigTreeOptions;
 export declare const convertOutputMethods: {
     [key in OutputType]: (value: EvaluatorOutput) => EvaluatorOutput | EvaluatorOutput[];
 };
 export declare const errorMessage: (err: unknown) => string;
-export declare const isObject: (input: unknown) => boolean;
+export declare const isObject: (input: unknown) => input is object;
 export declare const evaluateObject: (input: EvaluatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;

package/build/helpers.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateObject = exports.isObject = exports.errorMessage = exports.convertOutputMethods = exports.mergeOptions = exports.checkRequiredNodes = exports.replaceAliasNodeValues = exports.evaluateNodeAliases = exports.isAliasString = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.filterOperators = exports.getOperatorName = exports.isFragmentNode = exports.isOperatorNode = exports.parseIfJson = void 0;
+exports.evaluateObject = exports.isObject = exports.errorMessage = exports.convertOutputMethods = exports.mergeOptions = exports.replaceAliasNodeValues = exports.evaluateNodeAliases = exports.isAliasString = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.filterOperators = exports.getOperatorName = exports.isFragmentNode = exports.isOperatorNode = exports.parseIfJson = void 0;
 const change_case_1 = require("change-case");
 const evaluate_1 = require("./evaluate");
 const _operatorUtils_1 = require("./operators/_operatorUtils");
@@ -82,15 +82,6 @@ const replaceAliasNodeValues = (value, { resolvedAliasNodes }) => {
     return (_a = resolvedAliasNodes === null || resolvedAliasNodes === void 0 ? void 0 : resolvedAliasNodes[value]) !== null && _a !== void 0 ? _a : value;
 };
 exports.replaceAliasNodeValues = replaceAliasNodeValues;
-const checkRequiredNodes = (requiredProps, expression) => {
-    const missingProps = requiredProps.filter((prop) => !(prop in expression));
-    if (missingProps.length === 0)
-        return false;
-    if (!('children' in expression))
-        return `Missing properties: ${missingProps}`;
-    return false;
-};
-exports.checkRequiredNodes = checkRequiredNodes;
 const mergeOptions = (origOptions, newOptions) => {
     const combinedOptions = Object.assign(Object.assign({}, origOptions), newOptions);
     if (origOptions.data || newOptions.data)

package/build/index.d.ts

@@ -1,4 +1,4 @@
 import FigTreeEvaluator, { evaluateExpression } from './FigTreeEvaluator';
-import { Operator, GenericObject, FigTreeOptions, EvaluatorNode, EvaluatorOutput } from './types';
-export { evaluateExpression, type Operator, type GenericObject, type FigTreeOptions, type EvaluatorNode, type EvaluatorOutput, };
+import { Operator, FigTreeOptions, EvaluatorNode, EvaluatorOutput } from './types';
+export { evaluateExpression, type Operator, type FigTreeOptions, type EvaluatorNode, type EvaluatorOutput, };
 export default FigTreeEvaluator;

package/build/operators/AND/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/AND/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 = 'Logical AND';
 const aliases = ['and', '&', '&&'];
@@ -13,7 +13,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/AND/index.d.ts

@@ -1 +1 @@
-export { AND, type BasicExtendedNode } from './operator';
+export { AND } from './operator';

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

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

package/build/operators/AND/operator.js

@@ -37,7 +37,7 @@ 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 = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
-    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values }));
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values }));
     return values.reduce((acc, val) => acc && !!val, true);
 });
 const parseChildren = (expression) => {
@@ -46,7 +46,6 @@ const parseChildren = (expression) => {
 };
 exports.parseChildren = parseChildren;
 exports.AND = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/BUILD_OBJECT/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/BUILD_OBJECT/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 aliases = ['buildObject', 'build', 'object'];
 const description = 'Construct an object using objects defining keys and values';
@@ -13,7 +13,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/BUILD_OBJECT/operator.d.ts

@@ -1,10 +1,2 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../../types';
-export type BuildObjectNode = {
-    properties: BuildObjectElement[];
-} & BaseOperatorNode;
-type BuildObjectElement = {
-    key: EvaluatorNode;
-    value: EvaluatorNode;
-};
+import { OperatorObject } from '../../types';
 export declare const BUILD_OBJECT: OperatorObject;
-export {};

package/build/operators/BUILD_OBJECT/operator.js

@@ -41,7 +41,7 @@ const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, funct
         config.typeChecker({ name: 'key', value: key, expectedType: ['string', 'number', 'boolean'] });
         return [key, value];
     });
-    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { properties: expression.properties }));
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { properties: expression.properties }));
     const evaluated = expression.properties
         .filter((element) => element instanceof Object && 'key' in element && 'value' in element)
         .map(({ key, value }) => evaluatePair([key, value]));
@@ -57,7 +57,6 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { properties });
 };
 exports.BUILD_OBJECT = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/CONDITIONAL/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/CONDITIONAL/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 = 'Return a value based on a condition';
 const aliases = ['?', 'conditional', 'ifThen'];
@@ -27,7 +27,6 @@ const parameters = [
         type: 'any',
     },
 ];
-exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
 exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
 const operatorData = {
     description,

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

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

package/build/operators/CONDITIONAL/operator.js

@@ -34,10 +34,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONDITIONAL = void 0;
 const evaluate_1 = require("../../evaluate");
+const _operatorUtils_1 = require("../_operatorUtils");
 const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, {
+        condition: expression.condition,
+        valueIfTrue: expression.valueIfTrue,
+        valueIfFalse: expression.valueIfFalse,
+    }));
     const condition = yield (0, evaluate_1.evaluatorFunction)(expression.condition, config);
-    return !!condition
+    return condition
         ? yield (0, evaluate_1.evaluatorFunction)(expression.valueIfTrue, config)
         : yield (0, evaluate_1.evaluatorFunction)(expression.valueIfFalse, config);
 });
@@ -46,7 +52,6 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { condition, valueIfTrue, valueIfFalse });
 };
 exports.CONDITIONAL = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/COUNT/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/COUNT/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 = 'Count elements in an array';
 const aliases = ['count', 'length'];
@@ -13,7 +13,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/COUNT/operator.js

@@ -38,11 +38,10 @@ 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 = yield (0, _operatorUtils_1.evaluateArray)(expression.values, config);
-    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values }));
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values }));
     return values.length;
 });
 exports.COUNT = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/CUSTOM_FUNCTIONS/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/CUSTOM_FUNCTIONS/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 = 'Call a custom function (defined in options)';
 const aliases = [
@@ -24,10 +24,16 @@ const parameters = [
         description: 'Arguments for the function',
         aliases: ['arguments', 'variables'],
         required: false,
-        type: ['array'],
+        type: 'array',
+    },
+    {
+        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/CUSTOM_FUNCTIONS/operator.d.ts

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

package/build/operators/CUSTOM_FUNCTIONS/operator.js

@@ -40,12 +40,14 @@ const object_property_extractor_1 = __importDefault(require("object-property-ext
 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, _d;
-    const [functionPath, ...args] = (yield (0, _operatorUtils_1.evaluateArray)([expression.functionPath, ...(expression.args || [])], config));
-    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { functionPath, args }));
+    var _a, _b, _c;
+    const [functionPath, args = [], useCache] = (yield (0, _operatorUtils_1.evaluateArray)([expression.functionPath, expression.args, expression.useCache], config));
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { functionPath, args }));
     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 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, null);
+    if (!func || typeof func !== 'function')
+        throw new Error(`- No function found: "${functionPath}"`);
+    const shouldUseCache = (_c = useCache !== null && useCache !== void 0 ? useCache : config.options.useCache) !== null && _c !== void 0 ? _c : false;
     const result = yield config.cache.useCache(shouldUseCache, (_, ...args) => __awaiter(void 0, void 0, void 0, function* () {
         return yield func(...args);
     }), functionPath, ...args);
@@ -56,7 +58,6 @@ const parseChildren = (expression) => {
     return Object.assign(Object.assign({}, expression), { functionPath, args });
 };
 exports.CUSTOM_FUNCTIONS = {
-    requiredProperties: data_1.requiredProperties,
     propertyAliases: data_1.propertyAliases,
     operatorData: data_1.default,
     evaluate,

package/build/operators/DIVIDE/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/DIVIDE/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 = 'Divide one numerical value by another';
 const aliases = ['/', 'divide', '÷'];
@@ -31,10 +31,9 @@ const parameters = [
         description: 'Whether to output a quotient, remainder or decimal',
         aliases: [],
         required: false,
-        type: 'string',
+        type: { literal: ['quotient', 'remainder'] },
     },
 ];
-exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
 exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
 const operatorData = {
     description,

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

@@ -1,12 +1,2 @@
-import { BasicExtendedNode } from '../AND/operator';
-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;
-};
+import { OperatorObject } from '../../types';
 export declare const DIVIDE: OperatorObject;
-export {};