@legalplace/prerenderx 2.2.2 → 2.2.3

package/src/libs/InputsInitiator.ts

@@ -1,71 +1,68 @@
-import { Types } from "@legalplace/referencesparser";
+import { 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: {}
-  };
+  }
 
-  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;
+    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
+      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)
           }
         }
       }
-    });
+    })
   }
 
   /**
@@ -73,44 +70,23 @@ 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
     }
   }
 
@@ -118,42 +94,28 @@ 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,19 +12,18 @@ 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
@@ -34,15 +33,14 @@ 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,110 +1,71 @@
-import { Types } from "@legalplace/referencesparser";
-import ConditionsRunner from "./ConditionsRunner";
-import OVC_TYPE from "./ovc.type";
-import {
-  parseOutputWithVariables,
-  getRelatedVariablesValues
-} from "./OutputParser";
-import NumAuto from "./NumAuto";
+import { Types } from '@legalplace/referencesparser'
+import ConditionsRunner from './ConditionsRunner'
+import OVC_TYPE from './ovc.type'
+import { parseOutputWithVariables, getRelatedVariablesValues } from './OutputParser'
+import 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: OVC_TYPE;
+  ovc: OVC_TYPE
 
-  private NumAuto: NumAuto;
+  private NumAuto: NumAuto
 
-  constructor(options: {
-    references: Types.ReferencesType;
-    conditions: ConditionsRunner;
-    ovc: OVC_TYPE;
-    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: OVC_TYPE; 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]
-            ];
-          });
+            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
-        );
-
-        const output = parseOutputWithVariables(
-          option.meta.output,
-          variables,
-          autonums
-        );
-        this.outputs.push(output);
+        const variables = getRelatedVariablesValues(this.id, this.index, outputReference.variables, this.ovc, this.references)
+
+        const output = parseOutputWithVariables(option.meta.output, variables, autonums)
+        this.outputs.push(output)
       }
-      this.renderChildren();
+      this.renderChildren()
     }
   }
 
   private renderChildren() {
-    const option = this.references.options[this.id];
+    const option = this.references.options[this.id]
     option.options.forEach(optionId => {
       this.outputs = [
         ...this.outputs,
@@ -116,9 +77,9 @@ class OptionRender {
           conditions: this.conditions,
           numauto: this.NumAuto
         }).getOutputs()
-      ];
-    });
+      ]
+    })
   }
 }
 
-export default OptionRender;
+export default OptionRender

package/src/libs/OutputParser.ts

@@ -1,5 +1,5 @@
-import { Types } from "@legalplace/referencesparser";
-import OVC_TYPE from "./ovc.type";
+import { Types } from '@legalplace/referencesparser'
+import OVC_TYPE from './ovc.type'
 
 /**
  * Returns option's related variable values
@@ -7,64 +7,41 @@ import OVC_TYPE from "./ovc.type";
  * @param index Occurency index
  * @param variables Variables ids list
  */
-type relVarsValsT = Record<string, string | number>;
-type getRelatedVarsT = (
-  optionId: number,
-  index: number,
-  variables: number[],
-  ovc: OVC_TYPE,
-  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: OVC_TYPE, references: Types.ReferencesType) => relVarsValsT
+export const getRelatedVariablesValues: getRelatedVarsT = (optionId, index, variables, ovc, references) => {
   // Getting variables values
-  const variablesValues: Record<string, string> = {};
+  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`);
+    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;
+    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 (typeof currentValue === "number") return currentValue.toString();
-      if (typeof currentValue === "string") return currentValue;
-      return "";
-    });
+      if (typeof currentValue === 'number') return currentValue.toString()
+      if (typeof currentValue === 'string') return currentValue
+      return ''
+    })
 
     // Joining multiple variables
-    variablesValues[currentVariableId] =
-      cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(", ");
-  });
+    variablesValues[currentVariableId] = cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(', ')
+  })
 
-  return variablesValues;
-};
+  return variablesValues
+}
 
 /**
  * Parses output with variables
@@ -74,52 +51,30 @@ export const getRelatedVariablesValues: getRelatedVarsT = (
  * @param variables Variables values list
  * @param autonums Autonums values
  */
-type autonumsType = [string, string, number, string | null][];
-type parseOutputT = (
-  output: string,
-  variables: relVarsValsT,
-  autonums: autonumsType
-) => string;
-export const parseOutputWithVariables: parseOutputT = (
-  output,
-  variables,
-  autonums
-) => {
+type autonumsType = [string, string, number, string | null][]
+type parseOutputT = (output: string, variables: relVarsValsT, autonums: autonumsType) => string
+export const parseOutputWithVariables: parseOutputT = (output, variables, autonums) => {
   // Inserting values
-  let parsedOutput = `${output}`;
+  let parsedOutput = `${output}`
   Object.keys(variables).forEach(variableId => {
-    let value: string = variables[variableId].toString();
+    let value: string = variables[variableId].toString()
     if (value.trim().length === 0) {
-      value = new Array(16).join("_");
+      value = new Array(16).join('_')
     }
-    parsedOutput = parsedOutput.replace(
-      new RegExp(`\\[var:${variableId}\\]`, "g"),
-      value
-    );
-  });
+    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, '')
 
   // 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>`
-      );
-  });
+    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;
-};
+  return parsedOutput
+}