@legalplace/lplogic 2.3.1 → 2.3.2-staging.1

package/.gitlab-automator

@@ -0,0 +1,7 @@
+GITLAB_PRIVATE_TOKEN=glpat-BOv5W1i6MoAAvHjzkmc5nW86MQp1OjkH.01.0w119catf
+GITLAB_BASE_URL=https://git.legalplace.eu
+GITLAB_API_PROJECT_ID=28
+GITLAB_USER_ID=9
+CURRENT_PROJECT_ID=39
+SLACK_USER_ID=U0B3SNBV3
+CLICKUP_PRIVATE_TOKEN=pk_32519579_K5W4L4KEVXY03A3D2WFA46D07HVGTL5L

package/.gitlab-ci.yml

@@ -18,6 +18,7 @@ build:
   script:
     - export PATH=$PATH:./node_modules/.bin/
     - yarn install
+    - yarn test
     - yarn build
   except:
     - master  # Excludes the master branch

package/.vscode/settings.json

@@ -14,10 +14,9 @@
   "files.autoSave": "onFocusChange",
   "editor.formatOnSave": false,
   "editor.formatOnType": true,
-  "prettier.singleQuote": true,
-  "eslint.packageManager": "yarn",
   "eslint.quiet": true,
   "editor.codeActionsOnSave": {
-    "source.fixAll.eslint": true 
-  }
-}
+    "source.fixAll.eslint": "explicit"
+  },
+  "typescript.tsdk": "node_modules/typescript/lib"
+}

package/dist/LpLogic.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var json_logic_js_1 = __importDefault(require("@legalplace/json-logic-js"));
 var reduceParents = function (parents, length) {
     var reducedParents = [];
-    parents.sort(function (a, b) { return b.length - a.length; });
+    var safeParents = parents.filter(function (entry) { return Array.isArray(entry); });
+    safeParents.sort(function (a, b) { return b.length - a.length; });
     var _loop_1 = function (index) {
-        var currentIndexResult = parents.reduce(function (previousValue, currentValue) {
+        var currentIndexResult = safeParents.reduce(function (previousValue, currentValue) {
             if (currentValue.length === 1)
                 return previousValue && currentValue[0];
             if (currentValue[index] === undefined)
@@ -23,7 +24,7 @@ var reduceParents = function (parents, length) {
     return reducedParents;
 };
 var reduceValues = function (values, parents, compareFunction) {
-    if (parents === undefined || parents.length === 0) {
+    if (!Array.isArray(parents) || parents.length === 0) {
         return values.map(function (currentValue) {
             return compareFunction(currentValue, true);
         });
@@ -40,10 +41,25 @@ var parseNumber = function (value) {
         return parseFloat(value.replace(",", "."));
     return value;
 };
+var cleanString = function (value) {
+    var raw = typeof value === "number" ? value.toString() : value.trim();
+    return raw
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/œ/g, "oe")
+        .replace(/Œ/g, "oe")
+        .replace(/æ/g, "ae")
+        .replace(/Æ/g, "ae")
+        .toLowerCase();
+};
 var safeEqual = function (value, comparator) {
     var parsedValue = typeof value === "number" ? value : parseNumber(value);
     var parsedComparator = typeof comparator === "number" ? comparator : parseNumber(comparator);
-    return parsedValue === parsedComparator;
+    if (typeof parsedValue === "number" &&
+        typeof parsedComparator === "number") {
+        return parsedValue === parsedComparator;
+    }
+    return cleanString(value) === cleanString(comparator);
 };
 json_logic_js_1.default.add_operation("=", function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
@@ -129,34 +145,44 @@ json_logic_js_1.default.add_operation("has-many", function (values, comparator,
 });
 var is = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
-        var cleanValue = (typeof value === "number"
-            ? value.toString()
-            : value.trim()).toLowerCase();
-        var cleanComparator = (typeof comparator === "number"
-            ? comparator.toString()
-            : comparator.trim()).toLowerCase();
-        return cleanValue === cleanComparator && parent;
+        return cleanString(value) === cleanString(comparator) && parent;
     });
     var filter = reducedValues.filter(function (_value) { return _value === true; });
     return reducedValues.length === filter.length;
 };
 json_logic_js_1.default.add_operation("is", is);
-json_logic_js_1.default.add_operation("contains", is);
 var not = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
-        var cleanValue = (typeof value === "number"
-            ? value.toString()
-            : value.trim()).toLowerCase();
-        var cleanComparator = (typeof comparator === "number"
-            ? comparator.toString()
-            : comparator.trim()).toLowerCase();
-        return cleanValue !== cleanComparator && parent;
+        return cleanString(value) !== cleanString(comparator) && parent;
     });
     var filter = reducedValues.filter(function (_value) { return _value === true; });
     return reducedValues.length === filter.length;
 };
 json_logic_js_1.default.add_operation("not", not);
-json_logic_js_1.default.add_operation("does-not-contain", not);
+var contains = function (values, comparator, parents) {
+    var reducedValues = reduceValues(values, parents, function (value, parent) {
+        if (Array.isArray(value)) {
+            return (value.some(function (val) {
+                return cleanString(val).includes(cleanString(comparator));
+            }) && parent);
+        }
+        return (cleanString(value).includes(cleanString(comparator)) && parent);
+    });
+    var filter = reducedValues.filter(function (value) { return value === true; });
+    return reducedValues.length === filter.length;
+};
+json_logic_js_1.default.add_operation("contains", contains);
+var doesNotContain = function (values, comparator, parents) {
+    var reducedValues = reduceValues(values, parents, function (value, parent) {
+        if (Array.isArray(value)) {
+            return (value.every(function (val) { return !cleanString(val).includes(cleanString(comparator)); }) && parent);
+        }
+        return (!cleanString(value).includes(cleanString(comparator)) && parent);
+    });
+    var filter = reducedValues.filter(function (value) { return value === true; });
+    return reducedValues.length === filter.length;
+};
+json_logic_js_1.default.add_operation("does-not-contain", doesNotContain);
 json_logic_js_1.default.add_operation("empty", function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
         var stringValue = typeof value === "number" ? value.toString() : value;
@@ -175,13 +201,7 @@ json_logic_js_1.default.add_operation("not-empty", function (values, comparator,
 });
 var like = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
-        var cleanValue = (typeof value === "number"
-            ? value.toString()
-            : value.trim()).toLowerCase();
-        var cleanComparator = (typeof comparator === "number"
-            ? comparator.toString()
-            : comparator.trim()).toLowerCase();
-        return (new RegExp("( |^)" + cleanComparator + "( |$)", "i").test(cleanValue) && parent);
+        return (new RegExp("( |^)".concat(cleanString(comparator), "( |$)"), "i").test(cleanString(value)) && parent);
     });
     var filter = reducedValues.filter(function (_value) { return _value === true; });
     return reducedValues.length === filter.length;
@@ -189,14 +209,7 @@ var like = function (values, comparator, parents) {
 json_logic_js_1.default.add_operation("like", like);
 var notLike = function (values, comparator, parents) {
     var reducedValues = reduceValues(values, parents, function (value, parent) {
-        var cleanValue = (typeof value === "number"
-            ? value.toString()
-            : value.trim()).toLowerCase();
-        var cleanComparator = (typeof comparator === "number"
-            ? comparator.toString()
-            : comparator.trim()).toLowerCase();
-        return (!new RegExp("( |^)" + cleanComparator + "( |$)", "i").test(cleanValue) &&
-            parent);
+        return (!new RegExp("( |^)".concat(cleanString(comparator), "( |$)"), "i").test(cleanString(value)) && parent);
     });
     var filter = reducedValues.filter(function (_value) { return _value === true; });
     return reducedValues.length === filter.length;
@@ -226,5 +239,105 @@ var regexMatch = function (values, comparator, parents) {
     return reducedValues.length === filter.length;
 };
 json_logic_js_1.default.add_operation("regex-match", regexMatch);
+var aggregateAny = function (reducedValues) {
+    return reducedValues.includes(true);
+};
+var aggregateFirst = function (reducedValues) {
+    return reducedValues[0] === true;
+};
+var registerScopedBooleanOp = function (baseName, compareFn) {
+    json_logic_js_1.default.add_operation("".concat(baseName, "-first"), function (values, _comparator, parents) {
+        var reducedValue = reduceValues(values, parents, compareFn);
+        return aggregateFirst(reducedValue);
+    });
+    json_logic_js_1.default.add_operation("".concat(baseName, "-any"), function (values, _comparator, parents) {
+        var reducedValue = reduceValues(values, parents, compareFn);
+        return aggregateAny(reducedValue);
+    });
+};
+registerScopedBooleanOp("selected", function (value, parent) { return value && parent; });
+registerScopedBooleanOp("not-selected", function (value, parent) { return !value && parent; });
+var conditionMet = function (value, parent) {
+    return value === true && parent;
+};
+var conditionNotMet = function (value, parent) {
+    return value !== true && parent;
+};
+json_logic_js_1.default.add_operation("conditions-met", function (values, comparator, parents) {
+    return reduceValues(values, parents, conditionMet).every(function (value) { return value === true; });
+});
+json_logic_js_1.default.add_operation("conditions-not-met", function (values, comparator, parents) {
+    return reduceValues(values, parents, conditionNotMet).every(function (value) { return value === true; });
+});
+registerScopedBooleanOp("conditions-met", conditionMet);
+registerScopedBooleanOp("conditions-not-met", conditionNotMet);
+var registerScopedComparisonOp = function (baseName, compareFn) {
+    json_logic_js_1.default.add_operation("".concat(baseName, "-any"), function (values, comparator, parents) {
+        var reducedValues = reduceValues(values, parents, function (value, parent) {
+            return compareFn(value, comparator, parent);
+        });
+        return aggregateAny(reducedValues);
+    });
+    json_logic_js_1.default.add_operation("".concat(baseName, "-first"), function (values, comparator, parents) {
+        var reducedValues = reduceValues(values, parents, function (value, parent) {
+            return compareFn(value, comparator, parent);
+        });
+        return aggregateFirst(reducedValues);
+    });
+};
+registerScopedComparisonOp("=", function (value, comparator, parent) {
+    return safeEqual(value, comparator) && parent;
+});
+registerScopedComparisonOp("<>", function (value, comparator, parent) {
+    return !safeEqual(value, comparator) && parent;
+});
+registerScopedComparisonOp("==", function (value, comparator, parent) {
+    return parseNumber(value) === parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp(">=", function (value, comparator, parent) {
+    return parseNumber(value) >= parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp("<=", function (value, comparator, parent) {
+    return parseNumber(value) <= parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp(">", function (value, comparator, parent) {
+    return parseNumber(value) > parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp("<", function (value, comparator, parent) {
+    return parseNumber(value) < parseNumber(comparator) && parent;
+});
+registerScopedComparisonOp("is", function (value, comparator, parent) {
+    return cleanString(value) === cleanString(comparator) && parent;
+});
+registerScopedComparisonOp("not", function (value, comparator, parent) {
+    return cleanString(value) !== cleanString(comparator) && parent;
+});
+registerScopedComparisonOp("contains", function (value, comparator, parent) {
+    return cleanString(value).includes(cleanString(comparator)) && parent;
+});
+registerScopedComparisonOp("does-not-contain", function (value, comparator, parent) {
+    return !cleanString(value).includes(cleanString(comparator)) && parent;
+});
+registerScopedComparisonOp("like", function (value, comparator, parent) {
+    return new RegExp("( |^)".concat(cleanString(comparator), "( |$)"), "i").test(cleanString(value)) && parent;
+});
+registerScopedComparisonOp("not-like", function (value, comparator, parent) {
+    return !new RegExp("( |^)".concat(cleanString(comparator), "( |$)"), "i").test(cleanString(value)) && parent;
+});
+registerScopedComparisonOp("regex-match", function (value, comparator, parent) {
+    if (typeof comparator !== "string")
+        return false;
+    var regex;
+    try {
+        regex = new RegExp(comparator);
+    }
+    catch (error) {
+        return false;
+    }
+    var stringValue = typeof value === "number" ? value.toString() : value;
+    return regex.test(stringValue) && parent;
+});
+registerScopedComparisonOp("empty", function (value, _comparator, parent) { return cleanString(value).length === 0 && parent; });
+registerScopedComparisonOp("not-empty", function (value, _comparator, parent) { return cleanString(value).length > 0 && parent; });
 var LpLogic = json_logic_js_1.default.apply;
 exports.default = LpLogic;

package/dist/Parser.js

@@ -16,7 +16,7 @@ var Parser = (function () {
     Parser.prototype.validateCondition = function (condition) {
         var result = (0, jsonschema_1.validate)(condition, condition_v1_schema_1.default);
         if (result.errors.length > 0) {
-            throw new Error(JSON.stringify(condition) + " is not a valid condition");
+            throw new Error("".concat(JSON.stringify(condition), " is not a valid condition"));
         }
     };
     Parser.prototype.convertConditions = function (conditions) {
@@ -31,7 +31,7 @@ var Parser = (function () {
                     operator = value.t;
                 }
                 else if (value.t !== operator) {
-                    throw new Error("Conditions object is not valid, " + operator + " is not equal to " + value.t + " at index " + index + " in " + JSON.stringify(conditions));
+                    throw new Error("Conditions object is not valid, ".concat(operator, " is not equal to ").concat(value.t, " at index ").concat(index, " in ").concat(JSON.stringify(conditions)));
                 }
             }
         }
@@ -57,7 +57,7 @@ var Parser = (function () {
             logic = logicConditions[0];
         }
         else {
-            throw new Error("Invalid condition " + conditions);
+            throw new Error("Invalid condition ".concat(conditions));
         }
         return logic;
     };
@@ -70,18 +70,18 @@ var Parser = (function () {
         var dataReference;
         if (condition.o !== false && condition.o !== undefined) {
             dataReference = {
-                var: "o." + condition.o
+                var: "o.".concat(condition.o)
             };
             rule[operation] = [dataReference];
         }
         else if (condition.v !== false && condition.v !== undefined) {
             dataReference = {
-                var: "v." + condition.v
+                var: "v.".concat(condition.v)
             };
             rule[operation] = [dataReference, condition.value];
         }
         else {
-            throw new Error("Invalid condition " + condition);
+            throw new Error("Invalid condition ".concat(condition));
         }
         return rule;
     };

package/dist/definitions/model-v1-schema.d.ts

@@ -1,4 +1,4 @@
-export declare type ConditionV1Single = {
+export type ConditionV1Single = {
     c?: "selected" | "not-selected" | "has-one" | "at-least-one" | "has-many" | "contains" | "does-not-contain" | "=" | ">" | "<" | "!=" | ">=" | "<=" | "<>";
     o?: false | number | string;
     p?: string | number;
@@ -8,11 +8,11 @@ export declare type ConditionV1Single = {
     m?: boolean;
     t?: "and" | "or";
 };
-export declare type ConditionV1Array = {
+export type ConditionV1Array = {
     condition_array?: ConditionV1Compose[];
 };
-declare type ConditionV1Compose = ConditionV1Array & ConditionV1Single;
-export declare type CompiledConditionV1 = ConditionV1Compose[];
+type ConditionV1Compose = ConditionV1Array & ConditionV1Single;
+export type CompiledConditionV1 = ConditionV1Compose[];
 export interface ModelV1 {
     contract_name: string;
     sections: SectionV1[];

package/jest.config.js

@@ -1,13 +1,10 @@
 module.exports = {
-    "roots": [
-        "./tests"
-    ],
-    "transform": {
-        "^.+\\.tsx?$": "ts-jest"
-    },
-    "globals": {
-        "ts-jest": {
-            tsConfig: "tsconfig.json"
-        }
-    }
-}
+  roots: [
+    "./tests"
+  ],
+  transform: {
+    "^.+\\.tsx?$": ['ts-jest', {
+      tsconfig: "tsconfig.json"
+    }],
+  },
+};

package/package.json

@@ -1,24 +1,27 @@
 {
   "name": "@legalplace/lplogic",
-  "version": "2.3.1",
+  "version": "2.3.2-staging.1",
   "description": "LegalPlace LpLogic",
   "main": "dist/index.js",
   "scripts": {
-    "test": "npx jest",
-    "build": "npx tsc",
+    "test": "jest",
+    "build": "tsc",
     "release": "standard-version -a --no-verify"
   },
   "outDir": "./dist",
   "author": "Moncef Hammou <moncef@legalplace.fr>",
   "license": "ISC",
   "dependencies": {
-    "@legalplace/models-v3-types": "5.1.24",
     "@legalplace/json-logic-js": "^1.2.3",
+    "@legalplace/models-v3-types": "5.1.24",
     "jsonschema": "^1.2.4"
   },
   "devDependencies": {
     "@babel/core": "^7.7.2",
     "@babel/preset-typescript": "^7.7.2",
+    "@commitlint/cli": "^9.0.1",
+    "@commitlint/config-conventional": "^9.0.1",
+    "@types/jest": "^29.5.14",
     "@types/node": "^12.12.6",
     "@typescript-eslint/eslint-plugin": "^2.6.1",
     "@typescript-eslint/parser": "^2.6.1",
@@ -26,12 +29,12 @@
     "eslint": "^6.6.0",
     "eslint-config-airbnb-base": "^14.0.0",
     "eslint-plugin-import": "^2.18.2",
-    "typescript": "4.4.3",
-    "semantic-release": "^17.1.1",
     "husky": "^4.2.5",
-    "@commitlint/cli": "^9.0.1",
-    "@commitlint/config-conventional": "^9.0.1",
-    "standard-version": "^8.0.0"
+    "jest": "^29.7.0",
+    "semantic-release": "^17.1.1",
+    "standard-version": "^8.0.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "5.6.3"
   },
   "husky": {
     "hooks": {

package/tests/LpLogic.test.ts

@@ -1,131 +1,370 @@
 import LpLogic from "../lib/index"
 
 test('Testing "selected" operator on a boolean `true`', async () => {
-    expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":true}})).toBe(true)
+  expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[true]}})).toBe(true)
 })
 
 test('Testing "selected" operator on an array of boolean `true`', async () => {
-    expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[true, true]}})).toBe(true)
+  expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[true, true]}})).toBe(true)
 })
 
 
 test('Testing "selected" operator on an array of boolean `false`', async () => {
-    expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":false}})).toBe(false)
+  expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[false]}})).toBe(false)
 })
 
 test('Testing "selected" operator on an array containing a boolean `false`', async () => {
-    expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[true, false]}})).toBe(false)
+  expect(LpLogic({"selected":[{"var":"o.1"}]}, {"o":{"1":[true, false]}})).toBe(false)
 })
 
 test('Testing "not-selected" operator on a boolean `false`', async () => {
-    expect(LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":false}})).toBe(true)
+  expect(LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[false]}})).toBe(true)
 })
 
 test('Testing "not-selected" operator on an array of boolean `false`', async () => {
-    expect(LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[false, false]}})).toBe(true)
+  expect(LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[false, false]}})).toBe(true)
 })
 
 // Returns false
 
 test('Testing "not-selected" operator on a boolean `true`', async () => {
-    expect( LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":true}}) ).toBe(false)
+  expect( LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[true]}}) ).toBe(false)
 })
 
 test('Testing "not-selected" operator on an array containing a boolean `true`', async () => {
-    expect( LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[true, false]}}) ).toBe(false)
+  expect( LpLogic({"not-selected":[{"var":"o.1"}]}, {"o":{"1":[true, false]}}) ).toBe(false)
 })
 
 // Returns true
 test('Testing "has-one" on an array of one element', async () => {
-    expect(LpLogic({"has-one":[{"var":"o.1"}]}, {"o":{"1":[true]}})).toBe(true)
+  expect(LpLogic({"has-one":[{"var":"o.1"}]}, {"o":{"1":[true]}})).toBe(true)
 })
 
 // Returns false
 test('Testing "has-one" on an array of two elements', async () => {
-    expect( LpLogic({"has-one":[{"var":"o.1"}]}, {"o":{"1":[true, true]}}) ).toBe(false)
+  expect( LpLogic({"has-one":[{"var":"o.1"}]}, {"o":{"1":[true, true]}}) ).toBe(false)
 })
 
 
 // Returns true
 test('Testing "has-many" on an array of two elements', async () => {
-    expect( LpLogic({"has-many":[{"var":"o.1"}]}, {"o":{"1":[true, true]}}) ).toBe(true)
+  expect( LpLogic({"has-many":[{"var":"o.1"}]}, {"o":{"1":[true, true]}}) ).toBe(true)
 });
 
 
 // Returns false
 test('Testing "has-many" on an array of one element', async () => {
-    expect( LpLogic({"has-many":[{"var":"o.1"}]}, {"o":{"1":[true]}}) ).toBe(false)
+  expect( LpLogic({"has-many":[{"var":"o.1"}]}, {"o":{"1":[true]}}) ).toBe(false)
 })
 
 // Returns true
 test('Testing "at-least-one" on a array of three elements with one as true', async () => {
-    expect( LpLogic({"at-least-one":[{"var":"o.1"}]}, {"o":{"1":[false, false, true]}}) ).toBe(true)
+  expect( LpLogic({"at-least-one":[{"var":"o.1"}]}, {"o":{"1":[false, false, true]}}) ).toBe(true)
 })
 
 // Returns false
 test('Testing "at-least-one" on an array of three elements with all elements as false', async () => {
-    expect( LpLogic({"at-least-one":[{"var":"o.1"}]}, {"o":{"1":[false, false, false]}}) ).toBe(false)
+  expect( LpLogic({"at-least-one":[{"var":"o.1"}]}, {"o":{"1":[false, false, false]}}) ).toBe(false)
 });
 
 
 // Returns true
 test('Testing "contains" Hello on a value `Hello`', async () => {
-    expect( LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Hello"}}) ).toBe(true)
+  expect( LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Hello"]}}) ).toBe(true)
 })
 
 
 // Returns false
 test('Testing "contains" Hello on a value `Bye`', async () => {
-    expect( LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Bye"}}) ).toBe(false)
+  expect( LpLogic({"contains":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Bye"]}}) ).toBe(false)
 })
 
 // Returns true
 test('Testing "is" Hello on a value `Hello`', async () => {
-    expect( LpLogic({"is":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Hello"}}) ).toBe(true)
+  expect( LpLogic({"is":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Hello"]}}) ).toBe(true)
 })
 
 
 // Returns false
 test('Testing "is" Hello on a value `Bye`', async () => {
-    expect( LpLogic({"is":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Bye"}}) ).toBe(false)
+  expect( LpLogic({"is":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Bye"]}}) ).toBe(false)
 })
 
 // Returns true
 test('Testing "does-not-contain" Hello on a value `Bye`', async () => {
-    expect( LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Bye"}}) ).toBe(true)
+  expect( LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Bye"]}}) ).toBe(true)
 })
 
 // Returns false
 test('Testing "does-not-contain" Hello on a value `Hello`', async () => {
-    expect( LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Hello"}}) ).toBe(false)
+  expect( LpLogic({"does-not-contain":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Hello"]}}) ).toBe(false)
 })
 
 // Returns true
 test('Testing "not" Hello on a value `Bye`', async () => {
-    expect( LpLogic({"not":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Bye"}}) ).toBe(true)
+  expect( LpLogic({"not":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Bye"]}}) ).toBe(true)
 })
 
 // Returns false
 test('Testing "not" Hello on a value `Hello`', async () => {
-    expect( LpLogic({"not":[{"var":"v.1"}, "Hello"]}, {"v":{"1":"Hello"}}) ).toBe(false)
+  expect( LpLogic({"not":[{"var":"v.1"}, "Hello"]}, {"v":{"1":["Hello"]}}) ).toBe(false)
 })
 
 // Returns true
 test('Testing "like" World on a value `Hello world`', async () => {
-    expect( LpLogic({"like":[{"var":"v.1"}, "World"]}, {"v":{"1":"Hello world"}}) ).toBe(true)
+  expect( LpLogic({"like":[{"var":"v.1"}, "World"]}, {"v":{"1":["Hello world"]}}) ).toBe(true)
 })
 
 // Returns false
 test('Testing "like" Bye on a value `Hello world`', async () => {
-    expect( LpLogic({"like":[{"var":"v.1"}, "Bye"]}, {"v":{"1":"Hello world"}}) ).toBe(false)
+  expect( LpLogic({"like":[{"var":"v.1"}, "Bye"]}, {"v":{"1":["Hello world"]}}) ).toBe(false)
 })
 
 // Returns true
 test('Testing "not-like" Bye on a value `Hello world`', async () => {
-    expect( LpLogic({"not-like":[{"var":"v.1"}, "Bye"]}, {"v":{"1":"Hello world"}}) ).toBe(true)
+  expect( LpLogic({"not-like":[{"var":"v.1"}, "Bye"]}, {"v":{"1":["Hello world"]}}) ).toBe(true)
 })
 
 // Returns false
 test('Testing "not-like" World on a value `Hello world`', async () => {
-    expect( LpLogic({"not-like":[{"var":"v.1"}, "World"]}, {"v":{"1":"Hello world"}}) ).toBe(false)
-})
+  expect( LpLogic({"not-like":[{"var":"v.1"}, "World"]}, {"v":{"1":["Hello world"]}}) ).toBe(false)
+})
+
+test('Testing "selected-first" on first occurrence only', async () => {
+  expect(LpLogic({"selected-first":[{"var":"o.1"}]}, {"o":{"1":[true, false]}})).toBe(true)
+  expect(LpLogic({"selected-first":[{"var":"o.1"}]}, {"o":{"1":[false, true]}})).toBe(false)
+})
+
+test('Testing "=-any" on multiple values', async () => {
+  expect(LpLogic({"=-any":[{"var":"v.1"}, "a"]}, {"v":{"1":["a", "b"]}})).toBe(true)
+  expect(LpLogic({"=-any":[{"var":"v.1"}, "a"]}, {"v":{"1":["b", "c"]}})).toBe(false)
+})
+
+/**
+ * empty-any / not-empty-any cover occurrence scope "at least one" for emptiness checks.
+ */
+test('Testing "empty-any" on multiple values', async () => {
+  expect(LpLogic({"empty-any":[{"var":"v.1"}]}, {"v":{"1":["", "x"]}})).toBe(true)
+  expect(LpLogic({"empty-any":[{"var":"v.1"}]}, {"v":{"1":["x", "y"]}})).toBe(false)
+})
+
+test('Testing "empty-first" on multiple values', async () => {
+  expect(LpLogic({"empty-first":[{"var":"v.1"}]}, {"v":{"1":["", "x"]}})).toBe(true)
+  expect(LpLogic({"empty-first":[{"var":"v.1"}]}, {"v":{"1":["x", ""]}})).toBe(false)
+})
+
+test('Testing "not-empty-any" on multiple values', async () => {
+  expect(LpLogic({"not-empty-any":[{"var":"v.1"}]}, {"v":{"1":["", "x"]}})).toBe(true)
+  expect(LpLogic({"not-empty-any":[{"var":"v.1"}]}, {"v":{"1":["", ""]}})).toBe(false)
+})
+
+test('Testing "=-first" on multiple values', async () => {
+  expect(LpLogic({"=-first":[{"var":"v.1"}, "a"]}, {"v":{"1":["a", "b"]}})).toBe(true)
+  expect(LpLogic({"=-first":[{"var":"v.1"}, "a"]}, {"v":{"1":["b", "a"]}})).toBe(false)
+})
+
+test('Testing "conditions-met" without parents', async () => {
+  expect(
+    LpLogic({"conditions-met":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[true, true]}}})
+  ).toBe(true)
+  expect(
+    LpLogic({"conditions-met":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[true, false]}}})
+  ).toBe(false)
+})
+
+test('Testing "conditions-met" with parents', async () => {
+  expect(
+    LpLogic(
+      {"conditions-met":[{"var":"c.o.2"}, undefined, [{"var":"o.1"}]]},
+      {"c":{"o":{"2":[true, true]}}, "o":{"1":[true, true]}}
+    )
+  ).toBe(true)
+  expect(
+    LpLogic(
+      {"conditions-met":[{"var":"c.o.2"}, undefined, [{"var":"o.1"}]]},
+      {"c":{"o":{"2":[true, true]}}, "o":{"1":[true, false]}}
+    )
+  ).toBe(false)
+})
+
+test('Testing "conditions-met-first" on first occurrence only', async () => {
+  expect(
+    LpLogic({"conditions-met-first":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[true, false]}}})
+  ).toBe(true)
+  expect(
+    LpLogic({"conditions-met-first":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[false, true]}}})
+  ).toBe(false)
+})
+
+test('Testing "conditions-met-any" on multiple values', async () => {
+  expect(
+    LpLogic({"conditions-met-any":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[false, true]}}})
+  ).toBe(true)
+  expect(
+    LpLogic({"conditions-met-any":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[false, false]}}})
+  ).toBe(false)
+})
+
+test('Testing "conditions-not-met"', async () => {
+  expect(
+    LpLogic({"conditions-not-met":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[false, false]}}})
+  ).toBe(true)
+  expect(
+    LpLogic({"conditions-not-met":[{"var":"c.o.1"}]}, {"c":{"o":{"1":[true, false]}}})
+  ).toBe(false)
+})
+
+/**
+ * Regression: when a condition tree containing `undefined` parents is passed
+ * through any JSON serialization (e.g. Redux DevTools), `undefined` becomes
+ * `null` (`JSON.stringify([a, undefined])` → `'[a,null]'`). LpLogic must
+ * treat a `null` parents arg as "no parents" instead of throwing on
+ * `null.length`.
+ */
+test('Testing "conditions-met" with null parents (JSON round-trip safety)', async () => {
+  expect(
+    LpLogic(
+      { "conditions-met": [{ var: "c.o.1" }, null, null] },
+      { "c": { "o": { "1": [true, true] } } }
+    )
+  ).toBe(true)
+  expect(
+    LpLogic(
+      { "conditions-met-first": [{ var: "c.o.1" }, null, null] },
+      { "c": { "o": { "1": [true, false] } } }
+    )
+  ).toBe(true)
+})
+
+test('Testing "selected" with null parents (JSON round-trip safety)', async () => {
+  expect(
+    LpLogic(
+      { "selected": [{ var: "o.1" }, null, null] },
+      { "o": { "1": [true, true] } }
+    )
+  ).toBe(true)
+})
+
+test('Testing "conditions-met" with parents containing missing refs (null entries)', async () => {
+  // `{ var: "o.999" }` resolves to `null` because `o.999` is absent from data.
+  // Parents array is `[null]`; LpLogic must not throw.
+  expect(
+    LpLogic(
+      { "conditions-met": [{ var: "c.o.1" }, undefined, [{ var: "o.999" }]] },
+      { "c": { "o": { "1": [true] } } }
+    )
+  ).toBe(true)
+})
+
+/**
+ * Accent- and case-insensitive text matching (=, contains, like and negations).
+ * Matches the product table: la/lax, la/la ha, la/là, la/La, Léon/Leon.
+ */
+test('Testing "=" case-insensitive for strings', async () => {
+  expect(LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["La"] } })).toBe(
+    true
+  )
+  expect(LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["LA"] } })).toBe(
+    true
+  )
+})
+
+test('Testing "=" accent-insensitive for strings', async () => {
+  expect(LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })).toBe(
+    true
+  )
+  expect(
+    LpLogic({ "=": [{ var: "v.1" }, "Léon"] }, { v: { 1: ["Leon"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ "=": [{ var: "v.1" }, "Léon"] }, { v: { 1: ["LEON"] } })
+  ).toBe(true)
+})
+
+test('Testing "=" still false for different words', async () => {
+  expect(LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })).toBe(
+    false
+  )
+  expect(
+    LpLogic({ "=": [{ var: "v.1" }, "la"] }, { v: { 1: ["la ha"] } })
+  ).toBe(false)
+})
+
+test('Testing "=" still numeric for number-like values', async () => {
+  expect(LpLogic({ "=": [{ var: "v.1" }, "1.0"] }, { v: { 1: [1] } })).toBe(
+    true
+  )
+  expect(LpLogic({ "=": [{ var: "v.1" }, 1] }, { v: { 1: ["1"] } })).toBe(true)
+})
+
+test('Testing "<>" is inverse of accent/case-insensitive "="', async () => {
+  expect(LpLogic({ "<>": [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })).toBe(
+    false
+  )
+  expect(LpLogic({ "<>": [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })).toBe(
+    true
+  )
+})
+
+test('Testing "contains" accent- and case-insensitive', async () => {
+  expect(
+    LpLogic({ contains: [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ contains: [{ var: "v.1" }, "la"] }, { v: { 1: ["la ha"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ contains: [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ contains: [{ var: "v.1" }, "la"] }, { v: { 1: ["La"] } })
+  ).toBe(true)
+})
+
+test('Testing "does-not-contain" is inverse of accent-insensitive contains', async () => {
+  expect(
+    LpLogic(
+      { "does-not-contain": [{ var: "v.1" }, "la"] },
+      { v: { 1: ["là"] } }
+    )
+  ).toBe(false)
+  expect(
+    LpLogic(
+      { "does-not-contain": [{ var: "v.1" }, "la"] },
+      { v: { 1: ["Bye"] } }
+    )
+  ).toBe(true)
+})
+
+test('Testing "like" accent- and case-insensitive word match', async () => {
+  expect(
+    LpLogic({ like: [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })
+  ).toBe(false)
+  expect(
+    LpLogic({ like: [{ var: "v.1" }, "la"] }, { v: { 1: ["la ha"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ like: [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })
+  ).toBe(true)
+  expect(
+    LpLogic({ like: [{ var: "v.1" }, "la"] }, { v: { 1: ["La"] } })
+  ).toBe(true)
+})
+
+test('Testing "not-like" is inverse of accent-insensitive like', async () => {
+  expect(
+    LpLogic({ "not-like": [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })
+  ).toBe(false)
+  expect(
+    LpLogic({ "not-like": [{ var: "v.1" }, "la"] }, { v: { 1: ["lax"] } })
+  ).toBe(true)
+})
+
+test('Testing "is" accent-insensitive (legacy equal alias)', async () => {
+  expect(LpLogic({ is: [{ var: "v.1" }, "la"] }, { v: { 1: ["là"] } })).toBe(
+    true
+  )
+  expect(
+    LpLogic({ is: [{ var: "v.1" }, "Léon"] }, { v: { 1: ["Leon"] } })
+  ).toBe(true)
+})