@polotno/pdf-export 0.1.18 → 0.1.20

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/compare-render.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/compare-render.js

@@ -0,0 +1,185 @@
+/*
+Compare PDFs produced by polotno-node vs this library for a subset of samples.
+
+Usage examples:
+  node lib/compare-render.js --limit 10
+  node lib/compare-render.js --glob "2021-03-*"
+  node lib/compare-render.js --start 0 --end 50
+
+Outputs:
+  - builds PDFs under `comparisons/<sample>/polotno-node.pdf` and `comparisons/<sample>/current.pdf`
+  - writes a simple byte-size diff report to `comparisons/report.json`
+*/
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { promisify } from 'util';
+import { createInstance } from 'polotno-node';
+import { pdfToPng } from 'pdf-to-png-converter';
+import pixelmatch from 'pixelmatch';
+import { PNG } from 'pngjs';
+import { jsonToPDF } from './index.js';
+const readFile = promisify(fs.readFile);
+const writeFile = promisify(fs.writeFile);
+const mkdir = promisify(fs.mkdir);
+const access = promisify(fs.access);
+const readdir = promisify(fs.readdir);
+const SAMPLES_DIR = path.resolve('./samples');
+const OUTPUT_DIR = path.resolve('./comparisons');
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {};
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === '--limit')
+            result.limit = Number(args[++i]);
+        else if (a === '--start')
+            result.start = Number(args[++i]);
+        else if (a === '--end')
+            result.end = Number(args[++i]);
+        else if (a === '--glob')
+            result.glob = String(args[++i]);
+    }
+    return result;
+}
+async function tryEnsureDir(dir) {
+    try {
+        await access(dir, fs.constants.F_OK);
+    }
+    catch {
+        await mkdir(dir, { recursive: true });
+    }
+}
+function sha256(buf) {
+    return crypto.createHash('sha256').update(buf).digest('hex');
+}
+async function loadPolotnoJson(filePath) {
+    const buf = await readFile(filePath, 'utf8');
+    return JSON.parse(buf);
+}
+let polotnoInstance = null;
+async function getPolotnoInstance() {
+    if (polotnoInstance)
+        return polotnoInstance;
+    const key = process.env.POLOTNO_API_KEY || process.env.POLOTNO_API_TOKEN || '';
+    polotnoInstance = await createInstance({ key });
+    return polotnoInstance;
+}
+async function renderWithPolotnoNode(json, outPath) {
+    const instance = await getPolotnoInstance();
+    const base64 = await instance.jsonToPDFBase64(json, {
+        pixelRatio: 4,
+    });
+    await writeFile(outPath, Buffer.from(base64, 'base64'));
+}
+async function renderWithCurrent(json, outPath) {
+    await jsonToPDF(json, outPath, {});
+}
+function pickSampleDirs(allDirs, { start = 0, end, limit, glob }) {
+    let list = allDirs.filter((d) => !d.startsWith('.'));
+    if (glob) {
+        const re = new RegExp('^' + glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$');
+        list = list.filter((d) => re.test(d));
+    }
+    if (typeof start === 'number' && typeof end === 'number' && end > start) {
+        list = list.slice(start, end);
+    }
+    if (typeof limit === 'number' && limit > 0) {
+        list = list.slice(0, limit);
+    }
+    return list;
+}
+async function run() {
+    const args = parseArgs();
+    await tryEnsureDir(OUTPUT_DIR);
+    const all = await readdir(SAMPLES_DIR, { withFileTypes: true });
+    const sampleDirs = pickSampleDirs(all.filter((d) => d.isDirectory()).map((d) => d.name), args);
+    const report = [];
+    for (const dir of sampleDirs) {
+        const samplePath = path.join(SAMPLES_DIR, dir);
+        const jsonFiles = (await readdir(samplePath)).filter((f) => f.endsWith('.json') && f !== 'meta.json');
+        if (jsonFiles.length === 0)
+            continue;
+        const designPath = path.join(samplePath, jsonFiles[0]);
+        const json = await loadPolotnoJson(designPath);
+        const outDir = path.join(OUTPUT_DIR, dir);
+        await tryEnsureDir(outDir);
+        const polotnoOut = path.join(outDir, 'polotno-node.pdf');
+        const currentOut = path.join(outDir, 'current.pdf');
+        if (!fs.existsSync(polotnoOut)) {
+            // Render both
+            try {
+                await renderWithPolotnoNode(json, polotnoOut);
+            }
+            catch (e) {
+                await writeFile(path.join(outDir, 'error-polotno.txt'), String(e?.stack || e?.message || e));
+                continue;
+            }
+        }
+        try {
+            await renderWithCurrent(json, currentOut);
+        }
+        catch (e) {
+            await writeFile(path.join(outDir, 'error-current.txt'), String(e?.stack || e?.message || e));
+            continue;
+        }
+        // Rasterize first page of each PDF to PNG (via pdf-to-png-converter)
+        try {
+            const [imgA] = await pdfToPng(polotnoOut, { disableFontFace: true, viewportScale: 2, pagesToProcess: [1] });
+            const [imgB] = await pdfToPng(currentOut, { disableFontFace: true, viewportScale: 2, pagesToProcess: [1] });
+            const pngA = imgA.content;
+            const pngB = imgB.content;
+            const pngAPath = path.join(outDir, 'polotno-node.png');
+            const pngBPath = path.join(outDir, 'current.png');
+            await writeFile(pngAPath, pngA);
+            await writeFile(pngBPath, pngB);
+            // Visual diff with pixelmatch
+            const imgAParsed = PNG.sync.read(pngA);
+            const imgBParsed = PNG.sync.read(pngB);
+            const width = Math.min(imgAParsed.width, imgBParsed.width);
+            const height = Math.min(imgAParsed.height, imgBParsed.height);
+            const cropA = new PNG({ width, height });
+            const cropB = new PNG({ width, height });
+            PNG.bitblt(imgAParsed, cropA, 0, 0, width, height, 0, 0);
+            PNG.bitblt(imgBParsed, cropB, 0, 0, width, height, 0, 0);
+            const diff = new PNG({ width, height });
+            const numDiff = pixelmatch(cropA.data, cropB.data, diff.data, width, height, {
+                threshold: 0.1,
+                includeAA: true,
+            });
+            const diffPath = path.join(outDir, 'diff.png');
+            await writeFile(diffPath, PNG.sync.write(diff));
+            const a = await readFile(polotnoOut);
+            const b = await readFile(currentOut);
+            const item = {
+                sample: dir,
+                polotnoBytes: a.length,
+                currentBytes: b.length,
+                bytesDiff: Math.abs(a.length - b.length),
+                polotnoSha256: sha256(a),
+                currentSha256: sha256(b),
+                identical: numDiff === 0,
+                diffPixels: numDiff,
+                imageWidth: width,
+                imageHeight: height,
+            };
+            report.push(item);
+            await writeFile(path.join(outDir, 'summary.json'), JSON.stringify(item, null, 2));
+            console.log(`${dir}: diffPixels=${numDiff} sizeA=${item.polotnoBytes} sizeB=${item.currentBytes}`);
+        }
+        catch (e) {
+            await writeFile(path.join(outDir, 'error-diff.txt'), String(e?.stack || e?.message || e));
+        }
+    }
+    await writeFile(path.join(OUTPUT_DIR, 'report.json'), JSON.stringify(report, null, 2));
+    console.log(`Done. Compared ${report.length} samples. Report: ${path.join(OUTPUT_DIR, 'report.json')}`);
+    // Close polotno-node instance to allow process to exit
+    if (polotnoInstance) {
+        await polotnoInstance.close();
+        polotnoInstance = null;
+    }
+}
+run().catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});

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,83 @@
-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}`));
+        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) {
+                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 +97,36 @@ 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 {
+                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,
-};