@polotno/pdf-export 0.1.37 → 0.1.39

package/lib/platform/node.js

@@ -1,142 +0,0 @@
-import fs from 'fs';
-import { Buffer } from 'buffer';
-import { PassThrough } from 'stream';
-import PDFDocument from 'pdfkit';
-import SVGtoPDF from 'svg-to-pdfkit';
-import Canvas from 'canvas';
-import sharp from 'sharp';
-import nodeFetch from 'node-fetch';
-import { fileTypeFromBuffer } from 'file-type';
-import { convertToPDFX1a, validatePDFX1a } from '../ghostscript.js';
-function ensureBuffer(data) {
-    return Buffer.isBuffer(data) ? data : Buffer.from(data);
-}
-function getFetch() {
-    if (typeof globalThis.fetch === 'function') {
-        return globalThis.fetch.bind(globalThis);
-    }
-    return nodeFetch;
-}
-async function convertToPNG(buffer, mime) {
-    if (mime === 'image/png' || mime === 'image/jpeg') {
-        return buffer;
-    }
-    // Fall back to PNG conversion for other formats
-    return sharp(buffer).toFormat('png').toBuffer();
-}
-function attachAddSVG(doc) {
-    const existing = doc.addSVG;
-    if (!existing) {
-        doc.addSVG = function (svg, x, y, options) {
-            SVGtoPDF(this, svg, x, y, options);
-            return this;
-        };
-    }
-}
-async function writeBufferToFile(fileName, buffer) {
-    await fs.promises.writeFile(fileName, buffer);
-}
-export function createNodeAdapter() {
-    const fetchImpl = getFetch();
-    return {
-        async fetch(input, init) {
-            return (await fetchImpl(input, init));
-        },
-        async loadImage(src) {
-            let buffer;
-            let mime;
-            if (src.startsWith('data:')) {
-                const matches = src.match(/^data:(.+);base64,(.*)$/);
-                if (!matches) {
-                    throw new Error('Invalid data URL');
-                }
-                mime = matches[1];
-                buffer = Buffer.from(matches[2], 'base64');
-            }
-            else {
-                const response = await fetchImpl(src);
-                if (!response.ok) {
-                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-                const arrayBuffer = await response.arrayBuffer();
-                buffer = Buffer.from(arrayBuffer);
-                const typeInfo = await fileTypeFromBuffer(buffer);
-                if (typeInfo) {
-                    mime = typeInfo.mime;
-                }
-            }
-            const normalizedBuffer = await convertToPNG(buffer, mime);
-            return Canvas.loadImage(normalizedBuffer);
-        },
-        createCanvas(width, height) {
-            return Canvas.createCanvas(width, height);
-        },
-        createPDFContext(options) {
-            const doc = new PDFDocument(options);
-            attachAddSVG(doc);
-            const stream = doc.pipe(new PassThrough());
-            const chunks = [];
-            stream.on('data', (chunk) => {
-                chunks.push(Buffer.from(chunk));
-            });
-            const resultPromise = new Promise((resolve, reject) => {
-                stream.on('end', () => resolve(Buffer.concat(chunks)));
-                stream.on('error', reject);
-                doc.on('error', reject);
-            });
-            const finalize = async (options) => {
-                const buffer = await resultPromise;
-                const outputBuffer = Buffer.from(buffer);
-                if (options?.fileName) {
-                    const targetFile = options.fileName;
-                    await writeBufferToFile(targetFile, outputBuffer);
-                    if (options.attrs?.pdfx1a) {
-                        const tempFile = targetFile.replace('.pdf', '-temp.pdf');
-                        await fs.promises.rename(targetFile, tempFile);
-                        try {
-                            await convertToPDFX1a(tempFile, targetFile, {
-                                metadata: options.attrs.metadata || {},
-                            });
-                            await fs.promises.unlink(tempFile);
-                            if (options.attrs.validate) {
-                                const isValid = await validatePDFX1a(targetFile);
-                                if (!isValid) {
-                                    console.warn('Warning: Generated PDF may not be fully PDF/X-1a compliant');
-                                }
-                            }
-                        }
-                        catch (error) {
-                            if (fs.existsSync(tempFile)) {
-                                await fs.promises.rename(tempFile, targetFile);
-                            }
-                            throw new Error(`PDF/X-1a conversion failed: ${error.message}`);
-                        }
-                    }
-                }
-                return new Uint8Array(outputBuffer);
-            };
-            return {
-                doc,
-                finalize,
-            };
-        },
-        registerFont(doc, name, data) {
-            const buffer = ensureBuffer(data);
-            doc.registerFont(name, buffer);
-        },
-        encodeBase64(data) {
-            return Buffer.from(data).toString('base64');
-        },
-        decodeBase64(value) {
-            return new Uint8Array(Buffer.from(value, 'base64'));
-        },
-        embedImage(doc, data, x, y, options, _mimeType) {
-            if (typeof data === 'string') {
-                doc.image(data, x, y, options);
-                return;
-            }
-            const buffer = ensureBuffer(data);
-            doc.image(buffer, x, y, options);
-        },
-    };
-}

package/lib/spot-colors.d.ts

@@ -1,38 +0,0 @@
-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;

package/lib/spot-colors.js

@@ -1,141 +0,0 @@
-import { Util } from 'konva/lib/Util.js';
-/**
- * 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 function normalizeColor(color) {
-    if (!color) {
-        return null;
-    }
-    try {
-        // Handle array format [r, g, b, a]
-        if (Array.isArray(color)) {
-            const r = Math.round(color[0]);
-            const g = Math.round(color[1]);
-            const b = Math.round(color[2]);
-            const a = color[3] !== undefined ? color[3] : 1;
-            return `rgba(${r},${g},${b},${a})`;
-        }
-        // Handle string format
-        if (typeof color !== 'string') {
-            return null;
-        }
-        // Use Konva's colorToRGBA for consistent color parsing
-        const rgba = Util.colorToRGBA(color);
-        if (!rgba) {
-            return null;
-        }
-        // Konva returns {r, g, b, a} object
-        // Normalize to rgba string format
-        return `rgba(${rgba.r},${rgba.g},${rgba.b},${rgba.a})`;
-    }
-    catch (error) {
-        return 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 function getSpotColorForColor(color, spotColorConfig) {
-    if (!spotColorConfig || !color) {
-        return null;
-    }
-    const normalizedColor = normalizeColor(color);
-    if (!normalizedColor) {
-        return null;
-    }
-    // Check direct match first
-    if (spotColorConfig[color]) {
-        return spotColorConfig[color];
-    }
-    // Check normalized match
-    if (spotColorConfig[normalizedColor]) {
-        return spotColorConfig[normalizedColor];
-    }
-    // Check all configured colors with normalization
-    for (const [configColor, definition] of Object.entries(spotColorConfig)) {
-        const normalizedConfigColor = normalizeColor(configColor);
-        if (normalizedConfigColor === normalizedColor) {
-            return definition;
-        }
-    }
-    return 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 function registerSpotColor(doc, spotName, spotColorDef) {
-    const { cmyk = [0, 0, 0, 1] } = spotColorDef;
-    // Convert CMYK from 0-1 range to 0-100 percentage range for PDFKit
-    const c = Math.max(0, Math.min(100, cmyk[0] * 100));
-    const m = Math.max(0, Math.min(100, cmyk[1] * 100));
-    const y = Math.max(0, Math.min(100, cmyk[2] * 100));
-    const k = Math.max(0, Math.min(100, cmyk[3] * 100));
-    // Sanitize spot color name for PDF (no spaces or special characters)
-    const sanitizedName = spotName.replace(/[^a-zA-Z0-9-_]/g, '_');
-    // Use PDFKit's built-in spot color support
-    doc.addSpotColor(sanitizedName, c, m, y, k);
-    return {
-        name: sanitizedName,
-        cmyk: [c / 100, m / 100, y / 100, k / 100], // Store in 0-1 range
-    };
-}
-/**
- * Enable spot color support on a PDFDocument by intercepting color methods
- * @param doc - PDFKit document
- * @param spotColorConfig - Spot color configuration mapping
- */
-export function enableSpotColorSupport(doc, spotColorConfig) {
-    if (!spotColorConfig || Object.keys(spotColorConfig).length === 0) {
-        return;
-    }
-    // Store configuration and registered spot colors on the document
-    doc._spotColors = new Map();
-    doc._spotColorConfig = spotColorConfig;
-    // Register all spot colors using PDFKit's built-in addSpotColor method
-    for (const [color, definition] of Object.entries(spotColorConfig)) {
-        const spotName = definition.name || `Spot_${color}`;
-        const registered = registerSpotColor(doc, spotName, definition);
-        // Cache the registered color definition
-        const normalizedColor = normalizeColor(color);
-        doc._spotColors.set(normalizedColor, registered);
-        doc._spotColors.set(color, registered); // Also store original format
-    }
-    // Intercept fillColor method to automatically use spot colors
-    const originalFillColor = doc.fillColor.bind(doc);
-    doc.fillColor = function (color, opacity) {
-        const spotColorDef = getSpotColorForColor(color, spotColorConfig);
-        if (spotColorDef) {
-            const normalizedColor = normalizeColor(color);
-            const registered = doc._spotColors.get(normalizedColor) || doc._spotColors.get(color);
-            if (registered) {
-                // Use PDFKit's fillColor with the spot color name directly
-                return originalFillColor(registered.name, opacity);
-            }
-        }
-        return originalFillColor(color, opacity);
-    };
-    // Intercept strokeColor method to automatically use spot colors
-    const originalStrokeColor = doc.strokeColor.bind(doc);
-    doc.strokeColor = function (color, opacity) {
-        const spotColorDef = getSpotColorForColor(color, spotColorConfig);
-        if (spotColorDef) {
-            const normalizedColor = normalizeColor(color);
-            const registered = doc._spotColors.get(normalizedColor) || doc._spotColors.get(color);
-            if (registered) {
-                // Use PDFKit's strokeColor with the spot color name directly
-                return originalStrokeColor(registered.name, opacity);
-            }
-        }
-        return originalStrokeColor(color, opacity);
-    };
-}

package/lib/svg-render.d.ts

@@ -1,9 +0,0 @@
-import { ImageCache } from './utils.js';
-export interface SVGElement {
-    src: string;
-    width: number;
-    height: number;
-    opacity: number;
-    colorsReplace: Record<string, string>;
-}
-export declare function renderSVG(doc: any, element: SVGElement, cache?: ImageCache | null): Promise<void>;

package/lib/svg-render.js

@@ -1,63 +0,0 @@
-import * as svg from './svg.js';
-import { Util } from 'konva/lib/Util.js';
-export async function renderSVG(doc, element, cache = null) {
-    const str = await svg.urlToString(element.src, cache);
-    const replaceEntries = Object.entries(element.colorsReplace || {});
-    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 [rgb, opacity] = colors;
-            let colorString = null;
-            if (Array.isArray(rgb) && rgb.length === 3) {
-                colorString = `rgb(${rgb[0]},${rgb[1]},${rgb[2]})`;
-            }
-            else if (typeof rgb === 'string') {
-                colorString = rgb;
-            }
-            let nextColorString = colorString;
-            if (replaceEntries.length && colorString) {
-                for (const [from, to] of replaceEntries) {
-                    if (svg.sameColors(from, colorString)) {
-                        nextColorString = to;
-                        break;
-                    }
-                }
-            }
-            let nextColorArray = rgb;
-            let finalOpacity = opacity * element.opacity;
-            if (nextColorString != null) {
-                const rgbaObject = Util.colorToRGBA(nextColorString);
-                if (rgbaObject) {
-                    nextColorArray = [
-                        Math.round(rgbaObject.r),
-                        Math.round(rgbaObject.g),
-                        Math.round(rgbaObject.b),
-                    ];
-                    // Handle alpha channel from the color string
-                    if (rgbaObject.a !== undefined) {
-                        finalOpacity = rgbaObject.a * opacity * element.opacity;
-                    }
-                }
-            }
-            if (!Array.isArray(nextColorArray) &&
-                typeof nextColorArray === 'string') {
-                const rgbObject = Util.getRGB(nextColorArray);
-                if (rgbObject) {
-                    nextColorArray = [
-                        Math.round(rgbObject.r),
-                        Math.round(rgbObject.g),
-                        Math.round(rgbObject.b),
-                    ];
-                }
-            }
-            return [nextColorArray, finalOpacity];
-        },
-    });
-}

package/lib/svg.d.ts

@@ -1,12 +0,0 @@
-import { ImageCache } from './utils.js';
-export declare function urlToBase64(url: string, cache?: ImageCache | null): Promise<string>;
-export declare function urlToString(url: string, cache?: ImageCache | null): Promise<string>;
-export declare function getColors(svgString: string): string[];
-export declare function svgToURL(s: string): string;
-export declare function getSvgSize(url: string): Promise<{
-    width: number;
-    height: number;
-}>;
-export declare function fixSize(svgString: string): string;
-export declare const sameColors: (color1: any, color2: any) => boolean;
-export declare function replaceColors(svgString: string, replaceMap: Map<string, string>): string;

package/lib/svg.js

@@ -1,224 +0,0 @@
-import { Util } from 'konva/lib/Util.js';
-import { DOMParser, XMLSerializer } from 'xmldom';
-import { fetchWithTimeout } from './utils.js';
-function isInsideDef(element) {
-    while (element.parentNode) {
-        if (element.nodeName === 'defs') {
-            return true;
-        }
-        element = element.parentNode;
-    }
-    return false;
-}
-function parseStyleAttribute(style) {
-    if (!style) {
-        return {};
-    }
-    const styles = style.split(';');
-    const result = {};
-    styles.forEach((style) => {
-        const [key, value] = style.split(':');
-        if (key && value) {
-            result[key] = value;
-        }
-    });
-    return result;
-}
-function buildStyleAttribute(styleObject) {
-    return Object.keys(styleObject)
-        .map((key) => `${key}:${styleObject[key]}`)
-        .join(';');
-}
-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;
-}
-export async function urlToBase64(url, cache = null) {
-    // Check cache first
-    if (cache && cache.buffers.has(url)) {
-        return cache.buffers.get(url);
-    }
-    const req = await fetchWithTimeout(url);
-    let result;
-    if (req.arrayBuffer) {
-        const buffer = Buffer.from(await req.arrayBuffer());
-        result = `data:image/svg+xml;base64,${buffer.toString('base64')}`;
-    }
-    else {
-        const svgString = await req.text();
-        result = svgToURL(svgString);
-    }
-    // Store in cache
-    if (cache) {
-        cache.buffers.set(url, result);
-    }
-    return result;
-}
-export async function urlToString(url, cache = null) {
-    // Check cache first
-    if (cache && cache.buffers.has(url)) {
-        const cached = cache.buffers.get(url);
-        // If cached value is a base64 data URL, decode it
-        if (cached.startsWith('data:')) {
-            return Buffer.from(cached.split('base64,')[1], 'base64').toString();
-        }
-        return cached;
-    }
-    let svgString;
-    if (url.startsWith('data:')) {
-        svgString = Buffer.from(url.split('base64,')[1], 'base64').toString();
-    }
-    else {
-        const req = await fetchWithTimeout(url);
-        svgString = await req.text();
-    }
-    // Store in cache
-    if (cache) {
-        cache.buffers.set(url, svgString);
-    }
-    return svgString;
-}
-export 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 = Util.colorToRGBA(color);
-            if (!rgba) {
-                return;
-            }
-            if (colors.indexOf(color) === -1) {
-                colors.push(color);
-            }
-        });
-    });
-    return colors;
-}
-export function svgToURL(s) {
-    const uri = Buffer.from(unescape(encodeURIComponent(s))).toString('base64');
-    return 'data:image/svg+xml;base64,' + uri;
-}
-export 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) };
-}
-export 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;
-}
-export const sameColors = (color1, color2) => {
-    if (!color1 || !color2) {
-        return false;
-    }
-    if (color2 === 'currentColor' && color1 === 'black') {
-        return true;
-    }
-    const c1 = Util.colorToRGBA(color1);
-    const c2 = Util.colorToRGBA(color2);
-    if (!c1 || !c2) {
-        return;
-    }
-    return c1.r === c2.r && c1.g === c2.g && c1.b === c2.b && c1.a === c2.a;
-};
-export 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(oldColor, 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));
-                }
-            }
-        });
-    });
-    var xmlSerializer = new XMLSerializer();
-    const str = xmlSerializer.serializeToString(doc);
-    return svgToURL(str);
-}

package/lib/text/fonts.d.ts

@@ -1,16 +0,0 @@
-import { TextElement, TextSegment } from './types.js';
-export declare function registerFontUrl(fontFamily: string, url: string): void;
-/**
- * Get font weight string based on bold/italic state
- */
-export declare function getFontWeight(bold: boolean, italic: boolean, baseFontWeight?: string): string;
-/**
- * Get font key for caching
- */
-export declare function getFontKey(fontFamily: string, bold: boolean, italic: boolean, baseFontWeight?: string): string;
-export declare function getGoogleFontPath(fontFamily: string, fontWeight?: string, italic?: boolean): Promise<string>;
-/**
- * Load font for a text element or segment
- */
-export declare function loadFontForSegment(doc: any, segment: TextSegment | null, element: TextElement, fonts: Record<string, boolean>): Promise<string>;
-export declare function loadFontIfNeeded(doc: any, element: TextElement, fonts: Record<string, boolean>): Promise<string>;