@polotno/pdf-export 0.1.37 → 0.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polotno/pdf-export",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "description": "Convert Polotno JSON into vector PDF",
   "type": "module",
   "main": "./lib/index.js",

package/lib/browser-entry.d.ts

@@ -1,7 +0,0 @@
-import type { PolotnoJSON, RenderAttrs } from './core/index.js';
-export type { PolotnoJSON, RenderAttrs } from './core/index.js';
-export interface BrowserExportOptions {
-    fileName?: string;
-    attrs?: RenderAttrs;
-}
-export declare function jsonToPDF(json: PolotnoJSON, options?: BrowserExportOptions): Promise<Blob>;

package/lib/browser-entry.js

@@ -1,11 +0,0 @@
-import { setPlatformAdapter, hasPlatformAdapter } from './platform/adapter.js';
-import { createBrowserAdapter } from './platform/browser.js';
-import { jsonToPDF as coreJsonToPDF } from './core/index.js';
-if (!hasPlatformAdapter()) {
-    setPlatformAdapter(createBrowserAdapter());
-}
-export async function jsonToPDF(json, options = {}) {
-    const { fileName, attrs } = options;
-    const result = await coreJsonToPDF(json, fileName, attrs ?? {});
-    return result;
-}

package/lib/core/index.d.ts

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

package/lib/core/index.js

@@ -1,87 +0,0 @@
-import { srcToBuffer, parseColor } from '../utils.js';
-import { renderImage } from '../image.js';
-import { loadFontIfNeeded, renderText } from '../text.js';
-import { renderFigure } from '../figure.js';
-import { renderGroup } from '../group.js';
-import { lineToPDF } from '../line.js';
-import { renderSVG } from '../svg-render.js';
-import { enableSpotColorSupport } from '../spot-colors.js';
-import { getPlatformAdapter } from '../platform/adapter.js';
-async function renderElement({ doc, element, fonts, attrs, cache, }) {
-    if ((element.visible !== undefined && !element.visible) ||
-        (element.showInExport !== undefined && !element.showInExport)) {
-        return;
-    }
-    doc.save();
-    if (element.type !== 'group') {
-        doc.translate(element.x, element.y);
-        doc.rotate(element.rotation);
-    }
-    if (element.opacity !== undefined) {
-        doc.opacity(element.opacity);
-    }
-    if (element.type === 'group') {
-        await renderGroup(doc, element, renderElement, fonts, attrs, cache);
-    }
-    else if (element.type === 'text') {
-        await loadFontIfNeeded(doc, element, fonts);
-        await renderText(doc, element, fonts, attrs);
-    }
-    else if (element.type === 'line') {
-        lineToPDF(doc, element);
-    }
-    else if (element.type === 'image') {
-        await renderImage(doc, element, cache);
-    }
-    else if (element.type === 'svg') {
-        await renderSVG(doc, element, cache);
-    }
-    else if (element.type === 'figure') {
-        renderFigure(doc, element);
-    }
-    doc.restore();
-}
-export async function jsonToPDF(json, pdfFileName, attrs = {}) {
-    const fonts = {};
-    const cache = {
-        images: new Map(),
-        buffers: new Map(),
-        processedImages: new Map(),
-    };
-    const adapter = getPlatformAdapter();
-    const { doc, finalize } = adapter.createPDFContext({
-        size: [json.width, json.height],
-        autoFirstPage: false,
-    });
-    if (attrs.spotColors) {
-        enableSpotColorSupport(doc, attrs.spotColors);
-    }
-    for (const font of json.fonts) {
-        await adapter.registerFont(doc, font.fontFamily, await srcToBuffer(font.url, cache));
-        fonts[font.fontFamily] = true;
-    }
-    for (const page of json.pages) {
-        doc.addPage();
-        if (page.background) {
-            const isURL = page.background.indexOf('http') >= 0 ||
-                page.background.indexOf('.png') >= 0 ||
-                page.background.indexOf('.jpg') >= 0;
-            if (isURL) {
-                const mime = cache.buffers.get(`mime:${page.background}`);
-                await adapter.embedImage(doc, await srcToBuffer(page.background, cache), 0, 0, {
-                    cover: [json.width, json.height],
-                    align: 'center',
-                }, mime);
-            }
-            else {
-                doc.rect(0, 0, json.width, json.height);
-                doc.fill(parseColor(page.background).hex);
-            }
-        }
-        for (const element of page.children) {
-            await renderElement({ doc, element, fonts, attrs, cache });
-        }
-    }
-    doc.end();
-    return finalize({ fileName: pdfFileName, attrs });
-}

package/lib/platform/adapter.d.ts

@@ -1,37 +0,0 @@
-export interface FetchResponse {
-    ok: boolean;
-    status: number;
-    statusText: string;
-    headers: Headers;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    text(): Promise<string>;
-    json(): Promise<any>;
-}
-export interface CanvasLike {
-    width: number;
-    height: number;
-    getContext(type: '2d'): any;
-    toDataURL(type?: string, quality?: any): string;
-}
-export interface ImageLike {
-    width: number;
-    height: number;
-    [key: string]: any;
-}
-export interface PDFContext<TOutput = unknown, TFinalizeOptions = unknown> {
-    doc: any;
-    finalize(options?: TFinalizeOptions): Promise<TOutput>;
-}
-export interface PlatformAdapter<TOutput = unknown, TFinalizeOptions = unknown> {
-    fetch(input: string, init?: RequestInit): Promise<FetchResponse>;
-    loadImage(src: string): Promise<ImageLike>;
-    createCanvas(width: number, height: number): CanvasLike;
-    createPDFContext(options: any): PDFContext<TOutput, TFinalizeOptions>;
-    registerFont(doc: any, name: string, data: Uint8Array): void | Promise<void>;
-    encodeBase64(data: Uint8Array): string;
-    decodeBase64(value: string): Uint8Array;
-    embedImage(doc: any, data: Uint8Array | string, x: number, y: number, options: any, mimeType?: string): void | Promise<void>;
-}
-export declare function setPlatformAdapter(adapter: PlatformAdapter): void;
-export declare function hasPlatformAdapter(): boolean;
-export declare function getPlatformAdapter(): PlatformAdapter;

package/lib/platform/adapter.js

@@ -1,13 +0,0 @@
-let currentAdapter = null;
-export function setPlatformAdapter(adapter) {
-    currentAdapter = adapter;
-}
-export function hasPlatformAdapter() {
-    return currentAdapter !== null;
-}
-export function getPlatformAdapter() {
-    if (!currentAdapter) {
-        throw new Error('Platform adapter is not configured.');
-    }
-    return currentAdapter;
-}

package/lib/platform/browser-polyfill.js

@@ -1,5 +0,0 @@
-const globalScope = globalThis;
-if (typeof globalScope.global === 'undefined') {
-    globalScope.global = globalScope;
-}
-export {};

package/lib/platform/browser.d.ts

@@ -1,7 +0,0 @@
-import type { PlatformAdapter } from './adapter.js';
-interface FinalizeOptions {
-    fileName?: string;
-    attrs?: any;
-}
-export declare function createBrowserAdapter(): PlatformAdapter<Blob, FinalizeOptions>;
-export {};

package/lib/platform/browser.js

@@ -1,145 +0,0 @@
-import PDFDocument from 'pdfkit/js/pdfkit.standalone.js';
-import SVGtoPDF from 'svg-to-pdfkit';
-import { Buffer } from 'buffer';
-function attachAddSVG(doc) {
-    const existing = doc.addSVG;
-    if (!existing) {
-        doc.addSVG = function (svg, x, y, options) {
-            SVGtoPDF(this, svg, x, y, options);
-            return this;
-        };
-    }
-}
-function arrayBufferToBase64(buffer) {
-    let binary = '';
-    const chunkSize = 8192;
-    for (let i = 0; i < buffer.length; i += chunkSize) {
-        const chunk = buffer.subarray(i, i + chunkSize);
-        binary += String.fromCharCode(...chunk);
-    }
-    return btoa(binary);
-}
-function base64ToUint8Array(value) {
-    const binary = atob(value);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-        bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-}
-function loadImageElement(src) {
-    return new Promise((resolve, reject) => {
-        const img = new Image();
-        if (!src.startsWith('data:')) {
-            img.crossOrigin = 'anonymous';
-        }
-        img.onload = () => resolve(img);
-        img.onerror = (error) => reject(error);
-        img.src = src;
-    });
-}
-async function loadImageFromSource(src) {
-    if (src.startsWith('data:')) {
-        return loadImageElement(src);
-    }
-    const fetchImpl = globalThis.fetch?.bind(globalThis);
-    if (!fetchImpl) {
-        throw new Error('Global fetch is not available in this environment.');
-    }
-    const response = await fetchImpl(src, { mode: 'cors' });
-    if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    const blob = await response.blob();
-    const objectUrl = URL.createObjectURL(blob);
-    try {
-        return await loadImageElement(objectUrl);
-    }
-    finally {
-        URL.revokeObjectURL(objectUrl);
-    }
-}
-export function createBrowserAdapter() {
-    return {
-        async fetch(input, init) {
-            const fetchImpl = globalThis.fetch?.bind(globalThis);
-            if (!fetchImpl) {
-                throw new Error('Global fetch is not available in this environment.');
-            }
-            return (await fetchImpl(input, init));
-        },
-        async loadImage(src) {
-            return loadImageFromSource(src);
-        },
-        createCanvas(width, height) {
-            const canvas = document.createElement('canvas');
-            canvas.width = width;
-            canvas.height = height;
-            return canvas;
-        },
-        createPDFContext(options) {
-            const doc = new PDFDocument(options);
-            attachAddSVG(doc);
-            const blobParts = [];
-            const appendTypedArray = (view) => {
-                blobParts.push(view.slice());
-            };
-            doc.on('data', (chunk) => {
-                if (chunk instanceof Uint8Array) {
-                    appendTypedArray(chunk);
-                }
-                else if (Array.isArray(chunk)) {
-                    appendTypedArray(new Uint8Array(chunk));
-                }
-                else if (typeof chunk === 'string') {
-                    const encoder = new TextEncoder();
-                    appendTypedArray(encoder.encode(chunk));
-                }
-                else if (chunk?.buffer instanceof ArrayBuffer) {
-                    appendTypedArray(new Uint8Array(chunk.buffer));
-                }
-            });
-            const resultPromise = new Promise((resolve, reject) => {
-                doc.on('end', () => {
-                    try {
-                        resolve(new Blob(blobParts, { type: 'application/pdf' }));
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                });
-                doc.on('error', reject);
-            });
-            const finalize = async (options) => {
-                if (options?.attrs?.pdfx1a) {
-                    console.warn('PDF/X-1a conversion is not supported in the browser runtime.');
-                }
-                return resultPromise;
-            };
-            return {
-                doc,
-                finalize,
-            };
-        },
-        registerFont(doc, name, data) {
-            const buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-            doc.registerFont(name, buffer);
-        },
-        encodeBase64(data) {
-            return arrayBufferToBase64(data);
-        },
-        decodeBase64(value) {
-            return base64ToUint8Array(value);
-        },
-        embedImage(doc, data, x, y, options, mimeType) {
-            if (typeof data === 'string') {
-                doc.image(data, x, y, options);
-                return;
-            }
-            const mime = mimeType || 'image/png';
-            const base64 = arrayBufferToBase64(data);
-            const dataUrl = `data:${mime};base64,${base64}`;
-            doc.image(dataUrl, x, y, options);
-        },
-    };
-}

package/lib/platform/node.d.ts

@@ -1,7 +0,0 @@
-import type { PlatformAdapter } from './adapter.js';
-interface FinalizeOptions {
-    fileName?: string;
-    attrs?: any;
-}
-export declare function createNodeAdapter(): PlatformAdapter<Uint8Array, FinalizeOptions>;
-export {};

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);
-        },
-    };
-}