@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/esm/modules/pdf/render/page-renderer.js

@@ -41,10 +41,64 @@ export function renderPage(page, options, fontManager, totalPages) {
     for (const cell of page.cells) {
         drawCellBorders(stream, cell);
     }
+    // --- Step 3.5: Erase grid lines and borders in text overflow regions ---
+    // In Excel, text overflowing into adjacent empty cells hides gridlines and
+    // borders underneath. We draw white only over the portions of the overflow
+    // area that do NOT have a cell fill (cells with fill already cover gridlines
+    // in Step 2, and we must not erase their background).
+    for (const cell of page.cells) {
+        if (!cell.textOverflowWidth || cell.textOverflowWidth <= 0) {
+            continue;
+        }
+        const overflowLeft = cell.rect.x + cell.rect.width;
+        const overflowRight = overflowLeft + cell.textOverflowWidth;
+        const cellY = cell.rect.y;
+        const cellH = cell.rect.height;
+        // Find neighbor cells whose x range overlaps the overflow region and
+        // are on the same row (same y and height).
+        // Collect filled sub-ranges to skip.
+        const filledRanges = [];
+        for (const other of page.cells) {
+            if (other === cell || !other.fillColor) {
+                continue;
+            }
+            // Same row check: same y position and height
+            if (Math.abs(other.rect.y - cellY) > 0.01 || Math.abs(other.rect.height - cellH) > 0.01) {
+                continue;
+            }
+            const oLeft = other.rect.x;
+            const oRight = oLeft + other.rect.width;
+            // Check overlap with overflow region
+            if (oRight > overflowLeft && oLeft < overflowRight) {
+                filledRanges.push({
+                    left: Math.max(oLeft, overflowLeft),
+                    right: Math.min(oRight, overflowRight)
+                });
+            }
+        }
+        // Draw white in unfilled portions of the overflow area
+        if (filledRanges.length === 0) {
+            stream.fillRect(overflowLeft, cellY, cell.textOverflowWidth, cellH, { r: 1, g: 1, b: 1 });
+        }
+        else {
+            // Sort filled ranges and draw white in gaps
+            filledRanges.sort((a, b) => a.left - b.left);
+            let cursor = overflowLeft;
+            for (const fr of filledRanges) {
+                if (fr.left > cursor) {
+                    stream.fillRect(cursor, cellY, fr.left - cursor, cellH, { r: 1, g: 1, b: 1 });
+                }
+                cursor = Math.max(cursor, fr.right);
+            }
+            if (cursor < overflowRight) {
+                stream.fillRect(cursor, cellY, overflowRight - cursor, cellH, { r: 1, g: 1, b: 1 });
+            }
+        }
+    }
     // --- Step 4: Draw cell text ---
     const sf = page.scaleFactor;
     for (const cell of page.cells) {
-        if (cell.text) {
+        if (cell.text || cell.richText) {
             drawCellText(stream, cell, fontManager, alphaValues, sf);
         }
     }
@@ -296,54 +350,41 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
         if (availWidth <= 0) {
             return;
         }
-        // Concatenate full text and wrap it
-        const fullText = runs.map(r => r.text).join("");
-        const primaryResource = runResource(runs[0]);
-        const measure = (s) => fontManager.measureText(s, primaryResource, primaryFontSize);
-        const lines = wrapTextLines(fullText, measure, availWidth);
         // Build a character-to-run mapping so we know which run each char belongs to
+        const fullText = runs.map(r => r.text).join("");
         const runForChar = [];
         for (let ri = 0; ri < runs.length; ri++) {
             for (let ci = 0; ci < runs[ri].text.length; ci++) {
                 runForChar.push(ri);
             }
         }
-        const primaryResourceName = runResource(runs[0]);
+        // Run-aware word-wrap using each character's actual run font size
+        const runResources = runs.map(r => runResource(r));
+        // Word-wrap using actual per-run measurements — returns character ranges
+        const lineRanges = wrapRichTextLines(fullText, runForChar, runs, runResources, fontManager, availWidth);
+        const primaryResourceName = runResources[0];
         const ascent = fontManager.getFontAscent(primaryResourceName, primaryFontSize);
-        const totalTextHeight = lines.length * lineHeight;
+        const totalTextHeight = lineRanges.length * lineHeight;
         const textStartY = computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, pad.top, pad.bottom);
-        let charPos = 0;
-        for (let li = 0; li < lines.length; li++) {
+        for (let li = 0; li < lineRanges.length; li++) {
             const lineY = textStartY - li * lineHeight;
-            const lineLen = lines[li].length;
+            const { start: lineStart, end: lineEnd } = lineRanges[li];
             // Split the line into segments by run
             const segments = [];
-            const segStart = charPos;
-            for (let ci = 0; ci < lineLen; ci++) {
-                const globalIdx = charPos + ci;
-                const ri = runForChar[globalIdx] ?? runForChar.length - 1;
+            for (let ci = lineStart; ci < lineEnd; ci++) {
+                const ri = runForChar[ci] ?? runForChar.length - 1;
                 const last = segments[segments.length - 1];
                 if (last && last.run === runs[ri]) {
-                    last.text += lines[li][ci];
+                    last.text += fullText[ci];
                 }
                 else {
                     segments.push({
                         run: runs[ri],
-                        text: lines[li][ci],
-                        resourceName: runResource(runs[ri])
+                        text: fullText[ci],
+                        resourceName: runResources[ri]
                     });
                 }
             }
-            charPos += lineLen;
-            // Skip whitespace chars consumed by word-wrap between lines
-            while (charPos < runForChar.length && charPos < segStart + lineLen + 1) {
-                const nextLineStart = li + 1 < lines.length ? fullText.indexOf(lines[li + 1], charPos) : fullText.length;
-                if (nextLineStart > charPos) {
-                    charPos = nextLineStart;
-                    break;
-                }
-                break;
-            }
             // Measure total line width for alignment
             let lineWidth = 0;
             for (const seg of segments) {
@@ -901,6 +942,106 @@ export function wrapTextLines(text, measure, maxWidth) {
     }
     return allLines.length > 0 ? allLines : [""];
 }
+function wrapRichTextLines(fullText, runForChar, runs, runResources, fontManager, maxWidth) {
+    if (!fullText) {
+        return [{ start: 0, end: 0 }];
+    }
+    // Measure a substring using each character's actual run font size
+    const measureRange = (start, end) => {
+        if (start >= end) {
+            return 0;
+        }
+        let width = 0;
+        let segStart = start;
+        let currentRi = runForChar[start] ?? 0;
+        for (let i = start + 1; i <= end; i++) {
+            const ri = i < end ? (runForChar[i] ?? currentRi) : -1;
+            if (ri !== currentRi) {
+                const run = runs[currentRi];
+                const seg = fullText.slice(segStart, i);
+                width += fontManager.measureText(seg, runResources[currentRi], run.fontSize);
+                segStart = i;
+                currentRi = ri;
+            }
+        }
+        return width;
+    };
+    const allLines = [];
+    let globalOffset = 0;
+    const len = fullText.length;
+    // Process paragraph by paragraph (split on newlines)
+    while (globalOffset <= len) {
+        // Find end of current paragraph
+        let paraEnd = fullText.indexOf("\n", globalOffset);
+        if (paraEnd === -1) {
+            paraEnd = len;
+        }
+        if (paraEnd === globalOffset) {
+            // Empty paragraph
+            allLines.push({ start: globalOffset, end: globalOffset });
+            globalOffset = paraEnd + 1;
+            continue;
+        }
+        // Handle \r\n: exclude \r from paragraph content
+        const paraContentEnd = paraEnd > globalOffset && fullText[paraEnd - 1] === "\r" ? paraEnd - 1 : paraEnd;
+        if (paraContentEnd === globalOffset) {
+            // Paragraph was just \r\n — treat as empty
+            allLines.push({ start: globalOffset, end: globalOffset });
+            globalOffset = paraEnd + 1;
+            continue;
+        }
+        // Word-wrap this paragraph
+        const paraText = fullText.slice(globalOffset, paraContentEnd);
+        // Find word boundaries within this paragraph
+        const wordStarts = [];
+        const wordEnds = [];
+        let inWord = false;
+        for (let i = 0; i < paraText.length; i++) {
+            const isSpace = paraText[i] === " " || paraText[i] === "\t";
+            if (!isSpace && !inWord) {
+                wordStarts.push(i);
+                inWord = true;
+            }
+            else if (isSpace && inWord) {
+                wordEnds.push(i);
+                inWord = false;
+            }
+        }
+        if (inWord) {
+            wordEnds.push(paraText.length);
+        }
+        let lineStart = globalOffset;
+        let lineEnd = globalOffset;
+        for (let wi = 0; wi < wordStarts.length; wi++) {
+            const wordEnd = globalOffset + wordEnds[wi];
+            if (lineEnd === lineStart) {
+                // First word on line — always take it
+                lineEnd = wordEnd;
+                continue;
+            }
+            // Test if adding this word (with preceding space) fits
+            if (measureRange(lineStart, wordEnd) <= maxWidth) {
+                lineEnd = wordEnd;
+            }
+            else {
+                // Emit current line
+                allLines.push({ start: lineStart, end: lineEnd });
+                // Start new line at this word
+                lineStart = globalOffset + wordStarts[wi];
+                lineEnd = wordEnd;
+            }
+        }
+        // Emit last line of paragraph
+        if (lineEnd > lineStart || wordStarts.length === 0) {
+            allLines.push({ start: lineStart, end: Math.max(lineEnd, lineStart) });
+        }
+        globalOffset = paraEnd + 1;
+        if (paraEnd === len) {
+            break;
+        }
+    }
+    return allLines.length > 0 ? allLines : [{ start: 0, end: 0 }];
+}
 // =============================================================================
 // Page Header / Footer
 // =============================================================================

package/dist/esm/modules/pdf/render/pdf-exporter.js

@@ -17,8 +17,9 @@ import { PdfError, PdfRenderError } from "../errors.js";
 import { FontManager, resolvePdfFontName } from "../font/font-manager.js";
 import { discoverSystemFontCandidates } from "../font/system-fonts.js";
 import { parseTtf } from "../font/ttf-parser.js";
-import { PageSizes, PdfCellType } from "../types.js";
-import { layoutSheet } from "./layout-engine.js";
+import { PageSizes, PdfCellType, isPdfChartsheet } from "../types.js";
+import { createChartSurface } from "./chart-surface.js";
+import { layoutChartsheet, layoutSheet } from "./layout-engine.js";
 import { renderPage, alphaGsName, renderWatermark } from "./page-renderer.js";
 import { argbToPdfColor } from "./style-converter.js";
 // =============================================================================
@@ -90,11 +91,17 @@ function prepareExport(workbook, options) {
 }
 /**
  * Layout a single sheet and append its pages to the context.
+ *
+ * Dispatches on `sheet.kind`: chartsheets produce exactly one page via
+ * {@link layoutChartsheet}; cell-grid worksheets go through the full
+ * pagination pipeline via {@link layoutSheet}.
  */
 async function layoutSheetInto(ctx, sheet, options) {
     try {
         const resolved = resolveOptions(options, sheet);
-        const pages = await layoutSheet(sheet, resolved, ctx.fontManager);
+        const pages = isPdfChartsheet(sheet)
+            ? layoutChartsheet(sheet, resolved)
+            : await layoutSheet(sheet, resolved, ctx.fontManager);
         ctx.allPages.push(...pages);
     }
     catch (err) {
@@ -144,6 +151,7 @@ function ensureAtLeastOnePage(allPages, documentOptions, sheets) {
             rowYPositions: [],
             rowHeights: [],
             images: [],
+            charts: [],
             scaleFactor: 1
         });
     }
@@ -201,6 +209,35 @@ function renderSinglePage(page, fontManager, writer, fontObjectMap, totalPages,
                 contentStream.drawImage(imgName, img.rect.x, img.rect.y, img.rect.width, img.rect.height);
             }
         }
+        // Handle charts. Two paths:
+        //  - `drawVector` charts go through a {@link createChartSurface}
+        //    adapter so the vector PDF operators (lines, text, shapes) land
+        //    in the same content stream as the cells. Text stays selectable
+        //    and the chart scales crisply at any zoom level.
+        //  - `raster` charts fall back to the image XObject pipeline, which
+        //    is identical to an embedded PNG. Used only for ChartEx layouts
+        //    outside the vector-render whitelist.
+        if (page.charts.length > 0) {
+            let rasterCounter = page.images.length;
+            for (const chart of page.charts) {
+                if (chart.drawVector) {
+                    const surface = createChartSurface(contentStream, fontManager, alphaValues);
+                    // Constrain aspect ratio: charts look best at roughly 16:9 to
+                    // 4:3. If the allocated rect is too extreme (e.g. very tall and
+                    // narrow due to page layout), letterbox the chart within the
+                    // rect so it keeps a sensible proportion.
+                    const drawRect = constrainChartAspectRatio(chart.rect);
+                    chart.drawVector(surface, drawRect);
+                    continue;
+                }
+                if (chart.raster) {
+                    const imgName = `Im${++rasterCounter}`;
+                    const imgObjNum = writeImageXObject(writer, chart.raster.data, chart.raster.format);
+                    imageXObjects.set(imgName, imgObjNum);
+                    contentStream.drawImage(imgName, chart.rect.x, chart.rect.y, chart.rect.width, chart.rect.height);
+                }
+            }
+        }
         // --- Render watermark into a separate content stream ---
         // PDF supports Contents as an array of stream references. The watermark stream
         // is placed BEFORE the main content stream so it renders behind everything.
@@ -371,10 +408,21 @@ function selectSheets(workbook, sheets) {
  * Resolve user options with defaults.
  */
 function resolveOptions(options, sheet) {
-    // Use sheet's pageSetup as fallback for unspecified options
+    // Use sheet's pageSetup as fallback for unspecified options. Chartsheets
+    // expose a narrower pageSetup shape (`CT_CsPageSetup`) — the fields we
+    // care about (orientation, paperSize, margins) live in the same places
+    // so the same destructuring works.
     const ps = sheet?.pageSetup;
     const pageSize = resolvePageSize(options?.pageSize, ps?.paperSize);
-    const orientation = options?.orientation ?? (ps?.orientation === "landscape" ? "landscape" : "portrait");
+    // Chartsheets carry their own `orientation` override (Excel defaults
+    // to landscape for chartsheets); if set, it wins over the pageSetup
+    // fallback. Note: `layoutChartsheet` applies the same rule in its
+    // own clone of the resolved options, so selecting orientation here
+    // is only the document-level hint.
+    const chartsheetOrientation = sheet && isPdfChartsheet(sheet) ? sheet.orientation : undefined;
+    const orientation = options?.orientation ??
+        chartsheetOrientation ??
+        (ps?.orientation === "landscape" ? "landscape" : "portrait");
     const margins = resolveMargins(options?.margins, ps?.margins);
     const gridLineColorStr = options?.gridLineColor ?? "FFD0D0D0";
     const gridLineColor = argbToPdfColor(gridLineColorStr) ?? {
@@ -382,9 +430,11 @@ function resolveOptions(options, sheet) {
         g: 0.816,
         b: 0.816
     };
-    // Use sheet's printTitlesRow as fallback for repeatRows
+    // Use sheet's printTitlesRow as fallback for repeatRows. Only
+    // PdfSheetData carries `printTitlesRow` — chartsheets never have
+    // repeated header rows.
     let repeatRows = options?.repeatRows ?? false;
-    if (repeatRows === false && ps?.printTitlesRow) {
+    if (repeatRows === false && sheet && !isPdfChartsheet(sheet) && ps?.printTitlesRow) {
         // printTitlesRow format: "1:3" (repeat rows 1-3) or "1" (repeat row 1)
         const match = ps.printTitlesRow.match(/^(\d+)(?::(\d+))?$/);
         if (match) {
@@ -533,10 +583,20 @@ function isWatermarkApplicable(watermark, page) {
 /**
  * Collect all non-WinAnsi code points from sheet text (single pass).
  * Returns an empty set if all text is WinAnsi-representable.
+ *
+ * Chartsheets are skipped — the chart surface renders text via the
+ * same font manager but the characters come from the chart model (axis
+ * labels, data labels, title), which gets tracked via `fontManager.trackText`
+ * during rendering rather than here. This keeps the font-discovery scan
+ * focused on cell text, which is where non-WinAnsi characters
+ * overwhelmingly appear.
  */
 function collectNonWinAnsiCodePoints(sheets) {
     const result = new Set();
     for (const sheet of sheets) {
+        if (isPdfChartsheet(sheet)) {
+            continue;
+        }
         for (const row of sheet.rows.values()) {
             for (const cell of row.cells.values()) {
                 collectFromText(cell.text, result);
@@ -568,3 +628,53 @@ function collectFromText(text, out) {
         }
     }
 }
+// =============================================================================
+// Chart Aspect Ratio Constraint
+// =============================================================================
+/**
+ * Constrain a chart drawing rectangle to a reasonable aspect ratio.
+ *
+ * Charts render best at roughly 16:9 (landscape) to 4:3. When the
+ * allocated page rect has an extreme ratio (e.g. very wide + short, or
+ * very tall + narrow — common when the chart anchor spans many rows but
+ * few columns or vice versa), letterbox the chart within the rect using
+ * a target ratio of 16:9 so it renders with correct proportions.
+ *
+ * The returned rect is centred within the original rect.
+ */
+function constrainChartAspectRatio(rect) {
+    const { x, y, width, height } = rect;
+    if (width <= 0 || height <= 0) {
+        return rect;
+    }
+    const ratio = width / height;
+    // Target aspect ratio: 16:9 ≈ 1.78. Allow a generous range [1.0, 2.5]
+    // before applying correction. This avoids touching charts that already
+    // have a reasonable shape (e.g. 4:3 = 1.33, 16:9 = 1.78).
+    const minRatio = 1.0;
+    const maxRatio = 2.5;
+    const targetRatio = 16 / 9; // 1.778
+    if (ratio >= minRatio && ratio <= maxRatio) {
+        // Already in acceptable range — use as-is.
+        return rect;
+    }
+    let newWidth = width;
+    let newHeight = height;
+    if (ratio > maxRatio) {
+        // Too wide — shrink width to fit target ratio within the height.
+        newWidth = height * targetRatio;
+    }
+    else {
+        // Too tall — shrink height to fit target ratio within the width.
+        newHeight = width / targetRatio;
+    }
+    // Centre within the original rect.
+    const dx = (width - newWidth) / 2;
+    const dy = (height - newHeight) / 2;
+    return {
+        x: x + dx,
+        y: y + dy,
+        width: newWidth,
+        height: newHeight
+    };
+}

package/dist/esm/modules/pdf/types.js

@@ -23,6 +23,10 @@ export const PdfCellType = {
     Hyperlink: 8,
     Merge: 9
 };
+/** Type guard distinguishing chartsheets from cell-grid worksheets. */
+export function isPdfChartsheet(sheet) {
+    return sheet.kind === "chartsheet";
+}
 /**
  * Predefined page sizes.
  */