@polotno/pdf-import 0.0.2 → 0.0.3

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 {
@@ -43,11 +43,19 @@ export class FontRegistry {
         if (fontFamily !== mappedFamily) {
             this.renameMap.set(fontObj.name, fontFamily);
         }
-        // Collect font binary data
+        // 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(fontFamily) || [];
-            arr.push({ mime, data: new Uint8Array(fontObj.data) });
+            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)
@@ -93,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;
-            }
-            else {
-                fontData = mergeSubsetFonts(blobs.map((b) => b.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);
             }
-            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;
     }

package/lib/page-parser.js

@@ -558,7 +558,7 @@ async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors,
         // Find dominant span (longest text)
         const dominant = block.spans.reduce((a, b) => a.text.length > b.text.length ? a : b);
         const fontFamily = fontRegistry.getFontFamily(dominant.fontName);
-        const align = detectAlignment(block.spans, pageWidth, leftMargin, rightMargin);
+        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();
@@ -641,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) {
@@ -671,14 +675,8 @@ async function buildTextElements({ page, pageWidth, yFlipOffset, positionColors,
             text: textContent2,
             fontSize: dominant.fontSize,
             fontFamily,
-            // 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),
+            fontWeight: dominant.fontWeight || extractWeightFromName(dominant.fontName),
+            fontStyle: dominant.fontStyle || extractStyleFromName(dominant.fontName),
             fill: dominant.color || '#000000',
             align,
             lineHeight,

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) || [];
@@ -185,10 +185,16 @@ export function detectAlignment(blockSpans, pageWidth, leftMargin, rightMargin)
         // 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';
     }
@@ -204,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,
@@ -219,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.2",
+  "version": "0.0.3",
   "description": "Convert PDF files into Polotno JSON format",
   "type": "module",
   "main": "./lib/index.js",