fig-tree-evaluator 2.9.0 → 2.11.0

package/build/FigTreeEvaluator.js

@@ -1,121 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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.evaluateExpression = void 0;
-const evaluate_1 = require("./evaluate");
-const typeCheck_1 = require("./typeCheck");
-const _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
-const operators = __importStar(require("./operators"));
-const helpers_1 = require("./helpers");
-const cache_1 = __importDefault(require("./cache"));
-const version_1 = require("./version");
-const operatorAliases = _operatorAliases_json_1.default;
-class FigTreeEvaluator {
-    constructor(options = {}) {
-        var _a, _b;
-        this.typeChecker = (...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.getCache = () => this.cache.getCache();
-        this.setCache = (cache) => this.cache.setCache(cache);
-        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;
-        this.cache = new cache_1.default({ maxSize: options.maxCacheSize, maxTime: options.maxCacheTime });
-    }
-    evaluate(expression, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentOptions = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
-            if (currentOptions.maxCacheSize && currentOptions.maxCacheSize !== this.cache.getMax())
-                this.cache.setMax(currentOptions.maxCacheSize);
-            if (currentOptions.maxCacheTime && currentOptions.maxCacheTime !== this.cache.getMaxTime())
-                this.cache.setMaxTime(currentOptions.maxCacheTime);
-            return yield (0, evaluate_1.evaluatorFunction)(expression, {
-                options: currentOptions,
-                operators: options.excludeOperators
-                    ? (0, helpers_1.filterOperators)(operators, options.excludeOperators, operatorAliases)
-                    : this.operators,
-                operatorAliases: this.operatorAliases,
-                typeChecker: currentOptions.skipRuntimeTypeCheck
-                    ? () => {
-                    }
-                    : this.typeChecker,
-                resolvedAliasNodes: {},
-                cache: this.cache,
-            });
-        });
-    }
-    getOptions() {
-        return this.options;
-    }
-    updateOptions(options) {
-        this.options = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
-        if (this.options.excludeOperators)
-            this.operators = (0, helpers_1.filterOperators)(operators, this.options.excludeOperators, operatorAliases);
-    }
-    getOperators() {
-        const validOperators = this.options.excludeOperators
-            ? (0, helpers_1.filterOperators)(operators, this.options.excludeOperators, operatorAliases)
-            : this.operators;
-        return Object.entries(validOperators).map(([key, value]) => (Object.assign({ operator: key }, value.operatorData)));
-    }
-    getFragments() {
-        var _a;
-        return Object.entries((_a = this.options.fragments) !== null && _a !== void 0 ? _a : {}).map(([key, value]) => (Object.assign({ name: key }, value === null || value === void 0 ? void 0 : value.metadata)));
-    }
-    getCustomFunctions() {
-        var _a;
-        return Object.entries((_a = this.options.functions) !== null && _a !== void 0 ? _a : {}).map(([name, value]) => ({
-            name,
-            numRequiredArgs: value.length,
-        }));
-    }
-}
-exports.default = FigTreeEvaluator;
-const evaluateExpression = (expression, options) => new FigTreeEvaluator(options).evaluate(expression);
-exports.evaluateExpression = evaluateExpression;
-const standardiseOptionNames = (options) => {
-    if ('objects' in options) {
-        return Object.assign(Object.assign({}, options), { data: options.objects });
-    }
-    return options;
-};

package/build/cache.d.ts

@@ -1,27 +0,0 @@
-import { EvaluatorOutput, UnknownFunction } from './types';
-interface CacheOptions {
-    maxSize?: number;
-    maxTime?: number;
-}
-export interface Store {
-    [key: string]: {
-        result: EvaluatorOutput;
-        timestamp: number;
-    };
-}
-declare class FigTreeCache {
-    private store;
-    private queue;
-    private maxSize;
-    private maxTime;
-    constructor(options?: CacheOptions);
-    useCache: (shouldUseCache: boolean, action: UnknownFunction, ...args: unknown[]) => Promise<EvaluatorOutput>;
-    getMax: () => number;
-    setMax: (size: number) => void;
-    getMaxTime: () => number;
-    setMaxTime: (time: number) => void;
-    getCache: () => Store;
-    setCache: (cache: Store) => Store;
-    private resizeCache;
-}
-export default FigTreeCache;

package/build/cache.js

@@ -1,63 +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 });
-const MAX_CACHED_ITEMS = 50;
-const MAX_CACHE_TIME = 1800;
-class FigTreeCache {
-    constructor(options) {
-        var _a, _b;
-        this.useCache = (shouldUseCache, action, ...args) => __awaiter(this, void 0, void 0, function* () {
-            if (!shouldUseCache)
-                return yield action(...args);
-            const key = stringifyInput(args);
-            const keyExists = key in this.store;
-            const newTimestamp = Date.now();
-            const isExpired = keyExists && newTimestamp - this.store[key].timestamp > this.maxTime * 1000;
-            if (keyExists) {
-                this.queue = this.queue.filter((val) => val !== key);
-                this.queue.unshift(key);
-                this.store[key].timestamp = newTimestamp;
-                if (isExpired)
-                    this.store[key].result = yield action(...args);
-                return this.store[key].result;
-            }
-            const result = yield action(...args);
-            this.store[key] = { result, timestamp: newTimestamp };
-            this.queue.unshift(key);
-            this.resizeCache();
-            return result;
-        });
-        this.getMax = () => this.maxSize;
-        this.setMax = (size) => {
-            this.maxSize = size;
-            this.resizeCache();
-        };
-        this.getMaxTime = () => this.maxTime;
-        this.setMaxTime = (time) => {
-            this.maxTime = time;
-        };
-        this.getCache = () => this.store;
-        this.setCache = (cache) => (this.store = cache);
-        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 = [];
-        this.maxSize = (_a = options === null || options === void 0 ? void 0 : options.maxSize) !== null && _a !== void 0 ? _a : MAX_CACHED_ITEMS;
-        this.maxTime = (_b = options === null || options === void 0 ? void 0 : options.maxTime) !== null && _b !== void 0 ? _b : MAX_CACHE_TIME;
-    }
-}
-exports.default = FigTreeCache;
-const stringifyInput = (args) => args.map((arg) => (typeof arg === 'object' ? JSON.stringify(arg) : arg)).join('_');

package/build/evaluate.d.ts

@@ -1,2 +0,0 @@
-import { FigTreeConfig, EvaluatorNode, EvaluatorOutput } from './types';
-export declare const evaluatorFunction: (input: EvaluatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;

package/build/evaluate.js

@@ -1,87 +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.evaluatorFunction = void 0;
-const _operatorUtils_1 = require("./operators/_operatorUtils");
-const shorthandSyntax_1 = require("./shorthandSyntax");
-const helpers_1 = require("./helpers");
-const evaluatorFunction = (input, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d;
-    const { options, operators, operatorAliases } = config;
-    let expression = (options === null || options === void 0 ? void 0 : options.allowJSONStringInput) ? (0, helpers_1.parseIfJson)(input) : input;
-    expression = (0, shorthandSyntax_1.preProcessShorthand)(expression, (_a = config.options) === null || _a === void 0 ? void 0 : _a.fragments, !options.noShorthand);
-    if (Array.isArray(expression)) {
-        expression = yield (0, _operatorUtils_1.evaluateArray)(expression, config);
-    }
-    const isOperator = (0, helpers_1.isOperatorNode)(expression);
-    const isFragment = (0, helpers_1.isFragmentNode)(expression);
-    if (options.evaluateFullObject && !isOperator && !isFragment)
-        return (0, helpers_1.replaceAliasNodeValues)(yield (0, helpers_1.evaluateObject)(expression, config), config);
-    if (!isOperator && !isFragment) {
-        if (options.supportDeprecatedValueNodes && (0, helpers_1.isObject)(expression) && 'value' in expression)
-            return expression.value;
-        return (0, helpers_1.replaceAliasNodeValues)(expression, config);
-    }
-    const { fallback } = expression;
-    const returnErrorAsString = (_b = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _b !== void 0 ? _b : false;
-    if (isFragment) {
-        const [fragment, parameters] = (yield (0, _operatorUtils_1.evaluateArray)([expression.fragment, expression.parameters], config));
-        const fragmentReplacement = (0, shorthandSyntax_1.preProcessShorthand)((_c = options === null || options === void 0 ? void 0 : options.fragments) === null || _c === void 0 ? void 0 : _c[fragment], options.fragments, !options.noShorthand);
-        if (fragmentReplacement === undefined)
-            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Fragment not defined: ${fragment}`, returnErrorAsString);
-        if (!(0, helpers_1.isOperatorNode)(fragmentReplacement))
-            return (0, helpers_1.replaceAliasNodeValues)(fragmentReplacement, config);
-        expression = Object.assign(Object.assign(Object.assign({}, expression), fragmentReplacement), parameters);
-        delete expression.fragment;
-    }
-    try {
-        const operator = (0, helpers_1.getOperatorName)(expression.operator, operatorAliases);
-        if (!operator)
-            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 { 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;
-        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) {
-            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)
-            return result;
-        const evaluatedOutputType = (yield (0, exports.evaluatorFunction)(outputType, config));
-        if (!(evaluatedOutputType in helpers_1.convertOutputMethods))
-            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- Invalid output type: ${evaluatedOutputType}`, returnErrorAsString);
-        else {
-            return helpers_1.convertOutputMethods[evaluatedOutputType](result);
-        }
-    }
-    catch (err) {
-        return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), (0, helpers_1.errorMessage)(err), returnErrorAsString);
-    }
-});
-exports.evaluatorFunction = evaluatorFunction;

package/build/helpers.d.ts

@@ -1,23 +0,0 @@
-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) => 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: EvaluatorOutput, errorMessage: string, returnErrorAsString?: boolean) => string | number | boolean | object | null;
-export declare const mapPropertyAliases: (propertyAliases: {
-    [key: string]: string;
-}, expression: OperatorNode) => OperatorNode;
-export declare const isAliasString: (value: string) => boolean;
-export declare const evaluateNodeAliases: (expression: OperatorNode, config: FigTreeConfig) => Promise<{
-    [x: string]: EvaluatorOutput;
-}>;
-export declare const replaceAliasNodeValues: (value: EvaluatorOutput, { resolvedAliasNodes }: FigTreeConfig) => EvaluatorOutput;
-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) => input is object;
-export declare const evaluateObject: (input: EvaluatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;

package/build/helpers.js

@@ -1,137 +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.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");
-const parseIfJson = (input) => {
-    if (typeof input !== 'string')
-        return input;
-    try {
-        const parsedInput = JSON.parse(input);
-        return (0, exports.isOperatorNode)(parsedInput) ? parsedInput : input;
-    }
-    catch (err) {
-        return input;
-    }
-};
-exports.parseIfJson = parseIfJson;
-const isOperatorNode = (input) => input instanceof Object && 'operator' in input;
-exports.isOperatorNode = isOperatorNode;
-const isFragmentNode = (input) => input instanceof Object && 'fragment' in input;
-exports.isFragmentNode = isFragmentNode;
-const standardiseOperatorName = (name) => {
-    const camelCaseName = (0, change_case_1.camelCase)(name);
-    return camelCaseName ? camelCaseName : name;
-};
-const getOperatorName = (operator, operatorAliases) => operatorAliases[standardiseOperatorName(operator)];
-exports.getOperatorName = getOperatorName;
-const filterOperators = (operators, exclusions, operatorAliases) => {
-    const filteredOperators = Object.assign({}, operators);
-    exclusions.forEach((exclusion) => {
-        const operator = operatorAliases[standardiseOperatorName(exclusion)];
-        if (!operator)
-            console.warn(`Invalid operator exclusion: ${exclusion}`);
-        delete filteredOperators[operatorAliases[standardiseOperatorName(exclusion)]];
-    });
-    return filteredOperators;
-};
-exports.filterOperators = filterOperators;
-const truncateString = (string, length = 200) => string.length < length ? string : `${string.slice(0, length - 2).trim()}...`;
-exports.truncateString = truncateString;
-const fallbackOrError = (fallback, errorMessage, returnErrorAsString = false) => {
-    if (fallback !== undefined)
-        return fallback;
-    if (returnErrorAsString)
-        return (0, exports.truncateString)(errorMessage);
-    else
-        throw new Error((0, exports.truncateString)(errorMessage));
-};
-exports.fallbackOrError = fallbackOrError;
-const mapPropertyAliases = (propertyAliases, expression) => mapObjectKeys(expression, (key) => key in propertyAliases ? propertyAliases[key] : key);
-exports.mapPropertyAliases = mapPropertyAliases;
-const mapObjectKeys = (inputObj, mapFunction) => {
-    const keyVals = Object.entries(inputObj);
-    const mappedKeys = keyVals.map(([key, value]) => [mapFunction(key), value]);
-    return Object.fromEntries(mappedKeys);
-};
-const isAliasString = (value) => /^\$.+/.test(value);
-exports.isAliasString = isAliasString;
-const evaluateNodeAliases = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const aliasKeys = Object.keys(expression).filter(exports.isAliasString);
-    if (aliasKeys.length === 0)
-        return {};
-    const evaluations = [];
-    aliasKeys.forEach((alias) => evaluations.push((0, evaluate_1.evaluatorFunction)(expression[alias], config)));
-    return (0, _operatorUtils_1.zipArraysToObject)(aliasKeys, yield Promise.all(evaluations));
-});
-exports.evaluateNodeAliases = evaluateNodeAliases;
-const replaceAliasNodeValues = (value, { resolvedAliasNodes }) => {
-    var _a;
-    if (typeof value !== 'string' || !(0, exports.isAliasString)(value))
-        return value;
-    return (_a = resolvedAliasNodes === null || resolvedAliasNodes === void 0 ? void 0 : resolvedAliasNodes[value]) !== null && _a !== void 0 ? _a : value;
-};
-exports.replaceAliasNodeValues = replaceAliasNodeValues;
-const mergeOptions = (origOptions, newOptions) => {
-    const combinedOptions = Object.assign(Object.assign({}, origOptions), newOptions);
-    if (origOptions.data || newOptions.data)
-        combinedOptions.data = Object.assign(Object.assign({}, origOptions.data), newOptions.data);
-    if (origOptions.functions || newOptions.functions)
-        combinedOptions.functions = Object.assign(Object.assign({}, origOptions.functions), newOptions.functions);
-    if (origOptions.fragments || newOptions.fragments)
-        combinedOptions.fragments = Object.assign(Object.assign({}, origOptions.fragments), newOptions.fragments);
-    if (origOptions.headers || newOptions.headers)
-        combinedOptions.headers = Object.assign(Object.assign({}, origOptions.headers), newOptions.headers);
-    return combinedOptions;
-};
-exports.mergeOptions = mergeOptions;
-exports.convertOutputMethods = {
-    number: (value) => extractNumber(value),
-    string: (value) => String(value),
-    array: (value) => (Array.isArray(value) ? value : [value]),
-    boolean: (value) => Boolean(value),
-    bool: (value) => Boolean(value),
-};
-const errorMessage = (err) => err.message;
-exports.errorMessage = errorMessage;
-const extractNumber = (input) => {
-    if (typeof input !== 'string')
-        return Number.isNaN(Number(input)) ? input : Number(input);
-    const pattern = new RegExp(/-?\d*\.?\d+/gm);
-    const numberMatch = input.match(pattern);
-    if (!numberMatch)
-        return 0;
-    return Number(numberMatch[0]);
-};
-const isObject = (input) => typeof input === 'object' && input !== null && !Array.isArray(input);
-exports.isObject = isObject;
-const evaluateObject = (input, config) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!(0, exports.isObject)(input))
-        return input;
-    const newObjectEntries = [];
-    const newAliases = [];
-    Object.entries(input).forEach(([key, value]) => {
-        if ((0, exports.isAliasString)(key)) {
-            newAliases.push(key, (0, evaluate_1.evaluatorFunction)(value, config));
-            delete input[key];
-        }
-    });
-    const aliasArray = yield Promise.all(newAliases);
-    config.resolvedAliasNodes = Object.assign(Object.assign({}, config.resolvedAliasNodes), (0, _operatorUtils_1.singleArrayToObject)(aliasArray));
-    Object.entries(input).forEach(([key, value]) => {
-        newObjectEntries.push(key, (0, evaluate_1.evaluatorFunction)(value, config));
-    });
-    const results = yield Promise.all(newObjectEntries);
-    return (0, exports.replaceAliasNodeValues)((0, _operatorUtils_1.singleArrayToObject)(results), config);
-});
-exports.evaluateObject = evaluateObject;

package/build/index.js

@@ -1,29 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateExpression = void 0;
-const FigTreeEvaluator_1 = __importStar(require("./FigTreeEvaluator"));
-Object.defineProperty(exports, "evaluateExpression", { enumerable: true, get: function () { return FigTreeEvaluator_1.evaluateExpression; } });
-exports.default = FigTreeEvaluator_1.default;

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

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

package/build/operators/AND/data.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.propertyAliases = void 0;
-const _operatorUtils_1 = require("../_operatorUtils");
-const description = 'Logical AND';
-const aliases = ['and', '&', '&&'];
-const parameters = [
-    {
-        name: 'values',
-        description: 'Returns true if all values are true',
-        aliases: [],
-        required: true,
-        type: 'array',
-    },
-];
-exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
-const operatorData = {
-    description,
-    aliases,
-    parameters,
-};
-exports.default = operatorData;

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

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

package/build/operators/AND/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AND = void 0;
-var operator_1 = require("./operator");
-Object.defineProperty(exports, "AND", { enumerable: true, get: function () { return operator_1.AND; } });

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

@@ -1,3 +0,0 @@
-import { OperatorObject, ParseChildrenMethod } from '../../types';
-export declare const parseChildren: ParseChildrenMethod;
-export declare const AND: OperatorObject;

package/build/operators/AND/operator.js

@@ -1,53 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AND = exports.parseChildren = void 0;
-const _operatorUtils_1 = require("../_operatorUtils");
-const 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 }));
-    return values.reduce((acc, val) => acc && !!val, true);
-});
-const parseChildren = (expression) => {
-    const values = expression.children;
-    return Object.assign(Object.assign({}, expression), { values });
-};
-exports.parseChildren = parseChildren;
-exports.AND = {
-    propertyAliases: data_1.propertyAliases,
-    operatorData: data_1.default,
-    evaluate,
-    parseChildren: exports.parseChildren,
-};

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

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

package/build/operators/BUILD_OBJECT/data.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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';
-const parameters = [
-    {
-        name: 'properties',
-        description: 'An array of objects, each with a "key" property and a "value" property',
-        aliases: ['values', 'keyValPairs', 'keyValuePairs'],
-        required: true,
-        type: 'array',
-    },
-];
-exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
-const operatorData = {
-    description,
-    aliases,
-    parameters,
-};
-exports.default = operatorData;

package/build/operators/BUILD_OBJECT/index.d.ts

@@ -1 +0,0 @@
-export * from './operator';

package/build/operators/BUILD_OBJECT/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./operator"), exports);

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

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