@legalplace/prerenderx 2.0.0

package/src/libs/OutputParser.ts

@@ -0,0 +1,122 @@
+import { Types } from "@legalplace/referencesparser";
+import OVC_TYPE from "./ovc.type";
+
+/**
+ * Returns option's related variable values
+ * @param optionId Option's id
+ * @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
+) => {
+  // Getting variables values
+  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;
+
+    // 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]];
+
+    // 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 "";
+    });
+
+    // Joining multiple variables
+    variablesValues[currentVariableId] =
+      cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(", ");
+  });
+
+  return variablesValues;
+};
+
+/**
+ * Parses output with variables
+ * @param output Raw output
+ * @param id Box id
+ * @param index Occurency Index
+ * @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
+) => {
+  // Inserting values
+  let parsedOutput = `${output}`;
+  Object.keys(variables).forEach(variableId => {
+    let value: string = variables[variableId].toString();
+    if (value.trim().length === 0) {
+      value = new Array(16).join("_");
+    }
+    parsedOutput = parsedOutput.replace(
+      new RegExp(`\\[var:${variableId}\\]`, "g"),
+      value
+    );
+  });
+
+  // Inserting page breaks
+  parsedOutput = parsedOutput.replace(
+    "[[PAGE_BREAK]]",
+    '<p class="pagebreak"><!-- pagebreak --></p>'
+  );
+
+  // 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;
+};

package/src/libs/Prerender.ts

@@ -0,0 +1,107 @@
+import { ModelV3 } from "@legalplace/models-v3-types";
+import { Types, ReferencesParser } from "@legalplace/referencesparser";
+import crypto from "crypto";
+import DocumentRender from "./DocumentRender";
+import ConditionsRunner from "./ConditionsRunner";
+import OVC_TYPE from "./ovc.type";
+import NumAuto from "./NumAuto";
+
+class Prerender {
+  private model: ModelV3;
+
+  private references: Types.ReferencesType;
+
+  private ovc: OVC_TYPE;
+
+  private conditions: ConditionsRunner;
+
+  private documentRender: DocumentRender;
+
+  private NumAuto: NumAuto;
+
+  private documentsIndex: Record<
+    string,
+    {
+      name: string;
+      pdf: boolean;
+      docx: boolean;
+    }
+  > = {};
+
+  private renderedDocuments: Record<string, string> = {};
+
+  constructor(model: ModelV3, ovc: OVC_TYPE) {
+    this.model = model;
+    this.ovc = ovc;
+    this.NumAuto = new NumAuto();
+
+    // @ts-ignore
+    this.references = new ReferencesParser(model).getReferences();
+
+    // Initiating ConditionsRunner
+    this.conditions = new ConditionsRunner(this.references, this.ovc);
+
+    // Rendering documents
+    this.documentRender = new DocumentRender(
+      this.references,
+      this.conditions,
+      this.ovc,
+      this.NumAuto
+    );
+
+    this.generateDocumentNamesHash();
+    this.generateAllDocuments();
+  }
+
+  public getDocumentsIndex() {
+    return this.documentsIndex;
+  }
+
+  private generateDocumentNamesHash() {
+    Object.keys(this.model.documents).forEach(documentName => {
+      const conditionObject = this.references.conditions.documents[
+        documentName
+      ];
+      const condition =
+        conditionObject === undefined
+          ? true
+          : this.conditions.executeCondition(
+              conditionObject,
+              0,
+              0,
+              "documents"
+            );
+
+      // Rendering documents sections
+      if (condition === true) {
+        const hash = crypto
+          .createHash("sha1")
+          .update(documentName)
+          .digest("hex");
+
+        // Referencing in index
+        this.documentsIndex[hash] = {
+          name: documentName,
+          pdf: true,
+          docx: true
+        };
+      }
+    });
+  }
+
+  private generateAllDocuments() {
+    Object.keys(this.documentsIndex).forEach(documentNameHash => {
+      this.renderedDocuments[
+        documentNameHash
+      ] = this.documentRender.renderDocument(
+        this.documentsIndex[documentNameHash].name
+      );
+    });
+  }
+
+  public getDocument(documentNameHash: string) {
+    return this.renderedDocuments[documentNameHash];
+  }
+}
+
+export default Prerender;

package/src/libs/SectionRender.ts

@@ -0,0 +1,96 @@
+import { Types } from "@legalplace/referencesparser";
+import ConditionsRunner from "./ConditionsRunner";
+import OptionRender from "./OptionRender";
+import OVC_TYPE from "./ovc.type";
+import NumAuto from "./NumAuto";
+
+class SectionRender {
+  outputs: string[] = [];
+
+  references: Types.ReferencesType;
+
+  currentSection: number;
+
+  documentName: string;
+
+  conditions: ConditionsRunner;
+
+  ovc: OVC_TYPE;
+
+  private NumAuto: NumAuto;
+
+  constructor(options: {
+    references: Types.ReferencesType;
+    conditions: ConditionsRunner;
+    ovc: OVC_TYPE;
+    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();
+  }
+
+  getOutputs() {
+    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");
+
+    // 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.outputs = [
+            ...this.outputs,
+            ...new OptionRender({
+              references: this.references,
+              id: optionId,
+              ovc: this.ovc,
+              index,
+              conditions: this.conditions,
+              numauto: this.NumAuto
+            }).getOutputs()
+          ];
+        });
+      });
+    }
+  }
+}
+
+export default SectionRender;

package/src/libs/ovc.type.ts

@@ -0,0 +1,10 @@
+type OVC_TYPE = {
+  options: {
+    [key: string]: boolean[];
+  };
+  variables: {
+    [key: string]: (number | string)[];
+  };
+};
+
+export default OVC_TYPE;

package/tsconfig.eslint.json

@@ -0,0 +1,12 @@
+{
+  // extend your base config so you don't have to redefine your compilerOptions
+  "extends": "./tsconfig.json",
+  "include": [
+    "src/**/*.ts",
+    "*.ts",
+    // etc
+
+    // if you have a mixed JS/TS codebase, don't forget to include your JS files
+    "src/**/*.js"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "lib": ["es2018"],
+    "outDir": "./dist/",
+    "strict": true,
+    "typeRoots": ["node_modules/@types"],
+    "esModuleInterop": true,
+    "removeComments": true,
+    "declaration": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}