@legalplace/conditions-runner 2.2.20 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/conditions-runner",
-  "version": "2.2.20",
+  "version": "2.3.0",
   "description": "Package containing method to execute conditions",
   "license": "MIT",
   "main": "dist/ConditionsRunner.js",
@@ -21,14 +21,14 @@
   },
   "prettier": "@legalplace/prettier-config",
   "dependencies": {
-    "@legalplace/lplogic": "2.3.1",
-    "@legalplace/models-v3-types": "^5.17.22",
-    "@legalplace/referencesparser": "^3.2.42"
+    "@legalplace/lplogic": "2.3.3",
+    "@legalplace/models-v3-types": "^5.18.0",
+    "@legalplace/referencesparser": "^3.3.0"
   },
   "devDependencies": {
     "@legalplace/prettier-config": "^2.1.3",
-    "@legalplace/types": "^2.22.12",
+    "@legalplace/types": "^2.22.13",
     "ts-node": "^10.8.1"
   },
-  "gitHead": "717a08baa101e1dcdead28714410c726f6cf9166"
+  "gitHead": "5b5eed67e9a7815f5fa77492782158fa6af0ca13"
 }

package/src/ComparatorResolver.ts

@@ -0,0 +1,338 @@
+import { getRecognizedOperatorKeys } from "@legalplace/referencesparser";
+import type { Types } from "@legalplace/referencesparser";
+import type { InputsType } from "@legalplace/types";
+
+/**
+ * Placeholder for empty variables in condition comparators.
+ * Must not match real user input (`""` would make `contains` always true).
+ */
+export const CONDITION_COMPARATOR_EMPTY_SENTINEL = "\uE000__LP_EMPTY__\uE000";
+
+const VAR_TAG_IN_TEXT_REGEX = /\[var:[0-9]+\]/i;
+const UI_METADATA_KEYS = new Set(["scope", "groupMeta"]);
+const RECOGNIZED_OPERATOR_KEYS = new Set(getRecognizedOperatorKeys());
+
+/**
+ * Detects scoped operator suffixes (`-first`, `-any`) for occurrence-aware aggregation.
+ */
+export const SCOPED_OPERATOR_REGEX = /-(first|any)$/;
+
+export type ComparatorResolverContext = {
+  optionId: number;
+  index: number;
+  /** Variable whose condition runs (sibling `[var:N]` use this row `index`). */
+  conditionVariableId?: number;
+  /** Option whose condition runs (vars on that option use this row `index`). */
+  conditionOptionId?: number;
+  /** LHS `v.N` for sibling binding. */
+  evalVariableId?: number;
+};
+
+export type ComparatorResolverDeps = {
+  references: Types.ReferencesType;
+  ovc: InputsType;
+};
+
+/**
+ * Immediate parent option for a variable (`parents[0]`).
+ */
+export const getConditionVariableOptionId = (
+  references: Types.ReferencesType,
+  variableId: number
+): number => {
+  const parents = references.relations.variables[variableId]?.parents;
+  return parents !== undefined && parents.length > 0 ? parents[0] : variableId;
+};
+
+/**
+ * Extracts variable ids referenced as `[var:N]` tags.
+ */
+export const extractVarTagIds = (text: string): number[] => {
+  const tagsMatch = text.match(/\[var:([0-9]+)\]/gi);
+  if (tagsMatch === null) return [];
+  return [
+    ...new Set(
+      tagsMatch.map((tag) => {
+        const match = tag.match(/([0-9]+)/);
+        return match === null ? 0 : parseInt(match[0], 10);
+      })
+    ),
+  ];
+};
+
+/**
+ * Extracts the LHS variable id from `{ var: 'v.N' }` LHS shape.
+ */
+export const extractLhsVariableId = (lhs: unknown): number | undefined => {
+  if (
+    typeof lhs !== "object" ||
+    lhs === null ||
+    !("var" in lhs) ||
+    typeof (lhs as { var: unknown }).var !== "string"
+  ) {
+    return undefined;
+  }
+
+  const match = (lhs as { var: string }).var.match(/^v\.([0-9]+)$/);
+  return match === null ? undefined : parseInt(match[1], 10);
+};
+
+/**
+ * Whether two variables share the same multiple root parent.
+ */
+export const areVariablesSiblings = (
+  references: Types.ReferencesType,
+  variableA: number,
+  variableB: number
+): boolean => {
+  const rootA =
+    references.relations.variables[variableA]?.parents?.slice(-1)[0];
+  const rootB =
+    references.relations.variables[variableB]?.parents?.slice(-1)[0];
+  return rootA !== undefined && rootA === rootB;
+};
+
+/**
+ * Whether a variable value should be read at the current repeat row `index`.
+ */
+const shouldUseConditionRowIndex = (
+  references: Types.ReferencesType,
+  variableId: number,
+  optionId: number,
+  context?: {
+    contextVariableId?: number;
+    conditionOptionId?: number;
+  }
+): boolean => {
+  const contextVariableId = context?.contextVariableId;
+
+  if (
+    contextVariableId !== undefined &&
+    areVariablesSiblings(references, variableId, contextVariableId)
+  ) {
+    return true;
+  }
+
+  if (context?.conditionOptionId !== undefined) {
+    const parents = references.relations.variables[variableId]?.parents;
+    if (
+      parents !== undefined &&
+      parents.length > 0 &&
+      parents[0] === context.conditionOptionId
+    ) {
+      return true;
+    }
+  }
+
+  const variableParents = references.relations.variables[variableId]?.parents;
+  if (variableParents === undefined || variableParents.length === 0) {
+    return false;
+  }
+
+  const rootVariableParentId = variableParents[variableParents.length - 1];
+  const rootVariableParentRelations =
+    references.relations.options[rootVariableParentId];
+  if (rootVariableParentRelations === undefined) return false;
+
+  return (
+    rootVariableParentRelations.children.options.includes(optionId) ||
+    rootVariableParentRelations.dependants.includes(optionId) ||
+    optionId === rootVariableParentId
+  );
+};
+
+/**
+ * Normalizes a raw variable cell for condition comparison.
+ */
+const normalizeConditionValue = (
+  currentValue: string | number | null | undefined
+): string => {
+  if (currentValue === null || currentValue === undefined) return "";
+  if (typeof currentValue === "number") return currentValue.toString();
+  if (typeof currentValue === "string") return currentValue;
+  return "";
+};
+
+/**
+ * Substitutes `[var:N]` in a condition comparator using OVC values.
+ */
+export const parseConditionComparatorWithVariables = (
+  text: string,
+  optionId: number,
+  index: number,
+  deps: ComparatorResolverDeps,
+  context?: Pick<
+    ComparatorResolverContext,
+    "conditionVariableId" | "conditionOptionId" | "evalVariableId"
+  >
+): string => {
+  const variableIds = extractVarTagIds(text);
+  if (variableIds.length === 0) return text;
+
+  const rowContext = {
+    contextVariableId: context?.evalVariableId ?? context?.conditionVariableId,
+    conditionOptionId: context?.conditionOptionId,
+  };
+
+  let parsedText = text;
+  variableIds.forEach((variableId) => {
+    const values = deps.ovc.variables[variableId] ?? [];
+    const useRow = shouldUseConditionRowIndex(
+      deps.references,
+      variableId,
+      optionId,
+      rowContext
+    );
+
+    const cleanValues = useRow
+      ? [normalizeConditionValue(values[index])]
+      : values.map((value) => normalizeConditionValue(value));
+
+    let resolved =
+      cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(", ");
+
+    if (resolved.trim().length === 0) {
+      resolved = CONDITION_COMPARATOR_EMPTY_SENTINEL;
+    }
+
+    parsedText = parsedText.replace(
+      new RegExp(`\\[var:${variableId}\\]`, "gi"),
+      resolved
+    );
+  });
+
+  return parsedText;
+};
+
+/**
+ * Uses the LHS variable's immediate parent option for related-variable resolution.
+ */
+const resolveLeafContext = (
+  lhs: unknown,
+  context: ComparatorResolverContext,
+  deps: ComparatorResolverDeps
+): ComparatorResolverContext => {
+  const variableId = extractLhsVariableId(lhs);
+  if (variableId === undefined) return context;
+
+  return {
+    ...context,
+    optionId: getConditionVariableOptionId(deps.references, variableId),
+    evalVariableId: variableId,
+  };
+};
+
+/**
+ * Resolves a comparator string containing `[var:N]` tags.
+ *
+ * Same-multiple tags follow the leaf LHS evaluation index
+ * (`evalVariableId` + `index`): related → current row, first → 0.
+ */
+export const resolveComparatorString = (
+  value: string,
+  context: ComparatorResolverContext,
+  deps: ComparatorResolverDeps
+): string => {
+  if (!VAR_TAG_IN_TEXT_REGEX.test(value)) return value;
+
+  return parseConditionComparatorWithVariables(
+    value,
+    context.optionId,
+    context.index,
+    deps,
+    {
+      evalVariableId: context.evalVariableId,
+      conditionVariableId: context.conditionVariableId,
+      conditionOptionId: context.conditionOptionId,
+    }
+  );
+};
+
+/**
+ * Walks a condition tree and resolves comparator literals before LpLogic runs.
+ */
+const walkConditionNode = (
+  node: unknown,
+  context: ComparatorResolverContext,
+  deps: ComparatorResolverDeps
+): unknown => {
+  if (node === null || node === undefined) return node;
+
+  if (Array.isArray(node)) {
+    return node.map((child) => walkConditionNode(child, context, deps));
+  }
+
+  if (typeof node !== "object") return node;
+
+  const conditionNode = node as Record<string, unknown>;
+  const structuralKeys = Object.keys(conditionNode).filter(
+    (key) => !UI_METADATA_KEYS.has(key)
+  );
+
+  if (structuralKeys.length === 0) return conditionNode;
+
+  const operatorKey = structuralKeys.find((key) =>
+    RECOGNIZED_OPERATOR_KEYS.has(key)
+  );
+
+  if (structuralKeys.length > 1 && operatorKey === undefined) {
+    return conditionNode;
+  }
+
+  const currentKey = operatorKey ?? structuralKeys[0];
+
+  if (currentKey === "and" || currentKey === "or") {
+    const children = conditionNode[currentKey];
+    if (!Array.isArray(children)) return conditionNode;
+
+    return {
+      ...conditionNode,
+      [currentKey]: children.map((child) =>
+        walkConditionNode(child, context, deps)
+      ),
+    };
+  }
+
+  if (RECOGNIZED_OPERATOR_KEYS.has(currentKey)) {
+    const args = conditionNode[currentKey];
+    if (!Array.isArray(args) || args.length < 2) return conditionNode;
+
+    const resolvedArgs = [...args];
+    const comparator = resolvedArgs[1];
+    if (typeof comparator === "string") {
+      const baseContext = SCOPED_OPERATOR_REGEX.test(currentKey)
+        ? { ...context, index: 0 }
+        : context;
+      const leafContext = resolveLeafContext(
+        resolvedArgs[0],
+        baseContext,
+        deps
+      );
+      resolvedArgs[1] = resolveComparatorString(comparator, leafContext, deps);
+    }
+
+    return {
+      ...conditionNode,
+      [currentKey]: resolvedArgs,
+    };
+  }
+
+  return conditionNode;
+};
+
+/**
+ * Resolves comparators in a mapped conditions tree.
+ */
+export const resolveConditionComparators = (
+  conditions: unknown,
+  context: ComparatorResolverContext,
+  deps: ComparatorResolverDeps
+): unknown => {
+  if (Array.isArray(conditions)) {
+    return conditions.map((condition) =>
+      walkConditionNode(condition, context, deps)
+    );
+  }
+
+  return walkConditionNode(conditions, context, deps);
+};