@polotno/pdf-export 0.1.18 → 0.1.19

package/README.md

@@ -49,9 +49,61 @@ await jsonToPDF(json, './book-cover.pdf', {
 });
 ```
 
+## Spot Color / Foil Support
+
+For professional printing with special inks like metallic foils, Pantone colors, or other spot colors:
+
+```js
+await jsonToPDF(json, './output.pdf', {
+  pdfx1a: true,
+  spotColors: {
+    // Map any color to a spot color
+    'rgba(255,215,0,1)': {
+      name: 'Gold Foil',
+      type: 'pantone',
+      pantoneCode: 'Pantone 871 C', // Optional reference
+      cmyk: [0, 0.15, 0.5, 0], // CMYK fallback (0-1 range)
+    },
+    '#C0C0C0': {
+      name: 'Silver Foil',
+      type: 'custom',
+      cmyk: [0, 0, 0, 0.25],
+    },
+  },
+});
+```
+
+**How it works:**
+
+- Any element with a matching fill or stroke color is automatically converted to use the spot color
+- Colors are matched flexibly - `'#FFD700'`, `'#ffd700'`, and `'rgba(255,215,0,1)'` all match
+- Spot colors are preserved as separation color spaces in PDF/X-1a output
+- CMYK fallback values are used when viewers don't support spot colors
+- Works with all element types: text, shapes, lines, and SVG elements
+
+**Color Format Support:**
+
+- Hex: `'#FFD700'` or `'#ffd700'`
+- RGB: `'rgb(255,215,0)'`
+- RGBA: `'rgba(255,215,0,1)'`
+
+**Tips:**
+
+- Use professional color references (like Pantone codes) to communicate exact requirements to printers
+- Provide accurate CMYK fallback values for preview and proof prints
+- Spot colors work best with PDF/X-1a export enabled
+- You can verify spot colors in Adobe Acrobat by checking Output Preview > Separations
+
 ## Requirements
 
 - **GhostScript** must be installed for PDF/X-1a conversion
 - macOS: `brew install ghostscript`
 - Ubuntu: `apt-get install ghostscript`
 - Windows: Download from [ghostscript.com](https://www.ghostscript.com/)
+
+## Development
+
+```bash
+npm run build  # Build the library
+npm test       # Run tests
+```

package/lib/figure.d.ts

@@ -0,0 +1,10 @@
+export interface FigureElement {
+    fill?: string;
+    stroke?: string;
+    strokeWidth: number;
+    opacity: number;
+    width: number;
+    height: number;
+    [key: string]: any;
+}
+export declare function renderFigure(doc: any, element: FigureElement): void;

package/lib/figure.js

@@ -1,49 +1,54 @@
-const { parseColor } = require('./utils');
-const { figureToSvg } = require('polotno/utils/figure-to-svg');
-
-function renderFigure(doc, element) {
-  const svgStr = figureToSvg({
-    ...element,
-    fill: (() => {
-      if (!element.fill) return 'transparent';
-      const color = parseColor(element.fill);
-      if (!color || !color.rgba) return element.fill;
-      const oldOpacity = color.rgba[3] || 1;
-      const rgba = color.rgba
-        .slice(0, 3)
-        .concat(oldOpacity * element.opacity)
-        .join(',');
-      return `rgba(${rgba})`;
-    })(),
-    stroke: (() => {
-      if (!element.stroke || element.strokeWidth === 0) return 'none';
-      const color = parseColor(element.stroke);
-      if (!color || !color.rgba) return element.stroke;
-      const oldOpacity = color.rgba[3] || 1;
-      const rgba = color.rgba
-        .slice(0, 3)
-        .concat(oldOpacity * element.opacity)
-        .join(',');
-      return `rgba(${rgba})`;
-    })(),
-  });
-
-  doc.addSVG(svgStr, 0, 0, {
-    preserveAspectRatio: 'xMinYMin meet',
-    width: element.width,
-    height: element.height,
-    opacity: element.opacity,
-    colorCallback: (colors) => {
-      console.log('colors', colors);
-      if (!colors) {
-        return colors;
-      }
-      const [color, opacity] = colors;
-      return [color, opacity * element.opacity];
-    },
-  });
+import { parseColor } from './utils.js';
+import { figureToSvg } from 'polotno/utils/figure-to-svg';
+export function renderFigure(doc, element) {
+    const svgStr = figureToSvg({
+        ...element,
+        fill: (() => {
+            if (!element.fill)
+                return 'transparent';
+            const color = parseColor(element.fill);
+            if (!color || !color.rgba)
+                return element.fill;
+            let oldOpacity = color.rgba[3] || 1;
+            // Normalize opacity to 0-1 range if it's greater than 1
+            if (oldOpacity > 1) {
+                oldOpacity = oldOpacity / 100;
+            }
+            const rgba = color.rgba
+                .slice(0, 3)
+                .concat(oldOpacity * element.opacity)
+                .join(',');
+            return `rgba(${rgba})`;
+        })(),
+        stroke: (() => {
+            if (!element.stroke || element.strokeWidth === 0)
+                return 'none';
+            const color = parseColor(element.stroke);
+            if (!color || !color.rgba)
+                return element.stroke;
+            let oldOpacity = color.rgba[3] || 1;
+            // Normalize opacity to 0-1 range if it's greater than 1
+            if (oldOpacity > 1) {
+                oldOpacity = oldOpacity / 100;
+            }
+            const rgba = color.rgba
+                .slice(0, 3)
+                .concat(oldOpacity * element.opacity)
+                .join(',');
+            return `rgba(${rgba})`;
+        })(),
+    });
+    doc.addSVG(svgStr, 0, 0, {
+        preserveAspectRatio: 'xMinYMin meet',
+        width: element.width,
+        height: element.height,
+        opacity: element.opacity,
+        colorCallback: (colors) => {
+            if (!colors) {
+                return colors;
+            }
+            const [color, opacity] = colors;
+            return [color, opacity * element.opacity];
+        },
+    });
 }
-
-module.exports = {
-  renderFigure,
-};

package/lib/ghostscript.d.ts

@@ -0,0 +1,21 @@
+export interface PDFXMetadata {
+    title?: string;
+    author?: string;
+    application?: string;
+    producer?: string;
+}
+export interface ConversionOptions {
+    metadata?: PDFXMetadata;
+}
+/**
+ * Convert PDF to PDF/X-1a using GhostScript
+ * @param inputPath - Path to input PDF
+ * @param outputPath - Path to output PDF/X-1a file
+ * @param options - Conversion options
+ */
+export declare function convertToPDFX1a(inputPath: string, outputPath: string, options?: ConversionOptions): Promise<void>;
+/**
+ * Validate if PDF is PDF/X-1a compliant
+ * @param pdfPath - Path to PDF file
+ */
+export declare function validatePDFX1a(pdfPath: string): Promise<boolean>;

package/lib/ghostscript.js

@@ -1,100 +1,85 @@
-const { spawn } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
 /**
  * Convert PDF to PDF/X-1a using GhostScript
- * @param {string} inputPath - Path to input PDF
- * @param {string} outputPath - Path to output PDF/X-1a file
- * @param {Object} options - Conversion options
- * @returns {Promise<void>}
+ * @param inputPath - Path to input PDF
+ * @param outputPath - Path to output PDF/X-1a file
+ * @param options - Conversion options
  */
-async function convertToPDFX1a(inputPath, outputPath, options = {}) {
-  return new Promise((resolve, reject) => {
-    // PDF/X-1a conversion parameters with stroke preservation
-    const args = [
-      '-dNOPAUSE',
-      '-dBATCH',
-      '-dSAFER',
-      '-sDEVICE=pdfwrite',
-      '-dCompatibilityLevel=1.3',
-      '-dPDFX=true',
-      '-dColorConversionStrategy=/CMYK',
-      '-dProcessColorModel=/DeviceCMYK',
-      '-dUseCIEColor=true',
-      '-sColorConversionStrategy=CMYK',
-      '-sProcessColorModel=DeviceCMYK',
-      '-dOverrideICC=true',
-      // Preserve text rendering modes and strokes
-      '-dPreserveAnnots=true',
-      '-dPreserveCopyPage=true',
-      '-dPreserveDeviceN=true',
-      '-dDoThumbnails=false',
-      '-dDetectDuplicateImages=false',
-      '-dCompressFonts=false',
-      '-dSubsetFonts=false',
-      '-dEmbedAllFonts=true',
-      // Better handling of text rendering modes
-      '-dPDFSETTINGS=/prepress',
-      `-sOutputFile=${outputPath}`,
-      inputPath,
-    ];
-
-    // Add custom metadata if provided
-    if (options.metadata) {
-      // Create temporary PostScript file with metadata
-      const psMetadata = createMetadataPS(options.metadata);
-      const tempPSFile = path.join(path.dirname(outputPath), 'metadata.ps');
-      fs.writeFileSync(tempPSFile, psMetadata);
-      args.splice(-1, 0, tempPSFile); // Insert before input file
-    }
-
-    console.log('GhostScript command:', 'gs', args.join(' '));
-
-    const gs = spawn('gs', args);
-    let stderr = '';
-
-    gs.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    gs.on('close', (code) => {
-      // Clean up temp metadata file
-      if (options.metadata) {
-        const tempPSFile = path.join(path.dirname(outputPath), 'metadata.ps');
-        if (fs.existsSync(tempPSFile)) {
-          fs.unlinkSync(tempPSFile);
+export async function convertToPDFX1a(inputPath, outputPath, options = {}) {
+    return new Promise((resolve, reject) => {
+        // PDF/X-1a conversion parameters with stroke preservation
+        const args = [
+            '-dNOPAUSE',
+            '-dBATCH',
+            '-dSAFER',
+            '-sDEVICE=pdfwrite',
+            '-dCompatibilityLevel=1.3',
+            '-dPDFX=true',
+            '-dColorConversionStrategy=/CMYK',
+            '-dProcessColorModel=/DeviceCMYK',
+            '-dUseCIEColor=true',
+            '-sColorConversionStrategy=CMYK',
+            '-sProcessColorModel=DeviceCMYK',
+            '-dOverrideICC=true',
+            // Preserve text rendering modes and strokes
+            '-dPreserveAnnots=true',
+            '-dPreserveCopyPage=true',
+            '-dPreserveDeviceN=true', // IMPORTANT: Preserves spot/separation colors
+            '-dDoThumbnails=false',
+            '-dDetectDuplicateImages=true', // Enable duplicate image detection
+            '-dCompressFonts=true', // Enable font compression
+            '-dSubsetFonts=true', // Subset fonts to reduce size
+            '-dEmbedAllFonts=true',
+            // Better handling of text rendering modes
+            '-dPDFSETTINGS=/prepress',
+            `-sOutputFile=${outputPath}`,
+            inputPath,
+        ];
+        // Add custom metadata if provided
+        if (options.metadata) {
+            // Create temporary PostScript file with metadata
+            const psMetadata = createMetadataPS(options.metadata);
+            const tempPSFile = path.join(path.dirname(outputPath), 'metadata.ps');
+            fs.writeFileSync(tempPSFile, psMetadata);
+            args.splice(-1, 0, tempPSFile); // Insert before input file
         }
-      }
-
-      if (code === 0) {
-        console.log('PDF/X-1a conversion successful');
-        resolve();
-      } else {
-        reject(new Error(`GhostScript failed with code ${code}: ${stderr}`));
-      }
-    });
-
-    gs.on('error', (error) => {
-      reject(new Error(`Failed to start GhostScript: ${error.message}`));
+        console.log('GhostScript command:', 'gs', args.join(' '));
+        const gs = spawn('gs', args);
+        let stderr = '';
+        gs.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        gs.on('close', (code) => {
+            // Clean up temp metadata file
+            if (options.metadata) {
+                const tempPSFile = path.join(path.dirname(outputPath), 'metadata.ps');
+                if (fs.existsSync(tempPSFile)) {
+                    fs.unlinkSync(tempPSFile);
+                }
+            }
+            if (code === 0) {
+                console.log('PDF/X-1a conversion successful');
+                resolve();
+            }
+            else {
+                reject(new Error(`GhostScript failed with code ${code}: ${stderr}`));
+            }
+        });
+        gs.on('error', (error) => {
+            reject(new Error(`Failed to start GhostScript: ${error.message}`));
+        });
     });
-  });
 }
-
 /**
  * Create PostScript metadata for PDF/X-1a
- * @param {Object} metadata - Metadata object
- * @returns {string} PostScript code
+ * @param metadata - Metadata object
+ * @returns PostScript code
  */
 function createMetadataPS(metadata) {
-  const {
-    title = 'Cover Creator Export',
-    author = 'KDP Cover Creator',
-    application = 'KDP CoverCreator',
-    producer = 'Polotno PDF Export',
-  } = metadata;
-
-  return `
+    const { title = 'Cover Creator Export', author = 'KDP Cover Creator', application = 'KDP CoverCreator', producer = 'Polotno PDF Export', } = metadata;
+    return `
 %!PS
 % PDF/X-1a Metadata
 [/Title (${title})
@@ -114,49 +99,37 @@ function createMetadataPS(metadata) {
  /PDFX pdfmark
 `;
 }
-
 /**
  * Validate if PDF is PDF/X-1a compliant
- * @param {string} pdfPath - Path to PDF file
- * @returns {Promise<boolean>}
+ * @param pdfPath - Path to PDF file
  */
-async function validatePDFX1a(pdfPath) {
-  return new Promise((resolve, reject) => {
-    const args = [
-      '-dNOPAUSE',
-      '-dBATCH',
-      '-sDEVICE=nullpage',
-      '-dPDFX=true',
-      pdfPath,
-    ];
-
-    const gs = spawn('gs', args);
-    let stderr = '';
-
-    gs.stderr.on('data', (data) => {
-      stderr += data.toString();
+export async function validatePDFX1a(pdfPath) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            '-dNOPAUSE',
+            '-dBATCH',
+            '-sDEVICE=nullpage',
+            '-dPDFX=true',
+            pdfPath,
+        ];
+        const gs = spawn('gs', args);
+        let stderr = '';
+        gs.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        gs.on('close', (code) => {
+            if (code === 0 &&
+                !stderr.includes('Error') &&
+                !stderr.includes('Warning')) {
+                resolve(true);
+            }
+            else {
+                console.log('PDF/X-1a validation issues:', stderr);
+                resolve(false);
+            }
+        });
+        gs.on('error', (error) => {
+            reject(new Error(`Failed to validate PDF: ${error.message}`));
+        });
     });
-
-    gs.on('close', (code) => {
-      if (
-        code === 0 &&
-        !stderr.includes('Error') &&
-        !stderr.includes('Warning')
-      ) {
-        resolve(true);
-      } else {
-        console.log('PDF/X-1a validation issues:', stderr);
-        resolve(false);
-      }
-    });
-
-    gs.on('error', (error) => {
-      reject(new Error(`Failed to validate PDF: ${error.message}`));
-    });
-  });
 }
-
-module.exports = {
-  convertToPDFX1a,
-  validatePDFX1a,
-};

package/lib/group.d.ts

@@ -0,0 +1,5 @@
+export interface GroupElement {
+    children: any[];
+    [key: string]: any;
+}
+export declare function renderGroup(doc: any, element: GroupElement, renderElement: Function, fonts: Record<string, boolean>, attrs: any, cache: any): Promise<void>;

package/lib/group.js

@@ -1,9 +1,5 @@
-async function renderGroup(doc, element, renderElement, fonts, attrs) {
-  for (const child of element.children) {
-    await renderElement({ doc, element: child, fonts, attrs });
-  }
+export async function renderGroup(doc, element, renderElement, fonts, attrs, cache) {
+    for (const child of element.children) {
+        await renderElement({ doc, element: child, fonts, attrs, cache });
+    }
 }
-
-module.exports = {
-  renderGroup,
-};

package/lib/image.d.ts

@@ -0,0 +1,19 @@
+import { ImageCache } from './utils.js';
+export interface ImageElement {
+    src: string;
+    width: number;
+    height: number;
+    cropX: number;
+    cropY: number;
+    cropWidth: number;
+    cropHeight: number;
+    clipSrc?: string;
+    type?: string;
+    opacity?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+}
+export declare function getProcessedImageKey(element: ImageElement): string;
+export declare function cropImage(src: string, element: ImageElement, cache?: ImageCache | null): Promise<string>;
+export declare function clipImage(src: string, element: ImageElement, cache?: ImageCache | null): Promise<string>;
+export declare function renderImage(doc: any, element: ImageElement, cache?: ImageCache | null): Promise<void>;