@legalplace/prerenderx 2.2.5 → 2.3.0

package/README.md

@@ -14,7 +14,55 @@ const ovc = {options: {}, variables: {}}; // Your OVC
 
 const prerender = new Prerender(modelV3, ovc);
 
-const documents = prerender.getDocuments();
+// Getting documents index
+const documentsIndex = prerender.getDocumentsIndex();
+
+// Getting all documents
+const documents = Object.keys(documentsIndexes).map((hash) => prerender.getDocument(hash))
+```
+
+# Return formats
+*Prerender.getDocument* returns two different types:
+
+* In case document is an output it returns a *plaintext*
+* In case document is a pdf form it returns an object with this definition:
+```
+{
+  id: string
+  inputs: {
+    // Key is input's id
+    // Value is input's value
+    [key: string]: string 
+  }
+  boxes: {
+    // Key is box's id
+    // Value is box's value
+    [key: string]: string 
+  }
+}
+```
+
+# How to determine whether a document is an output or a pdf form
+*Note*
+* Outputs should be sent to the worker to generate DOCX & PDF files
+* Pdf forms should be filled with pdfjson and the original pdf
+
+```javascript
+import { Prerender } from 'prerenderx';
+
+const model = {}; // Your v3 (non final) model
+const ovc = {options: {}, variables: {}}; // Your OVC
+
+const prerender = new Prerender(modelV3, ovc);
+
+// Getting documents index
+const documentsIndex = prerender.getDocumentsIndex();
+
+// Extracting PDF Forms documents only
+const pdfFormsDocuments = documentsIndex.filter((documentDescription) => Prerender.isPdfForm(documentDescription))
+
+// Extracting outputs documents only
+const outputDocuments = documentsIndex.filter((documentDescription) => Prerender.isOutput(documentDescription))
 ```
 
 Variable `documents` will now contain an object containing all documents and their respective outputs

package/dist/libs/DocumentRender.d.ts

@@ -6,8 +6,6 @@ declare class DocumentRender {
     references: Types.ReferencesType;
     conditions: ConditionsRunner;
     ovc: OVC_TYPE;
-    documents: Record<string, string[]>;
-    documentsNamesHash: Record<string, string>;
     private NumAuto;
     constructor(references: Types.ReferencesType, conditions: ConditionsRunner, ovc: OVC_TYPE, numauto: NumAuto);
     renderDocument(documentName: string): string;

package/dist/libs/DocumentRender.js

@@ -6,8 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var SectionRender_1 = __importDefault(require("./SectionRender"));
 var DocumentRender = (function () {
     function DocumentRender(references, conditions, ovc, numauto) {
-        this.documents = {};
-        this.documentsNamesHash = {};
         this.references = references;
         this.conditions = conditions;
         this.ovc = ovc;

package/dist/libs/FillPdfForm.d.ts

@@ -0,0 +1,13 @@
+import FillPdfFormBase from './misc/FillPdfFormBase';
+declare class FillPdfForm extends FillPdfFormBase {
+    fillDocument(documentName: string): {
+        id: string;
+        inputs: Record<string, string>;
+        boxes: Record<string, string>;
+    };
+    private getInputValue;
+    private getBoxValue;
+    private getVariableValue;
+    private getOptionValue;
+}
+export default FillPdfForm;

package/dist/libs/FillPdfForm.js

@@ -0,0 +1,120 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var FillPdfFormBase_1 = __importDefault(require("./misc/FillPdfFormBase"));
+var FillPdfForm = (function (_super) {
+    __extends(FillPdfForm, _super);
+    function FillPdfForm() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    FillPdfForm.prototype.fillDocument = function (documentName) {
+        var _this = this;
+        var result = {
+            id: '',
+            inputs: {},
+            boxes: {}
+        };
+        var document = this.references.documents[documentName];
+        var pdf = document.pdf;
+        if (typeof pdf === 'undefined')
+            return result;
+        var form = pdf.form;
+        result.id = pdf.id;
+        form.inputs.forEach(function (input) {
+            var id = "Page" + input.page + "[0]." + input.name;
+            result.inputs[id] = _this.getInputValue(input);
+        });
+        form.boxes.forEach(function (box) {
+            var id = "Page" + box.page + "[0]." + box.name;
+            result.boxes[id] = _this.getBoxValue(box);
+        });
+        return result;
+    };
+    FillPdfForm.prototype.getInputValue = function (input) {
+        for (var i = 0; i < input.variables.length; i += 1) {
+            var variable = input.variables[i];
+            var currentValue = this.getVariableValue(variable.id);
+            if (currentValue !== false) {
+                var dateRegex = /^([0-9]{2})\/([0-9]{2})\/([0-9]{4})$/;
+                console.log('Value for', variable.id, currentValue, dateRegex.test(currentValue));
+                if (variable.date && dateRegex.test(currentValue)) {
+                    switch (variable.date) {
+                        case 'DD':
+                            console.log('Value s', variable.id, input.name, currentValue.replace(dateRegex, '$1'), dateRegex.test(currentValue));
+                            return currentValue.replace(dateRegex, '$1');
+                        case 'MM':
+                            return currentValue.replace(dateRegex, '$2');
+                        case 'YYYY':
+                            return currentValue.replace(dateRegex, '$3');
+                        default:
+                    }
+                }
+                var 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');
+                        default:
+                    }
+                }
+                var emailRegex = /^(.*)@(.*)$/;
+                if (variable.email && emailRegex.test(currentValue)) {
+                    switch (variable.email) {
+                        case 'ADDRESS':
+                            return currentValue.split('@')[0];
+                        case 'PROVIDER':
+                            return currentValue.split('@')[1];
+                        default:
+                    }
+                }
+                if (variable.fragment && typeof variable.fragment.from === 'number' && typeof variable.fragment.to === 'number') {
+                    var _a = variable.fragment, from = _a.from, to = _a.to;
+                    return currentValue.slice(from, to);
+                }
+                return currentValue;
+            }
+        }
+        return '';
+    };
+    FillPdfForm.prototype.getBoxValue = function (box) {
+        for (var i = 0; i < box.options.length; i += 1) {
+            var option = box.options[i];
+            var currentValue = this.getOptionValue(option.id);
+            if (currentValue === true) {
+                return box.value;
+            }
+        }
+        return '';
+    };
+    FillPdfForm.prototype.getVariableValue = function (variableId) {
+        var _a;
+        if (this.isVariableDisplayed(variableId, 0) === false)
+            return false;
+        return (((_a = this.ovc.variables[variableId]) === null || _a === void 0 ? void 0 : _a[0]) || '').toString();
+    };
+    FillPdfForm.prototype.getOptionValue = function (optionId) {
+        var _a;
+        if (this.isOptionDisplayed(optionId, 0) === false)
+            return false;
+        return ((_a = this.ovc.options[optionId]) === null || _a === void 0 ? void 0 : _a[0]) === true;
+    };
+    return FillPdfForm;
+}(FillPdfFormBase_1.default));
+exports.default = FillPdfForm;

package/dist/libs/Prerender.d.ts

@@ -1,23 +1,35 @@
 import { ModelV3 } from '@legalplace/models-v3-types';
 import OVC_TYPE from './ovc.type';
 import { OldOVC } from './OvcConverter';
+declare type DocumentOutputIndex = {
+    name: string;
+    pdf: boolean;
+    docx: boolean;
+};
+declare type DocumentPdfFormIndex = {
+    name: string;
+    form: boolean;
+};
+declare type FDFType = {
+    inputs: Record<string, string>;
+    boxes: Record<string, string>;
+};
 declare class Prerender {
     private model;
     private references;
     private ovc;
     private conditions;
     private documentRender;
+    private pdfFiller;
     private NumAuto;
     private documentsIndex;
     private renderedDocuments;
     constructor(model: ModelV3, ovc: OVC_TYPE | OldOVC);
-    getDocumentsIndex(): Record<string, {
-        name: string;
-        pdf: boolean;
-        docx: boolean;
-    }>;
+    getDocumentsIndex(): Record<string, DocumentOutputIndex | DocumentPdfFormIndex>;
+    getDocument(documentNameHash: string): string | FDFType;
     private generateDocumentNamesHash;
     private generateAllDocuments;
-    getDocument(documentNameHash: string): string;
+    static isPdfForm(index: DocumentOutputIndex | DocumentPdfFormIndex): index is DocumentPdfFormIndex;
+    static isOutput(index: DocumentOutputIndex | DocumentPdfFormIndex): index is DocumentOutputIndex;
 }
 export default Prerender;

package/dist/libs/Prerender.js

@@ -10,6 +10,7 @@ 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 FillPdfForm_1 = __importDefault(require("./FillPdfForm"));
 var Prerender = (function () {
     function Prerender(model, ovc) {
         this.documentsIndex = {};
@@ -21,15 +22,22 @@ var Prerender = (function () {
         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.pdfFiller = new FillPdfForm_1.default(this.references, this.conditions, inputs);
         this.generateDocumentNamesHash();
         this.generateAllDocuments();
     }
     Prerender.prototype.getDocumentsIndex = function () {
         return this.documentsIndex;
     };
+    Prerender.prototype.getDocument = function (documentNameHash) {
+        return this.renderedDocuments[documentNameHash];
+    };
     Prerender.prototype.generateDocumentNamesHash = function () {
         var _this = this;
         Object.keys(this.model.documents).forEach(function (documentName) {
+            var _a, _b;
+            var document = _this.model.documents[documentName];
+            var documentParams = _this.model.documents[documentName].params;
             var conditionObject = _this.references.conditions.documents[documentName];
             var condition = conditionObject === undefined ? true : _this.conditions.executeCondition(conditionObject, 0, 0, 'documents');
             if (condition === true) {
@@ -37,22 +45,39 @@ var Prerender = (function () {
                     .createHash('sha1')
                     .update(documentName)
                     .digest('hex');
-                _this.documentsIndex[hash] = {
-                    name: documentName,
-                    pdf: true,
-                    docx: true
-                };
+                if (typeof document.pdf === 'object' && typeof document.pdf.id === 'string' && typeof document.pdf.form === 'object') {
+                    _this.documentsIndex[hash] = {
+                        name: documentName,
+                        form: true
+                    };
+                }
+                else {
+                    _this.documentsIndex[hash] = {
+                        name: documentName,
+                        pdf: ((_a = documentParams === null || documentParams === void 0 ? void 0 : documentParams.formats) === null || _a === void 0 ? void 0 : _a.pdf) === undefined ? true : documentParams.formats.pdf,
+                        docx: ((_b = documentParams === null || documentParams === void 0 ? void 0 : documentParams.formats) === null || _b === void 0 ? void 0 : _b.docx) === undefined ? true : documentParams.formats.docx
+                    };
+                }
             }
         });
     };
     Prerender.prototype.generateAllDocuments = function () {
         var _this = this;
         Object.keys(this.documentsIndex).forEach(function (documentNameHash) {
-            _this.renderedDocuments[documentNameHash] = _this.documentRender.renderDocument(_this.documentsIndex[documentNameHash].name);
+            var index = _this.documentsIndex[documentNameHash];
+            if (Prerender.isPdfForm(index)) {
+                _this.renderedDocuments[documentNameHash] = _this.pdfFiller.fillDocument(_this.documentsIndex[documentNameHash].name);
+            }
+            else {
+                _this.renderedDocuments[documentNameHash] = _this.documentRender.renderDocument(_this.documentsIndex[documentNameHash].name);
+            }
         });
     };
-    Prerender.prototype.getDocument = function (documentNameHash) {
-        return this.renderedDocuments[documentNameHash];
+    Prerender.isPdfForm = function (index) {
+        return Object.prototype.hasOwnProperty.call(index, 'form');
+    };
+    Prerender.isOutput = function (index) {
+        return !Object.prototype.hasOwnProperty.call(index, 'form');
     };
     return Prerender;
 }());

package/dist/libs/misc/FillPdfFormBase.d.ts

@@ -0,0 +1,16 @@
+import { Types } from '@legalplace/referencesparser';
+import ConditionsRunner from '../ConditionsRunner';
+import OVC_TYPE from '../ovc.type';
+declare class FillPdfFormBase {
+    references: Types.ReferencesType;
+    conditions: ConditionsRunner;
+    ovc: OVC_TYPE;
+    constructor(references: Types.ReferencesType, conditions: ConditionsRunner, ovc: OVC_TYPE);
+    isVariableDisplayed(id: number, index: number): boolean;
+    isOptionDisplayed(id: number, index: number): boolean;
+    private getVariableCondition;
+    private getOptionCondition;
+    private getSectionCondition;
+    private getOptionParentSection;
+}
+export default FillPdfFormBase;

package/dist/libs/misc/FillPdfFormBase.js

@@ -0,0 +1,62 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var FillPdfFormBase = (function () {
+    function FillPdfFormBase(references, conditions, ovc) {
+        this.references = references;
+        this.conditions = conditions;
+        this.ovc = ovc;
+    }
+    FillPdfFormBase.prototype.isVariableDisplayed = function (id, index) {
+        var _a;
+        var variableCondition = this.getVariableCondition(id, index);
+        var variableParents = ((_a = this.references.relations.variables[id]) === null || _a === void 0 ? void 0 : _a.parents) || [];
+        var parentOptionIsDisplayed = this.isOptionDisplayed(variableParents[0], index);
+        return [variableCondition, parentOptionIsDisplayed].filter(function (c) { return c !== true; }).length === 0;
+    };
+    FillPdfFormBase.prototype.isOptionDisplayed = function (id, index) {
+        var _this = this;
+        var _a;
+        var optionCondition = this.getOptionCondition(id, index);
+        var optionParents = ((_a = this.references.relations.options[id]) === null || _a === void 0 ? void 0 : _a.parents) || [];
+        var parentsConditions = optionParents.map(function (optionId) {
+            return _this.getOptionCondition(optionId, index) !== false;
+        });
+        var parentsInputs = optionParents.map(function (optionId) {
+            return _this.ovc.options[optionId][index];
+        });
+        var parentSectionId = this.getOptionParentSection(id);
+        var parentSectionCondition = this.getSectionCondition(parentSectionId) !== false;
+        return __spreadArrays([optionCondition, parentSectionCondition], parentsConditions, parentsInputs).filter(function (c) { return c !== true; }).length === 0;
+    };
+    FillPdfFormBase.prototype.getVariableCondition = function (id, index) {
+        var conditionObject = this.references.conditions.variables[id];
+        return conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, id, index, 'variables');
+    };
+    FillPdfFormBase.prototype.getOptionCondition = function (id, index) {
+        var conditionObject = this.references.conditions.options[id];
+        return conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, id, index, 'options');
+    };
+    FillPdfFormBase.prototype.getSectionCondition = function (id) {
+        var conditionObject = this.references.conditions.sections.main[id];
+        return conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, id, 0, 'sections');
+    };
+    FillPdfFormBase.prototype.getOptionParentSection = function (id) {
+        var parents = this.references.relations.options[id].parents;
+        var rootId = parents.length > 0 ? parents[parents.length - 1] : id;
+        var sections = Object.values(this.references.sections.main);
+        for (var i = 0; i < sections.length; i += 1) {
+            if (sections[i].options.includes(rootId))
+                return sections[i].id;
+        }
+        throw new Error("Cannot find parent section for option " + id + " (Root option id: " + rootId + ")");
+    };
+    return FillPdfFormBase;
+}());
+exports.default = FillPdfFormBase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/prerenderx",
-  "version": "2.2.5",
+  "version": "2.3.0",
   "description": "PrerenderX",
   "main": "dist/index.js",
   "repository": "https://git.legalplace.eu/legalplace/prerenderx",
@@ -15,8 +15,8 @@
   },
   "dependencies": {
     "@legalplace/lplogic": "^2.0.0",
-    "@legalplace/models-v3-types": "^3.1.1",
-    "@legalplace/referencesparser": "^1.2.0",
+    "@legalplace/models-v3-types": "^3.4.47",
+    "@legalplace/referencesparser": "^1.4.1",
     "crypto": "^1.0.1",
     "typescript": "3.9.3"
   },

package/src/libs/DocumentRender.ts

@@ -11,10 +11,6 @@ class DocumentRender {
 
   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) {

package/src/libs/FillPdfForm.ts

@@ -0,0 +1,144 @@
+import { FDFBoxesV3, FDFInputsV3 } from '@legalplace/models-v3-types'
+import FillPdfFormBase from './misc/FillPdfFormBase'
+
+class FillPdfForm extends FillPdfFormBase {
+  public fillDocument(documentName: string) {
+    const result: {
+      id: string
+      inputs: Record<string, string>
+      boxes: Record<string, string>
+    } = {
+      id: '',
+      inputs: {},
+      boxes: {}
+    }
+
+    // Getting document
+    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
+
+    // Filling inputs
+    form.inputs.forEach(input => {
+      const id = `Page${input.page}[0].${input.name}`
+      result.inputs[id] = this.getInputValue(input)
+    })
+
+    // Filling boxes
+    form.boxes.forEach(box => {
+      const id = `Page${box.page}[0].${box.name}`
+      result.boxes[id] = this.getBoxValue(box)
+    })
+
+    return result
+  }
+
+  /**
+   * Returns an input value
+   * @param input Input
+   */
+  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)
+
+      if (currentValue !== false) {
+        // Date values
+        const dateRegex = /^([0-9]{2})\/([0-9]{2})\/([0-9]{4})$/
+        console.log('Value for', variable.id, currentValue, dateRegex.test(currentValue))
+        if (variable.date && dateRegex.test(currentValue)) {
+          switch (variable.date) {
+            case 'DD':
+              console.log('Value s', variable.id, input.name, currentValue.replace(dateRegex, '$1'), dateRegex.test(currentValue))
+              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})$/
+        if (variable.hour && hourRegex.test(currentValue)) {
+          switch (variable.hour) {
+            case 'HH':
+              return currentValue.replace(hourRegex, '$1')
+            case 'MM':
+              return currentValue.replace(hourRegex, '$2')
+            default:
+          }
+        }
+
+        // Email values
+        const emailRegex = /^(.*)@(.*)$/
+        if (variable.email && emailRegex.test(currentValue)) {
+          switch (variable.email) {
+            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)
+        }
+
+        // Return value
+        return currentValue
+      }
+    }
+
+    return ''
+  }
+
+  /**
+   * Return a box value
+   * @param box Box
+   */
+  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)
+
+      if (currentValue === true) {
+        return box.value
+      }
+    }
+
+    return ''
+  }
+
+  /**
+   * Returns a variable's value
+   */
+  private getVariableValue(variableId: number) {
+    // Checking if variable is displayed
+    if (this.isVariableDisplayed(variableId, 0) === false) return false
+
+    // Returning variable's value
+    return (this.ovc.variables[variableId]?.[0] || '').toString()
+  }
+
+  /**
+   * Returns a option's value
+   */
+  private getOptionValue(optionId: number) {
+    // Checking if option is displayed
+    if (this.isOptionDisplayed(optionId, 0) === false) return false
+
+    // Returning option's value
+    return this.ovc.options[optionId]?.[0] === true
+  }
+}
+
+export default FillPdfForm

package/src/libs/Prerender.ts

@@ -7,6 +7,24 @@ import OVC_TYPE from './ovc.type'
 import OvcConverter, { OldOVC } from './OvcConverter'
 import NumAuto from './NumAuto'
 import IntputsInitiator from './InputsInitiator'
+import FillPdfForm from './FillPdfForm'
+
+type DocumentOutputIndex = {
+  name: string
+  pdf: boolean
+  docx: boolean
+}
+type DocumentPdfFormIndex = {
+  name: string
+  form: boolean
+}
+
+type DocumentIndex = Record<string, DocumentOutputIndex | DocumentPdfFormIndex>
+
+type FDFType = {
+  inputs: Record<string, string>
+  boxes: Record<string, string>
+}
 
 class Prerender {
   private model: ModelV3
@@ -19,18 +37,13 @@ class Prerender {
 
   private documentRender: DocumentRender
 
+  private pdfFiller: FillPdfForm
+
   private NumAuto: NumAuto
 
-  private documentsIndex: Record<
-    string,
-    {
-      name: string
-      pdf: boolean
-      docx: boolean
-    }
-  > = {}
+  private documentsIndex: DocumentIndex = {}
 
-  private renderedDocuments: Record<string, string> = {}
+  private renderedDocuments: Record<string, string | FDFType> = {}
 
   constructor(model: ModelV3, ovc: OVC_TYPE | OldOVC) {
     this.model = model
@@ -53,6 +66,9 @@ class Prerender {
     // Rendering documents
     this.documentRender = new DocumentRender(this.references, this.conditions, inputs, this.NumAuto)
 
+    // Filling pdf documents
+    this.pdfFiller = new FillPdfForm(this.references, this.conditions, inputs)
+
     this.generateDocumentNamesHash()
     this.generateAllDocuments()
   }
@@ -61,8 +77,14 @@ class Prerender {
     return this.documentsIndex
   }
 
+  public getDocument(documentNameHash: string) {
+    return this.renderedDocuments[documentNameHash]
+  }
+
   private generateDocumentNamesHash() {
     Object.keys(this.model.documents).forEach(documentName => {
+      const document = this.model.documents[documentName]
+      const documentParams = this.model.documents[documentName].params
       const conditionObject = this.references.conditions.documents[documentName]
       const condition = conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, 0, 0, 'documents')
 
@@ -74,10 +96,17 @@ class Prerender {
           .digest('hex')
 
         // Referencing in index
-        this.documentsIndex[hash] = {
-          name: documentName,
-          pdf: true,
-          docx: true
+        if (typeof document.pdf === 'object' && typeof document.pdf.id === 'string' && typeof document.pdf.form === 'object') {
+          this.documentsIndex[hash] = {
+            name: documentName,
+            form: true
+          }
+        } else {
+          this.documentsIndex[hash] = {
+            name: documentName,
+            pdf: documentParams?.formats?.pdf === undefined ? true : documentParams.formats.pdf,
+            docx: documentParams?.formats?.docx === undefined ? true : documentParams.formats.docx
+          }
         }
       }
     })
@@ -85,12 +114,21 @@ class Prerender {
 
   private generateAllDocuments() {
     Object.keys(this.documentsIndex).forEach(documentNameHash => {
-      this.renderedDocuments[documentNameHash] = this.documentRender.renderDocument(this.documentsIndex[documentNameHash].name)
+      const index = this.documentsIndex[documentNameHash]
+      if (Prerender.isPdfForm(index)) {
+        this.renderedDocuments[documentNameHash] = this.pdfFiller.fillDocument(this.documentsIndex[documentNameHash].name)
+      } else {
+        this.renderedDocuments[documentNameHash] = this.documentRender.renderDocument(this.documentsIndex[documentNameHash].name)
+      }
     })
   }
 
-  public getDocument(documentNameHash: string) {
-    return this.renderedDocuments[documentNameHash]
+  static isPdfForm(index: DocumentOutputIndex | DocumentPdfFormIndex): index is DocumentPdfFormIndex {
+    return Object.prototype.hasOwnProperty.call(index, 'form')
+  }
+
+  static isOutput(index: DocumentOutputIndex | DocumentPdfFormIndex): index is DocumentOutputIndex {
+    return !Object.prototype.hasOwnProperty.call(index, 'form')
   }
 }
 

package/src/libs/misc/FillPdfFormBase.ts

@@ -0,0 +1,103 @@
+import { Types } from '@legalplace/referencesparser'
+import ConditionsRunner from '../ConditionsRunner'
+import OVC_TYPE from '../ovc.type'
+
+class FillPdfFormBase {
+  references: Types.ReferencesType
+
+  conditions: ConditionsRunner
+
+  ovc: OVC_TYPE
+
+  constructor(references: Types.ReferencesType, conditions: ConditionsRunner, ovc: OVC_TYPE) {
+    this.references = references
+    this.conditions = conditions
+    this.ovc = ovc
+  }
+
+  /**
+   * Checks whether a variable is displayed at a given index
+   * @param id Variable's ID
+   * @param index Index
+   */
+  isVariableDisplayed(id: number, index: number) {
+    // Getting variable's conditions & executing it if any
+    const variableCondition = this.getVariableCondition(id, index)
+    const variableParents = this.references.relations.variables[id]?.parents || []
+    const parentOptionIsDisplayed = this.isOptionDisplayed(variableParents[0], index)
+
+    return [variableCondition, parentOptionIsDisplayed].filter(c => c !== true).length === 0
+  }
+
+  /**
+   * Checks whether an option is displayed at a given index
+   * @param id Option's ID
+   * @param index Index
+   */
+  isOptionDisplayed(id: number, index: number) {
+    // Getting variable's conditions & executing it if any
+    const optionCondition = this.getOptionCondition(id, index)
+    const optionParents = this.references.relations.options[id]?.parents || []
+    const parentsConditions = optionParents.map(optionId => {
+      return this.getOptionCondition(optionId, index) !== false
+    })
+    const parentsInputs = optionParents.map(optionId => {
+      return this.ovc.options[optionId][index]
+    })
+    const parentSectionId = this.getOptionParentSection(id)
+    const parentSectionCondition = this.getSectionCondition(parentSectionId) !== false
+
+    return [optionCondition, parentSectionCondition, ...parentsConditions, ...parentsInputs].filter(c => c !== true).length === 0
+  }
+
+  /**
+   * Returns a variable's conditions
+   * @param id Variable's id
+   * @param index Variable's index
+   */
+  private getVariableCondition(id: number, index: number) {
+    const conditionObject = this.references.conditions.variables[id]
+    return conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, id, index, 'variables')
+  }
+
+  /**
+   * Returns an option's conditions
+   * @param id Option's id
+   * @param index Option's index
+   */
+  private getOptionCondition(id: number, index: number) {
+    const conditionObject = this.references.conditions.options[id]
+    return conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, id, index, 'options')
+  }
+
+  /**
+   * Returns a section's conditions
+   * @param id Section's id
+   */
+  private getSectionCondition(id: number) {
+    const conditionObject = this.references.conditions.sections.main[id]
+    return conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, id, 0, 'sections')
+  }
+
+  /**
+   * Returns option's parent section
+   * @param id Option's id
+   */
+  private getOptionParentSection(id: number) {
+    const { parents } = this.references.relations.options[id]
+
+    // Getting root option id
+    const rootId = parents.length > 0 ? parents[parents.length - 1] : id
+
+    // Looking for section
+    const sections = Object.values(this.references.sections.main)
+
+    for (let i = 0; i < sections.length; i += 1) {
+      if (sections[i].options.includes(rootId)) return sections[i].id
+    }
+
+    throw new Error(`Cannot find parent section for option ${id} (Root option id: ${rootId})`)
+  }
+}
+
+export default FillPdfFormBase