@polotno/pdf-export 0.1.38 → 0.1.40

package/lib/pdf-import/font-mapper.d.ts

@@ -1,17 +0,0 @@
-import type { ParsedFont } from './types.js';
-/**
- * Parse PDF font name to extract family, weight, and style
- * Examples:
- *   "Arial-BoldItalic" → { family: "Arial", weight: "700", style: "italic" }
- *   "Helvetica" → { family: "Arial", weight: "400", style: "normal" }
- *   "TimesNewRomanPS-BoldMT" → { family: "Times New Roman", weight: "700", style: "normal" }
- */
-export declare function parseFontName(pdfFontName: string): ParsedFont;
-/**
- * Apply custom font mapping from user options
- */
-export declare function applyCustomMapping(parsedFont: ParsedFont, customMapping?: Record<string, string>): ParsedFont;
-/**
- * Main function to map PDF font to Polotno-compatible font
- */
-export declare function mapFont(pdfFontName: string, customMapping?: Record<string, string>): ParsedFont;

package/lib/pdf-import/font-mapper.js

@@ -1,142 +0,0 @@
-/**
- * Map of common PDF font names to Google Fonts or web-safe equivalents
- */
-const FONT_MAPPING = {
-    // Serif fonts
-    'Times': 'Times New Roman',
-    'Times-Roman': 'Times New Roman',
-    'Times-Bold': 'Times New Roman',
-    'Times-Italic': 'Times New Roman',
-    'Times-BoldItalic': 'Times New Roman',
-    'TimesNewRoman': 'Times New Roman',
-    'TimesNewRomanPS': 'Times New Roman',
-    'Georgia': 'Georgia',
-    'Garamond': 'Garamond',
-    // Sans-serif fonts
-    'Helvetica': 'Arial',
-    'Helvetica-Bold': 'Arial',
-    'Helvetica-Oblique': 'Arial',
-    'Helvetica-BoldOblique': 'Arial',
-    'Arial': 'Arial',
-    'ArialMT': 'Arial',
-    'Arial-BoldMT': 'Arial',
-    'Verdana': 'Verdana',
-    'Tahoma': 'Tahoma',
-    'Trebuchet': 'Trebuchet MS',
-    'Calibri': 'Calibri',
-    'Roboto': 'Roboto',
-    // Monospace fonts
-    'Courier': 'Courier New',
-    'Courier-Bold': 'Courier New',
-    'Courier-Oblique': 'Courier New',
-    'Courier-BoldOblique': 'Courier New',
-    'CourierNew': 'Courier New',
-    'Consolas': 'Consolas',
-    'Monaco': 'Monaco',
-    // Other common fonts
-    'Symbol': 'Symbol',
-    'ZapfDingbats': 'Zapf Dingbats',
-    'ComicSansMS': 'Comic Sans MS',
-    'Impact': 'Impact',
-};
-/**
- * Font weight keywords and their numeric equivalents
- */
-const WEIGHT_MAPPING = {
-    'Thin': '100',
-    'ExtraLight': '200',
-    'UltraLight': '200',
-    'Light': '300',
-    'Normal': '400',
-    'Regular': '400',
-    'Medium': '500',
-    'SemiBold': '600',
-    'DemiBold': '600',
-    'Bold': '700',
-    'ExtraBold': '800',
-    'UltraBold': '800',
-    'Black': '900',
-    'Heavy': '900',
-};
-/**
- * Parse PDF font name to extract family, weight, and style
- * Examples:
- *   "Arial-BoldItalic" → { family: "Arial", weight: "700", style: "italic" }
- *   "Helvetica" → { family: "Arial", weight: "400", style: "normal" }
- *   "TimesNewRomanPS-BoldMT" → { family: "Times New Roman", weight: "700", style: "normal" }
- */
-export function parseFontName(pdfFontName) {
-    // Remove common suffixes and prefixes
-    let cleanName = pdfFontName
-        .replace(/^SUBSET\+/, '') // Remove subset prefix
-        .replace(/PS$/, '') // Remove PostScript suffix
-        .replace(/MT$/, '') // Remove MT suffix
-        .replace(/,/g, ''); // Remove commas
-    // Check for italic
-    const hasItalic = /Italic|Oblique|It$/i.test(cleanName);
-    const style = hasItalic ? 'italic' : 'normal';
-    // Check for bold and other weights
-    let weight = '400'; // Default to normal weight
-    for (const [keyword, numeric] of Object.entries(WEIGHT_MAPPING)) {
-        if (cleanName.includes(keyword)) {
-            weight = numeric;
-            // Remove the weight keyword from name
-            cleanName = cleanName.replace(keyword, '');
-            break;
-        }
-    }
-    // Remove style indicators from name
-    cleanName = cleanName
-        .replace(/[-_]?(Bold|Italic|Oblique|Regular|Normal|It)/gi, '')
-        .replace(/^[-_]+|[-_]+$/g, '') // Remove leading/trailing separators
-        .trim();
-    // Look up in mapping table
-    let family = FONT_MAPPING[pdfFontName] || FONT_MAPPING[cleanName] || cleanName;
-    // If no mapping found and name looks like it has no spaces, try to split camelCase
-    if (!FONT_MAPPING[pdfFontName] && !family.includes(' ')) {
-        family = splitCamelCase(family);
-    }
-    // Fallback to Roboto if font is empty or looks like a generic placeholder
-    if (!family || family.length < 2 || /^[A-Z]{6}\+/.test(pdfFontName)) {
-        family = 'Roboto';
-    }
-    return {
-        family,
-        weight,
-        style,
-    };
-}
-/**
- * Split camelCase font names into spaced names
- * Example: "TimesNewRoman" → "Times New Roman"
- */
-function splitCamelCase(text) {
-    return text
-        .replace(/([a-z])([A-Z])/g, '$1 $2')
-        .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2')
-        .trim();
-}
-/**
- * Apply custom font mapping from user options
- */
-export function applyCustomMapping(parsedFont, customMapping) {
-    if (!customMapping) {
-        return parsedFont;
-    }
-    // Check if there's a custom mapping for this font family
-    const mappedFamily = customMapping[parsedFont.family];
-    if (mappedFamily) {
-        return {
-            ...parsedFont,
-            family: mappedFamily,
-        };
-    }
-    return parsedFont;
-}
-/**
- * Main function to map PDF font to Polotno-compatible font
- */
-export function mapFont(pdfFontName, customMapping) {
-    const parsed = parseFontName(pdfFontName);
-    return applyCustomMapping(parsed, customMapping);
-}

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

@@ -1,35 +0,0 @@
-import type { PDFImportOptions } from './types.js';
-import type { PolotnoJSON } from '../index.js';
-/**
- * Convert PDF to Polotno JSON
- * @param source - PDF file path or buffer
- * @param options - Conversion options
- * @returns Polotno JSON object
- *
- * @example
- * ```typescript
- * // Basic usage with embedded images
- * const json = await pdfToJSON('document.pdf');
- *
- * // With custom options
- * const json = await pdfToJSON('document.pdf', {
- *   imageMode: 'dataURL',
- *   minTextBlockSize: 10,
- *   fontMapping: {
- *     'Helvetica': 'Roboto',
- *     'Times': 'Merriweather'
- *   }
- * });
- *
- * // With image upload
- * const json = await pdfToJSON('document.pdf', {
- *   imageMode: 'upload',
- *   imageUploadFn: async (buffer, mimeType) => {
- *     // Upload to your storage and return URL
- *     return 'https://your-cdn.com/image.jpg';
- *   }
- * });
- * ```
- */
-export declare function pdfToJSON(source: string | Buffer, options?: PDFImportOptions): Promise<PolotnoJSON>;
-export type { PDFImportOptions } from './types.js';

package/lib/pdf-import/index.js

@@ -1,105 +0,0 @@
-import { parsePDF } from './parser.js';
-import { clusterTextItems, applyAlignmentDetection } from './text-analysis.js';
-import { buildTextElement, processImages } from './element-builder.js';
-import { convertUnits } from './coordinate-transform.js';
-/**
- * Generate a random ID for Polotno pages
- */
-function randomId() {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-    for (let i = 0; i < 10; i++) {
-        result += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return result;
-}
-/**
- * Convert PDF to Polotno JSON
- * @param source - PDF file path or buffer
- * @param options - Conversion options
- * @returns Polotno JSON object
- *
- * @example
- * ```typescript
- * // Basic usage with embedded images
- * const json = await pdfToJSON('document.pdf');
- *
- * // With custom options
- * const json = await pdfToJSON('document.pdf', {
- *   imageMode: 'dataURL',
- *   minTextBlockSize: 10,
- *   fontMapping: {
- *     'Helvetica': 'Roboto',
- *     'Times': 'Merriweather'
- *   }
- * });
- *
- * // With image upload
- * const json = await pdfToJSON('document.pdf', {
- *   imageMode: 'upload',
- *   imageUploadFn: async (buffer, mimeType) => {
- *     // Upload to your storage and return URL
- *     return 'https://your-cdn.com/image.jpg';
- *   }
- * });
- * ```
- */
-export async function pdfToJSON(source, options = {}) {
-    // Set default options
-    const opts = {
-        imageMode: 'dataURL',
-        minTextBlockSize: 8,
-        textClusterThreshold: {
-            vertical: 20,
-            horizontal: 20,
-        },
-        outputUnit: 'px',
-        dpi: 72,
-        ...options,
-    };
-    // Validate options
-    if (opts.imageMode === 'upload' && !opts.imageUploadFn) {
-        throw new Error('imageUploadFn is required when imageMode is "upload"');
-    }
-    // Parse PDF
-    const pages = await parsePDF(source, opts.pageNumbers);
-    if (pages.length === 0) {
-        throw new Error('No pages found in PDF or invalid page numbers specified');
-    }
-    // Get document dimensions from first page
-    const firstPage = pages[0];
-    const documentWidth = convertUnits(firstPage.metadata.width, opts.outputUnit, opts.dpi);
-    const documentHeight = convertUnits(firstPage.metadata.height, opts.outputUnit, opts.dpi);
-    // Build Polotno JSON structure
-    const polotnoJSON = {
-        width: documentWidth,
-        height: documentHeight,
-        fonts: [], // No custom fonts in MVP
-        pages: [],
-    };
-    // Process each page
-    for (const page of pages) {
-        const pageWidth = page.metadata.width;
-        const pageHeight = page.metadata.height;
-        // Cluster text items into text blocks
-        let textBlocks = clusterTextItems(page.textItems, pageHeight, pageWidth, opts);
-        // Apply alignment detection
-        textBlocks = applyAlignmentDetection(textBlocks, pageWidth);
-        // Build text elements
-        const textElements = textBlocks.map(block => buildTextElement(block));
-        // Process images
-        const imageElements = await processImages(page.images, pageHeight, opts);
-        // Combine all elements
-        const children = [
-            ...textElements,
-            ...imageElements,
-        ];
-        // Add page to JSON
-        polotnoJSON.pages.push({
-            background: 'white',
-            children,
-            id: randomId(),
-        });
-    }
-    return polotnoJSON;
-}

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

@@ -1,29 +0,0 @@
-import type { PDFTextItem, PDFImageObject, ParsedPage, PDFPageMetadata } from './types.js';
-/**
- * Load PDF document from file path or buffer
- */
-export declare function loadPDF(source: string | Buffer): Promise<any>;
-/**
- * Get number of pages in PDF document
- */
-export declare function getPageCount(pdfDoc: any): number;
-/**
- * Extract metadata from a single PDF page
- */
-export declare function extractPageMetadata(page: any, pageNumber: number): Promise<PDFPageMetadata>;
-/**
- * Extract text items from a PDF page with position and font metadata
- */
-export declare function extractTextItems(page: any): Promise<PDFTextItem[]>;
-/**
- * Extract images from a PDF page with enhanced async handling
- */
-export declare function extractImages(page: any): Promise<PDFImageObject[]>;
-/**
- * Parse a single PDF page and extract all content
- */
-export declare function parsePage(pdfDoc: any, pageNumber: number): Promise<ParsedPage>;
-/**
- * Parse entire PDF document or specific pages
- */
-export declare function parsePDF(source: string | Buffer, pageNumbers?: number[]): Promise<ParsedPage[]>;

package/lib/pdf-import/parser.js

@@ -1,285 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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[];