@cj-tech-master/excelts 9.4.1 → 9.4.2

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

@@ -390,38 +390,49 @@ function computeRowHeights(sheet, scaleFactor, printRange, fontManager, options)
             height = row.height;
         }
         else if (row?.height) {
-            // Excel auto-calculated height — trust it as-is
-            height = row.height;
+            // Excel auto-calculated height — use it as a baseline, but ensure
+            // the row is tall enough for wrapped text.  The stored height may be
+            // stale when columns are narrower in the PDF layout or when the PDF
+            // uses different font metrics than the original Excel file.
+            height = Math.max(row.height, autoRowHeight(row, scaleFactor, sheet, fontManager, options));
         }
         else {
             // No height info: auto-size based on cell content
-            height = DEFAULT_ROW_HEIGHT;
-            if (row) {
-                for (const cell of row.cells.values()) {
-                    const fontSize = getCellFontSize(cell);
-                    const wrapLineCount = countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options);
-                    const lineHeight = fontSize * LINE_HEIGHT_FACTOR;
-                    // Account for border width: half of each border extends inward
-                    const borderTop = cell.style?.border?.top?.style
-                        ? borderStyleToLineWidth(cell.style.border.top.style) / 2
-                        : 0;
-                    const borderBottom = cell.style?.border?.bottom?.style
-                        ? borderStyleToLineWidth(cell.style.border.bottom.style) / 2
-                        : 0;
-                    const neededHeight = fontSize +
-                        (wrapLineCount - 1) * lineHeight +
-                        (CELL_PADDING_V + borderTop + borderBottom) * 2;
-                    if (neededHeight > height) {
-                        height = neededHeight;
-                    }
-                }
-            }
+            height = autoRowHeight(row, scaleFactor, sheet, fontManager, options);
         }
         rowHeights.push(height * scaleFactor);
         visibleRows.push(r);
     }
     return { rowHeights, visibleRows };
 }
+/**
+ * Compute the minimum row height required to display wrapped cell content.
+ * Returns at least `DEFAULT_ROW_HEIGHT`.
+ */
+function autoRowHeight(row, scaleFactor, sheet, fontManager, options) {
+    let height = DEFAULT_ROW_HEIGHT;
+    if (row) {
+        for (const cell of row.cells.values()) {
+            const fontSize = getCellFontSize(cell);
+            const wrapLineCount = countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options);
+            const lineHeight = fontSize * LINE_HEIGHT_FACTOR;
+            // Account for border width: half of each border extends inward
+            const borderTop = cell.style?.border?.top?.style
+                ? borderStyleToLineWidth(cell.style.border.top.style) / 2
+                : 0;
+            const borderBottom = cell.style?.border?.bottom?.style
+                ? borderStyleToLineWidth(cell.style.border.bottom.style) / 2
+                : 0;
+            const neededHeight = fontSize +
+                (wrapLineCount - 1) * lineHeight +
+                (CELL_PADDING_V + borderTop + borderBottom) * 2;
+            if (neededHeight > height) {
+                height = neededHeight;
+            }
+        }
+    }
+    return height;
+}
 /**
  * Get the largest font size for a cell, checking rich text runs.
  */
@@ -652,6 +663,8 @@ function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, f
     else {
         const pdfFontName = resolvePdfFontName(fontProps.fontFamily, fontProps.bold, fontProps.italic);
         fontManager.ensureFont(pdfFontName);
+        // Track non-WinAnsi code points for Type3 fallback font generation
+        fontManager.trackText(text);
     }
     // Rich text runs
     const richText = buildRichTextRuns(cell, options, fontManager, scaleFactor);

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

@@ -258,23 +258,14 @@ function drawCellText(stream, cell, fontManager, alphaValues, scaleFactor = 1) {
     const totalTextHeight = lines.length * lineHeight;
     const textStartY = computeTextStartY(verticalAlign, rect, totalTextHeight, ascent, pad.top, pad.bottom);
     stream.setFillColor(cell.textColor);
-    stream.beginText();
-    stream.setFont(resourceName, fontSize);
+    const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineY = textStartY - i * lineHeight;
         const textWidth = measure(line);
         const textX = computeTextX(horizontalAlign, rect, textWidth, indentPts, pad.left, pad.right);
-        stream.setTextMatrix(1, 0, 0, 1, textX, lineY);
-        const hexEncoded = fontManager.encodeText(line, resourceName);
-        if (hexEncoded) {
-            stream.showTextHex(hexEncoded);
-        }
-        else {
-            stream.showText(line);
-        }
+        emitTextWithType3(stream, line, textX, lineY, resourceName, fontSize, fontManager, useType3);
     }
-    stream.endText();
     drawTextDecorations(stream, cell, lines, lineHeight, textStartY, measure, resourceName, fontManager, indentPts, pad);
     stream.restore();
 }
@@ -359,21 +350,11 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
                 lineWidth += fontManager.measureText(seg.text, seg.resourceName, seg.run.fontSize);
             }
             let textX = computeTextX(horizontalAlign, rect, lineWidth, indentPts, pad.left, pad.right);
+            const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
             for (const seg of segments) {
                 const { run, text, resourceName } = seg;
-                const segWidth = fontManager.measureText(text, resourceName, run.fontSize);
                 stream.setFillColor(run.textColor);
-                stream.beginText();
-                stream.setFont(resourceName, run.fontSize);
-                stream.setTextMatrix(1, 0, 0, 1, textX, lineY);
-                const hex = fontManager.encodeText(text, resourceName);
-                if (hex) {
-                    stream.showTextHex(hex);
-                }
-                else {
-                    stream.showText(text);
-                }
-                stream.endText();
+                const segWidth = emitTextWithType3(stream, text, textX, lineY, resourceName, run.fontSize, fontManager, useType3);
                 if (run.strike) {
                     const descent = fontManager.getFontDescent(resourceName, run.fontSize);
                     const y = lineY + descent + run.fontSize * 0.3;
@@ -403,23 +384,13 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
     const ascent = fontManager.getFontAscent(primaryResourceName, primaryFontSize);
     const textStartY = computeTextStartY(verticalAlign, rect, lineHeight, ascent, pad.top, pad.bottom);
     let textX = computeTextX(horizontalAlign, rect, totalWidth, indentPts, pad.left, pad.right);
+    const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
     for (let i = 0; i < runs.length; i++) {
         const run = runs[i];
         const { resourceName } = runMetrics[i];
         stream.setFillColor(run.textColor);
-        stream.beginText();
-        stream.setFont(resourceName, run.fontSize);
-        stream.setTextMatrix(1, 0, 0, 1, textX, textStartY);
-        const hexEncoded = fontManager.encodeText(run.text, resourceName);
-        if (hexEncoded) {
-            stream.showTextHex(hexEncoded);
-        }
-        else {
-            stream.showText(run.text);
-        }
-        stream.endText();
+        const runWidth = emitTextWithType3(stream, run.text, textX, textStartY, resourceName, run.fontSize, fontManager, useType3);
         // Draw per-run decorations (strikethrough, underline)
-        const runWidth = runMetrics[i].width;
         if (run.strike) {
             const descent = fontManager.getFontDescent(resourceName, run.fontSize);
             const y = textStartY + descent + run.fontSize * 0.3;
@@ -430,7 +401,7 @@ function drawRichText(stream, cell, fontManager, indentPts, scaleFactor = 1) {
             const y = textStartY + descent * 0.5;
             stream.drawLine(textX, y, textX + runWidth, y, run.textColor, 0.5);
         }
-        textX += runMetrics[i].width;
+        textX += runWidth;
     }
 }
 // =============================================================================
@@ -527,6 +498,7 @@ function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize,
         // left (default)
         startX = rect.x + pad.left + ascent;
     }
+    const useType3 = fontManager.hasType3Fonts() && !fontManager.hasEmbeddedFont();
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineWidth = fontManager.measureText(line, resourceName, fontSize);
@@ -546,11 +518,7 @@ function drawRotated90(stream, cell, lines, fontManager, resourceName, fontSize,
             ty = rect.y + pad.bottom;
         }
         ty = Math.max(ty, rect.y + pad.bottom);
-        stream.beginText();
-        stream.setFont(resourceName, fontSize);
-        stream.setTextMatrix(0, 1, -1, 0, colX, ty);
-        emitText(stream, fontManager, line, resourceName);
-        stream.endText();
+        emitTextWithMatrix(stream, line, 0, 1, -1, 0, colX, ty, resourceName, fontSize, fontManager, useType3);
     }
 }
 /** -90° (270° CW): text reads top-to-bottom, lines stack right-to-left. */
@@ -569,6 +537,7 @@ function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, font
         // left (default)
         startX = rect.x + pad.left + totalColumnsWidth - lineHeight + ascent;
     }
+    const useType3 = fontManager.hasType3Fonts() && !fontManager.hasEmbeddedFont();
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineWidth = fontManager.measureText(line, resourceName, fontSize);
@@ -588,11 +557,7 @@ function drawRotatedMinus90(stream, cell, lines, fontManager, resourceName, font
             ty = rect.y + pad.bottom + lineWidth;
         }
         ty = Math.min(ty, rect.y + rect.height - pad.top);
-        stream.beginText();
-        stream.setFont(resourceName, fontSize);
-        stream.setTextMatrix(0, -1, 1, 0, colX, ty);
-        emitText(stream, fontManager, line, resourceName);
-        stream.endText();
+        emitTextWithMatrix(stream, line, 0, -1, 1, 0, colX, ty, resourceName, fontSize, fontManager, useType3);
     }
 }
 /** General rotation — center a multi-line text block in the cell. */
@@ -644,6 +609,7 @@ function drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, font
         // center (default for rotated)
         cx = rect.x + rect.width / 2 + indentOffset + slantAtCy;
     }
+    const useType3 = fontManager.hasType3Fonts() && !fontManager.hasEmbeddedFont();
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineWidth = fontManager.measureText(line, resourceName, fontSize);
@@ -652,11 +618,7 @@ function drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, font
         const offsetY = -ascent / 2 - lineOffset;
         const tx = cx + offsetX * cos - offsetY * sin;
         const ty = cy + offsetX * sin + offsetY * cos;
-        stream.beginText();
-        stream.setFont(resourceName, fontSize);
-        stream.setTextMatrix(cos, sin, -sin, cos, tx, ty);
-        emitText(stream, fontManager, line, resourceName);
-        stream.endText();
+        emitTextWithMatrix(stream, line, cos, sin, -sin, cos, tx, ty, resourceName, fontSize, fontManager, useType3);
     }
 }
 /** Emit a text string with hex encoding if available. */
@@ -669,6 +631,97 @@ function emitText(stream, fontManager, text, resourceName) {
         stream.showText(text);
     }
 }
+/**
+ * Render a text string with a custom text matrix, using Type3-aware splitting
+ * when needed.  For each sub-run the matrix origin is advanced along the
+ * text direction (cos, sin) by the rendered width.
+ *
+ * When `useType3` is false this collapses to a single BT/ET pair — identical
+ * to the old `emitText()` path but wrapped in begin/end for convenience.
+ */
+export function emitTextWithMatrix(stream, text, a, b, c, d, tx, ty, type1ResourceName, fontSize, fontManager, useType3) {
+    if (!useType3) {
+        stream.beginText();
+        stream.setFont(type1ResourceName, fontSize);
+        stream.setTextMatrix(a, b, c, d, tx, ty);
+        emitText(stream, fontManager, text, type1ResourceName);
+        stream.endText();
+        return;
+    }
+    // Type3 path: split into runs and advance origin along text direction
+    const runs = splitTextRuns(text, fontManager);
+    let curTx = tx;
+    let curTy = ty;
+    for (const run of runs) {
+        stream.beginText();
+        if (run.type3) {
+            stream.setFont(run.type3.resourceName, fontSize);
+            stream.setTextMatrix(a, b, c, d, curTx, curTy);
+            stream.showTextHex(run.type3.hex);
+        }
+        else {
+            stream.setFont(type1ResourceName, fontSize);
+            stream.setTextMatrix(a, b, c, d, curTx, curTy);
+            emitText(stream, fontManager, run.text, type1ResourceName);
+        }
+        stream.endText();
+        const w = fontManager.measureText(run.text, run.type3?.resourceName ?? type1ResourceName, fontSize);
+        // Advance along the text direction (first column of the matrix)
+        curTx += a * w;
+        curTy += b * w;
+    }
+}
+/**
+ * Split a line of text into runs of consecutive WinAnsi and non-WinAnsi
+ * characters.  Each non-WinAnsi character becomes its own Type3 run (since
+ * different code points may map to different Type3 fonts).  Consecutive
+ * WinAnsi characters are merged into a single Type1 run.
+ */
+function splitTextRuns(text, fontManager) {
+    const runs = [];
+    let winAnsiBuffer = "";
+    const flushWinAnsi = () => {
+        if (winAnsiBuffer) {
+            runs.push({ text: winAnsiBuffer, type3: null });
+            winAnsiBuffer = "";
+        }
+    };
+    for (let i = 0; i < text.length; i++) {
+        const cp = text.codePointAt(i);
+        const ch = String.fromCodePoint(cp);
+        if (cp > 0xffff) {
+            i++; // skip low surrogate
+        }
+        if (fontManager.needsType3(cp)) {
+            flushWinAnsi();
+            const t3 = fontManager.resolveType3(cp);
+            if (t3) {
+                const hex = fontManager.encodeType3Char(cp);
+                runs.push({
+                    text: ch,
+                    type3: { resourceName: t3.resourceName, hex: hex ?? "<00>" }
+                });
+            }
+            else {
+                // Character tracked but Type3 not yet written — render as space
+                runs.push({ text: ch, type3: null });
+            }
+        }
+        else {
+            winAnsiBuffer += ch;
+        }
+    }
+    flushWinAnsi();
+    return runs;
+}
+/**
+ * Render a text string at (textX, textY) using Type3-aware splitting when needed.
+ * Returns the rendered width so the caller can advance textX.
+ */
+function emitTextWithType3(stream, text, textX, textY, type1ResourceName, fontSize, fontManager, useType3) {
+    emitTextWithMatrix(stream, text, 1, 0, 0, 1, textX, textY, type1ResourceName, fontSize, fontManager, useType3);
+    return fontManager.measureText(text, type1ResourceName, fontSize);
+}
 /**
  * Draw vertical stacked text (each character top-to-bottom).
  * Newlines (\n) start a new column to the right.
@@ -699,6 +752,7 @@ function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFac
         startX = rect.x + pad.left + columnWidth / 2;
     }
     stream.setFillColor(cell.textColor);
+    const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
     for (let colIdx = 0; colIdx < columns.length; colIdx++) {
         const colText = columns[colIdx];
         const colX = startX + colIdx * columnWidth;
@@ -720,11 +774,7 @@ function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFac
                 break;
             }
             const charWidth = fontManager.measureText(ch, resourceName, fontSize);
-            stream.beginText();
-            stream.setFont(resourceName, fontSize);
-            stream.setTextMatrix(1, 0, 0, 1, colX - charWidth / 2, currentY);
-            emitText(stream, fontManager, ch, resourceName);
-            stream.endText();
+            emitTextWithMatrix(stream, ch, 1, 0, 0, 1, colX - charWidth / 2, currentY, resourceName, fontSize, fontManager, useType3);
             currentY -= charHeight;
         }
     }
@@ -865,17 +915,8 @@ function drawPageHeader(stream, page, options, fontManager) {
     const y = page.height - options.margins.top + 5;
     stream.save();
     stream.setFillColor({ r: 0.3, g: 0.3, b: 0.3 });
-    stream.beginText();
-    stream.setFont(resourceName, headerFontSize);
-    stream.setTextMatrix(1, 0, 0, 1, x, y);
-    const hex = fontManager.encodeText(headerText, resourceName);
-    if (hex) {
-        stream.showTextHex(hex);
-    }
-    else {
-        stream.showText(headerText);
-    }
-    stream.endText();
+    const useType3 = fontManager.hasType3Fonts() && !fontManager.hasEmbeddedFont();
+    emitTextWithMatrix(stream, headerText, 1, 0, 0, 1, x, y, resourceName, headerFontSize, fontManager, useType3);
     stream.restore();
 }
 function drawPageFooter(stream, page, options, fontManager, totalPages) {
@@ -980,6 +1021,7 @@ function renderTextWatermark(stream, page, watermark, fontManager) {
     const sin = Math.sin(radians);
     const needsAlpha = opacity < 1;
     const gsName = needsAlpha ? alphaGsName(opacity) : "";
+    const useType3 = fontManager.hasType3Fonts() && !isEmbedded;
     const drawSingleWatermark = (cx, cy) => {
         // Center the text at (cx, cy), compensating for both width and ascent height
         const halfW = textWidth / 2;
@@ -991,17 +1033,7 @@ function renderTextWatermark(stream, page, watermark, fontManager) {
             stream.setGraphicsState(gsName);
         }
         stream.setFillColor(color);
-        stream.beginText();
-        stream.setFont(resourceName, fontSize);
-        stream.setTextMatrix(cos, sin, -sin, cos, tx, ty);
-        const hex = fontManager.encodeText(watermark.text, resourceName);
-        if (hex) {
-            stream.showTextHex(hex);
-        }
-        else {
-            stream.showText(watermark.text);
-        }
-        stream.endText();
+        emitTextWithMatrix(stream, watermark.text, cos, sin, -sin, cos, tx, ty, resourceName, fontSize, fontManager, useType3);
         stream.restore();
     };
     if (watermark.repeat) {

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

@@ -11,12 +11,13 @@ import { yieldToEventLoop } from "../../../utils/utils.base.js";
 import { writeImageXObject } from "../builder/image-utils.js";
 import { initEncryption } from "../core/encryption.js";
 import { PdfDict, pdfRef, pdfNumber, pdfString as pdfStr } from "../core/pdf-object.js";
-import { PdfContentStream } from "../core/pdf-stream.js";
+import { PdfContentStream, isWinAnsiCodePoint } from "../core/pdf-stream.js";
 import { PdfWriter } from "../core/pdf-writer.js";
 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 } from "../types.js";
+import { PageSizes, PdfCellType } from "../types.js";
 import { layoutSheet } from "./layout-engine.js";
 import { renderPage, alphaGsName, renderWatermark } from "./page-renderer.js";
 import { argbToPdfColor } from "./style-converter.js";
@@ -50,13 +51,39 @@ function prepareExport(workbook, options) {
     }
     const fontManager = new FontManager();
     const writer = new PdfWriter();
-    if (options?.font) {
+    // Determine font data: user-provided > auto-discovered system font
+    let fontData = options?.font ?? null;
+    if (!fontData) {
+        // Collect non-WinAnsi code points from the document (single pass)
+        const nonWinAnsi = collectNonWinAnsiCodePoints(sheets);
+        if (nonWinAnsi.size > 0) {
+            // Try system font candidates in preference order until one covers all chars
+            for (const candidate of discoverSystemFontCandidates()) {
+                try {
+                    const testTtf = parseTtf(candidate);
+                    const allCovered = [...nonWinAnsi].every(cp => testTtf.cmap.has(cp));
+                    if (allCovered) {
+                        fontData = candidate;
+                        break;
+                    }
+                }
+                catch {
+                    // Parse failed — try next candidate
+                }
+            }
+        }
+    }
+    if (fontData) {
         try {
-            const ttf = parseTtf(options.font);
+            const ttf = parseTtf(fontData);
             fontManager.registerEmbeddedFont(ttf);
         }
         catch (err) {
-            throw new PdfRenderError("Failed to parse TrueType font", { cause: err });
+            if (options?.font) {
+                // Only throw if the user explicitly provided a font
+                throw new PdfRenderError("Failed to parse TrueType font", { cause: err });
+            }
+            // Auto-discovered font failed to parse — silently fall back to Type1 + Type3
         }
     }
     return { sheets, fontManager, writer, allPages: [] };
@@ -500,3 +527,44 @@ function isWatermarkApplicable(watermark, page) {
     }
     return true;
 }
+// =============================================================================
+// Non-WinAnsi Detection
+// =============================================================================
+/**
+ * Collect all non-WinAnsi code points from sheet text (single pass).
+ * Returns an empty set if all text is WinAnsi-representable.
+ */
+function collectNonWinAnsiCodePoints(sheets) {
+    const result = new Set();
+    for (const sheet of sheets) {
+        for (const row of sheet.rows.values()) {
+            for (const cell of row.cells.values()) {
+                collectFromText(cell.text, result);
+                if (cell.type === PdfCellType.RichText &&
+                    cell.value &&
+                    typeof cell.value === "object" &&
+                    "richText" in cell.value) {
+                    const runs = cell.value.richText;
+                    for (const run of runs) {
+                        collectFromText(run.text, result);
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+function collectFromText(text, out) {
+    if (!text) {
+        return;
+    }
+    for (let i = 0; i < text.length; i++) {
+        const cp = text.codePointAt(i);
+        if (cp > 0xffff) {
+            i++;
+        }
+        if (!isWinAnsiCodePoint(cp)) {
+            out.add(cp);
+        }
+    }
+}