@legalplace/prerenderx 3.8.17 → 3.8.18-staging.2

package/src/libs/FillPdfForm.ts

@@ -6,7 +6,13 @@ type FDFType = {
   fields: Record<string, string>;
 };
 class FillPdfForm extends FillPdfFormBase {
-  public fillDocument(documentName: string) {
+  /**
+   * Fills a PDF form template with values from `ovc`. When `baseIndex` is
+   * provided (document multiple), variables and options are read at that
+   * occurrence index instead of always reading slot 0. Each occurrence of
+   * a multiple PDF form document yields its own filled FDF.
+   */
+  public fillDocument(documentName: string, baseIndex = 0) {
     const result: FDFType = {
       id: "",
       fields: {},
@@ -24,13 +30,13 @@ class FillPdfForm extends FillPdfFormBase {
     // Filling inputs
     form.inputs.forEach((input) => {
       const id = `${input.name}`;
-      result.fields[id] = this.getInputValue(input);
+      result.fields[id] = this.getInputValue(input, baseIndex);
     });
 
     // Filling boxes
     form.boxes.forEach((box) => {
       const id = `${box.name}`;
-      const value = this.getBoxValue(box);
+      const value = this.getBoxValue(box, baseIndex);
       if (
         !(
           value === "" &&
@@ -44,13 +50,14 @@ class FillPdfForm extends FillPdfFormBase {
   }
 
   /**
-   * Returns an input value
+   * Returns an input value at the given occurrence `index`.
    * @param input Input
+   * @param index Occurrence index (defaults to 0)
    */
-  private getInputValue(input: FDFInputsV3): string {
+  private getInputValue(input: FDFInputsV3, index = 0): string {
     for (let i = 0; i < input.variables.length; i += 1) {
       const variable = input.variables[i];
-      const currentValue = this.getVariableValue(variable.id);
+      const currentValue = this.getVariableValue(variable.id, index);
 
       if (currentValue !== false) {
         // Date values
@@ -110,13 +117,14 @@ class FillPdfForm extends FillPdfFormBase {
   }
 
   /**
-   * Return a box value
+   * Return a box value at the given occurrence `index`.
    * @param box Box
+   * @param index Occurrence index (defaults to 0)
    */
-  private getBoxValue(box: FDFBoxesV3): string {
+  private getBoxValue(box: FDFBoxesV3, index = 0): string {
     for (let i = 0; i < box.options.length; i += 1) {
       const option = box.options[i];
-      const currentValue = this.getOptionValue(option.id);
+      const currentValue = this.getOptionValue(option.id, index);
 
       if (currentValue === true) {
         if (
@@ -132,25 +140,34 @@ class FillPdfForm extends FillPdfFormBase {
   }
 
   /**
-   * Returns a variable's value
+   * Returns a variable's value at the given occurrence `index`. Falls back
+   * to slot 0 when the requested index is missing (e.g. a non-multiple
+   * variable inside a multiple document).
    */
-  private getVariableValue(variableId: number) {
-    // Checking if variable is displayed
-    if (this.isVariableDisplayed(variableId, 0) === false) return false;
+  private getVariableValue(variableId: number, index = 0) {
+    // Checking if variable is displayed at the given occurrence
+    if (this.isVariableDisplayed(variableId, index) === false) return false;
 
-    // Returning variable's value
-    return (this.ovc.variables[variableId]?.[0] || "").toString();
+    const variableValues = this.ovc.variables[variableId];
+    const value =
+      variableValues?.[index] !== undefined
+        ? variableValues[index]
+        : variableValues?.[0] || "";
+
+    return (value ?? "").toString();
   }
 
   /**
-   * Returns a option's value
+   * Returns an option's boolean value at the given occurrence `index`.
    */
-  private getOptionValue(optionId: number) {
-    // Checking if option is displayed
-    if (this.isOptionDisplayed(optionId, 0) === false) return false;
-
-    // Returning option's value
-    return this.ovc.options[optionId]?.[0] === true;
+  private getOptionValue(optionId: number, index = 0) {
+    // Checking if option is displayed at the given occurrence
+    if (this.isOptionDisplayed(optionId, index) === false) return false;
+
+    const optionValues = this.ovc.options[optionId];
+    return optionValues?.[index] !== undefined
+      ? optionValues[index] === true
+      : optionValues?.[0] === true;
   }
 }
 

package/src/libs/OptionRender.ts

@@ -1,10 +1,23 @@
+import type { OptionV3 } from "@legalplace/models-v3-types";
 import type { Types } from "@legalplace/referencesparser";
 import type ConditionsRunner from "@legalplace/conditions-runner";
 import type InputsType from "@legalplace/types/dist/inputs";
+import {
+  isOptionDisplayed,
+  buildOutputTableCellStyleAttr,
+  buildOutputTableStyleAttr,
+  getOutputTableCellStyle,
+  replaceOutputTableMarkers,
+  stripOutputTableMarkers,
+} from "@legalplace/referencesparser";
 import {
   parseOutputWithVariables,
   getRelatedVariablesValues,
 } from "./OutputParser";
+import {
+  cleanupRenderedOutputHtml,
+  expandOutputTableMarkup,
+} from "./tableOutputExpansion";
 import type NumAuto from "./NumAuto";
 
 class OptionRender {
@@ -40,83 +53,225 @@ class OptionRender {
     this.renderOption();
   }
 
+  /**
+   * Returns rendered HTML outputs for this option subtree.
+   */
   getOutputs() {
     return this.outputs;
   }
 
+  /**
+   * Returns whether an option is displayed at the current occurrence.
+   */
+  private isDisplayed(optionId = this.id): boolean {
+    return isOptionDisplayed(
+      this.references,
+      this.ovc,
+      (type, entityId, entityIndex) => {
+        if (type === "options") {
+          const conditionObject = this.references.conditions.options[entityId];
+          return conditionObject === undefined
+            ? true
+            : this.conditions.executeCondition(
+                conditionObject,
+                entityId,
+                entityIndex,
+                "options"
+              );
+        }
+        if (type === "sections") {
+          const conditionObject =
+            this.references.conditions.sections.main[entityId];
+          return conditionObject === undefined
+            ? true
+            : this.conditions.executeCondition(
+                conditionObject,
+                entityId,
+                entityIndex,
+                "sections"
+              );
+        }
+        return true;
+      },
+      optionId,
+      this.index
+    );
+  }
+
+  /**
+   * Renders a table cell option as a td element.
+   */
+  private renderOutputTableCell(cellId: number): string {
+    const cellOption = this.references.options[cellId];
+    if (cellOption?.meta.tableRole !== "cell") return "";
+
+    const styleAttr = buildOutputTableCellStyleAttr(
+      getOutputTableCellStyle(cellOption)
+    );
+
+    // Hidden cells are omitted entirely instead of rendering an empty td
+    if (!this.isDisplayed(cellId)) {
+      return "";
+    }
+
+    const outputReference = this.references.outputs[cellId];
+    if (outputReference === undefined) {
+      return `<td${styleAttr}></td>`;
+    }
+
+    const autonums: [string, string, number, string | null][] =
+      outputReference.autonums.map((currentAn) => {
+        const fn =
+          currentAn[0] === "numauto-pre"
+            ? this.NumAuto.getNumPre
+            : this.NumAuto.getNum;
+        return [
+          currentAn[0],
+          currentAn[1],
+          fn(currentAn[1], currentAn[2]),
+          currentAn[2],
+        ];
+      });
+
+    const variables = getRelatedVariablesValues(
+      cellId,
+      this.index,
+      outputReference.variables,
+      this.ovc,
+      this.references
+    );
+
+    const content = parseOutputWithVariables(
+      outputReference.raw,
+      this.index,
+      variables,
+      autonums
+    );
+
+    return `<td${styleAttr}>${content}</td>`;
+  }
+
+  /**
+   * Renders a table row option as a tr element.
+   */
+  private renderOutputTableRow(rowId: number): string {
+    const rowOption = this.references.options[rowId];
+    if (rowOption?.meta.tableRole !== "row") return "";
+    if (!this.isDisplayed(rowId)) return "";
+
+    const cells = rowOption.options
+      .map((cellId) => this.renderOutputTableCell(cellId))
+      .join("");
+
+    if (cells.length === 0) return "";
+
+    return `<tr>${cells}</tr>`;
+  }
+
+  /**
+   * Renders a table option as a table element from its child rows.
+   */
+  private renderOutputTable(option: OptionV3): string {
+    const rows = option.options
+      .map((rowId) => this.renderOutputTableRow(rowId))
+      .filter((row) => row.length > 0)
+      .join("");
+
+    if (rows.length === 0) return "";
+
+    const styleAttr = buildOutputTableStyleAttr(option.meta.tableStyle);
+    return `<table${styleAttr}><tbody>${rows}</tbody></table>`;
+  }
+
+  /**
+   * Renders the current option output when displayed.
+   */
   private renderOption() {
     const option = this.references.options[this.id];
-    const conditionObject = this.references.conditions.options[this.id];
-    const condition =
-      conditionObject === undefined
-        ? true
-        : this.conditions.executeCondition(
-            conditionObject,
-            this.id,
-            this.index,
-            "options"
-          );
-
-    // Rendering documents sections
-    if (condition === true) {
-      if (
-        typeof option.meta.output === "string" &&
-        option.meta.output.trim().length > 0
-      ) {
-        // output Reference
-        const outputReference = this.references.outputs[this.id];
-
-        // Autonums
-        let autonums: [string, string, number, string | null][] = [];
-        if (condition !== false) {
-          autonums = outputReference.autonums.map((currentAn) => {
-            const fn =
-              currentAn[0] === "numauto-pre"
-                ? this.NumAuto.getNumPre
-                : this.NumAuto.getNum;
-            return [
-              currentAn[0],
-              currentAn[1],
-              fn(currentAn[1], currentAn[2]),
-              currentAn[2],
-            ];
-          });
-        }
+    const { tableRole } = option.meta;
+
+    if (tableRole === "row" || tableRole === "cell") {
+      return;
+    }
+
+    if (!this.isDisplayed()) return;
 
-        // variables
-        const variables = getRelatedVariablesValues(
-          this.id,
-          this.index,
-          outputReference.variables,
-          this.ovc,
-          this.references
-        );
-        let output = parseOutputWithVariables(
-          option.meta.output,
-          this.index,
-          variables,
-          autonums
-        );
-
-        // Removing spaces between tags
-        output = output.replace(/<\/([a-z]+)>([\n\s]+)</gi, "</$1><");
-
-        // Replacing \n with line-break
-        output = output.replace(/\n/g, "<br />");
-
-        // Cleaning \xA0
-        output = output.replace(/\xA0/g, " ");
-
-        // Pushing output
-        this.outputs.push(output);
+    if (tableRole === "table") {
+      const tableHtml = this.renderOutputTable(option);
+      if (tableHtml.length > 0) {
+        this.outputs.push(cleanupRenderedOutputHtml(tableHtml));
       }
-      this.renderChildren();
+      return;
     }
+
+    if (
+      typeof option.meta.output === "string" &&
+      option.meta.output.trim().length > 0
+    ) {
+      const outputReference = this.references.outputs[this.id];
+
+      const autonums: [string, string, number, string | null][] =
+        outputReference.autonums.map((currentAn) => {
+          const fn =
+            currentAn[0] === "numauto-pre"
+              ? this.NumAuto.getNumPre
+              : this.NumAuto.getNum;
+          return [
+            currentAn[0],
+            currentAn[1],
+            fn(currentAn[1], currentAn[2]),
+            currentAn[2],
+          ];
+        });
+
+      const variables = getRelatedVariablesValues(
+        this.id,
+        this.index,
+        outputReference.variables,
+        this.ovc,
+        this.references
+      );
+
+      let output = expandOutputTableMarkup({
+        output: option.meta.output,
+        references: this.references,
+        ovc: this.ovc,
+        conditions: this.conditions,
+        contextOptionId: this.id,
+        defaultOccurrenceIndex: this.index,
+      });
+
+      output = parseOutputWithVariables(
+        output,
+        this.index,
+        variables,
+        autonums
+      );
+
+      output = replaceOutputTableMarkers(output, (tableId) => {
+        const childOption = this.references.options[tableId];
+        if (!childOption || childOption.meta.tableRole !== "table") return "";
+        if (!this.isDisplayed(tableId)) return "";
+        return this.renderOutputTable(childOption);
+      });
+
+      output = stripOutputTableMarkers(output);
+      output = cleanupRenderedOutputHtml(output);
+
+      this.outputs.push(output);
+    }
+    this.renderChildren();
   }
 
+  /**
+   * Recursively renders child options.
+   */
   private renderChildren() {
     const option = this.references.options[this.id];
     option.options.forEach((optionId) => {
+      const childOption = this.references.options[optionId];
+      if (childOption?.meta.tableRole === "table") return;
+
       this.outputs = [
         ...this.outputs,
         ...new OptionRender({

package/src/libs/OutputParser.ts

@@ -199,20 +199,33 @@ export const parseOutputWithVariables: parseOutputT = (
 };
 
 /**
- * Parses document name with variables
- * @param text Document's name
+ * Parses document name with variables.
+ * When `index` is provided, each `[var:X]` is resolved using the value
+ * at occurrence `index` instead of always using occurrence 0. This is
+ * required for document multiples where each occurrence of the document
+ * must have its own filename interpolated with the right variable values.
+ *
+ * @param text Document's name (or filenameTemplate)
+ * @param ovc Inputs (parallel arrays)
+ * @param references References parsed from the model
+ * @param fallback Fallback used when an interpolated variable is empty
+ * @param index Occurrence index (defaults to 0)
  */
 type TParseDocumentNameWithVariables = (
   text: string,
   ovc: InputsType,
   references: Types.ReferencesType,
-  fallback?: string
+  fallback?: string,
+  index?: number,
+  contextOptionId?: number
 ) => string;
 export const parseDocumentNameWithVariables: TParseDocumentNameWithVariables = (
   text,
   ovc,
   references,
-  fallback
+  fallback,
+  index = 0,
+  contextOptionId
 ) => {
   /**
    * Variables
@@ -239,12 +252,30 @@ export const parseDocumentNameWithVariables: TParseDocumentNameWithVariables = (
     (c) => ovc !== undefined || references.variables[c] !== undefined
   );
 
-  // Getting values
   const variablesValues: Record<string, string> = {};
-  variables.forEach((variableId) => {
-    const value = ovc.variables[variableId]?.[0] || "";
-    variablesValues[variableId] = value.toString();
-  });
+  if (typeof contextOptionId === "number") {
+    const relatedValues = getRelatedVariablesValues(
+      contextOptionId,
+      index,
+      variables,
+      ovc,
+      references
+    );
+    variables.forEach((variableId) => {
+      variablesValues[variableId] = (
+        relatedValues[variableId] ?? ""
+      ).toString();
+    });
+  } else {
+    variables.forEach((variableId) => {
+      const variableValues = ovc.variables[variableId];
+      const valueAtIndex =
+        variableValues?.[index] !== undefined
+          ? variableValues[index]
+          : variableValues?.[0] || "";
+      variablesValues[variableId] = (valueAtIndex ?? "").toString();
+    });
+  }
 
   // Inserting values
   let parsedText = `${text}`;