@legalplace/prerenderx 3.8.24-staging.0 → 3.8.24

package/src/libs/OptionRender.ts

@@ -1,23 +1,10 @@
-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 {
@@ -53,225 +40,83 @@ 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 { tableRole } = option.meta;
-
-    if (tableRole === "row" || tableRole === "cell") {
-      return;
-    }
-
-    if (!this.isDisplayed()) return;
+    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],
+            ];
+          });
+        }
 
-    if (tableRole === "table") {
-      const tableHtml = this.renderOutputTable(option);
-      if (tableHtml.length > 0) {
-        this.outputs.push(cleanupRenderedOutputHtml(tableHtml));
+        // 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);
       }
-      return;
+      this.renderChildren();
     }
-
-    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,33 +199,20 @@ export const parseOutputWithVariables: parseOutputT = (
 };
 
 /**
- * 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)
+ * Parses document name with variables
+ * @param text Document's name
  */
 type TParseDocumentNameWithVariables = (
   text: string,
   ovc: InputsType,
   references: Types.ReferencesType,
-  fallback?: string,
-  index?: number,
-  contextOptionId?: number
+  fallback?: string
 ) => string;
 export const parseDocumentNameWithVariables: TParseDocumentNameWithVariables = (
   text,
   ovc,
   references,
-  fallback,
-  index = 0,
-  contextOptionId
+  fallback
 ) => {
   /**
    * Variables
@@ -252,30 +239,12 @@ export const parseDocumentNameWithVariables: TParseDocumentNameWithVariables = (
     (c) => ovc !== undefined || references.variables[c] !== undefined
   );
 
+  // Getting values
   const variablesValues: Record<string, string> = {};
-  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();
-    });
-  }
+  variables.forEach((variableId) => {
+    const value = ovc.variables[variableId]?.[0] || "";
+    variablesValues[variableId] = value.toString();
+  });
 
   // Inserting values
   let parsedText = `${text}`;

package/src/libs/Prerender.ts

@@ -1,11 +1,8 @@
 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";
@@ -19,7 +16,6 @@ import type {
   DocumentIndex,
   DocumentOutputIndex,
   DocumentPdfFormIndex,
-  DocumentLayout,
 } from "../types/types";
 
 class Prerender {
@@ -92,182 +88,67 @@ class Prerender {
     }
 
     const index = this.documentsIndex[documentNameHash];
-    const occurrenceIndex = index.occurrenceIndex ?? 0;
 
     this.renderedDocuments[documentNameHash] = Prerender.isPdfForm(index)
-      ? this.pdfFiller.fillDocument(index.slug, occurrenceIndex)
-      : this.documentRender.renderDocument(index.slug, occurrenceIndex);
+      ? this.pdfFiller.fillDocument(index.slug)
+      : this.documentRender.renderDocument(index.slug);
 
     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 = 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
-              );
-
+      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
         if (
           typeof document.pdf === "object" &&
           typeof document.pdf.id === "string" &&
           typeof document.pdf.form === "object"
         ) {
           this.documentsIndex[hash] = {
-            name,
+            name: parseDocumentNameWithVariables(
+              document.name,
+              this.ovc,
+              this.references,
+              document.fallbackName
+            ),
             slug,
             form: true,
             fdf: {
               id: "",
               fields: {},
             },
-            ...(isMultipleDocument ? { occurrenceIndex } : {}),
           };
         } else {
           this.documentsIndex[hash] = {
-            name,
+            name: parseDocumentNameWithVariables(
+              document.name,
+              this.ovc,
+              this.references,
+              document.fallbackName
+            ),
             slug,
             pdf: documentParams?.formats?.pdf !== false,
             docx: documentParams?.formats?.docx !== false,
-            ...(isMultipleDocument ? { occurrenceIndex } : {}),
           };
         }
-      });
+      }
     });
   }
 
@@ -283,15 +164,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(
-          index.slug,
-          occurrenceIndex
+          this.documentsIndex[documentNameHash].slug
         );
       } else {
         this.renderedDocuments[documentNameHash] =
-          this.documentRender.renderDocument(index.slug, occurrenceIndex);
+          this.documentRender.renderDocument(
+            this.documentsIndex[documentNameHash].slug
+          );
       }
     });
   }