@legalplace/prerenderx 3.8.17 → 3.8.18-staging.2

package/dist/libs/SectionRender.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var OptionRender_1 = __importDefault(require("./OptionRender"));
 var SectionRender = (function () {
     function SectionRender(options) {
+        var _a;
         this.outputs = [];
         this.references = options.references;
         this.conditions = options.conditions;
@@ -22,47 +23,88 @@ var SectionRender = (function () {
         this.currentSection = options.currentSection;
         this.ovc = options.ovc;
         this.NumAuto = options.numauto;
+        this.baseIndex = (_a = options.baseIndex) !== null && _a !== void 0 ? _a : 0;
         this.renderSection();
     }
     SectionRender.prototype.getOutputs = function () {
         return this.outputs;
     };
+    SectionRender.prototype.getDocumentMultipleSource = function () {
+        var _a, _b;
+        var docMultiple = (_b = (_a = this.references.documents[this.documentName]) === null || _a === void 0 ? void 0 : _a.params) === null || _b === void 0 ? void 0 : _b.multiple;
+        if ((docMultiple === null || docMultiple === void 0 ? void 0 : docMultiple.enabled) !== true)
+            return undefined;
+        return typeof docMultiple.repeatOption === "number"
+            ? docMultiple.repeatOption
+            : undefined;
+    };
     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.conditions.executeCondition(conditionObject, 0, this.baseIndex, "sections");
+        if (condition !== true)
+            return;
+        var documentMultipleSource = this.getDocumentMultipleSource();
+        section.options.forEach(function (optionId) {
+            var option = _this.references.options[optionId];
+            if (option.meta.type === "repeated" &&
+                documentMultipleSource !== undefined &&
+                option.meta.repeatOption === documentMultipleSource) {
+                option.options.forEach(function (childId) {
                     _this.outputs = __spreadArray(__spreadArray([], _this.outputs, true), new OptionRender_1.default({
                         references: _this.references,
-                        id: optionId,
+                        id: childId,
                         ovc: _this.ovc,
-                        index: index,
+                        index: _this.baseIndex,
                         conditions: _this.conditions,
                         numauto: _this.NumAuto,
                     }).getOutputs(), true);
                 });
+                return;
+            }
+            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),
+            ];
+            if (documentMultipleSource !== undefined &&
+                option.meta.type !== "repeated") {
+                var valueAtIndex = _this.baseIndex < inputs.length ? inputs[_this.baseIndex] : inputs[0];
+                if (valueAtIndex !== true)
+                    return;
+                _this.outputs = __spreadArray(__spreadArray([], _this.outputs, true), new OptionRender_1.default({
+                    references: _this.references,
+                    id: optionId,
+                    ovc: _this.ovc,
+                    index: _this.baseIndex,
+                    conditions: _this.conditions,
+                    numauto: _this.NumAuto,
+                }).getOutputs(), true);
+                return;
+            }
+            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;
 }());

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

@@ -6,11 +6,11 @@ declare class FillPdfFormBase {
     conditions: ConditionsRunner;
     ovc: InputsType;
     constructor(references: Types.ReferencesType, conditions: ConditionsRunner, ovc: InputsType);
+    private readonly conditionEvaluator;
     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

@@ -1,41 +1,25 @@
 "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 referencesparser_1 = require("@legalplace/referencesparser");
 var FillPdfFormBase = (function () {
     function FillPdfFormBase(references, conditions, ovc) {
+        var _this = this;
+        this.conditionEvaluator = function (type, id, index) {
+            if (type === "options")
+                return _this.getOptionCondition(id, index);
+            if (type === "variables")
+                return _this.getVariableCondition(id, index);
+            return _this.getSectionCondition(id);
+        };
         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);
+        return (0, referencesparser_1.isVariableDisplayed)(this.references, this.ovc, this.conditionEvaluator, id, index);
     };
     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);
+        return (0, referencesparser_1.isOptionDisplayed)(this.references, this.ovc, this.conditionEvaluator, id, index);
     };
     FillPdfFormBase.prototype.getVariableCondition = function (id, index) {
         var conditionObject = this.references.conditions.variables[id];
@@ -55,16 +39,6 @@ var FillPdfFormBase = (function () {
             ? 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/libs/outputTableRendering.d.ts

@@ -0,0 +1,16 @@
+import type { OptionV3 } from "@legalplace/models-v3-types";
+export type OutputTableCellStyle = Record<string, string>;
+export type OutputTableStyle = {
+    columnWidths?: number[];
+    width?: number;
+    borderStyle?: string;
+    borderColor?: string;
+    borderWidth?: number;
+};
+export declare const expandOutputTableCellStyle: (styles: OutputTableCellStyle) => OutputTableCellStyle;
+export declare const serializeInlineStyle: (styles: OutputTableCellStyle) => string;
+export declare const buildOutputTableStyleAttr: (tableStyle?: OutputTableStyle) => string;
+export declare const buildOutputTableCellStyleAttr: (cellStyle?: OutputTableCellStyle | null) => string;
+export declare const getOutputTableCellStyle: (option: OptionV3) => OutputTableCellStyle | undefined;
+export declare const replaceOutputTableMarkers: (html: string, renderTable: (tableId: number) => string) => string;
+export declare const stripOutputTableMarkers: (html: string) => string;

package/dist/libs/outputTableRendering.js

@@ -0,0 +1,130 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripOutputTableMarkers = exports.replaceOutputTableMarkers = exports.getOutputTableCellStyle = exports.buildOutputTableCellStyleAttr = exports.buildOutputTableStyleAttr = exports.serializeInlineStyle = exports.expandOutputTableCellStyle = void 0;
+var DEFAULT_OUTPUT_TABLE_CELL_STYLE = {
+    paddingTop: "4px",
+    paddingRight: "4px",
+    paddingBottom: "4px",
+    paddingLeft: "4px",
+    borderTopWidth: "1px",
+    borderTopStyle: "solid",
+    borderTopColor: "#000000",
+    borderRightWidth: "1px",
+    borderRightStyle: "solid",
+    borderRightColor: "#000000",
+    borderBottomWidth: "1px",
+    borderBottomStyle: "solid",
+    borderBottomColor: "#000000",
+    borderLeftWidth: "1px",
+    borderLeftStyle: "solid",
+    borderLeftColor: "#000000",
+};
+var BORDER_SIDES = ["Top", "Right", "Bottom", "Left"];
+var parseBoxShorthand = function (parts) {
+    var first = parts[0], second = parts[1], third = parts[2], fourth = parts[3];
+    if (parts.length === 1) {
+        return [first, first, first, first];
+    }
+    if (parts.length === 2) {
+        return [first, second, first, second];
+    }
+    if (parts.length === 3) {
+        return [first, second, third, second];
+    }
+    return [first, second, third, fourth];
+};
+var parseBorderShorthand = function (border) {
+    var parts = border.trim().split(/\s+/);
+    var width = parts.find(function (part) { return /^[0-9.]+(px|pt|em|rem|%)?$/i.test(part); }) || "1px";
+    var style = parts.find(function (part) {
+        return ["solid", "dashed", "dotted", "double", "none"].includes(part.toLowerCase());
+    }) || "solid";
+    var color = parts.find(function (part) { return part.startsWith("#") || part.startsWith("rgb"); }) ||
+        "#000000";
+    return { width: width, style: style, color: color };
+};
+var expandOutputTableCellStyle = function (styles) {
+    var expanded = __assign({}, styles);
+    if (expanded.padding) {
+        var _a = parseBoxShorthand(expanded.padding.trim().split(/\s+/)), top_1 = _a[0], right = _a[1], bottom = _a[2], left = _a[3];
+        delete expanded.padding;
+        expanded.paddingTop = expanded.paddingTop || top_1;
+        expanded.paddingRight = expanded.paddingRight || right;
+        expanded.paddingBottom = expanded.paddingBottom || bottom;
+        expanded.paddingLeft = expanded.paddingLeft || left;
+    }
+    if (expanded.border) {
+        var _b = parseBorderShorthand(expanded.border), width_1 = _b.width, style_1 = _b.style, color_1 = _b.color;
+        delete expanded.border;
+        BORDER_SIDES.forEach(function (side) {
+            var widthKey = "border".concat(side, "Width");
+            var styleKey = "border".concat(side, "Style");
+            var colorKey = "border".concat(side, "Color");
+            expanded[widthKey] = expanded[widthKey] || width_1;
+            expanded[styleKey] = expanded[styleKey] || style_1;
+            expanded[colorKey] = expanded[colorKey] || color_1;
+        });
+    }
+    return expanded;
+};
+exports.expandOutputTableCellStyle = expandOutputTableCellStyle;
+var camelToKebab = function (property) {
+    return property.replace(/[A-Z]/g, function (match) { return "-".concat(match.toLowerCase()); });
+};
+var serializeInlineStyle = function (styles) {
+    return Object.entries(styles)
+        .filter(function (_a) {
+        var value = _a[1];
+        return value !== undefined && value !== "";
+    })
+        .map(function (_a) {
+        var property = _a[0], value = _a[1];
+        return "".concat(camelToKebab(property), ":").concat(value);
+    })
+        .join(";");
+};
+exports.serializeInlineStyle = serializeInlineStyle;
+var buildOutputTableStyleAttr = function (tableStyle) {
+    var styles = [
+        "table-layout:fixed",
+        "border-spacing:0",
+        "border-collapse:collapse",
+    ];
+    if (typeof (tableStyle === null || tableStyle === void 0 ? void 0 : tableStyle.width) === "number") {
+        styles.push("width:".concat(tableStyle.width, "%"));
+    }
+    return " style=\"".concat(styles.join(";"), "\"");
+};
+exports.buildOutputTableStyleAttr = buildOutputTableStyleAttr;
+var buildOutputTableCellStyleAttr = function (cellStyle) {
+    var styles = (0, exports.expandOutputTableCellStyle)(__assign(__assign({}, DEFAULT_OUTPUT_TABLE_CELL_STYLE), (cellStyle || {})));
+    var serialized = (0, exports.serializeInlineStyle)(styles);
+    return serialized.length > 0 ? " style=\"".concat(serialized, "\"") : "";
+};
+exports.buildOutputTableCellStyleAttr = buildOutputTableCellStyleAttr;
+var getOutputTableCellStyle = function (option) {
+    return option.meta.cellStyle;
+};
+exports.getOutputTableCellStyle = getOutputTableCellStyle;
+var OUTPUT_TABLE_MARKER_REGEX = /<output-table\s+data-id="(\d+)"\s*><\/output-table>/gi;
+var replaceOutputTableMarkers = function (html, renderTable) {
+    return html.replace(OUTPUT_TABLE_MARKER_REGEX, function (_match, tableId) {
+        return renderTable(parseInt(tableId, 10));
+    });
+};
+exports.replaceOutputTableMarkers = replaceOutputTableMarkers;
+var stripOutputTableMarkers = function (html) {
+    return html.replace(OUTPUT_TABLE_MARKER_REGEX, "");
+};
+exports.stripOutputTableMarkers = stripOutputTableMarkers;

package/dist/libs/regionHelpers.d.ts

@@ -0,0 +1,5 @@
+import type { SectionRoleV3, SectionV3 } from "@legalplace/models-v3-types";
+export type OutputRegionRole = SectionRoleV3;
+export declare const isBodySection: (section: SectionV3) => boolean;
+export declare const isRegionSection: (section: SectionV3, role: OutputRegionRole) => boolean;
+export declare const getSectionIdsForRole: (sections: Record<string, SectionV3>, role: OutputRegionRole) => number[];

package/dist/libs/regionHelpers.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSectionIdsForRole = exports.isRegionSection = exports.isBodySection = void 0;
+var isBodySection = function (section) {
+    return !section.role || section.role === "body";
+};
+exports.isBodySection = isBodySection;
+var isRegionSection = function (section, role) {
+    if (role === "body")
+        return (0, exports.isBodySection)(section);
+    return section.role === role;
+};
+exports.isRegionSection = isRegionSection;
+var getSectionIdsForRole = function (sections, role) {
+    return Object.keys(sections)
+        .map(function (sectionId) { return parseInt(sectionId, 10); })
+        .filter(function (sectionId) {
+        var section = sections[sectionId];
+        return section && (0, exports.isRegionSection)(section, role);
+    });
+};
+exports.getSectionIdsForRole = getSectionIdsForRole;

package/dist/libs/tableOutputExpansion.d.ts

@@ -0,0 +1,20 @@
+import type { ConditionV3 } from "@legalplace/models-v3-types";
+import type ConditionsRunner from "@legalplace/conditions-runner";
+import type { Types } from "@legalplace/referencesparser";
+import { type ExpandTableMarkupContext } from "@legalplace/referencesparser";
+import type InputsType from "@legalplace/types/dist/inputs";
+export declare const evaluateInlineTableCondition: (condition: ConditionV3, contextOptionId: number, occurrenceIndex: number, conditionsRunner: ConditionsRunner, references: Types.ReferencesType, ovc: InputsType) => boolean;
+type CreateTableMarkupContextParams = {
+    references: Types.ReferencesType;
+    ovc: InputsType;
+    conditions: ConditionsRunner;
+    contextOptionId: number;
+    defaultOccurrenceIndex: number;
+};
+export declare const createTableMarkupContext: ({ references, ovc, conditions, contextOptionId, defaultOccurrenceIndex, }: CreateTableMarkupContextParams) => ExpandTableMarkupContext;
+type ExpandOutputTableMarkupParams = CreateTableMarkupContextParams & {
+    output: string;
+};
+export declare const expandOutputTableMarkup: ({ output, references, ovc, conditions, contextOptionId, defaultOccurrenceIndex, }: ExpandOutputTableMarkupParams) => string;
+export declare const cleanupRenderedOutputHtml: (output: string) => string;
+export {};

package/dist/libs/tableOutputExpansion.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupRenderedOutputHtml = exports.expandOutputTableMarkup = exports.createTableMarkupContext = exports.evaluateInlineTableCondition = void 0;
+var lplogic_1 = __importDefault(require("@legalplace/lplogic"));
+var DataPopulator_1 = __importDefault(require("@legalplace/conditions-runner/dist/DataPopulator"));
+var referencesparser_1 = require("@legalplace/referencesparser");
+var OutputParser_1 = require("./OutputParser");
+var extractVariableIds = function (html) {
+    var matches = html.match(/\[var:([0-9]+)\]/gi);
+    if (matches === null)
+        return [];
+    return Array.from(new Set(matches.map(function (tag) {
+        var idMatch = tag.match(/([0-9]+)/);
+        return idMatch ? parseInt(idMatch[1], 10) : 0;
+    }))).filter(function (id) { return id > 0; });
+};
+var evaluateInlineTableCondition = function (condition, contextOptionId, occurrenceIndex, conditionsRunner, references, ovc) {
+    var dataMap = (0, referencesparser_1.extractConditionDataMap)(condition);
+    var currentData = new DataPopulator_1.default(conditionsRunner, references, ovc, dataMap, contextOptionId, occurrenceIndex).getData();
+    var result = (0, lplogic_1.default)((0, referencesparser_1.stripConditionUiMetadata)(condition), currentData);
+    return result !== false;
+};
+exports.evaluateInlineTableCondition = evaluateInlineTableCondition;
+var createTableMarkupContext = function (_a) {
+    var references = _a.references, ovc = _a.ovc, conditions = _a.conditions, contextOptionId = _a.contextOptionId, defaultOccurrenceIndex = _a.defaultOccurrenceIndex;
+    return ({
+        defaultContextOptionId: contextOptionId,
+        defaultOccurrenceIndex: defaultOccurrenceIndex,
+        getOccurrenceInputs: function (multipleOptionId) {
+            return ovc.options[String(multipleOptionId)] || [];
+        },
+        evaluateCondition: function (condition, multipleOptionId, occurrenceIndex) {
+            return (0, exports.evaluateInlineTableCondition)(condition, multipleOptionId, occurrenceIndex, conditions, references, ovc);
+        },
+        substituteVariables: function (html, multipleOptionId, occurrenceIndex) {
+            var variableIds = extractVariableIds(html);
+            var variables = (0, OutputParser_1.getRelatedVariablesValues)(multipleOptionId, occurrenceIndex, variableIds, ovc, references);
+            return (0, OutputParser_1.parseOutputWithVariables)(html, occurrenceIndex, variables, []);
+        },
+    });
+};
+exports.createTableMarkupContext = createTableMarkupContext;
+var expandOutputTableMarkup = function (_a) {
+    var output = _a.output, references = _a.references, ovc = _a.ovc, conditions = _a.conditions, contextOptionId = _a.contextOptionId, defaultOccurrenceIndex = _a.defaultOccurrenceIndex;
+    if (!(0, referencesparser_1.hasTableDynamicMarkup)(output))
+        return output;
+    return (0, referencesparser_1.expandTableMarkup)(output, (0, exports.createTableMarkupContext)({
+        references: references,
+        ovc: ovc,
+        conditions: conditions,
+        contextOptionId: contextOptionId,
+        defaultOccurrenceIndex: defaultOccurrenceIndex,
+    }));
+};
+exports.expandOutputTableMarkup = expandOutputTableMarkup;
+var cleanupRenderedOutputHtml = function (output) {
+    if (output.includes("<table")) {
+        return output.replace(/\xA0/g, " ");
+    }
+    return output
+        .replace(/<\/([a-z]+)>([\n\s]+)</gi, "</$1><")
+        .replace(/\n/g, "<br />")
+        .replace(/\xA0/g, " ");
+};
+exports.cleanupRenderedOutputHtml = cleanupRenderedOutputHtml;

package/dist/types/types.d.ts

@@ -1,17 +1,30 @@
+import type { DocumentLayoutV3 } from "@legalplace/models-v3-types";
 export type DocumentOutputIndex = {
     name: string;
     slug: string;
     pdf: boolean;
     docx: boolean;
+    occurrenceIndex?: number;
 };
 export type DocumentPdfFormIndex = {
     name: string;
     slug: string;
     form: boolean;
     fdf: FDFType;
+    occurrenceIndex?: number;
 };
 export type DocumentIndex = Record<string, DocumentOutputIndex | DocumentPdfFormIndex>;
 export type FDFType = {
     id: string;
     fields: Record<string, string>;
 };
+export type DocumentLayout = {
+    header?: string;
+    footer?: string;
+    firstPageHeader?: string;
+    firstPageFooter?: string;
+    differentFirstPage: boolean;
+    margins?: DocumentLayoutV3["margins"];
+    headerDistance?: number;
+    footerDistance?: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legalplace/prerenderx",
-  "version": "3.8.17",
+  "version": "3.8.18-staging.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.2.14",
+    "@legalplace/conditions-runner": "2.2.15-staging.1",
     "@legalplace/eslint-config-base": "^1.2.0",
-    "@legalplace/lplogic": "2.3.1",
-    "@legalplace/models-v3-types": "^5.17.11",
-    "@legalplace/ovc-converter": "^2.2.14",
+    "@legalplace/lplogic": "2.3.2-staging.0",
+    "@legalplace/models-v3-types": "5.17.17-staging.1",
+    "@legalplace/ovc-converter": "2.2.15-staging.1",
     "@legalplace/prettier-config": "^2.1.3",
-    "@legalplace/referencesparser": "^3.2.31",
+    "@legalplace/referencesparser": "3.2.34-staging.1",
     "@legalplace/yousign": "^0.9.13",
     "crypto": "^1.0.1",
     "standard-version": "^9.3.1"
@@ -36,6 +36,5 @@
     "redux-mock-store": "^1.5.3",
     "ts-jest": "^24.0.2"
   },
-  "prettier": "@legalplace/prettier-config",
-  "gitHead": "66abb0a38764d6b5a41392eba66939a45cafc9ae"
+  "prettier": "@legalplace/prettier-config"
 }

package/src/libs/DocumentRender.ts

@@ -1,5 +1,9 @@
-import type { Types } from "@legalplace/referencesparser";
 import type ConditionsRunner from "@legalplace/conditions-runner";
+import {
+  getSectionIdsForRole,
+  type OutputRegionRole,
+  type Types,
+} from "@legalplace/referencesparser";
 import type InputsType from "@legalplace/types/dist/inputs";
 import SectionRender from "./SectionRender";
 import type NumAuto from "./NumAuto";
@@ -25,18 +29,42 @@ class DocumentRender {
     this.NumAuto = numauto;
   }
 
-  public renderDocument(documentName: string) {
+  /**
+   * Renders a document body. When `baseIndex` is provided (document multiple),
+   * the index is propagated through the section/option render pipeline
+   * so that variables referenced anywhere in the document resolve at the
+   * correct occurrence.
+   */
+  public renderDocument(documentName: string, baseIndex = 0) {
+    return this.renderRegion(documentName, "body", baseIndex);
+  }
+
+  /**
+   * Renders a document output region (body, header, footer, first page variants).
+   */
+  public renderRegion(
+    documentName: string,
+    role: OutputRegionRole,
+    baseIndex = 0
+  ) {
     const documentOutputs: string[] = [];
-    this.NumAuto.resetIndexes();
-    Object.keys(this.references.sections[documentName]).forEach((sectionId) => {
+    if (role === "body") this.NumAuto.resetIndexes();
+
+    const sectionIds = getSectionIdsForRole(
+      this.references.sections[documentName],
+      role
+    );
+
+    sectionIds.forEach((sectionId) => {
       documentOutputs.push(
         ...new SectionRender({
           references: this.references,
           conditions: this.conditions,
           documentName,
           ovc: this.ovc,
-          currentSection: parseInt(sectionId, 10),
+          currentSection: sectionId,
           numauto: this.NumAuto,
+          baseIndex,
         }).getOutputs()
       );
     });