@legalplace/prerenderx 3.2.0 → 3.3.0

package/src/libs/FillPdfForm.ts

@@ -1,40 +1,46 @@
-import { FDFBoxesV3, FDFInputsV3 } from '@legalplace/models-v3-types'
-import FillPdfFormBase from './misc/FillPdfFormBase'
+import type { FDFBoxesV3, FDFInputsV3 } from "@legalplace/models-v3-types";
+import FillPdfFormBase from "./misc/FillPdfFormBase";
 
 type FDFType = {
-  id: string
-  fields: Record<string, string>
-}
+  id: string;
+  fields: Record<string, string>;
+};
 class FillPdfForm extends FillPdfFormBase {
   public fillDocument(documentName: string) {
     const result: FDFType = {
-      id: '',
-      fields: {}
-    }
+      id: "",
+      fields: {},
+    };
 
     // Getting document
-    const document = this.references.documents[documentName]
-    const { pdf } = document
-    if (typeof pdf === 'undefined') return result
-    const { form } = pdf
+    const document = this.references.documents[documentName];
+    const { pdf } = document;
+    if (typeof pdf === "undefined") return result;
+    const { form } = pdf;
 
     // Setting pdf ID
-    result.id = pdf.id
+    result.id = pdf.id;
 
     // Filling inputs
-    form.inputs.forEach(input => {
-      const id = `${input.name}`
-      result.fields[id] = this.getInputValue(input)
-    })
+    form.inputs.forEach((input) => {
+      const id = `${input.name}`;
+      result.fields[id] = this.getInputValue(input);
+    });
 
     // Filling boxes
-    form.boxes.forEach(box => {
-      const id = `${box.name}`
-      const value = this.getBoxValue(box)
-      if (!(value === '' && Object.prototype.hasOwnProperty.call(result.fields, id))) result.fields[id] = value
-    })
-
-    return result
+    form.boxes.forEach((box) => {
+      const id = `${box.name}`;
+      const value = this.getBoxValue(box);
+      if (
+        !(
+          value === "" &&
+          Object.prototype.hasOwnProperty.call(result.fields, id)
+        )
+      )
+        result.fields[id] = value;
+    });
+
+    return result;
   }
 
   /**
@@ -43,60 +49,64 @@ class FillPdfForm extends FillPdfFormBase {
    */
   private getInputValue(input: FDFInputsV3): string {
     for (let i = 0; i < input.variables.length; i += 1) {
-      const variable = input.variables[i]
-      const currentValue = this.getVariableValue(variable.id)
+      const variable = input.variables[i];
+      const currentValue = this.getVariableValue(variable.id);
 
       if (currentValue !== false) {
         // Date values
-        const dateRegex = /^([0-9]{2})\/([0-9]{2})\/([0-9]{4})$/
+        const dateRegex = /^([0-9]{2})\/([0-9]{2})\/([0-9]{4})$/;
         if (variable.date && dateRegex.test(currentValue)) {
           switch (variable.date) {
-            case 'DD':
-              return currentValue.replace(dateRegex, '$1')
-            case 'MM':
-              return currentValue.replace(dateRegex, '$2')
-            case 'YYYY':
-              return currentValue.replace(dateRegex, '$3')
+            case "DD":
+              return currentValue.replace(dateRegex, "$1");
+            case "MM":
+              return currentValue.replace(dateRegex, "$2");
+            case "YYYY":
+              return currentValue.replace(dateRegex, "$3");
             default:
           }
         }
 
         // Hour values
-        const hourRegex = /^([0-9]{2}:[0-9]{2})$/
+        const hourRegex = /^([0-9]{2}:[0-9]{2})$/;
         if (variable.hour && hourRegex.test(currentValue)) {
           switch (variable.hour) {
-            case 'HH':
-              return currentValue.replace(hourRegex, '$1')
-            case 'MM':
-              return currentValue.replace(hourRegex, '$2')
+            case "HH":
+              return currentValue.replace(hourRegex, "$1");
+            case "MM":
+              return currentValue.replace(hourRegex, "$2");
             default:
           }
         }
 
         // Email values
-        const emailRegex = /^(.*)@(.*)$/
+        const emailRegex = /^(.*)@(.*)$/;
         if (variable.email && emailRegex.test(currentValue)) {
           switch (variable.email) {
-            case 'ADDRESS':
-              return currentValue.split('@')[0]
-            case 'PROVIDER':
-              return currentValue.split('@')[1]
+            case "ADDRESS":
+              return currentValue.split("@")[0];
+            case "PROVIDER":
+              return currentValue.split("@")[1];
             default:
           }
         }
 
         // Fragment values
-        if (variable.fragment && typeof variable.fragment.from === 'number' && typeof variable.fragment.to === 'number') {
-          const { from, to } = variable.fragment
-          return currentValue.slice(from, to)
+        if (
+          variable.fragment &&
+          typeof variable.fragment.from === "number" &&
+          typeof variable.fragment.to === "number"
+        ) {
+          const { from, to } = variable.fragment;
+          return currentValue.slice(from, to);
         }
 
         // Return value
-        return currentValue
+        return currentValue;
       }
     }
 
-    return ''
+    return "";
   }
 
   /**
@@ -105,17 +115,20 @@ class FillPdfForm extends FillPdfFormBase {
    */
   private getBoxValue(box: FDFBoxesV3): string {
     for (let i = 0; i < box.options.length; i += 1) {
-      const option = box.options[i]
-      const currentValue = this.getOptionValue(option.id)
+      const option = box.options[i];
+      const currentValue = this.getOptionValue(option.id);
 
       if (currentValue === true) {
-        if (this.references.options[option.id].meta.type === "checkbox" && box.value === "Off")
-          return "On"
-        return box.value
+        if (
+          this.references.options[option.id].meta.type === "checkbox" &&
+          box.value === "Off"
+        )
+          return "On";
+        return box.value;
       }
     }
 
-    return ''
+    return "";
   }
 
   /**
@@ -123,10 +136,10 @@ class FillPdfForm extends FillPdfFormBase {
    */
   private getVariableValue(variableId: number) {
     // Checking if variable is displayed
-    if (this.isVariableDisplayed(variableId, 0) === false) return false
+    if (this.isVariableDisplayed(variableId, 0) === false) return false;
 
     // Returning variable's value
-    return (this.ovc.variables[variableId]?.[0] || '').toString()
+    return (this.ovc.variables[variableId]?.[0] || "").toString();
   }
 
   /**
@@ -134,11 +147,11 @@ class FillPdfForm extends FillPdfFormBase {
    */
   private getOptionValue(optionId: number) {
     // Checking if option is displayed
-    if (this.isOptionDisplayed(optionId, 0) === false) return false
+    if (this.isOptionDisplayed(optionId, 0) === false) return false;
 
     // Returning option's value
-    return this.ovc.options[optionId]?.[0] === true
+    return this.ovc.options[optionId]?.[0] === true;
   }
 }
 
-export default FillPdfForm
+export default FillPdfForm;

package/src/libs/InputsInitiator.ts

@@ -1,68 +1,71 @@
-import { Types } from '@legalplace/referencesparser'
+import type { Types } from "@legalplace/referencesparser";
 
-type References = Types.ReferencesType
+type References = Types.ReferencesType;
 
 type OVC_TYPE = {
   options: {
-    [key: string]: boolean[]
-  }
+    [key: string]: boolean[];
+  };
   variables: {
-    [key: string]: (number | string)[]
-  }
-}
+    [key: string]: (number | string)[];
+  };
+};
 
 class IntputsInitiator {
   private inputs: OVC_TYPE = {
     options: {},
-    variables: {}
-  }
+    variables: {},
+  };
 
-  private references: References
+  private references: References;
 
-  private ovc: OVC_TYPE | null
+  private ovc: OVC_TYPE | null;
 
   /**
    * InitalConditions Constructor
    * @param references References object
    */
   constructor(references: References, ovc: OVC_TYPE | null) {
-    this.references = references
-    this.ovc = ovc
+    this.references = references;
+    this.ovc = ovc;
 
     // Setting multiples
-    this.setMultiples()
+    this.setMultiples();
 
     // Initiating inputs
-    this.initOptionsInputs()
-    this.initVariablesInputs()
+    this.initOptionsInputs();
+    this.initVariablesInputs();
   }
 
   public getInputs() {
-    return this.inputs
+    return this.inputs;
   }
 
   private setMultiples() {
-    if (this.ovc === null) return
-    Object.keys(this.ovc.options).forEach(id => {
-      if (this.ovc === null) return
-      const inputs = this.ovc.options[id]
+    if (this.ovc === null) return;
+    Object.keys(this.ovc.options).forEach((id) => {
+      if (this.ovc === null) return;
+      const inputs = this.ovc.options[id];
 
       if (inputs.length > 1) {
         // Getting parents
-        const parentsTree = this.references.relations.options[id].parents
+        const parentsTree = this.references.relations.options[id].parents;
 
         // root parent
-        const rootOptionId = parentsTree.length > 0 ? parentsTree[parentsTree.length - 1] : id
+        const rootOptionId =
+          parentsTree.length > 0 ? parentsTree[parentsTree.length - 1] : id;
 
         if (!this.ovc.options[rootOptionId]) {
           // root Option reference
-          const rootReference = this.references.options[rootOptionId]
-          if (rootReference.meta.type === 'static') {
-            this.ovc.options[rootOptionId] = new Array(inputs.length).fill(true)
+          const rootReference = this.references.options[rootOptionId];
+          if (rootReference.meta.type === "static") {
+            this.ovc.options[rootOptionId] = new Array(inputs.length).fill(
+              true
+            );
           }
         }
       }
-    })
+    });
   }
 
   /**
@@ -70,23 +73,44 @@ class IntputsInitiator {
    */
   private initOptionsInputs() {
     // Options
-    const optionsIds = Object.keys(this.references.options)
+    const optionsIds = Object.keys(this.references.options);
     for (let i = 0; i < optionsIds.length; i += 1) {
-      const optionId = optionsIds[i]
-      const option = this.references.options[optionId]
-
-      let values = [false]
-      if (this.ovc && Object.prototype.hasOwnProperty.call(this.ovc.options, optionId)) {
-        if (['static', 'hidden', 'brut-text', 'repeated', 'box', 'separator'].includes(option.meta.type)) {
-          values = new Array(this.ovc.options[optionId].length).fill(true)
+      const optionId = optionsIds[i];
+      const option = this.references.options[optionId];
+
+      let values = [false];
+      if (
+        this.ovc &&
+        Object.prototype.hasOwnProperty.call(this.ovc.options, optionId)
+      ) {
+        if (
+          [
+            "static",
+            "hidden",
+            "brut-text",
+            "repeated",
+            "box",
+            "separator",
+          ].includes(option.meta.type)
+        ) {
+          values = new Array(this.ovc.options[optionId].length).fill(true);
         } else {
-          values = this.ovc.options[optionId]
+          values = this.ovc.options[optionId];
         }
-      } else if (['static', 'hidden', 'brut-text', 'repeated', 'box', 'separator'].includes(option.meta.type)) {
-        values = [true]
+      } else if (
+        [
+          "static",
+          "hidden",
+          "brut-text",
+          "repeated",
+          "box",
+          "separator",
+        ].includes(option.meta.type)
+      ) {
+        values = [true];
       }
 
-      this.inputs.options[optionId] = values
+      this.inputs.options[optionId] = values;
     }
   }
 
@@ -94,28 +118,42 @@ class IntputsInitiator {
    * Initates variables inputs
    */
   private initVariablesInputs() {
-    const variablesIds = Object.keys(this.references.variables)
+    const variablesIds = Object.keys(this.references.variables);
     for (let i = 0; i < variablesIds.length; i += 1) {
-      const variableId = variablesIds[i]
-
-      let values: (string | number)[] = ['']
-      if (this.ovc && Object.prototype.hasOwnProperty.call(this.ovc.variables, variableId)) {
-        values = this.ovc.variables[variableId]
+      const variableId = variablesIds[i];
+
+      let values: (string | number)[] = [""];
+      if (
+        this.ovc &&
+        Object.prototype.hasOwnProperty.call(this.ovc.variables, variableId)
+      ) {
+        values = this.ovc.variables[variableId];
       } else {
-        let defaultValue = ''
+        let defaultValue = "";
 
         // Checking for first prefill without condition
-        const { prefillings } = this.references.variables[variableId]
-        if (prefillings && Array.isArray(prefillings) && prefillings.length > 0) {
-          const noConditionsPrefills = prefillings.filter(prefill => typeof prefill.conditions === 'undefined' || Object.keys(prefill.conditions).length === 0)
-          defaultValue = noConditionsPrefills.length > 0 ? noConditionsPrefills[0].value : ''
+        const { prefillings } = this.references.variables[variableId];
+        if (
+          prefillings &&
+          Array.isArray(prefillings) &&
+          prefillings.length > 0
+        ) {
+          const noConditionsPrefills = prefillings.filter(
+            (prefill) =>
+              typeof prefill.conditions === "undefined" ||
+              Object.keys(prefill.conditions).length === 0
+          );
+          defaultValue =
+            noConditionsPrefills.length > 0
+              ? noConditionsPrefills[0].value
+              : "";
         }
-        values = [defaultValue]
+        values = [defaultValue];
       }
 
-      this.inputs.variables[variableId] = values
+      this.inputs.variables[variableId] = values;
     }
   }
 }
 
-export default IntputsInitiator
+export default IntputsInitiator;

package/src/libs/NumAuto.ts

@@ -1,7 +1,7 @@
 class NumAuto {
-  indexesList: Record<string, any> = {}
+  indexesList: Record<string, any> = {};
 
-  tagsIndex: Record<string, number> = {}
+  tagsIndex: Record<string, number> = {};
 
   /**
    * Increments the given index by 1 and
@@ -12,18 +12,19 @@ class NumAuto {
     // In case the index doesn't exist
     if (!Object.prototype.hasOwnProperty.call(this.indexesList, index)) {
       // Let's first make sure it's not a tag and return it if it is
-      if (Object.prototype.hasOwnProperty.call(this.tagsIndex, index)) return this.tagsIndex[index]
+      if (Object.prototype.hasOwnProperty.call(this.tagsIndex, index))
+        return this.tagsIndex[index];
 
       // Otherwise we set a new index
-      this.indexesList[index] = 0
+      this.indexesList[index] = 0;
     }
 
-    this.indexesList[index] += 1
+    this.indexesList[index] += 1;
 
-    if (typeof tag === 'string') this.tagsIndex[tag] = this.indexesList[index]
+    if (typeof tag === "string") this.tagsIndex[tag] = this.indexesList[index];
 
-    return this.indexesList[index]
-  }
+    return this.indexesList[index];
+  };
 
   /**
    * Returns the current count of the given index
@@ -33,14 +34,15 @@ class NumAuto {
     // In case the index doesn't exist
     if (!Object.prototype.hasOwnProperty.call(this.indexesList, index)) {
       // Let's first make sure it's not a tag and return it if it is
-      if (Object.prototype.hasOwnProperty.call(this.tagsIndex, index)) return this.tagsIndex[index]
+      if (Object.prototype.hasOwnProperty.call(this.tagsIndex, index))
+        return this.tagsIndex[index];
     }
-    return this.indexesList[index]
-  }
+    return this.indexesList[index];
+  };
 
   resetIndexes = () => {
-    this.indexesList = {}
-  }
+    this.indexesList = {};
+  };
 }
 
-export default NumAuto
+export default NumAuto;

package/src/libs/OptionRender.ts

@@ -1,82 +1,122 @@
-import { Types } from '@legalplace/referencesparser'
-import ConditionsRunner from '@legalplace/conditions-runner'
-import InputsType from '@legalplace/types/dist/inputs'
-import { parseOutputWithVariables, getRelatedVariablesValues } from './OutputParser'
-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 {
+  parseOutputWithVariables,
+  getRelatedVariablesValues,
+} from "./OutputParser";
+import type NumAuto from "./NumAuto";
 
 class OptionRender {
-  outputs: string[] = []
+  outputs: string[] = [];
 
-  references: Types.ReferencesType
+  references: Types.ReferencesType;
 
-  index: number
+  index: number;
 
-  id: number
+  id: number;
 
-  conditions: ConditionsRunner
+  conditions: ConditionsRunner;
 
-  ovc: InputsType
+  ovc: InputsType;
 
-  private NumAuto: NumAuto
+  private NumAuto: NumAuto;
 
-  constructor(options: { references: Types.ReferencesType; conditions: ConditionsRunner; ovc: InputsType; index: number; id: number; numauto: NumAuto }) {
-    this.references = options.references
-    this.conditions = options.conditions
-    this.index = options.index
-    this.id = options.id
-    this.ovc = options.ovc
-    this.NumAuto = options.numauto
+  constructor(options: {
+    references: Types.ReferencesType;
+    conditions: ConditionsRunner;
+    ovc: InputsType;
+    index: number;
+    id: number;
+    numauto: NumAuto;
+  }) {
+    this.references = options.references;
+    this.conditions = options.conditions;
+    this.index = options.index;
+    this.id = options.id;
+    this.ovc = options.ovc;
+    this.NumAuto = options.numauto;
 
-    this.renderOption()
+    this.renderOption();
   }
 
   getOutputs() {
-    return this.outputs
+    return this.outputs;
   }
 
   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')
+    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) {
+      if (
+        typeof option.meta.output === "string" &&
+        option.meta.output.trim().length > 0
+      ) {
         // output Reference
-        const outputReference = this.references.outputs[this.id]
+        const outputReference = this.references.outputs[this.id];
 
         // Autonums
-        let autonums: [string, string, number, string | null][] = []
+        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]]
-          })
+          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],
+            ];
+          });
         }
 
         // variables
-        const variables = getRelatedVariablesValues(this.id, this.index, outputReference.variables, this.ovc, this.references)
-        let output = parseOutputWithVariables(option.meta.output, this.index, variables, autonums)
+        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><');
+        output = output.replace(/<\/([a-z]+)>([\n\s]+)</gi, "</$1><");
 
         // Replacing \n with line-break
-        output = output.replace(/\n/g, '<br />')
+        output = output.replace(/\n/g, "<br />");
 
         // Cleaning \xA0
-        output = output.replace(/\xA0/g, ' ')
+        output = output.replace(/\xA0/g, " ");
 
         // Pushing output
-        this.outputs.push(output)
+        this.outputs.push(output);
       }
-      this.renderChildren()
+      this.renderChildren();
     }
   }
 
   private renderChildren() {
-    const option = this.references.options[this.id]
-    option.options.forEach(optionId => {
+    const option = this.references.options[this.id];
+    option.options.forEach((optionId) => {
       this.outputs = [
         ...this.outputs,
         ...new OptionRender({
@@ -85,11 +125,11 @@ class OptionRender {
           ovc: this.ovc,
           index: this.index,
           conditions: this.conditions,
-          numauto: this.NumAuto
-        }).getOutputs()
-      ]
-    })
+          numauto: this.NumAuto,
+        }).getOutputs(),
+      ];
+    });
   }
 }
 
-export default OptionRender
+export default OptionRender;