@polotno/pdf-import 0.0.1 → 0.0.3

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,8 +557,8 @@ 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 align = detectAlignment(block.spans, pageWidth, leftMargin, rightMargin);
+        const fontFamily = fontRegistry.getFontFamily(dominant.fontName);
+        const align = detectAlignment(block.spans, pageWidth, leftMargin, rightMargin, blocks.map((b) => ({ x: b.x, width: b.width })));
         const lineHeight = computeLineHeight(block.spans);
         // Build text content with line breaks
         const lineMap = new Map();
@@ -628,10 +641,14 @@ async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors,
         else if (align === 'right') {
             elemX -= extraWidth;
         }
-        // Polotno rotates text around the top-left corner. For vertical text, anchor
-        // against the baseline/right edge so the rotated box stays in the same place.
+        // Polotno rotates text around the top-left corner. For vertical text we need
+        // to convert PDF baseline coordinates into Polotno element coordinates.
+        // The element's y-axis maps to the visual x-axis after rotation, so the
+        // half-leading and ascent offsets that normally adjust elemY must instead
+        // adjust elemX.
         if (dominant.rotation <= -45 && dominant.rotation >= -135) {
-            elemX -= elemHeight;
+            const ascentPx = dominant.baselineY - dominant.y;
+            elemX = block.x - ascentPx - halfLeading;
             elemY = dominant.baselineY;
         }
         else if (dominant.rotation >= 45 && dominant.rotation <= 135) {
@@ -642,7 +659,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(),

package/lib/text-blocks.d.ts

@@ -1,6 +1,9 @@
 import type { TextBlock, TextSpan } from './text-types.js';
 export declare function groupSpansByBlock(spans: TextSpan[]): TextBlock[];
-export declare function detectAlignment(blockSpans: TextSpan[], pageWidth: number, leftMargin: number, rightMargin: number): string;
+export declare function detectAlignment(blockSpans: TextSpan[], pageWidth: number, leftMargin: number, rightMargin: number, allBlocks?: {
+    x: number;
+    width: number;
+}[]): string;
 export declare function estimatePageMargins(spans: TextSpan[]): [number, number];
 export declare function computeLineHeight(blockSpans: TextSpan[]): number;
 //# sourceMappingURL=text-blocks.d.ts.map

package/lib/text-blocks.js

@@ -152,7 +152,7 @@ function splitSpansAtPositions(spans, splitPositions) {
     return columns.filter((c) => c.length > 0);
 }
 // Alignment detection
-export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin) {
+export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin, allBlocks) {
     const lines = new Map();
     for (const span of blockSpans) {
         const arr = lines.get(span.lineNo) || [];
@@ -175,15 +175,26 @@ 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
         // is more likely a paragraph line than a right-aligned label.
+        // Additional guard: if other blocks share this left edge, the text is in a
+        // left-aligned column and just happens to reach the right margin.
         const lineWidth = x1 - x0;
+        const hasAlignedNeighbors = allBlocks &&
+            allBlocks.filter((b) => Math.abs(b.x - x0) < 3 && b.width !== lineWidth)
+                .length >= 2;
         if (Math.abs(x1 - rightMargin) < rightTol &&
             x0 > leftMargin + centerTol &&
-            lineWidth < textWidth * 0.6)
+            lineWidth < textWidth * 0.6 &&
+            !hasAlignedNeighbors)
             return 'right';
         return 'left';
     }
@@ -199,6 +210,11 @@ export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin)
     const rightStd = stddev(rightEdges);
     const midStd = stddev(midpoints);
     const THRESHOLD = 3.0;
+    // For center detection, scale threshold with font size. A fixed 3px is fine
+    // for 12px text but too tight for large display text (e.g. 55px "BENEFIT OF"
+    // / "WAXING" has midpoint stddev 3.2 — clearly centered but misses 3.0).
+    const dominantFontSize = blockSpans.reduce((a, b) => a.text.length > b.text.length ? a : b).fontSize;
+    const centerThreshold = Math.max(THRESHOLD, dominantFontSize * 0.1);
     if (leftStd < THRESHOLD && rightStd < THRESHOLD)
         return 'justify';
     // Justify detection with tolerance for short lines: last lines of paragraphs,
@@ -214,7 +230,7 @@ export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin)
                 return 'justify';
         }
     }
-    if (midStd < THRESHOLD && midStd <= leftStd && midStd <= rightStd)
+    if (midStd < centerThreshold && midStd <= leftStd && midStd <= rightStd)
         return 'center';
     if (rightStd < THRESHOLD && rightStd < leftStd)
         return 'right';

package/lib/text-layout.js

@@ -276,7 +276,7 @@ function assignBlockNumbers(spans, startBlockNo = 0) {
         const fontSizeRatio = Math.max(prevFontSize, currFontSize) /
             Math.min(prevFontSize, currFontSize);
         const onSameLine = prev.spans[0].lineNo === curr.spans[0].lineNo;
-        const fontSizeChanged = !onSameLine && fontSizeRatio > 1.15;
+        const fontSizeChanged = !onSameLine && fontSizeRatio > 1.08;
         // Color change between lines signals different text elements (e.g. diagram
         // labels in different colors: gray "Force control signal" vs black "Inter-neurons").
         // Only split on color when X overlap is weak — paragraph lines have strong overlap

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polotno/pdf-import",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "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",