@polotno/pdf-export 0.1.38 → 0.1.40

package/lib/text.js

@@ -1,576 +0,0 @@
-import { parseColor, srcToBuffer, fetchWithTimeout } from './utils.js';
-import getUrls from 'get-urls';
-import { stripHtml } from "string-strip-html";
-/**
- * Check if text contains HTML tags
- */
-function containsHTML(text) {
-    const htmlTagRegex = /<\/?(?:strong|b|em|i|u|span)[^>]*>/i;
-    return htmlTagRegex.test(text);
-}
-/**
- * Parse HTML text into styled segments
- */
-function parseHTMLToSegments(html, baseElement) {
-    const segments = [];
-    const tagStack = [];
-    // Regex to match tags and text content
-    const regex = /<(\/?)(strong|b|em|i|u|span)([^>]*)>|([^<]+)/gi;
-    let match;
-    while ((match = regex.exec(html)) !== null) {
-        if (match[4]) {
-            // Text content
-            const text = match[4];
-            // Calculate current styles from tag stack
-            let bold = false;
-            let italic = false;
-            let underline = false;
-            let color = undefined;
-            for (const tag of tagStack) {
-                if (tag.tag === 'strong' || tag.tag === 'b')
-                    bold = true;
-                if (tag.tag === 'em' || tag.tag === 'i')
-                    italic = true;
-                if (tag.tag === 'u')
-                    underline = true;
-                if (tag.color)
-                    color = tag.color;
-            }
-            segments.push({
-                text,
-                bold,
-                italic,
-                underline,
-                color
-            });
-        }
-        else {
-            // Tag
-            const isClosing = match[1] === '/';
-            const tagName = match[2].toLowerCase();
-            const attributes = match[3];
-            if (isClosing) {
-                // Remove from stack
-                const index = tagStack.findIndex(t => t.tag === tagName);
-                if (index !== -1) {
-                    tagStack.splice(index, 1);
-                }
-            }
-            else {
-                // Add to stack
-                const tagData = { tag: tagName };
-                // Parse color from span style attribute
-                if (attributes) {
-                    const colorMatch = /style=["'](?:[^"']*)?color:\s*([^;"']+)/i.exec(attributes);
-                    if (colorMatch) {
-                        tagData.color = colorMatch[1].trim();
-                    }
-                }
-                tagStack.push(tagData);
-            }
-        }
-    }
-    return segments;
-}
-/**
- * Get font weight string based on bold/italic state
- */
-function getFontWeight(bold, italic, baseFontWeight) {
-    if (bold) {
-        return 'bold';
-    }
-    return baseFontWeight || 'normal';
-}
-/**
- * Get font key for caching
- */
-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 fetchWithTimeout(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;
-}
-export 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 isItalic = element.fontStyle?.indexOf('italic') >= 0;
-    const isBold = element.fontWeight == 'bold';
-    const fontKey = getFontKey(element.fontFamily, isBold, isItalic, element.fontWeight);
-    if (!fonts[fontKey]) {
-        const src = await getGoogleFontPath(element.fontFamily, element.fontWeight, isItalic);
-        doc.registerFont(fontKey, await srcToBuffer(src));
-        fonts[fontKey] = true;
-    }
-    doc.font(fontKey);
-    return fontKey;
-}
-/**
- * Load font for a rich text segment
- */
-async function loadFontForSegment(doc, segment, element, fonts) {
-    const fontFamily = element.fontFamily;
-    const bold = segment.bold || element.fontWeight == 'bold' || false;
-    const italic = segment.italic || element.fontStyle?.indexOf('italic') >= 0 || false;
-    // Check if universal font is already defined
-    if (fonts[fontFamily]) {
-        doc.font(fontFamily);
-        return fontFamily;
-    }
-    const fontKey = getFontKey(fontFamily, bold, italic, element.fontWeight);
-    if (!fonts[fontKey]) {
-        const weight = getFontWeight(bold, italic, element.fontWeight);
-        const src = await getGoogleFontPath(fontFamily, weight, italic);
-        doc.registerFont(fontKey, await srcToBuffer(src));
-        fonts[fontKey] = true;
-    }
-    doc.font(fontKey);
-    return fontKey;
-}
-/**
- * Parse HTML into tokens (text and tags)
- */
-function tokenizeHTML(html) {
-    const tokens = [];
-    const regex = /<(\/?)(strong|b|em|i|u|span)([^>]*)>|([^<]+)/gi;
-    let match;
-    while ((match = regex.exec(html)) !== null) {
-        if (match[4]) {
-            // Text content
-            tokens.push({
-                type: 'text',
-                content: match[4]
-            });
-        }
-        else {
-            // Tag
-            const isClosing = match[1] === '/';
-            const tagName = match[2].toLowerCase();
-            tokens.push({
-                type: 'tag',
-                content: match[0],
-                tagName: tagName,
-                isClosing: isClosing
-            });
-        }
-    }
-    return tokens;
-}
-/**
- * Reconstruct HTML from tokens while maintaining proper tag nesting across line breaks
- * @param tokens - Array of parsed HTML tokens
- * @param openTags - Tags that were opened in previous lines and should be carried forward
- * @returns Reconstructed HTML string and the updated list of open tags
- */
-function tokensToHTML(tokens, openTags) {
-    let html = '';
-    const tagStack = [...openTags]; // Clone the open tags
-    // Prepend any open tags
-    for (const tag of openTags) {
-        html += tag.fullTag;
-    }
-    // Process tokens
-    for (const token of tokens) {
-        if (token.type === 'text') {
-            html += token.content;
-        }
-        else if (token.type === 'tag') {
-            html += token.content;
-            if (token.isClosing) {
-                // Remove from stack
-                const idx = tagStack.findIndex(t => t.name === token.tagName);
-                if (idx !== -1) {
-                    tagStack.splice(idx, 1);
-                }
-            }
-            else {
-                // Add to stack
-                tagStack.push({
-                    name: token.tagName,
-                    fullTag: token.content
-                });
-            }
-        }
-    }
-    // Close any remaining open tags for this line
-    for (let i = tagStack.length - 1; i >= 0; i--) {
-        html += `</${tagStack[i].name}>`;
-    }
-    return { html, openTags: tagStack };
-}
-/**
- * Split text into lines that fit within the element width while preserving HTML formatting
- * Handles word wrapping and ensures HTML tags are properly opened/closed across line breaks
- */
-function splitTextIntoLines(doc, element, props) {
-    const lines = [];
-    const paragraphs = element.text.split('\n');
-    for (const paragraph of paragraphs) {
-        // Tokenize the paragraph
-        const tokens = tokenizeHTML(paragraph);
-        // Extract plain text for width calculation
-        const plainText = tokens
-            .filter(t => t.type === 'text')
-            .map(t => t.content)
-            .join('');
-        const paragraphWidth = doc.widthOfString(plainText, props);
-        // Justify alignment using native pdfkit instruments
-        if (paragraphWidth <= element.width || element.align === 'justify') {
-            // Paragraph fits on one line
-            lines.push({ text: paragraph, width: paragraphWidth });
-        }
-        else {
-            // Need to split paragraph into multiple lines
-            let currentLine = '';
-            let currentWidth = 0;
-            let currentTokens = [];
-            let openTags = [];
-            for (const token of tokens) {
-                if (token.type === 'tag') {
-                    currentTokens.push(token);
-                    continue;
-                }
-                // Text token - split by words
-                const textWords = token.content.split(' ');
-                for (let i = 0; i < textWords.length; i++) {
-                    const word = textWords[i];
-                    const testLine = currentLine ? `${currentLine}${i > 0 ? ' ' : ''}${word}` : word;
-                    const testWidth = doc.widthOfString(testLine, props);
-                    if (testWidth <= element.width) {
-                        currentLine = testLine;
-                        currentWidth = testWidth;
-                        // Add text token (with space if not first word in token)
-                        if (i > 0 || currentTokens.length > 0) {
-                            let content = (i > 0 ? ' ' : '') + word;
-                            currentTokens.push({
-                                type: 'text',
-                                content: content
-                            });
-                        }
-                        else {
-                            currentTokens.push({
-                                type: 'text',
-                                content: word
-                            });
-                        }
-                    }
-                    else {
-                        // Line is too long, save current line and start new one
-                        if (currentLine) {
-                            const result = tokensToHTML(currentTokens, openTags);
-                            lines.push({ text: result.html, width: currentWidth });
-                            openTags = result.openTags;
-                            currentTokens = [];
-                        }
-                        currentLine = word;
-                        currentWidth = doc.widthOfString(word, props);
-                        currentTokens.push({
-                            type: 'text',
-                            content: word
-                        });
-                    }
-                }
-            }
-            // Add the last line
-            if (currentLine) {
-                const result = tokensToHTML(currentTokens, openTags);
-                lines.push({ text: result.html, width: currentWidth });
-            }
-        }
-    }
-    return lines;
-}
-/**
- * Calculate horizontal offset for a line of text based on alignment
- * @param element - Text element with alignment settings
- * @param lineWidth - Width of the current line
- * @returns X offset for positioning the line
- */
-function calculateLineXOffset(element, lineWidth) {
-    const align = element.align;
-    if (align === 'right') {
-        return element.width - lineWidth;
-    }
-    else if (align === 'center') {
-        return (element.width - lineWidth) / 2;
-    }
-    else if (align === 'justify') {
-        // Justify alignment is handled by PDFKit's align property
-        return 0;
-    }
-    // Default: left alignment
-    return 0;
-}
-/**
- * Calculate text rendering metrics including line height and baseline offset
- */
-function calculateTextMetrics(doc, element) {
-    const textOptions = {
-        align: element.align === 'justify' ? 'justify' : 'left',
-        baseline: 'alphabetic',
-        lineGap: 1,
-        width: element.width,
-        underline: element.textDecoration.indexOf('underline') >= 0,
-        characterSpacing: element.letterSpacing
-            ? element.letterSpacing * element.fontSize
-            : 0,
-        lineBreak: false,
-        stroke: false,
-        fill: false
-    };
-    const currentLineHeight = doc.heightOfString('A', textOptions);
-    const lineHeight = element.lineHeight * element.fontSize;
-    const fontBoundingBoxAscent = (doc._font.ascender / 1000) * element.fontSize;
-    const fontBoundingBoxDescent = (doc._font.descender / 1000) * element.fontSize;
-    // Calculate baseline offset based on font metrics (similar to Konva rendering)
-    const baselineOffset = (fontBoundingBoxAscent - Math.abs(fontBoundingBoxDescent)) / 2 + lineHeight / 2;
-    // Adjust line gap to match desired line height
-    const lineHeightDiff = currentLineHeight - lineHeight;
-    textOptions.lineGap = textOptions.lineGap - lineHeightDiff;
-    const textLines = splitTextIntoLines(doc, element, textOptions);
-    return {
-        textOptions,
-        lineHeightPx: lineHeight,
-        baselineOffset,
-        textLines
-    };
-}
-/**
- * Calculate vertical alignment offset for text
- */
-function calculateVerticalAlignment(doc, element, textOptions) {
-    if (!element.verticalAlign || element.verticalAlign === 'top') {
-        return 0;
-    }
-    const strippedContent = stripHtml(element.text).result;
-    const textHeight = doc.heightOfString(strippedContent, textOptions);
-    if (element.verticalAlign === 'middle') {
-        return (element.height - textHeight) / 2;
-    }
-    else if (element.verticalAlign === 'bottom') {
-        return element.height - textHeight;
-    }
-    return 0;
-}
-/**
- * Reduce font size to fit text within element height
- */
-function fitTextToHeight(doc, element, textOptions) {
-    const strippedContent = stripHtml(element.text).result;
-    for (let size = element.fontSize; size > 0; size -= 1) {
-        doc.fontSize(size);
-        const height = doc.heightOfString(strippedContent, textOptions);
-        if (height <= element.height) {
-            break;
-        }
-    }
-}
-/**
- * Render text background box
- */
-function renderTextBackground(doc, element, verticalAlignmentOffset, textOptions) {
-    if (!element.backgroundEnabled) {
-        return;
-    }
-    const strippedContent = stripHtml(element.text).result;
-    const padding = element.backgroundPadding * (element.fontSize * element.lineHeight);
-    const cornerRadius = element.backgroundCornerRadius * (element.fontSize * element.lineHeight * 0.5);
-    const textWidth = doc.widthOfString(strippedContent, {
-        ...textOptions,
-        width: element.width,
-    });
-    const textHeight = doc.heightOfString(strippedContent, {
-        ...textOptions,
-        width: element.width,
-    });
-    let bgX = -padding / 2;
-    let bgY = verticalAlignmentOffset - padding / 2;
-    const bgWidth = textWidth + padding;
-    const bgHeight = textHeight + padding;
-    // Adjust horizontal position based on text alignment
-    if (element.align === 'center') {
-        bgX = (element.width - textWidth) / 2 - padding / 2;
-    }
-    else if (element.align === 'right') {
-        bgX = element.width - textWidth - padding / 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 stroke using PDF/X-1a compatible method (multiple offset fills)
- */
-function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions) {
-    const strokeColor = parseColor(element.stroke).hex;
-    const strokeWidth = element.strokeWidth;
-    const isJustify = element.align === 'justify';
-    // Generate stroke offsets in a circle pattern
-    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,
-        });
-    }
-    // Render stroke layer by drawing text multiple times with offsets
-    doc.save();
-    doc.fillColor(strokeColor, element.opacity);
-    for (let i = 0; i < textLines.length; i++) {
-        const line = textLines[i];
-        const lineXOffset = calculateLineXOffset(element, line.width);
-        const lineYOffset = yOffset + (i * lineHeightPx);
-        for (const offset of offsets) {
-            doc.text(line.text, lineXOffset + offset.x, lineYOffset + offset.y, {
-                ...textOptions,
-                width: isJustify ? element.width : undefined,
-                stroke: false,
-            });
-        }
-    }
-    doc.restore();
-    // Render fill layer on top
-    doc.fillColor(parseColor(element.fill).hex, element.opacity);
-    for (let i = 0; i < textLines.length; i++) {
-        const line = textLines[i];
-        const lineXOffset = calculateLineXOffset(element, line.width);
-        const lineYOffset = yOffset + (i * lineHeightPx);
-        doc.text(line.text, lineXOffset, lineYOffset, {
-            ...textOptions,
-            width: isJustify ? element.width : undefined,
-            stroke: false,
-        });
-    }
-}
-/**
- * Render text stroke using standard PDF stroke
- */
-function renderStandardStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions) {
-    const isJustify = element.align === 'justify';
-    doc.save();
-    doc.lineWidth(element.strokeWidth);
-    doc.lineCap('round').lineJoin('round');
-    doc.strokeColor(parseColor(element.stroke).hex, element.opacity);
-    let cumulativeYOffset = 0;
-    for (let i = 0; i < textLines.length; i++) {
-        const line = textLines[i];
-        const lineXOffset = calculateLineXOffset(element, line.width);
-        const lineYOffset = yOffset + cumulativeYOffset;
-        const strippedLineText = stripHtml(line.text).result;
-        const heightOfLine = line.text === ''
-            ? lineHeightPx
-            : doc.heightOfString(strippedLineText, textOptions);
-        cumulativeYOffset += heightOfLine;
-        doc.text(line.text, lineXOffset, lineYOffset, {
-            ...textOptions,
-            width: isJustify ? element.width : undefined,
-            height: heightOfLine,
-            stroke: true,
-            fill: false
-        });
-    }
-    doc.restore();
-}
-/**
- * Render text fill with rich text support (HTML segments)
- */
-async function renderTextFill(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts) {
-    if (!element.fill) {
-        return;
-    }
-    const baseParsedColor = parseColor(element.fill);
-    const baseOpacity = Math.min(baseParsedColor.rgba[3] ?? 1, element.opacity, 1);
-    doc.fillColor(baseParsedColor.hex, baseOpacity);
-    const isJustify = element.align === 'justify';
-    let cumulativeYOffset = 0;
-    for (let i = 0; i < textLines.length; i++) {
-        const line = textLines[i];
-        const lineXOffset = calculateLineXOffset(element, line.width);
-        const lineYOffset = yOffset + cumulativeYOffset;
-        const strippedLineText = stripHtml(line.text).result;
-        const heightOfLine = line.text === ''
-            ? lineHeightPx
-            : doc.heightOfString(strippedLineText, textOptions);
-        cumulativeYOffset += heightOfLine;
-        // Position cursor at line start
-        doc.text('', lineXOffset, lineYOffset, { height: 0, width: 0 });
-        // Parse line into styled segments
-        const segments = parseHTMLToSegments(line.text, element);
-        // Render each segment with its own styling
-        for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
-            const segment = segments[segmentIndex];
-            const isLastSegment = segmentIndex === segments.length - 1;
-            // Load appropriate font for this segment
-            await loadFontForSegment(doc, segment, element, fonts);
-            doc.fontSize(element.fontSize);
-            // Apply segment color
-            const segmentColor = segment.color
-                ? parseColor(segment.color).hex
-                : parseColor(element.fill).hex;
-            const segmentParsedColor = segment.color
-                ? parseColor(segment.color)
-                : parseColor(element.fill);
-            const segmentOpacity = Math.min(segmentParsedColor.rgba[3] ?? 1, element.opacity, 1);
-            doc.fillColor(segmentColor, segmentOpacity);
-            // Render segment text
-            doc.text(segment.text, {
-                ...textOptions,
-                width: isJustify ? element.width : undefined,
-                height: heightOfLine,
-                continued: !isLastSegment,
-                underline: segment.underline || textOptions.underline || false,
-                lineBreak: !!segment.underline, // Workaround for pdfkit bug
-                stroke: false,
-                fill: true
-            });
-        }
-    }
-}
-/**
- * Main text rendering function
- */
-export async function renderText(doc, element, fonts, attrs = {}) {
-    doc.fontSize(element.fontSize);
-    const hasStroke = element.strokeWidth > 0;
-    const isPDFX1a = attrs.pdfx1a;
-    // Calculate text metrics and line positioning
-    const metrics = calculateTextMetrics(doc, element);
-    const verticalAlignmentOffset = calculateVerticalAlignment(doc, element, metrics.textOptions);
-    // Fit text to element height if needed
-    fitTextToHeight(doc, element, metrics.textOptions);
-    // Calculate final vertical offset
-    const finalYOffset = verticalAlignmentOffset + metrics.baselineOffset;
-    // Render background if enabled
-    renderTextBackground(doc, element, 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
-        renderPDFX1aStroke(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
-    }
-    else {
-        // Standard rendering: stroke first, then fill
-        if (hasStroke) {
-            renderStandardStroke(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions);
-        }
-        await renderTextFill(doc, element, metrics.textLines, finalYOffset, metrics.lineHeightPx, metrics.textOptions, fonts);
-    }
-}

package/lib/utils.d.ts

@@ -1,16 +0,0 @@
-import parseColor from 'parse-color';
-export declare const DPI = 75;
-export declare const PIXEL_RATIO = 2;
-export declare function fetchWithTimeout(url: string, timeout?: number, retries?: number): Promise<any>;
-export declare function pxToPt(px: number): number;
-export interface ImageCache {
-    images: Map<string, any>;
-    buffers: Map<string, any>;
-    processedImages: Map<string, string>;
-    imageFiles: Map<string, string>;
-    tempDir: string | null;
-}
-export declare function loadImage(src: string, cache?: ImageCache | null): Promise<any>;
-export declare function srcToBase64(src: string, cache?: ImageCache | null): Promise<string>;
-export declare function srcToBuffer(src: string, cache?: ImageCache | null): Promise<Buffer>;
-export { parseColor };