@polotno/pdf-import 0.0.1 → 0.0.2

package/lib/index.js

@@ -1 +1 @@
-import{getDocument as x,GlobalWorkerOptions as m}from"pdfjs-dist/legacy/build/pdf.mjs";import{parsePage as I}from"./page-parser.js";import{FontRegistry as R}from"./font-registry.js";import{buildJpegIndex as S}from"./pdf-image-extractor.js";let k=0;function A(){return`el_${Date.now()}_${++k}`}async function j({pdf:e,fontStrategy:w="embed"}){typeof window<"u"&&!m.workerSrc&&(m.workerSrc=new URL("pdfjs-dist/legacy/build/pdf.worker.mjs",import.meta.url).toString());const s=new Uint8Array(e instanceof ArrayBuffer?e:e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength)),l=S(s),r=await x({data:s,useSystemFonts:!0,disableFontFace:!0,fontExtraProperties:!0}).promise,i=new R;let c=612,g=792;const f=await r.getPage(1),u=f.getViewport({scale:1});c=u.width,g=u.height;const d=3,n=new Array(r.numPages);for(let o=0;o<r.numPages;o+=d){const y=Math.min(o+d,r.numPages),p=[];for(let t=o;t<y;t++)p.push((async()=>{const a=t===0?f:await r.getPage(t+1),{parsedPage:P}=await I({page:a,pageIdx:t,fontRegistry:i,generateId:A,jpegIndex:l});return{parsedPage:P,pageIdx:t}})());const b=await Promise.all(p);for(const{parsedPage:t,pageIdx:a}of b)n[a]=t}await r.destroy();const h=i.finalize(w,n);return{width:c,height:g,fonts:h,pages:n,unit:"px",dpi:72}}export{j as pdfToJson};
+import{getDocument as x,GlobalWorkerOptions as m}from"pdfjs-dist/legacy/build/pdf.mjs";import{parsePage as R}from"./page-parser.js";import{FontRegistry as I}from"./font-registry.js";import{buildJpegIndex as O}from"./pdf-image-extractor.js";import{workerSource as k}from"./generated/pdf-worker-source.js";let A=0;function C(){return`el_${Date.now()}_${++A}`}async function L({pdf:e,fontStrategy:s="embed"}){if(typeof window<"u"&&!m.workerSrc){const r=new Blob([k],{type:"application/javascript"});m.workerSrc=URL.createObjectURL(r)}const i=new Uint8Array(e instanceof ArrayBuffer?e:e.buffer.slice(e.byteOffset,e.byteOffset+e.byteLength)),d=O(i),o=await x({data:i,useSystemFonts:!0,disableFontFace:!0,fontExtraProperties:!0}).promise,c=new I;let g=612,p=792;const f=await o.getPage(1),u=f.getViewport({scale:1});g=u.width,p=u.height;const w=3,n=new Array(o.numPages);for(let r=0;r<o.numPages;r+=w){const h=Math.min(r+w,o.numPages),l=[];for(let t=r;t<h;t++)l.push((async()=>{const a=t===0?f:await o.getPage(t+1),{parsedPage:P}=await R({page:a,pageIdx:t,fontRegistry:c,generateId:C,jpegIndex:d,fontStrategy:s});return{parsedPage:P,pageIdx:t}})());const y=await Promise.all(l);for(const{parsedPage:t,pageIdx:a}of y)n[a]=t}await o.destroy();const b=c.finalize(s,n);return{width:g,height:p,fonts:b,pages:n,unit:"px",dpi:72}}export{L as pdfToJson};

package/lib/page-parser.d.ts

@@ -7,12 +7,13 @@ interface ParsePageOptions {
     fontRegistry: FontRegistry;
     generateId: () => string;
     jpegIndex: Map<number, RawImageStream>;
+    fontStrategy: 'embed' | 'googleFontsMatch';
 }
 interface ParsePageResult {
     parsedPage: PolotnoPage;
     pageWidth: number;
     pageHeight: number;
 }
-export declare function parsePage({ page, pageIdx, fontRegistry, generateId, jpegIndex, }: ParsePageOptions): Promise<ParsePageResult>;
+export declare function parsePage({ page, pageIdx, fontRegistry, generateId, jpegIndex, fontStrategy, }: ParsePageOptions): Promise<ParsePageResult>;
 export {};
 //# sourceMappingURL=page-parser.d.ts.map

package/lib/page-parser.js

@@ -1,13 +1,13 @@
 import { extractTextPositionColors, extractDrawingsAndImages, } from './operator-list.js';
 import { groupTextItems, groupSpansByBlock, detectAlignment, estimatePageMargins, computeLineHeight, } from './text-grouper.js';
-import { mapPdfFont, isKnownWebFont, extractWeightFromName, extractStyleFromName, } from './font-mapper.js';
+import { isKnownWebFont, extractWeightFromName, extractStyleFromName, } from './font-mapper.js';
 import { drawingToSvg, svgToDataUri, clippedDrawingsToSvg, clipPathToSvg, } from './svg-builder.js';
 import { imageDataToDataUri } from './image-encoder.js';
 import { rgbTupleToHex } from './color-utils.js';
 import { MIN_TEXT_WIDTH, MIN_TEXT_HEIGHT, MIN_IMAGE_WIDTH, MIN_IMAGE_HEIGHT, } from './constants.js';
 import { parseRef } from './pdf-image-extractor.js';
 import { imageBytesToDataUri } from './image-encoder.js';
-export async function parsePage({ page, pageIdx, fontRegistry, generateId, jpegIndex, }) {
+export async function parsePage({ page, pageIdx, fontRegistry, generateId, jpegIndex, fontStrategy, }) {
     const viewport = page.getViewport({ scale: 1 });
     const pageWidth = viewport.width;
     const pageHeight = viewport.height;
@@ -25,7 +25,7 @@ export async function parsePage({ page, pageIdx, fontRegistry, generateId, jpegI
     const [, imageElements, { fontNameMap, fontAscentMap, fontOtMap }] = await Promise.all([
         resolveDrawingGradients(page, drawings),
         buildImageElements(page, imageRefs, pageIdx, generateId, jpegIndex),
-        collectPageFonts(page, fontRefs, fontRegistry),
+        collectPageFonts(page, fontRefs, fontRegistry, fontStrategy === 'embed'),
     ]);
     const pageBackground = detectPageBackground(drawings, pageWidth, pageHeight);
     const svgElements = buildSvgElements(drawings, pageWidth, pageHeight, generateId);
@@ -38,6 +38,8 @@ export async function parsePage({ page, pageIdx, fontRegistry, generateId, jpegI
         fontAscentMap,
         fontOtMap,
         generateId,
+        fontStrategy,
+        fontRegistry,
     });
     // Assemble page: all elements sorted by PDF paint order
     const allElements = [...svgElements, ...imageElements, ...textElements].sort((a, b) => a._order - b._order);
@@ -383,7 +385,7 @@ async function buildImageElements(page, imageRefs, pageIdx, generateId, jpegInde
     }
     return imageElements;
 }
-async function collectPageFonts(page, fontRefs, fontRegistry) {
+async function collectPageFonts(page, fontRefs, fontRegistry, embedAll = false) {
     // Build font name map: loadedName (g_d0_f1) → real PDF name (CZZZZZ+Roboto-Regular)
     // Also build font ascent map for accurate Y positioning (glyph top vs baseline)
     const fontNameMap = new Map();
@@ -405,7 +407,7 @@ async function collectPageFonts(page, fontRefs, fontRegistry) {
                 if (fontObj.ascent != null) {
                     fontAscentMap.set(ref, fontObj.ascent);
                 }
-                fontRegistry.recordFont(fontObj);
+                fontRegistry.recordFont(fontObj, embedAll);
                 // Parse font binary with opentype.js for per-character width computation
                 // Uses FontRegistry cache to avoid re-parsing the same font across pages
                 if (fontObj.data && fontObj.data.length > 0) {
@@ -432,19 +434,18 @@ async function collectPageFonts(page, fontRefs, fontRegistry) {
  *
  * We average across all spans in the block and express as ratio of fontSize.
  */
-function computeBlockLetterSpacing(fullText, blockWidth, spans, fontSize, dominantFontName, fontOtByName) {
+function computeBlockLetterSpacing(fullText, blockWidth, spans, fontSize, dominantFontName, fontOtByName, allFontsEmbedded = false) {
     if (fontSize < 1)
         return 0;
     const isSingleLine = !fullText.includes('\n');
     // For single-line text, compare the font's full rendering width against the
-    // PDF block width. For embedded (non-web) fonts the browser uses the same
-    // subset we parsed, so .notdef space width is correct. For known web fonts
-    // the browser uses the real font (not the subset), so .notdef space width
-    // is wrong — bail out and use the per-span path instead.
+    // PDF block width. When space maps to .notdef, use a fixed 25% em-width
+    // estimate instead of the .notdef advance width. PDF subset fonts' .notdef
+    // widths vary wildly (26–60% of em) and don't reflect what the browser
+    // actually renders for a missing space glyph (system font fallback, ~25%).
     if (isSingleLine) {
         const otFont = fontOtByName.get(dominantFontName);
         if (otFont) {
-            const fontIsEmbedded = !isKnownWebFont(dominantFontName);
             const scale = fontSize / otFont.unitsPerEm;
             const notdefGlyph = otFont.glyphs.get(0);
             let fontWidth = 0;
@@ -453,10 +454,12 @@ function computeBlockLetterSpacing(fullText, blockWidth, spans, fontSize, domina
             for (const ch of fullText) {
                 const glyph = otFont.charToGlyph(ch);
                 if (glyph === notdefGlyph || !glyph.advanceWidth) {
-                    // For embedded fonts, .notdef space is what the browser will render.
-                    // For web fonts, .notdef space width is wrong — bail out.
-                    if (ch === ' ' && fontIsEmbedded) {
-                        fontWidth += (glyph.advanceWidth || 0) * scale;
+                    if (ch === ' ') {
+                        // Use typical space width (~25% of em) as estimate for what the
+                        // browser renders when the embedded font lacks a space glyph.
+                        // See DESIGN_NOTES.md "Letter Spacing & Missing Space Glyphs"
+                        // for why .notdef width and font injection don't work here.
+                        fontWidth += fontSize * 0.25;
                         charCount++;
                         continue;
                     }
@@ -516,13 +519,23 @@ function computeBlockLetterSpacing(fullText, blockWidth, spans, fontSize, domina
         return 0;
     const perCharRatio = totalDelta / totalChars / fontSize;
     const rounded = Math.round(perCharRatio * 1000) / 1000;
+    // For known web fonts, the embedded subset glyph widths can differ
+    // significantly from the real web font the browser will load. Large
+    // letterSpacing values (>0.02) are likely subset metric mismatches,
+    // not real tracking. Cap to avoid visual distortion.
+    // When fonts are embedded, the subset metrics match what Polotno renders,
+    // so trust the computed value. For web fonts, large values are likely
+    // subset metric mismatches — cap to avoid distortion.
+    const dominantIsWebFont = !allFontsEmbedded && isKnownWebFont(spans[0]?.fontName ?? '');
+    if (dominantIsWebFont && Math.abs(rounded) > 0.02)
+        return 0;
     // Threshold: ignore if the total pixel impact is < 1px.
     // At small fonts (12pt, 10 chars) 0.005 ratio = 0.6px total → skip.
     // At large fonts (615pt, 9 chars) 0.003 ratio = 16px total → keep.
     const totalPxImpact = Math.abs(rounded) * fontSize * totalChars;
     return totalPxImpact < 1 ? 0 : rounded;
 }
-async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors, fontNameMap, fontAscentMap, fontOtMap, generateId, }) {
+async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors, fontNameMap, fontAscentMap, fontOtMap, generateId, fontStrategy, fontRegistry, }) {
     // Extract text
     const textContent = await page.getTextContent();
     const textSpans = groupTextItems(textContent.items, textContent.styles || {}, yFlipOffset, positionColors, fontNameMap, fontAscentMap);
@@ -544,7 +557,7 @@ async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors,
             continue;
         // Find dominant span (longest text)
         const dominant = block.spans.reduce((a, b) => a.text.length > b.text.length ? a : b);
-        const fontFamily = mapPdfFont(dominant.fontName);
+        const fontFamily = fontRegistry.getFontFamily(dominant.fontName);
         const align = detectAlignment(block.spans, pageWidth, leftMargin, rightMargin);
         const lineHeight = computeLineHeight(block.spans);
         // Build text content with line breaks
@@ -642,7 +655,7 @@ async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors,
         // Compute letter spacing by comparing PDF advance widths with opentype.js
         // character widths. The difference (per char, as ratio of fontSize) tells us
         // how much extra spacing the PDF applies vs browser default rendering.
-        const letterSpacing = computeBlockLetterSpacing(textContent2, block.width, block.spans, dominant.fontSize, dominant.fontName, fontOtByName);
+        const letterSpacing = computeBlockLetterSpacing(textContent2, block.width, block.spans, dominant.fontSize, dominant.fontName, fontOtByName, fontStrategy === 'embed');
         textElements.push({
             type: 'text',
             id: generateId(),
@@ -658,8 +671,14 @@ async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors,
             text: textContent2,
             fontSize: dominant.fontSize,
             fontFamily,
-            fontWeight: dominant.fontWeight || extractWeightFromName(dominant.fontName),
-            fontStyle: dominant.fontStyle || extractStyleFromName(dominant.fontName),
+            // When embedding fonts, the subset file IS the specific variant (bold,
+            // italic, etc.), so use "normal" to avoid Polotno synthesizing on top.
+            fontWeight: fontStrategy === 'embed'
+                ? 'normal'
+                : dominant.fontWeight || extractWeightFromName(dominant.fontName),
+            fontStyle: fontStrategy === 'embed'
+                ? 'normal'
+                : dominant.fontStyle || extractStyleFromName(dominant.fontName),
             fill: dominant.color || '#000000',
             align,
             lineHeight,

package/lib/text-blocks.js

@@ -175,7 +175,12 @@ export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin)
         const pageCenter = (leftMargin + rightMargin) / 2;
         const centerTol = textWidth * 0.05;
         const rightTol = textWidth * 0.05;
-        if (Math.abs(blockCenter - pageCenter) < centerTol)
+        // Also check against actual page center to avoid false positives when all
+        // text is clustered on one side (margins don't reflect the full page).
+        const actualPageCenter = pageWidth / 2;
+        const pageCenterTol = pageWidth * 0.05;
+        if (Math.abs(blockCenter - pageCenter) < centerTol &&
+            Math.abs(blockCenter - actualPageCenter) < pageCenterTol)
             return 'center';
         // Only classify as right-aligned if the line is short relative to the text
         // area — a near-full-width line that happens to align with the right margin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polotno/pdf-import",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Convert PDF files into Polotno JSON format",
   "type": "module",
   "main": "./lib/index.js",
@@ -12,7 +12,7 @@
     }
   },
   "scripts": {
-    "build": "tsc && node build.js",
+    "build": "node generate-worker.js && tsc && node build.js",
     "test": "vitest run tests/index.test.ts",
     "test:update": "vitest run tests/index.test.ts --update",
     "test:visual": "node --max-old-space-size=4096 ./node_modules/.bin/vitest run --config vitest.visual.config.ts tests/visual-regression.test.ts",