fig-tree-evaluator 2.0.0 → 2.0.3

package/README.md

@@ -140,6 +140,7 @@ The `options` parameter is an object with the following available properties (al
 - `returnErrorAsString` -- by default the evaluator will throw errors with invalid evaluation expressions (with helpful error messages indicating the node which threw the error and what the problem was). But if you have `returnErrorAsString: true` set, the evaluator will never throw, but instead return error messages as a valid string output. (See also the [`fallback`](#other-common-properties) parameter below)
 - `allowJSONStringInput` -- the evaluator is expecting the input expression to be a javascript object. However, it will also accept JSON strings if this option is set to `true`. We have to perform additional logic on every evaluation input to determine if a string is a JSON expression or a standard string, so this is skipped by default for performance reasons. However, if you want to send (for example) user input directly to the evaluator without running it through your own `JSON.parse()`, then enable this option.
 - `skipRuntimeTypeCheck` -- we perform comprehensive type checking at runtime to ensure that each operator only performs its operation on valid inputs. If type checking fails, we throw an error detailing the explicit problem. However, if `skipRuntimeTypeCheck` is set to `true`, then all inputs are passed to the operator regardless, and any errors will come from whatever standard javascript errors might be encoutered (e.g. trying to pass a primitive value when an array is expected => `.map is not a function`)
+- `nullEqualsUndefined` -- this only affects the [`equal`/`notEqual` operators](#equal) (see there for more detail). 
 
 As mentioned above, `options` can be provided as part of the constructor as part of each seperate evaluation. You can also change the options permanently for a given evaluator instance with:
 
@@ -200,7 +201,7 @@ Most of the time named properties is preferable; however there are situations wh
 In each operator node, as well as the operator-specific properties, the following two optional properties can be provided:
 
 - `fallback`: if the operation throws an error, the `fallback` value will be returned instead. The `fallback` property can be provided at any level of the expression tree and bubbled up from where errors are caught to parent nodes.
-- `outputType` (or `type`): will convert the result of the current node to the specified `outputType`. Valid values are `string`, `number`, `boolean` (or `bool`), and `array`. You can experiment in the [demo app](LINK) to see the outcome of applying different `outputType` values to various results.
+- `outputType` (or `type`): will convert the result of the current node to the specified `outputType`. Valid values are `string`, `number`, `boolean` (or `bool`), and `array`. You can experiment in the [demo app](https://carlosnz.github.io/fig-tree-evaluator/) to see the outcome of applying different `outputType` values to various results.
 
 Remember that *all* operator node properties can themselves be operator nodes, *including* the `fallback` and `outputType` properties.
 
@@ -297,7 +298,8 @@ Aliases: `=`, `eq`, `equal`, `equals`
 
 #### Properties
 
-- `values`<sup>*</sup>: (array) -- any number of elements; will be compared using Javascript `==` operator
+- `values`<sup>*</sup>: (array) -- any number of elements; will be compared for strict equality. This includes simple types as well as deep equality of objects and arrays.
+- `nullEqualsUndefined`: (boolean, default `false`) -- there are times when it is convenient for `null` to be considered equal to `undefined`. If this is desiered, set this property to `true`, otherwise all equality checks will be "strict" equality. If you find that you want this setting enabled globally, then you can set it in the overall [evaluator options](#available-options) instead of having to add this additional property to every equality expression.
 
 e.g.
 ```js
@@ -319,7 +321,8 @@ Aliases: `!=`, `!`, `ne`, `notEqual`
 
 #### Properties
 
-- `values`<sup>*</sup>: (array) -- any number of elements; will be compared using Javascript `!=` operator
+- `values`<sup>*</sup>: (array) -- any number of elements; will be compared for inequality. This includes simple types as well as deep comparison of objects and arrays.
+- `nullEqualsUndefined`: (boolean, default `false`) -- as [above](#equal)
 
 e.g.
 ```js
@@ -1247,6 +1250,8 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 
 ## Changelog
 
+
+- **v2.0.1**: Add deep equality comparison for objects/arrayr in =/!= operators
 - **v2.0.0**: Re-write as stand-alone package. Major improvements include:
   -  more [operators](#operator-reference)
   -  operator (and property) [aliases](#operator--property-aliases)

package/build/helpers.d.ts

@@ -1,4 +1,4 @@
-import { OutputType, EvaluatorNode, CombinedOperatorNode, Operator, EvaluatorOutput } from './types';
+import { OutputType, EvaluatorNode, CombinedOperatorNode, Operator, EvaluatorOutput, FigTreeOptions } from './types';
 export declare const parseIfJson: (input: EvaluatorNode) => any;
 export declare const isOperatorNode: (input: EvaluatorNode) => boolean;
 export declare const getOperatorName: (operator: string, operatorAliases: {
@@ -10,6 +10,7 @@ export declare const mapPropertyAliases: (propertyAliases: {
     [key: string]: string;
 }, expression: CombinedOperatorNode) => CombinedOperatorNode;
 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[];
 };

package/build/helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorMessage = exports.convertOutputMethods = exports.checkRequiredNodes = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.getOperatorName = exports.isOperatorNode = exports.parseIfJson = void 0;
+exports.errorMessage = exports.convertOutputMethods = exports.mergeOptions = exports.checkRequiredNodes = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.getOperatorName = exports.isOperatorNode = exports.parseIfJson = void 0;
 const change_case_1 = require("change-case");
 const parseIfJson = (input) => {
     if (typeof input !== 'string')
@@ -49,6 +49,17 @@ const checkRequiredNodes = (requiredProps, expression) => {
     return false;
 };
 exports.checkRequiredNodes = checkRequiredNodes;
+const mergeOptions = (origOptions, newOptions) => {
+    const combinedOptions = Object.assign(Object.assign({}, origOptions), newOptions);
+    if (origOptions.objects || newOptions.objects)
+        combinedOptions.objects = Object.assign(Object.assign({}, origOptions.objects), newOptions.objects);
+    if (origOptions.functions || newOptions.functions)
+        combinedOptions.functions = Object.assign(Object.assign({}, origOptions.functions), newOptions.functions);
+    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),

package/build/index.js

@@ -40,6 +40,7 @@ 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");
 class FigTreeEvaluator {
     constructor(options = {}) {
         this.typeChecker = (...args) => {
@@ -54,12 +55,12 @@ class FigTreeEvaluator {
     }
     evaluate(expression, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const instanceOptions = Object.assign(Object.assign({}, this.options), options);
+            const currentOptions = (0, helpers_1.mergeOptions)(this.options, options);
             return yield (0, evaluate_1.evaluatorFunction)(expression, {
-                options: instanceOptions,
+                options: currentOptions,
                 operators: this.operators,
                 operatorAliases: this.operatorAliases,
-                typeChecker: instanceOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
+                typeChecker: currentOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
             });
         });
     }

package/build/operators/equal.js

@@ -12,13 +12,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EQUAL = void 0;
 const logicalAnd_1 = require("./logicalAnd");
 const _operatorUtils_1 = require("./_operatorUtils");
+const lite_1 = require("dequal/lite");
 const requiredProperties = ['values'];
 const operatorAliases = ['=', 'eq', 'equal', 'equals'];
 const propertyAliases = {};
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
+    var _a;
+    const [values, nullMatch] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.nullEqualsUndefined], config));
     config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.every((value) => value == values[0]);
+    const nullEqualsUndefined = nullMatch !== undefined
+        ? nullMatch
+        : ((_a = config.options) === null || _a === void 0 ? void 0 : _a.nullEqualsUndefined) !== undefined
+            ? config.options.nullEqualsUndefined
+            : false;
+    if (nullEqualsUndefined && (values[0] === null || values[0] === undefined))
+        return values.every((value) => value === null || value === undefined);
+    return values.every((value) => (0, lite_1.dequal)(value, values[0]));
 });
 exports.EQUAL = {
     requiredProperties,

package/build/operators/notEqual.js

@@ -12,13 +12,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NOT_EQUAL = void 0;
 const logicalAnd_1 = require("./logicalAnd");
 const _operatorUtils_1 = require("./_operatorUtils");
+const lite_1 = require("dequal/lite");
 const requiredProperties = ['values'];
 const operatorAliases = ['!=', '!', 'ne', 'notEqual'];
 const propertyAliases = {};
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
+    var _a;
+    const [values, nullMatch] = (yield (0, _operatorUtils_1.evaluateArray)([expression.values, expression.nullEqualsUndefined], config));
     config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.some((val) => val !== values[0]);
+    const nullEqualsUndefined = nullMatch !== undefined
+        ? nullMatch
+        : ((_a = config.options) === null || _a === void 0 ? void 0 : _a.nullEqualsUndefined) !== undefined
+            ? config.options.nullEqualsUndefined
+            : false;
+    if (nullEqualsUndefined && (values[0] === null || values[0] === undefined))
+        return values.some((value) => value === null && value === undefined);
+    return values.some((val) => !(0, lite_1.dequal)(val, values[0]));
 });
 exports.NOT_EQUAL = {
     requiredProperties,

package/build/types.d.ts

@@ -17,6 +17,7 @@ export interface FigTreeOptions {
         [key: string]: string;
     };
     returnErrorAsString?: boolean;
+    nullEqualsUndefined?: boolean;
     allowJSONStringInput?: boolean;
     skipRuntimeTypeCheck?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fig-tree-evaluator",
-  "version": "2.0.0",
+  "version": "2.0.3",
   "description": "Module to evaluate JSON-structured expression trees",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -35,6 +35,7 @@
   "dependencies": {
     "axios": "^0.27.2",
     "change-case": "^4.1.2",
+    "dequal": "^2.0.3",
     "object-property-extractor": "^1.0.3"
   },
   "bugs": {