@polotno/pdf-export 0.1.38 → 0.1.39

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

package/lib/text/fonts.js

@@ -1,113 +0,0 @@
-import { srcToBuffer } from '../utils.js';
-import getUrls from 'get-urls';
-import fetch from 'node-fetch';
-const fontUrlRegistry = {};
-const patchedPrototypes = new WeakSet();
-/**
- * Patch fontkit's TTFGlyph._getCBox to handle zero-length glyphs.
- * Some fonts (e.g. "Cute Font") have glyphs with equal start/end offsets
- * in the loca table (no outline data), but fontkit still tries to read
- * from the glyf table at that offset, causing a DataView out-of-bounds error.
- */
-function patchFontkitGlyphs(doc) {
-    const fkFont = doc._font?.font;
-    if (!fkFont || typeof fkFont.getGlyph !== 'function')
-        return;
-    const glyph = fkFont.getGlyph(0);
-    const proto = Object.getPrototypeOf(glyph);
-    if (!proto._getCBox || patchedPrototypes.has(proto))
-        return;
-    const origGetCBox = proto._getCBox;
-    proto._getCBox = function (internal) {
-        const loca = this._font.loca;
-        if (loca) {
-            const start = loca.offsets[this.id];
-            const end = loca.offsets[this.id + 1];
-            if (start === end) {
-                return Object.freeze({ minX: 0, minY: 0, maxX: 0, maxY: 0 });
-            }
-        }
-        return origGetCBox.call(this, internal);
-    };
-    patchedPrototypes.add(proto);
-}
-export function registerFontUrl(fontFamily, url) {
-    fontUrlRegistry[fontFamily] = url;
-}
-/**
- * Get font weight string based on bold/italic state
- */
-export function getFontWeight(bold, italic, baseFontWeight) {
-    if (bold) {
-        return 'bold';
-    }
-    return baseFontWeight || 'normal';
-}
-/**
- * Get font key for caching
- */
-export function getFontKey(fontFamily, bold, italic, baseFontWeight) {
-    const weight = getFontWeight(bold, italic, baseFontWeight);
-    const style = italic ? 'italic' : 'normal';
-    return `${fontFamily}-${weight}-${style}`;
-}
-export async function getGoogleFontPath(fontFamily, fontWeight = 'normal', italic = false) {
-    const weight = fontWeight === 'bold' ? '700' : '400';
-    const italicParam = italic ? 'italic' : '';
-    const url = `https://fonts.googleapis.com/css?family=${fontFamily}:${italicParam}${weight}`;
-    const req = await fetch(url);
-    if (!req.ok) {
-        if (weight !== '400' || italic) {
-            // Fallback: try normal weight without italic
-            return getGoogleFontPath(fontFamily, 'normal', false);
-        }
-        throw new Error(`Failed to fetch Google font: ${fontFamily}`);
-    }
-    const text = await req.text();
-    const urls = getUrls(text);
-    return urls.values().next().value;
-}
-/**
- * Load font for a text element or segment
- */
-export async function loadFontForSegment(doc, segment, element, fonts) {
-    const fontFamily = element.fontFamily;
-    // Determine bold/italic from segment or element
-    const bold = segment
-        ? segment.bold || element.fontWeight == 'bold' || false
-        : element.fontWeight == 'bold';
-    const italic = segment
-        ? segment.italic || element.fontStyle?.indexOf('italic') >= 0 || false
-        : element.fontStyle?.indexOf('italic') >= 0 || false;
-    // Check if universal font is already defined
-    if (fonts[fontFamily]) {
-        doc.font(fontFamily);
-        patchFontkitGlyphs(doc);
-        return fontFamily;
-    }
-    const fontKey = getFontKey(fontFamily, bold, italic, element.fontWeight);
-    if (!fonts[fontKey]) {
-        let src;
-        if (fontUrlRegistry[fontFamily]) {
-            src = fontUrlRegistry[fontFamily];
-        }
-        else {
-            const weight = getFontWeight(bold, italic, element.fontWeight);
-            src = await getGoogleFontPath(fontFamily, weight, italic);
-        }
-        try {
-            doc.registerFont(fontKey, await srcToBuffer(src));
-        }
-        catch (error) {
-            throw new Error(`Failed to load font "${fontFamily}" from ${src}: ${error.message}`);
-        }
-        fonts[fontKey] = true;
-    }
-    doc.font(fontKey);
-    patchFontkitGlyphs(doc);
-    return fontKey;
-}
-// Alias for backward compatibility
-export async function loadFontIfNeeded(doc, element, fonts) {
-    return loadFontForSegment(doc, null, element, fonts);
-}

package/lib/text/index.d.ts

@@ -1,8 +0,0 @@
-import { TextElement, RenderAttrs } from './types.js';
-export * from './types.js';
-export { loadFontIfNeeded } from './fonts.js';
-export { normalizeRichText, parseHTMLToSegments } from './parser.js';
-/**
- * Main text rendering function
- */
-export declare function renderText(doc: PDFKit.PDFDocument, element: TextElement, fonts: Record<string, boolean>, attrs?: RenderAttrs): Promise<void>;

package/lib/text/index.js

@@ -1,42 +0,0 @@
-import { normalizeRichText } from './parser.js';
-import { calculateTextMetrics, calculateVerticalAlignment, fitTextToHeight, } from './layout.js';
-import { renderTextBackground, renderPDFX1aStroke, renderStandardStroke, renderTextFill, } from './render.js';
-export * from './types.js';
-export { loadFontIfNeeded } from './fonts.js';
-export { normalizeRichText, parseHTMLToSegments } from './parser.js';
-/**
- * Main text rendering function
- */
-export async function renderText(doc, element, fonts, attrs = {}) {
-    let elementToRender = element;
-    if (typeof element.text === 'string') {
-        const normalizedText = normalizeRichText(element.text);
-        if (normalizedText !== element.text) {
-            elementToRender = { ...element, text: normalizedText };
-        }
-    }
-    doc.fontSize(elementToRender.fontSize);
-    const hasStroke = elementToRender.strokeWidth > 0;
-    const isPDFX1a = attrs.pdfx1a;
-    // Calculate text metrics and line positioning
-    const metrics = calculateTextMetrics(doc, elementToRender);
-    const verticalAlignmentOffset = calculateVerticalAlignment(doc, elementToRender, metrics.textOptions);
-    // Fit text to element height if needed
-    fitTextToHeight(doc, elementToRender, metrics.textOptions);
-    // Calculate final vertical offset
-    const finalYOffset = verticalAlignmentOffset + metrics.baselineOffset;
-    // Render background if enabled
-    renderTextBackground(doc, elementToRender, verticalAlignmentOffset, metrics.textOptions);
-    // Render text based on stroke and PDF/X-1a requirements
-    if (hasStroke && isPDFX1a) {
-        // PDF/X-1a mode: simulate stroke with offset fills
-        await renderPDFX1aStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
-    }
-    else {
-        // Standard rendering: stroke first, then fill
-        if (hasStroke) {
-            await renderStandardStroke(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
-        }
-        await renderTextFill(doc, elementToRender, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
-    }
-}

package/lib/text/layout.d.ts

@@ -1,22 +0,0 @@
-import { TextElement, TextLine, TextMetrics, RenderSegment, TabExpansionSegment } from './types.js';
-/**
- * Expand tabs in text with word spacing adjustment for accurate visual alignment.
- */
-export declare function expandTabsWithWordSpacing(text: string, doc: PDFKit.PDFDocument, textOptions: PDFKit.Mixins.TextOptions, tabSizeInSpaces?: number, currentWidth?: number): {
-    segments: TabExpansionSegment[];
-    finalWidth: number;
-};
-export declare function buildRenderSegmentsForLine(doc: PDFKit.PDFDocument, element: TextElement, lineText: string, textOptions: PDFKit.Mixins.TextOptions, fonts: Record<string, boolean>): Promise<RenderSegment[]>;
-export declare function splitTextIntoLines(doc: PDFKit.PDFDocument, element: TextElement, props: PDFKit.Mixins.TextOptions): TextLine[];
-export declare function calculateTextMetrics(doc: PDFKit.PDFDocument, element: TextElement): TextMetrics;
-export declare function calculateVerticalAlignment(doc: PDFKit.PDFDocument, element: TextElement, textOptions: PDFKit.Mixins.TextOptions): number;
-export declare function fitTextToHeight(doc: PDFKit.PDFDocument, element: TextElement, textOptions: PDFKit.Mixins.TextOptions): void;
-/**
- * Calculate X offset for list markers (not used for text content positioning)
- */
-export declare function calculateLineXOffset(element: TextElement, line: TextLine): number;
-export declare function calculateTextContentXOffset(element: TextElement, line: TextLine): number;
-/**
- * Calculate effective width for text rendering, considering justify and underline constraints
- */
-export declare function calculateEffectiveWidth(element: TextElement, line: TextLine, widthOption: number | undefined, hasUnderline: boolean): number | undefined;