fig-tree-evaluator 2.1.1 → 2.1.6

package/build/helpers.d.ts

@@ -16,6 +16,6 @@ export declare const replaceAliasNodeValues: (value: EvaluatorOutput, { resolved
 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]: <T>(value: T) => EvaluatorOutput | T[];
+    [key in OutputType]: (value: EvaluatorOutput) => EvaluatorOutput | EvaluatorOutput[];
 };
 export declare const errorMessage: (err: unknown) => string;

package/build/helpers.js

@@ -100,7 +100,8 @@ exports.errorMessage = errorMessage;
 const extractNumber = (input) => {
     if (typeof input !== 'string')
         return Number.isNaN(Number(input)) ? input : Number(input);
-    const numberMatch = input.match(/(-?(\d+\.\d+))|(-?((?<!\.)\.\d+))|(-?\d+)/gm);
+    const pattern = new RegExp(/-?\d*\.?\d+/gm);
+    const numberMatch = input.match(pattern);
     if (!numberMatch)
         return 0;
     return Number(numberMatch[0]);

package/build/index.d.ts

@@ -1,4 +1,5 @@
 import { EvaluatorNode, FigTreeOptions } from './types';
+export declare const getVersion: () => any;
 declare class FigTreeEvaluator {
     private options;
     private operators;
@@ -8,6 +9,7 @@ declare class FigTreeEvaluator {
     evaluate(expression: EvaluatorNode, options?: FigTreeOptions): Promise<import("./types").EvaluatorOutput>;
     getOptions(): FigTreeOptions;
     updateOptions(options: FigTreeOptions): void;
+    getVersion: () => any;
 }
 export default FigTreeEvaluator;
 export declare const evaluateExpression: (expression: EvaluatorNode, options?: FigTreeOptions) => Promise<import("./types").EvaluatorOutput>;

package/build/index.js

@@ -35,12 +35,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateExpression = void 0;
+exports.evaluateExpression = exports.getVersion = 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 pkg = require('../package.json');
+const getVersion = () => pkg.version;
+exports.getVersion = getVersion;
 class FigTreeEvaluator {
     constructor(options = {}) {
         this.typeChecker = (...args) => {
@@ -49,6 +52,7 @@ class FigTreeEvaluator {
                 return;
             throw new Error(result);
         };
+        this.getVersion = exports.getVersion;
         this.options = options;
         this.operators = operators;
         this.operatorAliases = _operatorAliases_json_1.default;

package/build/operators/buildObject.d.ts

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

package/build/operators/conditional.d.ts

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

package/build/operators/customFunctions.d.ts

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

package/build/operators/divide.d.ts

@@ -4,7 +4,7 @@ interface DivisionNodeWithProps extends BaseOperatorNode {
     dividend: EvaluatorNode;
     divisor: EvaluatorNode;
 }
-export declare type DivisionNode = BasicExtendedNode & DivisionNodeWithProps & {
+export type DivisionNode = BasicExtendedNode & DivisionNodeWithProps & {
     output?: 'quotient' | 'remainder';
 };
 export declare const DIVIDE: OperatorObject;

package/build/operators/getRequest.d.ts

@@ -1,6 +1,6 @@
 import { BaseOperatorNode, EvaluatorNode, FigTreeConfig, CombinedOperatorNode, GenericObject, OperatorObject } from '../types';
 declare const requiredProperties: readonly ["url"];
-export declare type APINode = {
+export type APINode = {
     [key in typeof requiredProperties[number]]: EvaluatorNode;
 } & BaseOperatorNode & {
     parameters?: EvaluatorNode;

package/build/operators/graphQL.d.ts

@@ -1,6 +1,6 @@
 import { BaseOperatorNode, EvaluatorNode, GenericObject, OperatorObject } from '../types';
 declare const requiredProperties: readonly ["query"];
-export declare type GraphQLNode = {
+export type GraphQLNode = {
     [key in typeof requiredProperties[number]]: EvaluatorNode;
 } & BaseOperatorNode & {
     url?: EvaluatorNode;

package/build/operators/greaterThan.d.ts

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

package/build/operators/logicalAnd.d.ts

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

package/build/operators/objectProperties.d.ts

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

package/build/operators/passThru.d.ts

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

package/build/operators/pgSQL.d.ts

@@ -1,6 +1,6 @@
 import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
 declare const requiredProperties: readonly ["query"];
-export declare type PGNode = {
+export type PGNode = {
     [key in typeof requiredProperties[number]]: EvaluatorNode;
 } & BaseOperatorNode & {
     values?: EvaluatorNode[];

package/build/operators/plus.d.ts

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

package/build/operators/regex.d.ts

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

package/build/operators/split.d.ts

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

package/build/operators/stringSubstitution.d.ts

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

package/build/operators/subtract.d.ts

@@ -4,6 +4,6 @@ interface SubtractionNodeWithProps extends BaseOperatorNode {
     subtract: EvaluatorNode;
     from: EvaluatorNode;
 }
-export declare type SubtractionNode = BasicExtendedNode & SubtractionNodeWithProps;
+export type SubtractionNode = BasicExtendedNode & SubtractionNodeWithProps;
 export declare const SUBTRACT: OperatorObject;
 export {};

package/build/typeCheck.d.ts

@@ -1,5 +1,5 @@
-declare type ExpectedType = 'string' | 'boolean' | 'number' | 'array' | 'undefined' | 'null' | 'object';
-export declare type TypeCheckInput = {
+type ExpectedType = 'string' | 'boolean' | 'number' | 'array' | 'undefined' | 'null' | 'object';
+export type TypeCheckInput = {
     value: unknown;
     name?: string;
     not?: boolean;

package/build/types.d.ts

@@ -1,8 +1,8 @@
 import { BasicExtendedNode, SubtractionNode, DivisionNode, ComparatorNode, ConditionalNode, RegexNode, StringSubNode, SplitNode, ObjPropNode, APINode, PGNode, GraphQLNode, BuildObjectNode, FunctionNode, PassThruNode, PGConnection, GraphQLConnection } from './operators';
 import { TypeCheckInput } from './typeCheck';
 export declare const Operators: readonly ["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", "CUSTOM_FUNCTIONS", "PASSTHRU"];
-export declare type Operator = typeof Operators[number];
-export declare type GenericObject = {
+export type Operator = typeof Operators[number];
+export type GenericObject = {
     [key: string]: any;
 };
 export interface FigTreeOptions {
@@ -32,7 +32,7 @@ export interface FigTreeConfig {
         [key: string]: EvaluatorOutput;
     };
 }
-export declare type OutputType = 'string' | 'number' | 'boolean' | 'bool' | 'array';
+export type OutputType = 'string' | 'number' | 'boolean' | 'bool' | 'array';
 export interface BaseOperatorNode {
     operator: Operator;
     outputType?: OutputType;
@@ -40,11 +40,11 @@ export interface BaseOperatorNode {
     fallback?: any;
     [key: string]: EvaluatorNode;
 }
-export declare type CombinedOperatorNode = BaseOperatorNode & BasicExtendedNode & SubtractionNode & DivisionNode & ComparatorNode & ConditionalNode & RegexNode & StringSubNode & SplitNode & ObjPropNode & APINode & PGNode & GraphQLNode & BuildObjectNode & FunctionNode & PassThruNode;
-export declare type OperatorNodeUnion = BasicExtendedNode | SubtractionNode | DivisionNode | ComparatorNode | ConditionalNode | RegexNode | StringSubNode | SplitNode | ObjPropNode | PGNode | GraphQLNode | APINode | BuildObjectNode | FunctionNode | PassThruNode;
-export declare type EvaluatorOutput = string | boolean | number | GenericObject | null | undefined | any[];
-export declare type EvaluatorNode = CombinedOperatorNode | EvaluatorOutput;
-export declare type OperatorObject = {
+export type CombinedOperatorNode = BaseOperatorNode & BasicExtendedNode & SubtractionNode & DivisionNode & ComparatorNode & ConditionalNode & RegexNode & StringSubNode & SplitNode & ObjPropNode & APINode & PGNode & GraphQLNode & BuildObjectNode & FunctionNode & PassThruNode;
+export type OperatorNodeUnion = BasicExtendedNode | SubtractionNode | DivisionNode | ComparatorNode | ConditionalNode | RegexNode | StringSubNode | SplitNode | ObjPropNode | PGNode | GraphQLNode | APINode | BuildObjectNode | FunctionNode | PassThruNode;
+export type EvaluatorOutput = string | boolean | number | GenericObject | null | undefined | any[];
+export type EvaluatorNode = CombinedOperatorNode | EvaluatorOutput;
+export type OperatorObject = {
     requiredProperties: readonly string[];
     operatorAliases: string[];
     propertyAliases: {
@@ -53,6 +53,6 @@ export declare type OperatorObject = {
     evaluate: (expression: CombinedOperatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;
     parseChildren: (expression: CombinedOperatorNode, config: FigTreeConfig) => OperatorNodeUnion | Promise<OperatorNodeUnion>;
 };
-export declare type OperatorReference = {
+export type OperatorReference = {
     [key in Operator]: OperatorObject;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fig-tree-evaluator",
-  "version": "2.1.1",
+  "version": "2.1.6",
   "description": "Module to evaluate JSON-structured expression trees",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -30,7 +30,8 @@
     "generate": "ts-node ./codegen/buildOperatorAliasReference.ts",
     "build": "yarn generate && rimraf ./lib && tsc",
     "dev": "cp -n src/dev/playground_example.ts src/dev/playground.ts || ts-node src/dev/playground.ts",
-    "demo": "cd demo && yarn start"
+    "demo": "cd demo && yarn start",
+    "prepublish": "yarn build"
   },
   "dependencies": {
     "axios": "^0.27.2",