@legalplace/prerenderx 3.8.24 → 3.9.0

package/src/libs/SectionRender.ts

@@ -17,6 +17,13 @@ class SectionRender {
 
   ovc: InputsType;
 
+  /**
+   * Occurrence index injected by the parent DocumentRender when the document
+   * is multiple (`params.multiple.enabled === true`). For non-multiple
+   * documents this is always 0.
+   */
+  baseIndex: number;
+
   private NumAuto: NumAuto;
 
   constructor(options: {
@@ -26,6 +33,7 @@ class SectionRender {
     documentName: string;
     currentSection: number;
     numauto: NumAuto;
+    baseIndex?: number;
   }) {
     this.references = options.references;
     this.conditions = options.conditions;
@@ -33,6 +41,7 @@ class SectionRender {
     this.currentSection = options.currentSection;
     this.ovc = options.ovc;
     this.NumAuto = options.numauto;
+    this.baseIndex = options.baseIndex ?? 0;
 
     this.renderSection();
   }
@@ -41,6 +50,19 @@ class SectionRender {
     return this.outputs;
   }
 
+  /**
+   * Returns the multiple source option id for the current document if any.
+   * Returns `undefined` for non-multiple documents.
+   */
+  private getDocumentMultipleSource(): number | undefined {
+    const docMultiple =
+      this.references.documents[this.documentName]?.params?.multiple;
+    if (docMultiple?.enabled !== true) return undefined;
+    return typeof docMultiple.repeatOption === "number"
+      ? docMultiple.repeatOption
+      : undefined;
+  }
+
   private renderSection() {
     const section =
       this.references.sections[this.documentName][this.currentSection];
@@ -51,45 +73,106 @@ class SectionRender {
     const condition =
       conditionObject === undefined
         ? true
-        : this.conditions.executeCondition(conditionObject, 0, 0, "sections");
-
-    // Rendering documents sections
-    if (condition === true) {
-      section.options.forEach((optionId) => {
-        const option = this.references.options[optionId];
-        let repeatOption = optionId;
-        if (option.meta.type === "repeated") {
-          if (option.meta.repeatOption === undefined) return;
-          repeatOption =
-            typeof option.meta.repeatOption === "number"
-              ? option.meta.repeatOption
-              : parseInt(option.meta.repeatOption, 10);
-        }
-
-        // Option inputs
-        const inputs = this.ovc.options[repeatOption] || [
-          !["radio", "checkbox"].includes(option.meta.type),
-        ]; // Falling back on a single value array if option doesn't exist in ovc
-
-        // Looping through inputs
-        inputs.forEach((value, index) => {
-          // If value is false we stop here
-          if (value !== true) return;
-
+        : this.conditions.executeCondition(
+            conditionObject,
+            0,
+            this.baseIndex,
+            "sections"
+          );
+
+    if (condition !== true) return;
+
+    const documentMultipleSource = this.getDocumentMultipleSource();
+
+    section.options.forEach((optionId) => {
+      const option = this.references.options[optionId];
+
+      // Detect a `repeated` wrapper that points to the same source as the
+      // document multiple. In that case, iterating over `repeatOption` here
+      // would double the loop (the document is already rendered N times by
+      // Prerender). Instead, render the wrapper's children once at the
+      // document's current occurrence index.
+      if (
+        option.meta.type === "repeated" &&
+        documentMultipleSource !== undefined &&
+        option.meta.repeatOption === documentMultipleSource
+      ) {
+        option.options.forEach((childId) => {
           this.outputs = [
             ...this.outputs,
             ...new OptionRender({
               references: this.references,
-              id: optionId,
+              id: childId,
               ovc: this.ovc,
-              index,
+              index: this.baseIndex,
               conditions: this.conditions,
               numauto: this.NumAuto,
             }).getOutputs(),
           ];
         });
+        return;
+      }
+
+      let repeatOption = optionId;
+      if (option.meta.type === "repeated") {
+        if (option.meta.repeatOption === undefined) return;
+        repeatOption =
+          typeof option.meta.repeatOption === "number"
+            ? option.meta.repeatOption
+            : parseInt(option.meta.repeatOption, 10);
+      }
+
+      // Option inputs
+      const inputs = this.ovc.options[repeatOption] || [
+        !["radio", "checkbox"].includes(option.meta.type),
+      ]; // Falling back on a single value array if option doesn't exist in ovc
+
+      // Inside a multiple document, every non-`repeated` root option is
+      // rendered at the document's occurrence index instead of looping
+      // through every input slot. We pick the value at `baseIndex` (or
+      // fall back to slot 0 for non-multiplied options whose inputs are
+      // a single-element array).
+      if (
+        documentMultipleSource !== undefined &&
+        option.meta.type !== "repeated"
+      ) {
+        const valueAtIndex =
+          this.baseIndex < inputs.length ? inputs[this.baseIndex] : inputs[0];
+        if (valueAtIndex !== true) return;
+
+        this.outputs = [
+          ...this.outputs,
+          ...new OptionRender({
+            references: this.references,
+            id: optionId,
+            ovc: this.ovc,
+            index: this.baseIndex,
+            conditions: this.conditions,
+            numauto: this.NumAuto,
+          }).getOutputs(),
+        ];
+        return;
+      }
+
+      // Looping through inputs (default behaviour, also used for `repeated`
+      // wrappers whose source differs from the document multiple source).
+      inputs.forEach((value, index) => {
+        // If value is false we stop here
+        if (value !== true) return;
+
+        this.outputs = [
+          ...this.outputs,
+          ...new OptionRender({
+            references: this.references,
+            id: optionId,
+            ovc: this.ovc,
+            index,
+            conditions: this.conditions,
+            numauto: this.NumAuto,
+          }).getOutputs(),
+        ];
       });
-    }
+    });
   }
 }
 

package/src/libs/misc/FillPdfFormBase.ts

@@ -1,6 +1,11 @@
 import type { Types } from "@legalplace/referencesparser";
 import type ConditionsRunner from "@legalplace/conditions-runner";
 import type InputsType from "@legalplace/types/dist/inputs";
+import {
+  isOptionDisplayed as sharedIsOptionDisplayed,
+  isVariableDisplayed as sharedIsVariableDisplayed,
+  type ConditionEvaluator,
+} from "@legalplace/referencesparser";
 
 class FillPdfFormBase {
   references: Types.ReferencesType;
@@ -20,59 +25,46 @@ class FillPdfFormBase {
   }
 
   /**
-   * Checks whether a variable is displayed at a given index
-   * @param id Variable's ID
-   * @param index Index
+   * Evaluates a stored condition for options, variables or sections.
+   */
+  private readonly conditionEvaluator: ConditionEvaluator = (
+    type,
+    id,
+    index
+  ) => {
+    if (type === "options") return this.getOptionCondition(id, index);
+    if (type === "variables") return this.getVariableCondition(id, index);
+    return this.getSectionCondition(id);
+  };
+
+  /**
+   * Checks whether a variable is displayed at a given index.
    */
   isVariableDisplayed(id: number, index: number) {
-    // Getting variable's conditions & executing it if any
-    const variableCondition = this.getVariableCondition(id, index);
-    const variableParents =
-      this.references.relations.variables[id]?.parents || [];
-    const parentOptionIsDisplayed = this.isOptionDisplayed(
-      variableParents[0],
+    return sharedIsVariableDisplayed(
+      this.references,
+      this.ovc,
+      this.conditionEvaluator,
+      id,
       index
     );
-
-    return (
-      [variableCondition, parentOptionIsDisplayed].filter((c) => c !== true)
-        .length === 0
-    );
   }
 
   /**
-   * Checks whether an option is displayed at a given index
-   * @param id Option's ID
-   * @param index Index
+   * Checks whether an option is displayed at a given index.
    */
   isOptionDisplayed(id: number, index: number) {
-    // Getting variable's conditions & executing it if any
-    const optionCondition = this.getOptionCondition(id, index);
-    const optionParents = this.references.relations.options[id]?.parents || [];
-    const parentsConditions = optionParents.map(
-      (optionId) => this.getOptionCondition(optionId, index) !== false
-    );
-    const parentsInputs = optionParents.map(
-      (optionId) => this.ovc.options[optionId][index]
-    );
-    const parentSectionId = this.getOptionParentSection(id);
-    const parentSectionCondition =
-      this.getSectionCondition(parentSectionId) !== false;
-
-    return (
-      [
-        optionCondition,
-        parentSectionCondition,
-        ...parentsConditions,
-        ...parentsInputs,
-      ].filter((c) => c !== true).length === 0
+    return sharedIsOptionDisplayed(
+      this.references,
+      this.ovc,
+      this.conditionEvaluator,
+      id,
+      index
     );
   }
 
   /**
-   * Returns a variable's conditions
-   * @param id Variable's id
-   * @param index Variable's index
+   * Returns a variable's conditions.
    */
   private getVariableCondition(id: number, index: number) {
     const conditionObject = this.references.conditions.variables[id];
@@ -87,9 +79,7 @@ class FillPdfFormBase {
   }
 
   /**
-   * Returns an option's conditions
-   * @param id Option's id
-   * @param index Option's index
+   * Returns an option's conditions.
    */
   private getOptionCondition(id: number, index: number) {
     const conditionObject = this.references.conditions.options[id];
@@ -99,8 +89,7 @@ class FillPdfFormBase {
   }
 
   /**
-   * Returns a section's conditions
-   * @param id Section's id
+   * Returns a section's conditions.
    */
   private getSectionCondition(id: number) {
     const conditionObject = this.references.conditions.sections.main[id];
@@ -108,28 +97,6 @@ class FillPdfFormBase {
       ? true
       : this.conditions.executeCondition(conditionObject, id, 0, "sections");
   }
-
-  /**
-   * Returns option's parent section
-   * @param id Option's id
-   */
-  private getOptionParentSection(id: number) {
-    const { parents } = this.references.relations.options[id];
-
-    // Getting root option id
-    const rootId = parents.length > 0 ? parents[parents.length - 1] : id;
-
-    // Looking for section
-    const sections = Object.values(this.references.sections.main);
-
-    for (let i = 0; i < sections.length; i += 1) {
-      if (sections[i].options.includes(rootId)) return sections[i].id;
-    }
-
-    throw new Error(
-      `Cannot find parent section for option ${id} (Root option id: ${rootId})`
-    );
-  }
 }
 
 export default FillPdfFormBase;

package/src/libs/tableOutputExpansion.ts

@@ -0,0 +1,145 @@
+import LpLogic from "@legalplace/lplogic";
+import type { ConditionV3 } from "@legalplace/models-v3-types";
+import type ConditionsRunner from "@legalplace/conditions-runner";
+import DataPopulator from "@legalplace/conditions-runner/dist/DataPopulator";
+import type { Types } from "@legalplace/referencesparser";
+import {
+  expandTableMarkup,
+  extractConditionDataMap,
+  hasTableDynamicMarkup,
+  stripConditionUiMetadata,
+  type ExpandTableMarkupContext,
+} from "@legalplace/referencesparser";
+import type InputsType from "@legalplace/types/dist/inputs";
+import {
+  getRelatedVariablesValues,
+  parseOutputWithVariables,
+} from "./OutputParser";
+
+/**
+ * Extracts variable ids referenced as `[var:N]` tags in an HTML fragment.
+ */
+const extractVariableIds = (html: string): number[] => {
+  const matches = html.match(/\[var:([0-9]+)\]/gi);
+  if (matches === null) return [];
+
+  return Array.from(
+    new Set(
+      matches.map((tag) => {
+        const idMatch = tag.match(/([0-9]+)/);
+        return idMatch ? parseInt(idMatch[1], 10) : 0;
+      })
+    )
+  ).filter((id) => id > 0);
+};
+
+/**
+ * Evaluates an inline table condition at a given occurrence index.
+ */
+export const evaluateInlineTableCondition = (
+  condition: ConditionV3,
+  contextOptionId: number,
+  occurrenceIndex: number,
+  conditionsRunner: ConditionsRunner,
+  references: Types.ReferencesType,
+  ovc: InputsType
+): boolean => {
+  const dataMap = extractConditionDataMap(condition);
+  const currentData = new DataPopulator(
+    conditionsRunner,
+    references,
+    ovc,
+    dataMap,
+    contextOptionId,
+    occurrenceIndex
+  ).getData();
+  const result = LpLogic(stripConditionUiMetadata(condition), currentData);
+  return result !== false;
+};
+
+type CreateTableMarkupContextParams = {
+  references: Types.ReferencesType;
+  ovc: InputsType;
+  conditions: ConditionsRunner;
+  contextOptionId: number;
+  defaultOccurrenceIndex: number;
+};
+
+/**
+ * Builds the expandTableMarkup context for prerenderx output rendering.
+ */
+export const createTableMarkupContext = ({
+  references,
+  ovc,
+  conditions,
+  contextOptionId,
+  defaultOccurrenceIndex,
+}: CreateTableMarkupContextParams): ExpandTableMarkupContext => ({
+  defaultContextOptionId: contextOptionId,
+  defaultOccurrenceIndex,
+  getOccurrenceInputs: (multipleOptionId: number) =>
+    ovc.options[String(multipleOptionId)] || [],
+  evaluateCondition: (condition, multipleOptionId, occurrenceIndex) =>
+    evaluateInlineTableCondition(
+      condition,
+      multipleOptionId,
+      occurrenceIndex,
+      conditions,
+      references,
+      ovc
+    ),
+  substituteVariables: (html, multipleOptionId, occurrenceIndex) => {
+    const variableIds = extractVariableIds(html);
+    const variables = getRelatedVariablesValues(
+      multipleOptionId,
+      occurrenceIndex,
+      variableIds,
+      ovc,
+      references
+    );
+    return parseOutputWithVariables(html, occurrenceIndex, variables, []);
+  },
+});
+
+type ExpandOutputTableMarkupParams = CreateTableMarkupContextParams & {
+  output: string;
+};
+
+/**
+ * Expands dynamic table markup in an output HTML string when needed.
+ */
+export const expandOutputTableMarkup = ({
+  output,
+  references,
+  ovc,
+  conditions,
+  contextOptionId,
+  defaultOccurrenceIndex,
+}: ExpandOutputTableMarkupParams): string => {
+  if (!hasTableDynamicMarkup(output)) return output;
+
+  return expandTableMarkup(
+    output,
+    createTableMarkupContext({
+      references,
+      ovc,
+      conditions,
+      contextOptionId,
+      defaultOccurrenceIndex,
+    })
+  );
+};
+
+/**
+ * Applies post-processing cleanup to rendered output HTML.
+ */
+export const cleanupRenderedOutputHtml = (output: string): string => {
+  if (output.includes("<table")) {
+    return output.replace(/\xA0/g, " ");
+  }
+
+  return output
+    .replace(/<\/([a-z]+)>([\n\s]+)</gi, "</$1><")
+    .replace(/\n/g, "<br />")
+    .replace(/\xA0/g, " ");
+};

package/src/types/types.ts

@@ -1,14 +1,27 @@
+import type { DocumentLayoutV3 } from "@legalplace/models-v3-types";
+
 export type DocumentOutputIndex = {
   name: string;
   slug: string;
   pdf: boolean;
   docx: boolean;
+  /**
+   * Occurrence index of the document when the document is multiple
+   * (`params.multiple.enabled === true`). `undefined` for non-multiple
+   * documents (treated as 0 internally).
+   */
+  occurrenceIndex?: number;
 };
+
 export type DocumentPdfFormIndex = {
   name: string;
   slug: string;
   form: boolean;
   fdf: FDFType;
+  /**
+   * Occurrence index of the document when the document is multiple.
+   */
+  occurrenceIndex?: number;
 };
 
 export type DocumentIndex = Record<
@@ -20,3 +33,17 @@ export type FDFType = {
   id: string;
   fields: Record<string, string>;
 };
+
+/**
+ * Rendered header/footer regions and page layout for DOCX generation.
+ */
+export type DocumentLayout = {
+  header?: string;
+  footer?: string;
+  firstPageHeader?: string;
+  firstPageFooter?: string;
+  differentFirstPage: boolean;
+  margins?: DocumentLayoutV3["margins"];
+  headerDistance?: number;
+  footerDistance?: number;
+};