@legalplace/prerenderx 3.8.24 → 3.9.0

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

package/src/libs/Prerender.ts

@@ -1,8 +1,11 @@
 import type { ModelV3 } from "@legalplace/models-v3-types";
-import type { Types } from "@legalplace/referencesparser";
-import { ReferencesParser } from "@legalplace/referencesparser";
 import ConditionsRunner from "@legalplace/conditions-runner";
 import OvcConverter from "@legalplace/ovc-converter";
+import {
+  ReferencesParser,
+  type OutputRegionRole,
+  type Types,
+} from "@legalplace/referencesparser";
 import type OvcType from "@legalplace/types/dist/ovc";
 import type InputsType from "@legalplace/types/dist/inputs";
 import crypto from "crypto";
@@ -16,6 +19,7 @@ import type {
   DocumentIndex,
   DocumentOutputIndex,
   DocumentPdfFormIndex,
+  DocumentLayout,
 } from "../types/types";
 
 class Prerender {
@@ -88,67 +92,182 @@ class Prerender {
     }
 
     const index = this.documentsIndex[documentNameHash];
+    const occurrenceIndex = index.occurrenceIndex ?? 0;
 
     this.renderedDocuments[documentNameHash] = Prerender.isPdfForm(index)
-      ? this.pdfFiller.fillDocument(index.slug)
-      : this.documentRender.renderDocument(index.slug);
+      ? this.pdfFiller.fillDocument(index.slug, occurrenceIndex)
+      : this.documentRender.renderDocument(index.slug, occurrenceIndex);
 
     return this.renderedDocuments[documentNameHash];
   }
 
+  /**
+   * Returns rendered header/footer regions and page layout settings for DOCX.
+   */
+  public getDocumentLayout(documentNameHash: string): DocumentLayout {
+    const index = this.documentsIndex[documentNameHash];
+    const occurrenceIndex = index.occurrenceIndex ?? 0;
+    const document = this.references.documents[index.slug];
+    const layoutParams = document.params?.layout;
+
+    const renderRegion = (role: OutputRegionRole): string | undefined => {
+      const html = this.documentRender.renderRegion(
+        index.slug,
+        role,
+        occurrenceIndex
+      );
+      return html.trim().length > 0 ? html : undefined;
+    };
+
+    const header = renderRegion("header");
+    const footer = renderRegion("footer");
+    const differentFirstPage = layoutParams?.differentFirstPage === true;
+
+    return {
+      header,
+      footer,
+      firstPageHeader: differentFirstPage
+        ? renderRegion("firstPageHeader")
+        : undefined,
+      firstPageFooter: differentFirstPage
+        ? renderRegion("firstPageFooter")
+        : undefined,
+      differentFirstPage,
+      margins: layoutParams?.margins,
+      headerDistance: layoutParams?.headerDistance,
+      footerDistance: layoutParams?.footerDistance,
+    };
+  }
+
+  /**
+   * Resolves a document occurrence's display name. Interpolates `[var:X]`
+   * in `document.name` at the linked occurrence. Optional `filenameTemplate`
+   * overrides the title when set and non-empty after interpolation.
+   */
+  private resolveDocumentOccurrenceName(
+    document: Types.ReferencesDocumentType,
+    docMultiple: NonNullable<
+      NonNullable<Types.ReferencesDocumentType["params"]>["multiple"]
+    >,
+    occurrenceIndex: number
+  ): string {
+    const baseName = parseDocumentNameWithVariables(
+      document.name,
+      this.ovc,
+      this.references,
+      document.fallbackName,
+      occurrenceIndex,
+      docMultiple.repeatOption
+    );
+
+    const template = docMultiple.filenameTemplate;
+    if (typeof template !== "string" || template.trim().length === 0) {
+      return baseName;
+    }
+
+    const resolved = parseDocumentNameWithVariables(
+      template,
+      this.ovc,
+      this.references,
+      undefined,
+      occurrenceIndex,
+      docMultiple.repeatOption
+    );
+
+    if (resolved.trim().length === 0) return baseName;
+    return resolved;
+  }
+
+  /**
+   * Returns the array of occurrences (true = render this occurrence) for a
+   * given document slug. For non-multiple documents, returns `[true]`.
+   * For multiple documents, returns the parallel array of the source option
+   * (`params.multiple.repeatOption`), defaulting to `[true]` if absent.
+   */
+  private getDocumentOccurrences(slug: string): boolean[] {
+    const document = this.references.documents[slug];
+    const docMultiple = document.params?.multiple;
+    if (docMultiple?.enabled !== true) return [true];
+
+    const { repeatOption } = docMultiple;
+    if (typeof repeatOption !== "number") return [true];
+
+    const inputs = this.ovc.options[String(repeatOption)];
+    if (!Array.isArray(inputs) || inputs.length === 0) return [true];
+    return inputs;
+  }
+
   private generateDocumentNamesHash() {
     Object.keys(this.references.documents).forEach((slug) => {
       const document = this.references.documents[slug];
-      const documentParams = this.references.documents[slug].params;
-      const conditionObject = this.references.conditions.documents[slug];
-      const condition =
-        conditionObject === undefined
-          ? true
-          : this.conditions.executeCondition(
-              conditionObject,
-              0,
-              0,
-              "documents"
-            );
-
-      // Rendering documents sections
-      if (condition === true) {
-        const hash = crypto.createHash("sha1").update(slug).digest("hex");
-
-        // Referencing in index
+      const documentParams = document.params;
+      const docMultiple = documentParams?.multiple;
+      const isMultipleDocument = docMultiple?.enabled === true;
+
+      const occurrences = this.getDocumentOccurrences(slug);
+
+      occurrences.forEach((occurrenceValue, occurrenceIndex) => {
+        if (occurrenceValue !== true) return;
+
+        const conditionObject = this.references.conditions.documents[slug];
+        const documentSourceId =
+          isMultipleDocument && typeof docMultiple.repeatOption === "number"
+            ? docMultiple.repeatOption
+            : 0;
+        const condition =
+          conditionObject === undefined
+            ? true
+            : this.conditions.executeCondition(
+                conditionObject,
+                documentSourceId,
+                occurrenceIndex,
+                "documents"
+              );
+
+        if (condition !== true) return;
+
+        const seed = isMultipleDocument ? `${slug}:${occurrenceIndex}` : slug;
+        const hash = crypto.createHash("sha1").update(seed).digest("hex");
+
+        const name =
+          isMultipleDocument && docMultiple
+            ? this.resolveDocumentOccurrenceName(
+                document,
+                docMultiple,
+                occurrenceIndex
+              )
+            : parseDocumentNameWithVariables(
+                document.name,
+                this.ovc,
+                this.references,
+                document.fallbackName
+              );
+
         if (
           typeof document.pdf === "object" &&
           typeof document.pdf.id === "string" &&
           typeof document.pdf.form === "object"
         ) {
           this.documentsIndex[hash] = {
-            name: parseDocumentNameWithVariables(
-              document.name,
-              this.ovc,
-              this.references,
-              document.fallbackName
-            ),
+            name,
             slug,
             form: true,
             fdf: {
               id: "",
               fields: {},
             },
+            ...(isMultipleDocument ? { occurrenceIndex } : {}),
           };
         } else {
           this.documentsIndex[hash] = {
-            name: parseDocumentNameWithVariables(
-              document.name,
-              this.ovc,
-              this.references,
-              document.fallbackName
-            ),
+            name,
             slug,
             pdf: documentParams?.formats?.pdf !== false,
             docx: documentParams?.formats?.docx !== false,
+            ...(isMultipleDocument ? { occurrenceIndex } : {}),
           };
         }
-      }
+      });
     });
   }
 
@@ -164,15 +283,15 @@ class Prerender {
   private generateAllDocuments() {
     Object.keys(this.documentsIndex).forEach((documentNameHash) => {
       const index = this.documentsIndex[documentNameHash];
+      const occurrenceIndex = index.occurrenceIndex ?? 0;
       if (Prerender.isPdfForm(index)) {
         this.renderedDocuments[documentNameHash] = this.pdfFiller.fillDocument(
-          this.documentsIndex[documentNameHash].slug
+          index.slug,
+          occurrenceIndex
         );
       } else {
         this.renderedDocuments[documentNameHash] =
-          this.documentRender.renderDocument(
-            this.documentsIndex[documentNameHash].slug
-          );
+          this.documentRender.renderDocument(index.slug, occurrenceIndex);
       }
     });
   }