@legalplace/prerenderx 3.8.17 → 3.8.18-staging.2

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,178 @@ 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 condition =
+          conditionObject === undefined
+            ? true
+            : this.conditions.executeCondition(
+                conditionObject,
+                0,
+                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 +279,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);
       }
     });
   }

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;