@legalplace/prerenderx 3.8.2-nightly.0 → 3.8.2

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.8.2](https://git.legalplace.eu/legalplace/prerenderx/compare/@legalplace/prerenderx@3.8.1...@legalplace/prerenderx@3.8.2) (2026-03-16)
+
+**Note:** Version bump only for package @legalplace/prerenderx
+
+
+
+
+
 ## [3.8.1](https://git.legalplace.eu/legalplace/prerenderx/compare/@legalplace/prerenderx@3.8.0...@legalplace/prerenderx@3.8.1) (2026-02-03)
 
 **Note:** Version bump only for package @legalplace/prerenderx

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import Prerender from "./libs/Prerender";
+export * from "./types/types";
+export default Prerender;

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Prerender_1 = __importDefault(require("./libs/Prerender"));
+__exportStar(require("./types/types"), exports);
+exports.default = Prerender_1.default;

package/dist/libs/DocumentRender.d.ts

@@ -0,0 +1,13 @@
+import type { Types } from "@legalplace/referencesparser";
+import type ConditionsRunner from "@legalplace/conditions-runner";
+import type InputsType from "@legalplace/types/dist/inputs";
+import type NumAuto from "./NumAuto";
+declare class DocumentRender {
+    references: Types.ReferencesType;
+    conditions: ConditionsRunner;
+    ovc: InputsType;
+    private NumAuto;
+    constructor(references: Types.ReferencesType, conditions: ConditionsRunner, ovc: InputsType, numauto: NumAuto);
+    renderDocument(documentName: string): string;
+}
+export default DocumentRender;

package/dist/libs/DocumentRender.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var SectionRender_1 = __importDefault(require("./SectionRender"));
+var DocumentRender = (function () {
+    function DocumentRender(references, conditions, ovc, numauto) {
+        this.references = references;
+        this.conditions = conditions;
+        this.ovc = ovc;
+        this.NumAuto = numauto;
+    }
+    DocumentRender.prototype.renderDocument = function (documentName) {
+        var _this = this;
+        var documentOutputs = [];
+        this.NumAuto.resetIndexes();
+        Object.keys(this.references.sections[documentName]).forEach(function (sectionId) {
+            documentOutputs.push.apply(documentOutputs, new SectionRender_1.default({
+                references: _this.references,
+                conditions: _this.conditions,
+                documentName: documentName,
+                ovc: _this.ovc,
+                currentSection: parseInt(sectionId, 10),
+                numauto: _this.NumAuto,
+            }).getOutputs());
+        });
+        return documentOutputs.join("");
+    };
+    return DocumentRender;
+}());
+exports.default = DocumentRender;

package/dist/libs/FillPdfForm.d.ts

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

package/dist/libs/FillPdfForm.js

@@ -0,0 +1,127 @@
+"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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        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: "",
+            fields: {},
+        };
+        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 = "".concat(input.name);
+            result.fields[id] = _this.getInputValue(input);
+        });
+        form.boxes.forEach(function (box) {
+            var id = "".concat(box.name);
+            var value = _this.getBoxValue(box);
+            if (!(value === "" &&
+                Object.prototype.hasOwnProperty.call(result.fields, id)))
+                result.fields[id] = value;
+        });
+        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})$/;
+                if (variable.date && dateRegex.test(currentValue)) {
+                    switch (variable.date) {
+                        case "DD":
+                            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) {
+                if (this.references.options[option.id].meta.type === "checkbox" &&
+                    box.value === "Off")
+                    return "On";
+                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/InputsInitiator.d.ts

@@ -0,0 +1,21 @@
+import type { Types } from "@legalplace/referencesparser";
+type References = Types.ReferencesType;
+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,104 @@
+"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)) {
+                if ([
+                    "static",
+                    "hidden",
+                    "brut-text",
+                    "repeated",
+                    "box",
+                    "separator",
+                ].includes(option.meta.type)) {
+                    values = new Array(this.ovc.options[optionId].length).fill(true);
+                }
+                else {
+                    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/NumAuto.d.ts

@@ -0,0 +1,8 @@
+declare class NumAuto {
+    indexesList: Record<string, any>;
+    tagsIndex: Record<string, number>;
+    getNum: (index: string, tag: string | null) => number;
+    getNumPre: (index: string) => number;
+    resetIndexes: () => void;
+}
+export default NumAuto;

package/dist/libs/NumAuto.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var NumAuto = (function () {
+    function NumAuto() {
+        var _this = this;
+        this.indexesList = {};
+        this.tagsIndex = {};
+        this.getNum = function (index, tag) {
+            if (!Object.prototype.hasOwnProperty.call(_this.indexesList, index)) {
+                if (Object.prototype.hasOwnProperty.call(_this.tagsIndex, index))
+                    return _this.tagsIndex[index];
+                _this.indexesList[index] = 0;
+            }
+            _this.indexesList[index] += 1;
+            if (typeof tag === "string")
+                _this.tagsIndex[tag] = _this.indexesList[index];
+            return _this.indexesList[index];
+        };
+        this.getNumPre = function (index) {
+            if (!Object.prototype.hasOwnProperty.call(_this.indexesList, index)) {
+                if (Object.prototype.hasOwnProperty.call(_this.tagsIndex, index))
+                    return _this.tagsIndex[index];
+            }
+            return _this.indexesList[index];
+        };
+        this.resetIndexes = function () {
+            _this.indexesList = {};
+        };
+    }
+    return NumAuto;
+}());
+exports.default = NumAuto;

package/dist/libs/OptionRender.d.ts

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

package/dist/libs/OptionRender.js

@@ -0,0 +1,78 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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 = (0, OutputParser_1.getRelatedVariablesValues)(this.id, this.index, outputReference.variables, this.ovc, this.references);
+                var output = (0, 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 = __spreadArray(__spreadArray([], _this.outputs, true), new OptionRender({
+                references: _this.references,
+                id: optionId,
+                ovc: _this.ovc,
+                index: _this.index,
+                conditions: _this.conditions,
+                numauto: _this.NumAuto,
+            }).getOutputs(), true);
+        });
+    };
+    return OptionRender;
+}());
+exports.default = OptionRender;

package/dist/libs/OutputParser.d.ts

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

package/dist/libs/OutputParser.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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDocumentNameWithVariables = exports.parseOutputWithVariables = exports.getRelatedVariablesValues = void 0;
+var yousign_1 = require("@legalplace/yousign");
+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;
+};
+var 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 ".concat(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 ".concat(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.getRelatedVariablesValues = getRelatedVariablesValues;
+var parseOutputWithVariables = function (output, index, variables, autonums) {
+    var parsedOutput = "".concat(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:".concat(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=\"signature\" data-signature-id=\"".concat(signatureId, "\" data-signer-index=\"").concat(index, "\"></span>");
+    });
+    parsedOutput = parsedOutput.replace(/\[signature:date\]/g, function () { return '<span data-signature="date"></span>'; });
+    parsedOutput = parsedOutput.replace(/\[signature:date:([0-9]+)\]/g, function (v, signatureId) {
+        return "<span data-signature=\"date\" data-signature-id=\"".concat(signatureId, "\" data-signer-index=\"").concat(index, "\"></span>");
+    });
+    parsedOutput = parsedOutput.replace(/\[signature:mention:([0-9]+):(?:&quot;|")((?:[^"&]|\\.)*?)(?:&quot;|")\]/g, function (v, signatureId, mention) {
+        return "<span data-signature=\"mention\" data-signature-id=\"".concat(signatureId, "\" data-signer-index=\"").concat(index, "\" data-signer-mention=\"").concat(mention, "\"></span>");
+    });
+    parsedOutput = parsedOutput.replace(/\[date\]/g, function () { return '<span data-signature="date"></span>'; });
+    parsedOutput = parsedOutput.replace(new RegExp(yousign_1.yousignTagFieldRegex, "g"), function (v, paramsString) {
+        try {
+            var parsedParams = (0, yousign_1.parseYousignTag)("[yousign:".concat(paramsString.replace(/((=)&quot;)|(&quot;(;|$))/g, '$2"$4'), "]"));
+            return (0, yousign_1.convertParamsToHtmlTag)(__assign(__assign({}, parsedParams), { signerIndex: index }));
+        }
+        catch (error) {
+            console.error("Failed to parse Yousign tag: ".concat(v), error);
+            return v;
+        }
+    });
+    autonums.forEach(function (currentAn) {
+        if (currentAn[3] === null)
+            parsedOutput = parsedOutput.replace("[".concat(currentAn[0], ":").concat(currentAn[1], "]"), "<span class=\"".concat(currentAn[0], "\">").concat(currentAn[2], "</span>"));
+        else
+            parsedOutput = parsedOutput.replace("[".concat(currentAn[0], ":").concat(currentAn[1], "](").concat(currentAn[3], ")"), "<span class=\"".concat(currentAn[0], "\">").concat(currentAn[2], "</span>"));
+    });
+    return parsedOutput;
+};
+exports.parseOutputWithVariables = parseOutputWithVariables;
+var parseDocumentNameWithVariables = function (text, ovc, references, fallback) {
+    var tagsMatch = text.match(/\[var:([0-9]+)\]/gi);
+    var variables = [];
+    if (tagsMatch !== null) {
+        var variablesTags = __spreadArray([], tagsMatch, true);
+        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 = "".concat(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:".concat(variableId, "\\]"), "gi"), value);
+    });
+    return parsedText;
+};
+exports.parseDocumentNameWithVariables = parseDocumentNameWithVariables;

package/dist/libs/Prerender.d.ts

@@ -0,0 +1,25 @@
+import type { ModelV3 } from "@legalplace/models-v3-types";
+import type { Types } from "@legalplace/referencesparser";
+import type OvcType from "@legalplace/types/dist/ovc";
+import type InputsType from "@legalplace/types/dist/inputs";
+import type { FDFType, DocumentIndex, DocumentOutputIndex, DocumentPdfFormIndex } from "../types/types";
+declare class Prerender {
+    private references;
+    private ovc;
+    private conditions;
+    private documentRender;
+    private pdfFiller;
+    private NumAuto;
+    private documentsIndex;
+    private renderedDocuments;
+    constructor(model: ModelV3 | Types.ReferencesType, ovc: InputsType | OvcType);
+    getDocumentsIndexWithoutFdf(): DocumentIndex;
+    getDocumentsIndex(): DocumentIndex;
+    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,116 @@
+"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 conditions_runner_1 = __importDefault(require("@legalplace/conditions-runner"));
+var ovc_converter_1 = __importDefault(require("@legalplace/ovc-converter"));
+var crypto_1 = __importDefault(require("crypto"));
+var DocumentRender_1 = __importDefault(require("./DocumentRender"));
+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.NumAuto = new NumAuto_1.default();
+        this.references = referencesparser_1.ReferencesParser.isReferences(model)
+            ? model
+            : new referencesparser_1.ReferencesParser(model).getReferences();
+        this.ovc = ovc_converter_1.default.isOvc(ovc)
+            ? ovc_converter_1.default.convertToOptionsVariables(ovc, this.references)
+            : ovc;
+        var inputs = new InputsInitiator_1.default(this.references, this.ovc).getInputs();
+        this.conditions = new conditions_runner_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();
+    }
+    Prerender.prototype.getDocumentsIndexWithoutFdf = function () {
+        return this.documentsIndex;
+    };
+    Prerender.prototype.getDocumentsIndex = function () {
+        this.generateAllDocuments();
+        this.fillPdfForms();
+        return this.documentsIndex;
+    };
+    Prerender.prototype.getDocument = function (documentNameHash) {
+        if (this.renderedDocuments[documentNameHash]) {
+            return this.renderedDocuments[documentNameHash];
+        }
+        var index = this.documentsIndex[documentNameHash];
+        this.renderedDocuments[documentNameHash] = Prerender.isPdfForm(index)
+            ? this.pdfFiller.fillDocument(index.slug)
+            : this.documentRender.renderDocument(index.slug);
+        return this.renderedDocuments[documentNameHash];
+    };
+    Prerender.prototype.generateDocumentNamesHash = function () {
+        var _this = this;
+        Object.keys(this.references.documents).forEach(function (slug) {
+            var _a, _b;
+            var document = _this.references.documents[slug];
+            var documentParams = _this.references.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: (0, OutputParser_1.parseDocumentNameWithVariables)(document.name, _this.ovc, _this.references, document.fallbackName),
+                        slug: slug,
+                        form: true,
+                        fdf: {
+                            id: "",
+                            fields: {},
+                        },
+                    };
+                }
+                else {
+                    _this.documentsIndex[hash] = {
+                        name: (0, 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) !== false,
+                        docx: ((_b = documentParams === null || documentParams === void 0 ? void 0 : documentParams.formats) === null || _b === void 0 ? void 0 : _b.docx) !== false,
+                    };
+                }
+            }
+        });
+    };
+    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 type { Types } from "@legalplace/referencesparser";
+import type ConditionsRunner from "@legalplace/conditions-runner";
+import type InputsType from "@legalplace/types/dist/inputs";
+import type NumAuto from "./NumAuto";
+declare class SectionRender {
+    outputs: string[];
+    references: Types.ReferencesType;
+    currentSection: number;
+    documentName: string;
+    conditions: ConditionsRunner;
+    ovc: InputsType;
+    private NumAuto;
+    constructor(options: {
+        references: Types.ReferencesType;
+        conditions: ConditionsRunner;
+        ovc: InputsType;
+        documentName: string;
+        currentSection: number;
+        numauto: NumAuto;
+    });
+    getOutputs(): string[];
+    private renderSection;
+}
+export default SectionRender;

package/dist/libs/SectionRender.js

@@ -0,0 +1,69 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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 = __spreadArray(__spreadArray([], _this.outputs, true), new OptionRender_1.default({
+                        references: _this.references,
+                        id: optionId,
+                        ovc: _this.ovc,
+                        index: index,
+                        conditions: _this.conditions,
+                        numauto: _this.NumAuto,
+                    }).getOutputs(), true);
+                });
+            });
+        }
+    };
+    return SectionRender;
+}());
+exports.default = SectionRender;

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

@@ -0,0 +1,16 @@
+import type { Types } from "@legalplace/referencesparser";
+import type ConditionsRunner from "@legalplace/conditions-runner";
+import type InputsType from "@legalplace/types/dist/inputs";
+declare class FillPdfFormBase {
+    references: Types.ReferencesType;
+    conditions: ConditionsRunner;
+    ovc: InputsType;
+    constructor(references: Types.ReferencesType, conditions: ConditionsRunner, ovc: InputsType);
+    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,70 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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 (__spreadArray(__spreadArray([
+            optionCondition,
+            parentSectionCondition
+        ], parentsConditions, true), parentsInputs, true).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 ".concat(id, " (Root option id: ").concat(rootId, ")"));
+    };
+    return FillPdfFormBase;
+}());
+exports.default = FillPdfFormBase;

package/dist/types/types.d.ts

@@ -0,0 +1,17 @@
+export type DocumentOutputIndex = {
+    name: string;
+    slug: string;
+    pdf: boolean;
+    docx: boolean;
+};
+export type DocumentPdfFormIndex = {
+    name: string;
+    slug: string;
+    form: boolean;
+    fdf: FDFType;
+};
+export type DocumentIndex = Record<string, DocumentOutputIndex | DocumentPdfFormIndex>;
+export type FDFType = {
+    id: string;
+    fields: Record<string, string>;
+};

package/dist/types/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/prerenderx",
-  "version": "3.8.2-nightly.0",
+  "version": "3.8.2",
   "description": "PrerenderX",
   "main": "dist/index.js",
   "repository": "https://git.legalplace.eu/legalplace/prerenderx",
@@ -16,13 +16,13 @@
     "release": "standard-version -a --no-verify"
   },
   "dependencies": {
-    "@legalplace/conditions-runner": "^2.1.45",
+    "@legalplace/conditions-runner": "^2.2.0",
     "@legalplace/eslint-config-base": "^1.2.0",
-    "@legalplace/lplogic": "2.4.0-nightly.0",
-    "@legalplace/models-v3-types": "^5.15.18",
-    "@legalplace/ovc-converter": "^2.1.10",
+    "@legalplace/lplogic": "2.3.1",
+    "@legalplace/models-v3-types": "^5.16.0",
+    "@legalplace/ovc-converter": "^2.2.0",
     "@legalplace/prettier-config": "^2.1.3",
-    "@legalplace/referencesparser": "^3.1.102",
+    "@legalplace/referencesparser": "^3.2.0",
     "@legalplace/yousign": "^0.8.1",
     "crypto": "^1.0.1",
     "standard-version": "^9.3.1"
@@ -36,5 +36,6 @@
     "redux-mock-store": "^1.5.3",
     "ts-jest": "^24.0.2"
   },
-  "prettier": "@legalplace/prettier-config"
+  "prettier": "@legalplace/prettier-config",
+  "gitHead": "c2ecbc53d3a74ecc7b17893b30880a85a5dc7e62"
 }