@briza/illogical 1.7.0 → 1.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@briza/illogical",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "A micro conditional javascript engine used to parse the raw logical and comparison expressions, evaluate the expression in the given data context, and provide access to a text form of the given expressions.",
   "main": "lib/illogical.js",
   "module": "lib/illogical.esm.js",

package/readme.md

@@ -2,8 +2,6 @@
 
 A micro conditional javascript engine used to parse the raw logical and comparison expressions, evaluate the expression in the given data context, and provide access to a text form of the given expressions.
 
-> Revision: March 22, 2022.
-
 ## About
 
 This project has been developed to provide a shared conditional logic between front-end and back-end code, stored in JSON or in any other data serialization format.
@@ -224,19 +222,6 @@ engine.simplify(
 ) // ['==', '$b', 20]
 ```
 
-### Unsafe Simplify
-
-Simplifies an expression with a given context, but without parsing and ensuring the condition is
-syntatically correct. This can be used in situations where you can decouple the parsing from
-the simplification and extra performance is needed in runtime.
-
-```js
-engine.unsafeSimplify(
-  ['OR', ['==', '$a', 10], ['==', '$b', 20], ['==', '$c', 20]],
-  { a: 10 }
-) // true due to $a. Expressions for $b and $c won't even be parsed.
-```
-
 ## Working with Expressions
 
 ### Evaluation Data Context

package/types/common/evaluable.d.ts

@@ -35,13 +35,15 @@ export interface Evaluable {
      * Simplifies this Evaluable when possible.
      *
      * @param {Context} ctx context for the evaluation
-     * @param {string[]} strictKeys keys to be considered present even if they are not present in the context
-     * @param {string[]} optionalKeys keys to be considered not present unless they are in the context or in
+     * @param {string[] | Set<string>} strictKeys keys to be considered present even if they are not present in the
+     *  context. Passing as a Set is recommended for performance reasons.
+     * @param {string[] | Set<string>} optionalKeys keys to be considered not present unless they are in the context or in
      *  `strictKeys`; when `strictKeys` is `undefined` and `optionalKeys` is an array, every key that is not in
-     *  `optionalKeys` is considered to be present and thus will be evaluated
+     *  `optionalKeys` is considered to be present and thus will be evaluated. Passing as a Set is recommended for
+     *  performance reasons.
      * @returns {Result | Evaluable} simplified value or itself
      */
-    simplify(ctx: Context, strictKeys?: string[], optionalKeys?: string[]): Result | Evaluable;
+    simplify(ctx: Context, strictKeys?: string[] | Set<string>, optionalKeys?: string[] | Set<string>): Result | Evaluable;
     /**
      * Serializes the Evaluable to its input format.
      *

package/types/expression/logical/index.d.ts

@@ -22,7 +22,7 @@ export declare abstract class Logical implements Evaluable {
     /**
      * {@link Evaluable.simplify}
      */
-    abstract simplify(ctx: Context, strictKeys?: string[], optionalKeys?: string[]): Result | Evaluable;
+    abstract simplify(ctx: Context, strictKeys?: string[] | Set<string>, optionalKeys?: string[] | Set<string>): Result | Evaluable;
     /**
      * Get the strict representation of the expression.
      * @return {string}

package/types/index.d.ts

@@ -68,13 +68,14 @@ declare class Engine {
      *
      * @param {ExpressionInput} exp  Raw expression.
      * @param {Context} context Evaluation data context.
-     * @param {string[]} strictKeys keys to be considered present even if they are not present in the context
-     * @param {string[]} optionalKeys keys to be considered not present unless they are in the context or in
+     * @param {string[] | Set<string>} strictKeys keys to be considered present even if they are not present in the
+     *  context. Passing as a Set is recommended for performance reasons.
+     * @param {string[] | Set<string>} optionalKeys keys to be considered not present unless they are in the context or in
      *  `strictKeys`; when `strictKeys` is `undefined` and `optionalKeys` is an array, every key that is not in
-     *  `optionalKeys` is considered to be present and thus will be evaluated
+     *  `optionalKeys` is considered to be present and thus will be evaluated. Passing as a Set is recommended for
+     *  performance reasons.
      * @returns {Inpunt | boolean}
      */
-    simplify(exp: ExpressionInput, context: Context, strictKeys?: string[], optionalKeys?: string[]): Input | boolean;
-    unsafeSimplify(exp: ExpressionInput, context: Context, strictKeys?: string[], optionalKeys?: string[]): Input | boolean;
+    simplify(exp: ExpressionInput, context: Context, strictKeys?: string[] | Set<string>, optionalKeys?: string[] | Set<string>): Input | boolean;
 }
 export default Engine;

package/types/operand/index.d.ts

@@ -13,7 +13,7 @@ export declare abstract class Operand implements Evaluable {
     /**
      * {@link Evaluable.simplify}
      */
-    abstract simplify(ctx: Context, strictKeys?: string[], optionalKeys?: string[]): Result | Evaluable;
+    abstract simplify(ctx: Context, strictKeys?: string[] | Set<string>, optionalKeys?: string[] | Set<string>): Result | Evaluable;
     /**
      * {@link Evaluable.serialize}
      */

package/types/operand/reference.d.ts

@@ -24,10 +24,11 @@ export declare class Reference extends Operand {
      * @return {boolean}
      */
     evaluate(ctx: Context): Result;
+    private checkStrictAndOptional;
     /**
      * {@link Evaluable.simplify}
      */
-    simplify(ctx: Context, strictKeys?: string[], optionalKeys?: string[]): Result | Evaluable;
+    simplify(ctx: Context, strictKeys?: string[] | Set<string>, optionalKeys?: string[] | Set<string>): Result | Evaluable;
     /**
      * {@link Evaluable.serialize}
      */

package/types/parser/index.d.ts

@@ -10,6 +10,7 @@ export declare class Parser {
     private readonly opts;
     private readonly expectedRootOperators;
     private readonly unexpectedRootSymbols;
+    private readonly referenceCache;
     /**
      * @constructor
      * @param {Options?} options Parser options.
@@ -20,6 +21,8 @@ export declare class Parser {
      * @type {Options}
      */
     get options(): Options;
+    private getReference;
+    private resolve;
     /**
      * Parse raw expression into evaluable expression.
      * @param {ExpressionInput} raw Raw expression.

package/types/unsafe/simplify.d.ts

@@ -1,4 +1,4 @@
 import { Context, Evaluable } from '../common/evaluable';
 import { Input } from '../parser';
 import { Options } from '../parser/options';
-export declare const unsafeSimplify: (context: Context, opts: Options, strictKeys?: string[], optionalKeys?: string[]) => (input: Input) => Input | Evaluable;
+export declare const unsafeSimplify: (context: Context, opts: Options, strictKeys?: Set<string>, optionalKeys?: Set<string>) => (input: Input) => Input | Evaluable;