@polotno/pdf-export 0.1.18 → 0.1.20

package/lib/utils.d.ts

@@ -0,0 +1,16 @@
+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,78 +1,124 @@
-const parseColor = require('parse-color');
-const fetch = require('node-fetch').default;
-const fileTypePromise = import('file-type');
-const sharp = require('sharp');
-const Canvas = require('canvas');
-
-const DPI = 75;
-const PIXEL_RATIO = 2;
-
-function pxToPt(px) {
-  return (px * DPI) / 100;
+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;
 }
-
-async function loadImage(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');
+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 fetch(src);
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch image: ${src} (Status: ${response.status})`
-        );
-      }
-      buffer = await response.buffer();
-      const fileType = await fileTypePromise;
-      const typeData = await fileType.fileTypeFromBuffer(buffer);
-      if (typeData) {
-        ({ mime } = typeData);
-      }
-    } catch (error) {
-      throw new Error(`Failed to process image from ${src}: ${error.message}`);
+    else {
+        try {
+            const response = await fetchWithTimeout(src);
+            buffer = await response.buffer();
+            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';
-  }
-
-  return await Canvas.loadImage(imageBuffer);
+    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;
 }
-
-async function srcToBase64(src) {
-  if (src.indexOf('base64') >= 0) {
-    return src.split('base64,')[1];
-  }
-  const res = await fetch(src);
-  if (!res.ok) {
-    throw new Error(`Failed to fetch: ${src} (Status: ${res.status})`);
-  }
-  const data = await res.buffer();
-  return data.toString('base64');
+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 = await res.buffer();
+        base64 = data.toString('base64');
+    }
+    // Store in cache
+    if (cache) {
+        cache.buffers.set(base64CacheKey, base64);
+    }
+    return base64;
 }
-
-async function srcToBuffer(src) {
-  return Buffer.from(await srcToBase64(src), '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;
 }
-
-module.exports = {
-  pxToPt,
-  loadImage,
-  srcToBase64,
-  srcToBuffer,
-  DPI,
-  PIXEL_RATIO,
-  parseColor,
-};
+export { parseColor };

package/package.json

@@ -1,38 +1,58 @@
 {
   "name": "@polotno/pdf-export",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Convert Polotno JSON into vector PDF",
-  "main": "index.js",
+  "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  },
   "scripts": {
+    "build": "tsc",
     "test": "vitest",
-    "test:update-snapshots": "vitest -u"
+    "test:update-snapshots": "vitest -u",
+    "dev": "vite client",
+    "compare": "node lib/compare-render.js",
+    "postinstall": "patch-package"
   },
   "author": "Anton Lavrenov",
   "files": [
-    "index.js",
-    "README.md",
-    "lib"
+    "lib",
+    "README.md"
   ],
   "dependencies": {
-    "@canvas/image": "^2.0.0",
-    "@file-type/xml": "^0.4.3",
-    "canvas": "^3.1.1",
+    "canvas": "^3.2.0",
     "file-type": "^21.0.0",
     "get-urls": "^12.1.0",
-    "konva": "^9.3.20",
+    "konva": "^10.0.8",
     "node-fetch": "^3.3.2",
     "parse-color": "^1.0.0",
     "pdf2pic": "^3.2.0",
-    "pdfkit": "^0.17.1",
-    "polotno": "^2.24.1",
-    "sharp": "^0.34.2",
+    "pdfkit": "^0.17.2",
+    "polotno": "^2.29.5",
+    "sharp": "^0.34.4",
+    "string-strip-html": "^13.5.0",
     "svg-to-pdfkit": "^0.1.8",
     "xmldom": "^0.6.0"
   },
   "devDependencies": {
-    "@types/pdfkit": "^0.14.0",
+    "@types/node": "^24.10.0",
+    "@types/parse-color": "^1.0.3",
+    "@types/pdfkit": "^0.17.3",
     "jest-image-snapshot": "^6.5.1",
+    "patch-package": "^8.0.1",
     "pdf-img-convert": "^2.0.0",
-    "vitest": "^3.2.4"
+    "pdf-to-png-converter": "^3.10.0",
+    "pixelmatch": "^7.1.0",
+    "pngjs": "^7.0.0",
+    "polotno-node": "^2.12.30",
+    "typescript": "~5.9.3",
+    "@vitejs/plugin-react": "^5.1.0",
+    "vite": "^7.2.0",
+    "vitest": "^4.0.7"
   }
 }

package/index.js

@@ -1,130 +0,0 @@
-const PDFDocument = require('pdfkit');
-const fs = require('fs');
-const path = require('path');
-const { srcToBuffer, parseColor } = require('./lib/utils');
-const { renderImage } = require('./lib/image');
-const { loadFontIfNeeded, renderText } = require('./lib/text');
-const { renderFigure } = require('./lib/figure');
-const { renderGroup } = require('./lib/group');
-const { lineToPDF } = require('./lib/line');
-const { renderSVG } = require('./lib/svg-render');
-const { convertToPDFX1a, validatePDFX1a } = require('./lib/ghostscript');
-const SVGtoPDF = require('svg-to-pdfkit');
-
-PDFDocument.prototype.addSVG = function (svg, x, y, options) {
-  return SVGtoPDF(this, svg, x, y, options), this;
-};
-
-async function renderElement({ doc, element, fonts, attrs }) {
-  if (!element.visible || !element.showInExport) {
-    return;
-  }
-
-  doc.save();
-  if (element.type !== 'group') {
-    doc.translate(element.x, element.y);
-    doc.rotate(element.rotation);
-  }
-
-  if (element.opacity !== undefined) {
-    doc.opacity(element.opacity);
-  }
-
-  if (element.type === 'group') {
-    await renderGroup(doc, element, renderElement, fonts, attrs);
-  } else if (element.type === 'text') {
-    await loadFontIfNeeded(doc, element, fonts);
-    renderText(doc, element, attrs);
-  } else if (element.type === 'line') {
-    lineToPDF(doc, element);
-  } else if (element.type === 'image') {
-    await renderImage(doc, element);
-  } else if (element.type === 'svg') {
-    await renderSVG(doc, element);
-  } else if (element.type === 'figure') {
-    renderFigure(doc, element);
-  }
-
-  doc.restore();
-}
-
-module.exports.jsonToPDF = async function jsonToPDF(
-  json,
-  pdfFileName,
-  attrs = {}
-) {
-  const fonts = {};
-
-  var doc = new PDFDocument({
-    size: [json.width, json.height],
-    autoFirstPage: false,
-  });
-
-  for (const font of json.fonts) {
-    doc.registerFont(font.fontFamily, await srcToBuffer(font.url));
-    fonts[font.fontFamily] = true;
-  }
-
-  for (const page of json.pages) {
-    doc.addPage();
-    if (page.background) {
-      const isURL =
-        page.background.indexOf('http') >= 0 ||
-        page.background.indexOf('.png') >= 0 ||
-        page.background.indexOf('.jpg') >= 0;
-
-      if (isURL) {
-        doc.image(await srcToBuffer(page.background), 0, 0);
-      } else {
-        doc.rect(0, 0, json.width, json.height);
-        doc.fill(parseColor(page.background).hex);
-      }
-    }
-    for (const element of page.children) {
-      await renderElement({ doc, element, fonts, attrs });
-    }
-  }
-
-  doc.end();
-
-  await new Promise((r) =>
-    doc.pipe(fs.createWriteStream(pdfFileName)).on('finish', r)
-  );
-
-  // Optional PDF/X-1a conversion
-  if (attrs.pdfx1a) {
-    console.log('Converting to PDF/X-1a...');
-    const tempFileName = pdfFileName.replace('.pdf', '-temp.pdf');
-
-    // Rename current file to temp
-    fs.renameSync(pdfFileName, tempFileName);
-
-    try {
-      // Convert temp file to PDF/X-1a
-      await convertToPDFX1a(tempFileName, pdfFileName, {
-        metadata: attrs.metadata || {},
-      });
-
-      // Clean up temp file
-      fs.unlinkSync(tempFileName);
-
-      // Optional validation
-      if (attrs.validate) {
-        const isValid = await validatePDFX1a(pdfFileName);
-        if (!isValid) {
-          console.warn(
-            'Warning: Generated PDF may not be fully PDF/X-1a compliant'
-          );
-        }
-      }
-
-      console.log('PDF/X-1a conversion completed');
-    } catch (error) {
-      // Restore original file if conversion fails
-      if (fs.existsSync(tempFileName)) {
-        fs.renameSync(tempFileName, pdfFileName);
-      }
-      throw new Error(`PDF/X-1a conversion failed: ${error.message}`);
-    }
-  }
-};