@legalplace/conditions-runner 2.2.20-staging.0 → 2.2.20

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.2.20](https://git.legalplace.eu/legalplace/monorepo/compare/@legalplace/conditions-runner@2.2.19...@legalplace/conditions-runner@2.2.20) (2026-08-27)
+
+**Note:** Version bump only for package @legalplace/conditions-runner
+
+
+
+
+
 ## [2.2.19](https://git.legalplace.eu/legalplace/monorepo/compare/@legalplace/conditions-runner@2.2.18...@legalplace/conditions-runner@2.2.19) (2026-08-26)
 
 **Note:** Version bump only for package @legalplace/conditions-runner

package/dist/ConditionsRunner.d.ts

@@ -15,6 +15,5 @@ declare class ConditionsRunner {
         dataMap: ConditionDataMap;
         conditions: ConditionV3;
     }, id: number, index: number, conditionType: "options" | "optionValidator" | "variables" | "prefillers" | "variableValidator" | "sections" | "documents"): any;
-    private buildComparatorResolverContext;
 }
 export default ConditionsRunner;

package/dist/ConditionsRunner.js

@@ -4,10 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const lplogic_1 = __importDefault(require("@legalplace/lplogic"));
-const referencesparser_1 = require("@legalplace/referencesparser");
 const DataPopulator_1 = __importDefault(require("./DataPopulator"));
-const ScopedLeafEvaluator_1 = require("./ScopedLeafEvaluator");
-const ComparatorResolver_1 = require("./ComparatorResolver");
 class ConditionsRunner {
     constructor(references, ovc) {
         this.executeConditionMemo = {};
@@ -80,28 +77,9 @@ class ConditionsRunner {
         else if (conditionType === "sections" || conditionType === "documents") {
             currentData = new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap, id, index).getData();
         }
-        const resolverContext = this.buildComparatorResolverContext(id, index, conditionType);
-        const deps = { references: this.references, ovc: this.ovc };
-        const aggregatedConditions = (0, ScopedLeafEvaluator_1.aggregateScopedLeaves)((0, referencesparser_1.lowerScope)(condition.conditions), new DataPopulator_1.default(this, this.references, this.ovc, condition.dataMap).getData(), resolverContext, deps);
-        const resolvedConditions = (0, ComparatorResolver_1.resolveConditionComparators)(aggregatedConditions, resolverContext, deps);
-        const result = (0, lplogic_1.default)(resolvedConditions, currentData);
+        const result = (0, lplogic_1.default)(condition.conditions, currentData);
         this.executeConditionMemo[memoizedKey] = result;
         return result;
     }
-    buildComparatorResolverContext(id, index, conditionType) {
-        if (conditionType === "options" || conditionType === "optionValidator") {
-            return { optionId: id, index, conditionOptionId: id };
-        }
-        if (conditionType === "variables" ||
-            conditionType === "prefillers" ||
-            conditionType === "variableValidator") {
-            return {
-                optionId: (0, ComparatorResolver_1.getConditionVariableOptionId)(this.references, id),
-                index,
-                conditionVariableId: id,
-            };
-        }
-        return { optionId: id, index };
-    }
 }
 exports.default = ConditionsRunner;

package/dist/ConditionsRunner.test.js

@@ -3,292 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const referencesparser_1 = require("@legalplace/referencesparser");
 const ConditionsRunner_1 = __importDefault(require("./ConditionsRunner"));
-const ComparatorResolver_1 = require("./ComparatorResolver");
 const inputs_type_json_1 = __importDefault(require("./fixtures/inputs-type.json"));
 const references_json_1 = __importDefault(require("./fixtures/references.json"));
-const emptyOptionRelations = {
-    options: [],
-    variables: [],
-    sections: {},
-    documents: [],
-    prefillers: [],
-    validators: { options: [], variables: [] },
-    parents: [],
-    children: { options: [], variables: [] },
-    dependants: [],
-};
-const buildRelatedDocumentReferences = () => ({
-    options: {
-        2: {
-            meta: {
-                id: 2,
-                type: "static",
-                label: "Partner",
-                step: "*",
-                multiple: { enabled: true },
-            },
-            options: [3, 4],
-            variables: [],
-        },
-        3: {
-            meta: { id: 3, type: "radio", label: "Yes", step: "*" },
-            options: [],
-            variables: [],
-        },
-        4: {
-            meta: { id: 4, type: "radio", label: "No", step: "*" },
-            options: [],
-            variables: [],
-        },
-    },
-    variables: {},
-    outputs: {},
-    boxes: {},
-    documents: {
-        annex: {
-            name: "Annex",
-            params: { multiple: { enabled: true, repeatOption: 2 } },
-        },
-    },
-    sections: {},
-    relations: {
-        options: {
-            2: {
-                ...emptyOptionRelations,
-                children: { options: [3, 4], variables: [] },
-            },
-            3: { ...emptyOptionRelations, parents: [2] },
-            4: { ...emptyOptionRelations, parents: [2] },
-        },
-        variables: {},
-        sections: {},
-    },
-    conditions: {
-        options: {},
-        variables: {},
-        documents: {},
-        sections: { main: {} },
-        prefillers: {},
-        validators: { options: {}, variables: {} },
-    },
-    defaults: {},
-    evaluations: {},
-    optionTags: {},
-    variableTags: {},
-});
-const buildSiblingVariableReferences = () => ({
-    options: {
-        10: {
-            meta: {
-                id: 10,
-                type: "static",
-                label: "Repeat",
-                step: "*",
-                multiple: { enabled: true },
-            },
-            options: [],
-            variables: [3, 4],
-        },
-        20: {
-            meta: { id: 20, type: "static", label: "Other", step: "*" },
-            options: [],
-            variables: [5],
-        },
-    },
-    variables: {
-        3: { meta: { id: 3, type: "string", label: "Left" }, options: [] },
-        4: { meta: { id: 4, type: "string", label: "Right" }, options: [] },
-        5: { meta: { id: 5, type: "string", label: "Elsewhere" }, options: [] },
-    },
-    outputs: {},
-    boxes: {},
-    documents: {},
-    sections: {},
-    relations: {
-        options: {
-            10: {
-                ...emptyOptionRelations,
-                children: { options: [], variables: [3, 4] },
-            },
-            20: {
-                ...emptyOptionRelations,
-                children: { options: [], variables: [5] },
-            },
-        },
-        variables: {
-            3: { ...emptyOptionRelations, parents: [10] },
-            4: { ...emptyOptionRelations, parents: [10] },
-            5: { ...emptyOptionRelations, parents: [20] },
-        },
-        sections: {},
-    },
-    conditions: {
-        options: {},
-        variables: {},
-        documents: {},
-        sections: { main: {} },
-        prefillers: {},
-        validators: { options: {}, variables: {} },
-    },
-    defaults: {},
-    evaluations: {},
-    optionTags: {},
-    variableTags: {},
-});
-const relatedOvc = {
-    options: {
-        2: [true, true],
-        3: [true, false],
-        4: [false, true],
-    },
-    variables: {},
-};
-const siblingOvc = {
-    options: {
-        10: [true, true, true],
-        20: [true],
-    },
-    variables: {
-        3: ["same", "b", "c"],
-        4: ["same", "y", "c"],
-        5: ["solo-a", "solo-b"],
-    },
-};
-const mappedCondition = (conditions) => ({
-    dataMap: (0, referencesparser_1.extractConditionDataMap)(conditions),
-    conditions,
-});
 describe("ConditionsRunner class", () => {
     it("should not raise error when instanciating class", () => {
         expect(new ConditionsRunner_1.default(references_json_1.default, inputs_type_json_1.default)).toBeDefined();
     });
-    it("slices related document conditions to the current occurrence", () => {
-        const runner = new ConditionsRunner_1.default(buildRelatedDocumentReferences(), relatedOvc);
-        const condition = mappedCondition({
-            selected: [{ var: "o.3" }],
-            scope: "related",
-        });
-        expect(runner.executeCondition(condition, 2, 0, "documents")).toBe(true);
-        expect(runner.executeCondition(condition, 2, 1, "documents")).toBe(false);
-    });
-    it("evaluates selected + first against the first row after id/index slicing", () => {
-        const runner = new ConditionsRunner_1.default(buildRelatedDocumentReferences(), relatedOvc);
-        const condition = mappedCondition({
-            selected: [{ var: "o.3" }],
-            scope: "first",
-        });
-        expect(runner.executeCondition(condition, 2, 1, "documents")).toBe(true);
-    });
-    it("related sibling [var:N] uses the current occurrence index", () => {
-        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), siblingOvc);
-        const condition = mappedCondition({
-            "=": [{ var: "v.3" }, "[var:4]"],
-            scope: "related",
-        });
-        expect(runner.executeCondition(condition, 3, 0, "variables")).toBe(true);
-        expect(runner.executeCondition(condition, 3, 1, "variables")).toBe(false);
-        expect(runner.executeCondition(condition, 3, 2, "variables")).toBe(true);
-    });
-    it("first-scoped sibling [var:N] uses occurrence 0", () => {
-        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), siblingOvc);
-        const condition = mappedCondition({
-            "=": [{ var: "v.3" }, "[var:4]"],
-            scope: "first",
-        });
-        expect(runner.executeCondition(condition, 3, 2, "variables")).toBe(true);
-    });
-    it("all-scope sibling [var:N] is pairwise true when every row matches", () => {
-        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), {
-            options: { 10: [true, true], 20: [true] },
-            variables: {
-                3: [1, 2],
-                4: [2, 3],
-                5: ["solo-a"],
-            },
-        });
-        const condition = mappedCondition({
-            "<": [{ var: "v.3" }, "[var:4]"],
-            scope: "all",
-        });
-        expect(runner.executeCondition(condition, 3, 0, "options")).toBe(true);
-    });
-    it("all-scope sibling [var:N] is pairwise false when a row fails", () => {
-        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), {
-            options: { 10: [true, true], 20: [true] },
-            variables: {
-                3: [1, 5],
-                4: [2, 3],
-                5: ["solo-a"],
-            },
-        });
-        const condition = mappedCondition({
-            "<": [{ var: "v.3" }, "[var:4]"],
-            scope: "all",
-        });
-        expect(runner.executeCondition(condition, 3, 0, "options")).toBe(false);
-    });
-    it("any-scope sibling [var:N] succeeds on a later pairwise row", () => {
-        const runner = new ConditionsRunner_1.default(buildSiblingVariableReferences(), {
-            options: { 10: [true, true], 20: [true] },
-            variables: {
-                3: [5, 1],
-                4: [2, 10],
-                5: ["solo-a"],
-            },
-        });
-        const condition = mappedCondition({
-            "<": [{ var: "v.3" }, "[var:4]"],
-            scope: "any",
-        });
-        expect(runner.executeCondition(condition, 5, 0, "options")).toBe(true);
-    });
-    it("joins non-sibling [var:N] values instead of slicing by row", () => {
-        const references = buildSiblingVariableReferences();
-        const resolved = (0, ComparatorResolver_1.resolveConditionComparators)((0, referencesparser_1.lowerScope)({
-            "=": [{ var: "v.3" }, "[var:5]"],
-            scope: "related",
-        }), { optionId: 10, index: 2, conditionVariableId: 3 }, { references, ovc: siblingOvc });
-        expect(resolved).toEqual({
-            "=": [{ var: "v.3" }, "solo-a, solo-b"],
-        });
-    });
-});
-describe("resolveConditionComparators", () => {
-    const references = buildSiblingVariableReferences();
-    const deps = { references, ovc: siblingOvc };
-    it("related leaf: sibling [var:N] uses the current occurrence index", () => {
-        const resolved = (0, ComparatorResolver_1.resolveConditionComparators)((0, referencesparser_1.lowerScope)({
-            "=": [{ var: "v.3" }, "[var:4]"],
-            scope: "related",
-        }), { optionId: 10, index: 2, conditionVariableId: 3 }, deps);
-        expect(resolved).toEqual({
-            "=": [{ var: "v.3" }, "c"],
-        });
-    });
-    it("first-scoped leaf: sibling [var:N] uses occurrence 0", () => {
-        const resolved = (0, ComparatorResolver_1.resolveConditionComparators)((0, referencesparser_1.lowerScope)({
-            "=": [{ var: "v.3" }, "[var:4]"],
-            scope: "first",
-        }), { optionId: 10, index: 2, conditionVariableId: 3 }, deps);
-        expect(resolved).toEqual({
-            "=-first": [{ var: "v.3" }, "same"],
-        });
-    });
-    it("uses empty sentinel for missing sibling values", () => {
-        const resolved = (0, ComparatorResolver_1.resolveConditionComparators)((0, referencesparser_1.lowerScope)({
-            "=": [{ var: "v.3" }, "[var:4]"],
-            scope: "related",
-        }), { optionId: 10, index: 5, conditionVariableId: 3 }, {
-            references,
-            ovc: {
-                options: siblingOvc.options,
-                variables: { 3: ["a"], 4: ["b"], 5: [] },
-            },
-        });
-        expect(resolved).toEqual({
-            "=": [{ var: "v.3" }, ComparatorResolver_1.CONDITION_COMPARATOR_EMPTY_SENTINEL],
-        });
-    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/conditions-runner",
-  "version": "2.2.20-staging.0",
+  "version": "2.2.20",
   "description": "Package containing method to execute conditions",
   "license": "MIT",
   "main": "dist/ConditionsRunner.js",
@@ -21,13 +21,14 @@
   },
   "prettier": "@legalplace/prettier-config",
   "dependencies": {
-    "@legalplace/lplogic": "2.3.2-staging.1",
-    "@legalplace/models-v3-types": "^5.17.20",
-    "@legalplace/referencesparser": "^3.2.41"
+    "@legalplace/lplogic": "2.3.1",
+    "@legalplace/models-v3-types": "^5.17.22",
+    "@legalplace/referencesparser": "^3.2.42"
   },
   "devDependencies": {
     "@legalplace/prettier-config": "^2.1.3",
-    "@legalplace/types": "^2.22.11",
+    "@legalplace/types": "^2.22.12",
     "ts-node": "^10.8.1"
-  }
+  },
+  "gitHead": "717a08baa101e1dcdead28714410c726f6cf9166"
 }