fig-tree-evaluator 2.0.1 → 2.0.4

package/README.md

@@ -201,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.
 
@@ -846,11 +846,6 @@ e.g.
 `children` array: `[value, delimiter]`  
 (`trimWhiteSpace` and `excludeTrailing` not available, since array can only support one optional parameter)
 
-- `urlObject`: either a url string, or an object structured as `{url: <string>, headers: <object>}` (if additional headers are required)
-- `parameterKeys`: an array of strings representing the keys of any query parameters
-- `...values`: one value for each key specified in `parameterKeys`
-- `returnProperty` (optional): as above
-
 ---
 ### GET
 
@@ -1250,7 +1245,7 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 
 ## Changelog
 
-
+- **v2.0.4**: Backwards compatibility for customFunctions (#53)
 - **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)

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/customFunctions.js

@@ -33,11 +33,11 @@ const propertyAliases = {
     variables: 'args',
 };
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+    var _a, _b;
     const [functionPath, ...args] = (yield (0, _operatorUtils_1.evaluateArray)([expression.functionPath, ...(expression.args || [])], config));
     config.typeChecker({ name: 'functionPath', value: functionPath, expectedType: 'string' });
     const { objects, functions } = config.options;
-    const func = ((_a = (0, object_property_extractor_1.default)(functions, functionPath, null)) !== null && _a !== void 0 ? _a : (0, object_property_extractor_1.default)(objects, functionPath));
+    const func = ((_b = (_a = (0, object_property_extractor_1.default)(functions, functionPath, null)) !== null && _a !== void 0 ? _a : (0, object_property_extractor_1.default)(objects, functionPath, null)) !== null && _b !== void 0 ? _b : (0, object_property_extractor_1.default)(config.options, functionPath));
     return yield func(...args);
 });
 const parseChildren = (expression) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fig-tree-evaluator",
-  "version": "2.0.1",
+  "version": "2.0.4",
   "description": "Module to evaluate JSON-structured expression trees",
   "main": "build/index.js",
   "types": "build/index.d.ts",