@briza/illogical 1.5.5 → 1.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@briza/illogical",
-  "version": "1.5.5",
+  "version": "1.5.8",
   "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,31 +42,31 @@
     "rules"
   ],
   "devDependencies": {
-    "@babel/core": "^7.17.9",
-    "@babel/plugin-proposal-class-properties": "^7.16.7",
-    "@babel/preset-env": "^7.16.11",
-    "@babel/preset-typescript": "^7.16.7",
-    "@rollup/plugin-babel": "^5.3.1",
-    "@rollup/plugin-commonjs": "^21.0.3",
-    "@rollup/plugin-node-resolve": "^13.2.0",
-    "@types/jest": "^27.4.1",
-    "@typescript-eslint/eslint-plugin": "^5.19.0",
-    "@typescript-eslint/parser": "^5.19.0",
-    "eslint": "^8.13.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-import-resolver-typescript": "^2.7.1",
-    "eslint-plugin-import": "^2.26.0",
+    "@babel/core": "^7.23.6",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/preset-env": "^7.23.6",
+    "@babel/preset-typescript": "^7.23.3",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@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",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^3.4.1",
-    "eslint-plugin-promise": "^6.0.0",
-    "eslint-plugin-simple-import-sort": "^7.0.0",
-    "jest": "^27.5.1",
+    "eslint-plugin-prettier": "^5.0.1",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-simple-import-sort": "^10.0.0",
+    "jest": "^29.7.0",
     "license-checker": "^25.0.1",
-    "prettier": "^2.6.2",
-    "rollup": "^2.70.1",
-    "rollup-plugin-eslint": "^7.0.0",
-    "ts-jest": "^27.1.4",
-    "typedoc": "^0.22.15",
-    "typescript": "4.6.3"
+    "prettier": "^3.1.1",
+    "rollup": "^4.8.0",
+    "ts-jest": "^29.1.1",
+    "typedoc": "^0.25.4",
+    "typescript": "^5.3.3"
   }
 }

package/readme.md

@@ -230,6 +230,26 @@ The evaluation data context is used to provide the expression with variable refe
 To reference the nested reference, please use "." delimiter, e.g.:
 `$address.city`
 
+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: {
+    'city.code': 'TOR'
+  }
+}
+```
+
+`` $address.`city.code`[0] `` can reference the object
+```javascript
+{
+  address: {
+    'city.code': ['TOR']
+  }
+}
+```
+when the value of the nested reference is an array.
+
 #### Accessing Array Element:
 
 `$options[1]`
@@ -331,11 +351,12 @@ The reference operand must be prefixed with `$` symbol, e.g.: `$name`. This migh
 
 **Example**
 
-| Expression                    | Data Context      |
-| ----------------------------- | ----------------- |
-| `['==', '$age', 21]`          | `{age: 21}`       |
-| `['==', 'circle', '$shape'] ` | `{age: 'circle'}` |
-| `['==', '$visible', true]`    | `{visible: true}` |
+| Expression                    | Data Context                          |
+| ----------------------------- | ------------------------------------- |
+| `['==', '$age', 21]`          | `{age: 21}`                           |
+| `['==', 'circle', '$shape'] ` | `{shape: 'circle'}`                   |
+| `['==', '$visible', true]`    | `{visible: true}`                     |
+| `['==', '$circle', '$shape']` | `{circle: 'circle', shape: 'circle'}` |
 
 #### Collection
 
@@ -383,56 +404,72 @@ engine.evaluate(['!=', 'circle', 'square']) // true
 
 Expression format: `[">", `[Left Operand](#operand-types), [Right Operand](#operand-types)`]`.
 
-> Valid operand types: number.
+> Valid operand types: number, string.
+
+- String comparison only supports ISO-8601 formatted dates.
 
 ```json
 [">", 10, 5]
+[">", "2023-01-01", "2022-12-31"]
 ```
 
 ```js
 engine.evaluate(['>', 10, 5]) // true
+engine.evaluate(['>', '2023-01-01', '2022-12-31']) // true
 ```
 
 #### Greater Than or Equal
 
 Expression format: `[">=", `[Left Operand](#operand-types), [Right Operand](#operand-types)`]`.
 
-> Valid operand types: number.
+> Valid operand types: number, string.
+
+- String comparison only supports ISO-8601 formatted dates.
 
 ```json
 [">=", 5, 5]
+[">=", "2023-01-01",  "2023-01-01"]
 ```
 
 ```js
 engine.evaluate(['>=', 5, 5]) // true
+engine.evaluate(['>=', '2023-01-01', '2023-01-01']) // true
 ```
 
 #### Less Than
 
 Expression format: `["<", `[Left Operand](#operand-types), [Right Operand](#operand-types)`]`.
 
-> Valid operand types: number.
+> Valid operand types: number, string.
+
+- String comparison only supports ISO-8601 formatted dates.
 
 ```json
 ["<", 5, 10]
+["<", "2022-12-31",  "2023-01-01"]
 ```
 
 ```js
 engine.evaluate(['<', 5, 10]) // true
+engine.evaluate(['<', '2022-12-31', '2023-01-01']) // true
 ```
 
 #### Less Than or Equal
 
 Expression format: `["<=", `[Left Operand](#operand-types), [Right Operand](#operand-types)`]`.
 
-> Valid operand types: number.
+> Valid operand types: number, string.
+
+- String comparison only supports ISO-8601 formatted dates.
 
 ```json
 ["<=", 5, 5]
+["<=", "2023-01-01",  "2023-01-01"]
 ```
 
 ```js
 engine.evaluate(['<=', 5, 5]) // true
+engine.evaluate(['<=', '2023-01-01', '2023-01-01']) // true
 ```
 
 #### In

package/types/common/evaluable.d.ts

@@ -3,7 +3,7 @@ import { Options } from '../parser/options';
 /**
  * Valid types for context members
  */
-declare type ContextValue = Record<string, unknown> | string | number | boolean | null | undefined | ContextValue[];
+type ContextValue = Record<string, unknown> | string | number | boolean | null | undefined | ContextValue[];
 /**
  * Evaluation Context
  * Holds references used during the evaluation process.
@@ -15,7 +15,7 @@ export interface Context {
 /**
  * Evaluation result
  */
-export declare type Result = undefined | null | string | number | boolean | Array<Result> | Record<string, unknown>;
+export type Result = undefined | null | string | number | boolean | Array<Result> | Record<string, unknown>;
 export declare enum EvaluableType {
     Operand = "Operand",
     Expression = "Expression"
@@ -53,5 +53,5 @@ export interface Evaluable {
      */
     toString(): string;
 }
-export declare type SimplifyArgs = Parameters<Evaluable['simplify']>;
+export type SimplifyArgs = Parameters<Evaluable['simplify']>;
 export {};

package/types/common/util.d.ts

@@ -9,3 +9,8 @@ export declare const toNumber: (value: Result) => number | undefined;
  * @param value value to be converted to string
  */
 export declare const toString: (value: Result) => string | undefined;
+/**
+ * Convert a value to number if it's type is string, otherwise return NaN
+ * @param value value to be converted to number
+ */
+export declare const toDateNumber: (value: Result) => number;

package/types/parser/index.d.ts

@@ -1,8 +1,8 @@
 import { Evaluable } from '../common/evaluable';
 import { Options } from './options';
-export declare type Input = string | number | boolean | null | Input[] | [string, ...Input[]];
-export declare type ArrayInput = Input[];
-export declare type ExpressionInput = [string, ...Input[]];
+export type Input = string | number | boolean | null | Input[] | [string, ...Input[]];
+export type ArrayInput = Input[];
+export type ExpressionInput = [string, ...Input[]];
 /**
  * Parser of raw expressions into Evaluable expression
  */

package/types/parser/options.d.ts

@@ -1,4 +1,4 @@
-export declare type optionValue = ((operand: string) => string | boolean) | Map<symbol, string>;
+export type optionValue = ((operand: string) => string | boolean) | Map<symbol, string>;
 export interface Options {
     /**
      * A function used to determine if the operand is a reference type,