@legalplace/prerenderx 2.6.3 → 3.0.0

package/dist/libs/OptionRender.d.ts

@@ -0,0 +1,25 @@
+import { Types } from '@legalplace/referencesparser';
+import ConditionsRunner from './ConditionsRunner';
+import OVC_TYPE from './ovc.type';
+import NumAuto from './NumAuto';
+declare class OptionRender {
+    outputs: string[];
+    references: Types.ReferencesType;
+    index: number;
+    id: number;
+    conditions: ConditionsRunner;
+    ovc: OVC_TYPE;
+    private NumAuto;
+    constructor(options: {
+        references: Types.ReferencesType;
+        conditions: ConditionsRunner;
+        ovc: OVC_TYPE;
+        index: number;
+        id: number;
+        numauto: NumAuto;
+    });
+    getOutputs(): string[];
+    private renderOption;
+    private renderChildren;
+}
+export default OptionRender;

package/dist/libs/OptionRender.js

@@ -0,0 +1,66 @@
+"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 OutputParser_1 = require("./OutputParser");
+var OptionRender = (function () {
+    function OptionRender(options) {
+        this.outputs = [];
+        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();
+    }
+    OptionRender.prototype.getOutputs = function () {
+        return this.outputs;
+    };
+    OptionRender.prototype.renderOption = function () {
+        var _this = this;
+        var option = this.references.options[this.id];
+        var conditionObject = this.references.conditions.options[this.id];
+        var condition = conditionObject === undefined ? true : this.conditions.executeCondition(conditionObject, this.id, this.index, 'options');
+        if (condition === true) {
+            if (typeof option.meta.output === 'string' && option.meta.output.trim().length > 0) {
+                var outputReference = this.references.outputs[this.id];
+                var autonums = [];
+                if (condition !== false) {
+                    autonums = outputReference.autonums.map(function (currentAn) {
+                        var fn = currentAn[0] === 'numauto-pre' ? _this.NumAuto.getNumPre : _this.NumAuto.getNum;
+                        return [currentAn[0], currentAn[1], fn(currentAn[1], currentAn[2]), currentAn[2]];
+                    });
+                }
+                var variables = OutputParser_1.getRelatedVariablesValues(this.id, this.index, outputReference.variables, this.ovc, this.references);
+                var output = OutputParser_1.parseOutputWithVariables(option.meta.output, this.index, variables, autonums);
+                output = output.replace(/<\/([a-z]+)>([\n\s]+)</gi, '</$1><');
+                output = output.replace(/\n/g, '<br />');
+                output = output.replace(/\xA0/g, ' ');
+                this.outputs.push(output);
+            }
+            this.renderChildren();
+        }
+    };
+    OptionRender.prototype.renderChildren = function () {
+        var _this = this;
+        var option = this.references.options[this.id];
+        option.options.forEach(function (optionId) {
+            _this.outputs = __spreadArrays(_this.outputs, new OptionRender({
+                references: _this.references,
+                id: optionId,
+                ovc: _this.ovc,
+                index: _this.index,
+                conditions: _this.conditions,
+                numauto: _this.NumAuto
+            }).getOutputs());
+        });
+    };
+    return OptionRender;
+}());
+exports.default = OptionRender;

package/dist/libs/OutputParser.d.ts

@@ -0,0 +1,11 @@
+import { Types } from '@legalplace/referencesparser';
+import OVC_TYPE from './ovc.type';
+declare type relVarsValsT = Record<string, string | number>;
+declare type getRelatedVarsT = (optionId: number, index: number, variables: number[], ovc: OVC_TYPE, references: Types.ReferencesType) => relVarsValsT;
+export declare const getRelatedVariablesValues: getRelatedVarsT;
+declare type autonumsType = [string, string, number, string | null][];
+declare type parseOutputT = (output: string, index: number, variables: relVarsValsT, autonums: autonumsType) => string;
+export declare const parseOutputWithVariables: parseOutputT;
+declare type TParseDocumentNameWithVariables = (text: string, ovc: OVC_TYPE, references: Types.ReferencesType, fallback?: string) => string;
+export declare const parseDocumentNameWithVariables: TParseDocumentNameWithVariables;
+export {};

package/dist/libs/OutputParser.js

@@ -0,0 +1,93 @@
+"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 });
+exports.parseDocumentNameWithVariables = exports.parseOutputWithVariables = exports.getRelatedVariablesValues = void 0;
+var frenchNumber = function (value) {
+    var result = typeof value === 'number' ? value.toString() : value;
+    if (/^([0-9]+)\.([0-9]+)$/.test(result.trim()))
+        result = result.trim().replace('.', ',');
+    return result;
+};
+exports.getRelatedVariablesValues = function (optionId, index, variables, ovc, references) {
+    var variablesValues = {};
+    variables.forEach(function (currentVariableId) {
+        var value = ovc.variables[currentVariableId] || [''];
+        var variableParents = references.relations.variables[currentVariableId].parents;
+        if (variableParents === undefined)
+            throw new Error("Variable " + currentVariableId + " parents object does not exist");
+        var rootVariableParentId = variableParents[variableParents.length - 1];
+        var rootVariableParentRelations = references.relations.options[rootVariableParentId];
+        if (rootVariableParentRelations === undefined)
+            throw new Error("Option " + rootVariableParentId + " does not exist");
+        if (typeof variableParents === 'undefined')
+            return;
+        if (rootVariableParentRelations.children.options.includes(optionId) || rootVariableParentRelations.dependants.includes(optionId) || optionId === rootVariableParentId)
+            value = [value[index]];
+        var cleanValues = value.map(function (currentValue) {
+            if (['number', 'string'].includes(typeof currentValue))
+                return frenchNumber(currentValue);
+            return '';
+        });
+        var currentVariableValue = cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(', ');
+        variablesValues[currentVariableId] = currentVariableValue;
+    });
+    return variablesValues;
+};
+exports.parseOutputWithVariables = function (output, index, variables, autonums) {
+    var parsedOutput = "" + output;
+    Object.keys(variables).forEach(function (variableId) {
+        var value = variables[variableId].toString();
+        if (value.trim().length === 0) {
+            value = new Array(16).join('_');
+        }
+        value = value.replace(/\n/g, '<br />');
+        parsedOutput = parsedOutput.replace(new RegExp("\\[var:" + variableId + "\\]", 'g'), value);
+    });
+    parsedOutput = parsedOutput.replace(/\[\[PAGE_BREAK\]\]/gi, '<div style="page-break-after:always"></div>');
+    parsedOutput = parsedOutput.replace(/\[(E|B)_BLUR\]/gi, '');
+    parsedOutput = parsedOutput.replace(/\[signature:([0-9]+)\]/g, function (v, signatureId) { return "<span data-signature-id=\"" + signatureId + "\" data-signer-index=\"" + index + "\"></span>"; });
+    autonums.forEach(function (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;
+};
+exports.parseDocumentNameWithVariables = function (text, ovc, references, fallback) {
+    var tagsMatch = text.match(/\[var:([0-9]+)\]/gi);
+    var variables = [];
+    if (tagsMatch !== null) {
+        var variablesTags = __spreadArrays(tagsMatch);
+        variables = variablesTags.map(function (current) {
+            var outputVariableMatch = current.match(/([0-9]+)/);
+            if (outputVariableMatch === null)
+                return 0;
+            return parseInt(outputVariableMatch[0], 10);
+        });
+    }
+    variables = variables.filter(function (c, i) { return variables.indexOf(c) === i; });
+    variables = variables.filter(function (c) { return ovc !== undefined || references.variables[c] !== undefined; });
+    var variablesValues = {};
+    variables.forEach(function (variableId) {
+        var _a;
+        var value = ((_a = ovc.variables[variableId]) === null || _a === void 0 ? void 0 : _a[0]) || '';
+        variablesValues[variableId] = value.toString();
+    });
+    var parsedText = "" + text;
+    variables.forEach(function (variableId) {
+        var value = variablesValues[variableId];
+        if (value.trim().length === 0 && fallback)
+            parsedText = fallback;
+        if (parsedText === fallback && fallback)
+            return;
+        parsedText = parsedText.replace(new RegExp("\\[var:" + variableId + "\\]", 'gi'), value);
+    });
+    return parsedText;
+};

package/dist/libs/OvcConverter.d.ts

@@ -0,0 +1,21 @@
+import OVC_TYPE from './ovc.type';
+import { Types } from '@legalplace/referencesparser';
+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, references: Types.ReferencesType): OVC_TYPE;
+    isOvc(_obj: OVC_TYPE | OldOVC): _obj is OldOVC;
+    isOptionsVariables(_obj: OVC_TYPE | OldOVC): boolean;
+    private pushStaticChildren;
+}
+declare const _default: OvcConverter;
+export default _default;

package/dist/libs/OvcConverter.js

@@ -0,0 +1,132 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 OvcConverter = (function () {
+    function OvcConverter() {
+    }
+    OvcConverter.prototype.convertToOptionsVariables = function (ovc, references) {
+        var _this = this;
+        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;
+                    inputs.options = __assign(__assign({}, inputs.options), _this.pushStaticChildren(inputs.options, id, occurences_1, references));
+                    currentOption.forEach(function (childId, index) {
+                        var sanitizedId = typeof childId === 'string' && childId.split('_').length > 0
+                            ? childId.split('_')[0]
+                            : childId;
+                        if (!Object.prototype.hasOwnProperty.call(inputs.options, id)) {
+                            inputs.options[id] = new Array(occurences_1).fill(false);
+                        }
+                        if (typeof sanitizedId === 'string' &&
+                            sanitizedId.trim().length === 0) {
+                            return;
+                        }
+                        if (!Object.prototype.hasOwnProperty.call(inputs.options, sanitizedId)) {
+                            inputs.options[sanitizedId] = new Array(occurences_1).fill(false);
+                        }
+                        inputs.options = __assign(__assign({}, inputs.options), _this.pushStaticChildren(inputs.options, sanitizedId, occurences_1, references));
+                        inputs.options[sanitizedId][index] = true;
+                    });
+                }
+                else {
+                    if (typeof currentOption === 'string' &&
+                        currentOption.trim().length === 0)
+                        return;
+                    inputs.options[currentOption] = [true];
+                }
+            });
+        }
+        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];
+                }
+            });
+        }
+        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;
+                    var parentsTree = references.relations.variables[id].parents;
+                    var parentOption = inputs.options["" + parentsTree[parentsTree.length - 1]];
+                    if (Array.isArray(parentOption)) {
+                        var occurences = parentOption.length;
+                        if (currentVariable.length < occurences) {
+                            inputs.variables[id] = __spreadArrays(currentVariable, Array(occurences - currentVariable.length).fill(''));
+                        }
+                    }
+                }
+                else {
+                    inputs.variables[id] = [currentVariable];
+                }
+            });
+        }
+        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;
+    };
+    OvcConverter.prototype.pushStaticChildren = function (inputOptions, id, occurences, references) {
+        var result = __assign({}, inputOptions);
+        var intId = typeof id === 'number' ? id : parseInt(id, 10);
+        var options = references.relations.options[intId].children.options;
+        var staticOptions = options.filter(function (childId) {
+            return references.options[childId].meta.type === 'static';
+        });
+        staticOptions.forEach(function (childId) {
+            if (!Object.prototype.hasOwnProperty.call(result, childId)) {
+                result[childId] = new Array(occurences).fill(false);
+            }
+        });
+        return result;
+    };
+    return OvcConverter;
+}());
+exports.default = new OvcConverter();

package/dist/libs/Prerender.d.ts

@@ -0,0 +1,42 @@
+import { ModelV3 } from '@legalplace/models-v3-types';
+import OVC_TYPE from './ovc.type';
+import { OldOVC } from './OvcConverter';
+declare type DocumentOutputIndex = {
+    name: string;
+    slug: string;
+    pdf: boolean;
+    docx: boolean;
+};
+declare type DocumentPdfFormIndex = {
+    name: string;
+    slug: string;
+    form: boolean;
+    fdf: {
+        id: string;
+        fields: Record<string, string>;
+    };
+};
+declare type FDFType = {
+    id: string;
+    fields: 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, DocumentOutputIndex | DocumentPdfFormIndex>;
+    getDocument(documentNameHash: string): string | FDFType;
+    private generateDocumentNamesHash;
+    private fillPdfForms;
+    private generateAllDocuments;
+    static isPdfForm(index: DocumentOutputIndex | DocumentPdfFormIndex): index is DocumentPdfFormIndex;
+    static isOutput(index: DocumentOutputIndex | DocumentPdfFormIndex): index is DocumentOutputIndex;
+}
+export default Prerender;

package/dist/libs/Prerender.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 FillPdfForm_1 = __importDefault(require("./FillPdfForm"));
+var OutputParser_1 = require("./OutputParser");
+var Prerender = (function () {
+    function Prerender(model, ovc) {
+        this.documentsIndex = {};
+        this.renderedDocuments = {};
+        this.model = model;
+        this.NumAuto = new NumAuto_1.default();
+        this.references = new referencesparser_1.ReferencesParser(model).getReferences();
+        this.ovc = OvcConverter_1.default.isOvc(ovc)
+            ? OvcConverter_1.default.convertToOptionsVariables(ovc, this.references)
+            : ovc;
+        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();
+        this.fillPdfForms();
+    }
+    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 (slug) {
+            var _a, _b;
+            var document = _this.model.documents[slug];
+            var documentParams = _this.model.documents[slug].params;
+            var conditionObject = _this.references.conditions.documents[slug];
+            var condition = conditionObject === undefined ? true : _this.conditions.executeCondition(conditionObject, 0, 0, 'documents');
+            if (condition === true) {
+                var hash = crypto_1.default
+                    .createHash('sha1')
+                    .update(slug)
+                    .digest('hex');
+                if (typeof document.pdf === 'object' && typeof document.pdf.id === 'string' && typeof document.pdf.form === 'object') {
+                    _this.documentsIndex[hash] = {
+                        name: OutputParser_1.parseDocumentNameWithVariables(document.name, _this.ovc, _this.references, document.fallbackName),
+                        slug: slug,
+                        form: true,
+                        fdf: {
+                            id: '',
+                            fields: {}
+                        }
+                    };
+                }
+                else {
+                    _this.documentsIndex[hash] = {
+                        name: OutputParser_1.parseDocumentNameWithVariables(document.name, _this.ovc, _this.references, document.fallbackName),
+                        slug: slug,
+                        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.fillPdfForms = function () {
+        var _this = this;
+        Object.keys(this.documentsIndex).forEach(function (documentNameHash) {
+            var index = _this.documentsIndex[documentNameHash];
+            if (Prerender.isPdfForm(index)) {
+                index.fdf = _this.getDocument(documentNameHash);
+            }
+        });
+    };
+    Prerender.prototype.generateAllDocuments = function () {
+        var _this = this;
+        Object.keys(this.documentsIndex).forEach(function (documentNameHash) {
+            var index = _this.documentsIndex[documentNameHash];
+            if (Prerender.isPdfForm(index)) {
+                _this.renderedDocuments[documentNameHash] = _this.pdfFiller.fillDocument(_this.documentsIndex[documentNameHash].slug);
+            }
+            else {
+                _this.renderedDocuments[documentNameHash] = _this.documentRender.renderDocument(_this.documentsIndex[documentNameHash].slug);
+            }
+        });
+    };
+    Prerender.isPdfForm = function (index) {
+        return Object.prototype.hasOwnProperty.call(index, 'form');
+    };
+    Prerender.isOutput = function (index) {
+        return !Object.prototype.hasOwnProperty.call(index, 'form');
+    };
+    return Prerender;
+}());
+exports.default = Prerender;

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,60 @@
+"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/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;