@legalplace/conditions-runner 2.2.20 → 2.3.1

package/src/ConditionsRunner.test.ts

@@ -1,7 +1,185 @@
-import { Types } from "@legalplace/referencesparser";
+import { Types, extractConditionDataMap, lowerScope } from "@legalplace/referencesparser";
+import type { ConditionV3 } from "@legalplace/models-v3-types";
 import ConditionsRunner from "./ConditionsRunner";
+import {
+  CONDITION_COMPARATOR_EMPTY_SENTINEL,
+  resolveConditionComparators,
+} from "./ComparatorResolver";
 import dummyInputs from "./fixtures/inputs-type.json";
 import dummyReferences from "./fixtures/references.json";
+import type { ConditionDataMap } from "./types/conditions.d";
+
+const emptyOptionRelations = {
+  options: [],
+  variables: [],
+  sections: {},
+  documents: [] as string[],
+  prefillers: [],
+  validators: { options: [], variables: [] },
+  parents: [] as number[],
+  children: { options: [] as number[], variables: [] as number[] },
+  dependants: [] as number[],
+};
+
+/**
+ * Builds a minimal references graph: multiple #2 with radio children 3/4.
+ */
+const buildRelatedDocumentReferences = (): Types.ReferencesType =>
+  ({
+    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: {},
+  } as unknown as Types.ReferencesType);
+
+/**
+ * Multiple #10 hosting sibling variables 3 and 4 (same root parent).
+ */
+const buildSiblingVariableReferences = (): Types.ReferencesType =>
+  ({
+    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: {},
+  } as unknown as Types.ReferencesType);
+
+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"],
+  },
+};
+
+/**
+ * Builds executeCondition input from an authored ConditionV3 (scope on the node).
+ * @param conditions Authored condition tree
+ */
+const mappedCondition = (
+  conditions: ConditionV3
+): { dataMap: ConditionDataMap; conditions: ConditionV3 } => ({
+  dataMap: extractConditionDataMap(conditions),
+  conditions,
+});
 
 describe("ConditionsRunner class", () => {
   it("should not raise error when instanciating class", () => {
@@ -12,4 +190,186 @@ describe("ConditionsRunner class", () => {
       )
     ).toBeDefined();
   });
+
+  it("slices related document conditions to the current occurrence", () => {
+    const runner = new ConditionsRunner(
+      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(
+      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(
+      buildSiblingVariableReferences(),
+      siblingOvc
+    );
+    const condition = mappedCondition({
+      "=": [{ var: "v.3" }, "[var:4]"],
+      scope: "related",
+    });
+
+    // index 0: "same" === "same"
+    expect(runner.executeCondition(condition, 3, 0, "variables")).toBe(true);
+    // index 1: "b" === "y"
+    expect(runner.executeCondition(condition, 3, 1, "variables")).toBe(false);
+    // index 2: "c" === "c" (not "same" from occurrence 0)
+    expect(runner.executeCondition(condition, 3, 2, "variables")).toBe(true);
+  });
+
+  it("first-scoped sibling [var:N] uses occurrence 0", () => {
+    const runner = new ConditionsRunner(
+      buildSiblingVariableReferences(),
+      siblingOvc
+    );
+    const condition = mappedCondition({
+      "=": [{ var: "v.3" }, "[var:4]"],
+      scope: "first",
+    });
+
+    // Outer index 2 still binds both sides to occurrence 0 → "same" === "same"
+    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(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(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(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 = resolveConditionComparators(
+      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 = resolveConditionComparators(
+      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 = resolveConditionComparators(
+      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 = resolveConditionComparators(
+      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" }, CONDITION_COMPARATOR_EMPTY_SENTINEL],
+    });
+  });
 });

package/src/ConditionsRunner.ts

@@ -1,10 +1,17 @@
 /* eslint-disable max-len */
 import LpLogic from "@legalplace/lplogic";
 import type { Types } from "@legalplace/referencesparser";
+import { lowerScope } from "@legalplace/referencesparser";
 import type { ConditionV3 } from "@legalplace/models-v3-types";
 import type InputsType from "@legalplace/types/dist/inputs";
 import DataPopulator from "./DataPopulator";
 import type { ConditionDataMap } from "./types/conditions.d";
+import { aggregateScopedLeaves } from "./ScopedLeafEvaluator";
+import {
+  getConditionVariableOptionId,
+  resolveConditionComparators,
+  type ComparatorResolverContext,
+} from "./ComparatorResolver";
 
 class ConditionsRunner {
   private references: Types.ReferencesType;
@@ -171,10 +178,64 @@ class ConditionsRunner {
       ).getData();
     }
 
-    const result = LpLogic(condition.conditions, currentData);
+    const resolverContext = this.buildComparatorResolverContext(
+      id,
+      index,
+      conditionType
+    );
+    const deps = { references: this.references, ovc: this.ovc };
+
+    // Pairwise sibling `[var:N]` (all/any/first) must run before string
+    // substitution collapses the tag to a single value.
+    const aggregatedConditions = aggregateScopedLeaves(
+      lowerScope(condition.conditions),
+      new DataPopulator(
+        this,
+        this.references,
+        this.ovc,
+        condition.dataMap
+      ).getData(),
+      resolverContext,
+      deps
+    );
+
+    const resolvedConditions = resolveConditionComparators(
+      aggregatedConditions,
+      resolverContext,
+      deps
+    );
+
+    const result = LpLogic(resolvedConditions, currentData);
     this.executeConditionMemo[memoizedKey] = result;
     return result;
   }
+
+  /**
+   * Builds option/index context for comparator `[var:N]` substitution.
+   */
+  private buildComparatorResolverContext(
+    id: number,
+    index: number,
+    conditionType: string
+  ): ComparatorResolverContext {
+    if (conditionType === "options" || conditionType === "optionValidator") {
+      return { optionId: id, index, conditionOptionId: id };
+    }
+
+    if (
+      conditionType === "variables" ||
+      conditionType === "prefillers" ||
+      conditionType === "variableValidator"
+    ) {
+      return {
+        optionId: getConditionVariableOptionId(this.references, id),
+        index,
+        conditionVariableId: id,
+      };
+    }
+
+    return { optionId: id, index };
+  }
 }
 
 export default ConditionsRunner;

package/src/DataPopulator.ts

@@ -169,7 +169,7 @@ class DataPopulator {
   private getVariableValues(variableId: number): Readonly<(string | number)[]> {
     const value = this.ovc.variables[variableId] || [];
     if (this.id === undefined || this.index === undefined) {
-      return value;
+      return this.cleanArrayFromNullValues([...value]);
     }
 
     // Getting variable parent option
@@ -181,7 +181,7 @@ class DataPopulator {
       variableRootRelations.dependants.includes(this.id) ||
       this.id === variableRootParent
     ) {
-      return [value[this.index]];
+      return this.cleanArrayFromNullValues([value[this.index]]);
     }
 
     return this.cleanArrayFromNullValues([...value]);
@@ -203,9 +203,9 @@ class DataPopulator {
    * @param arr Values array
    */
   private cleanArrayFromNullValues(
-    arr: (string | number | null)[]
+    arr: (string | number | null | undefined)[]
   ): (string | number)[] {
-    return arr.map((v) => (v === null ? "" : v));
+    return arr.map((v) => (v === null || v === undefined ? "" : v));
   }
 
   /**