fig-tree-evaluator 2.6.0 → 2.8.0

package/build/operators/GREATER_THAN/operator.js

@@ -0,0 +1,55 @@
+"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.GREATER_THAN = void 0;
+const operator_1 = require("../AND/operator");
+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, strict = true] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.strict], config));
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values, strict }));
+    if (values.length < 2)
+        throw new Error('- Not enough values provided');
+    const [first, second] = values;
+    if (first === second && !strict)
+        return true;
+    return first > second;
+});
+exports.GREATER_THAN = {
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
+    evaluate,
+    parseChildren: operator_1.parseChildren,
+};

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

@@ -0,0 +1,5 @@
+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/LESS_THAN/data.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Test if a value is smaller than (or equal to) another value';
+const aliases = ['<', 'lessThan', 'lower', 'smaller'];
+const parameters = [
+    {
+        name: 'values',
+        description: 'Array of values - 1st element will be compared to the second',
+        aliases: [],
+        required: true,
+        type: 'array',
+    },
+    {
+        name: 'strict',
+        description: 'Whether value must be strictly smaller than (i.e. not equal) (default: false)',
+        aliases: [],
+        required: false,
+        type: 'boolean',
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

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

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

package/build/operators/LESS_THAN/index.js

@@ -0,0 +1,17 @@
+"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/{lessThan.d.ts → LESS_THAN/operator.d.ts}

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

package/build/operators/LESS_THAN/operator.js

@@ -0,0 +1,55 @@
+"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.LESS_THAN = void 0;
+const operator_1 = require("../AND/operator");
+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, strict = true] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.strict], config));
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values, strict }));
+    if (values.length < 2)
+        throw new Error('- Not enough values provided');
+    const [first, second] = values;
+    if (first === second && !strict)
+        return true;
+    return first < second;
+});
+exports.LESS_THAN = {
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
+    evaluate,
+    parseChildren: operator_1.parseChildren,
+};

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

@@ -0,0 +1,5 @@
+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/MATCH/data.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Return different values depending on a matching expression';
+const aliases = ['match', 'switch'];
+const parameters = [
+    {
+        name: 'matchExpression',
+        description: 'Expression to match against',
+        aliases: ['match'],
+        required: true,
+        type: ['string', 'number', 'boolean'],
+    },
+    {
+        name: 'branches',
+        description: 'Object whose keys are compared against the match expression. The value of the matching key is returned',
+        aliases: ['arms', 'cases'],
+        required: false,
+        type: ['object', 'array'],
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

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

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

package/build/operators/MATCH/index.js

@@ -0,0 +1,17 @@
+"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/{match.d.ts → MATCH/operator.d.ts}

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

package/build/operators/{match.js → MATCH/operator.js}

@@ -1,4 +1,27 @@
 "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) {
@@ -10,24 +33,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MATCH = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const evaluate_1 = require("../evaluate");
-const helpers_1 = require("../helpers");
-const requiredProperties = ['matchExpression'];
-const operatorAliases = ['match', 'switch'];
-const propertyAliases = { arms: 'branches', cases: 'branches', match: 'matchExpression' };
+const _operatorUtils_1 = require("../_operatorUtils");
+const evaluate_1 = require("../../evaluate");
+const helpers_1 = require("../../helpers");
+const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     const matchExpression = (yield (0, evaluate_1.evaluatorFunction)(expression.matchExpression, config));
     const branches = expression.branches;
-    config.typeChecker({
-        name: 'matchExpression',
-        value: matchExpression,
-        expectedType: ['string', 'number', 'boolean'],
-    }, {
-        name: 'branches',
-        value: branches,
-        expectedType: ['object', 'array', 'undefined'],
-    });
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { matchExpression, branches }));
     let branchObject = Array.isArray(branches) ? (0, _operatorUtils_1.singleArrayToObject)(branches) : branches !== null && branches !== void 0 ? branches : {};
     if ((0, helpers_1.isOperatorNode)(branchObject))
         branchObject = yield (0, evaluate_1.evaluatorFunction)(branchObject, config);
@@ -45,9 +58,9 @@ const parseChildren = (expression, config) => __awaiter(void 0, void 0, void 0,
     return Object.assign(Object.assign({}, expression), { matchExpression, branches });
 });
 exports.MATCH = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
     parseChildren,
 };

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

@@ -0,0 +1,5 @@
+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/MULTIPLY/data.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Multiply several numerical values together';
+const aliases = ['*', 'x', 'multiply', 'times'];
+const parameters = [
+    {
+        name: 'values',
+        description: 'Array of values whose product will be calculated',
+        aliases: [],
+        required: true,
+        type: 'array',
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

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

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

package/build/operators/MULTIPLY/index.js

@@ -0,0 +1,17 @@
+"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/{multiply.d.ts → MULTIPLY/operator.d.ts}

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

package/build/operators/MULTIPLY/operator.js

@@ -0,0 +1,50 @@
+"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.MULTIPLY = void 0;
+const operator_1 = require("../AND/operator");
+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, number) => acc * number);
+});
+exports.MULTIPLY = {
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
+    evaluate,
+    parseChildren: operator_1.parseChildren,
+};

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

@@ -0,0 +1,5 @@
+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/NOT_EQUAL/data.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Test if any values are different';
+const aliases = ['!=', '!', 'ne', 'notEqual'];
+const parameters = [
+    {
+        name: 'values',
+        description: 'Array of values to check for inequality',
+        aliases: [],
+        required: true,
+        type: 'array',
+    },
+    {
+        name: 'nullEqualsUndefined',
+        description: 'Whether a null value should be considered equal to an undefined value',
+        aliases: [],
+        required: false,
+        type: 'boolean',
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

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

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

package/build/operators/NOT_EQUAL/index.js

@@ -0,0 +1,17 @@
+"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/{notEqual.d.ts → NOT_EQUAL/operator.d.ts}

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

package/build/operators/{notEqual.js → NOT_EQUAL/operator.js}

@@ -1,4 +1,27 @@
 "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) {
@@ -10,16 +33,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NOT_EQUAL = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
+const operator_1 = require("../AND/operator");
+const _operatorUtils_1 = require("../_operatorUtils");
 const lite_1 = require("dequal/lite");
-const requiredProperties = ['values'];
-const operatorAliases = ['!=', '!', 'ne', 'notEqual'];
-const propertyAliases = {};
+const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     const [values, nullMatch] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.nullEqualsUndefined], config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+    config.typeChecker(...(0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values, nullEqualsUndefined: nullMatch }));
     const nullEqualsUndefined = nullMatch !== undefined
         ? nullMatch
         : ((_a = config.options) === null || _a === void 0 ? void 0 : _a.nullEqualsUndefined) !== undefined
@@ -30,9 +51,9 @@ const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, funct
     return values.some((val) => !(0, lite_1.dequal)(val, values[0]));
 });
 exports.NOT_EQUAL = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    requiredProperties: data_1.requiredProperties,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
+    parseChildren: operator_1.parseChildren,
 };

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

@@ -0,0 +1,5 @@
+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/OBJECT_PROPERTIES/data.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Extract values from data objects';
+const aliases = [
+    'dataProperties',
+    'data',
+    'getData',
+    'objectProperties',
+    'objProps',
+    'getProperty',
+    'getObjProp',
+];
+const parameters = [
+    {
+        name: 'property',
+        description: 'The path to the required property (e.g. "user.firstName")',
+        aliases: ['path', 'propertyName'],
+        required: true,
+        type: 'string',
+    },
+    {
+        name: 'additionalData',
+        description: 'Additional data objects to be considered',
+        aliases: ['additional', 'objects', 'data', 'additionalObjects'],
+        required: false,
+        type: 'object',
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

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

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

package/build/operators/OBJECT_PROPERTIES/index.js

@@ -0,0 +1,17 @@
+"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/{objectProperties.d.ts → OBJECT_PROPERTIES/operator.d.ts}

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