@polotno/pdf-export 0.1.37 → 0.1.39

package/lib/utils.d.ts

@@ -1,16 +0,0 @@
-import parseColor from 'parse-color';
-export declare const DPI = 75;
-export declare const PIXEL_RATIO = 2;
-export declare function fetchWithTimeout(url: string, timeout?: number, retries?: number): Promise<any>;
-export declare function pxToPt(px: number): number;
-export interface ImageCache {
-    images: Map<string, any>;
-    buffers: Map<string, any>;
-    processedImages: Map<string, string>;
-    imageFiles: Map<string, string>;
-    tempDir: string | null;
-}
-export declare function loadImage(src: string, cache?: ImageCache | null): Promise<any>;
-export declare function srcToBase64(src: string, cache?: ImageCache | null): Promise<string>;
-export declare function srcToBuffer(src: string, cache?: ImageCache | null): Promise<Buffer>;
-export { parseColor };

package/lib/utils.js

@@ -1,124 +0,0 @@
-import parseColor from 'parse-color';
-import fetch from 'node-fetch';
-import Canvas from 'canvas';
-import sharp from 'sharp';
-export const DPI = 75;
-export const PIXEL_RATIO = 2;
-// Fetch with timeout and retry logic
-export async function fetchWithTimeout(url, timeout = 30000, retries = 3) {
-    for (let attempt = 1; attempt <= retries; attempt++) {
-        try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), timeout);
-            const response = await fetch(url, {
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            return response;
-        }
-        catch (error) {
-            const isLastAttempt = attempt === retries;
-            const isAbortError = error.name === 'AbortError';
-            const isTimeoutError = error.code === 'ETIMEDOUT' || error.type === 'request-timeout';
-            if (isLastAttempt) {
-                throw new Error(`Failed to fetch ${url} after ${retries} attempts: ${error.message}`);
-            }
-            // Only retry on network/timeout errors, not on 4xx client errors
-            if (isAbortError || isTimeoutError || error.code?.startsWith('E')) {
-                console.warn(`Fetch attempt ${attempt}/${retries} failed for ${url}, retrying...`);
-                // Exponential backoff: 1s, 2s, 4s, etc.
-                await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt - 1) * 1000));
-                continue;
-            }
-            // Don't retry on other errors (e.g., 404, 403)
-            throw error;
-        }
-    }
-    throw new Error(`Failed to fetch ${url}`);
-}
-export function pxToPt(px) {
-    return (px * DPI) / 100;
-}
-export async function loadImage(src, cache = null) {
-    // Check cache first
-    if (cache && cache.images.has(src)) {
-        return cache.images.get(src);
-    }
-    let buffer;
-    let mime = 'unknown';
-    if (src.startsWith('data:')) {
-        const matches = src.match(/^data:(.+);base64,(.*)$/);
-        if (matches) {
-            mime = matches[1];
-            buffer = Buffer.from(matches[2], 'base64');
-        }
-        else {
-            throw new Error('Invalid data URL');
-        }
-    }
-    else {
-        try {
-            const response = await fetchWithTimeout(src);
-            buffer = Buffer.from(await response.arrayBuffer());
-            const { fileTypeFromBuffer } = await import('file-type');
-            const typeData = await fileTypeFromBuffer(buffer);
-            if (typeData) {
-                mime = typeData.mime;
-            }
-        }
-        catch (error) {
-            console.log(error);
-            throw new Error(`Failed to process image from ${src}: ${error.message}`);
-        }
-    }
-    let imageBuffer = buffer;
-    if (mime !== 'image/png' && mime !== 'image/jpeg') {
-        imageBuffer = await sharp(buffer).toFormat('png').toBuffer();
-        mime = 'image/png';
-    }
-    const image = await Canvas.loadImage(imageBuffer);
-    // Store in cache
-    if (cache) {
-        cache.images.set(src, image);
-    }
-    return image;
-}
-export async function srcToBase64(src, cache = null) {
-    // For base64 caching, we use a different cache key to avoid collision with buffer cache
-    const base64CacheKey = `base64:${src}`;
-    // Check cache first
-    if (cache && cache.buffers.has(base64CacheKey)) {
-        return cache.buffers.get(base64CacheKey);
-    }
-    let base64;
-    if (src.indexOf('base64') >= 0) {
-        base64 = src.split('base64,')[1];
-    }
-    else {
-        const res = await fetchWithTimeout(src);
-        const data = Buffer.from(await res.arrayBuffer());
-        base64 = data.toString('base64');
-    }
-    // Store in cache
-    if (cache) {
-        cache.buffers.set(base64CacheKey, base64);
-    }
-    return base64;
-}
-export async function srcToBuffer(src, cache = null) {
-    // Check if we have a cached Buffer for this source
-    if (cache && cache.buffers.has(src)) {
-        return cache.buffers.get(src);
-    }
-    const base64 = await srcToBase64(src, cache);
-    const buffer = Buffer.from(base64, 'base64');
-    // Cache the actual Buffer object so PDFKit can reuse it
-    if (cache) {
-        cache.buffers.set(src, buffer);
-    }
-    return buffer;
-}
-export { parseColor };