@legalplace/conditions-runner 2.2.20 → 2.3.1

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;
+};