@polotno/pdf-export 0.1.36 → 0.1.38

package/lib/pdf-import/parser.js

@@ -0,0 +1,285 @@
+import * as pdfjsLib from 'pdfjs-dist/legacy/build/pdf.mjs';
+import fs from 'fs';
+import { createCanvas } from 'canvas';
+import { calculateFontSize, extractPosition } from './coordinate-transform.js';
+/**
+ * Load PDF document from file path or buffer
+ */
+export async function loadPDF(source) {
+    let data;
+    if (typeof source === 'string') {
+        // Load from file path
+        data = new Uint8Array(fs.readFileSync(source));
+    }
+    else {
+        // Use buffer directly
+        data = new Uint8Array(source);
+    }
+    const loadingTask = pdfjsLib.getDocument({
+        data,
+        // useSystemFonts: false,
+        // standardFontDataUrl: undefined,
+        // useWorkerFetch: false,
+        // isEvalSupported: true,
+    });
+    return await loadingTask.promise;
+}
+/**
+ * Get number of pages in PDF document
+ */
+export function getPageCount(pdfDoc) {
+    return pdfDoc.numPages;
+}
+/**
+ * Extract metadata from a single PDF page
+ */
+export async function extractPageMetadata(page, pageNumber) {
+    const viewport = page.getViewport({ scale: 1.0 });
+    return {
+        pageNumber,
+        width: viewport.width,
+        height: viewport.height,
+        rotate: viewport.rotation || 0,
+    };
+}
+/**
+ * Extract text items from a PDF page with position and font metadata
+ */
+export async function extractTextItems(page) {
+    const textContent = await page.getTextContent({
+        includeMarkedContent: true
+    });
+    const items = [];
+    for (const item of textContent.items) {
+        // Skip empty text
+        if (!item.str || item.str.trim().length === 0) {
+            continue;
+        }
+        // Extract font size from transformation matrix
+        const fontSize = calculateFontSize(item.transform);
+        // Extract position
+        const position = extractPosition(item.transform);
+        // Get color if available (default to black)
+        let color = [0, 0, 0]; // Default black
+        if (item.color && Array.isArray(item.color)) {
+            color = item.color;
+        }
+        items.push({
+            str: item.str,
+            transform: item.transform,
+            width: item.width,
+            height: item.height,
+            fontName: textContent.styles[item.fontName].fontFamily,
+            fontSize,
+            hasEOL: item.hasEOL || false,
+            dir: item.dir || 'ltr',
+            color,
+        });
+    }
+    return items;
+}
+/**
+ * Multiply two transformation matrices
+ */
+function multiplyMatrices(m1, m2) {
+    const [a1, b1, c1, d1, e1, f1] = m1;
+    const [a2, b2, c2, d2, e2, f2] = m2;
+    return [
+        a1 * a2 + b1 * c2,
+        a1 * b2 + b1 * d2,
+        c1 * a2 + d1 * c2,
+        c1 * b2 + d1 * d2,
+        e1 * a2 + f1 * c2 + e2,
+        e1 * b2 + f1 * d2 + f2
+    ];
+}
+/**
+ * Find transform matrix for an image by looking for the pattern:
+ * - Pure translation matrix (position)
+ * - Scale/flip matrix (dimensions)
+ *
+ * We combine these to get the final transform
+ */
+function findTransformForImage(ops, imageIndex) {
+    let translationTransform = null;
+    let scaleTransform = null;
+    // Walk backwards from the image to find the most recent transforms
+    for (let i = imageIndex - 1; i >= 0; i--) {
+        const fn = ops.fnArray[i];
+        // Stop if we hit a restore (means we're outside the image's graphics state)
+        if (fn === 32 || fn === 11) {
+            break;
+        }
+        if (fn === 35 || fn === 12) { // Transform operation
+            const transform = ops.argsArray[i];
+            if (transform && Array.isArray(transform) && transform.length >= 6) {
+                const [a, b, c, d, e, f] = transform;
+                // Check if this is a pure translation (identity scale/rotation with position)
+                if (Math.abs(a - 1) < 0.001 && Math.abs(b) < 0.001 &&
+                    Math.abs(c) < 0.001 && Math.abs(Math.abs(d) - 1) < 0.001) {
+                    if (!translationTransform) {
+                        translationTransform = transform;
+                    }
+                }
+                else {
+                    // This is a scale/rotation transform
+                    if (!scaleTransform) {
+                        scaleTransform = transform;
+                    }
+                }
+                // If we found both, we're done
+                if (translationTransform && scaleTransform) {
+                    break;
+                }
+            }
+        }
+    }
+    // Build the final transform by combining translation and scale
+    if (translationTransform && scaleTransform) {
+        const [, , , , tx, ty] = translationTransform;
+        const [a, b, c, d, sx, sy] = scaleTransform;
+        // Combine: use scale/rotation from scaleTransform, position from translationTransform
+        return [a, b, c, d, tx, ty];
+    }
+    // Fallback to scale transform only if no translation found
+    if (scaleTransform) {
+        return scaleTransform;
+    }
+    // Fallback to translation only if no scale found
+    if (translationTransform) {
+        return translationTransform;
+    }
+    // Ultimate fallback: identity
+    return [1, 0, 0, 1, 0, 0];
+}
+/**
+ * Wait for a PDF object to be resolved with timeout and retry logic
+ */
+async function waitForObject(page, objectName, timeoutMs = 5000) {
+    const startTime = Date.now();
+    const retryDelay = 50; // ms between retries
+    while (Date.now() - startTime < timeoutMs) {
+        try {
+            // Check if object exists in the objects dictionary
+            if (page.objs.has(objectName)) {
+                const obj = page.objs.get(objectName);
+                if (obj) {
+                    return obj;
+                }
+            }
+            // Wait a bit before retrying
+            await new Promise(resolve => setTimeout(resolve, retryDelay));
+        }
+        catch (error) {
+            // Continue retrying
+        }
+    }
+    throw new Error(`Timeout waiting for ${objectName} after ${timeoutMs}ms`);
+}
+/**
+ * Extract images from a PDF page with enhanced async handling
+ */
+export async function extractImages(page) {
+    try {
+        const ops = await page.getOperatorList();
+        // First pass: collect all image names and their indices
+        const imageOperations = [];
+        for (let i = 0; i < ops.fnArray.length; i++) {
+            const fn = ops.fnArray[i];
+            const args = ops.argsArray[i];
+            // Check for image operations
+            // OPS.paintImageXObject = 85, OPS.paintInlineImageXObject = 86
+            if (fn === 85 || fn === 86) {
+                const imageName = args[0];
+                if (imageName) {
+                    imageOperations.push({ name: imageName, index: i, opCode: fn });
+                }
+            }
+        }
+        // If no images found, return early
+        if (imageOperations.length === 0) {
+            return [];
+        }
+        // Second pass: extract all images in parallel with proper async handling
+        const imagePromises = imageOperations.map(async ({ name, index, opCode }) => {
+            try {
+                // Wait for the object to be resolved with timeout
+                const image = await waitForObject(page, name, 5000);
+                if (!image || !image.data) {
+                    return null;
+                }
+                // PDF.js returns raw RGBA pixel data, we need to encode it as PNG/JPEG
+                const canvas = createCanvas(image.width, image.height);
+                const ctx = canvas.getContext('2d');
+                // Create ImageData from the raw pixel data
+                const imageData = ctx.createImageData(image.width, image.height);
+                imageData.data.set(image.data);
+                ctx.putImageData(imageData, 0, 0);
+                // Encode to buffer (PNG by default, JPEG if original was JPEG)
+                let buffer;
+                let mimeType;
+                if (image.kind === 1) {
+                    // Original was JPEG - encode as JPEG with 90% quality
+                    buffer = canvas.toBuffer('image/jpeg', { quality: 0.9 });
+                    mimeType = 'image/jpeg';
+                }
+                else {
+                    // Encode as PNG (lossless)
+                    buffer = canvas.toBuffer('image/png');
+                    mimeType = 'image/png';
+                }
+                // Get transformation matrix
+                const transform = findTransformForImage(ops, index);
+                return {
+                    buffer,
+                    mimeType,
+                    width: image.width,
+                    height: image.height,
+                    transform,
+                };
+            }
+            catch (error) {
+                console.warn(`Failed to extract image ${name}:`, error instanceof Error ? error.message : error);
+                return null;
+            }
+        });
+        // Wait for all images to be processed
+        const results = await Promise.all(imagePromises);
+        // Filter out null results (failed extractions)
+        return results.filter((img) => img !== null);
+    }
+    catch (error) {
+        console.warn('Failed to extract images from page:', error);
+        return [];
+    }
+}
+/**
+ * Parse a single PDF page and extract all content
+ */
+export async function parsePage(pdfDoc, pageNumber) {
+    const page = await pdfDoc.getPage(pageNumber);
+    const [metadata, textItems, images] = await Promise.all([
+        extractPageMetadata(page, pageNumber),
+        extractTextItems(page),
+        extractImages(page),
+    ]);
+    return {
+        metadata,
+        textItems,
+        images,
+    };
+}
+/**
+ * Parse entire PDF document or specific pages
+ */
+export async function parsePDF(source, pageNumbers) {
+    const pdfDoc = await loadPDF(source);
+    const totalPages = getPageCount(pdfDoc);
+    // Determine which pages to parse
+    const pagesToParse = pageNumbers && pageNumbers.length > 0
+        ? pageNumbers.filter(n => n >= 1 && n <= totalPages)
+        : Array.from({ length: totalPages }, (_, i) => i + 1);
+    // Parse all pages in parallel
+    const pages = await Promise.all(pagesToParse.map(pageNum => parsePage(pdfDoc, pageNum)));
+    return pages;
+}

package/lib/pdf-import/text-analysis.d.ts

@@ -0,0 +1,17 @@
+import type { PDFTextItem, TextBlock, PDFImportOptions } from './types.js';
+/**
+ * Sort text items by position (top-to-bottom, left-to-right)
+ */
+export declare function sortTextItems(items: PDFTextItem[], pageHeight: number): PDFTextItem[];
+/**
+ * Cluster text items into text blocks
+ */
+export declare function clusterTextItems(items: PDFTextItem[], pageHeight: number, pageWidth: number, options: PDFImportOptions): TextBlock[];
+/**
+ * Detect text alignment based on position within page
+ */
+export declare function detectAlignment(block: TextBlock, pageWidth: number): 'left' | 'center' | 'right';
+/**
+ * Apply alignment detection to all blocks
+ */
+export declare function applyAlignmentDetection(blocks: TextBlock[], pageWidth: number): TextBlock[];

package/lib/pdf-import/text-analysis.js

@@ -0,0 +1,186 @@
+import { extractPosition, extractRotation, pdfToPolotnoX, pdfToPolotnoY, pdfColorToHex, } from './coordinate-transform.js';
+import { mapFont } from './font-mapper.js';
+/**
+ * Sort text items by position (top-to-bottom, left-to-right)
+ */
+export function sortTextItems(items, pageHeight) {
+    return items.sort((a, b) => {
+        const posA = extractPosition(a.transform);
+        const posB = extractPosition(b.transform);
+        // Convert PDF Y (bottom-origin) to top-origin for comparison
+        const yA = pageHeight - posA.y;
+        const yB = pageHeight - posB.y;
+        // Same line threshold (5 pixels)
+        const lineThreshold = 5;
+        if (Math.abs(yA - yB) < lineThreshold) {
+            // Same line, sort by X (left to right)
+            return posA.x - posB.x;
+        }
+        // Different lines, sort by Y (top to bottom)
+        return yA - yB;
+    });
+}
+/**
+ * Check if two text items should be in the same block based on proximity and font
+ */
+function shouldMerge(item1, item2, pageHeight, options) {
+    const pos1 = extractPosition(item1.transform);
+    const pos2 = extractPosition(item2.transform);
+    // Get thresholds from options
+    const verticalThreshold = item1.fontSize; // options.textClusterThreshold?.vertical ?? 20;
+    const horizontalThreshold = options.textClusterThreshold?.horizontal ?? 10;
+    // Convert PDF Y to top-origin
+    const y1 = pageHeight - pos1.y;
+    const y2 = pageHeight - pos2.y;
+    // Check vertical distance
+    const verticalDistance = Math.abs(y1 - y2);
+    if (verticalDistance > verticalThreshold) {
+        return false;
+    }
+    // Check horizontal distance (for same line)
+    const horizontalDistance = Math.abs(pos2.x - (pos1.x + item1.width));
+    if (verticalDistance < 5 && horizontalDistance > horizontalThreshold) {
+        return false;
+    }
+    // Check font consistency
+    if (item1.fontName !== item2.fontName) {
+        return false;
+    }
+    // Check font size consistency (within 1pt tolerance)
+    if (Math.abs((item1.fontSize || 0) - (item2.fontSize || 0)) > 1) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Cluster text items into text blocks
+ */
+export function clusterTextItems(items, pageHeight, pageWidth, options) {
+    if (items.length === 0) {
+        return [];
+    }
+    // Sort items first
+    const sortedItems = sortTextItems(items, pageHeight);
+    // Filter out items that are too small
+    const minSize = options.minTextBlockSize ?? 8;
+    const filteredItems = sortedItems.filter(item => (item.fontSize || 0) >= minSize);
+    if (filteredItems.length === 0) {
+        return [];
+    }
+    const blocks = [];
+    let currentBlock = [filteredItems[0]];
+    for (let i = 1; i < filteredItems.length; i++) {
+        const prevItem = filteredItems[i - 1];
+        const currentItem = filteredItems[i];
+        if (shouldMerge(prevItem, currentItem, pageHeight, options)) {
+            // Add to current block
+            currentBlock.push(currentItem);
+        }
+        else {
+            // Finalize current block and start new one
+            if (currentBlock.length > 0) {
+                blocks.push(createTextBlock(currentBlock, pageHeight, options));
+            }
+            currentBlock = [currentItem];
+        }
+    }
+    // Don't forget the last block
+    if (currentBlock.length > 0) {
+        blocks.push(createTextBlock(currentBlock, pageHeight, options));
+    }
+    return blocks;
+}
+/**
+ * Create a text block from a cluster of text items
+ */
+function createTextBlock(items, pageHeight, options) {
+    // Combine text with proper spacing
+    let text = '';
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        text += item.str;
+        // Add space if needed (not at end, and next item doesn't start with space)
+        if (i < items.length - 1) {
+            const nextItem = items[i + 1];
+            const pos = extractPosition(item.transform);
+            const nextPos = extractPosition(nextItem.transform);
+            // Check if items are on same line
+            const y = pageHeight - pos.y;
+            const nextY = pageHeight - nextPos.y;
+            if (Math.abs(y - nextY) < 5) {
+                // Same line - add space if there's a gap
+                const gap = nextPos.x - (pos.x + item.width);
+                if (gap > 2 && !nextItem.str.startsWith(' ') && !item.str.endsWith(' ')) {
+                    text += ' ';
+                }
+            }
+            else {
+                // Different line - add newline
+                if (!text.endsWith('\n')) {
+                    text += '\n';
+                }
+            }
+        }
+    }
+    // Calculate bounding box
+    const positions = items.map(item => extractPosition(item.transform));
+    const minX = Math.min(...positions.map(p => p.x));
+    const maxX = Math.max(...items.map((item, i) => positions[i].x + item.width));
+    const minY = Math.min(...positions.map(p => p.y));
+    const maxY = Math.max(...items.map((item, i) => positions[i].y + item.height));
+    const width = maxX - minX;
+    const height = maxY - minY;
+    // Use first item for font properties
+    const firstItem = items[0];
+    const fontSize = firstItem.fontSize || 12;
+    const rotation = extractRotation(firstItem.transform);
+    // Map font
+    const mappedFont = mapFont(firstItem.fontName, options.fontMapping);
+    // Extract color
+    const color = pdfColorToHex(firstItem.color || [0, 0, 0]);
+    // Transform coordinates
+    const x = pdfToPolotnoX(minX);
+    const y = pdfToPolotnoY(minY, height, pageHeight);
+    return {
+        text,
+        x,
+        y,
+        width,
+        height,
+        fontName: mappedFont.family,
+        fontSize,
+        fontWeight: mappedFont.weight,
+        fontStyle: mappedFont.style,
+        color,
+        rotation,
+        align: 'left', // Default to left alignment
+    };
+}
+/**
+ * Detect text alignment based on position within page
+ */
+export function detectAlignment(block, pageWidth) {
+    const blockCenter = block.x + block.width / 2;
+    const pageCenter = pageWidth / 2;
+    // Check if block is centered (within 10% of page width)
+    const centerThreshold = pageWidth * 0.1;
+    if (Math.abs(blockCenter - pageCenter) < centerThreshold) {
+        return 'center';
+    }
+    // Check if block is right-aligned (within 10% of right edge)
+    const rightEdge = pageWidth;
+    if (Math.abs(block.x + block.width - rightEdge) < centerThreshold) {
+        return 'right';
+    }
+    // Default to left
+    return 'left';
+}
+/**
+ * Apply alignment detection to all blocks
+ */
+export function applyAlignmentDetection(blocks, pageWidth) {
+    return blocks.map(block => ({
+        ...block,
+        align: detectAlignment(block, pageWidth),
+    }));
+}

package/lib/pdf-import/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Options for PDF to JSON conversion
+ */
+export interface PDFImportOptions {
+    pageNumbers?: number[];
+    imageMode?: 'dataURL' | 'upload';
+    imageUploadFn?: (buffer: Buffer, mimeType: string) => Promise<string>;
+    fontMapping?: Record<string, string>;
+    minTextBlockSize?: number;
+    textClusterThreshold?: {
+        vertical?: number;
+        horizontal?: number;
+    };
+    outputUnit?: 'px' | 'cm' | 'in';
+    dpi?: number;
+}
+/**
+ * Raw text item extracted from PDF with position and font metadata
+ */
+export interface PDFTextItem {
+    str: string;
+    transform: number[];
+    width: number;
+    height: number;
+    fontName: string;
+    fontSize?: number;
+    hasEOL?: boolean;
+    dir?: string;
+    color?: number[];
+}
+/**
+ * Clustered text block representing a semantic unit
+ */
+export interface TextBlock {
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fontName: string;
+    fontSize: number;
+    fontWeight: string;
+    fontStyle: string;
+    color: string;
+    rotation: number;
+    align?: string;
+}
+/**
+ * Raw image object extracted from PDF
+ */
+export interface PDFImageObject {
+    buffer: Buffer;
+    mimeType: string;
+    width: number;
+    height: number;
+    transform: number[];
+}
+/**
+ * Polotno image element ready for JSON
+ */
+export interface ImageBlock {
+    src: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+}
+/**
+ * Parsed font information from PDF font name
+ */
+export interface ParsedFont {
+    family: string;
+    weight: string;
+    style: string;
+}
+/**
+ * Coordinate transformation context
+ */
+export interface CoordinateContext {
+    pageHeight: number;
+    pageWidth: number;
+    rotation?: number;
+}
+/**
+ * PDF page metadata
+ */
+export interface PDFPageMetadata {
+    pageNumber: number;
+    width: number;
+    height: number;
+    rotate?: number;
+}
+/**
+ * Result of PDF parsing for one page
+ */
+export interface ParsedPage {
+    metadata: PDFPageMetadata;
+    textItems: PDFTextItem[];
+    images: PDFImageObject[];
+}

package/lib/scripts/compare-json.d.ts

@@ -0,0 +1 @@
+export {};