@softwear/latestcollectioncore 1.0.174 → 1.0.176

package/src/reports.ts

@@ -0,0 +1,831 @@
+import { jsPDF } from 'jspdf'
+import { format } from 'date-fns'
+import deepCopy from './deepCopy'
+import { PaperSize, Layout, LayoutObject, ContainerLayoutObject } from './pdf'
+
+type RenderMode = 'measurement' | 'rendering'
+
+export interface GenPdfAlert {
+  header: string
+  body?: string
+  type?: 'warning' | 'error' | 'success' | 'info'
+  timeout?: number
+}
+
+export interface PdfFontVariant {
+  style: 'normal' | 'bold' | 'italic' | 'bolditalic'
+  url: string
+}
+
+export interface PdfFontDefinition {
+  family: string
+  variants: PdfFontVariant[]
+}
+
+export interface PdfImageAsset {
+  dataUrl: string
+  format: 'PNG' | 'JPEG'
+  width?: number
+  height?: number
+}
+
+export interface GenPdfOptions {
+  onAlert?: (alert: GenPdfAlert) => void
+  translate?: (key: string) => string
+  resolveLogoUrl?: () => string | undefined
+  isCustomPdfFont?: (fontFamily: string) => boolean
+  getPdfFontDefinition?: (fontFamily: string) => PdfFontDefinition | undefined
+  loadImage?: (url: string) => Promise<PdfImageAsset | undefined>
+}
+
+interface RenderContext {
+  mode: RenderMode
+  pageCount?: number
+  currentPageCount?: number // For measurement mode
+  measureOnly?: boolean // When true, skip drawing to measure bounds (for fillContainer rectangles)
+  imageAssets?: Map<string, PdfImageAsset>
+  /** Layout default font used when object.fontFamily is undefined */
+  defaultFontFamily?: string
+}
+
+// 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: jsPDF, layout: Layout, printBuffer: any, paperSize: PaperSize, options: GenPdfOptions, context: RenderContext): void {
+  // to be assigned later
+}
+
+// Forward declaration - parameters intentionally unused, function is overwritten below
+/* eslint-disable @typescript-eslint/no-unused-vars */
+let addObjectToPDF = function (
+  _originX: number,
+  _originY: number,
+  _doc: jsPDF,
+  _object: LayoutObject,
+  _printBuffer: any,
+  _paperSize: PaperSize,
+  _layout: Layout,
+  _options: GenPdfOptions,
+  _rootPrintBuffer: any,
+  _containerChain: { object: ContainerLayoutObject; printBuffer: any }[],
+  _context: RenderContext
+): { x: number; y: number } {
+  // to be assigned later
+  return { x: 0, y: 0 }
+}
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
+const formatDate = function (date: number | string): string {
+  return format(new Date(date), 'MM-dd-yy HH:mm:ss')
+}
+
+function getProperty(propertyName: string, object: any): any {
+  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
+}
+
+/** jsPDF font style strings. fontStyle bitmask: 0=normal, 1=bold, 2=italic, 3=bold+italic */
+const FONT_STYLES = ['normal', 'bold', 'italic', 'bolditalic'] as const
+
+/** Recursively collect used custom fonts from layout objects (text/field with fontFamily) and layout default. */
+function collectUsedFontsFromLayout(layout: Layout, options: GenPdfOptions): Set<string> {
+  const used = new Set<string>()
+  const isCustomPdfFont = options.isCustomPdfFont || (() => false)
+  function walk(obj: LayoutObject) {
+    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: string): string {
+  if (typeof btoa === 'function') return btoa(binary)
+
+  const buffer = (globalThis as any).Buffer
+  if (buffer) return buffer.from(binary, 'binary').toString('base64')
+
+  throw new Error('No base64 encoder available')
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+  const buffer = (globalThis as any).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: Uint8Array, offset: number): number {
+  return (bytes[offset] << 8) | bytes[offset + 1]
+}
+
+function readUint32BE(bytes: Uint8Array, offset: number): number {
+  return bytes[offset] * 0x1000000 + ((bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3])
+}
+
+function isPng(bytes: Uint8Array): boolean {
+  return bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47
+}
+
+function isJpeg(bytes: Uint8Array): boolean {
+  return bytes[0] === 0xff && bytes[1] === 0xd8
+}
+
+function getImageFormat(url: string, contentType: string | null, bytes: Uint8Array): 'PNG' | 'JPEG' {
+  const lowerContentType = contentType?.toLowerCase() || ''
+  const lowerUrl = url.toLowerCase()
+  if (lowerContentType.includes('png') || isPng(bytes) || lowerUrl.endsWith('.png')) return 'PNG'
+  return 'JPEG'
+}
+
+function getImageMimeType(format: 'PNG' | 'JPEG'): string {
+  return format === 'PNG' ? 'image/png' : 'image/jpeg'
+}
+
+function getImageDimensions(bytes: Uint8Array, format: 'PNG' | 'JPEG'): { width?: number; height?: number } {
+  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 {}
+}
+
+async function loadImageForPdf(url: string): Promise<PdfImageAsset> {
+  const res = await fetch(url, { mode: 'cors' })
+  if (!res.ok) throw new Error(`Image fetch failed: ${url} ${res.status}`)
+
+  const arrayBuffer = await 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 { dataUrl, format, ...dimensions }
+}
+
+function resolveImageUrl(object: LayoutObject, printBuffer: any): string | undefined {
+  if (object.type !== 'image') return undefined
+  const imgObj = object as any
+  return imgObj.source && printBuffer ? getProperty(imgObj.source, printBuffer) : imgObj.url
+}
+
+function collectImageUrlsFromLayout(layout: Layout, printBuffer: any): string[] {
+  const urls = new Set<string>()
+
+  function walk(objects: LayoutObject[], currentPrintBuffer: any) {
+    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 = (object as any).printOnlyAtEnd === true && (!object.source || object.source === '') ? [currentPrintBuffer] : getProperty(object.source, 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. */
+async function fetchFontAsBase64(url: string): Promise<string> {
+  const res = await fetch(url, { mode: 'cors' })
+  if (!res.ok) throw new Error(`Font fetch failed: ${url} ${res.status}`)
+  const arrayBuffer = await 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. */
+async function embedFontsInDoc(doc: jsPDF, usedFontFamilies: Set<string>, options: GenPdfOptions): Promise<void> {
+  for (const family of usedFontFamilies) {
+    const def = options.getPdfFontDefinition?.(family)
+    if (!def) {
+      continue
+    }
+    if (def.variants.length === 0) {
+      continue
+    }
+    for (const variant of def.variants) {
+      const vfsName = `${family}-${variant.style}.ttf`
+      const base64 = await fetchFontAsBase64(variant.url)
+      doc.addFileToVFS(vfsName, base64)
+      doc.addFont(vfsName, family, variant.style, 'Identity-H')
+    }
+  }
+}
+
+function truncateTextToFitWidth(doc: jsPDF, text: string, maxWidth: number): string {
+  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: number,
+  y: number,
+  doc: jsPDF,
+  object: LayoutObject,
+  printBuffer: any,
+  width: number,
+  height: number,
+  options: GenPdfOptions,
+  context: RenderContext
+): void {
+  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') {
+      options.onAlert?.({ 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 as any
+    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 as any
+    const imgUrl = resolveImageUrl(object, printBuffer)
+    if (imgUrl) {
+      const urlLower = String(imgUrl).toLowerCase()
+      const imageAsset = context.imageAssets?.get(String(imgUrl))
+      const format = 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?.width && 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?.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: 'left' | 'center' | 'right' | undefined
+    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 && options.isCustomPdfFont?.(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: number,
+  originY: number,
+  doc: jsPDF,
+  layout: Layout,
+  rootPrintBuffer: any,
+  paperSize: PaperSize,
+  options: GenPdfOptions,
+  containerChain: { object: ContainerLayoutObject; printBuffer: any }[],
+  context: RenderContext
+): { originX: number; originY: number; x: number; y: number } {
+  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: ContainerLayoutObject,
+  originX: number,
+  originY: number,
+  absoluteLowerRightHandSide: { x: number; y: number },
+  bottomChildY: number,
+  paperSize: PaperSize,
+  doc: jsPDF,
+  layout: Layout,
+  rootPrintBuffer: any,
+  options: GenPdfOptions,
+  newContainerChain: { object: ContainerLayoutObject; printBuffer: any }[],
+  container: any,
+  context: RenderContext
+): { originX: number; originY: number; x: number; y: number } {
+  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: number,
+  originY: number,
+  doc: jsPDF,
+  object: LayoutObject,
+  printBuffer: any,
+  paperSize: PaperSize,
+  layout: Layout,
+  options: GenPdfOptions,
+  rootPrintBuffer: any,
+  containerChain: { object: ContainerLayoutObject; printBuffer: any }[],
+  context: RenderContext
+): { x: number; y: number } {
+  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 isPrintOnlyAtEnd = (object as any).printOnlyAtEnd === true
+    const source = isPrintOnlyAtEnd && (!object.source || object.source === '') ? [printBuffer] : getProperty(object.source, printBuffer)
+    if (source === undefined) {
+      options.onAlert?.({ 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 as any).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: any) => c.type === 'rectangle' && c.fillContainer)
+      if (fillContainerRects.length > 0 && !context.measureOnly) {
+        const measureContext = { ...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: any) {
+          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 as ContainerLayoutObject, printBuffer: container }]
+        object.children.forEach(function (child: any) {
+          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 as ContainerLayoutObject,
+          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: any) {
+          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 as any
+            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 as ContainerLayoutObject, 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 as ContainerLayoutObject,
+            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 as ContainerLayoutObject,
+        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: jsPDF, layout: Layout, printBuffer: any, paperSize: PaperSize, options: GenPdfOptions, context: RenderContext): void {
+  layout.objects.forEach(function (object) {
+    if (object.type != 'container') {
+      addObjectToPDF(0, 0, doc, object, printBuffer, paperSize, layout, options, printBuffer, [], context)
+    }
+  })
+}
+
+function sortVertical(objects: LayoutObject[]): void {
+  objects.sort((a, b) => a.y - b.y)
+  objects.forEach((element) => {
+    if ((element as ContainerLayoutObject).children) sortVertical((element as ContainerLayoutObject).children)
+  })
+}
+
+export async function genPDF(layout: Layout, printBuffer: any, options: GenPdfOptions = {}): Promise<jsPDF> {
+  // Make a deep copy of the layout so we can add temporary properties
+  layout = deepCopy(layout)
+  sortVertical(layout.objects)
+  // Load images for static images
+  layout.objects.forEach((object) => {
+    if (object.type != 'image') return
+    if (object.name == 'Logo') {
+      const logoUrl = options.resolveLogoUrl?.()
+      if (logoUrl) object.url = logoUrl
+    }
+  })
+  // Preload image bytes for Node.js and dimensions for objectFit:contain
+  const imageAssets = new Map<string, PdfImageAsset>()
+  const loadImage = options.loadImage || loadImageForPdf
+  const urls = collectImageUrlsFromLayout(layout, printBuffer)
+  await Promise.all(
+    urls.map(async (url) => {
+      try {
+        const asset = await loadImage(url)
+        if (asset) imageAssets.set(url, asset)
+      } catch {
+        // Ignore load failures; jsPDF will still get the original URL as fallback
+      }
+    })
+  )
+  const paperSize = layout.paperSize
+  const paperSizeCopy = { ...paperSize }
+  paperSize.width *= 10
+  paperSize.height *= 10
+  paperSize.footerHeight *= 10
+
+  // First pass: Measurement mode - count pages without rendering
+  const measurementContext: RenderContext = {
+    mode: 'measurement',
+    currentPageCount: 1, // Start with page 1
+  }
+  // Create a minimal jsPDF instance for measurement (needed for some calculations)
+  const measurementDoc = new jsPDF({
+    orientation: paperSizeCopy.width > paperSizeCopy.height ? 'landscape' : 'portrait',
+    format: [paperSizeCopy.width, paperSizeCopy.height],
+  })
+  const usedFonts = collectUsedFontsFromLayout(layout, options)
+  if (usedFonts.size > 0) {
+    await embedFontsInDoc(measurementDoc, usedFonts, options)
+  }
+  drawStaticPartOfPage(measurementDoc, layout, printBuffer, paperSize, options, measurementContext)
+
+  // Draw containers in measurement mode (same order as render: normal first, then printOnlyAtEnd on fresh page)
+  layout.objects
+    .filter((object) => object.type == 'container' && !(object as any).printOnlyAtEnd)
+    .forEach((object) => {
+      addObjectToPDF(0, 0, measurementDoc, object, printBuffer, paperSize, layout, options, printBuffer, [], measurementContext)
+    })
+  layout.objects
+    .filter((object) => object.type == 'container' && (object as any).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({
+    orientation: paperSizeCopy.width > paperSizeCopy.height ? 'landscape' : 'portrait',
+    format: [paperSizeCopy.width, paperSizeCopy.height],
+  })
+  if (usedFonts.size > 0) {
+    await embedFontsInDoc(doc, usedFonts, options)
+  }
+  const renderContext: RenderContext = {
+    mode: 'rendering',
+    pageCount: totalPageCount,
+    imageAssets,
+    defaultFontFamily: layout.defaultFontFamily,
+  }
+  drawStaticPartOfPage(doc, layout, printBuffer, paperSize, options, renderContext)
+
+  // Draw containers in rendering mode (normal containers first)
+  layout.objects
+    .filter((object) => object.type == 'container' && !(object as any).printOnlyAtEnd)
+    .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 as any).printOnlyAtEnd)
+  printOnlyAtEndContainers.forEach((object) => {
+    addObjectToPDF(0, 0, doc, object, printBuffer, paperSize, layout, options, printBuffer, [], renderContext)
+  })
+  return doc
+}
+
+export default {
+  genPDF,
+}