@cj-tech-master/excelts 9.4.1 → 9.4.2

package/dist/esm/modules/pdf/font/font-manager.js

@@ -1,23 +1,27 @@
 /**
  * Font manager for PDF generation.
  *
- * Manages two kinds of fonts:
+ * Manages three kinds of fonts:
  * 1. **Standard Type1 fonts** (Helvetica, Times, Courier) — always available,
- *    used as fallback for Latin text when no embedded font is provided.
+ *    used for Latin text (WinAnsi repertoire) when no embedded font is provided.
  * 2. **Embedded TrueType fonts** — user-provided .ttf files for full
  *    Unicode support (CJK, Arabic, Hindi, etc.)
+ * 3. **Type3 fallback fonts** — auto-generated vector-drawn glyphs for
+ *    Unicode characters outside WinAnsi when no embedded font is provided.
  *
  * When an embedded font is registered, ALL text uses the embedded font.
- * When no embedded font is provided, the system falls back to standard fonts
- * exactly as before (mapping Calibri→Helvetica, etc.)
+ * When no embedded font is provided, the system uses Type1 for WinAnsi
+ * characters and Type3 for everything else.
  *
  * The manager tracks which Unicode code points are used so the font embedder
- * can create a minimal subset when writing the PDF.
+ * and Type3 builder can create minimal subsets when writing the PDF.
  */
 import { PdfDict, pdfName, pdfRef } from "../core/pdf-object.js";
+import { hasNonWinAnsiChars, isWinAnsiCodePoint } from "../core/pdf-stream.js";
 import { PdfFontError } from "../errors.js";
 import { embedTtfFont } from "./font-embedder.js";
 import { measureText as measureType1Text, getFontAscent as getType1Ascent, getFontDescent as getType1Descent, getLineHeight as getType1LineHeight } from "./metrics.js";
+import { writeType3Fonts } from "./type3-font.js";
 // =============================================================================
 // Font Name Mapping (Type1 fallback)
 // =============================================================================
@@ -104,7 +108,8 @@ export function resolvePdfFontName(fontFamily, bold, italic) {
 // =============================================================================
 /**
  * Manages PDF font resources for a document.
- * Supports both standard Type1 fonts and embedded TrueType fonts.
+ * Supports standard Type1 fonts, embedded TrueType fonts, and auto-generated
+ * Type3 fallback fonts for non-WinAnsi Unicode characters.
  */
 export class FontManager {
     constructor() {
@@ -117,6 +122,9 @@ export class FontManager {
         this.embeddedResourceName = "";
         this.usedCodePoints = new Set();
         this.nextEmbeddedId = 1;
+        // --- Type3 fallback font tracking ---
+        this.type3CodePoints = new Set();
+        this._type3Result = null;
         /** Stored after writeFontResources is called */
         this._embeddedResult = null;
     }
@@ -149,14 +157,25 @@ export class FontManager {
      * Must be called for every text string before writing the PDF.
      */
     trackText(text) {
-        if (!this.embeddedFont) {
-            return;
+        if (this.embeddedFont) {
+            for (let i = 0; i < text.length; i++) {
+                const cp = text.codePointAt(i);
+                this.usedCodePoints.add(cp);
+                if (cp > 0xffff) {
+                    i++; // skip low surrogate
+                }
+            }
         }
-        for (let i = 0; i < text.length; i++) {
-            const cp = text.codePointAt(i);
-            this.usedCodePoints.add(cp);
-            if (cp > 0xffff) {
-                i++; // skip low surrogate
+        else {
+            // No embedded font — track non-WinAnsi chars for Type3 fallback
+            for (let i = 0; i < text.length; i++) {
+                const cp = text.codePointAt(i);
+                if (cp > 0xffff) {
+                    i++;
+                }
+                if (!isWinAnsiCodePoint(cp)) {
+                    this.type3CodePoints.add(cp);
+                }
             }
         }
     }
@@ -194,17 +213,72 @@ export class FontManager {
         return this.resourceToType1.get(resourceName) ?? "Helvetica";
     }
     // ==========================================================================
+    // Type3 Fallback Font
+    // ==========================================================================
+    /**
+     * Check if Type3 fallback fonts are available (after writeFontResources).
+     */
+    hasType3Fonts() {
+        return this._type3Result !== null && this._type3Result.fontObjects.size > 0;
+    }
+    /**
+     * Resolve the Type3 font resource name and char code for a code point.
+     * Returns null if the code point is not in the Type3 encoding.
+     */
+    resolveType3(codePoint) {
+        if (!this._type3Result) {
+            return null;
+        }
+        return this._type3Result.encoding.get(codePoint) ?? null;
+    }
+    /**
+     * Check if a code point needs Type3 rendering (non-WinAnsi, no embedded font).
+     */
+    needsType3(codePoint) {
+        return !this.embeddedFont && !isWinAnsiCodePoint(codePoint);
+    }
+    // ==========================================================================
     // Text Measurement
     // ==========================================================================
     /**
      * Measure text width using the correct font metrics.
+     * For mixed Type1/Type3 text, measures each character with the right font.
      */
     measureText(text, resourceName, fontSize) {
         if (this.embeddedFont && resourceName === this.embeddedResourceName) {
             return measureEmbeddedText(text, this.embeddedFont, fontSize);
         }
+        // If no Type3 fonts or text has no non-WinAnsi chars, use Type1 directly
+        if (!this._type3Result || !hasNonWinAnsiChars(text)) {
+            const pdfFontName = this.getPdfFontName(resourceName);
+            return measureType1Text(text, pdfFontName, fontSize);
+        }
+        // Mixed text: measure char by char
+        let totalWidth = 0;
         const pdfFontName = this.getPdfFontName(resourceName);
-        return measureType1Text(text, pdfFontName, fontSize);
+        for (let i = 0; i < text.length; i++) {
+            const cp = text.codePointAt(i);
+            if (cp > 0xffff) {
+                i++;
+            }
+            if (isWinAnsiCodePoint(cp)) {
+                totalWidth += measureType1Text(String.fromCodePoint(cp), pdfFontName, fontSize);
+            }
+            else {
+                // Type3 character width
+                const t3 = this._type3Result.encoding.get(cp);
+                if (t3) {
+                    const widthMap = this._type3Result.widths.get(t3.resourceName);
+                    const glyphWidth = widthMap?.get(t3.charCode) ?? 600;
+                    totalWidth += (glyphWidth / 1000) * fontSize;
+                }
+                else {
+                    // Notdef width
+                    totalWidth += (600 / 1000) * fontSize;
+                }
+            }
+        }
+        return totalWidth;
     }
     /**
      * Get the font ascent in points.
@@ -213,7 +287,11 @@ export class FontManager {
         if (this.embeddedFont && resourceName === this.embeddedResourceName) {
             return (this.embeddedFont.ascent / this.embeddedFont.unitsPerEm) * fontSize;
         }
-        return getType1Ascent(this.getPdfFontName(resourceName), fontSize);
+        // Type3 fonts use the same metrics as the base Type1 font
+        const base = this.isType3Resource(resourceName)
+            ? "Helvetica"
+            : this.getPdfFontName(resourceName);
+        return getType1Ascent(base, fontSize);
     }
     /**
      * Get the font descent in points (negative value).
@@ -222,7 +300,10 @@ export class FontManager {
         if (this.embeddedFont && resourceName === this.embeddedResourceName) {
             return (this.embeddedFont.descent / this.embeddedFont.unitsPerEm) * fontSize;
         }
-        return getType1Descent(this.getPdfFontName(resourceName), fontSize);
+        const base = this.isType3Resource(resourceName)
+            ? "Helvetica"
+            : this.getPdfFontName(resourceName);
+        return getType1Descent(base, fontSize);
     }
     /**
      * Get the line height in points.
@@ -232,7 +313,10 @@ export class FontManager {
             const f = this.embeddedFont;
             return ((f.ascent - f.descent) / f.unitsPerEm) * fontSize;
         }
-        return getType1LineHeight(this.getPdfFontName(resourceName), fontSize);
+        const base = this.isType3Resource(resourceName)
+            ? "Helvetica"
+            : this.getPdfFontName(resourceName);
+        return getType1LineHeight(base, fontSize);
     }
     // ==========================================================================
     // Text Encoding
@@ -243,6 +327,12 @@ export class FontManager {
     isEmbeddedFont(resourceName) {
         return this.embeddedFont !== null && resourceName === this.embeddedResourceName;
     }
+    /**
+     * Check if a resource name refers to a Type3 fallback font.
+     */
+    isType3Resource(resourceName) {
+        return this._type3Result?.fontObjects.has(resourceName) ?? false;
+    }
     /**
      * Encode text for the given font resource.
      * For embedded fonts, returns a hex string `<0012003A...>`.
@@ -263,6 +353,21 @@ export class FontManager {
         // writeFontResources not called yet — this is a programming error
         throw new PdfFontError("encodeText called before writeFontResources — subset mapping not available");
     }
+    /**
+     * Encode a single character for a Type3 font.
+     * Returns a hex string `<XX>` suitable for the Tj operator.
+     */
+    encodeType3Char(codePoint) {
+        if (!this._type3Result) {
+            return null;
+        }
+        const entry = this._type3Result.encoding.get(codePoint);
+        if (!entry) {
+            return null;
+        }
+        const hex = entry.charCode.toString(16).toUpperCase().padStart(2, "0");
+        return `<${hex}>`;
+    }
     // ==========================================================================
     // PDF Object Writing
     // ==========================================================================
@@ -290,6 +395,13 @@ export class FontManager {
             // Store the embedding result for text re-encoding
             this._embeddedResult = embedded;
         }
+        // Write Type3 fallback fonts (only when no embedded font)
+        if (!this.embeddedFont && this.type3CodePoints.size > 0) {
+            this._type3Result = writeType3Fonts(writer, this.type3CodePoints);
+            for (const [resourceName, objNum] of this._type3Result.fontObjects) {
+                fontObjectMap.set(resourceName, objNum);
+            }
+        }
         return fontObjectMap;
     }
     /**

package/dist/esm/modules/pdf/font/system-fonts.js

@@ -0,0 +1,188 @@
+/**
+ * System font discovery for PDF generation.
+ *
+ * When no embedded font is provided and the document contains non-WinAnsi
+ * characters, this module searches standard system font directories for a
+ * TrueType font (.ttf or .ttc) with broad Unicode coverage.
+ *
+ * This is a Node.js-only feature — browser environments do not have
+ * file system access and must always provide fonts explicitly.
+ *
+ * .ttc (TrueType Collection) files are supported — parseTtf() extracts
+ * the first font from the collection automatically.
+ *
+ * Results are cached: the filesystem search runs only once per process.
+ */
+import { fileExistsSync, readFileBytesSync, traverseDirectorySync } from "../../../utils/fs.js";
+// =============================================================================
+// Platform Font Directories
+// =============================================================================
+function getSystemFontDirs() {
+    const platform = typeof process !== "undefined" ? process.platform : "";
+    const home = typeof process !== "undefined" ? (process.env.HOME ?? process.env.USERPROFILE ?? "") : "";
+    const dirs = [];
+    switch (platform) {
+        case "darwin":
+            dirs.push("/System/Library/Fonts", "/System/Library/Fonts/Supplemental", "/Library/Fonts", `${home}/Library/Fonts`);
+            break;
+        case "win32": {
+            const winDir = process.env.WINDIR ?? process.env.SystemRoot ?? "C:\\Windows";
+            dirs.push(`${winDir}\\Fonts`, `${process.env.LOCALAPPDATA ?? ""}\\Microsoft\\Windows\\Fonts`);
+            break;
+        }
+        case "linux":
+        default:
+            dirs.push("/usr/share/fonts", "/usr/local/share/fonts", "/usr/share/fonts/truetype", "/usr/share/fonts/opentype", "/usr/share/fonts/TTF", "/usr/share/fonts/noto", "/usr/share/fonts/noto-cjk", "/usr/share/fonts/google-noto", "/usr/share/fonts/google-noto-cjk", "/usr/share/fonts/truetype/noto", "/usr/share/fonts/truetype/dejavu", "/usr/share/fonts/truetype/liberation", "/usr/share/fonts/truetype/droid", "/usr/share/fonts/wqy", `${home}/.local/share/fonts`, `${home}/.fonts`);
+            break;
+    }
+    return dirs;
+}
+// =============================================================================
+// Preferred Font Names (ordered by preference — first match wins)
+// =============================================================================
+const PREFERRED_FONTS = [
+    // Noto Sans CJK — broadest open-source coverage
+    "NotoSansCJKsc-Regular.ttf",
+    "NotoSansCJK-Regular.ttc",
+    "NotoSansCJKSC-Regular.otf",
+    "NotoSansSC-Regular.ttf",
+    "NotoSansTC-Regular.ttf",
+    "NotoSansJP-Regular.ttf",
+    "NotoSansKR-Regular.ttf",
+    "NotoSans-Regular.ttf",
+    // Arial Unicode MS
+    "Arial Unicode.ttf",
+    "Arial Unicode MS.ttf",
+    "ArialUnicode.ttf",
+    "arialuni.ttf",
+    // macOS
+    "PingFang.ttc",
+    "Hiragino Sans GB.ttc",
+    "STHeiti Light.ttc",
+    "STHeiti Medium.ttc",
+    "Songti.ttc",
+    "AppleSDGothicNeo.ttc",
+    // Windows
+    "msyh.ttc",
+    "msyhbd.ttc",
+    "msjh.ttc",
+    "simsun.ttc",
+    "simhei.ttf",
+    "malgun.ttf",
+    "meiryo.ttc",
+    "yugothic.ttf",
+    "segoeui.ttf",
+    "arial.ttf",
+    // Linux
+    "DejaVuSans.ttf",
+    "LiberationSans-Regular.ttf",
+    "FreeSans.ttf",
+    "DroidSansFallbackFull.ttf",
+    "DroidSansFallback.ttf",
+    "wqy-microhei.ttc",
+    "wqy-zenhei.ttc",
+    "uming.ttc",
+    "NanumGothic.ttf",
+    "IPAexGothic.ttf"
+];
+// =============================================================================
+// Font Discovery
+// =============================================================================
+let _cachedCandidates;
+/**
+ * Return all discoverable system font candidates, ordered by preference.
+ *
+ * Each entry is the raw font file bytes of a `.ttf` or `.ttc` file.
+ * The caller decides which candidate to use (e.g. by checking cmap coverage).
+ *
+ * Results are cached — the filesystem scan runs only once per process.
+ */
+export function discoverSystemFontCandidates() {
+    if (_cachedCandidates !== undefined) {
+        return _cachedCandidates;
+    }
+    if (typeof process === "undefined" || !process.platform) {
+        _cachedCandidates = [];
+        return _cachedCandidates;
+    }
+    const candidates = [];
+    const seen = new Set(); // dedupe by path
+    const dirs = getSystemFontDirs();
+    // Strategy 1: Check preferred font filenames (in order)
+    for (const fontName of PREFERRED_FONTS) {
+        for (const dir of dirs) {
+            const fontPath = `${dir}/${fontName}`;
+            if (seen.has(fontPath)) {
+                continue;
+            }
+            if (fileExistsSync(fontPath)) {
+                const data = tryReadFont(fontPath);
+                if (data) {
+                    candidates.push(data);
+                    seen.add(fontPath);
+                }
+            }
+        }
+    }
+    // Strategy 2: Scan directories for any .ttf/.ttc not already found
+    const broadRe = /noto|unicode|cjk|yahei|heiti|gothic|sans|serif|ming|song|dejavu|liberation|droid|wqy/i;
+    for (const dir of dirs) {
+        try {
+            const entries = traverseDirectorySync(dir, { recursive: true, filter: e => !e.isDirectory });
+            const fonts = entries.filter(e => /\.tt[cf]$/i.test(e.absolutePath) && !seen.has(e.absolutePath));
+            // Broad-coverage names first, then large files
+            const broad = fonts.filter(e => broadRe.test(e.absolutePath));
+            const rest = fonts.filter(e => !broadRe.test(e.absolutePath) && e.size > 50000);
+            for (const entry of [...broad, ...rest]) {
+                if (seen.has(entry.absolutePath)) {
+                    continue;
+                }
+                const data = tryReadFont(entry.absolutePath);
+                if (data) {
+                    candidates.push(data);
+                    seen.add(entry.absolutePath);
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or not readable
+        }
+    }
+    _cachedCandidates = candidates;
+    return candidates;
+}
+/**
+ * Search for a system font suitable for Unicode rendering.
+ *
+ * Returns the raw font file bytes of the highest-priority candidate,
+ * or `null` if no font was found. This is a convenience wrapper around
+ * {@link discoverSystemFontCandidates}.
+ */
+export function discoverSystemFont() {
+    const candidates = discoverSystemFontCandidates();
+    return candidates.length > 0 ? candidates[0] : null;
+}
+/**
+ * Reset the cached font discovery result (for testing).
+ */
+export function resetFontDiscoveryCache() {
+    _cachedCandidates = undefined;
+}
+/**
+ * Override the cached candidates with a custom list (for testing).
+ * Call {@link resetFontDiscoveryCache} to clear the override.
+ */
+export function _setCandidatesForTest(candidates) {
+    _cachedCandidates = candidates;
+}
+// =============================================================================
+// Internal
+// =============================================================================
+function tryReadFont(fontPath) {
+    try {
+        return readFileBytesSync(fontPath);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/esm/modules/pdf/font/ttf-parser.js

@@ -111,8 +111,36 @@ class BEReader {
  */
 export function parseTtf(data) {
     const r = new BEReader(data);
+    // --- Check for TTC (TrueType Collection) ---
+    const magic = r.u32();
+    if (magic === 0x74746366) {
+        // 'ttcf' — TrueType Collection
+        // Read the offset of the first font and restart parsing from there
+        r.skip(4); // majorVersion, minorVersion
+        const numFonts = r.u32();
+        if (numFonts === 0) {
+            throw new PdfFontError("TrueType Collection is empty (0 fonts)");
+        }
+        const firstFontOffset = r.u32();
+        return parseTtfAtOffset(data, firstFontOffset);
+    }
+    // Not TTC — parse as regular TTF starting from the magic we already read
+    return parseTtfFromMagic(data, r, magic);
+}
+/**
+ * Parse a TTF font starting at a given byte offset within the data.
+ * Used for TTC collections where each font starts at a different offset.
+ */
+function parseTtfAtOffset(data, offset) {
+    const r = new BEReader(data, offset);
+    const magic = r.u32();
+    return parseTtfFromMagic(data, r, magic);
+}
+/**
+ * Core TTF parsing after the first 4 bytes (sfVersion) have been read.
+ */
+function parseTtfFromMagic(data, r, sfVersion) {
     // --- Offset table ---
-    const sfVersion = r.u32();
     // TrueType: 0x00010000 or 'true' (0x74727565)
     // OpenType with CFF: 'OTTO' (0x4F54544F) — not supported for subsetting
     if (sfVersion !== 0x00010000 && sfVersion !== 0x74727565) {