@cj-tech-master/excelts 6.2.0 → 7.0.0

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

@@ -1,13 +1,16 @@
 "use strict";
 /**
- * Layout engine for Excel-to-PDF conversion.
+ * Layout engine for PDF generation.
  *
- * Takes a worksheet and produces LayoutPage objects that describe exactly
+ * Takes a PdfSheetData and produces LayoutPage objects that describe exactly
  * where each cell, border, and piece of text should be drawn on each PDF page.
  *
+ * This module is fully independent of the Excel module — it works with
+ * the PDF module's own data model (PdfSheetData, PdfCellData, etc.).
+ *
  * Key responsibilities:
- * - Convert Excel column widths (character units) to PDF points
- * - Convert Excel row heights (points already, but may need scaling)
+ * - Convert column widths (character units) to PDF points
+ * - Convert row heights (points already, but may need scaling)
  * - Handle merged cells spanning multiple rows/columns
  * - Paginate content across multiple pages
  * - Handle fitToPage scaling
@@ -15,12 +18,9 @@
  * - Skip hidden rows and columns
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.layoutWorksheet = layoutWorksheet;
+exports.layoutSheet = layoutSheet;
 exports.paginateRows = paginateRows;
-const enums_1 = require("../../excel/enums.js");
-const address_1 = require("../../excel/utils/address.js");
-const cell_format_1 = require("../../excel/utils/cell-format.js");
-const utils_base_1 = require("../../../utils/utils.base.js");
+const types_1 = require("../types");
 const font_manager_1 = require("../font/font-manager");
 const style_converter_1 = require("./style-converter");
 // =============================================================================
@@ -34,9 +34,9 @@ const MIN_COLUMN_WIDTH = 5;
 // Layout Engine
 // =============================================================================
 /**
- * Compute the layout for a worksheet across one or more PDF pages.
+ * Compute the layout for a sheet across one or more PDF pages.
  */
-function layoutWorksheet(worksheet, options, fontManager) {
+function layoutSheet(sheet, options, fontManager) {
     const { margins } = options;
     let pageWidth = options.pageSize.width;
     let pageHeight = options.pageSize.height;
@@ -49,15 +49,15 @@ function layoutWorksheet(worksheet, options, fontManager) {
     const footerHeight = options.showPageNumbers ? 20 : 0;
     const availableHeight = contentHeight - headerHeight - footerHeight;
     // Determine print area bounds (if set)
-    const printRange = getPrintRange(worksheet);
+    const printRange = getPrintRange(sheet);
     // --- Step 1: Visible columns and widths ---
-    const { columnWidths, visibleCols } = computeColumnWidths(worksheet, printRange);
+    const { columnWidths, visibleCols } = computeColumnWidths(sheet, printRange);
     const columnCount = visibleCols.length;
     if (columnCount === 0) {
-        return [emptyPage(pageWidth, pageHeight, worksheet.name, options)];
+        return [emptyPage(pageWidth, pageHeight, sheet.name, options)];
     }
     // --- Step 2: Scale ---
-    let totalTableWidth = columnWidths.reduce((sum, w) => sum + w, 0);
+    const totalTableWidth = columnWidths.reduce((sum, w) => sum + w, 0);
     let scaleFactor = options.scale;
     if (options.fitToPage && totalTableWidth > 0) {
         const fitScale = contentWidth / totalTableWidth;
@@ -66,26 +66,15 @@ function layoutWorksheet(worksheet, options, fontManager) {
         }
     }
     const scaledColumnWidths = columnWidths.map(w => w * scaleFactor);
-    totalTableWidth = scaledColumnWidths.reduce((sum, w) => sum + w, 0);
-    // Column x-offsets
-    const columnOffsets = [];
-    let xOffset = margins.left;
-    if (totalTableWidth < contentWidth) {
-        xOffset = margins.left + (contentWidth - totalTableWidth) / 2;
-    }
-    for (let i = 0; i < scaledColumnWidths.length; i++) {
-        columnOffsets.push(xOffset);
-        xOffset += scaledColumnWidths[i];
-    }
     // --- Step 3: Visible rows and heights ---
-    const { rowHeights, visibleRows } = computeRowHeights(worksheet, scaleFactor, printRange);
+    const { rowHeights, visibleRows } = computeRowHeights(sheet, scaleFactor, printRange);
     // --- Step 4: Merge map ---
-    const mergeMap = buildMergeMap(worksheet);
+    const mergeMap = buildMergeMap(sheet);
     // --- Step 5: Paginate vertically (rows) and horizontally (columns) ---
     const repeatRowCount = typeof options.repeatRows === "number" ? options.repeatRows : 0;
-    const rowBreakSet = buildRowBreakSet(worksheet, visibleRows);
+    const rowBreakSet = buildRowBreakSet(sheet, visibleRows);
     const rowPages = paginateRows(rowHeights, availableHeight, repeatRowCount, rowBreakSet);
-    const colGroups = paginateColumns(scaledColumnWidths, contentWidth, worksheet, visibleCols);
+    const colGroups = paginateColumns(scaledColumnWidths, contentWidth, sheet, visibleCols);
     // --- Step 6: Layout cells per page (row page × column page) ---
     const layoutPages = [];
     for (const rowPage of rowPages) {
@@ -125,8 +114,8 @@ function layoutWorksheet(worksheet, options, fontManager) {
                     if (mergeInfo && !mergeInfo.isMaster) {
                         continue;
                     }
-                    const row = worksheet.findRow(wsRowNumber);
-                    const cell = row ? row.findCell(wsColNumber) : undefined;
+                    const row = sheet.rows.get(wsRowNumber);
+                    const cell = row?.cells.get(wsColNumber);
                     let colSpan = 1;
                     let rowSpan = 1;
                     if (mergeInfo && mergeInfo.isMaster) {
@@ -164,7 +153,7 @@ function layoutWorksheet(worksheet, options, fontManager) {
                         cellHeight += pageRowHeights[ri + s];
                     }
                     const rectY = cellY - cellHeight;
-                    cells.push(buildLayoutCell(cell, ci, visibleRowIdx, cellX, rectY, cellWidth, cellHeight, colSpan, rowSpan, options, fontManager, scaleFactor));
+                    cells.push(buildLayoutCell(cell, cellX, rectY, cellWidth, cellHeight, colSpan, rowSpan, options, fontManager, scaleFactor));
                 }
             }
             layoutPages.push({
@@ -173,20 +162,20 @@ function layoutWorksheet(worksheet, options, fontManager) {
                 cells,
                 width: pageWidth,
                 height: pageHeight,
-                sheetName: worksheet.name,
-                worksheetCols: colGroup.map(ci => visibleCols[ci]),
+                sheetName: sheet.name,
+                sheetCols: colGroup.map(ci => visibleCols[ci]),
                 columnOffsets: groupColOffsets,
                 columnWidths: groupColWidths,
-                worksheetRows: rowPage.map(ri => visibleRows[ri]),
+                sheetRows: rowPage.map(ri => visibleRows[ri]),
                 rowYPositions,
                 rowHeights: pageRowHeights,
                 images: []
             });
         }
     }
-    // --- Step 7: Collect images and place them on the correct pages ---
-    if (layoutPages.length > 0) {
-        assignImagesToPages(worksheet, layoutPages);
+    // --- Step 7: Place images on the correct pages ---
+    if (layoutPages.length > 0 && sheet.images) {
+        assignImagesToPages(sheet.images, layoutPages);
     }
     return layoutPages;
 }
@@ -201,21 +190,49 @@ function emptyPage(width, height, sheetName, options) {
         width,
         height,
         sheetName,
-        worksheetCols: [],
+        sheetCols: [],
         columnOffsets: [],
         columnWidths: [],
-        worksheetRows: [],
+        sheetRows: [],
         rowYPositions: [],
         rowHeights: [],
         images: []
     };
 }
 /**
- * Get the print area range from the worksheet's pageSetup.
+ * Parse a cell reference like "A1" into 0-indexed { c, r }.
+ */
+function parseCellRef(ref) {
+    const upper = ref.replace(/\$/g, "").toUpperCase();
+    let col = 0;
+    let i = 0;
+    while (i < upper.length && upper.charCodeAt(i) >= 65 && upper.charCodeAt(i) <= 90) {
+        col = col * 26 + (upper.charCodeAt(i) - 64);
+        i++;
+    }
+    const row = parseInt(upper.substring(i), 10);
+    return { c: col - 1, r: row - 1 };
+}
+/**
+ * Parse a range string like "A1:B2" into 0-indexed start/end.
+ */
+function parseRangeRef(range) {
+    const idx = range.indexOf(":");
+    if (idx === -1) {
+        const cell = parseCellRef(range);
+        return { s: cell, e: { ...cell } };
+    }
+    return {
+        s: parseCellRef(range.slice(0, idx)),
+        e: parseCellRef(range.slice(idx + 1))
+    };
+}
+/**
+ * Get the print area range from the sheet's pageSetup.
  * Returns null if no print area is set.
  */
-function getPrintRange(worksheet) {
-    const printArea = worksheet.pageSetup?.printArea;
+function getPrintRange(sheet) {
+    const printArea = sheet.pageSetup?.printArea;
     if (!printArea || typeof printArea !== "string") {
         return null;
     }
@@ -226,7 +243,7 @@ function getPrintRange(worksheet) {
         return null;
     }
     try {
-        const range = (0, address_1.decodeRange)(firstRange);
+        const range = parseRangeRef(firstRange);
         return {
             startRow: range.s.r + 1,
             endRow: range.e.r + 1,
@@ -241,22 +258,22 @@ function getPrintRange(worksheet) {
 // =============================================================================
 // Column Width Computation
 // =============================================================================
-function computeColumnWidths(worksheet, printRange) {
-    const dimensions = worksheet.dimensions;
-    const hasData = dimensions && dimensions.model.top > 0 && dimensions.model.left > 0;
+function computeColumnWidths(sheet, printRange) {
+    const bounds = sheet.bounds;
+    const hasData = bounds.top > 0 && bounds.left > 0;
     if (!hasData) {
         return { columnWidths: [], visibleCols: [] };
     }
-    const startCol = printRange?.startCol ?? dimensions.model.left;
-    const endCol = printRange?.endCol ?? dimensions.model.right;
+    const startCol = printRange?.startCol ?? bounds.left;
+    const endCol = printRange?.endCol ?? bounds.right;
     const columnWidths = [];
     const visibleCols = [];
     for (let c = startCol; c <= endCol; c++) {
-        const col = worksheet.getColumn(c);
-        if (col.hidden) {
+        const col = sheet.columns.get(c);
+        if (col?.hidden) {
             continue;
         }
-        const excelWidth = col.width ?? DEFAULT_COLUMN_WIDTH;
+        const excelWidth = col?.width ?? DEFAULT_COLUMN_WIDTH;
         const pointWidth = Math.max(excelWidth * EXCEL_CHAR_WIDTH_TO_POINTS, MIN_COLUMN_WIDTH);
         columnWidths.push(pointWidth);
         visibleCols.push(c);
@@ -266,17 +283,17 @@ function computeColumnWidths(worksheet, printRange) {
 // =============================================================================
 // Row Height Computation
 // =============================================================================
-function computeRowHeights(worksheet, scaleFactor, printRange) {
-    const dimensions = worksheet.dimensions;
-    if (!dimensions || dimensions.model.top <= 0) {
+function computeRowHeights(sheet, scaleFactor, printRange) {
+    const bounds = sheet.bounds;
+    if (bounds.top <= 0) {
         return { rowHeights: [], visibleRows: [] };
     }
-    const startRow = printRange?.startRow ?? dimensions.model.top;
-    const endRow = printRange?.endRow ?? dimensions.model.bottom;
+    const startRow = printRange?.startRow ?? bounds.top;
+    const endRow = printRange?.endRow ?? bounds.bottom;
     const rowHeights = [];
     const visibleRows = [];
     for (let r = startRow; r <= endRow; r++) {
-        const row = worksheet.findRow(r);
+        const row = sheet.rows.get(r);
         if (row && row.hidden) {
             continue;
         }
@@ -287,10 +304,9 @@ function computeRowHeights(worksheet, scaleFactor, printRange) {
         }
         else {
             // Auto-size: scan cells in this row to find the largest needed height.
-            // Account for font size and multi-line content (explicit newlines or wrapText).
             height = DEFAULT_ROW_HEIGHT;
             if (row) {
-                row.eachCell({ includeEmpty: false }, cell => {
+                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;
@@ -308,8 +324,9 @@ function computeRowHeights(worksheet, scaleFactor, printRange) {
                     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.alignment?.wrapText && lineCount === 1 && text.length > 0) {
-                        const colWidth = worksheet.getColumn(cell.col).width ?? DEFAULT_COLUMN_WIDTH;
+                    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));
@@ -319,7 +336,7 @@ function computeRowHeights(worksheet, scaleFactor, printRange) {
                     if (neededHeight > height) {
                         height = neededHeight;
                     }
-                });
+                }
             }
         }
         rowHeights.push(height * scaleFactor);
@@ -333,19 +350,19 @@ function computeRowHeights(worksheet, scaleFactor, printRange) {
 /**
  * Build a set of visible-row indices where manual page breaks occur.
  */
-function buildRowBreakSet(worksheet, visibleRows) {
+function buildRowBreakSet(sheet, visibleRows) {
     const breaks = new Set();
-    const rowBreaks = worksheet.rowBreaks ?? [];
+    const rowBreaks = sheet.rowBreaks ?? [];
     if (rowBreaks.length === 0) {
         return breaks;
     }
-    // Map worksheet row numbers to visible-row indices
+    // Map row numbers to visible-row indices
     const rowToIndex = new Map();
     for (let i = 0; i < visibleRows.length; i++) {
         rowToIndex.set(visibleRows[i], i);
     }
     for (const brk of rowBreaks) {
-        const idx = rowToIndex.get(brk.id);
+        const idx = rowToIndex.get(brk);
         if (idx !== undefined) {
             // Break AFTER this row, so the next row starts a new page
             breaks.add(idx + 1);
@@ -354,21 +371,17 @@ function buildRowBreakSet(worksheet, visibleRows) {
     return breaks;
 }
 /**
- * Build a map of all merged cell regions in the worksheet.
- * Uses the worksheet model's public mergeCells property.
+ * Build a map of all merged cell regions.
  * Key: "row:col" (1-based), Value: merge info
  */
-function buildMergeMap(worksheet) {
+function buildMergeMap(sheet) {
     const map = new Map();
-    if (!worksheet.hasMerges) {
+    const merges = sheet.merges;
+    if (!merges || merges.length === 0) {
         return map;
     }
-    const mergeCells = worksheet.model.mergeCells;
-    if (!mergeCells) {
-        return map;
-    }
-    for (const rangeStr of mergeCells) {
-        const range = (0, address_1.decodeRange)(rangeStr);
+    for (const rangeStr of merges) {
+        const range = parseRangeRef(rangeStr);
         const top = range.s.r + 1;
         const left = range.s.c + 1;
         const bottom = range.e.r + 1;
@@ -423,9 +436,6 @@ function paginateRows(rowHeights, availableHeight, repeatRowCount, rowBreaks) {
                     currentPage.length > 0 &&
                     currentPage.length === repeatedPrefixCount;
                 if (pageHasOnlyRepeatRows) {
-                    // If repeated header rows consume too much space to allow any body row,
-                    // fall back to placing body rows without repeated headers rather than
-                    // emitting a header-only page or overflowing the page.
                     currentPage = [];
                     currentPageHeight = 0;
                     repeatedPrefixCount = 0;
@@ -458,25 +468,22 @@ function paginateRows(rowHeights, availableHeight, repeatRowCount, rowBreaks) {
 }
 /**
  * Split columns into groups for horizontal pagination.
- * Each group is an array of column indices (into the visibleCols/scaledColumnWidths arrays).
- * If the total width fits in contentWidth and there are no colBreaks, returns a single group.
  */
-function paginateColumns(columnWidths, contentWidth, worksheet, visibleCols) {
+function paginateColumns(columnWidths, contentWidth, sheet, visibleCols) {
     if (columnWidths.length === 0) {
         return [[]];
     }
     // Build col break set (indices into visibleCols)
     const colBreaks = new Set();
-    const wsColBreaks = worksheet.colBreaks ?? [];
+    const wsColBreaks = sheet.colBreaks ?? [];
     if (wsColBreaks.length > 0) {
         const colToIndex = new Map();
         for (let i = 0; i < visibleCols.length; i++) {
             colToIndex.set(visibleCols[i], i);
         }
         for (const brk of wsColBreaks) {
-            const idx = colToIndex.get(brk.id);
+            const idx = colToIndex.get(brk);
             if (idx !== undefined) {
-                // Break AFTER this column, so the next column starts a new group
                 colBreaks.add(idx + 1);
             }
         }
@@ -486,9 +493,6 @@ function paginateColumns(columnWidths, contentWidth, worksheet, visibleCols) {
     let currentWidth = 0;
     for (let i = 0; i < columnWidths.length; i++) {
         const colWidth = columnWidths[i];
-        // Force break at column break positions or when exceeding page width
-        // Use a small epsilon (0.01pt) to avoid floating-point precision issues
-        // when fitToPage scales columns to exactly match content width
         const forceBreak = colBreaks.has(i) && currentGroup.length > 0;
         if ((forceBreak || currentWidth + colWidth > contentWidth + 0.01) && currentGroup.length > 0) {
             groups.push(currentGroup);
@@ -506,8 +510,8 @@ function paginateColumns(columnWidths, contentWidth, worksheet, visibleCols) {
 // =============================================================================
 // Cell Layout
 // =============================================================================
-function buildLayoutCell(cell, _colIndex, _rowIndex, x, y, width, height, colSpan, rowSpan, options, fontManager, scaleFactor) {
-    const text = getCellText(cell);
+function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, fontManager, scaleFactor) {
+    const text = cell?.text ?? "";
     const style = cell?.style ?? {};
     const fontProps = (0, style_converter_1.extractFontProperties)(style.font, options.defaultFontFamily, options.defaultFontSize);
     // Scale font size proportionally when fitToPage shrinks the layout
@@ -520,7 +524,7 @@ function buildLayoutCell(cell, _colIndex, _rowIndex, x, y, width, height, colSpa
         const pdfFontName = (0, font_manager_1.resolvePdfFontName)(fontProps.fontFamily, fontProps.bold, fontProps.italic);
         fontManager.ensureFont(pdfFontName);
     }
-    // Rich text runs (buildRichTextRuns handles font tracking internally)
+    // Rich text runs
     const richText = buildRichTextRuns(cell, options, fontManager, scaleFactor);
     return {
         text,
@@ -546,57 +550,22 @@ function buildLayoutCell(cell, _colIndex, _rowIndex, x, y, width, height, colSpa
     };
 }
 // =============================================================================
-// Image Collection
+// Image Placement
 // =============================================================================
 /**
- * Collect images from a worksheet and assign them to the page that contains
- * their top-left anchor.
+ * Assign pre-collected images to the pages that contain their top-left anchor.
  */
-function assignImagesToPages(worksheet, layoutPages) {
-    // Access worksheet images via getImages()
-    const wsImages = worksheet.getImages?.();
-    if (!wsImages || !Array.isArray(wsImages)) {
-        return;
-    }
-    // Access the workbook for image data
-    const workbook = worksheet.workbook;
-    if (!workbook) {
-        return;
-    }
-    for (const wsImage of wsImages) {
-        if (!wsImage.range?.tl) {
-            continue;
-        }
-        const imageId = wsImage.imageId;
-        const mediaItem = workbook.getImage?.(Number(imageId));
-        if (!mediaItem) {
-            continue;
-        }
-        // Get image data
-        let data;
-        if (mediaItem.buffer instanceof Uint8Array) {
-            data = mediaItem.buffer;
-        }
-        else if (mediaItem.base64) {
-            data = (0, utils_base_1.base64ToUint8Array)(mediaItem.base64);
-        }
-        if (!data || data.length === 0) {
-            continue;
-        }
-        const format = mediaItem.extension;
-        if (format !== "jpeg" && format !== "png") {
-            continue; // Only JPEG and PNG are supported
-        }
-        // Calculate position from anchor
-        const tl = wsImage.range.tl;
+function assignImagesToPages(images, layoutPages) {
+    for (const img of images) {
+        const tl = img.range.tl;
         const tlCol = (tl.nativeCol ?? tl.col ?? 0) + 1; // convert 0-indexed to 1-indexed
         const tlRow = (tl.nativeRow ?? tl.row ?? 0) + 1;
-        const targetPage = layoutPages.find(page => page.worksheetCols.includes(tlCol) && page.worksheetRows.includes(tlRow));
+        const targetPage = layoutPages.find(page => page.sheetCols.includes(tlCol) && page.sheetRows.includes(tlRow));
         if (!targetPage) {
             continue;
         }
-        const pageColIndex = targetPage.worksheetCols.indexOf(tlCol);
-        const pageRowIndex = targetPage.worksheetRows.indexOf(tlRow);
+        const pageColIndex = targetPage.sheetCols.indexOf(tlCol);
+        const pageRowIndex = targetPage.sheetRows.indexOf(tlRow);
         const baseX = targetPage.columnOffsets[pageColIndex] ?? targetPage.options.margins.left;
         const baseY = targetPage.rowYPositions[pageRowIndex] ??
             targetPage.height -
@@ -606,22 +575,20 @@ function assignImagesToPages(worksheet, layoutPages) {
         const tlColOff = (tl.nativeColOff ?? 0) / 12700 || 0;
         const tlRowOff = (tl.nativeRowOff ?? 0) / 12700 || 0;
         const imgX = baseX + tlColOff;
-        const imgY = baseY - tlRowOff; // PDF y-axis is bottom-up, offset moves down
+        const imgY = baseY - tlRowOff;
         // Determine image size
         let imgWidth = 100;
         let imgHeight = 100;
-        if (wsImage.range.ext) {
-            // ext.width and ext.height are in pixels; convert to points (1px ≈ 0.75pt)
-            imgWidth = (wsImage.range.ext.width ?? 100) * 0.75;
-            imgHeight = (wsImage.range.ext.height ?? 100) * 0.75;
+        if (img.range.ext) {
+            imgWidth = (img.range.ext.width ?? 100) * 0.75;
+            imgHeight = (img.range.ext.height ?? 100) * 0.75;
         }
-        else if (wsImage.range.br) {
-            // Calculate from bottom-right anchor
-            const br = wsImage.range.br;
+        else if (img.range.br) {
+            const br = img.range.br;
             const brCol = (br.nativeCol ?? br.col ?? 0) + 1;
             const brRow = (br.nativeRow ?? br.row ?? 0) + 1;
-            const brPageColIndex = targetPage.worksheetCols.indexOf(brCol);
-            const brPageRowIndex = targetPage.worksheetRows.indexOf(brRow);
+            const brPageColIndex = targetPage.sheetCols.indexOf(brCol);
+            const brPageRowIndex = targetPage.sheetRows.indexOf(brRow);
             const brBaseX = brPageColIndex >= 0
                 ? targetPage.columnOffsets[brPageColIndex]
                 : imgX + (targetPage.columnWidths[pageColIndex] ?? 100);
@@ -635,10 +602,9 @@ function assignImagesToPages(worksheet, layoutPages) {
             imgWidth = brX - imgX;
             imgHeight = imgY - brY;
         }
-        // PDF coordinates: y is bottom of image
         targetPage.images.push({
-            data,
-            format,
+            data: img.data,
+            format: img.format,
             rect: {
                 x: imgX,
                 y: imgY - imgHeight,
@@ -648,66 +614,6 @@ function assignImagesToPages(worksheet, layoutPages) {
         });
     }
 }
-/**
- * Extract display text from a cell, applying numFmt formatting.
- */
-function getCellText(cell) {
-    if (!cell) {
-        return "";
-    }
-    switch (cell.type) {
-        case enums_1.ValueType.Null:
-        case enums_1.ValueType.Merge:
-            return "";
-        case enums_1.ValueType.RichText: {
-            // RichText cell.value is a CellRichTextValue object; cell.text joins the run texts
-            return cell.text;
-        }
-        case enums_1.ValueType.Hyperlink:
-            return cell.text;
-        case enums_1.ValueType.Error: {
-            // Error cells have value = { error: "#N/A" } etc.
-            const errValue = cell.value;
-            return errValue?.error ?? cell.text;
-        }
-        case enums_1.ValueType.Formula: {
-            const result = cell.result;
-            if (result !== undefined && result !== null) {
-                if (typeof result === "object" && "error" in result) {
-                    return result.error;
-                }
-                return formatCellValueSafe(result, cell.style?.numFmt);
-            }
-            return cell.text;
-        }
-        default: {
-            const value = cell.value;
-            if (value === null || value === undefined) {
-                return "";
-            }
-            return formatCellValueSafe(value, cell.style?.numFmt);
-        }
-    }
-}
-/**
- * Safely format a cell value using its numFmt.
- * Falls back to toString if formatting fails or no format is specified.
- */
-function formatCellValueSafe(value, numFmt) {
-    const fmt = typeof numFmt === "string" ? numFmt : numFmt?.formatCode;
-    if (fmt && (typeof value === "number" || value instanceof Date || typeof value === "boolean")) {
-        try {
-            return (0, cell_format_1.formatCellValue)(value, fmt);
-        }
-        catch {
-            // Fall through to default
-        }
-    }
-    if (value instanceof Date) {
-        return value.toLocaleDateString();
-    }
-    return String(value);
-}
 // =============================================================================
 // Rich Text
 // =============================================================================
@@ -716,7 +622,7 @@ function formatCellValueSafe(value, numFmt) {
  * Returns null for non-RichText cells.
  */
 function buildRichTextRuns(cell, options, fontManager, scaleFactor) {
-    if (!cell || cell.type !== enums_1.ValueType.RichText) {
+    if (!cell || cell.type !== types_1.PdfCellType.RichText) {
         return null;
     }
     const rtValue = cell.value;