@cj-tech-master/excelts 8.1.2 → 9.0.0

package/dist/browser/modules/pdf/render/layout-engine.js

@@ -19,20 +19,86 @@
 import { PdfCellType } from "../types.js";
 import { resolvePdfFontName } from "../font/font-manager.js";
 import { extractFontProperties, excelFillToPdfColor, excelBordersToPdf, excelHAlignToPdf, excelVAlignToPdf } from "./style-converter.js";
+import { wrapTextLines } from "./page-renderer.js";
+import { CELL_PADDING_H, CELL_PADDING_V, LINE_HEIGHT_FACTOR, INDENT_WIDTH, MAX_DIGIT_WIDTH_PX, EXCEL_COLUMN_PADDING_PX, PX_TO_PT } from "./constants.js";
+import { yieldToEventLoop } from "../../../utils/utils.base.js";
 // =============================================================================
 // Constants
 // =============================================================================
-const EXCEL_CHAR_WIDTH_TO_POINTS = 7;
 const DEFAULT_COLUMN_WIDTH = 8.43;
 const DEFAULT_ROW_HEIGHT = 15;
-const MIN_COLUMN_WIDTH = 5;
+const MIN_COLUMN_WIDTH = 3;
+// =============================================================================
+// Type-based Default Alignment
+// =============================================================================
+/**
+ * Resolve horizontal alignment, using Excel's type-based defaults when
+ * no explicit alignment is set (or when alignment is "general"):
+ * - Numbers/Dates → right
+ * - Booleans/Errors → center
+ * - Text/RichText/Hyperlink → left
+ * - Formulas → based on result type
+ */
+function resolveHorizontalAlign(alignment, cellType, formulaResult) {
+    // If explicitly set (and not "general"), use the explicit alignment
+    if (alignment?.horizontal && alignment.horizontal !== "general") {
+        return excelHAlignToPdf(alignment);
+    }
+    // Use type-based default
+    if (cellType !== undefined) {
+        switch (cellType) {
+            case PdfCellType.Number:
+            case PdfCellType.Date:
+                return "right";
+            case PdfCellType.Boolean:
+            case PdfCellType.Error:
+                return "center";
+            case PdfCellType.Formula:
+                if (typeof formulaResult === "number" || formulaResult instanceof Date) {
+                    return "right";
+                }
+                if (typeof formulaResult === "boolean") {
+                    return "center";
+                }
+                return "left";
+            default:
+                return "left";
+        }
+    }
+    return "left";
+}
 // =============================================================================
 // Layout Engine
 // =============================================================================
 /**
  * Compute the layout for a sheet across one or more PDF pages.
+ * Yields to the event loop between each output page.
  */
-export function layoutSheet(sheet, options, fontManager) {
+export async function layoutSheet(sheet, options, fontManager) {
+    const ctx = prepareLayout(sheet, options, fontManager);
+    if (!ctx) {
+        return [createEmptyPage(sheet, options)];
+    }
+    const layoutPages = [];
+    const totalOutputPages = ctx.rowPages.length * ctx.colGroups.length;
+    for (const rowPage of ctx.rowPages) {
+        for (const colGroup of ctx.colGroups) {
+            layoutPages.push(buildPageLayout(ctx, rowPage, colGroup, layoutPages.length, sheet, options, fontManager));
+            if (layoutPages.length < totalOutputPages) {
+                await yieldToEventLoop();
+            }
+        }
+    }
+    if (layoutPages.length > 0 && sheet.images) {
+        assignImagesToPages(sheet.images, layoutPages, ctx.scaleFactor);
+    }
+    return layoutPages;
+}
+/**
+ * Steps 1–5: compute columns, scale, rows, merges, pagination.
+ * Returns null if the sheet has no visible columns (→ caller should emit an empty page).
+ */
+function prepareLayout(sheet, options, fontManager) {
     const { margins } = options;
     let pageWidth = options.pageSize.width;
     let pageHeight = options.pageSize.height;
@@ -44,13 +110,11 @@ export function layoutSheet(sheet, options, fontManager) {
     const headerHeight = options.showSheetNames ? 20 : 0;
     const footerHeight = options.showPageNumbers ? 20 : 0;
     const availableHeight = contentHeight - headerHeight - footerHeight;
-    // Determine print area bounds (if set)
     const printRange = getPrintRange(sheet);
     // --- Step 1: Visible columns and widths ---
     const { columnWidths, visibleCols } = computeColumnWidths(sheet, printRange);
-    const columnCount = visibleCols.length;
-    if (columnCount === 0) {
-        return [emptyPage(pageWidth, pageHeight, sheet.name, options)];
+    if (visibleCols.length === 0) {
+        return null;
     }
     // --- Step 2: Scale ---
     const totalTableWidth = columnWidths.reduce((sum, w) => sum + w, 0);
@@ -63,136 +127,159 @@ export function layoutSheet(sheet, options, fontManager) {
     }
     const scaledColumnWidths = columnWidths.map(w => w * scaleFactor);
     // --- Step 3: Visible rows and heights ---
-    const { rowHeights, visibleRows } = computeRowHeights(sheet, scaleFactor, printRange);
+    const { rowHeights, visibleRows } = computeRowHeights(sheet, scaleFactor, printRange, fontManager, options);
     // --- Step 4: Merge map ---
     const mergeMap = buildMergeMap(sheet);
-    // --- Step 5: Paginate vertically (rows) and horizontally (columns) ---
+    // --- Step 5: Paginate ---
     const repeatRowCount = typeof options.repeatRows === "number" ? options.repeatRows : 0;
     const rowBreakSet = buildRowBreakSet(sheet, visibleRows);
     const rowPages = paginateRows(rowHeights, availableHeight, repeatRowCount, rowBreakSet);
     const colGroups = paginateColumns(scaledColumnWidths, contentWidth, sheet, visibleCols);
-    // --- Step 6: Layout cells per page (row page × column page) ---
-    const layoutPages = [];
-    for (const rowPage of rowPages) {
-        for (const colGroup of colGroups) {
-            const cells = [];
-            // Compute column offsets for this column group
-            const groupColWidths = colGroup.map(ci => scaledColumnWidths[ci]);
-            const groupTotalWidth = groupColWidths.reduce((s, w) => s + w, 0);
-            const groupColOffsets = [];
-            let gx = margins.left;
-            if (groupTotalWidth < contentWidth) {
-                gx = margins.left + (contentWidth - groupTotalWidth) / 2;
-            }
-            for (const w of groupColWidths) {
-                groupColOffsets.push(gx);
-                gx += w;
-            }
-            // Row Y positions
-            const rowYPositions = [];
-            const pageRowHeights = [];
-            let currentY = pageHeight - margins.top - headerHeight;
-            for (const rowIdx of rowPage) {
-                const rowH = rowHeights[rowIdx] ?? DEFAULT_ROW_HEIGHT * scaleFactor;
-                rowYPositions.push(currentY);
-                pageRowHeights.push(rowH);
-                currentY -= rowH;
+    return {
+        pageWidth,
+        pageHeight,
+        contentWidth,
+        headerHeight,
+        scaleFactor,
+        scaledColumnWidths,
+        rowHeights,
+        visibleRows,
+        visibleCols,
+        mergeMap,
+        rowPages,
+        colGroups,
+        margins
+    };
+}
+/**
+ * Build the LayoutPage for a single rowPage × colGroup combination.
+ */
+function buildPageLayout(ctx, rowPage, colGroup, currentPageCount, sheet, options, fontManager) {
+    const { scaledColumnWidths, rowHeights, visibleRows, visibleCols, mergeMap, pageWidth, pageHeight, contentWidth, headerHeight, scaleFactor, margins } = ctx;
+    const cells = [];
+    // Compute column offsets for this column group
+    const groupColWidths = colGroup.map(ci => scaledColumnWidths[ci]);
+    const groupTotalWidth = groupColWidths.reduce((s, w) => s + w, 0);
+    const groupColOffsets = [];
+    let gx = margins.left;
+    if (groupTotalWidth < contentWidth) {
+        gx = margins.left + (contentWidth - groupTotalWidth) / 2;
+    }
+    for (const w of groupColWidths) {
+        groupColOffsets.push(gx);
+        gx += w;
+    }
+    // Row Y positions
+    const rowYPositions = [];
+    const pageRowHeights = [];
+    let currentY = pageHeight - margins.top - headerHeight;
+    for (const rowIdx of rowPage) {
+        const rowH = rowHeights[rowIdx] ?? DEFAULT_ROW_HEIGHT * scaleFactor;
+        rowYPositions.push(currentY);
+        pageRowHeights.push(rowH);
+        currentY -= rowH;
+    }
+    // Build cells for this row page × column group
+    const cellGrid = new Map();
+    for (let ri = 0; ri < rowPage.length; ri++) {
+        const visibleRowIdx = rowPage[ri];
+        const wsRowNumber = visibleRows[visibleRowIdx];
+        for (let gci = 0; gci < colGroup.length; gci++) {
+            const ci = colGroup[gci];
+            const wsColNumber = visibleCols[ci];
+            const mergeKey = `${wsRowNumber}:${wsColNumber}`;
+            const mergeInfo = mergeMap.get(mergeKey);
+            if (mergeInfo && !mergeInfo.isMaster) {
+                continue;
             }
-            // Build cells for this row page × column group
-            for (let ri = 0; ri < rowPage.length; ri++) {
-                const visibleRowIdx = rowPage[ri];
-                const wsRowNumber = visibleRows[visibleRowIdx];
-                for (let gci = 0; gci < colGroup.length; gci++) {
-                    const ci = colGroup[gci]; // index into visibleCols
-                    const wsColNumber = visibleCols[ci];
-                    const mergeKey = `${wsRowNumber}:${wsColNumber}`;
-                    const mergeInfo = mergeMap.get(mergeKey);
-                    if (mergeInfo && !mergeInfo.isMaster) {
-                        continue;
+            const row = sheet.rows.get(wsRowNumber);
+            const cell = row?.cells.get(wsColNumber);
+            let colSpan = 1;
+            let rowSpan = 1;
+            if (mergeInfo && mergeInfo.isMaster) {
+                const mergeEndCol = wsColNumber + mergeInfo.colSpan - 1;
+                colSpan = 0;
+                for (let s = gci; s < colGroup.length; s++) {
+                    if (visibleCols[colGroup[s]] <= mergeEndCol) {
+                        colSpan++;
                     }
-                    const row = sheet.rows.get(wsRowNumber);
-                    const cell = row?.cells.get(wsColNumber);
-                    let colSpan = 1;
-                    let rowSpan = 1;
-                    if (mergeInfo && mergeInfo.isMaster) {
-                        const mergeEndCol = wsColNumber + mergeInfo.colSpan - 1;
-                        colSpan = 0;
-                        for (let s = gci; s < colGroup.length; s++) {
-                            if (visibleCols[colGroup[s]] <= mergeEndCol) {
-                                colSpan++;
-                            }
-                            else {
-                                break;
-                            }
-                        }
-                        const mergeEndRow = wsRowNumber + mergeInfo.rowSpan - 1;
-                        rowSpan = 0;
-                        for (let s = visibleRowIdx; s < visibleRows.length; s++) {
-                            if (visibleRows[s] <= mergeEndRow) {
-                                rowSpan++;
-                            }
-                            else {
-                                break;
-                            }
-                        }
-                        colSpan = Math.max(colSpan, 1);
-                        rowSpan = Math.max(rowSpan, 1);
+                    else {
+                        break;
                     }
-                    const cellX = groupColOffsets[gci];
-                    const cellY = rowYPositions[ri];
-                    let cellWidth = 0;
-                    for (let s = 0; s < colSpan && gci + s < groupColWidths.length; s++) {
-                        cellWidth += groupColWidths[gci + s];
+                }
+                const mergeEndRow = wsRowNumber + mergeInfo.rowSpan - 1;
+                rowSpan = 0;
+                for (let s = visibleRowIdx; s < visibleRows.length; s++) {
+                    if (visibleRows[s] <= mergeEndRow) {
+                        rowSpan++;
                     }
-                    let cellHeight = 0;
-                    for (let s = 0; s < rowSpan && ri + s < pageRowHeights.length; s++) {
-                        cellHeight += pageRowHeights[ri + s];
+                    else {
+                        break;
                     }
-                    const rectY = cellY - cellHeight;
-                    cells.push(buildLayoutCell(cell, cellX, rectY, cellWidth, cellHeight, colSpan, rowSpan, options, fontManager, scaleFactor));
                 }
+                colSpan = Math.max(colSpan, 1);
+                rowSpan = Math.max(rowSpan, 1);
+            }
+            const cellX = groupColOffsets[gci];
+            const cellY = rowYPositions[ri];
+            let cellWidth = 0;
+            for (let s = 0; s < colSpan && gci + s < groupColWidths.length; s++) {
+                cellWidth += groupColWidths[gci + s];
+            }
+            let cellHeight = 0;
+            for (let s = 0; s < rowSpan && ri + s < pageRowHeights.length; s++) {
+                cellHeight += pageRowHeights[ri + s];
+            }
+            const rectY = cellY - cellHeight;
+            cells.push(buildLayoutCell(cell, cellX, rectY, cellWidth, cellHeight, colSpan, rowSpan, options, fontManager, scaleFactor));
+            const layoutCell = cells[cells.length - 1];
+            // Propagate merged cell borders from boundary cells
+            if (mergeInfo?.isMaster) {
+                propagateMergeBorders(layoutCell, mergeInfo, wsRowNumber, wsColNumber, sheet);
             }
-            layoutPages.push({
-                pageNumber: layoutPages.length + 1,
-                options,
-                cells,
-                width: pageWidth,
-                height: pageHeight,
-                sheetName: sheet.name,
-                sheetCols: colGroup.map(ci => visibleCols[ci]),
-                columnOffsets: groupColOffsets,
-                columnWidths: groupColWidths,
-                sheetRows: rowPage.map(ri => visibleRows[ri]),
-                rowYPositions,
-                rowHeights: pageRowHeights,
-                images: []
-            });
+            cellGrid.set(`${ri}:${gci}`, layoutCell);
         }
     }
-    // --- Step 7: Place images on the correct pages ---
-    if (layoutPages.length > 0 && sheet.images) {
-        assignImagesToPages(sheet.images, layoutPages);
-    }
-    return layoutPages;
+    // Compute text overflow widths for non-wrapped cells
+    computeTextOverflows(cellGrid, rowPage, colGroup, visibleRows, visibleCols, groupColWidths, mergeMap, fontManager);
+    return {
+        pageNumber: currentPageCount + 1,
+        options,
+        cells,
+        width: pageWidth,
+        height: pageHeight,
+        sheetName: sheet.name,
+        sheetCols: colGroup.map(ci => visibleCols[ci]),
+        columnOffsets: groupColOffsets,
+        columnWidths: groupColWidths,
+        sheetRows: rowPage.map(ri => visibleRows[ri]),
+        rowYPositions,
+        rowHeights: pageRowHeights,
+        images: [],
+        scaleFactor
+    };
 }
-// =============================================================================
-// Helpers
-// =============================================================================
-function emptyPage(width, height, sheetName, options) {
+function createEmptyPage(sheet, options) {
+    let pageWidth = options.pageSize.width;
+    let pageHeight = options.pageSize.height;
+    if (options.orientation === "landscape") {
+        [pageWidth, pageHeight] = [pageHeight, pageWidth];
+    }
     return {
         pageNumber: 1,
         options,
         cells: [],
-        width,
-        height,
-        sheetName,
+        width: pageWidth,
+        height: pageHeight,
+        sheetName: sheet.name,
         sheetCols: [],
         columnOffsets: [],
         columnWidths: [],
         sheetRows: [],
         rowYPositions: [],
         rowHeights: [],
-        images: []
+        images: [],
+        scaleFactor: 1
     };
 }
 /**
@@ -270,7 +357,8 @@ function computeColumnWidths(sheet, printRange) {
             continue;
         }
         const excelWidth = col?.width ?? DEFAULT_COLUMN_WIDTH;
-        const pointWidth = Math.max(excelWidth * EXCEL_CHAR_WIDTH_TO_POINTS, MIN_COLUMN_WIDTH);
+        const pixelWidth = excelWidth * MAX_DIGIT_WIDTH_PX + EXCEL_COLUMN_PADDING_PX;
+        const pointWidth = Math.max(pixelWidth * PX_TO_PT, MIN_COLUMN_WIDTH);
         columnWidths.push(pointWidth);
         visibleCols.push(c);
     }
@@ -279,7 +367,7 @@ function computeColumnWidths(sheet, printRange) {
 // =============================================================================
 // Row Height Computation
 // =============================================================================
-function computeRowHeights(sheet, scaleFactor, printRange) {
+function computeRowHeights(sheet, scaleFactor, printRange, fontManager, options) {
     const bounds = sheet.bounds;
     if (bounds.top <= 0) {
         return { rowHeights: [], visibleRows: [] };
@@ -290,45 +378,27 @@ function computeRowHeights(sheet, scaleFactor, printRange) {
     const visibleRows = [];
     for (let r = startRow; r <= endRow; r++) {
         const row = sheet.rows.get(r);
-        if (row && row.hidden) {
+        if (row?.hidden) {
             continue;
         }
         let height;
-        if (row?.height) {
-            // Explicit row height set by user
+        if (row?.height && row.customHeight) {
+            // Custom height explicitly set by user — use as-is
+            height = row.height;
+        }
+        else if (row?.height) {
+            // Excel auto-calculated height — trust it as-is
             height = row.height;
         }
         else {
-            // Auto-size: scan cells in this row to find the largest needed height.
+            // No height info: auto-size based on cell content
             height = DEFAULT_ROW_HEIGHT;
             if (row) {
                 for (const cell of row.cells.values()) {
-                    let fontSize = cell.style?.font?.size ?? 11;
-                    // For rich text cells, find the largest font size across all runs
-                    const rtValue = cell.value;
-                    if (rtValue?.richText) {
-                        for (const run of rtValue.richText) {
-                            const runSize = run.font?.size ?? fontSize;
-                            if (runSize > fontSize) {
-                                fontSize = runSize;
-                            }
-                        }
-                    }
-                    const lineHeight = fontSize * 1.5;
-                    // Count lines: explicit newlines in the text
-                    const text = cell.text ?? "";
-                    const lineCount = Math.max(1, (text.match(/\n/g) ?? []).length + 1);
-                    // For wrapText cells, estimate how many lines word-wrapping produces
-                    let wrapLineCount = lineCount;
-                    if (cell.style?.alignment?.wrapText && lineCount === 1 && text.length > 0) {
-                        const col = sheet.columns.get(cell.col);
-                        const colWidth = col?.width ?? DEFAULT_COLUMN_WIDTH;
-                        const colPts = colWidth * EXCEL_CHAR_WIDTH_TO_POINTS * scaleFactor;
-                        const avgCharWidth = fontSize * 0.55; // rough average char width
-                        const charsPerLine = Math.max(1, Math.floor(colPts / avgCharWidth));
-                        wrapLineCount = Math.ceil(text.length / charsPerLine);
-                    }
-                    const neededHeight = lineHeight * wrapLineCount;
+                    const fontSize = getCellFontSize(cell);
+                    const wrapLineCount = countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options);
+                    const lineHeight = fontSize * LINE_HEIGHT_FACTOR;
+                    const neededHeight = fontSize + (wrapLineCount - 1) * lineHeight + CELL_PADDING_V * 2;
                     if (neededHeight > height) {
                         height = neededHeight;
                     }
@@ -340,6 +410,51 @@ function computeRowHeights(sheet, scaleFactor, printRange) {
     }
     return { rowHeights, visibleRows };
 }
+/**
+ * Get the largest font size for a cell, checking rich text runs.
+ */
+function getCellFontSize(cell) {
+    let fontSize = cell.style?.font?.size ?? 11;
+    if (cell.type === PdfCellType.RichText) {
+        const value = cell.value;
+        if (value && typeof value === "object" && "richText" in value) {
+            const runs = value.richText;
+            for (const run of runs) {
+                const runSize = run.font?.size ?? fontSize;
+                if (runSize > fontSize) {
+                    fontSize = runSize;
+                }
+            }
+        }
+    }
+    return fontSize;
+}
+/**
+ * Count the wrap-line count for a cell, using actual font measurements
+ * so row heights match the page renderer exactly.
+ */
+function countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options) {
+    const text = typeof cell.text === "string" ? cell.text : String(cell.text ?? "");
+    const lineCount = Math.max(1, (text.match(/\n/g) ?? []).length + 1);
+    if (!cell.style?.alignment?.wrapText || text.length === 0) {
+        return lineCount;
+    }
+    const col = sheet.columns.get(cell.col);
+    const colWidth = col?.width ?? DEFAULT_COLUMN_WIDTH;
+    const scaledColPts = (colWidth * MAX_DIGIT_WIDTH_PX + EXCEL_COLUMN_PADDING_PX) * PX_TO_PT * scaleFactor;
+    const indent = cell.style.alignment.indent ?? 0;
+    const padding = CELL_PADDING_H * 2 + indent * INDENT_WIDTH;
+    const effectiveWidth = Math.max(scaledColPts - padding, 1);
+    const scaledFontSize = fontSize * scaleFactor;
+    const fontProps = extractFontProperties(cell.style.font, options.defaultFontFamily, options.defaultFontSize);
+    const pdfFontName = resolvePdfFontName(fontProps.fontFamily, fontProps.bold, fontProps.italic);
+    const resourceName = fontManager.hasEmbeddedFont()
+        ? fontManager.getEmbeddedResourceName()
+        : fontManager.ensureFont(pdfFontName);
+    const measure = (s) => fontManager.measureText(s, resourceName, scaledFontSize);
+    const wrappedLines = wrapTextLines(text, measure, effectiveWidth);
+    return Math.max(lineCount, wrappedLines.length);
+}
 // =============================================================================
 // Row Breaks
 // =============================================================================
@@ -533,7 +648,7 @@ function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, f
         underline: fontProps.underline,
         textColor: fontProps.textColor,
         fillColor: excelFillToPdfColor(style.fill),
-        horizontalAlign: excelHAlignToPdf(style.alignment),
+        horizontalAlign: resolveHorizontalAlign(style.alignment, cell?.type, cell?.result),
         verticalAlign: excelVAlignToPdf(style.alignment),
         wrapText: style.alignment?.wrapText ?? false,
         borders: excelBordersToPdf(style.border),
@@ -542,7 +657,8 @@ function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, f
         hyperlink: cell?.hyperlink ?? null,
         richText,
         indent: style.alignment?.indent ?? 0,
-        textRotation: style.alignment?.textRotation ?? 0
+        textRotation: style.alignment?.textRotation === 255 ? "vertical" : (style.alignment?.textRotation ?? 0),
+        textOverflowWidth: 0
     };
 }
 // =============================================================================
@@ -551,7 +667,7 @@ function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, f
 /**
  * Assign pre-collected images to the pages that contain their top-left anchor.
  */
-function assignImagesToPages(images, layoutPages) {
+function assignImagesToPages(images, layoutPages, scaleFactor) {
     for (const img of images) {
         const tl = img.range.tl;
         const tlCol = (tl.nativeCol ?? tl.col ?? 0) + 1; // convert 0-indexed to 1-indexed
@@ -567,17 +683,17 @@ function assignImagesToPages(images, layoutPages) {
             targetPage.height -
                 targetPage.options.margins.top -
                 (targetPage.options.showSheetNames ? 20 : 0);
-        // Apply sub-cell offsets (EMU: 1pt = 12700 EMU)
-        const tlColOff = (tl.nativeColOff ?? 0) / 12700 || 0;
-        const tlRowOff = (tl.nativeRowOff ?? 0) / 12700 || 0;
+        // Apply sub-cell offsets (EMU: 1pt = 12700 EMU), scaled to match page layout
+        const tlColOff = ((tl.nativeColOff ?? 0) / 12700 || 0) * scaleFactor;
+        const tlRowOff = ((tl.nativeRowOff ?? 0) / 12700 || 0) * scaleFactor;
         const imgX = baseX + tlColOff;
         const imgY = baseY - tlRowOff;
         // Determine image size
         let imgWidth = 100;
         let imgHeight = 100;
         if (img.range.ext) {
-            imgWidth = (img.range.ext.width ?? 100) * 0.75;
-            imgHeight = (img.range.ext.height ?? 100) * 0.75;
+            imgWidth = (img.range.ext.width ?? 100) * 0.75 * scaleFactor;
+            imgHeight = (img.range.ext.height ?? 100) * 0.75 * scaleFactor;
         }
         else if (img.range.br) {
             const br = img.range.br;
@@ -591,8 +707,8 @@ function assignImagesToPages(images, layoutPages) {
             const brBaseY = brPageRowIndex >= 0
                 ? targetPage.rowYPositions[brPageRowIndex]
                 : imgY - (targetPage.rowHeights[pageRowIndex] ?? 100);
-            const brColOff = (br.nativeColOff ?? 0) / 12700 || 0;
-            const brRowOff = (br.nativeRowOff ?? 0) / 12700 || 0;
+            const brColOff = ((br.nativeColOff ?? 0) / 12700 || 0) * scaleFactor;
+            const brRowOff = ((br.nativeRowOff ?? 0) / 12700 || 0) * scaleFactor;
             const brX = brBaseX + brColOff;
             const brY = brBaseY - brRowOff;
             imgWidth = brX - imgX;
@@ -611,6 +727,89 @@ function assignImagesToPages(images, layoutPages) {
     }
 }
 // =============================================================================
+// Merge Border Propagation
+// =============================================================================
+/**
+ * Excel stores merged-cell borders on the boundary cells, not on the master.
+ * Copy the right border from the rightmost column cell and the bottom border
+ * from the bottom row cell so the layout cell renders them correctly.
+ */
+function propagateMergeBorders(layoutCell, mergeInfo, wsRowNumber, wsColNumber, sheet) {
+    if (mergeInfo.colSpan > 1) {
+        const rightCol = wsColNumber + mergeInfo.colSpan - 1;
+        const rightCellData = sheet.rows.get(wsRowNumber)?.cells.get(rightCol);
+        if (rightCellData?.style?.border?.right) {
+            const converted = excelBordersToPdf({ right: rightCellData.style.border.right });
+            if (converted.right) {
+                layoutCell.borders.right = converted.right;
+            }
+        }
+    }
+    if (mergeInfo.rowSpan > 1) {
+        const bottomRowNum = wsRowNumber + mergeInfo.rowSpan - 1;
+        const bottomCellData = sheet.rows.get(bottomRowNum)?.cells.get(wsColNumber);
+        if (bottomCellData?.style?.border?.bottom) {
+            const converted = excelBordersToPdf({ bottom: bottomCellData.style.border.bottom });
+            if (converted.bottom) {
+                layoutCell.borders.bottom = converted.bottom;
+            }
+        }
+    }
+}
+// =============================================================================
+// Text Overflow Calculation
+// =============================================================================
+/**
+ * In Excel, non-wrapped text overflows into adjacent empty cells.
+ * Fill color alone does NOT block overflow — only text content does.
+ * Computes `textOverflowWidth` for cells whose text exceeds the cell width.
+ */
+function computeTextOverflows(cellGrid, rowPage, colGroup, visibleRows, visibleCols, groupColWidths, mergeMap, fontManager) {
+    for (let ri = 0; ri < rowPage.length; ri++) {
+        for (let gci = 0; gci < colGroup.length; gci++) {
+            const cell = cellGrid.get(`${ri}:${gci}`);
+            if (!cell ||
+                cell.wrapText ||
+                cell.colSpan > 1 ||
+                !cell.text ||
+                cell.richText ||
+                (typeof cell.textRotation === "number" && cell.textRotation !== 0) ||
+                cell.textRotation === "vertical") {
+                continue;
+            }
+            const resourceName = fontManager.hasEmbeddedFont()
+                ? fontManager.getEmbeddedResourceName()
+                : fontManager.ensureFont(resolvePdfFontName(cell.fontFamily, cell.bold, cell.italic));
+            const textWidth = fontManager.measureText(cell.text, resourceName, cell.fontSize);
+            const cellContentWidth = cell.rect.width - CELL_PADDING_H * 2;
+            if (textWidth <= cellContentWidth) {
+                continue;
+            }
+            const overflowNeeded = textWidth - cellContentWidth;
+            let overflowAvailable = 0;
+            for (let j = gci + 1; j < colGroup.length; j++) {
+                const visibleRowIdx = rowPage[ri];
+                const wsRow = visibleRows[visibleRowIdx];
+                const wsCol = visibleCols[colGroup[j]];
+                if (mergeMap.has(`${wsRow}:${wsCol}`)) {
+                    break;
+                }
+                const neighborCell = cellGrid.get(`${ri}:${j}`);
+                if (neighborCell?.text) {
+                    break;
+                }
+                overflowAvailable += groupColWidths[j];
+                if (overflowAvailable >= overflowNeeded) {
+                    break;
+                }
+            }
+            if (overflowAvailable > 0) {
+                cell.textOverflowWidth = Math.min(overflowNeeded, overflowAvailable);
+            }
+        }
+    }
+}
+// =============================================================================
 // Rich Text
 // =============================================================================
 /**
@@ -621,11 +820,15 @@ function buildRichTextRuns(cell, options, fontManager, scaleFactor) {
     if (!cell || cell.type !== PdfCellType.RichText) {
         return null;
     }
-    const rtValue = cell.value;
-    if (!rtValue?.richText || rtValue.richText.length === 0) {
+    const value = cell.value;
+    if (!value || typeof value !== "object" || !("richText" in value)) {
+        return null;
+    }
+    const runs = value.richText;
+    if (runs.length === 0) {
         return null;
     }
-    return rtValue.richText.map(run => {
+    return runs.map(run => {
         const fontProps = extractFontProperties(run.font, options.defaultFontFamily, options.defaultFontSize);
         // Register font for this run
         if (fontManager.hasEmbeddedFont()) {