@polotno/pdf-export 0.1.37 → 0.1.39

package/lib/group.d.ts

@@ -1,5 +0,0 @@
-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,5 +0,0 @@
-export async function renderGroup(doc, element, renderElement, fonts, attrs, cache) {
-    for (const child of element.children) {
-        await renderElement({ doc, element: child, fonts, attrs, cache });
-    }
-}

package/lib/image.d.ts

@@ -1,38 +0,0 @@
-import { ImageCache } from './utils.js';
-export interface ImageElement {
-    src: string;
-    width: number;
-    height: number;
-    cropX: number;
-    cropY: number;
-    cropWidth: number;
-    cropHeight: number;
-    clipSrc?: string;
-    type?: string;
-    opacity?: number;
-    flipX?: boolean;
-    flipY?: boolean;
-    borderSize?: number;
-    borderColor?: string;
-    brightnessEnabled: boolean;
-    brightness: number;
-    grayscaleEnabled: boolean;
-    sepiaEnabled: boolean;
-    blurEnabled: boolean;
-    blurRadius: number;
-    filters: Record<string, ShapeFilter>;
-    shadowEnabled?: boolean;
-    shadowBlur?: number;
-    shadowOffsetX?: number;
-    shadowOffsetY?: number;
-    shadowColor?: string;
-    shadowOpacity?: number;
-}
-type ShapeFilter = {
-    intensity: number;
-};
-export declare function getProcessedImageKey(element: ImageElement): string;
-export declare function cropImage(src: string, element: ImageElement, cache?: ImageCache | null): Promise<string>;
-export declare function clipImage(src: string, element: ImageElement, cache?: ImageCache | null): Promise<string>;
-export declare function renderImage(doc: PDFKit.PDFDocument, element: ImageElement, cache?: ImageCache | null): Promise<void>;
-export {};

package/lib/image.js

@@ -1,279 +0,0 @@
-import { loadImage, PIXEL_RATIO, srcToBuffer, parseColor, } from './utils.js';
-import Canvas from 'canvas';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import crypto from 'crypto';
-import Konva from 'konva';
-import { elementFilterToKonva } from './filters.js';
-async function applyFlip(image, element) {
-    const { flipX, flipY } = element;
-    if (!flipX && !flipY) {
-        return image;
-    }
-    if (!image || !image.width || !image.height) {
-        return null;
-    }
-    const canvas = new Canvas.Canvas(image.width, image.height);
-    const ctx = canvas.getContext('2d');
-    let x = flipX ? -canvas.width : 0;
-    let y = flipY ? -canvas.height : 0;
-    ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
-    ctx.drawImage(image, x, y, canvas.width, canvas.height);
-    return canvas;
-}
-// Helper to create cache key for processed images
-export function getProcessedImageKey(element) {
-    return JSON.stringify({
-        src: element.src,
-        width: element.width,
-        height: element.height,
-        cropX: element.cropX,
-        cropY: element.cropY,
-        cropWidth: element.cropWidth,
-        cropHeight: element.cropHeight,
-        clipSrc: element.clipSrc,
-        brightnessEnabled: element.brightnessEnabled,
-        brightness: element.brightness,
-        grayscaleEnabled: element.grayscaleEnabled,
-        sepiaEnabled: element.sepiaEnabled,
-        blurEnabled: element.blurEnabled,
-        blurRadius: element.blurRadius,
-        filters: element.filters,
-    });
-}
-export async function cropImage(src, element, cache = null) {
-    let image = await loadImage(src);
-    // Apply flip transformations first
-    image = await applyFlip(image, element);
-    if (!image) {
-        return null;
-    }
-    const canvas = Canvas.createCanvas(element.width * PIXEL_RATIO, 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');
-}
-export async function clipImage(src, element, cache = null) {
-    const image = await loadImage(src, cache);
-    const clipImage = await loadImage(element.clipSrc, cache);
-    const canvas = Canvas.createCanvas(element.width, element.height);
-    const ctx = canvas.getContext('2d');
-    ctx.drawImage(image, 0, 0, element.width, element.height);
-    const clipCanvas = Canvas.createCanvas(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 applyFilter(src, element, cache = null) {
-    const image = await loadImage(src, cache);
-    const canvas = Canvas.createCanvas(element.width * PIXEL_RATIO, element.height * PIXEL_RATIO);
-    const ctx = canvas.getContext('2d');
-    ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
-    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
-    const data = imageData.data;
-    if (element.brightnessEnabled) {
-        Konva.Filters.Brighten.bind({
-            brightness: () => element.brightness,
-        })({ data });
-    }
-    // grayscale
-    if (element.grayscaleEnabled) {
-        Konva.Filters.Grayscale.bind({})({ data });
-    }
-    // sepia
-    if (element.sepiaEnabled) {
-        Konva.Filters.Sepia.bind({})({ data });
-    }
-    // blur
-    if (element.blurEnabled) {
-        Konva.Filters.Blur.bind({
-            blurRadius: () => element.blurRadius,
-        })({ data });
-    }
-    // filters
-    if (element.filters) {
-        Object.entries(element.filters).forEach(([type, effect]) => {
-            const filter = elementFilterToKonva[type];
-            if (filter) {
-                filter(effect.intensity).bind({})({ data });
-            }
-        });
-    }
-    ctx.putImageData(imageData, 0, 0);
-    return canvas.toDataURL('image/png');
-}
-function applyBorder(doc, element) {
-    if (element.borderSize > 0) {
-        const borderColor = parseColor(element.borderColor).keyword || 'black';
-        doc
-            .rect(element.borderSize / 2, element.borderSize / 2, element.width - element.borderSize, element.height - element.borderSize)
-            .lineWidth(element.borderSize)
-            .strokeColor(borderColor)
-            .stroke();
-    }
-}
-function saveToTempFile(buffer, key, cache) {
-    if (cache) {
-        if (!cache.imageFiles) {
-            cache.imageFiles = new Map();
-        }
-        if (!cache.tempDir) {
-            cache.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pdfkit-images-'));
-        }
-        // Create a unique filename based on cache key hash
-        const hash = crypto.createHash('md5').update(key).digest('hex');
-        const filePath = path.join(cache.tempDir, `${hash}.png`);
-        // Write buffer to file
-        fs.writeFileSync(filePath, buffer);
-        cache.imageFiles.set(key, filePath);
-        return filePath;
-    }
-    else {
-        return buffer;
-    }
-}
-async function getShadowImage(src, element, cache) {
-    const image = await loadImage(src, cache);
-    const { shadowBlur, shadowColor, shadowOpacity } = element;
-    // Shadow blur in Konva is standard. In Canvas it is standard.
-    // We need to scale it by PIXEL_RATIO as our canvas is scaled.
-    const ratio = PIXEL_RATIO;
-    const blur = (shadowBlur || 0) * ratio;
-    // Padding.
-    const padding = blur * 4 + 20; // Sufficient padding
-    const width = image.width + padding * 2;
-    const height = image.height + padding * 2;
-    const canvas = Canvas.createCanvas(width, height);
-    const ctx = canvas.getContext('2d');
-    // Parse color
-    const parsed = parseColor(shadowColor || 'black');
-    const opacity = shadowOpacity !== undefined ? shadowOpacity : 1;
-    const r = parsed.rgb[0];
-    const g = parsed.rgb[1];
-    const b = parsed.rgb[2];
-    const a = opacity;
-    const colorString = `rgba(${r},${g},${b},${a})`;
-    ctx.shadowColor = colorString;
-    ctx.shadowBlur = blur;
-    // We want the shadow to appear at (padding, padding) relative to canvas.
-    // We draw the image at (padding - OFFSET, padding - OFFSET)
-    // And set shadowOffset to (OFFSET, OFFSET).
-    // OFFSET should be large enough to move image out of view.
-    const OFFSET = 10000;
-    ctx.shadowOffsetX = OFFSET;
-    ctx.shadowOffsetY = OFFSET;
-    // Draw image
-    ctx.drawImage(image, padding - OFFSET, padding - OFFSET, image.width, image.height);
-    return {
-        src: canvas.toDataURL('image/png'),
-        padding: padding / ratio, // return padding in original units (points)
-        width: width / ratio,
-        height: height / ratio,
-    };
-}
-export async function renderImage(doc, element, cache = null) {
-    // Check if we have a cached processed version
-    const cacheKey = getProcessedImageKey(element);
-    let src = null;
-    const hasCachedFile = cache && cache.imageFiles && cache.imageFiles.has(cacheKey);
-    if (hasCachedFile) {
-        src = cache.imageFiles.get(cacheKey);
-    }
-    else if (cache && cache.processedImages.has(cacheKey)) {
-        src = cache.processedImages.get(cacheKey);
-    }
-    else {
-        src = await cropImage(element.src, element, cache);
-        if (element.clipSrc) {
-            src = await clipImage(src, element, cache);
-        }
-        src = await applyFilter(src, element, cache);
-        // Cache the processed result
-        if (cache && src) {
-            cache.processedImages.set(cacheKey, src);
-        }
-    }
-    if (element.shadowEnabled && src) {
-        const shadowKey = cacheKey +
-            '_shadow_' +
-            JSON.stringify({
-                blur: element.shadowBlur,
-                color: element.shadowColor,
-                opacity: element.shadowOpacity,
-            });
-        let shadowPadding = 0;
-        let shadowW = 0;
-        let shadowH = 0;
-        if (cache && cache.imageFiles && cache.imageFiles.has(shadowKey)) {
-            const filePath = cache.imageFiles.get(shadowKey);
-            // Recalculate padding/dimensions as we don't cache them
-            const ratio = PIXEL_RATIO;
-            const blur = (element.shadowBlur || 0) * ratio;
-            shadowPadding = (blur * 4 + 20) / ratio;
-            shadowW = element.width + shadowPadding * 2;
-            shadowH = element.height + shadowPadding * 2;
-            console.log('✓ Using cached shadow file:', path.basename(filePath));
-            doc.image(filePath, (element.shadowOffsetX || 0) - shadowPadding, (element.shadowOffsetY || 0) - shadowPadding, {
-                width: shadowW,
-                height: shadowH,
-            });
-        }
-        else {
-            const shadowResult = await getShadowImage(src, element, cache);
-            const shadowSrc = shadowResult.src;
-            shadowPadding = shadowResult.padding;
-            shadowW = shadowResult.width;
-            shadowH = shadowResult.height;
-            if (shadowSrc) {
-                const buffer = await srcToBuffer(shadowSrc, cache);
-                const filePath = saveToTempFile(buffer, shadowKey, cache);
-                doc.image(filePath, (element.shadowOffsetX || 0) - shadowPadding, (element.shadowOffsetY || 0) - shadowPadding, {
-                    width: shadowW,
-                    height: shadowH,
-                });
-            }
-        }
-    }
-    if (src) {
-        if (hasCachedFile) {
-            console.log('✓ Using cached image file:', path.basename(src));
-            doc.image(src, 0, 0, {
-                width: element.width,
-                height: element.height,
-            });
-        }
-        else {
-            const buffer = await srcToBuffer(src, cache);
-            const filePath = saveToTempFile(buffer, cacheKey, cache);
-            doc.image(filePath, 0, 0, {
-                width: element.width,
-                height: element.height,
-            });
-        }
-        applyBorder(doc, element);
-    }
-}

package/lib/line.d.ts

@@ -1,10 +0,0 @@
-export interface LineElement {
-    height: number;
-    width: number;
-    color: string;
-    opacity: number;
-    dash?: number[];
-    startHead?: string;
-    endHead?: string;
-}
-export declare function lineToPDF(doc: any, element: LineElement): void;

package/lib/line.js

@@ -1,66 +0,0 @@
-import { Util } from 'konva/lib/Util.js';
-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}`;
-}
-function 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;
-    }
-    doc.fillAndStroke(fillColor, fillColor);
-}
-export function 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,
-    });
-}

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.d.ts

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

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 {};