@polotno/pdf-export 0.1.37 → 0.1.38

package/lib/scripts/compare-json.js

@@ -0,0 +1,141 @@
+import fs from 'fs';
+function compareImages(original, converted, index) {
+    const differences = [];
+    // Compare position
+    const xDiff = Math.abs(original.x - converted.x);
+    const yDiff = Math.abs(original.y - converted.y);
+    if (xDiff > 1) {
+        differences.push(`  X: ${original.x.toFixed(2)} → ${converted.x.toFixed(2)} (Δ ${(converted.x - original.x).toFixed(2)})`);
+    }
+    if (yDiff > 1) {
+        differences.push(`  Y: ${original.y.toFixed(2)} → ${converted.y.toFixed(2)} (Δ ${(converted.y - original.y).toFixed(2)})`);
+    }
+    // Compare dimensions
+    const widthDiff = Math.abs(original.width - converted.width);
+    const heightDiff = Math.abs(original.height - converted.height);
+    if (widthDiff > 1) {
+        differences.push(`  Width: ${original.width.toFixed(2)} → ${converted.width.toFixed(2)} (Δ ${(converted.width - original.width).toFixed(2)})`);
+    }
+    if (heightDiff > 1) {
+        differences.push(`  Height: ${original.height.toFixed(2)} → ${converted.height.toFixed(2)} (Δ ${(converted.height - original.height).toFixed(2)})`);
+    }
+    // Compare rotation
+    const origRotation = original.rotation || 0;
+    const convRotation = converted.rotation || 0;
+    if (Math.abs(origRotation - convRotation) > 0.1) {
+        differences.push(`  Rotation: ${origRotation} → ${convRotation}`);
+    }
+    return differences;
+}
+function compareJSON(originalPath, convertedPath) {
+    console.log('='.repeat(80));
+    console.log('PDF Import Comparison Tool');
+    console.log('='.repeat(80));
+    console.log();
+    // Read JSON files
+    const original = JSON.parse(fs.readFileSync(originalPath, 'utf-8'));
+    const converted = JSON.parse(fs.readFileSync(convertedPath, 'utf-8'));
+    // Compare document dimensions
+    console.log('📄 Document Dimensions:');
+    console.log(`  Original:  ${original.width.toFixed(2)} x ${original.height.toFixed(2)}`);
+    console.log(`  Converted: ${converted.width.toFixed(2)} x ${converted.height.toFixed(2)}`);
+    const dimMatch = Math.abs(original.width - converted.width) < 1 &&
+        Math.abs(original.height - converted.height) < 1;
+    console.log(`  Status: ${dimMatch ? '✅ Match' : '❌ Mismatch'}`);
+    console.log();
+    // Compare page count
+    console.log('📑 Page Count:');
+    console.log(`  Original:  ${original.pages.length}`);
+    console.log(`  Converted: ${converted.pages.length}`);
+    console.log(`  Status: ${original.pages.length === converted.pages.length ? '✅ Match' : '❌ Mismatch'}`);
+    console.log();
+    // Compare each page
+    const maxPages = Math.max(original.pages.length, converted.pages.length);
+    for (let pageIdx = 0; pageIdx < maxPages; pageIdx++) {
+        console.log(`${'─'.repeat(80)}`);
+        console.log(`Page ${pageIdx + 1}:`);
+        console.log(`${'─'.repeat(80)}`);
+        const origPage = original.pages[pageIdx];
+        const convPage = converted.pages[pageIdx];
+        if (!origPage || !convPage) {
+            console.log('❌ Page missing in one of the documents');
+            console.log();
+            continue;
+        }
+        // Filter to only image elements for comparison
+        const origImages = origPage.children.filter(el => el.type === 'image');
+        const convImages = convPage.children.filter(el => el.type === 'image');
+        console.log();
+        console.log(`🖼️  Image Elements:`);
+        console.log(`  Original:  ${origImages.length} images`);
+        console.log(`  Converted: ${convImages.length} images`);
+        console.log();
+        // Compare each image
+        const maxImages = Math.max(origImages.length, convImages.length);
+        for (let imgIdx = 0; imgIdx < maxImages; imgIdx++) {
+            const origImg = origImages[imgIdx];
+            const convImg = convImages[imgIdx];
+            console.log(`  Image ${imgIdx + 1}:`);
+            if (!origImg) {
+                console.log('    ❌ Missing in original');
+                console.log();
+                continue;
+            }
+            if (!convImg) {
+                console.log('    ❌ Missing in converted');
+                console.log();
+                continue;
+            }
+            // Show original values
+            console.log(`    Original:  x=${origImg.x.toFixed(2)}, y=${origImg.y.toFixed(2)}, w=${origImg.width.toFixed(2)}, h=${origImg.height.toFixed(2)}`);
+            console.log(`    Converted: x=${convImg.x.toFixed(2)}, y=${convImg.y.toFixed(2)}, w=${convImg.width.toFixed(2)}, h=${convImg.height.toFixed(2)}`);
+            // Compare and show differences
+            const differences = compareImages(origImg, convImg, imgIdx);
+            if (differences.length === 0) {
+                console.log('    ✅ Perfect match');
+            }
+            else {
+                console.log('    ❌ Differences:');
+                differences.forEach(diff => console.log(`    ${diff}`));
+            }
+            console.log();
+        }
+        // Compare text elements
+        const origTexts = origPage.children.filter(el => el.type === 'text');
+        const convTexts = convPage.children.filter(el => el.type === 'text');
+        if (origTexts.length > 0 || convTexts.length > 0) {
+            console.log(`📝 Text Elements:`);
+            console.log(`  Original:  ${origTexts.length} text elements`);
+            console.log(`  Converted: ${convTexts.length} text elements`);
+            console.log();
+        }
+        // Show other element types
+        const origOther = origPage.children.filter(el => el.type !== 'image' && el.type !== 'text');
+        const convOther = convPage.children.filter(el => el.type !== 'image' && el.type !== 'text');
+        if (origOther.length > 0 || convOther.length > 0) {
+            console.log(`🔧 Other Elements:`);
+            console.log(`  Original:  ${origOther.length} elements`);
+            console.log(`  Converted: ${convOther.length} elements`);
+            console.log();
+        }
+    }
+    console.log('='.repeat(80));
+}
+// CLI usage
+const args = process.argv.slice(2);
+if (args.length < 2) {
+    console.log('Usage: npm run compare-json <original.json> <converted.json>');
+    console.log('Example: npm run compare-json tests/files/pdf-img-design.json tests/files/pdf-img-converted.json');
+    process.exit(1);
+}
+const [originalPath, convertedPath] = args;
+// Check files exist
+if (!fs.existsSync(originalPath)) {
+    console.error(`Error: Original file not found: ${originalPath}`);
+    process.exit(1);
+}
+if (!fs.existsSync(convertedPath)) {
+    console.error(`Error: Converted file not found: ${convertedPath}`);
+    process.exit(1);
+}
+compareJSON(originalPath, convertedPath);

package/lib/text/fonts.js

@@ -2,6 +2,35 @@ import { srcToBuffer } from '../utils.js';
 import getUrls from 'get-urls';
 import fetch from 'node-fetch';
 const fontUrlRegistry = {};
+const patchedPrototypes = new WeakSet();
+/**
+ * Patch fontkit's TTFGlyph._getCBox to handle zero-length glyphs.
+ * Some fonts (e.g. "Cute Font") have glyphs with equal start/end offsets
+ * in the loca table (no outline data), but fontkit still tries to read
+ * from the glyf table at that offset, causing a DataView out-of-bounds error.
+ */
+function patchFontkitGlyphs(doc) {
+    const fkFont = doc._font?.font;
+    if (!fkFont || typeof fkFont.getGlyph !== 'function')
+        return;
+    const glyph = fkFont.getGlyph(0);
+    const proto = Object.getPrototypeOf(glyph);
+    if (!proto._getCBox || patchedPrototypes.has(proto))
+        return;
+    const origGetCBox = proto._getCBox;
+    proto._getCBox = function (internal) {
+        const loca = this._font.loca;
+        if (loca) {
+            const start = loca.offsets[this.id];
+            const end = loca.offsets[this.id + 1];
+            if (start === end) {
+                return Object.freeze({ minX: 0, minY: 0, maxX: 0, maxY: 0 });
+            }
+        }
+        return origGetCBox.call(this, internal);
+    };
+    patchedPrototypes.add(proto);
+}
 export function registerFontUrl(fontFamily, url) {
     fontUrlRegistry[fontFamily] = url;
 }
@@ -53,6 +82,7 @@ export async function loadFontForSegment(doc, segment, element, fonts) {
     // Check if universal font is already defined
     if (fonts[fontFamily]) {
         doc.font(fontFamily);
+        patchFontkitGlyphs(doc);
         return fontFamily;
     }
     const fontKey = getFontKey(fontFamily, bold, italic, element.fontWeight);
@@ -74,6 +104,7 @@ export async function loadFontForSegment(doc, segment, element, fonts) {
         fonts[fontKey] = true;
     }
     doc.font(fontKey);
+    patchFontkitGlyphs(doc);
     return fontKey;
 }
 // Alias for backward compatibility

package/lib/text.d.ts

@@ -31,19 +31,9 @@ export interface TextSegment {
     underline?: boolean;
     color?: string;
 }
-/**
- * Normalize rich text HTML by converting block-level line breaks into newline characters
- * while preserving inline formatting tags.
- */
-declare function normalizeRichText(text: string): string;
-/**
- * Parse HTML text into styled segments
- */
-declare function parseHTMLToSegments(html: string, baseElement: TextElement): TextSegment[];
 export declare function getGoogleFontPath(fontFamily: string, fontWeight?: string, italic?: boolean): Promise<string>;
 export declare function loadFontIfNeeded(doc: any, element: TextElement, fonts: Record<string, boolean>): Promise<string>;
 /**
  * Main text rendering function
  */
 export declare function renderText(doc: PDFKit.PDFDocument, element: TextElement, fonts: Record<string, boolean>, attrs?: RenderAttrs): Promise<void>;
-export { normalizeRichText as __normalizeRichTextForTests, parseHTMLToSegments as __parseHTMLToSegmentsForTests, };