@legalplace/prerenderx 2.0.1 → 2.1.1

package/.vscode/settings.json

@@ -1,17 +1,12 @@
 {
   "eslint.enable": true,
-  "eslint.autoFixOnSave": true,
   "editor.tabSize": 2,
-  "eslint.validate": [
-    "javascript",
-    {
-      "autoFix": true,
-      "language": "typescript"
-    }
-  ],
   "eslint.options": {
     "extensions": [".ts", ".js"]
   },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": true
+  },
   "files.autoSave": "off",
   "editor.formatOnSave": false,
   "editor.formatOnType": true,

package/dist/libs/InputsInitiator.d.ts

@@ -0,0 +1,21 @@
+import { Types } from "@legalplace/referencesparser";
+declare type References = Types.ReferencesType;
+declare type OVC_TYPE = {
+    options: {
+        [key: string]: boolean[];
+    };
+    variables: {
+        [key: string]: (number | string)[];
+    };
+};
+declare class IntputsInitiator {
+    private inputs;
+    private references;
+    private ovc;
+    constructor(references: References, ovc: OVC_TYPE | null);
+    getInputs(): OVC_TYPE;
+    private setMultiples;
+    private initOptionsInputs;
+    private initVariablesInputs;
+}
+export default IntputsInitiator;

package/dist/libs/InputsInitiator.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var IntputsInitiator = (function () {
+    function IntputsInitiator(references, ovc) {
+        this.inputs = {
+            options: {},
+            variables: {}
+        };
+        this.references = references;
+        this.ovc = ovc;
+        this.setMultiples();
+        this.initOptionsInputs();
+        this.initVariablesInputs();
+    }
+    IntputsInitiator.prototype.getInputs = function () {
+        return this.inputs;
+    };
+    IntputsInitiator.prototype.setMultiples = function () {
+        var _this = this;
+        if (this.ovc === null)
+            return;
+        Object.keys(this.ovc.options).forEach(function (id) {
+            if (_this.ovc === null)
+                return;
+            var inputs = _this.ovc.options[id];
+            if (inputs.length > 1) {
+                var parentsTree = _this.references.relations.options[id].parents;
+                var rootOptionId = parentsTree.length > 0 ? parentsTree[parentsTree.length - 1] : id;
+                if (!_this.ovc.options[rootOptionId]) {
+                    var rootReference = _this.references.options[rootOptionId];
+                    if (rootReference.meta.type === "static") {
+                        _this.ovc.options[rootOptionId] = new Array(inputs.length).fill(true);
+                    }
+                }
+            }
+        });
+    };
+    IntputsInitiator.prototype.initOptionsInputs = function () {
+        var optionsIds = Object.keys(this.references.options);
+        for (var i = 0; i < optionsIds.length; i += 1) {
+            var optionId = optionsIds[i];
+            var option = this.references.options[optionId];
+            var values = [false];
+            if (this.ovc &&
+                Object.prototype.hasOwnProperty.call(this.ovc.options, optionId)) {
+                values = this.ovc.options[optionId];
+            }
+            else if ([
+                "static",
+                "hidden",
+                "brut-text",
+                "repeated",
+                "box",
+                "separator"
+            ].includes(option.meta.type)) {
+                values = [true];
+            }
+            this.inputs.options[optionId] = values;
+        }
+    };
+    IntputsInitiator.prototype.initVariablesInputs = function () {
+        var variablesIds = Object.keys(this.references.variables);
+        for (var i = 0; i < variablesIds.length; i += 1) {
+            var variableId = variablesIds[i];
+            var values = [""];
+            if (this.ovc &&
+                Object.prototype.hasOwnProperty.call(this.ovc.variables, variableId)) {
+                values = this.ovc.variables[variableId];
+            }
+            else {
+                var defaultValue = "";
+                var prefillings = this.references.variables[variableId].prefillings;
+                if (prefillings &&
+                    Array.isArray(prefillings) &&
+                    prefillings.length > 0) {
+                    var noConditionsPrefills = prefillings.filter(function (prefill) {
+                        return typeof prefill.conditions === "undefined" ||
+                            Object.keys(prefill.conditions).length === 0;
+                    });
+                    defaultValue =
+                        noConditionsPrefills.length > 0
+                            ? noConditionsPrefills[0].value
+                            : "";
+                }
+                values = [defaultValue];
+            }
+            this.inputs.variables[variableId] = values;
+        }
+    };
+    return IntputsInitiator;
+}());
+exports.default = IntputsInitiator;

package/dist/libs/OvcConverter.d.ts

@@ -0,0 +1,19 @@
+import OVC_TYPE from "./ovc.type";
+export interface OldOVC {
+    o: {
+        [k: string]: string | number | (string | number)[];
+    };
+    v: {
+        [k: string]: string | number | (string | number)[];
+    };
+    c: {
+        [k: string]: boolean | boolean[];
+    };
+}
+declare class OvcConverter {
+    convertToOptionsVariables(ovc: OldOVC): OVC_TYPE;
+    isOvc(_obj: OVC_TYPE | OldOVC): _obj is OldOVC;
+    isOptionsVariables(_obj: OVC_TYPE | OldOVC): boolean;
+}
+declare const _default: OvcConverter;
+export default _default;

package/dist/libs/OvcConverter.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var OvcConverter = (function () {
+    function OvcConverter() {
+    }
+    OvcConverter.prototype.convertToOptionsVariables = function (ovc) {
+        var inputs = {
+            options: {},
+            variables: {}
+        };
+        if (typeof ovc !== "object")
+            return inputs;
+        if (typeof ovc.o === "object") {
+            Object.keys(ovc.o).forEach(function (id) {
+                var currentOption = ovc.o[id];
+                if (Array.isArray(currentOption)) {
+                    var occurences_1 = currentOption.length;
+                    currentOption.forEach(function (childId, index) {
+                        if (typeof childId === "string" && childId.trim().length === 0)
+                            return;
+                        if (!Object.prototype.hasOwnProperty.call(inputs.options, childId)) {
+                            inputs.options[childId] = new Array(occurences_1).fill(false);
+                        }
+                        inputs.options[childId][index] = true;
+                    });
+                }
+                else {
+                    if (typeof currentOption === "string" &&
+                        currentOption.trim().length === 0)
+                        return;
+                    inputs.options[currentOption] = [true];
+                }
+            });
+        }
+        if (typeof ovc.v === "object") {
+            Object.keys(ovc.v).forEach(function (id) {
+                var currentVariable = ovc.v[id];
+                if (Array.isArray(currentVariable)) {
+                    inputs.variables[id] = currentVariable;
+                }
+                else {
+                    inputs.variables[id] = [currentVariable];
+                }
+            });
+        }
+        if (typeof ovc.c === "object") {
+            Object.keys(ovc.c).forEach(function (id) {
+                var currentCheckbox = ovc.c[id];
+                if (typeof id === "string" && id.trim().length === 0)
+                    return;
+                if (Array.isArray(currentCheckbox)) {
+                    inputs.options[id] = currentCheckbox;
+                }
+                else {
+                    inputs.options[id] = [currentCheckbox];
+                }
+            });
+        }
+        return inputs;
+    };
+    OvcConverter.prototype.isOvc = function (_obj) {
+        if (typeof _obj !== "object" || _obj === null)
+            return false;
+        var ovcKeys = ["o", "v", "c"];
+        var foundKeys = Object.keys(_obj)
+            .map(function (key) { return (ovcKeys.includes(key) ? 1 : 0); })
+            .reduce(function (a, b) { return a + b; }, 0);
+        return foundKeys > 1;
+    };
+    OvcConverter.prototype.isOptionsVariables = function (_obj) {
+        if (typeof _obj !== "object" || _obj === null)
+            return false;
+        var optionsVariablesKeys = ["options", "variables"];
+        var foundKeys = Object.keys(_obj)
+            .map(function (key) { return (optionsVariablesKeys.includes(key) ? 1 : 0); })
+            .reduce(function (a, b) { return a + b; }, 0);
+        return foundKeys === 2;
+    };
+    return OvcConverter;
+}());
+exports.default = new OvcConverter();

package/dist/libs/Prerender.d.ts

@@ -1,5 +1,6 @@
 import { ModelV3 } from "@legalplace/models-v3-types";
 import OVC_TYPE from "./ovc.type";
+import { OldOVC } from "./OvcConverter";
 declare class Prerender {
     private model;
     private references;
@@ -9,7 +10,7 @@ declare class Prerender {
     private NumAuto;
     private documentsIndex;
     private renderedDocuments;
-    constructor(model: ModelV3, ovc: OVC_TYPE);
+    constructor(model: ModelV3, ovc: OVC_TYPE | OldOVC);
     getDocumentsIndex(): Record<string, {
         name: string;
         pdf: boolean;

package/dist/libs/Prerender.js

@@ -7,17 +7,22 @@ var referencesparser_1 = require("@legalplace/referencesparser");
 var crypto_1 = __importDefault(require("crypto"));
 var DocumentRender_1 = __importDefault(require("./DocumentRender"));
 var ConditionsRunner_1 = __importDefault(require("./ConditionsRunner"));
+var OvcConverter_1 = __importDefault(require("./OvcConverter"));
 var NumAuto_1 = __importDefault(require("./NumAuto"));
+var InputsInitiator_1 = __importDefault(require("./InputsInitiator"));
 var Prerender = (function () {
     function Prerender(model, ovc) {
         this.documentsIndex = {};
         this.renderedDocuments = {};
         this.model = model;
-        this.ovc = ovc;
+        this.ovc = OvcConverter_1.default.isOvc(ovc)
+            ? OvcConverter_1.default.convertToOptionsVariables(ovc)
+            : ovc;
         this.NumAuto = new NumAuto_1.default();
         this.references = new referencesparser_1.ReferencesParser(model).getReferences();
-        this.conditions = new ConditionsRunner_1.default(this.references, this.ovc);
-        this.documentRender = new DocumentRender_1.default(this.references, this.conditions, this.ovc, this.NumAuto);
+        var inputs = new InputsInitiator_1.default(this.references, this.ovc).getInputs();
+        this.conditions = new ConditionsRunner_1.default(this.references, inputs);
+        this.documentRender = new DocumentRender_1.default(this.references, this.conditions, inputs, this.NumAuto);
         this.generateDocumentNamesHash();
         this.generateAllDocuments();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/prerenderx",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "PrerenderX",
   "main": "dist/index.js",
   "repository": "https://git.legalplace.eu/legalplace/prerenderx",

package/src/libs/InputsInitiator.ts

@@ -0,0 +1,146 @@
+import { Types } from "@legalplace/referencesparser";
+
+type References = Types.ReferencesType;
+
+type OVC_TYPE = {
+  options: {
+    [key: string]: boolean[];
+  };
+  variables: {
+    [key: string]: (number | string)[];
+  };
+};
+
+class IntputsInitiator {
+  private inputs: OVC_TYPE = {
+    options: {},
+    variables: {}
+  };
+
+  private references: References;
+
+  private ovc: OVC_TYPE | null;
+
+  /**
+   * InitalConditions Constructor
+   * @param references References object
+   */
+  constructor(references: References, ovc: OVC_TYPE | null) {
+    this.references = references;
+    this.ovc = ovc;
+
+    // Setting multiples
+    this.setMultiples();
+
+    // Initiating inputs
+    this.initOptionsInputs();
+    this.initVariablesInputs();
+  }
+
+  public getInputs() {
+    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 (inputs.length > 1) {
+        // Getting parents
+        const parentsTree = this.references.relations.options[id].parents;
+
+        // root parent
+        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
+            );
+          }
+        }
+      }
+    });
+  }
+
+  /**
+   * Initates options inputs
+   */
+  private initOptionsInputs() {
+    // 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)
+      ) {
+        values = this.ovc.options[optionId];
+      } else if (
+        [
+          "static",
+          "hidden",
+          "brut-text",
+          "repeated",
+          "box",
+          "separator"
+        ].includes(option.meta.type)
+      ) {
+        values = [true];
+      }
+
+      this.inputs.options[optionId] = values;
+    }
+  }
+
+  /**
+   * Initates variables inputs
+   */
+  private initVariablesInputs() {
+    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];
+      } else {
+        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
+              : "";
+        }
+        values = [defaultValue];
+      }
+
+      this.inputs.variables[variableId] = values;
+    }
+  }
+}
+
+export default IntputsInitiator;

package/src/libs/OvcConverter.ts

@@ -0,0 +1,107 @@
+import OVC_TYPE from "./ovc.type";
+
+export interface OldOVC {
+  o: {
+    [k: string]: string | number | (string | number)[];
+  };
+  v: {
+    [k: string]: string | number | (string | number)[];
+  };
+  c: {
+    [k: string]: boolean | boolean[];
+  };
+}
+
+class OvcConverter {
+  public convertToOptionsVariables(ovc: OldOVC) {
+    const inputs: OVC_TYPE = {
+      options: {},
+      variables: {}
+    };
+
+    if (typeof ovc !== "object") return inputs;
+
+    // Reading options
+    if (typeof ovc.o === "object") {
+      Object.keys(ovc.o).forEach(id => {
+        const currentOption = ovc.o[id];
+
+        // If it's a multiple
+        if (Array.isArray(currentOption)) {
+          const occurences = currentOption.length;
+          currentOption.forEach((childId, index) => {
+            if (typeof childId === "string" && childId.trim().length === 0)
+              return;
+
+            // Creating input if it doesn't exist
+            if (
+              !Object.prototype.hasOwnProperty.call(inputs.options, childId)
+            ) {
+              inputs.options[childId] = new Array(occurences).fill(false);
+            }
+
+            // Setting current index to true
+            inputs.options[childId][index] = true;
+          });
+        } else {
+          if (
+            typeof currentOption === "string" &&
+            currentOption.trim().length === 0
+          )
+            return;
+          inputs.options[currentOption] = [true];
+        }
+      });
+    }
+
+    // Reading variables
+    if (typeof ovc.v === "object") {
+      Object.keys(ovc.v).forEach(id => {
+        const currentVariable = ovc.v[id];
+
+        // If it's a multiple
+        if (Array.isArray(currentVariable)) {
+          inputs.variables[id] = currentVariable;
+        } else {
+          inputs.variables[id] = [currentVariable];
+        }
+      });
+    }
+
+    // Reading checkboxes
+    if (typeof ovc.c === "object") {
+      Object.keys(ovc.c).forEach(id => {
+        const currentCheckbox = ovc.c[id];
+        if (typeof id === "string" && id.trim().length === 0) return;
+        // If it's a multiple
+        if (Array.isArray(currentCheckbox)) {
+          inputs.options[id] = currentCheckbox;
+        } else {
+          inputs.options[id] = [currentCheckbox];
+        }
+      });
+    }
+
+    return inputs;
+  }
+
+  public isOvc(_obj: OVC_TYPE | OldOVC): _obj is OldOVC {
+    if (typeof _obj !== "object" || _obj === null) return false;
+    const ovcKeys = ["o", "v", "c"];
+    const foundKeys = Object.keys(_obj)
+      .map((key): number => (ovcKeys.includes(key) ? 1 : 0))
+      .reduce((a, b) => a + b, 0);
+    return foundKeys > 1;
+  }
+
+  public isOptionsVariables(_obj: OVC_TYPE | OldOVC) {
+    if (typeof _obj !== "object" || _obj === null) return false;
+    const optionsVariablesKeys = ["options", "variables"];
+    const foundKeys = Object.keys(_obj)
+      .map((key): number => (optionsVariablesKeys.includes(key) ? 1 : 0))
+      .reduce((a, b) => a + b, 0);
+    return foundKeys === 2;
+  }
+}
+
+export default new OvcConverter();

package/src/libs/Prerender.ts

@@ -4,7 +4,9 @@ import crypto from "crypto";
 import DocumentRender from "./DocumentRender";
 import ConditionsRunner from "./ConditionsRunner";
 import OVC_TYPE from "./ovc.type";
+import OvcConverter, { OldOVC } from "./OvcConverter";
 import NumAuto from "./NumAuto";
+import IntputsInitiator from "./InputsInitiator";
 
 class Prerender {
   private model: ModelV3;
@@ -30,22 +32,31 @@ class Prerender {
 
   private renderedDocuments: Record<string, string> = {};
 
-  constructor(model: ModelV3, ovc: OVC_TYPE) {
+  constructor(model: ModelV3, ovc: OVC_TYPE | OldOVC) {
     this.model = model;
-    this.ovc = ovc;
+
+    // Converting OVC if needed
+    this.ovc = OvcConverter.isOvc(ovc)
+      ? OvcConverter.convertToOptionsVariables(ovc)
+      : ovc;
+
+    // Initiating num auto
     this.NumAuto = new NumAuto();
 
-    // @ts-ignore
+    // Parsing references
     this.references = new ReferencesParser(model).getReferences();
 
+    // Initiating inputs
+    const inputs = new IntputsInitiator(this.references, this.ovc).getInputs();
+
     // Initiating ConditionsRunner
-    this.conditions = new ConditionsRunner(this.references, this.ovc);
+    this.conditions = new ConditionsRunner(this.references, inputs);
 
     // Rendering documents
     this.documentRender = new DocumentRender(
       this.references,
       this.conditions,
-      this.ovc,
+      inputs,
       this.NumAuto
     );