@polotno/pdf-import 0.0.1 → 0.0.3

package/lib/font-registry.d.ts

@@ -4,12 +4,15 @@ export declare class FontRegistry {
     private fontDataMap;
     private fontMetricsMap;
     private otCache;
+    private renameMap;
     /**
      * Parse font data with opentype.js, returning cached result if available.
      * Key is the pdfjs loaded font name (e.g. "g_d0_f1").
      */
     parseOpentype(loadedName: string, data: Uint8Array): opentype.Font | null;
-    recordFont(fontObj: any): void;
+    recordFont(fontObj: any, embedAllFonts?: boolean): void;
+    /** Get the fontFamily name for a PDF font, accounting for renames. */
+    getFontFamily(pdfFontName: string): string;
     finalize(fontStrategy: 'embed' | 'googleFontsMatch', pages: PolotnoPage[]): PolotnoFont[];
 }
 //# sourceMappingURL=font-registry.d.ts.map

package/lib/font-registry.js

@@ -1,5 +1,5 @@
 import opentype from 'opentype.js';
-import { mapPdfFont, isKnownWebFont } from './font-mapper.js';
+import { mapPdfFont, isKnownWebFont, extractWeightFromName, extractStyleFromName, } from './font-mapper.js';
 import { findClosestGoogleFont } from './font-matcher.js';
 import { mergeSubsetFonts } from './font-merger.js';
 export class FontRegistry {
@@ -8,6 +8,8 @@ export class FontRegistry {
         this.fontMetricsMap = new Map();
         // Cache opentype.js parsed fonts across pages to avoid re-parsing
         this.otCache = new Map();
+        // Maps PDF font name → renamed fontFamily (only for embed-all renamed fonts)
+        this.renameMap = new Map();
     }
     /**
      * Parse font data with opentype.js, returning cached result if available.
@@ -28,25 +30,41 @@ export class FontRegistry {
             return null;
         }
     }
-    recordFont(fontObj) {
+    recordFont(fontObj, embedAllFonts = false) {
         if (!fontObj?.name)
             return;
         const mappedFamily = mapPdfFont(fontObj.name);
-        const isUnknown = !isKnownWebFont(fontObj.name);
-        // Collect font binary data for non-Google/non-standard fonts
-        if (isUnknown && fontObj.data && fontObj.data.length > 0) {
+        const isGoogleFont = isKnownWebFont(fontObj.name);
+        const shouldEmbed = embedAllFonts || !isGoogleFont;
+        // When embedding a known Google Font, rename to avoid Polotno loading
+        // the Google version instead of the embedded subset.
+        const fontFamily = embedAllFonts && isGoogleFont ? `${mappedFamily} (PDF)` : mappedFamily;
+        // Track the rename so text elements can use the correct fontFamily
+        if (fontFamily !== mappedFamily) {
+            this.renameMap.set(fontObj.name, fontFamily);
+        }
+        // Detect weight/style from the PDF font name
+        const fontWeight = extractWeightFromName(fontObj.name);
+        const fontStyle = extractStyleFromName(fontObj.name);
+        // Collect font binary data with weight/style info
+        if (shouldEmbed && fontObj.data && fontObj.data.length > 0) {
             const mime = fontObj.mimetype || 'font/opentype';
-            const arr = this.fontDataMap.get(mappedFamily) || [];
-            arr.push({ mime, data: new Uint8Array(fontObj.data) });
-            this.fontDataMap.set(mappedFamily, arr);
+            const arr = this.fontDataMap.get(fontFamily) || [];
+            arr.push({
+                mime,
+                data: new Uint8Array(fontObj.data),
+                fontWeight,
+                fontStyle,
+            });
+            this.fontDataMap.set(fontFamily, arr);
         }
         // Collect font metrics for unknown fonts (for Google Font matching)
-        if (isUnknown && !this.fontMetricsMap.has(mappedFamily)) {
+        if (shouldEmbed && !this.fontMetricsMap.has(fontFamily)) {
             const widths = (fontObj.widths || []).filter((w) => w != null && w > 0);
             const avgWidth = widths.length > 0
                 ? widths.reduce((a, b) => a + b, 0) / widths.length
                 : 500;
-            this.fontMetricsMap.set(mappedFamily, {
+            this.fontMetricsMap.set(fontFamily, {
                 fontName: fontObj.name.replace(/^[A-Z]{6}\+/, ''),
                 isSerifFont: fontObj.isSerifFont || false,
                 isMonospace: fontObj.isMonospace || false,
@@ -56,6 +74,10 @@ export class FontRegistry {
             });
         }
     }
+    /** Get the fontFamily name for a PDF font, accounting for renames. */
+    getFontFamily(pdfFontName) {
+        return this.renameMap.get(pdfFontName) ?? mapPdfFont(pdfFontName);
+    }
     finalize(fontStrategy, pages) {
         const fonts = [];
         if (fontStrategy === 'googleFontsMatch') {
@@ -79,30 +101,59 @@ export class FontRegistry {
             return fonts;
         }
         // 'embed' strategy: embed font data as base64 data URIs.
-        // When multiple subsets exist, merge them into a single font.
         for (const [fontFamily, blobs] of this.fontDataMap) {
-            let fontData;
-            let mime;
-            if (blobs.length === 1) {
-                fontData = blobs[0].data;
-                mime = blobs[0].mime;
+            // Group blobs by weight+style variant
+            const variantMap = new Map();
+            for (const blob of blobs) {
+                const key = `${blob.fontWeight}|${blob.fontStyle}`;
+                const arr = variantMap.get(key) || [];
+                arr.push(blob);
+                variantMap.set(key, arr);
             }
-            else {
-                fontData = mergeSubsetFonts(blobs.map((b) => b.data));
-                mime = blobs[0].mime;
-            }
-            let b64;
-            if (typeof Buffer !== 'undefined') {
-                b64 = Buffer.from(fontData).toString('base64');
+            // When multiple subsets exist for the same variant, merge them.
+            const variants = [];
+            for (const [, variantBlobs] of variantMap) {
+                let fontData;
+                if (variantBlobs.length === 1) {
+                    fontData = variantBlobs[0].data;
+                }
+                else {
+                    fontData = mergeSubsetFonts(variantBlobs.map((b) => b.data));
+                }
+                variants.push({
+                    fontWeight: variantBlobs[0].fontWeight,
+                    fontStyle: variantBlobs[0].fontStyle,
+                    data: fontData,
+                    mime: variantBlobs[0].mime,
+                });
             }
-            else {
+            function toBase64(data) {
+                if (typeof Buffer !== 'undefined') {
+                    return Buffer.from(data).toString('base64');
+                }
                 let binary = '';
-                for (let bi = 0; bi < fontData.length; bi++) {
-                    binary += String.fromCharCode(fontData[bi]);
+                for (let bi = 0; bi < data.length; bi++) {
+                    binary += String.fromCharCode(data[bi]);
                 }
-                b64 = btoa(binary);
+                return btoa(binary);
+            }
+            if (variants.length === 1 && variants[0].fontWeight === 'normal' && variants[0].fontStyle === 'normal') {
+                // Single normal variant — use simple url format
+                const b64 = toBase64(variants[0].data);
+                fonts.push({ fontFamily, url: `data:${variants[0].mime};base64,${b64}` });
+            }
+            else {
+                // Multiple variants — use styles array
+                const styles = variants.map((v) => {
+                    const b64 = toBase64(v.data);
+                    return {
+                        src: `url("data:${v.mime};base64,${b64}")`,
+                        fontWeight: v.fontWeight,
+                        fontStyle: v.fontStyle,
+                    };
+                });
+                fonts.push({ fontFamily, styles });
             }
-            fonts.push({ fontFamily, url: `data:${mime};base64,${b64}` });
         }
         return fonts;
     }