@polotno/pdf-export 0.1.18 → 0.1.19

package/lib/text.d.ts

@@ -0,0 +1,28 @@
+export interface TextElement {
+    fontFamily: string;
+    fontWeight?: string;
+    fontSize: number;
+    fill: string;
+    opacity: number;
+    strokeWidth: number;
+    stroke?: string;
+    align: string;
+    textDecoration: string;
+    letterSpacing?: number;
+    lineHeight: number;
+    text: string;
+    width: number;
+    height: number;
+    verticalAlign?: string;
+    backgroundEnabled?: boolean;
+    backgroundPadding?: number;
+    backgroundCornerRadius?: number;
+    backgroundColor?: string;
+}
+export interface RenderAttrs {
+    pdfx1a?: boolean;
+    textVerticalResizeEnabled?: boolean;
+}
+export declare function getGoogleFontPath(fontFamily: string, fontWeight?: string): Promise<string>;
+export declare function loadFontIfNeeded(doc: any, element: TextElement, fonts: Record<string, boolean>): Promise<string>;
+export declare function renderText(doc: any, element: TextElement, attrs?: RenderAttrs): void;

package/lib/text.js

@@ -1,184 +1,157 @@
-const { parseColor, srcToBuffer } = require('./utils');
-const getUrls = require('get-urls').default;
-const fetch = require('node-fetch').default;
-
-async function getGoogleFontPath(fontFamily, fontWeight = 'normal') {
-  const weight = fontWeight === 'bold' ? '700' : '400';
-  const url = `https://fonts.googleapis.com/css?family=${fontFamily}:${weight}`;
-  const req = await fetch(url);
-  if (!req.ok) {
-    if (weight !== '400') {
-      return getGoogleFontPath(fontFamily, 'normal');
+import { parseColor, srcToBuffer } from './utils.js';
+import getUrls from 'get-urls';
+import fetch from 'node-fetch';
+export async function getGoogleFontPath(fontFamily, fontWeight = 'normal') {
+    const weight = fontWeight === 'bold' ? '700' : '400';
+    const url = `https://fonts.googleapis.com/css?family=${fontFamily}:${weight}`;
+    const req = await fetch(url);
+    if (!req.ok) {
+        if (weight !== '400') {
+            return getGoogleFontPath(fontFamily, 'normal');
+        }
+        throw new Error(`Failed to fetch Google font: ${fontFamily}`);
     }
-    throw new Error(`Failed to fetch Google font: ${fontFamily}`);
-  }
-  const text = await req.text();
-  const urls = getUrls(text);
-  return urls.values().next().value;
+    const text = await req.text();
+    const urls = getUrls(text);
+    return urls.values().next().value;
 }
-
-async function loadFontIfNeeded(doc, element, fonts) {
-  // check if universal font is already defined
-  if (fonts[element.fontFamily]) {
-    doc.font(element.fontFamily);
-    return element.fontFamily;
-  }
-  const fontKey = `${element.fontFamily}-${element.fontWeight || 'normal'}`;
-  if (!fonts[fontKey]) {
-    const src = await getGoogleFontPath(element.fontFamily, element.fontWeight);
-    doc.registerFont(fontKey, await srcToBuffer(src));
-    fonts[fontKey] = true;
-  }
-  doc.font(fontKey);
-  return fontKey;
+export async function loadFontIfNeeded(doc, element, fonts) {
+    // check if universal font is already defined
+    if (fonts[element.fontFamily]) {
+        doc.font(element.fontFamily);
+        return element.fontFamily;
+    }
+    const fontKey = `${element.fontFamily}-${element.fontWeight || 'normal'}`;
+    if (!fonts[fontKey]) {
+        const src = await getGoogleFontPath(element.fontFamily, element.fontWeight);
+        doc.registerFont(fontKey, await srcToBuffer(src));
+        fonts[fontKey] = true;
+    }
+    doc.font(fontKey);
+    return fontKey;
 }
-
-function renderText(doc, element, attrs = {}) {
-  doc.fontSize(element.fontSize);
-  doc.fillColor(parseColor(element.fill).hex, element.opacity);
-
-  // Handle stroked text differently for PDF/X-1a compatibility
-  const hasStroke = element.strokeWidth > 0;
-  const isPDFX1a = attrs.pdfx1a;
-
-  if (hasStroke && !isPDFX1a) {
-    // Standard PDF: use PDFKit's built-in stroke support
-    doc.lineWidth(element.strokeWidth / 2);
-    doc.strokeColor(parseColor(element.stroke).hex);
-  }
-
-  const props = {
-    align: element.align,
-    fill: element.fill,
-    baseline: 'top',
-    lineGap: 1,
-    width: element.width,
-    underline: element.textDecoration.indexOf('underline') >= 0,
-    characterSpacing: element.letterSpacing
-      ? element.letterSpacing * element.fontSize
-      : 0,
-    lineBreak: false,
-    stroke: hasStroke && !isPDFX1a, // Only use stroke for non-PDF/X-1a
-  };
-
-  const currentLineHeight = doc.heightOfString('A', props);
-  const lineHeight = element.lineHeight * element.fontSize;
-
-  const fontBoundingBoxAscent = (doc._font.ascender / 1000) * element.fontSize;
-  const fontBoundingBoxDescent =
-    (doc._font.descender / 1000) * element.fontSize;
-  const translateY = (fontBoundingBoxAscent - fontBoundingBoxDescent) / 2;
-
-  const diff = currentLineHeight - lineHeight;
-  props.lineGap = props.lineGap - diff;
-
-  let yOffset = 0;
-  if ((attrs.textVerticalResizeEnabled || true) && element.verticalAlign) {
-    const textHeight = doc.heightOfString(element.text, props);
-    if (element.verticalAlign === 'middle') {
-      yOffset = (element.height - textHeight) / 2;
-    } else if (element.verticalAlign === 'bottom') {
-      yOffset = element.height - textHeight;
+export function renderText(doc, element, attrs = {}) {
+    doc.fontSize(element.fontSize);
+    doc.fillColor(parseColor(element.fill).hex, element.opacity);
+    // Handle stroked text differently for PDF/X-1a compatibility
+    const hasStroke = element.strokeWidth > 0;
+    const isPDFX1a = attrs.pdfx1a;
+    if (hasStroke && !isPDFX1a) {
+        // Standard PDF: use PDFKit's built-in stroke support
+        doc.lineWidth(element.strokeWidth / 2);
+        doc.strokeColor(parseColor(element.stroke).hex);
     }
-  }
-
-  for (var size = element.fontSize; size > 0; size -= 1) {
-    doc.fontSize(size);
-    const height = doc.heightOfString(element.text, {
-      ...props,
-    });
-    if (height <= element.height) {
-      break;
+    const props = {
+        align: element.align,
+        fill: element.fill,
+        baseline: 'top',
+        lineGap: 1,
+        width: element.width,
+        underline: element.textDecoration.indexOf('underline') >= 0,
+        characterSpacing: element.letterSpacing
+            ? element.letterSpacing * element.fontSize
+            : 0,
+        lineBreak: false,
+        stroke: hasStroke && !isPDFX1a, // Only use stroke for non-PDF/X-1a
+    };
+    const currentLineHeight = doc.heightOfString('A', props);
+    const lineHeight = element.lineHeight * element.fontSize;
+    const fontBoundingBoxAscent = (doc._font.ascender / 1000) * element.fontSize;
+    const fontBoundingBoxDescent = (doc._font.descender / 1000) * element.fontSize;
+    const translateY = (fontBoundingBoxAscent - fontBoundingBoxDescent) / 2;
+    const diff = currentLineHeight - lineHeight;
+    props.lineGap = props.lineGap - diff;
+    let yOffset = 0;
+    if ((attrs.textVerticalResizeEnabled || true) && element.verticalAlign) {
+        const textHeight = doc.heightOfString(element.text, props);
+        if (element.verticalAlign === 'middle') {
+            yOffset = (element.height - textHeight) / 2;
+        }
+        else if (element.verticalAlign === 'bottom') {
+            yOffset = element.height - textHeight;
+        }
     }
-  }
-
-  const halfLineHeight = ((element.lineHeight - 1) / 2) * element.fontSize;
-
-  if (element.backgroundEnabled) {
-    const backPadding =
-      element.backgroundPadding * (element.fontSize * element.lineHeight);
-    const cornerRadius =
-      element.backgroundCornerRadius *
-      (element.fontSize * element.lineHeight * 0.5);
-
-    const textWidth = doc.widthOfString(element.text, {
-      ...props,
-      width: element.width,
-    });
-    const textHeight = doc.heightOfString(element.text, {
-      ...props,
-      width: element.width,
-    });
-
-    let bgX = -backPadding / 2;
-    let bgY = -backPadding / 2;
-    let bgWidth = textWidth + backPadding;
-    let bgHeight = textHeight + backPadding;
-
-    if (element.align === 'center') {
-      bgX = (element.width - textWidth) / 2 - backPadding / 2;
-    } else if (element.align === 'right') {
-      bgX = element.width - textWidth - backPadding / 2;
+    for (var size = element.fontSize; size > 0; size -= 1) {
+        doc.fontSize(size);
+        const height = doc.heightOfString(element.text, {
+            ...props,
+        });
+        if (height <= element.height) {
+            break;
+        }
     }
-
-    if (element.verticalAlign === 'middle') {
-      bgY = (element.height - textHeight) / 2 - backPadding / 2;
-    } else if (element.verticalAlign === 'bottom') {
-      bgY = element.height - textHeight - backPadding / 2;
+    const halfLineHeight = ((element.lineHeight - 1) / 2) * element.fontSize;
+    if (element.backgroundEnabled) {
+        const backPadding = element.backgroundPadding * (element.fontSize * element.lineHeight);
+        const cornerRadius = element.backgroundCornerRadius *
+            (element.fontSize * element.lineHeight * 0.5);
+        const textWidth = doc.widthOfString(element.text, {
+            ...props,
+            width: element.width,
+        });
+        const textHeight = doc.heightOfString(element.text, {
+            ...props,
+            width: element.width,
+        });
+        let bgX = -backPadding / 2;
+        let bgY = -backPadding / 2;
+        let bgWidth = textWidth + backPadding;
+        let bgHeight = textHeight + backPadding;
+        if (element.align === 'center') {
+            bgX = (element.width - textWidth) / 2 - backPadding / 2;
+        }
+        else if (element.align === 'right') {
+            bgX = element.width - textWidth - backPadding / 2;
+        }
+        if (element.verticalAlign === 'middle') {
+            bgY = (element.height - textHeight) / 2 - backPadding / 2;
+        }
+        else if (element.verticalAlign === 'bottom') {
+            bgY = element.height - textHeight - backPadding / 2;
+        }
+        doc.roundedRect(bgX, bgY, bgWidth, bgHeight, cornerRadius);
+        doc.fillColor(parseColor(element.backgroundColor).hex);
+        doc.fill();
+        doc.fillColor(parseColor(element.fill).hex, element.opacity);
     }
-
-    doc.roundedRect(bgX, bgY, bgWidth, bgHeight, cornerRadius);
-    doc.fillColor(parseColor(element.backgroundColor).hex);
-    doc.fill();
-    doc.fillColor(parseColor(element.fill).hex, element.opacity);
-  }
-
-  // Render text with PDF/X-1a compatible stroke simulation
-  if (hasStroke && isPDFX1a) {
-    // For PDF/X-1a: simulate stroke by drawing text multiple times
-    const strokeColor = parseColor(element.stroke).hex;
-    const strokeWidth = element.strokeWidth;
-
-    // Draw stroke by rendering text multiple times with offsets
-    const offsets = [];
-    for (let angle = 0; angle < 360; angle += 45) {
-      const radian = (angle * Math.PI) / 180;
-      offsets.push({
-        x: Math.cos(radian) * strokeWidth,
-        y: Math.sin(radian) * strokeWidth,
-      });
+    // Render text with PDF/X-1a compatible stroke simulation
+    if (hasStroke && isPDFX1a) {
+        // For PDF/X-1a: simulate stroke by drawing text multiple times
+        const strokeColor = parseColor(element.stroke).hex;
+        const strokeWidth = element.strokeWidth;
+        // Draw stroke by rendering text multiple times with offsets
+        const offsets = [];
+        for (let angle = 0; angle < 360; angle += 45) {
+            const radian = (angle * Math.PI) / 180;
+            offsets.push({
+                x: Math.cos(radian) * strokeWidth,
+                y: Math.sin(radian) * strokeWidth,
+            });
+        }
+        // Draw stroke layers
+        doc.save();
+        doc.fillColor(strokeColor, element.opacity);
+        for (const offset of offsets) {
+            doc.text(element.text, offset.x, yOffset + halfLineHeight + offset.y, {
+                ...props,
+                stroke: false, // Force no stroke for compatibility
+                height: element.height + element.fontSize,
+            });
+        }
+        doc.restore();
+        // Draw fill text on top
+        doc.fillColor(parseColor(element.fill).hex, element.opacity);
+        doc.text(element.text, 0, yOffset + halfLineHeight, {
+            ...props,
+            stroke: false, // Force no stroke for compatibility
+            height: element.height + element.fontSize,
+        });
     }
-
-    // Draw stroke layers
-    doc.save();
-    doc.fillColor(strokeColor, element.opacity);
-    for (const offset of offsets) {
-      doc.text(element.text, offset.x, yOffset + halfLineHeight + offset.y, {
-        ...props,
-        stroke: false, // Force no stroke for compatibility
-        height: element.height + element.fontSize,
-      });
+    else {
+        // Standard rendering
+        doc.text(element.text, 0, yOffset + halfLineHeight, {
+            ...props,
+            height: element.height + element.fontSize,
+        });
     }
-    doc.restore();
-
-    // Draw fill text on top
-    doc.fillColor(parseColor(element.fill).hex, element.opacity);
-    doc.text(element.text, 0, yOffset + halfLineHeight, {
-      ...props,
-      stroke: false, // Force no stroke for compatibility
-      height: element.height + element.fontSize,
-    });
-  } else {
-    // Standard rendering
-    doc.text(element.text, 0, yOffset + halfLineHeight, {
-      ...props,
-      height: element.height + element.fontSize,
-    });
-  }
 }
-
-module.exports = {
-  getGoogleFontPath,
-  renderText,
-  loadFontIfNeeded,
-};

package/lib/utils.d.ts

@@ -0,0 +1,15 @@
+import parseColor from 'parse-color';
+export declare const DPI = 75;
+export declare const PIXEL_RATIO = 2;
+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,94 @@
-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;
+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);
     }
-  } 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}`);
+    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');
+        }
     }
-  }
-
-  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);
+    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 { fileTypeFromBuffer } = await import('file-type');
+            const typeData = await fileTypeFromBuffer(buffer);
+            if (typeData) {
+                mime = typeData.mime;
+            }
+        }
+        catch (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;
 }
-
-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 fetch(src);
+        if (!res.ok) {
+            throw new Error(`Failed to fetch: ${src} (Status: ${res.status})`);
+        }
+        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,46 @@
 {
   "name": "@polotno/pdf-export",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "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"
   },
   "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",
+    "pdfkit": "^0.17.2",
     "pdf2pic": "^3.2.0",
-    "pdfkit": "^0.17.1",
-    "polotno": "^2.24.1",
-    "sharp": "^0.34.2",
+    "polotno": "^2.29.5",
+    "sharp": "^0.34.4",
     "svg-to-pdfkit": "^0.1.8",
     "xmldom": "^0.6.0"
   },
   "devDependencies": {
-    "@types/pdfkit": "^0.14.0",
+    "@types/node": "^24.9.1",
+    "@types/pdfkit": "^0.17.3",
     "jest-image-snapshot": "^6.5.1",
     "pdf-img-convert": "^2.0.0",
-    "vitest": "^3.2.4"
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.3"
   }
 }