@polotno/pdf-export 0.1.18 → 0.1.19

package/lib/image.js

@@ -1,92 +1,137 @@
-const { loadImage, PIXEL_RATIO, srcToBuffer } = require('./utils');
-const Canvas = require('canvas');
-
-async function cropImage(src, element) {
-  const image = await loadImage(src);
-  const canvas = new Canvas.Canvas();
-
-  canvas.width = element.width * PIXEL_RATIO;
-  canvas.height = element.height * PIXEL_RATIO;
-
-  const ctx = canvas.getContext('2d');
-
-  let { cropX, cropY } = element;
-
-  const availableWidth = image.width * element.cropWidth;
-  const availableHeight = image.height * element.cropHeight;
-
-  const aspectRatio = element.width / element.height;
-
-  let cropAbsoluteWidth;
-  let cropAbsoluteHeight;
-
-  const imageRatio = availableWidth / availableHeight;
-  const allowScale = element.type === 'svg';
-
-  if (allowScale) {
-    cropAbsoluteWidth = availableWidth;
-    cropAbsoluteHeight = availableHeight;
-  } else if (aspectRatio >= imageRatio) {
-    cropAbsoluteWidth = availableWidth;
-    cropAbsoluteHeight = availableWidth / aspectRatio;
-  } else {
-    cropAbsoluteWidth = availableHeight * aspectRatio;
-    cropAbsoluteHeight = availableHeight;
-  }
-
-  ctx.drawImage(
-    image,
-    cropX * image.width,
-    cropY * image.height,
-    cropAbsoluteWidth,
-    cropAbsoluteHeight,
-    0,
-    0,
-    canvas.width,
-    canvas.height
-  );
-
-  return canvas.toDataURL('image/png');
+import { loadImage, PIXEL_RATIO, srcToBuffer } from './utils.js';
+import Canvas from 'canvas';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+async function applyFlip(image, element) {
+    const { flipX, flipY } = element;
+    if (!flipX && !flipY) {
+        return image;
+    }
+    if (!image || !image.width || !image.height) {
+        return null;
+    }
+    const canvas = new Canvas.Canvas(image.width, image.height);
+    const ctx = canvas.getContext('2d');
+    let x = flipX ? -canvas.width : 0;
+    let y = flipY ? -canvas.height : 0;
+    ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
+    ctx.drawImage(image, x, y, canvas.width, canvas.height);
+    return canvas;
 }
-
-async function clipImage(src, element) {
-  const image = await loadImage(src);
-  const clipImage = await loadImage(element.clipSrc);
-
-  const canvas = new Canvas.Canvas(element.width, element.height);
-  const ctx = canvas.getContext('2d');
-
-  ctx.drawImage(image, 0, 0, element.width, element.height);
-
-  const clipCanvas = new Canvas.Canvas(element.width, element.height);
-  const clipCtx = clipCanvas.getContext('2d');
-
-  clipCtx.drawImage(clipImage, 0, 0, element.width, element.height);
-
-  ctx.globalCompositeOperation = 'destination-in';
-  ctx.drawImage(clipCanvas, 0, 0);
-
-  ctx.globalCompositeOperation = 'source-over';
-
-  return canvas.toDataURL('image/png');
-}
-
-async function renderImage(doc, element) {
-  let src = await cropImage(element.src, element);
-  if (element.clipSrc) {
-    src = await clipImage(src, element);
-  }
-  if (src) {
-    doc.image(await srcToBuffer(src), 0, 0, {
-      width: element.width,
-      height: element.height,
-      opacity: element.opacity,
+// Helper to create cache key for processed images
+export function getProcessedImageKey(element) {
+    return JSON.stringify({
+        src: element.src,
+        width: element.width,
+        height: element.height,
+        cropX: element.cropX,
+        cropY: element.cropY,
+        cropWidth: element.cropWidth,
+        cropHeight: element.cropHeight,
+        clipSrc: element.clipSrc,
     });
-  }
 }
-
-module.exports = {
-  cropImage,
-  clipImage,
-  renderImage,
-};
+export async function cropImage(src, element, cache = null) {
+    let image = await loadImage(src);
+    // Apply flip transformations first
+    image = await applyFlip(image, element);
+    if (!image) {
+        return null;
+    }
+    const canvas = Canvas.createCanvas(element.width * PIXEL_RATIO, element.height * PIXEL_RATIO);
+    const ctx = canvas.getContext('2d');
+    let { cropX, cropY } = element;
+    const availableWidth = image.width * element.cropWidth;
+    const availableHeight = image.height * element.cropHeight;
+    const aspectRatio = element.width / element.height;
+    let cropAbsoluteWidth;
+    let cropAbsoluteHeight;
+    const imageRatio = availableWidth / availableHeight;
+    const allowScale = element.type === 'svg';
+    if (allowScale) {
+        cropAbsoluteWidth = availableWidth;
+        cropAbsoluteHeight = availableHeight;
+    }
+    else if (aspectRatio >= imageRatio) {
+        cropAbsoluteWidth = availableWidth;
+        cropAbsoluteHeight = availableWidth / aspectRatio;
+    }
+    else {
+        cropAbsoluteWidth = availableHeight * aspectRatio;
+        cropAbsoluteHeight = availableHeight;
+    }
+    ctx.drawImage(image, cropX * image.width, cropY * image.height, cropAbsoluteWidth, cropAbsoluteHeight, 0, 0, canvas.width, canvas.height);
+    return canvas.toDataURL('image/png');
+}
+export async function clipImage(src, element, cache = null) {
+    const image = await loadImage(src, cache);
+    const clipImage = await loadImage(element.clipSrc, cache);
+    const canvas = Canvas.createCanvas(element.width, element.height);
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(image, 0, 0, element.width, element.height);
+    const clipCanvas = Canvas.createCanvas(element.width, element.height);
+    const clipCtx = clipCanvas.getContext('2d');
+    clipCtx.drawImage(clipImage, 0, 0, element.width, element.height);
+    ctx.globalCompositeOperation = 'destination-in';
+    ctx.drawImage(clipCanvas, 0, 0);
+    ctx.globalCompositeOperation = 'source-over';
+    return canvas.toDataURL('image/png');
+}
+export async function renderImage(doc, element, cache = null) {
+    // Check if we have a cached processed version
+    const cacheKey = getProcessedImageKey(element);
+    // Check if we have a cached file path for this image
+    if (cache && cache.imageFiles && cache.imageFiles.has(cacheKey)) {
+        const filePath = cache.imageFiles.get(cacheKey);
+        console.log('✓ Using cached image file:', path.basename(filePath));
+        doc.image(filePath, 0, 0, {
+            width: element.width,
+            height: element.height,
+            opacity: element.opacity,
+        });
+        return;
+    }
+    let src = null;
+    if (cache && cache.processedImages.has(cacheKey)) {
+        src = cache.processedImages.get(cacheKey);
+    }
+    else {
+        src = await cropImage(element.src, element, cache);
+        if (element.clipSrc) {
+            src = await clipImage(src, element, cache);
+        }
+        // Cache the processed result
+        if (cache && src) {
+            cache.processedImages.set(cacheKey, src);
+        }
+    }
+    if (src) {
+        const buffer = await srcToBuffer(src, cache);
+        // Save buffer to a temp file and cache the path
+        let filePath;
+        if (cache) {
+            if (!cache.imageFiles) {
+                cache.imageFiles = new Map();
+            }
+            if (!cache.tempDir) {
+                cache.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdfkit-images-'));
+            }
+            // Create a unique filename based on cache key hash
+            const hash = crypto.createHash('md5').update(cacheKey).digest('hex');
+            filePath = path.join(cache.tempDir, `${hash}.png`);
+            // Write buffer to file
+            fs.writeFileSync(filePath, buffer);
+            cache.imageFiles.set(cacheKey, filePath);
+        }
+        else {
+            filePath = buffer;
+        }
+        doc.image(filePath, 0, 0, {
+            width: element.width,
+            height: element.height,
+            opacity: element.opacity,
+        });
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+import { SpotColorConfig } from './spot-colors.js';
+export interface PolotnoJSON {
+    width: number;
+    height: number;
+    fonts: Array<{
+        fontFamily: string;
+        url: string;
+    }>;
+    pages: Array<{
+        background?: string;
+        children: any[];
+    }>;
+}
+export interface RenderAttrs {
+    pdfx1a?: boolean;
+    validate?: boolean;
+    metadata?: {
+        title?: string;
+        author?: string;
+        application?: string;
+        producer?: string;
+    };
+    spotColors?: SpotColorConfig;
+    textVerticalResizeEnabled?: boolean;
+}
+export declare function jsonToPDF(json: PolotnoJSON, pdfFileName: string, attrs?: RenderAttrs): Promise<void>;

package/lib/index.js

@@ -0,0 +1,130 @@
+import PDFDocument from 'pdfkit';
+import fs from 'fs';
+import path from 'path';
+import { srcToBuffer, parseColor } from './utils.js';
+import { renderImage } from './image.js';
+import { loadFontIfNeeded, renderText } from './text.js';
+import { renderFigure } from './figure.js';
+import { renderGroup } from './group.js';
+import { lineToPDF } from './line.js';
+import { renderSVG } from './svg-render.js';
+import { convertToPDFX1a, validatePDFX1a } from './ghostscript.js';
+import { enableSpotColorSupport } from './spot-colors.js';
+import SVGtoPDF from 'svg-to-pdfkit';
+// Extend PDFDocument prototype with addSVG method
+PDFDocument.prototype.addSVG = function (svg, x, y, options) {
+    return SVGtoPDF(this, svg, x, y, options), this;
+};
+async function renderElement({ doc, element, fonts, attrs, cache, }) {
+    if ((element.visible !== undefined && !element.visible) ||
+        (element.showInExport !== undefined && !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, cache);
+    }
+    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, cache);
+    }
+    else if (element.type === 'svg') {
+        await renderSVG(doc, element, cache);
+    }
+    else if (element.type === 'figure') {
+        renderFigure(doc, element);
+    }
+    doc.restore();
+}
+export async function jsonToPDF(json, pdfFileName, attrs = {}) {
+    const fonts = {};
+    // Create cache for images and processed results
+    const cache = {
+        images: new Map(), // Cache for loaded Canvas images
+        buffers: new Map(), // Cache for fetched buffers
+        processedImages: new Map(), // Cache for cropped/clipped image data URLs
+        imageFiles: new Map(), // Cache for image file paths
+        tempDir: null, // Temporary directory for image files
+    };
+    var doc = new PDFDocument({
+        size: [json.width, json.height],
+        autoFirstPage: false,
+    });
+    // Enable spot color support if configured
+    if (attrs.spotColors) {
+        enableSpotColorSupport(doc, attrs.spotColors);
+    }
+    for (const font of json.fonts) {
+        doc.registerFont(font.fontFamily, await srcToBuffer(font.url, cache));
+        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, cache), 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, cache });
+        }
+    }
+    doc.end();
+    await new Promise((r) => doc.pipe(fs.createWriteStream(pdfFileName)).on('finish', r));
+    // Clean up temporary image files
+    if (cache.tempDir && fs.existsSync(cache.tempDir)) {
+        const files = fs.readdirSync(cache.tempDir);
+        for (const file of files) {
+            fs.unlinkSync(path.join(cache.tempDir, file));
+        }
+        fs.rmdirSync(cache.tempDir);
+    }
+    // Optional PDF/X-1a conversion
+    if (attrs.pdfx1a) {
+        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');
+                }
+            }
+        }
+        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}`);
+        }
+    }
+}

package/lib/line.d.ts

@@ -0,0 +1,10 @@
+export interface LineElement {
+    height: number;
+    width: number;
+    color: string;
+    opacity: number;
+    dash?: number[];
+    startHead?: string;
+    endHead?: string;
+}
+export declare function lineToPDF(doc: any, element: LineElement): void;

package/lib/line.js

@@ -1,82 +1,66 @@
-const { Util } = require('konva');
-const h = (type, props, ...children) => {
-    return { type, props, children: children || [] };
-};
-
-const getLineHead = ({ element, type, doc }) => {
+import { Util } from 'konva/lib/Util.js';
+function rgbToHex({ r, g, b }) {
+    // Ensure each value is within the valid range
+    r = Math.max(0, Math.min(255, r));
+    g = Math.max(0, Math.min(255, g));
+    b = Math.max(0, Math.min(255, b));
+    // Convert each value to a 2-digit hexadecimal string
+    const hexR = r.toString(16).padStart(2, '0');
+    const hexG = g.toString(16).padStart(2, '0');
+    const hexB = b.toString(16).padStart(2, '0');
+    // Return the concatenated hex string
+    return `#${hexR}${hexG}${hexB}`;
+}
+function getLineHead({ element, type, doc }) {
     doc.lineWidth(element.height);
     doc.lineCap('round');
     doc.lineJoin('round');
     doc.opacity(element.opacity);
-
     const rgba = Util.colorToRGBA(element.color);
     const fillColor = rgbToHex(rgba);
-
     if (type === 'arrow') {
-        doc.moveTo(element.height * 3, -element.height * 2)
+        doc
+            .moveTo(element.height * 3, -element.height * 2)
             .lineTo(0, 0)
             .lineTo(element.height * 3, element.height * 2);
-        doc.stroke()
-        return
-
-    } else if (type === 'triangle') {
-        doc.polygon([element.height * 3, -element.height * 2],
-            [0, 0],
-            [element.height * 3, element.height * 2]);
-
-    } else if (type === 'bar') {
-        doc.polygon([0, -element.height * 2],
-            [0, 0],
-            [0, element.height * 2]);
-
-    } else if (type === 'circle') {
+        doc.stroke();
+        return;
+    }
+    else if (type === 'triangle') {
+        doc.polygon([element.height * 3, -element.height * 2], [0, 0], [element.height * 3, element.height * 2]);
+    }
+    else if (type === 'bar') {
+        doc.polygon([0, -element.height * 2], [0, 0], [0, element.height * 2]);
+    }
+    else if (type === 'circle') {
         doc.circle(element.height * 2, 0, element.height * 2);
-
-    } else if (type === 'square') {
-        doc.rect(0, -element.height * 2,
-            element.height * 4,
-            element.height * 4);
-
-    } else {
-        return null;
     }
-
+    else if (type === 'square') {
+        doc.rect(0, -element.height * 2, element.height * 4, element.height * 4);
+    }
+    else {
+        return;
+    }
     doc.fillAndStroke(fillColor, fillColor);
-};
-
-module.exports.lineToPDF = (doc, element) => {
+}
+export function lineToPDF(doc, element) {
     doc.translate(0, element.height / 2);
     doc.lineWidth(element.height);
     doc.moveTo(0, 0);
     doc.lineTo(element.width, 0);
-    
     if (element.dash && element.dash.length > 0) {
-        doc.dash(element.dash.map(dash => dash * element.height));
+        doc.dash(element.dash.map((dash) => dash * element.height));
     }
-    
     const rgba = Util.colorToRGBA(element.color);
     doc.strokeColor(rgbToHex(rgba));
     doc.stroke();
-    
     if (element.dash && element.dash.length > 0) {
         doc.undash();
     }
-    
-    getLineHead({element, doc: doc, type: element.startHead});
-    getLineHead({element, doc: doc.translate(element.width, 0).rotate(180), type: element.endHead});
-}
-
-function rgbToHex({ r, g, b}) {
-    // Ensure each value is within the valid range
-    r = Math.max(0, Math.min(255, r));
-    g = Math.max(0, Math.min(255, g));
-    b = Math.max(0, Math.min(255, b));
-
-    // Convert each value to a 2-digit hexadecimal string
-    const hexR = r.toString(16).padStart(2, '0');
-    const hexG = g.toString(16).padStart(2, '0');
-    const hexB = b.toString(16).padStart(2, '0');
-
-    // Return the concatenated hex string
-    return `#${hexR}${hexG}${hexB}`;
+    getLineHead({ element, doc: doc, type: element.startHead });
+    getLineHead({
+        element,
+        doc: doc.translate(element.width, 0).rotate(180),
+        type: element.endHead,
+    });
 }

package/lib/spot-colors.d.ts

@@ -0,0 +1,38 @@
+export interface SpotColorDefinition {
+    name?: string;
+    cmyk?: number[];
+}
+export interface SpotColorConfig {
+    [color: string]: SpotColorDefinition;
+}
+/**
+ * Normalize color to a consistent format for matching using Konva's color parser
+ * This ensures consistency with how Polotno/Konva handles colors
+ * @param color - Color in any format (string or [r, g, b, a] array)
+ * @returns Normalized color string in rgba format
+ */
+export declare function normalizeColor(color: string | number[]): string | null;
+/**
+ * Get spot color definition for a given color
+ * @param color - Color to check
+ * @param spotColorConfig - Spot color configuration
+ * @returns Spot color definition or null
+ */
+export declare function getSpotColorForColor(color: string, spotColorConfig: SpotColorConfig): SpotColorDefinition | null;
+/**
+ * Register a spot color using PDFKit's built-in addSpotColor method
+ * @param doc - PDFKit document
+ * @param spotName - Name of the spot color
+ * @param spotColorDef - Spot color definition with CMYK fallback
+ * @returns Reference to the registered spot color
+ */
+export declare function registerSpotColor(doc: any, spotName: string, spotColorDef: SpotColorDefinition): {
+    name: string;
+    cmyk: number[];
+};
+/**
+ * Enable spot color support on a PDFDocument by intercepting color methods
+ * @param doc - PDFKit document
+ * @param spotColorConfig - Spot color configuration mapping
+ */
+export declare function enableSpotColorSupport(doc: any, spotColorConfig: SpotColorConfig): void;