@briza/illogical 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@briza/illogical",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "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",
@@ -29,7 +29,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:briza-insurance/illogical.git"
+    "url": "git+ssh://git@github.com/briza-insurance/illogical.git"
   },
   "bugs": {
     "url": "https://github.com/briza-insurance/illogical/issues"
@@ -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

@@ -224,6 +224,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 +250,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 +259,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 +268,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 +721,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 +737,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 +753,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 +769,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/expression/arithmetic/index.d.ts

@@ -17,6 +17,16 @@ export declare abstract class Arithmetic implements Evaluable {
      * @param {Operand[]} operands Operands.
      */
     constructor(operator: string, operatorSymbol: symbol, operands: Operand[]);
+    /**
+     * Helper function to assist with arithmetic evaluation. Ensures that all
+     * operands are present and are numbers. Throws error if any operand is not a
+     * number.
+     *
+     * @param {Result[]} results
+     * @returns {number[] | false} false if any operand is missing, otherwise the
+     *   array of numbers
+     */
+    protected getResultValues(results: Result[]): number[] | false;
     /**
      * Performs the arithmetic operation on the operands evaluated values.
      * @param {Result[]} results Operand result values.

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[]];
 /**

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;