@briza/illogical 1.6.1 → 1.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@briza/illogical",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "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",
@@ -42,7 +42,7 @@
     "rules"
   ],
   "devDependencies": {
-    "@babel/core": "^7.25.2",
+    "@babel/core": "^7.27.3",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@babel/preset-env": "^7.25.3",
     "@babel/preset-typescript": "^7.24.7",
@@ -64,7 +64,7 @@
     "jest": "^29.7.0",
     "license-checker": "^25.0.1",
     "prettier": "^3.3.3",
-    "rollup": "^4.20.0",
+    "rollup": "^4.41.1",
     "ts-jest": "^29.2.4",
     "typedoc": "^0.26.5",
     "typescript": "^5.5.4"

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,6 +222,19 @@ 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
@@ -237,6 +248,7 @@ To reference the nested reference, please use "." delimiter, e.g.:
 
 If the key of the nested reference includes the "." delimiter, please wrap the whole key with backticks `` ` ``, e.g.:
 `` $address.`city.code` `` can reference the object
+
 ```javascript
 {
   address: {
@@ -245,7 +257,8 @@ If the key of the nested reference includes the "." delimiter, please wrap the w
 }
 ```
 
-`` $address.`city.code`[0] `` can reference the object
+``$address.`city.code`[0]`` can reference the object
+
 ```javascript
 {
   address: {
@@ -253,6 +266,7 @@ If the key of the nested reference includes the "." delimiter, please wrap the w
   }
 }
 ```
+
 when the value of the nested reference is an array.
 
 #### Accessing Array Element:
@@ -705,7 +719,7 @@ Expression format: `["/", First Operand, Second Operand, ... , Nth Operand]`.
 ```
 
 ```js
-engine.evaluate(["==", ["/", 100, 10], 10]) // true
+engine.evaluate(['==', ['/', 100, 10], 10]) // true
 ```
 
 #### Multiplication
@@ -721,7 +735,7 @@ Expression format: `["*", First Operand, Second Operand, ... , Nth Operand]`.
 ```
 
 ```js
-engine.evaluate(["==", ["*", 10, 10], 100]) // true
+engine.evaluate(['==', ['*', 10, 10], 100]) // true
 ```
 
 #### Subtraction
@@ -737,10 +751,9 @@ Expression format: `["-", First Operand, Second Operand, ... , Nth Operand]`.
 ```
 
 ```js
-engine.evaluate(["==", ["-", 20, 10], 10]) // true
+engine.evaluate(['==', ['-', 20, 10], 10]) // true
 ```
 
-
 #### Addition
 
 The arithmetical operator for addition produces the sum of the operands.
@@ -754,10 +767,9 @@ Expression format: `["+", First Operand, Second Operand, ... , Nth Operand]`.
 ```
 
 ```js
-engine.evaluate(["==", ["+", 5, 5], 10]) // true
+engine.evaluate(['==', ['+', 5, 5], 10]) // true
 ```
 
-
 ## Engine Options
 
 ### Parser Options

package/types/common/type-check.d.ts

@@ -43,3 +43,5 @@ export declare function areAllResults(values: (Result | Evaluable)[]): values is
  * @returns {boolean} type guard
  */
 export declare function areAllNumbers(results: Result[]): results is number[];
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function isNull(value: unknown): value is null;

package/types/index.d.ts

@@ -75,5 +75,6 @@ declare class Engine {
      * @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;
 }
 export default Engine;

package/types/operand/collection.d.ts

@@ -9,6 +9,11 @@ import { Value } from './value';
  */
 export declare class Collection extends Operand {
     private readonly items;
+    /**
+     * Get the items in the collection.
+     * @returns {Array<Value | Reference>}
+     */
+    getItems(): Array<Value | Reference>;
     /**
      * @constructor
      * @param {Operand[]} items Collection of operands.

package/types/parser/index.d.ts

@@ -1,6 +1,6 @@
 import { Evaluable } from '../common/evaluable';
 import { Options } from './options';
-export type Input = string | number | boolean | null | Input[] | [string, ...Input[]];
+export type Input = string | number | boolean | null | Input[] | [string, ...Input[]] | Record<string, unknown>;
 export type ArrayInput = Input[];
 export type ExpressionInput = [string, ...Input[]];
 /**
@@ -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/and.d.ts

@@ -0,0 +1,3 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+export declare const simplifyAnd: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/arithmetic.d.ts

@@ -0,0 +1,6 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+export declare const simplifySum: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;
+export declare const simplifySubtract: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;
+export declare const simplifyMultiply: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;
+export declare const simplifyDivide: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/comparison.d.ts

@@ -0,0 +1,7 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+import { Options } from '../parser/options';
+export declare const simplifyGt: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;
+export declare const simplifyGe: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;
+export declare const simplifyLt: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;
+export declare const simplifyLe: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/equality.d.ts

@@ -0,0 +1,5 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+import { Options } from '../parser/options';
+export declare const simplifyEq: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;
+export declare const simplifyNe: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/in.d.ts

@@ -0,0 +1,3 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+export declare const simplifyIn: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/nor.d.ts

@@ -0,0 +1,4 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+import { Options } from '../parser/options';
+export declare const simplifyNor: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/not-in.d.ts

@@ -0,0 +1,3 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+export declare const simplifyNotIn: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/not.d.ts

@@ -0,0 +1,3 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+export declare const simplifyNot: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/or.d.ts

@@ -0,0 +1,3 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+export declare const simplifyOr: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/overlap.d.ts

@@ -0,0 +1,3 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+export declare const simplifyOverlap: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/prefix.d.ts

@@ -0,0 +1,5 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+import { Options } from '../parser/options';
+export declare const simplifyPrefix: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;
+export declare const simplifySuffix: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/present.d.ts

@@ -0,0 +1,4 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+export declare const simplifyPresent: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;
+export declare const simplifyUndefined: (simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;

package/types/unsafe/simplify.d.ts

@@ -0,0 +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;

package/types/unsafe/type-check.d.ts

@@ -0,0 +1,12 @@
+import { Evaluable, Result } from '../common/evaluable';
+import { Input } from '../parser';
+export declare const isTrueResult: (value: Input) => value is true;
+export declare const isFalseResult: (value: Input) => value is false;
+export declare const isNonFalseResult: (operand: Input | Evaluable) => operand is Input;
+export declare const isNonTrueResult: (operand: Input | Evaluable) => operand is Input;
+export declare const resultToInputInternal: (value: Result) => Input | undefined;
+export declare const resultToInput: (value: Result) => Input | undefined;
+export declare const areAllNumbers: (results: Input[]) => results is number[];
+export declare const areAllInputs: (values: (Input | Evaluable)[]) => values is Input[];
+export declare const getInputValues: (results: Input[]) => number[] | false;
+export declare const extractValues: (input: Input | Evaluable) => Result[];

package/types/unsafe/xor.d.ts

@@ -0,0 +1,4 @@
+import { Evaluable } from '../common/evaluable';
+import { Input } from '../parser';
+import { Options } from '../parser/options';
+export declare const simplifyXor: (opts: Options, simplifyInput: (input: Input) => Input | Evaluable) => (input: Input[] | [string, ...Input[]]) => Input | Evaluable;