@legalplace/prerenderx 3.2.1 → 3.3.0

package/src/libs/OutputParser.ts

@@ -1,14 +1,13 @@
-import { Types } from '@legalplace/referencesparser'
-import InputsType from '@legalplace/types/dist/inputs'
-
+import type { Types } from "@legalplace/referencesparser";
+import type InputsType from "@legalplace/types/dist/inputs";
 
 /**
  * Parses number to correct french number format ("," instead of ".")
  */
 const frenchNumber = (value: string | number) => {
-  let result = typeof value === 'number' ? value.toString() : value;
+  let result = typeof value === "number" ? value.toString() : value;
   if (/^([0-9]+)\.([0-9]+)$/.test(result.trim()))
-    result = result.trim().replace('.', ',');
+    result = result.trim().replace(".", ",");
   return result;
 };
 
@@ -18,43 +17,67 @@ const frenchNumber = (value: string | number) => {
  * @param index Occurency index
  * @param variables Variables ids list
  */
-type relVarsValsT = Record<string, string | number>
-type getRelatedVarsT = (optionId: number, index: number, variables: number[], ovc: InputsType, references: Types.ReferencesType) => relVarsValsT
-export const getRelatedVariablesValues: getRelatedVarsT = (optionId, index, variables, ovc, references) => {
+type relVarsValsT = Record<string, string | number>;
+type getRelatedVarsT = (
+  optionId: number,
+  index: number,
+  variables: number[],
+  ovc: InputsType,
+  references: Types.ReferencesType
+) => relVarsValsT;
+export const getRelatedVariablesValues: getRelatedVarsT = (
+  optionId,
+  index,
+  variables,
+  ovc,
+  references
+) => {
   // Getting variables values
-  const variablesValues: Record<string, string> = {}
-  variables.forEach(currentVariableId => {
+  const variablesValues: Record<string, string> = {};
+  variables.forEach((currentVariableId) => {
     // Getting option value
-    let value = ovc.variables[currentVariableId] || ['']
-    const variableParents = references.relations.variables[currentVariableId].parents
-    if (variableParents === undefined) throw new Error(`Variable ${currentVariableId} parents object does not exist`)
-    const rootVariableParentId = variableParents[variableParents.length - 1]
-    const rootVariableParentRelations = references.relations.options[rootVariableParentId]
-    if (rootVariableParentRelations === undefined) throw new Error(`Option ${rootVariableParentId} does not exist`)
-
-    if (typeof variableParents === 'undefined') return
+    let value = ovc.variables[currentVariableId] || [""];
+    const variableParents =
+      references.relations.variables[currentVariableId].parents;
+    if (variableParents === undefined)
+      throw new Error(
+        `Variable ${currentVariableId} parents object does not exist`
+      );
+    const rootVariableParentId = variableParents[variableParents.length - 1];
+    const rootVariableParentRelations =
+      references.relations.options[rootVariableParentId];
+    if (rootVariableParentRelations === undefined)
+      throw new Error(`Option ${rootVariableParentId} does not exist`);
+
+    if (typeof variableParents === "undefined") return;
 
     // Getting rootOption parent
 
     // Checking if current option is related to the option that changed
-    if (rootVariableParentRelations.children.options.includes(optionId) || rootVariableParentRelations.dependants.includes(optionId) || optionId === rootVariableParentId)
-      value = [value[index]]
+    if (
+      rootVariableParentRelations.children.options.includes(optionId) ||
+      rootVariableParentRelations.dependants.includes(optionId) ||
+      optionId === rootVariableParentId
+    )
+      value = [value[index]];
 
     // Making sure all values are strings
-    const cleanValues = value.map(currentValue => {
-      if (['number', 'string'].includes(typeof currentValue)) return frenchNumber(currentValue)
-      return ''
-    })
+    const cleanValues = value.map((currentValue) => {
+      if (["number", "string"].includes(typeof currentValue))
+        return frenchNumber(currentValue);
+      return "";
+    });
 
     // Joining multiple variables if needed
-    const currentVariableValue = cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(', ')
+    const currentVariableValue =
+      cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(", ");
 
     // Setting variable value
-    variablesValues[currentVariableId] = currentVariableValue
-  })
+    variablesValues[currentVariableId] = currentVariableValue;
+  });
 
-  return variablesValues
-}
+  return variablesValues;
+};
 
 /**
  * Parses output with variables
@@ -64,53 +87,84 @@ export const getRelatedVariablesValues: getRelatedVarsT = (optionId, index, vari
  * @param variables Variables values list
  * @param autonums Autonums values
  */
-type autonumsType = [string, string, number, string | null][]
-type parseOutputT = (output: string, index: number, variables: relVarsValsT, autonums: autonumsType) => string
-export const parseOutputWithVariables: parseOutputT = (output, index, variables, autonums) => {
+type autonumsType = [string, string, number, string | null][];
+type parseOutputT = (
+  output: string,
+  index: number,
+  variables: relVarsValsT,
+  autonums: autonumsType
+) => string;
+export const parseOutputWithVariables: parseOutputT = (
+  output,
+  index,
+  variables,
+  autonums
+) => {
   // Inserting values
-  let parsedOutput = `${output}`
-  Object.keys(variables).forEach(variableId => {
-    let value: string = variables[variableId].toString()
+  let parsedOutput = `${output}`;
+  Object.keys(variables).forEach((variableId) => {
+    let value: string = variables[variableId].toString();
     if (value.trim().length === 0) {
-      value = new Array(16).join('_')
+      value = new Array(16).join("_");
     }
 
     // Replacing linebreaks with br tags
-    value = value.replace(/\n/g, '<br />')
-    parsedOutput = parsedOutput.replace(new RegExp(`\\[var:${variableId}\\]`, 'g'), value)
-  })
+    value = value.replace(/\n/g, "<br />");
+    parsedOutput = parsedOutput.replace(
+      new RegExp(`\\[var:${variableId}\\]`, "g"),
+      value
+    );
+  });
 
   // Inserting page breaks
-  parsedOutput = parsedOutput.replace(/\[\[PAGE_BREAK\]\]/gi, '<div style="page-break-after:always"></div>')
+  parsedOutput = parsedOutput.replace(
+    /\[\[PAGE_BREAK\]\]/gi,
+    '<div style="page-break-after:always"></div>'
+  );
 
   // Cleaning BLURS
-  parsedOutput = parsedOutput.replace(/\[(E|B)_BLUR\]/gi, '')
+  parsedOutput = parsedOutput.replace(/\[(E|B)_BLUR\]/gi, "");
 
   // Parsing Signatures
-  parsedOutput = parsedOutput.replace(/\[signature:([0-9]+)\]/g, (v, signatureId) => `<span data-signature-id="${signatureId}" data-signer-index="${index}"></span>`)
+  parsedOutput = parsedOutput.replace(
+    /\[signature:([0-9]+)\]/g,
+    (v, signatureId) =>
+      `<span data-signature-id="${signatureId}" data-signer-index="${index}"></span>`
+  );
 
   // Inserting autonums
-  autonums.forEach(currentAn => {
-    if (currentAn[3] === null) parsedOutput = parsedOutput.replace(`[${currentAn[0]}:${currentAn[1]}]`, `<span class="${currentAn[0]}">${currentAn[2]}</span>`)
-    else parsedOutput = parsedOutput.replace(`[${currentAn[0]}:${currentAn[1]}](${currentAn[3]})`, `<span class="${currentAn[0]}">${currentAn[2]}</span>`)
-  })
-
-  return parsedOutput
-}
-
+  autonums.forEach((currentAn) => {
+    if (currentAn[3] === null)
+      parsedOutput = parsedOutput.replace(
+        `[${currentAn[0]}:${currentAn[1]}]`,
+        `<span class="${currentAn[0]}">${currentAn[2]}</span>`
+      );
+    else
+      parsedOutput = parsedOutput.replace(
+        `[${currentAn[0]}:${currentAn[1]}](${currentAn[3]})`,
+        `<span class="${currentAn[0]}">${currentAn[2]}</span>`
+      );
+  });
 
+  return parsedOutput;
+};
 
 /**
  * Parses document name with variables
  * @param text Document's name
  */
- type TParseDocumentNameWithVariables = (
-   text: string,
-   ovc: InputsType,
-   references: Types.ReferencesType,
-   fallback?: string
+type TParseDocumentNameWithVariables = (
+  text: string,
+  ovc: InputsType,
+  references: Types.ReferencesType,
+  fallback?: string
 ) => string;
-export const parseDocumentNameWithVariables: TParseDocumentNameWithVariables = (text, ovc, references, fallback) => {
+export const parseDocumentNameWithVariables: TParseDocumentNameWithVariables = (
+  text,
+  ovc,
+  references,
+  fallback
+) => {
   /**
    * Variables
    */
@@ -139,7 +193,7 @@ export const parseDocumentNameWithVariables: TParseDocumentNameWithVariables = (
   // Getting values
   const variablesValues: Record<string, string> = {};
   variables.forEach((variableId) => {
-    const value = ovc.variables[variableId]?.[0] || ''
+    const value = ovc.variables[variableId]?.[0] || "";
     variablesValues[variableId] = value.toString();
   });
 
@@ -150,7 +204,7 @@ export const parseDocumentNameWithVariables: TParseDocumentNameWithVariables = (
     if (value.trim().length === 0 && fallback) parsedText = fallback;
     if (parsedText === fallback && fallback) return;
     parsedText = parsedText.replace(
-      new RegExp(`\\[var:${variableId}\\]`, 'gi'),
+      new RegExp(`\\[var:${variableId}\\]`, "gi"),
       value
     );
   });

package/src/libs/Prerender.ts

@@ -1,149 +1,193 @@
-import { ModelV3 } from '@legalplace/models-v3-types'
-import { Types, ReferencesParser } from '@legalplace/referencesparser'
-import ConditionsRunner from '@legalplace/conditions-runner'
-import OvcConverter from '@legalplace/ovc-converter'
-import OvcType from '@legalplace/types/dist/ovc'
-import InputsType from '@legalplace/types/dist/inputs'
-import crypto from 'crypto'
-import DocumentRender from './DocumentRender'
-import NumAuto from './NumAuto'
-import IntputsInitiator from './InputsInitiator'
-import FillPdfForm from './FillPdfForm'
-import { parseDocumentNameWithVariables } from './OutputParser'
-import type { FDFType, DocumentIndex, DocumentOutputIndex, DocumentPdfFormIndex } from "../types/types"
+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 type OvcType from "@legalplace/types/dist/ovc";
+import type InputsType from "@legalplace/types/dist/inputs";
+import crypto from "crypto";
+import DocumentRender from "./DocumentRender";
+import NumAuto from "./NumAuto";
+import IntputsInitiator from "./InputsInitiator";
+import FillPdfForm from "./FillPdfForm";
+import { parseDocumentNameWithVariables } from "./OutputParser";
+import type {
+  FDFType,
+  DocumentIndex,
+  DocumentOutputIndex,
+  DocumentPdfFormIndex,
+} from "../types/types";
 
 class Prerender {
-  private model: ModelV3
+  private references: Types.ReferencesType;
 
-  private references: Types.ReferencesType
+  private ovc: InputsType;
 
-  private ovc: InputsType
+  private conditions: ConditionsRunner;
 
-  private conditions: ConditionsRunner
+  private documentRender: DocumentRender;
 
-  private documentRender: DocumentRender
+  private pdfFiller: FillPdfForm;
 
-  private pdfFiller: FillPdfForm
+  private NumAuto: NumAuto;
 
-  private NumAuto: NumAuto
+  private documentsIndex: DocumentIndex = {};
 
-  private documentsIndex: DocumentIndex = {}
-
-  private renderedDocuments: Record<string, string | FDFType> = {}
-
-  constructor(model: ModelV3, ovc: InputsType | OvcType) {
-    this.model = model
+  private renderedDocuments: Record<string, string | FDFType> = {};
 
+  constructor(
+    model: ModelV3 | Types.ReferencesType,
+    ovc: InputsType | OvcType
+  ) {
     // Initiating num auto
-    this.NumAuto = new NumAuto()
+    this.NumAuto = new NumAuto();
 
     // Parsing references
-    this.references = new ReferencesParser(model).getReferences()
+    this.references = ReferencesParser.isReferences(model)
+      ? model
+      : new ReferencesParser(model).getReferences();
 
     // Converting OVC if needed
-    this.ovc = OvcConverter.isOvc(ovc) ? OvcConverter.convertToOptionsVariables(ovc, this.references) : ovc
+    this.ovc = OvcConverter.isOvc(ovc)
+      ? OvcConverter.convertToOptionsVariables(ovc, this.references)
+      : ovc;
 
     // Initiating inputs
-    const inputs = new IntputsInitiator(this.references, this.ovc).getInputs()
+    const inputs = new IntputsInitiator(this.references, this.ovc).getInputs();
 
     // Initiating ConditionsRunner
-    this.conditions = new ConditionsRunner(this.references, inputs)
+    this.conditions = new ConditionsRunner(this.references, inputs);
 
     // Rendering documents
-    this.documentRender = new DocumentRender(this.references, this.conditions, inputs, this.NumAuto)
+    this.documentRender = new DocumentRender(
+      this.references,
+      this.conditions,
+      inputs,
+      this.NumAuto
+    );
 
     // Filling pdf documents
-    this.pdfFiller = new FillPdfForm(this.references, this.conditions, inputs)
+    this.pdfFiller = new FillPdfForm(this.references, this.conditions, inputs);
 
-    this.generateDocumentNamesHash()
+    this.generateDocumentNamesHash();
   }
 
   public getDocumentsIndexWithoutFdf() {
-    return this.documentsIndex
+    return this.documentsIndex;
   }
 
   public getDocumentsIndex() {
-    this.generateAllDocuments()
-    this.fillPdfForms()
-    return this.documentsIndex
+    this.generateAllDocuments();
+    this.fillPdfForms();
+    return this.documentsIndex;
   }
 
   public getDocument(documentNameHash: string) {
     if (this.renderedDocuments[documentNameHash]) {
-      return this.renderedDocuments[documentNameHash]
+      return this.renderedDocuments[documentNameHash];
     }
 
-    const index = this.documentsIndex[documentNameHash]
+    const index = this.documentsIndex[documentNameHash];
 
-    this.renderedDocuments[documentNameHash] = Prerender.isPdfForm(index) ? this.pdfFiller.fillDocument(index.slug) : this.documentRender.renderDocument(index.slug)
+    this.renderedDocuments[documentNameHash] = Prerender.isPdfForm(index)
+      ? this.pdfFiller.fillDocument(index.slug)
+      : this.documentRender.renderDocument(index.slug);
 
-    return this.renderedDocuments[documentNameHash]
+    return this.renderedDocuments[documentNameHash];
   }
 
   private generateDocumentNamesHash() {
-    Object.keys(this.model.documents).forEach(slug => {
-      const document = this.model.documents[slug]
-      const documentParams = this.model.documents[slug].params
-      const conditionObject = this.references.conditions.documents[slug]
-      const condition = conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, 0, 0, 'documents')
+    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')
+        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') {
+        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: parseDocumentNameWithVariables(
+              document.name,
+              this.ovc,
+              this.references,
+              document.fallbackName
+            ),
             slug,
             form: true,
             fdf: {
-              id: '',
-              fields: {}
-            }
-          }
+              id: "",
+              fields: {},
+            },
+          };
         } else {
           this.documentsIndex[hash] = {
-            name: parseDocumentNameWithVariables(document.name, this.ovc, this.references, document.fallbackName),
+            name: parseDocumentNameWithVariables(
+              document.name,
+              this.ovc,
+              this.references,
+              document.fallbackName
+            ),
             slug,
             pdf: documentParams?.formats?.pdf !== false,
-            docx: documentParams?.formats?.docx !== false
-          }
+            docx: documentParams?.formats?.docx !== false,
+          };
         }
       }
-    })
+    });
   }
 
   private fillPdfForms() {
-    Object.keys(this.documentsIndex).forEach(documentNameHash => {
-      const index = this.documentsIndex[documentNameHash]
+    Object.keys(this.documentsIndex).forEach((documentNameHash) => {
+      const index = this.documentsIndex[documentNameHash];
       if (Prerender.isPdfForm(index)) {
-        index.fdf = this.getDocument(documentNameHash) as FDFType
+        index.fdf = this.getDocument(documentNameHash) as FDFType;
       }
-    })
+    });
   }
 
   private generateAllDocuments() {
-    Object.keys(this.documentsIndex).forEach(documentNameHash => {
-      const index = this.documentsIndex[documentNameHash]
+    Object.keys(this.documentsIndex).forEach((documentNameHash) => {
+      const index = this.documentsIndex[documentNameHash];
       if (Prerender.isPdfForm(index)) {
-        this.renderedDocuments[documentNameHash] = this.pdfFiller.fillDocument(this.documentsIndex[documentNameHash].slug)
+        this.renderedDocuments[documentNameHash] = this.pdfFiller.fillDocument(
+          this.documentsIndex[documentNameHash].slug
+        );
       } else {
-        this.renderedDocuments[documentNameHash] = this.documentRender.renderDocument(this.documentsIndex[documentNameHash].slug)
+        this.renderedDocuments[documentNameHash] =
+          this.documentRender.renderDocument(
+            this.documentsIndex[documentNameHash].slug
+          );
       }
-    })
+    });
   }
 
-  static isPdfForm(index: DocumentOutputIndex | DocumentPdfFormIndex): index is DocumentPdfFormIndex {
-    return Object.prototype.hasOwnProperty.call(index, 'form')
+  static isPdfForm(
+    index: DocumentOutputIndex | DocumentPdfFormIndex
+  ): index is DocumentPdfFormIndex {
+    return Object.prototype.hasOwnProperty.call(index, "form");
   }
 
-  static isOutput(index: DocumentOutputIndex | DocumentPdfFormIndex): index is DocumentOutputIndex {
-    return !Object.prototype.hasOwnProperty.call(index, 'form')
+  static isOutput(
+    index: DocumentOutputIndex | DocumentPdfFormIndex
+  ): index is DocumentOutputIndex {
+    return !Object.prototype.hasOwnProperty.call(index, "form");
   }
 }
 
-export default Prerender
+export default Prerender;

package/src/libs/SectionRender.ts

@@ -1,61 +1,80 @@
-import { Types } from '@legalplace/referencesparser'
-import ConditionsRunner from '@legalplace/conditions-runner'
-import InputsType from '@legalplace/types/dist/inputs'
-import OptionRender from './OptionRender'
-import NumAuto from './NumAuto'
+import type { Types } from "@legalplace/referencesparser";
+import type ConditionsRunner from "@legalplace/conditions-runner";
+import type InputsType from "@legalplace/types/dist/inputs";
+import OptionRender from "./OptionRender";
+import type NumAuto from "./NumAuto";
 
 class SectionRender {
-  outputs: string[] = []
+  outputs: string[] = [];
 
-  references: Types.ReferencesType
+  references: Types.ReferencesType;
 
-  currentSection: number
+  currentSection: number;
 
-  documentName: string
+  documentName: string;
 
-  conditions: ConditionsRunner
+  conditions: ConditionsRunner;
 
-  ovc: InputsType
+  ovc: InputsType;
 
-  private NumAuto: NumAuto
+  private NumAuto: NumAuto;
 
-  constructor(options: { references: Types.ReferencesType; conditions: ConditionsRunner; ovc: InputsType; documentName: string; currentSection: number; numauto: NumAuto }) {
-    this.references = options.references
-    this.conditions = options.conditions
-    this.documentName = options.documentName
-    this.currentSection = options.currentSection
-    this.ovc = options.ovc
-    this.NumAuto = options.numauto
+  constructor(options: {
+    references: Types.ReferencesType;
+    conditions: ConditionsRunner;
+    ovc: InputsType;
+    documentName: string;
+    currentSection: number;
+    numauto: NumAuto;
+  }) {
+    this.references = options.references;
+    this.conditions = options.conditions;
+    this.documentName = options.documentName;
+    this.currentSection = options.currentSection;
+    this.ovc = options.ovc;
+    this.NumAuto = options.numauto;
 
-    this.renderSection()
+    this.renderSection();
   }
 
   getOutputs() {
-    return this.outputs
+    return this.outputs;
   }
 
   private renderSection() {
-    const section = this.references.sections[this.documentName][this.currentSection]
-    const conditionObject = this.references.conditions.sections[this.documentName][this.currentSection]
-    const condition = conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, 0, 0, 'sections')
+    const section =
+      this.references.sections[this.documentName][this.currentSection];
+    const conditionObject =
+      this.references.conditions.sections[this.documentName][
+        this.currentSection
+      ];
+    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)
+      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
+        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
+          if (value !== true) return;
 
           this.outputs = [
             ...this.outputs,
@@ -65,13 +84,13 @@ class SectionRender {
               ovc: this.ovc,
               index,
               conditions: this.conditions,
-              numauto: this.NumAuto
-            }).getOutputs()
-          ]
-        })
-      })
+              numauto: this.NumAuto,
+            }).getOutputs(),
+          ];
+        });
+      });
     }
   }
 }
 
-export default SectionRender
+export default SectionRender;