@legalplace/prerenderx 2.0.0

package/dist/libs/SectionRender.d.ts

@@ -0,0 +1,24 @@
+import { Types } from "@legalplace/referencesparser";
+import ConditionsRunner from "./ConditionsRunner";
+import OVC_TYPE from "./ovc.type";
+import NumAuto from "./NumAuto";
+declare class SectionRender {
+    outputs: string[];
+    references: Types.ReferencesType;
+    currentSection: number;
+    documentName: string;
+    conditions: ConditionsRunner;
+    ovc: OVC_TYPE;
+    private NumAuto;
+    constructor(options: {
+        references: Types.ReferencesType;
+        conditions: ConditionsRunner;
+        ovc: OVC_TYPE;
+        documentName: string;
+        currentSection: number;
+        numauto: NumAuto;
+    });
+    getOutputs(): string[];
+    private renderSection;
+}
+export default SectionRender;

package/dist/libs/SectionRender.js

@@ -0,0 +1,67 @@
+"use strict";
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var OptionRender_1 = __importDefault(require("./OptionRender"));
+var SectionRender = (function () {
+    function SectionRender(options) {
+        this.outputs = [];
+        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();
+    }
+    SectionRender.prototype.getOutputs = function () {
+        return this.outputs;
+    };
+    SectionRender.prototype.renderSection = function () {
+        var _this = this;
+        var section = this.references.sections[this.documentName][this.currentSection];
+        var conditionObject = this.references.conditions.sections[this.documentName][this.currentSection];
+        var condition = conditionObject === undefined
+            ? true
+            : this.conditions.executeCondition(conditionObject, 0, 0, "sections");
+        if (condition === true) {
+            section.options.forEach(function (optionId) {
+                var option = _this.references.options[optionId];
+                var 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);
+                }
+                var inputs = _this.ovc.options[repeatOption] || [
+                    !["radio", "checkbox"].includes(option.meta.type)
+                ];
+                inputs.forEach(function (value, index) {
+                    if (value !== true)
+                        return;
+                    _this.outputs = __spreadArrays(_this.outputs, new OptionRender_1.default({
+                        references: _this.references,
+                        id: optionId,
+                        ovc: _this.ovc,
+                        index: index,
+                        conditions: _this.conditions,
+                        numauto: _this.NumAuto
+                    }).getOutputs());
+                });
+            });
+        }
+    };
+    return SectionRender;
+}());
+exports.default = SectionRender;

package/dist/libs/ovc.type.d.ts

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

package/dist/libs/ovc.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/jest.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  roots: ["./tests"],
+  transform: {
+    "^.+\\.tsx?$": "ts-jest"
+  },
+  globals: {
+    "ts-jest": {
+      tsConfig: "tsconfig.json"
+    }
+  }
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@legalplace/prerenderx",
+  "version": "2.0.0",
+  "description": "PrerenderX",
+  "main": "dist/index.js",
+  "repository": "https://git.legalplace.eu/legalplace/prerenderx",
+  "author": "Moncef Hammou <moncef@legalplace.fr> <moncef@legalplace.fr>",
+  "license": "MIT",
+  "scripts": {
+    "lint": "npx eslint ./src/ --ext ts,js",
+    "test": "npx jest",
+    "build": "npx tsc"
+  },
+  "dependencies": {
+    "crypto": "^1.0.1",
+    "@legalplace/lplogic": "^2.0.0",
+    "@legalplace/models-v3-types": "^3.1.1",
+    "@legalplace/referencesparser": "^1.1.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.7.2",
+    "@babel/preset-typescript": "^7.7.2",
+    "@types/jest": "^24.0.15",
+    "@types/node": "^12.12.6",
+    "@typescript-eslint/eslint-plugin": "^2.6.1",
+    "@typescript-eslint/parser": "^2.6.1",
+    "airbnb-standard": "^1.0.0",
+    "eslint": "^6.6.0",
+    "eslint-config-airbnb-base": "^14.0.0",
+    "eslint-config-prettier": "^6.5.0",
+    "eslint-plugin-import": "^2.18.2",
+    "eslint-plugin-prettier": "^3.1.1",
+    "jest": "^24.8.0",
+    "prettier": "1.19.1",
+    "redux-mock-store": "^1.5.3",
+    "ts-jest": "^24.0.2",
+    "typescript": "^3.7.2"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import Prerender from "./libs/Prerender";
+
+export { Prerender };

package/src/libs/ConditionsRunner.ts

@@ -0,0 +1,237 @@
+/* eslint-disable max-len */
+import LpLogic from "@legalplace/lplogic";
+import { Types } from "@legalplace/referencesparser";
+import { ConditionV3 } from "@legalplace/models-v3-types";
+
+type OVC_TYPE = {
+  options: {
+    [key: string]: boolean[];
+  };
+  variables: {
+    [key: string]: (number | string)[];
+  };
+};
+
+interface ConditionDataMap {
+  o: number[];
+  v: number[];
+}
+
+interface ConditionData {
+  o: Record<string, boolean[]>;
+  v: Record<string, (string | number)[]>;
+}
+
+class ConditionsRunner {
+  private references: Types.ReferencesType;
+
+  private ovc: OVC_TYPE;
+
+  constructor(references: Types.ReferencesType, ovc: OVC_TYPE) {
+    this.references = references;
+    this.ovc = ovc;
+  }
+
+  private populateData(
+    id: number,
+    index: number,
+    dataMap: ConditionDataMap,
+    withRelations = true
+  ) {
+    const data: ConditionData = {
+      o: {},
+      v: {}
+    };
+
+    // Populating options
+    dataMap.o.forEach(currentOptionId => {
+      // Getting option value
+      let value = this.ovc.options[currentOptionId];
+
+      // Getting current relations
+      const currentOptionParents = this.references.relations.options[
+        currentOptionId
+      ].parents;
+      const currentOptionRoot =
+        currentOptionParents[currentOptionParents.length - 1];
+      const currentOptionRootRelations = currentOptionRoot
+        ? this.references.relations.options[currentOptionId]
+        : undefined;
+
+      // Checking if current option is related to the option that changed
+      if (withRelations === true && currentOptionRootRelations) {
+        if (
+          id === currentOptionId ||
+          currentOptionRootRelations.children.options.includes(id) ||
+          currentOptionRootRelations.dependants.includes(id)
+        )
+          value = [value[index]];
+      }
+
+      data.o[currentOptionId] = value;
+    });
+
+    // Populating variables
+    dataMap.v.forEach(currentVariableId => {
+      // Getting variable data
+      const variableReference = this.references.variables[currentVariableId];
+      let value = this.ovc.variables[currentVariableId];
+      const variableParents = this.references.relations.variables[
+        currentVariableId
+      ].parents;
+      const currentOptionId = variableParents[0];
+
+      // Getting current relations
+      const currentOptionParents = this.references.relations.options[
+        currentOptionId
+      ].parents;
+      const currentOptionRoot =
+        currentOptionParents[currentOptionParents.length - 1];
+      const currentOptionRootRelations = currentOptionRoot
+        ? this.references.relations.options[currentOptionId]
+        : undefined;
+
+      // Checking if current option is related to the option that changed
+      if (withRelations === true && currentOptionRootRelations) {
+        if (
+          currentOptionRootRelations.children.options.includes(
+            currentOptionId
+          ) ||
+          currentOptionRootRelations.dependants.includes(currentOptionId)
+        ) {
+          value = [value[index]];
+        }
+      }
+
+      let dataValue: (string | number)[] = value.map(v =>
+        v === null ? "" : v
+      );
+
+      // If variable is of type number
+      if (variableReference.type === "number") {
+        dataValue = dataValue.map(v =>
+          typeof v === "number" ? v : parseFloat(v)
+        );
+      }
+
+      data.v[currentVariableId] = dataValue;
+    });
+
+    return data;
+  }
+
+  isOptionRelatedToOption(optionA: number, optionB: number): boolean {
+    // Getting B relations
+    const OptionBParents = this.references.relations.options[optionB].parents;
+    const OptionBRoot = OptionBParents[OptionBParents.length - 1];
+    const OptionBRootRelations = OptionBRoot
+      ? this.references.relations.options[OptionBRoot]
+      : undefined;
+
+    // Checking if B option is related to the option that changed
+    if (OptionBRootRelations) {
+      if (
+        optionA === optionB ||
+        OptionBRootRelations.children.options.includes(optionA) ||
+        OptionBRootRelations.dependants.includes(optionA)
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  isVariableRelatedToOption(variableId: number, optionId: number): boolean {
+    // Variable parent
+    const variableParentId = this.references.relations.variables[variableId]
+      .parents[0];
+
+    // Getting B relations
+    const optionParents = this.references.relations.options[variableParentId]
+      .parents;
+    const optionRoot = optionParents[optionParents.length - 1];
+    const optionRootRelations = optionRoot
+      ? this.references.relations.options[optionRoot]
+      : undefined;
+
+    // Checking if B option is related to the option that changed
+    if (optionRootRelations) {
+      if (
+        optionRootRelations.children.options.includes(optionId) ||
+        optionRootRelations.dependants.includes(optionId)
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  isVariableRelatedToVariable(variableA: number, variableB: number): boolean {
+    // Getting variables options
+    const optionA = this.references.relations.variables[variableA].parents[0];
+    const optionB = this.references.relations.variables[variableB].parents[0];
+
+    // Getting B relations
+    const OptionBParents = this.references.relations.options[optionB].parents;
+    const OptionBRoot = OptionBParents[OptionBParents.length - 1];
+    const OptionBRootRelations = OptionBRoot
+      ? this.references.relations.options[OptionBRoot]
+      : undefined;
+
+    // Checking if B option is related to the option that changed
+    if (OptionBRootRelations) {
+      if (
+        optionA === optionB ||
+        OptionBRootRelations.children.options.includes(optionA) ||
+        OptionBRootRelations.dependants.includes(optionA)
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  executeCondition(
+    condition: {
+      dataMap: { o: number[]; v: number[] };
+      conditions: ConditionV3;
+    },
+    id: number,
+    index: number,
+    conditionType:
+      | "options"
+      | "optionValidator"
+      | "variables"
+      | "prefillers"
+      | "variableValidator"
+      | "sections"
+      | "documents"
+  ): any {
+    if (Array.isArray(condition))
+      return condition.map(_condition =>
+        this.executeCondition(_condition, id, index, conditionType)
+      );
+
+    // Populating Data
+    let currentData;
+    if (conditionType === "options" || conditionType === "optionValidator") {
+      currentData = this.populateData(id, index, condition.dataMap);
+    } else if (
+      conditionType === "variables" ||
+      conditionType === "prefillers" ||
+      conditionType === "variableValidator"
+    ) {
+      const dataId = this.references.relations.variables[id].parents[0];
+      currentData = this.populateData(dataId, index, condition.dataMap);
+    } else if (conditionType === "sections" || conditionType === "documents") {
+      currentData = this.populateData(id, index, condition.dataMap, false);
+    }
+
+    return LpLogic(condition.conditions, currentData);
+  }
+}
+
+export default ConditionsRunner;

package/src/libs/DocumentRender.ts

@@ -0,0 +1,52 @@
+import { Types } from "@legalplace/referencesparser";
+import ConditionsRunner from "./ConditionsRunner";
+import SectionRender from "./SectionRender";
+import OVC_TYPE from "./ovc.type";
+import NumAuto from "./NumAuto";
+
+class DocumentRender {
+  references: Types.ReferencesType;
+
+  conditions: ConditionsRunner;
+
+  ovc: OVC_TYPE;
+
+  documents: Record<string, string[]> = {};
+
+  documentsNamesHash: Record<string, string> = {};
+
+  private NumAuto: NumAuto;
+
+  constructor(
+    references: Types.ReferencesType,
+    conditions: ConditionsRunner,
+    ovc: OVC_TYPE,
+    numauto: NumAuto
+  ) {
+    this.references = references;
+    this.conditions = conditions;
+    this.ovc = ovc;
+    this.NumAuto = numauto;
+  }
+
+  public renderDocument(documentName: string) {
+    const documentOutputs: string[] = [];
+    this.NumAuto.resetIndexes();
+    Object.keys(this.references.sections[documentName]).forEach(sectionId => {
+      documentOutputs.push(
+        ...new SectionRender({
+          references: this.references,
+          conditions: this.conditions,
+          documentName,
+          ovc: this.ovc,
+          currentSection: parseInt(sectionId, 10),
+          numauto: this.NumAuto
+        }).getOutputs()
+      );
+    });
+
+    return documentOutputs.join("");
+  }
+}
+
+export default DocumentRender;

package/src/libs/NumAuto.ts

@@ -0,0 +1,48 @@
+class NumAuto {
+  indexesList: Record<string, any> = {};
+
+  tagsIndex: Record<string, number> = {};
+
+  /**
+   * Increments the given index by 1 and
+   * returns the count
+   * @param index Index name
+   */
+  getNum = (index: string, tag: string | null): number => {
+    // 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];
+
+      // Otherwise we set a new index
+      this.indexesList[index] = 0;
+    }
+
+    this.indexesList[index] += 1;
+
+    if (typeof tag === "string") this.tagsIndex[tag] = this.indexesList[index];
+
+    return this.indexesList[index];
+  };
+
+  /**
+   * Returns the current count of the given index
+   * @param index Index name
+   */
+  getNumPre = (index: string): number => {
+    // 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];
+    }
+    return this.indexesList[index];
+  };
+
+  resetIndexes = () => {
+    this.indexesList = {};
+  };
+}
+
+export default NumAuto;

package/src/libs/OptionRender.ts

@@ -0,0 +1,124 @@
+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[] = [];
+
+  references: Types.ReferencesType;
+
+  index: number;
+
+  id: number;
+
+  conditions: ConditionsRunner;
+
+  ovc: OVC_TYPE;
+
+  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;
+
+    this.renderOption();
+  }
+
+  getOutputs() {
+    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"
+          );
+
+    // 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]
+            ];
+          });
+        }
+
+        // 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);
+      }
+      this.renderChildren();
+    }
+  }
+
+  private renderChildren() {
+    const option = this.references.options[this.id];
+    option.options.forEach(optionId => {
+      this.outputs = [
+        ...this.outputs,
+        ...new OptionRender({
+          references: this.references,
+          id: optionId,
+          ovc: this.ovc,
+          index: this.index,
+          conditions: this.conditions,
+          numauto: this.NumAuto
+        }).getOutputs()
+      ];
+    });
+  }
+}
+
+export default OptionRender;