@briza/illogical 1.5.8 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@briza/illogical",
-  "version": "1.5.8",
+  "version": "1.6.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",
@@ -25,7 +25,7 @@
     "lint": "eslint --max-warnings 0 \"src/**/*.{ts,js}\"",
     "lint:fix": "eslint --max-warnings 0 \"src/**/*.{ts,js}\" --fix",
     "prepublishOnly": "npm run test && npm run build",
-    "check-licenses": "license-checker --summary --excludePrivatePackages --onlyAllow \"MIT;MIT OR X11;Apache-2.0;ISC;BSD-3-Clause;BSD-2-Clause;CC-BY-4.0;Public Domain;BSD;CC-BY-3.0;CC0-1.0;Python-2.0;Unlicense\""
+    "check-licenses": "license-checker --summary --excludePrivatePackages --onlyAllow \"MIT;MIT OR X11;Apache-2.0;ISC;BSD-3-Clause;BSD-2-Clause;CC-BY-4.0;Public Domain;BSD;CC-BY-3.0;CC0-1.0;Python-2.0;BlueOak-1.0.0;Unlicense\""
   },
   "repository": {
     "type": "git",
@@ -42,31 +42,31 @@
     "rules"
   ],
   "devDependencies": {
-    "@babel/core": "^7.23.6",
+    "@babel/core": "^7.25.2",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
-    "@babel/preset-env": "^7.23.6",
-    "@babel/preset-typescript": "^7.23.3",
+    "@babel/preset-env": "^7.25.3",
+    "@babel/preset-typescript": "^7.24.7",
     "@rollup/plugin-babel": "^6.0.4",
-    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-commonjs": "^26.0.1",
     "@rollup/plugin-eslint": "^9.0.5",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@types/jest": "^28.1.8",
-    "@typescript-eslint/eslint-plugin": "^6.14.0",
-    "@typescript-eslint/parser": "^6.14.0",
-    "eslint": "^8.55.0",
+    "@types/jest": "^29.5.12",
+    "@typescript-eslint/eslint-plugin": "^8.0.1",
+    "@typescript-eslint/parser": "^8.0.1",
+    "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.29.0",
+    "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^5.0.1",
-    "eslint-plugin-promise": "^6.1.1",
-    "eslint-plugin-simple-import-sort": "^10.0.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-promise": "^7.1.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
     "jest": "^29.7.0",
     "license-checker": "^25.0.1",
-    "prettier": "^3.1.1",
-    "rollup": "^4.8.0",
-    "ts-jest": "^29.1.1",
-    "typedoc": "^0.25.4",
-    "typescript": "^5.3.3"
+    "prettier": "^3.3.3",
+    "rollup": "^4.20.0",
+    "ts-jest": "^29.2.4",
+    "typedoc": "^0.26.5",
+    "typescript": "^5.5.4"
   }
 }

package/readme.md

@@ -58,6 +58,11 @@ yarn add @briza/illogical -D
     - [Nor](#nor)
     - [Xor](#xor)
     - [Not](#not)
+  - [Arithmetic Expressions](#arithmetic-expressions)
+    - [Divide](#divide)
+    - [Multiply](#multiply)
+    - [Subtract](#subtract)
+    - [Sum](#sum)
 - [Engine Options](#engine-options)
   - [Parser Options](#parser-options)
     - [Reference Predicate](#reference-predicate)
@@ -683,6 +688,76 @@ Expression format: `["NOT", Operand]`
 engine.evaluate(['NOT', ['==', 5, 5]]) // true
 ```
 
+### Arithmetic Expressions
+
+Arithmetic Expressions are not supported as root level expressions since they must evaluate to a boolean. But it can be used nested within [Comparisson Expressions](#comparison-expressions).
+
+#### Division
+
+The arithmetical operator for division produces the quotient of its operands where the left-most operand is the dividend and the subsequent one is the divisor, done from left to right.
+
+Expression format: `["/", First Operand, Second Operand, ... , Nth Operand]`.
+
+> Valid operand types: [Arithmetic Expressions](#arithmetic-expressions) or [Operands](#operand-types).
+
+```json
+["==", ["/", 100, 10], 10]
+```
+
+```js
+engine.evaluate(["==", ["/", 100, 10], 10]) // true
+```
+
+#### Multiplication
+
+The arithmetical operator for multiplication produces the product of the operands.
+
+Expression format: `["*", First Operand, Second Operand, ... , Nth Operand]`.
+
+> Valid operand types: [Arithmetic Expressions](#arithmetic-expressions) or [Operands](#operand-types).
+
+```json
+["==", ["*", 100, 10], 10]
+```
+
+```js
+engine.evaluate(["==", ["*", 10, 10], 100]) // true
+```
+
+#### Subtraction
+
+The arithmetical operator for subtraction subtracts the operands, producing their difference.
+
+Expression format: `["-", First Operand, Second Operand, ... , Nth Operand]`.
+
+> Valid operand types: [Arithmetic Expressions](#arithmetic-expressions) or [Operands](#operand-types).
+
+```json
+["==", ["-", 20, 10], 10]
+```
+
+```js
+engine.evaluate(["==", ["-", 20, 10], 10]) // true
+```
+
+
+#### Addition
+
+The arithmetical operator for addition produces the sum of the operands.
+
+Expression format: `["+", First Operand, Second Operand, ... , Nth Operand]`.
+
+> Valid operand types: [Arithmetic Expressions](#arithmetic-expressions) or [Operands](#operand-types).
+
+```json
+["==", ["+", 5, 5], 10]
+```
+
+```js
+engine.evaluate(["==", ["+", 5, 5], 10]) // true
+```
+
+
 ## Engine Options
 
 ### Parser Options
@@ -741,19 +816,31 @@ operatorMapping: Map<symbol, string>
 **Default operator mapping:**
 
 ```typescript
-// Comparison
-;[OPERATOR_EQ, '=='][(OPERATOR_NE, '!=')][(OPERATOR_GT, '>')][
-  (OPERATOR_GE, '>=')
-][(OPERATOR_LT, '<')][(OPERATOR_LE, '<=')][(OPERATOR_IN, 'IN')][
-  (OPERATOR_NOT_IN, 'NOT IN')
-][(OPERATOR_PREFIX, 'PREFIX')][(OPERATOR_SUFFIX, 'SUFFIX')][
-  (OPERATOR_OVERLAP, 'OVERLAP')
-][(OPERATOR_UNDEFINED, 'UNDEFINED')][(OPERATOR_PRESENT, 'PRESENT')][
+  // Comparison
+  [OPERATOR_EQ, '=='],
+  [OPERATOR_NE, '!='],
+  [OPERATOR_GT, '>'],
+  [OPERATOR_GE, '>='],
+  [OPERATOR_LT, '<'],
+  [OPERATOR_LE, '<='],
+  [OPERATOR_IN, 'IN'],
+  [OPERATOR_NOT_IN, 'NOT IN'],
+  [OPERATOR_PREFIX, 'PREFIX'],
+  [OPERATOR_SUFFIX, 'SUFFIX'],
+  [OPERATOR_OVERLAP, 'OVERLAP'],
+  [OPERATOR_UNDEFINED, 'UNDEFINED'],
+  [OPERATOR_PRESENT, 'PRESENT'],
   // Logical
-  (OPERATOR_AND, 'AND')
-][(OPERATOR_OR, 'OR')][(OPERATOR_NOR, 'NOR')][(OPERATOR_XOR, 'XOR')][
-  (OPERATOR_NOT, 'NOT')
-]
+  [OPERATOR_AND, 'AND'],
+  [OPERATOR_OR, 'OR'],
+  [OPERATOR_NOR, 'NOR'],
+  [OPERATOR_XOR, 'XOR'],
+  [OPERATOR_NOT, 'NOT'],
+  // Arithmetic
+  [OPERATOR_SUM, '+'],
+  [OPERATOR_SUBTRACT, '-'],
+  [OPERATOR_MULTIPLY, '*'],
+  [OPERATOR_DIVIDE, '/'],
 ```
 
 > The operator keys are unique symbols which could be imported from the engine package:
@@ -778,6 +865,10 @@ import {
   OPERATOR_NOR,
   OPERATOR_XOR,
   OPERATOR_NOT,
+  OPERATOR_DIVIDE,
+  OPERATOR_MULTIPLY,
+  OPERATOR_SUBTRACT,
+  OPERATOR_SUM,
 } from '@briza/illogical'
 ```
 

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

@@ -4,6 +4,11 @@ import { Evaluable, Result } from './evaluable';
  * @param value Tested value.
  */
 export declare function isNumber(value: Result): value is number;
+/**
+ * Is number predicate.
+ * @param value Tested value.
+ */
+export declare function isInfinite(value: Result): value is typeof Infinity;
 /**
  * Is string type predicate.
  * @param value Tested value.
@@ -26,3 +31,15 @@ export declare function isBoolean(value: unknown): value is boolean;
  * @returns {Evaluable}
  */
 export declare function isEvaluable(value: Result | Evaluable): value is Evaluable;
+/**
+ * Ensures all values are results.
+ * @param {(Result | Evaluable)[]} values results or evaluables
+ * @returns {boolean} type guard
+ */
+export declare function areAllResults(values: (Result | Evaluable)[]): values is Result[];
+/**
+ * Ensures all values are numbers.
+ * @param {Result[]} results results or evaluables
+ * @returns {boolean} type guard
+ */
+export declare function areAllNumbers(results: Result[]): results is number[];

package/types/expression/arithmetic/divide.d.ts

@@ -0,0 +1,14 @@
+import { Evaluable, Result } from '../../common/evaluable';
+import { Arithmetic } from '.';
+export declare const OPERATOR: unique symbol;
+/**
+ * Divide operation expression
+ */
+export declare class Divide extends Arithmetic {
+    /**
+     * @constructor Generic constructor
+     * @param {Evaluable[]} args
+     */
+    constructor(...args: Evaluable[]);
+    operate(results: Result[]): Result;
+}

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

@@ -0,0 +1,42 @@
+import { Context, Evaluable, EvaluableType, Result, SimplifyArgs } from '../../common/evaluable';
+import { Operand } from '../../operand';
+import { ExpressionInput } from '../../parser';
+import { Options } from '../../parser/options';
+/**
+ * Abstract arithmetic expression
+ */
+export declare abstract class Arithmetic implements Evaluable {
+    protected readonly operator: string;
+    protected readonly operatorSymbol: symbol;
+    protected readonly operands: Operand[];
+    type: EvaluableType;
+    /**
+     * @constructor
+     * @param {string} operator String representation of the operator.
+     * @param {symbol} operatorSymbol Operator symbol.
+     * @param {Operand[]} operands Operands.
+     */
+    constructor(operator: string, operatorSymbol: symbol, operands: Operand[]);
+    /**
+     * Performs the arithmetic operation on the operands evaluated values.
+     * @param {Result[]} results Operand result values.
+     * @returns {Result}
+     */
+    abstract operate(results: Result[]): Result;
+    /**
+     * {@link Evaluable.evaluate}
+     */
+    evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.toString}
+     */
+    toString(): string;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    simplify(...args: SimplifyArgs): Result | Evaluable;
+    /**
+     * {@link Evaluable.serialize}
+     */
+    serialize(options: Options): ExpressionInput;
+}

package/types/expression/arithmetic/isSimplifiedArithmeticExpression.d.ts

@@ -0,0 +1,3 @@
+import { Evaluable, Result } from '../../common/evaluable';
+import { Operand } from '../../operand';
+export declare const isSimplifiedArithmeticExpression: (operand: Operand, result: Result | Evaluable) => result is Result;

package/types/expression/arithmetic/multiply.d.ts

@@ -0,0 +1,14 @@
+import { Evaluable, Result } from '../../common/evaluable';
+import { Arithmetic } from '.';
+export declare const OPERATOR: unique symbol;
+/**
+ * Multiply operation expression
+ */
+export declare class Multiply extends Arithmetic {
+    /**
+     * @constructor Generic constructor
+     * @param {Evaluable[]} args
+     */
+    constructor(...args: Evaluable[]);
+    operate(results: Result[]): Result;
+}

package/types/expression/arithmetic/operateWithExpectedDecimals.d.ts

@@ -0,0 +1 @@
+export declare const operateWithExpectedDecimals: (operation: "sum" | "subtract" | "multiply") => (first: number, second: number) => number;

package/types/expression/arithmetic/subtract.d.ts

@@ -0,0 +1,14 @@
+import { Evaluable, Result } from '../../common/evaluable';
+import { Arithmetic } from '.';
+export declare const OPERATOR: unique symbol;
+/**
+ * Subtract operation expression
+ */
+export declare class Subtract extends Arithmetic {
+    /**
+     * @constructor Generic constructor
+     * @param {Evaluable[]} args
+     */
+    constructor(...args: Evaluable[]);
+    operate(results: Result[]): Result;
+}

package/types/expression/arithmetic/sum.d.ts

@@ -0,0 +1,14 @@
+import { Evaluable, Result } from '../../common/evaluable';
+import { Arithmetic } from '.';
+export declare const OPERATOR: unique symbol;
+/**
+ * Sum operation expression
+ */
+export declare class Sum extends Arithmetic {
+    /**
+     * @constructor Generic constructor
+     * @param {Evaluable[]} args
+     */
+    constructor(...args: Evaluable[]);
+    operate(results: Result[]): Result;
+}

package/types/index.d.ts

@@ -4,6 +4,10 @@
  */
 import { Context, Evaluable } from './common/evaluable';
 import { isEvaluable } from './common/type-check';
+import { OPERATOR as OPERATOR_DIVIDE } from './expression/arithmetic/divide';
+import { OPERATOR as OPERATOR_MULTIPLY } from './expression/arithmetic/multiply';
+import { OPERATOR as OPERATOR_SUBTRACT } from './expression/arithmetic/subtract';
+import { OPERATOR as OPERATOR_SUM } from './expression/arithmetic/sum';
 import { OPERATOR as OPERATOR_EQ } from './expression/comparison/eq';
 import { OPERATOR as OPERATOR_GE } from './expression/comparison/ge';
 import { OPERATOR as OPERATOR_GT } from './expression/comparison/gt';
@@ -25,7 +29,7 @@ import { OPERATOR as OPERATOR_XOR } from './expression/logical/xor';
 import { ExpressionInput, Input } from './parser';
 import { Options } from './parser/options';
 export { defaultOptions } from './parser/options';
-export { isEvaluable, OPERATOR_EQ, OPERATOR_NE, OPERATOR_GT, OPERATOR_GE, OPERATOR_LT, OPERATOR_LE, OPERATOR_IN, OPERATOR_NOT_IN, OPERATOR_PREFIX, OPERATOR_SUFFIX, OPERATOR_OVERLAP, OPERATOR_UNDEFINED, OPERATOR_PRESENT, OPERATOR_AND, OPERATOR_OR, OPERATOR_NOR, OPERATOR_XOR, OPERATOR_NOT, };
+export { isEvaluable, OPERATOR_EQ, OPERATOR_NE, OPERATOR_GT, OPERATOR_GE, OPERATOR_LT, OPERATOR_LE, OPERATOR_IN, OPERATOR_NOT_IN, OPERATOR_PREFIX, OPERATOR_SUFFIX, OPERATOR_OVERLAP, OPERATOR_UNDEFINED, OPERATOR_PRESENT, OPERATOR_AND, OPERATOR_OR, OPERATOR_NOR, OPERATOR_XOR, OPERATOR_NOT, OPERATOR_DIVIDE, OPERATOR_MULTIPLY, OPERATOR_SUBTRACT, OPERATOR_SUM, };
 /**
  * Condition engine
  */

package/types/parser/index.d.ts

@@ -8,7 +8,8 @@ export type ExpressionInput = [string, ...Input[]];
  */
 export declare class Parser {
     private readonly opts;
-    private readonly expectedOperators;
+    private readonly expectedRootOperators;
+    private readonly unexpectedRootSymbols;
     /**
      * @constructor
      * @param {Options?} options Parser options.