@softwear/latestcollectioncore 1.0.175 → 1.0.177

package/dist/reports.js

@@ -0,0 +1,724 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genPDF = void 0;
+const jspdf_1 = require("jspdf");
+const date_fns_1 = require("date-fns");
+const deepCopy_1 = __importDefault(require("./deepCopy"));
+// We have to declare some functions that will be called by other functions but also have to call those other functions
+// We overwrite the function definition as soon as those other functions have been declared
+/* eslint-disable @typescript-eslint/no-unused-vars */
+let drawStaticPartOfPage = function (doc, layout, printBuffer, paperSize, options, context) {
+    // to be assigned later
+};
+// Forward declaration - parameters intentionally unused, function is overwritten below
+/* eslint-disable @typescript-eslint/no-unused-vars */
+let addObjectToPDF = function (_originX, _originY, _doc, _object, _printBuffer, _paperSize, _layout, _options, _rootPrintBuffer, _containerChain, _context) {
+    // to be assigned later
+    return { x: 0, y: 0 };
+};
+/* eslint-enable @typescript-eslint/no-unused-vars */
+const formatDate = function (date) {
+    return (0, date_fns_1.format)(new Date(date), 'MM-dd-yy HH:mm:ss');
+};
+function getProperty(propertyName, object) {
+    const parts = propertyName.split('.');
+    const length = parts.length;
+    let property = object;
+    for (let i = 0; i < length; i++) {
+        if (property) {
+            property = property[parts[i]];
+        }
+    }
+    return property;
+}
+/** Repeat once over the current buffer when the container is only a visual group (no `source` binding). */
+function containerLoopSource(container, printBuffer) {
+    if (!container.source || container.source === '')
+        return [printBuffer];
+    return getProperty(container.source, printBuffer);
+}
+/** jsPDF font style strings. fontStyle bitmask: 0=normal, 1=bold, 2=italic, 3=bold+italic */
+const FONT_STYLES = ['normal', 'bold', 'italic', 'bolditalic'];
+/** Recursively collect used custom fonts from layout objects (text/field with fontFamily) and layout default. */
+function collectUsedFontsFromLayout(layout, options) {
+    const used = new Set();
+    const isCustomPdfFont = options.isCustomPdfFont || (() => false);
+    function walk(obj) {
+        if ((obj.type === 'text' || obj.type === 'field') && obj.fontFamily && isCustomPdfFont(obj.fontFamily)) {
+            used.add(obj.fontFamily);
+        }
+        if (obj.type === 'container' && obj.children) {
+            obj.children.forEach(walk);
+        }
+    }
+    layout.objects.forEach(walk);
+    if (layout.defaultFontFamily && isCustomPdfFont(layout.defaultFontFamily)) {
+        used.add(layout.defaultFontFamily);
+    }
+    return used;
+}
+function binaryToBase64(binary) {
+    if (typeof btoa === 'function')
+        return btoa(binary);
+    const buffer = globalThis.Buffer;
+    if (buffer)
+        return buffer.from(binary, 'binary').toString('base64');
+    throw new Error('No base64 encoder available');
+}
+function bytesToBase64(bytes) {
+    const buffer = globalThis.Buffer;
+    if (buffer)
+        return buffer.from(bytes).toString('base64');
+    const chunkSize = 8192;
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+        const chunk = bytes.subarray(i, Math.min(i + chunkSize, bytes.length));
+        binary += String.fromCharCode.apply(null, Array.from(chunk));
+    }
+    return binaryToBase64(binary);
+}
+function readUint16BE(bytes, offset) {
+    return (bytes[offset] << 8) | bytes[offset + 1];
+}
+function readUint32BE(bytes, offset) {
+    return bytes[offset] * 0x1000000 + ((bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]);
+}
+function isPng(bytes) {
+    return bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47;
+}
+function isJpeg(bytes) {
+    return bytes[0] === 0xff && bytes[1] === 0xd8;
+}
+function getImageFormat(url, contentType, bytes) {
+    const lowerContentType = (contentType === null || contentType === void 0 ? void 0 : contentType.toLowerCase()) || '';
+    const lowerUrl = url.toLowerCase();
+    if (lowerContentType.includes('png') || isPng(bytes) || lowerUrl.endsWith('.png'))
+        return 'PNG';
+    return 'JPEG';
+}
+function getImageMimeType(format) {
+    return format === 'PNG' ? 'image/png' : 'image/jpeg';
+}
+function getImageDimensions(bytes, format) {
+    if (format === 'PNG' && bytes.length >= 24 && isPng(bytes)) {
+        return { width: readUint32BE(bytes, 16), height: readUint32BE(bytes, 20) };
+    }
+    if (format === 'JPEG' && isJpeg(bytes)) {
+        let offset = 2;
+        while (offset + 9 < bytes.length) {
+            if (bytes[offset] !== 0xff) {
+                offset++;
+                continue;
+            }
+            const marker = bytes[offset + 1];
+            const length = readUint16BE(bytes, offset + 2);
+            const isStartOfFrameMarker = (marker >= 0xc0 && marker <= 0xc3) || (marker >= 0xc5 && marker <= 0xc7) || (marker >= 0xc9 && marker <= 0xcb) || (marker >= 0xcd && marker <= 0xcf);
+            if (isStartOfFrameMarker) {
+                return { height: readUint16BE(bytes, offset + 5), width: readUint16BE(bytes, offset + 7) };
+            }
+            if (length < 2)
+                break;
+            offset += 2 + length;
+        }
+    }
+    return {};
+}
+function loadImageForPdf(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield fetch(url, { mode: 'cors' });
+        if (!res.ok)
+            throw new Error(`Image fetch failed: ${url} ${res.status}`);
+        const arrayBuffer = yield res.arrayBuffer();
+        const bytes = new Uint8Array(arrayBuffer);
+        const format = getImageFormat(url, res.headers.get('content-type'), bytes);
+        const dimensions = getImageDimensions(bytes, format);
+        const dataUrl = `data:${getImageMimeType(format)};base64,${bytesToBase64(bytes)}`;
+        return Object.assign({ dataUrl, format }, dimensions);
+    });
+}
+function resolveImageUrl(object, printBuffer) {
+    if (object.type !== 'image')
+        return undefined;
+    const imgObj = object;
+    return imgObj.source && printBuffer ? getProperty(imgObj.source, printBuffer) : imgObj.url;
+}
+function collectImageUrlsFromLayout(layout, printBuffer) {
+    const urls = new Set();
+    function walk(objects, currentPrintBuffer) {
+        objects.forEach((object) => {
+            if (object.type === 'image') {
+                const imageUrl = resolveImageUrl(object, currentPrintBuffer);
+                if (imageUrl)
+                    urls.add(String(imageUrl));
+                return;
+            }
+            if (object.type !== 'container')
+                return;
+            const source = containerLoopSource(object, currentPrintBuffer);
+            if (!Array.isArray(source))
+                return;
+            source.forEach((containerPrintBuffer) => walk(object.children, containerPrintBuffer));
+        });
+    }
+    walk(layout.objects, printBuffer);
+    return [...urls];
+}
+/** Fetch TTF from URL and return as base64. */
+function fetchFontAsBase64(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield fetch(url, { mode: 'cors' });
+        if (!res.ok)
+            throw new Error(`Font fetch failed: ${url} ${res.status}`);
+        const arrayBuffer = yield res.arrayBuffer();
+        const bytes = new Uint8Array(arrayBuffer);
+        const chunkSize = 8192;
+        let binary = '';
+        for (let i = 0; i < bytes.length; i += chunkSize) {
+            const chunk = bytes.subarray(i, Math.min(i + chunkSize, bytes.length));
+            binary += String.fromCharCode.apply(null, Array.from(chunk));
+        }
+        const base64 = binaryToBase64(binary);
+        return base64;
+    });
+}
+/** Embed custom fonts into jsPDF doc. Only embeds fonts that are actually used. */
+function embedFontsInDoc(doc, usedFontFamilies, options) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const family of usedFontFamilies) {
+            const def = (_a = options.getPdfFontDefinition) === null || _a === void 0 ? void 0 : _a.call(options, family);
+            if (!def) {
+                continue;
+            }
+            if (def.variants.length === 0) {
+                continue;
+            }
+            for (const variant of def.variants) {
+                const vfsName = `${family}-${variant.style}.ttf`;
+                const base64 = yield fetchFontAsBase64(variant.url);
+                doc.addFileToVFS(vfsName, base64);
+                doc.addFont(vfsName, family, variant.style, 'Identity-H');
+            }
+        }
+    });
+}
+function truncateTextToFitWidth(doc, text, maxWidth) {
+    if (doc.getTextWidth(text) <= maxWidth)
+        return text;
+    const ELLIPSIS = '...';
+    let truncatedText = '';
+    for (let i = 0; i < text.length; i++) {
+        const tempText = truncatedText + text[i];
+        if (doc.getTextWidth(tempText + ELLIPSIS) > maxWidth)
+            break;
+        truncatedText = tempText;
+    }
+    return truncatedText + ELLIPSIS;
+}
+function drawSimpleObject(x, y, doc, object, printBuffer, width, height, options, context) {
+    var _a, _b, _c;
+    let text = ''; // Will hold text to display for either 'text' or 'field'
+    // Get text from object for text objects
+    if (object.type == 'text') {
+        text = options.translate ? options.translate(object.text) : object.text;
+    }
+    // Get text from printBuffer for field objects
+    if (object.type == 'field') {
+        if (object.source === 'pageNumber') {
+            text = String(doc.getNumberOfPages());
+        }
+        else if (object.source === 'pageCount') {
+            text = String(context.pageCount || 0);
+        }
+        else if (object.source === 'page') {
+            text = String(doc.getNumberOfPages()) + ' / ' + String(context.pageCount || 0);
+        }
+        else if (object.source && printBuffer) {
+            text = getProperty(object.source, printBuffer);
+        }
+        else {
+            text = printBuffer;
+        }
+        if (typeof text == 'number')
+            text = '' + text;
+        if (object.format == 'date')
+            text = formatDate(parseInt(text));
+        if (text === undefined || typeof text != 'string') {
+            (_a = options.onAlert) === null || _a === void 0 ? void 0 : _a.call(options, { header: 'fieldnotfound', body: object.source, type: 'warning', timeout: 10000 });
+            text = '';
+        }
+        if (object.format == 'currency')
+            text = String.fromCharCode(128) + ' ' + parseFloat(text).toFixed(2);
+    }
+    // Manipulate case as specified in object
+    if ((object.type === 'text' || object.type === 'field') && object.case === 1)
+        text = text.toUpperCase();
+    if ((object.type === 'text' || object.type === 'field') && object.case === 2)
+        text = text.toLowerCase();
+    // Skip actual drawing in measurement mode or when measuring for fillContainer
+    if (context.mode === 'measurement' || context.measureOnly) {
+        return;
+    }
+    // Draw rectangle for rectangle objects (supports backgroundColor, borderRadius, strokeWidth, strokeColor)
+    // fillContainer rectangles are drawn separately as background - skip here to avoid duplicate 1px strip
+    if (object.type == 'rectangle') {
+        const rectObj = object;
+        if (rectObj.fillContainer)
+            return;
+        const hasFill = rectObj.backgroundColor;
+        const radius = (rectObj.borderRadius || 0) / 10; // layout units to mm
+        const hasCustomStroke = rectObj.strokeColor != null || rectObj.strokeWidth != null;
+        if (hasCustomStroke) {
+            if (rectObj.strokeColor) {
+                let hex = String(rectObj.strokeColor).replace(/^#/, '');
+                if (hex.length === 3)
+                    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+                doc.setDrawColor(parseInt(hex.slice(0, 2), 16) || 0, parseInt(hex.slice(2, 4), 16) || 0, parseInt(hex.slice(4, 6), 16) || 0);
+            }
+            if (rectObj.strokeWidth != null)
+                doc.setLineWidth(rectObj.strokeWidth);
+        }
+        if (radius > 0 || hasFill) {
+            if (hasFill) {
+                let hex = String(rectObj.backgroundColor).replace(/^#/, '');
+                if (hex.length === 3)
+                    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+                doc.setFillColor(parseInt(hex.slice(0, 2), 16) || 0, parseInt(hex.slice(2, 4), 16) || 0, parseInt(hex.slice(4, 6), 16) || 0);
+            }
+            if (typeof doc.roundedRect === 'function') {
+                const mode = hasFill ? 'FD' : 'S'; // FD = fill + stroke, S = stroke only
+                doc.roundedRect(x, y, width, height, radius, radius, mode);
+            }
+            else {
+                if (hasFill)
+                    doc.rect(x, y, width, height, 'F');
+                else
+                    doc.rect(x, y, width, height);
+            }
+        }
+        else {
+            doc.rect(x, y, width, height);
+        }
+        if (hasCustomStroke) {
+            doc.setDrawColor(0, 0, 0);
+            doc.setLineWidth(0.35);
+        }
+    }
+    // Draw image for image objects (static url or dynamic source)
+    if (object.type == 'image') {
+        const imgObj = object;
+        const imgUrl = resolveImageUrl(object, printBuffer);
+        if (imgUrl) {
+            const urlLower = String(imgUrl).toLowerCase();
+            const imageAsset = (_b = context.imageAssets) === null || _b === void 0 ? void 0 : _b.get(String(imgUrl));
+            const format = (imageAsset === null || imageAsset === void 0 ? void 0 : imageAsset.format) || (urlLower.endsWith('.png') ? 'PNG' : urlLower.endsWith('.jpg') || urlLower.endsWith('.jpeg') ? 'JPEG' : 'JPEG');
+            let drawX = x;
+            let drawY = y;
+            let drawWidth = width;
+            let drawHeight = height;
+            // Preserve aspect ratio when objectFit is 'contain' and we have dimensions
+            if (imgObj.objectFit === 'contain' && (imageAsset === null || imageAsset === void 0 ? void 0 : imageAsset.width) && (imageAsset === null || imageAsset === void 0 ? void 0 : imageAsset.height)) {
+                const scale = Math.min(width / imageAsset.width, height / imageAsset.height);
+                drawWidth = imageAsset.width * scale;
+                drawHeight = imageAsset.height * scale;
+                drawX = x + (width - drawWidth) / 2;
+                drawY = y + (height - drawHeight) / 2;
+            }
+            try {
+                doc.addImage((imageAsset === null || imageAsset === void 0 ? void 0 : imageAsset.dataUrl) || imgUrl, format, drawX, drawY, drawWidth, drawHeight);
+            }
+            catch (_e) {
+                // Skip if image fails to load (e.g. CORS, invalid URL)
+            }
+        }
+    }
+    // Draw text for text and field objets
+    if ((object.type == 'text' || object.type == 'field') && text) {
+        let textAlign;
+        if (object.textAlign == 1)
+            textAlign = 'left';
+        if (object.textAlign == 2) {
+            textAlign = 'center';
+            x = x + width / 2;
+        }
+        if (object.textAlign == 3) {
+            textAlign = 'right';
+            x = x + width;
+        }
+        if (object.name == 'qty' && text == '0')
+            return;
+        const fontStyleStr = FONT_STYLES[object.fontStyle & 3] || 'normal';
+        // Use object font if it's a custom font; otherwise layout default overrides standard fonts (Helvetica etc.)
+        const fontFamily = object.fontFamily && ((_c = options.isCustomPdfFont) === null || _c === void 0 ? void 0 : _c.call(options, object.fontFamily)) ? object.fontFamily : context.defaultFontFamily || object.fontFamily || 'Helvetica';
+        doc.setFont(fontFamily, fontStyleStr);
+        doc.setFontSize(object.fontSize / 4);
+        doc.text(truncateTextToFitWidth(doc, text, width), x, y, { align: textAlign, baseline: 'hanging' });
+    }
+}
+function addPage(originX, originY, doc, layout, rootPrintBuffer, paperSize, options, containerChain, context) {
+    if (context.mode === 'measurement') {
+        // Track page count in measurement mode
+        if (context.currentPageCount === undefined) {
+            context.currentPageCount = 1;
+        }
+        context.currentPageCount++;
+    }
+    else if (!context.measureOnly) {
+        // Actually add page in rendering mode (skip when measuring for fillContainer)
+        doc.addPage();
+    }
+    if (!context.measureOnly) {
+        drawStaticPartOfPage(doc, layout, rootPrintBuffer, paperSize, options, context);
+    }
+    const absoluteLowerRightHandSide = { x: originX / 10, y: originY / 10 };
+    // Now draw all the parent containers of the current container
+    if (containerChain.length > 0) {
+        // Let origin start at (x,y) of the outermost container
+        originX = containerChain[0].object.x;
+        originY = containerChain[0].object.y;
+        absoluteLowerRightHandSide.x = originX / 10;
+        absoluteLowerRightHandSide.y = originY / 10;
+        containerChain.forEach((link) => {
+            link.object.children.forEach((child) => {
+                if (!child.snapToBottom && (child.type != 'container' || child.repeatOnOverflow)) {
+                    const childLowerRightHandSide = addObjectToPDF(originX, originY, doc, child, link.printBuffer, paperSize, layout, options, rootPrintBuffer, [], context);
+                    absoluteLowerRightHandSide.x = Math.max(absoluteLowerRightHandSide.x, childLowerRightHandSide.x);
+                    absoluteLowerRightHandSide.y = Math.max(absoluteLowerRightHandSide.y, childLowerRightHandSide.y);
+                }
+            });
+            if (link.object.repeatContainer == 'horizontal')
+                originX = absoluteLowerRightHandSide.x * 10;
+            if (link.object.repeatContainer == 'vertical')
+                originY = absoluteLowerRightHandSide.y * 10;
+        });
+    }
+    return { originX: originX, originY: originY, x: absoluteLowerRightHandSide.x, y: absoluteLowerRightHandSide.y };
+}
+function drawBottomDwellers(object, originX, originY, absoluteLowerRightHandSide, bottomChildY, paperSize, doc, layout, rootPrintBuffer, options, newContainerChain, container, context) {
+    let childRelativeToBottomDrawn = false;
+    let firstBottomRelativeChildY = Math.min(...object.children.filter((child) => child.snapToBottom).map((child) => child.y));
+    object.children.forEach(function (child) {
+        if (child.snapToBottom) {
+            // Objects relative to bottom/right
+            if (!childRelativeToBottomDrawn)
+                originY = absoluteLowerRightHandSide.y * 10;
+            childRelativeToBottomDrawn = true;
+            // child.text = '======'+originX+':'+originY+'======'
+            if (object.pageBreak || originY + object.height - bottomChildY > paperSize.height - paperSize.footerHeight) {
+                // We ran out of paper
+                const newOrigin = addPage(originX, originY, doc, layout, rootPrintBuffer, paperSize, options, newContainerChain, context);
+                originX = newOrigin.originX;
+                originY = newOrigin.originY;
+                absoluteLowerRightHandSide = { x: newOrigin.x, y: newOrigin.y };
+                firstBottomRelativeChildY = 0;
+            }
+            // originY = absoluteLowerRightHandSide.y * 10
+            const childLowerRightHandSide = addObjectToPDF(originX, originY - firstBottomRelativeChildY, doc, child, container, paperSize, layout, options, rootPrintBuffer, [], context);
+            absoluteLowerRightHandSide.x = Math.max(absoluteLowerRightHandSide.x, childLowerRightHandSide.x);
+            absoluteLowerRightHandSide.y = Math.max(absoluteLowerRightHandSide.y, childLowerRightHandSide.y);
+            absoluteLowerRightHandSide.y = Math.max(absoluteLowerRightHandSide.y, (originY + object.height - firstBottomRelativeChildY) / 10);
+        }
+    });
+    if (childRelativeToBottomDrawn)
+        originY = absoluteLowerRightHandSide.y * 10;
+    return { originX: originX, originY: originY, x: absoluteLowerRightHandSide.x, y: absoluteLowerRightHandSide.y };
+}
+/**
+ * Add an object to the PDF document.
+ *
+ * Use originX,originY as origin to displace the object's own x,y coordinates
+ */
+addObjectToPDF = function (originX, originY, doc, object, printBuffer, paperSize, layout, options, rootPrintBuffer, containerChain, context) {
+    var _a;
+    const x = (originX + object.x) / 10;
+    const y = (originY + object.y) / 10;
+    const width = object.width / 10;
+    const height = object.height / 10;
+    // Keep track of the lower righthandside of all objects in this container
+    // We need to return this object so whatever calls addObjectToPDF knows how big our drawing was
+    let absoluteLowerRightHandSide = { x: x + width, y: y + height };
+    if (!object.active)
+        return absoluteLowerRightHandSide;
+    if (object.type != 'container')
+        drawSimpleObject(x, y, doc, object, printBuffer, width, height, options, context);
+    // Recursively draw all child objects from a container object
+    if (object.type == 'container') {
+        let originX = x * 10, originY = y * 10;
+        const source = containerLoopSource(object, printBuffer);
+        if (source === undefined) {
+            (_a = options.onAlert) === null || _a === void 0 ? void 0 : _a.call(options, { header: 'containernotfound', body: object.source, type: 'warning', timeout: 10000 });
+            return absoluteLowerRightHandSide;
+        }
+        const nrContainers = source.length;
+        for (let containerIndex = 0; containerIndex < nrContainers; containerIndex++) {
+            const newContainerChain = containerChain.filter(function () {
+                return true;
+            });
+            const container = source[containerIndex];
+            absoluteLowerRightHandSide = { x: originX / 10, y: originY / 10 };
+            const minHeightMm = object.minHeightBeforeBreak;
+            const useOrphanCheck = minHeightMm != null && minHeightMm > 0;
+            if (useOrphanCheck && (object.pageBreak || originY + minHeightMm > paperSize.height - paperSize.footerHeight)) {
+                // We ran out of paper
+                originX = x * 10;
+                originY = y * 10;
+                const newOrigin = addPage(originX, originY, doc, layout, rootPrintBuffer, paperSize, options, newContainerChain, context);
+                originX = newOrigin.originX;
+                originY = newOrigin.originY;
+                absoluteLowerRightHandSide = { x: newOrigin.x, y: newOrigin.y };
+            }
+            // If container has fillContainer rectangles, measure bounds first then draw them as background
+            const fillContainerRects = object.children.filter((c) => c.type === 'rectangle' && c.fillContainer);
+            if (fillContainerRects.length > 0 && !context.measureOnly) {
+                const measureContext = Object.assign(Object.assign({}, context), { measureOnly: true });
+                const measureOriginX = originX;
+                const measureOriginY = originY;
+                const measureBounds = { x: originX / 10, y: originY / 10 };
+                let measureBottomChildY = 0;
+                object.children.forEach(function (child) {
+                    if (child.type != 'container' && !child.snapToBottom) {
+                        measureBottomChildY = Math.max(measureBottomChildY, child.y + child.height);
+                        const r = addObjectToPDF(measureOriginX, measureOriginY, doc, child, container, paperSize, layout, options, rootPrintBuffer, [], measureContext);
+                        measureBounds.x = Math.max(measureBounds.x, r.x);
+                        measureBounds.y = Math.max(measureBounds.y, r.y);
+                    }
+                });
+                const measureChain = [...newContainerChain, { object: object, printBuffer: container }];
+                object.children.forEach(function (child) {
+                    if (child.type == 'container' && !child.snapToBottom) {
+                        measureBottomChildY = Math.max(measureBottomChildY, child.y + child.height);
+                        const r = addObjectToPDF(measureOriginX, measureOriginY, doc, child, container, paperSize, layout, options, rootPrintBuffer, measureChain, measureContext);
+                        measureBounds.x = Math.max(measureBounds.x, r.x);
+                        measureBounds.y = Math.max(measureBounds.y, r.y);
+                    }
+                });
+                const measureBottom = drawBottomDwellers(object, measureOriginX, measureOriginY, { x: measureBounds.x, y: measureBounds.y }, measureBottomChildY, paperSize, doc, layout, rootPrintBuffer, options, measureChain, container, measureContext);
+                measureBounds.y = Math.max(measureBounds.y, measureBottom.y);
+                // Draw fillContainer rectangles as background
+                fillContainerRects.forEach(function (rect) {
+                    const rx = (measureOriginX + rect.x) / 10;
+                    const ry = (measureOriginY + rect.y) / 10;
+                    const rw = rect.width / 10;
+                    const rh = measureBounds.y - ry;
+                    if (rh > 0) {
+                        const rectObj = rect;
+                        const hasFill = rectObj.backgroundColor;
+                        const radius = (rectObj.borderRadius || 0) / 10;
+                        const hasCustomStroke = rectObj.strokeColor != null || rectObj.strokeWidth != null;
+                        if (hasCustomStroke) {
+                            if (rectObj.strokeColor) {
+                                let hex = String(rectObj.strokeColor).replace(/^#/, '');
+                                if (hex.length === 3)
+                                    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+                                doc.setDrawColor(parseInt(hex.slice(0, 2), 16) || 0, parseInt(hex.slice(2, 4), 16) || 0, parseInt(hex.slice(4, 6), 16) || 0);
+                            }
+                            if (rectObj.strokeWidth != null)
+                                doc.setLineWidth(rectObj.strokeWidth);
+                        }
+                        if (hasFill) {
+                            let hex = String(rectObj.backgroundColor).replace(/^#/, '');
+                            if (hex.length === 3)
+                                hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+                            doc.setFillColor(parseInt(hex.slice(0, 2), 16) || 0, parseInt(hex.slice(2, 4), 16) || 0, parseInt(hex.slice(4, 6), 16) || 0);
+                        }
+                        if (typeof doc.roundedRect === 'function') {
+                            doc.roundedRect(rx, ry, rw, rh, radius, radius, hasFill ? 'FD' : 'S');
+                        }
+                        else {
+                            if (hasFill)
+                                doc.rect(rx, ry, rw, rh, 'F');
+                            else
+                                doc.rect(rx, ry, rw, rh);
+                        }
+                        if (hasCustomStroke) {
+                            doc.setDrawColor(0, 0, 0);
+                            doc.setLineWidth(0.35);
+                        }
+                    }
+                });
+            }
+            // normal objects first, then containers
+            let bottomChildY = 0;
+            object.children.forEach(function (child) {
+                if (child.type != 'container' && !child.snapToBottom) {
+                    // Objects relative to top/left
+                    bottomChildY = Math.max(bottomChildY, child.y + child.height);
+                    const childLowerRightHandSide = addObjectToPDF(originX, originY, doc, child, container, paperSize, layout, options, rootPrintBuffer, [], context);
+                    absoluteLowerRightHandSide.x = Math.max(absoluteLowerRightHandSide.x, childLowerRightHandSide.x);
+                    absoluteLowerRightHandSide.y = Math.max(absoluteLowerRightHandSide.y, childLowerRightHandSide.y);
+                }
+            });
+            newContainerChain.push({ object: object, printBuffer: container });
+            object.children.forEach(function (child) {
+                if (child.type == 'container' && !child.snapToBottom) {
+                    bottomChildY = Math.max(bottomChildY, child.y + child.height);
+                    const childLowerRightHandSide = addObjectToPDF(originX, originY, doc, child, container, paperSize, layout, options, rootPrintBuffer, newContainerChain, context);
+                    absoluteLowerRightHandSide.x = Math.max(absoluteLowerRightHandSide.x, childLowerRightHandSide.x);
+                    absoluteLowerRightHandSide.y = Math.max(absoluteLowerRightHandSide.y, childLowerRightHandSide.y);
+                }
+            });
+            if (containerIndex < nrContainers - 1) {
+                if (object.repeatContainer == 'horizontal')
+                    originX = absoluteLowerRightHandSide.x * 10;
+                if (object.repeatContainer == 'vertical')
+                    originY = absoluteLowerRightHandSide.y * 10;
+                if (object.pageBreak || originY + object.height - bottomChildY > paperSize.height - paperSize.footerHeight) {
+                    // We ran out of paper
+                    const newOrigin = addPage(originX, originY, doc, layout, rootPrintBuffer, paperSize, options, newContainerChain, context);
+                    originX = newOrigin.originX;
+                    originY = newOrigin.originY;
+                    absoluteLowerRightHandSide = { x: newOrigin.x, y: newOrigin.y };
+                    const newestOrigin = drawBottomDwellers(object, originX, originY, absoluteLowerRightHandSide, bottomChildY, paperSize, doc, layout, rootPrintBuffer, options, newContainerChain, container, context);
+                    originX = newestOrigin.originX;
+                    originY = newestOrigin.originY;
+                    absoluteLowerRightHandSide = { x: newestOrigin.x, y: newestOrigin.y };
+                    continue;
+                }
+            }
+            const newestOrigin = drawBottomDwellers(object, originX, originY, absoluteLowerRightHandSide, bottomChildY, paperSize, doc, layout, rootPrintBuffer, options, newContainerChain, container, context);
+            originX = newestOrigin.originX;
+            originY = newestOrigin.originY;
+            absoluteLowerRightHandSide = { x: newestOrigin.x, y: newestOrigin.y };
+        }
+    }
+    return absoluteLowerRightHandSide;
+};
+/**
+ * Draw all non-container objects on the page
+ */
+drawStaticPartOfPage = function (doc, layout, printBuffer, paperSize, options, context) {
+    layout.objects.forEach(function (object) {
+        if (object.type != 'container') {
+            addObjectToPDF(0, 0, doc, object, printBuffer, paperSize, layout, options, printBuffer, [], context);
+        }
+    });
+};
+function sortVertical(objects) {
+    objects.sort((a, b) => a.y - b.y);
+    objects.forEach((element) => {
+        if (element.children)
+            sortVertical(element.children);
+    });
+}
+function genPDF(layout, printBuffer, options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Make a deep copy of the layout so we can add temporary properties
+        layout = (0, deepCopy_1.default)(layout);
+        sortVertical(layout.objects);
+        // Load images for static images
+        layout.objects.forEach((object) => {
+            var _a;
+            if (object.type != 'image')
+                return;
+            if (object.name == 'Logo') {
+                const logoUrl = (_a = options.resolveLogoUrl) === null || _a === void 0 ? void 0 : _a.call(options);
+                if (logoUrl)
+                    object.url = logoUrl;
+            }
+        });
+        // Preload image bytes for Node.js and dimensions for objectFit:contain
+        const imageAssets = new Map();
+        const loadImage = options.loadImage || loadImageForPdf;
+        const urls = collectImageUrlsFromLayout(layout, printBuffer);
+        yield Promise.all(urls.map((url) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const asset = yield loadImage(url);
+                if (asset)
+                    imageAssets.set(url, asset);
+            }
+            catch (_a) {
+                // Ignore load failures; jsPDF will still get the original URL as fallback
+            }
+        })));
+        const paperSize = layout.paperSize;
+        const paperSizeCopy = Object.assign({}, paperSize);
+        paperSize.width *= 10;
+        paperSize.height *= 10;
+        paperSize.footerHeight *= 10;
+        // First pass: Measurement mode - count pages without rendering
+        const measurementContext = {
+            mode: 'measurement',
+            currentPageCount: 1, // Start with page 1
+        };
+        // Create a minimal jsPDF instance for measurement (needed for some calculations)
+        const measurementDoc = new jspdf_1.jsPDF({
+            orientation: paperSizeCopy.width > paperSizeCopy.height ? 'landscape' : 'portrait',
+            format: [paperSizeCopy.width, paperSizeCopy.height],
+        });
+        const usedFonts = collectUsedFontsFromLayout(layout, options);
+        if (usedFonts.size > 0) {
+            yield embedFontsInDoc(measurementDoc, usedFonts, options);
+        }
+        drawStaticPartOfPage(measurementDoc, layout, printBuffer, paperSize, options, measurementContext);
+        // Draw containers in measurement mode (same order as render)
+        layout.objects
+            .filter((object) => object.type == 'container' && object.printOnlyAtStart)
+            .forEach((object) => {
+            addObjectToPDF(0, 0, measurementDoc, object, printBuffer, paperSize, layout, options, printBuffer, [], measurementContext);
+        });
+        layout.objects
+            .filter((object) => object.type == 'container' &&
+            !object.printOnlyAtEnd &&
+            !object.printOnlyAtStart)
+            .forEach((object) => {
+            addObjectToPDF(0, 0, measurementDoc, object, printBuffer, paperSize, layout, options, printBuffer, [], measurementContext);
+        });
+        layout.objects
+            .filter((object) => object.type == 'container' && object.printOnlyAtEnd)
+            .forEach((object) => {
+            addObjectToPDF(0, 0, measurementDoc, object, printBuffer, paperSize, layout, options, printBuffer, [], measurementContext);
+        });
+        // Get total page count from measurement pass
+        const totalPageCount = measurementContext.currentPageCount || 1;
+        // Second pass: Rendering mode - actual PDF generation with pageCount available
+        const doc = new jspdf_1.jsPDF({
+            orientation: paperSizeCopy.width > paperSizeCopy.height ? 'landscape' : 'portrait',
+            format: [paperSizeCopy.width, paperSizeCopy.height],
+        });
+        if (usedFonts.size > 0) {
+            yield embedFontsInDoc(doc, usedFonts, options);
+        }
+        const renderContext = {
+            mode: 'rendering',
+            pageCount: totalPageCount,
+            imageAssets,
+            defaultFontFamily: layout.defaultFontFamily,
+        };
+        drawStaticPartOfPage(doc, layout, printBuffer, paperSize, options, renderContext);
+        layout.objects
+            .filter((object) => object.type == 'container' && object.printOnlyAtStart)
+            .forEach((object) => {
+            addObjectToPDF(0, 0, doc, object, printBuffer, paperSize, layout, options, printBuffer, [], renderContext);
+        });
+        // Draw containers in rendering mode (body containers after printOnlyAtStart)
+        layout.objects
+            .filter((object) => object.type == 'container' &&
+            !object.printOnlyAtEnd &&
+            !object.printOnlyAtStart)
+            .forEach((object) => {
+            addObjectToPDF(0, 0, doc, object, printBuffer, paperSize, layout, options, printBuffer, [], renderContext);
+        });
+        // Draw printOnlyAtEnd containers once at the end (at their layout coordinates on current page)
+        const printOnlyAtEndContainers = layout.objects.filter((object) => object.type == 'container' && object.printOnlyAtEnd);
+        printOnlyAtEndContainers.forEach((object) => {
+            addObjectToPDF(0, 0, doc, object, printBuffer, paperSize, layout, options, printBuffer, [], renderContext);
+        });
+        return doc;
+    });
+}
+exports.genPDF = genPDF;
+exports.default = {
+    genPDF,
+};