@legalplace/lplogic 2.3.2-staging.0 → 2.3.2

package/.gitlab-automator

@@ -1,7 +1,7 @@
-GITLAB_PRIVATE_TOKEN=glpat-BOv5W1i6MoAAvHjzkmc5nW86MQp1OjkH.01.0w119catf
+GITLAB_PRIVATE_TOKEN=glpat-2LLXVHzUViBmoVAUPBzy
 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
+CLICKUP_PRIVATE_TOKEN=pk_32519579_FSGO0KOHXZ93NPCODYRPIWHWG12Y4G3A

package/dist/LpLogic.js

@@ -6,10 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var json_logic_js_1 = __importDefault(require("@legalplace/json-logic-js"));
 var reduceParents = function (parents, length) {
     var reducedParents = [];
-    var safeParents = parents.filter(function (entry) { return Array.isArray(entry); });
-    safeParents.sort(function (a, b) { return b.length - a.length; });
+    parents.sort(function (a, b) { return b.length - a.length; });
     var _loop_1 = function (index) {
-        var currentIndexResult = safeParents.reduce(function (previousValue, currentValue) {
+        var currentIndexResult = parents.reduce(function (previousValue, currentValue) {
             if (currentValue.length === 1)
                 return previousValue && currentValue[0];
             if (currentValue[index] === undefined)
@@ -24,7 +23,7 @@ var reduceParents = function (parents, length) {
     return reducedParents;
 };
 var reduceValues = function (values, parents, compareFunction) {
-    if (!Array.isArray(parents) || parents.length === 0) {
+    if (parents === undefined || parents.length === 0) {
         return values.map(function (currentValue) {
             return compareFunction(currentValue, true);
         });
@@ -271,108 +270,5 @@ 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 cleanString = function (value) {
-    return (typeof value === "number" ? value.toString() : value.trim()).toLowerCase();
-};
-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/lplogic",
-  "version": "2.3.2-staging.0",
+  "version": "2.3.2",
   "description": "LegalPlace LpLogic",
   "main": "dist/index.js",
   "scripts": {

package/tests/LpLogic.test.ts

@@ -129,129 +129,3 @@ test('Testing "not-like" Bye on a value `Hello world`', async () => {
 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)
 })
-
-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)
-})