@legalplace/conditions-runner 2.2.20 → 2.3.0

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/ScopedLeafEvaluator.ts

@@ -0,0 +1,236 @@
+import LpLogic from "@legalplace/lplogic";
+import type { ConditionData } from "./types/conditions.d";
+import {
+  areVariablesSiblings,
+  extractLhsVariableId,
+  extractVarTagIds,
+  getConditionVariableOptionId,
+  resolveComparatorString,
+  SCOPED_OPERATOR_REGEX,
+  type ComparatorResolverContext,
+  type ComparatorResolverDeps,
+} from "./ComparatorResolver";
+
+const UI_METADATA_KEYS = new Set(["scope", "groupMeta"]);
+
+/**
+ * Whether the comparator references a same-multiple sibling of the LHS variable.
+ */
+const hasSiblingComparatorTag = (
+  deps: ComparatorResolverDeps,
+  comparator: string,
+  lhsVariableId: number
+): boolean =>
+  extractVarTagIds(comparator).some((variableId) =>
+    areVariablesSiblings(deps.references, variableId, lhsVariableId)
+  );
+
+/**
+ * Whether this leaf must be evaluated pairwise (one RHS index per LHS row).
+ */
+const shouldEvaluatePairwiseSiblingLeaf = (
+  operatorKey: string,
+  args: unknown[],
+  context: ComparatorResolverContext,
+  deps: ComparatorResolverDeps
+): boolean => {
+  const comparator = args[1];
+  if (typeof comparator !== "string") return false;
+
+  const lhsVariableId = extractLhsVariableId(args[0]);
+  if (lhsVariableId === undefined) return false;
+  if (!hasSiblingComparatorTag(deps, comparator, lhsVariableId)) return false;
+
+  return (
+    context.conditionVariableId === undefined ||
+    SCOPED_OPERATOR_REGEX.test(operatorKey)
+  );
+};
+
+/**
+ * Builds leaf context bound to a specific LHS variable occurrence.
+ */
+const withLhsLeafContext = (
+  context: ComparatorResolverContext,
+  deps: ComparatorResolverDeps,
+  lhsVariableId: number,
+  index: number
+): ComparatorResolverContext => ({
+  ...context,
+  index,
+  evalVariableId: lhsVariableId,
+  optionId: getConditionVariableOptionId(deps.references, lhsVariableId),
+});
+
+/**
+ * Evaluates one occurrence of a comparison leaf.
+ */
+const evaluateRowComparison = (
+  baseOperator: string,
+  lhs: unknown,
+  comparator: string,
+  lhsVariableId: number,
+  lhsValue: string | number,
+  leafContext: ComparatorResolverContext,
+  deps: ComparatorResolverDeps
+): boolean => {
+  const resolvedComparator = resolveComparatorString(
+    comparator,
+    leafContext,
+    deps
+  );
+  const leafData: ConditionData = {
+    o: {},
+    v: { [lhsVariableId]: [lhsValue] },
+    c: { o: {}, s: {}, v: {} },
+  };
+  return Boolean(
+    LpLogic({ [baseOperator]: [lhs, resolvedComparator] }, leafData)
+  );
+};
+
+/**
+ * Evaluates a sibling `[var:N]` leaf pairwise across occurrences.
+ */
+const evaluatePairwiseSiblingLeaf = (
+  operatorKey: string,
+  args: unknown[],
+  context: ComparatorResolverContext,
+  deps: ComparatorResolverDeps
+): boolean => {
+  const scopeMatch = operatorKey.match(SCOPED_OPERATOR_REGEX);
+  const scope = scopeMatch === null ? "all" : scopeMatch[1];
+  const baseOperator = operatorKey.replace(SCOPED_OPERATOR_REGEX, "");
+  const lhsVariableId = extractLhsVariableId(args[0]);
+  if (lhsVariableId === undefined) return false;
+
+  const lhsValues = deps.ovc.variables[lhsVariableId] ?? [];
+  if (lhsValues.length === 0) {
+    return scope !== "any" && scope !== "first";
+  }
+
+  const comparator = args[1] as string;
+  const lhs = args[0];
+
+  if (scope === "first") {
+    return evaluateRowComparison(
+      baseOperator,
+      lhs,
+      comparator,
+      lhsVariableId,
+      lhsValues[0] as string | number,
+      withLhsLeafContext(context, deps, lhsVariableId, 0),
+      deps
+    );
+  }
+
+  if (scope === "any") {
+    return lhsValues.some((lhsValue, index) =>
+      evaluateRowComparison(
+        baseOperator,
+        lhs,
+        comparator,
+        lhsVariableId,
+        lhsValue as string | number,
+        withLhsLeafContext(context, deps, lhsVariableId, index),
+        deps
+      )
+    );
+  }
+
+  return lhsValues.every((lhsValue, index) =>
+    evaluateRowComparison(
+      baseOperator,
+      lhs,
+      comparator,
+      lhsVariableId,
+      lhsValue as string | number,
+      withLhsLeafContext(context, deps, lhsVariableId, index),
+      deps
+    )
+  );
+};
+
+/**
+ * Evaluates a scoped `-first` / `-any` leaf (non-pairwise) against unsliced data.
+ */
+const evaluateScopedLeaf = (
+  operatorKey: string,
+  args: unknown[],
+  unslicedData: ConditionData,
+  context: ComparatorResolverContext,
+  deps: ComparatorResolverDeps
+): boolean => {
+  const lhsVariableId = extractLhsVariableId(args[0]);
+  const comparator = args[1];
+  const leafContext =
+    lhsVariableId === undefined
+      ? { ...context, index: 0 }
+      : withLhsLeafContext(context, deps, lhsVariableId, 0);
+
+  const resolvedArgs = [...args];
+  if (typeof comparator === "string") {
+    resolvedArgs[1] = resolveComparatorString(comparator, leafContext, deps);
+  }
+
+  return Boolean(LpLogic({ [operatorKey]: resolvedArgs }, unslicedData));
+};
+
+/**
+ * Replaces `-first` / `-any` leaves and pairwise sibling `[var:N]` leaves with booleans.
+ *
+ * DataPopulator slices same-multiple rows for `related`; scoped operators must
+ * still aggregate across every occurrence. Sibling comparators on `all` / `any`
+ * / `first` must compare matching indexes pairwise.
+ */
+export const aggregateScopedLeaves = (
+  tree: unknown,
+  unslicedData: ConditionData,
+  context: ComparatorResolverContext,
+  deps: ComparatorResolverDeps
+): unknown => {
+  if (tree === null || tree === undefined) return tree;
+
+  if (Array.isArray(tree)) {
+    return tree.map((child) =>
+      aggregateScopedLeaves(child, unslicedData, context, deps)
+    );
+  }
+
+  if (typeof tree !== "object") return tree;
+
+  const node = tree as Record<string, unknown>;
+  const structuralKeys = Object.keys(node).filter(
+    (key) => !UI_METADATA_KEYS.has(key)
+  );
+
+  if (structuralKeys.length === 0) return node;
+
+  const operatorKey = structuralKeys[0];
+
+  if (operatorKey === "and" || operatorKey === "or") {
+    const children = node[operatorKey];
+    if (!Array.isArray(children)) return node;
+    return {
+      ...node,
+      [operatorKey]: children.map((child) =>
+        aggregateScopedLeaves(child, unslicedData, context, deps)
+      ),
+    };
+  }
+
+  const args = node[operatorKey];
+  if (
+    Array.isArray(args) &&
+    shouldEvaluatePairwiseSiblingLeaf(operatorKey, args, context, deps)
+  ) {
+    return evaluatePairwiseSiblingLeaf(operatorKey, args, context, deps);
+  }
+
+  if (SCOPED_OPERATOR_REGEX.test(operatorKey)) {
+    if (!Array.isArray(args)) return node;
+    return evaluateScopedLeaf(operatorKey, args, unslicedData, context, deps);
+  }
+
+  return node;
+};