fig-tree-evaluator 2.0.1 → 2.0.3

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.
 

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/package.json

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