@polotno/pdf-export 0.1.18

package/README.md

@@ -0,0 +1,57 @@
+# Polotno to Vector PDF
+
+Convert polotno JSON into vector PDF file from NodeJS with optional PDF/X-1a print-ready export.
+
+```bash
+npm install @polotno/pdf-export
+```
+
+## Basic Usage
+
+```js
+import fs from 'fs';
+import { jsonToPDF } from '@polotno/pdf-export';
+
+async function run() {
+  const json = JSON.parse(fs.readFileSync('./polotno.json'));
+
+  // Standard PDF export
+  await jsonToPDF(json, './output.pdf');
+}
+
+run();
+```
+
+## PDF/X-1a Print-Ready Export
+
+For professional printing, use the PDF/X-1a option which ensures:
+
+- CMYK color space conversion
+- Transparency flattening
+- Font embedding/outlining
+- Print industry compliance
+
+```js
+// PDF/X-1a export
+await jsonToPDF(json, './print-ready.pdf', {
+  pdfx1a: true,
+});
+
+// PDF/X-1a with custom metadata
+await jsonToPDF(json, './book-cover.pdf', {
+  pdfx1a: true,
+  validate: true, // Optional validation
+  metadata: {
+    title: 'My Book Cover',
+    author: 'Author Name',
+    application: 'KDP CoverCreator v1.0',
+  },
+});
+```
+
+## 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/)

package/index.js

@@ -0,0 +1,130 @@
+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}`);
+    }
+  }
+};

package/lib/figure.js

@@ -0,0 +1,49 @@
+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];
+    },
+  });
+}
+
+module.exports = {
+  renderFigure,
+};

package/lib/ghostscript.js

@@ -0,0 +1,162 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('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>}
+ */
+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);
+        }
+      }
+
+      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
+ */
+function createMetadataPS(metadata) {
+  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})
+ /Author (${author})
+ /Creator (${application})
+ /Producer (${producer})
+ /CreationDate (D:${new Date().toISOString().replace(/[-:]/g, '').slice(0, 14)})
+ /ModDate (D:${new Date().toISOString().replace(/[-:]/g, '').slice(0, 14)})
+ /DOCINFO pdfmark
+
+% Output Intent for PDF/X-1a
+[/OutputIntent
+ /GTS_PDFX
+ /Info (PDF/X-1a Output Intent)
+ /OutputConditionIdentifier (CGATS TR 001)
+ /RegistryName (http://www.color.org)
+ /PDFX pdfmark
+`;
+}
+
+/**
+ * Validate if PDF is PDF/X-1a compliant
+ * @param {string} pdfPath - Path to PDF file
+ * @returns {Promise<boolean>}
+ */
+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}`));
+    });
+  });
+}
+
+module.exports = {
+  convertToPDFX1a,
+  validatePDFX1a,
+};

package/lib/group.js

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

package/lib/image.js

@@ -0,0 +1,92 @@
+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');
+}
+
+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,
+    });
+  }
+}
+
+module.exports = {
+  cropImage,
+  clipImage,
+  renderImage,
+};

package/lib/line.js

@@ -0,0 +1,82 @@
+const { Util } = require('konva');
+const h = (type, props, ...children) => {
+    return { type, props, children: children || [] };
+};
+
+const 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)
+            .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.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;
+    }
+
+    doc.fillAndStroke(fillColor, fillColor);
+};
+
+module.exports.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));
+    }
+    
+    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}`;
+}

package/lib/svg-render.js

@@ -0,0 +1,29 @@
+const svg = require('./svg');
+
+async function renderSVG(doc, element) {
+  const svgStr = await svg.urlToString(element.src);
+  const src = svg.replaceColors(
+    svgStr,
+    new Map(Object.entries(element.colorsReplace))
+  );
+  const str = await svg.urlToString(src);
+
+  doc.addSVG(str, 0, 0, {
+    // Use 'none' to allow stretching to exact dimensions, 'xMinYMin meet' to preserve aspect ratio
+    preserveAspectRatio: 'none',
+    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 = {
+  renderSVG,
+};

package/lib/svg.js

@@ -0,0 +1,245 @@
+const Konva = require('konva');
+var nodeFetch = require('node-fetch').default;
+const xmldom = require('xmldom');
+
+const DOMParser = xmldom.DOMParser;
+const XMLSerializer = xmldom.XMLSerializer;
+
+const originalFetch = nodeFetch;
+
+const fetch = (url) => {
+  if (url.indexOf('base64') >= 0) {
+    return {
+      text: async () => {
+        let buff = Buffer.from(url.split('base64,')[1], 'base64');
+        return buff.toString('ascii');
+      },
+      buffer: async () => {
+        return Buffer.from(url.split('base64,')[1], 'base64');
+      },
+    };
+  }
+  return originalFetch(url);
+};
+
+function isInsideDef(element) {
+  while (element.parentNode) {
+    if (element.nodeName === 'defs') {
+      return true;
+    }
+    element = element.parentNode;
+  }
+  return false;
+}
+
+function getElementColors(e) {
+  const style = parseStyleAttribute(e.getAttribute('style'));
+
+  const colors = {
+    fill: '',
+    stroke: '',
+  };
+  if (e.getAttribute('fill') && e.getAttribute('fill') !== 'none') {
+    colors.fill = e.getAttribute('fill');
+  }
+  if (!colors.fill && style && style.fill && style.fill !== 'none') {
+    colors.fill = style.fill;
+  }
+  if (e.getAttribute('stroke')) {
+    colors.stroke = e.getAttribute('stroke');
+  }
+  if (!colors.stroke && style && style.stroke) {
+    colors.stroke = style.stroke;
+  }
+  if (!colors.stroke && !colors.fill) {
+    colors.fill = 'black';
+  }
+  return colors;
+}
+
+const SVG_SHAPES = ['path', 'rect', 'circle'];
+
+function getAllElementsWithColor(doc) {
+  var matchingElements = [];
+  var allElements = doc.getElementsByTagName('*');
+  for (var i = 0, n = allElements.length; i < n; i++) {
+    const element = allElements[i];
+    if (isInsideDef(element)) {
+      continue;
+    }
+    if (element.getAttribute('fill') !== null) {
+      matchingElements.push(element);
+    }
+
+    const style = element.getAttribute('style');
+
+    if (style != null && style.indexOf('fill') >= 0) {
+      matchingElements.push(element);
+    }
+
+    if (element.getAttribute('stroke') !== null) {
+      matchingElements.push(element);
+    } else if (element.style && element.style['fill']) {
+      matchingElements.push(element);
+    } else if (SVG_SHAPES.indexOf(element.nodeName) >= 0) {
+      matchingElements.push(element);
+    }
+  }
+  return matchingElements;
+}
+
+module.exports.urlToBase64 = async function urlToBase64(url) {
+  const req = await fetch(url);
+  if (req.buffer) {
+    const buffer = await req.buffer();
+    return `data:image/svg+xml;base64,${buffer.toString('base64')}`;
+  } else {
+    const svgString = await req.text();
+    return svgToURL(svgString);
+  }
+};
+
+module.exports.urlToString = async function urlToString(url) {
+  if (url.startsWith('data:')) {
+    // console.log(Buffer.from(url.split('base64,')[1], 'base64').toString());
+    return Buffer.from(url.split('base64,')[1], 'base64').toString();
+  }
+  const req = await fetch(url, { mode: 'cors' });
+  const svgString = await req.text();
+  return svgString;
+};
+
+module.exports.getColors = function getColors(svgString) {
+  var parser = new DOMParser();
+  var doc = parser.parseFromString(svgString, 'text/xml');
+
+  const elements = getAllElementsWithColor(doc);
+
+  const colors = [];
+
+  elements.forEach((e) => {
+    const { fill, stroke } = getElementColors(e);
+    const results = [fill, stroke];
+    results.forEach((color) => {
+      if (!color) {
+        return;
+      }
+      const rgba = Konva.Util.colorToRGBA(color);
+      if (!rgba) {
+        return;
+      }
+      if (colors.indexOf(color) === -1) {
+        colors.push(color);
+      }
+    });
+  });
+  return colors;
+};
+
+module.exports.svgToURL = function svgToURL(s) {
+  const uri = Buffer.from(unescape(encodeURIComponent(s))).toString('base64');
+  return 'data:image/svg+xml;base64,' + uri;
+};
+
+module.exports.getSvgSize = async function getSvgSize(url) {
+  const svgString = await urlToString(url);
+  var parser = new DOMParser();
+  var doc = parser.parseFromString(svgString, 'image/svg+xml');
+  const viewBox = doc.documentElement.getAttribute('viewBox');
+  const [x, y, width, height] = viewBox?.split(' ') || [];
+  return { width: parseFloat(width), height: parseFloat(height) };
+};
+
+module.exports.fixSize = function fixSize(svgString) {
+  var parser = new DOMParser();
+  var doc = parser.parseFromString(svgString, 'image/svg+xml');
+  const viewBox = doc.documentElement.getAttribute('viewBox');
+  const [x, y, width, height] = viewBox?.split(' ') || [];
+  if (!doc.documentElement.getAttribute('width')) {
+    doc.documentElement.setAttribute('width', width + 'px');
+  }
+
+  if (!doc.documentElement.getAttribute('height')) {
+    doc.documentElement.setAttribute('height', height + 'px');
+  }
+  var xmlSerializer = new XMLSerializer();
+  const str = xmlSerializer.serializeToString(doc);
+  return str;
+};
+
+const sameColors = (c1, c2) => {
+  if (!c2 || !c2) {
+    return false;
+  }
+  return c1.r === c2.r && c1.g === c2.g && c1.b === c2.b && c1.a === c2.a;
+};
+
+module.exports.replaceColors = function replaceColors(svgString, replaceMap) {
+  var parser = new DOMParser();
+  var doc = parser.parseFromString(svgString, 'text/xml');
+
+  const elements = getAllElementsWithColor(doc);
+
+  const oldColors = Array.from(replaceMap.keys());
+
+  elements.forEach((el) => {
+    const { fill, stroke } = getElementColors(el);
+    const colors = [
+      { prop: 'fill', color: fill },
+      { prop: 'stroke', color: stroke },
+    ];
+    colors.forEach(({ prop, color }) => {
+      // find matched oldColor
+      const marchedOldValue = oldColors.find((oldColor) => {
+        return sameColors(
+          Konva.Util.colorToRGBA(oldColor),
+          Konva.Util.colorToRGBA(color)
+        );
+      });
+      if (!marchedOldValue) {
+        return;
+      } else {
+        el.setAttribute(prop, replaceMap.get(marchedOldValue));
+
+        const style = parseStyleAttribute(el.getAttribute('style'));
+
+        if (style && style[prop]) {
+          style[prop] = replaceMap.get(marchedOldValue);
+          el.setAttribute('style', buildStyleAttribute(style));
+        }
+
+        // el[prop] = replaceMap.get(marchedOldValue);
+      }
+    });
+  });
+  var xmlSerializer = new XMLSerializer();
+  const str = xmlSerializer.serializeToString(doc);
+
+  // console.log(str);
+  // Array.from(replaceMap.keys()).forEach((oldColor) => {
+  //   svgString = svgString.replace(
+  //     new RegExp(oldColor, 'g'),
+  //     replaceMap.get(oldColor) as string
+  //   );
+  // });
+  return module.exports.svgToURL(str);
+};
+
+function parseStyleAttribute(style) {
+  if (!style) {
+    return {};
+  }
+  const styles = style.split(';');
+  const result = {};
+  styles.forEach((style) => {
+    const [key, value] = style.split(':');
+    result[key] = value;
+  });
+  return result;
+}
+
+function buildStyleAttribute(styleObject) {
+  return Object.keys(styleObject)
+    .map((key) => `${key}:${styleObject[key]}`)
+    .join(';');
+}

package/lib/text.js

@@ -0,0 +1,184 @@
+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');
+    }
+    throw new Error(`Failed to fetch Google font: ${fontFamily}`);
+  }
+  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;
+}
+
+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;
+    }
+  }
+
+  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 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);
+  }
+
+  // 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,
+    });
+  } else {
+    // Standard rendering
+    doc.text(element.text, 0, yOffset + halfLineHeight, {
+      ...props,
+      height: element.height + element.fontSize,
+    });
+  }
+}
+
+module.exports = {
+  getGoogleFontPath,
+  renderText,
+  loadFontIfNeeded,
+};

package/lib/utils.js

@@ -0,0 +1,78 @@
+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;
+}
+
+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');
+    }
+  } 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 imageBuffer = buffer;
+  if (mime !== 'image/png' && mime !== 'image/jpeg') {
+    imageBuffer = await sharp(buffer).toFormat('png').toBuffer();
+    mime = 'image/png';
+  }
+
+  return await Canvas.loadImage(imageBuffer);
+}
+
+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');
+}
+
+async function srcToBuffer(src) {
+  return Buffer.from(await srcToBase64(src), 'base64');
+}
+
+module.exports = {
+  pxToPt,
+  loadImage,
+  srcToBase64,
+  srcToBuffer,
+  DPI,
+  PIXEL_RATIO,
+  parseColor,
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@polotno/pdf-export",
+  "version": "0.1.18",
+  "description": "Convert Polotno JSON into vector PDF",
+  "main": "index.js",
+  "scripts": {
+    "test": "vitest",
+    "test:update-snapshots": "vitest -u"
+  },
+  "author": "Anton Lavrenov",
+  "files": [
+    "index.js",
+    "README.md",
+    "lib"
+  ],
+  "dependencies": {
+    "@canvas/image": "^2.0.0",
+    "@file-type/xml": "^0.4.3",
+    "canvas": "^3.1.1",
+    "file-type": "^21.0.0",
+    "get-urls": "^12.1.0",
+    "konva": "^9.3.20",
+    "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",
+    "svg-to-pdfkit": "^0.1.8",
+    "xmldom": "^0.6.0"
+  },
+  "devDependencies": {
+    "@types/pdfkit": "^0.14.0",
+    "jest-image-snapshot": "^6.5.1",
+    "pdf-img-convert": "^2.0.0",
+    "vitest": "^3.2.4"
+  }
+}