@polotno/pdf-export 0.1.38 → 0.1.40

package/lib/text/layout.js

@@ -1,522 +0,0 @@
-import { stripHtml } from 'string-strip-html';
-import { tokenizeHTML, parseHtmlToParagraphs, tokensToHTML, decodeHtmlEntities, parseHTMLToSegments, } from './parser.js';
-import { loadFontForSegment } from './fonts.js';
-/**
- * Expand tabs to spaces based on character positions (every 8 characters by default).
- * This is a lightweight character-based approximation used for line-breaking calculations.
- */
-function expandTabsToTabStops(text, tabSize = 8, startPosition = 0) {
-    if (!text) {
-        return text;
-    }
-    let result = '';
-    let position = startPosition; // Current character position
-    for (let i = 0; i < text.length; i++) {
-        const char = text[i];
-        if (char === '\t') {
-            // Calculate how many spaces needed to reach next tab stop
-            const spacesNeeded = tabSize - (position % tabSize);
-            result += ' '.repeat(spacesNeeded);
-            position += spacesNeeded;
-        }
-        else if (char === '\n') {
-            // Reset position on newline (tab stops reset at line start)
-            result += char;
-            position = 0;
-        }
-        else {
-            result += char;
-            position++;
-        }
-    }
-    return result;
-}
-/**
- * Expand tabs in text with word spacing adjustment for accurate visual alignment.
- */
-export function expandTabsWithWordSpacing(text, doc, textOptions, tabSizeInSpaces = 8, currentWidth = 0) {
-    if (!text || !text.includes('\t')) {
-        // No tabs, return as-is
-        const width = currentWidth + doc.widthOfString(text, textOptions);
-        return {
-            segments: [{ type: 'text', text, wordSpacing: 0 }],
-            finalWidth: width,
-        };
-    }
-    // Measure the width of one space character (for rendering tab spaces)
-    const spaceWidth = doc.widthOfString(' ', textOptions);
-    const tabStopWidth = Math.max(spaceWidth * tabSizeInSpaces, spaceWidth || 1);
-    const segments = [];
-    let width = currentWidth;
-    let currentSegment = '';
-    for (let i = 0; i < text.length; i++) {
-        const char = text[i];
-        if (char === '\t') {
-            // Flush current segment if any
-            if (currentSegment) {
-                const segmentWidth = doc.widthOfString(currentSegment, textOptions);
-                segments.push({ type: 'text', text: currentSegment, wordSpacing: 0 });
-                width += segmentWidth;
-                currentSegment = '';
-            }
-            // Calculate the exact distance to next tab stop
-            const currentTabPosition = width % tabStopWidth;
-            const targetWidth = tabStopWidth - currentTabPosition;
-            const widthBeforeTab = width;
-            // Emit a tab instruction so the renderer can manually reposition the cursor.
-            segments.push({
-                type: 'tab',
-                advanceWidth: widthBeforeTab + targetWidth,
-            });
-            width += targetWidth;
-        }
-        else if (char === '\n') {
-            // Flush current segment and add newline
-            if (currentSegment) {
-                const segmentWidth = doc.widthOfString(currentSegment, textOptions);
-                segments.push({ type: 'text', text: currentSegment, wordSpacing: 0 });
-                width += segmentWidth;
-                currentSegment = '';
-            }
-            segments.push({ type: 'text', text: '\n', wordSpacing: 0 });
-            width = 0; // Reset width on newline
-        }
-        else {
-            currentSegment += char;
-        }
-    }
-    // Flush remaining segment
-    if (currentSegment) {
-        const segmentWidth = doc.widthOfString(currentSegment, textOptions);
-        segments.push({ type: 'text', text: currentSegment, wordSpacing: 0 });
-        width += segmentWidth;
-    }
-    return { segments, finalWidth: width };
-}
-export async function buildRenderSegmentsForLine(doc, element, lineText, textOptions, fonts) {
-    const parsedSegments = parseHTMLToSegments(lineText, element);
-    let currentLineWidth = 0;
-    const renderSegments = [];
-    for (const segment of parsedSegments) {
-        const fontKey = await loadFontForSegment(doc, segment, element, fonts);
-        doc.font(fontKey);
-        doc.fontSize(element.fontSize);
-        if (segment.text.includes('\t')) {
-            const expanded = expandTabsWithWordSpacing(segment.text, doc, textOptions, 8, currentLineWidth);
-            currentLineWidth = expanded.finalWidth;
-            for (const tabSegment of expanded.segments) {
-                if (tabSegment.type === 'tab') {
-                    renderSegments.push({
-                        segment,
-                        fontKey,
-                        type: 'tab',
-                        advanceWidth: tabSegment.advanceWidth,
-                    });
-                }
-                else {
-                    renderSegments.push({
-                        segment,
-                        fontKey,
-                        type: 'text',
-                        text: tabSegment.text,
-                        wordSpacing: tabSegment.wordSpacing,
-                    });
-                }
-            }
-        }
-        else {
-            const segmentWidth = doc.widthOfString(segment.text, textOptions);
-            currentLineWidth += segmentWidth;
-            renderSegments.push({
-                segment,
-                fontKey,
-                type: 'text',
-                text: segment.text,
-                wordSpacing: 0,
-            });
-        }
-    }
-    return renderSegments;
-}
-function cloneListMetaForLine(meta, showMarker) {
-    if (!meta) {
-        return undefined;
-    }
-    return {
-        ...meta,
-        showMarker,
-    };
-}
-function createListLineMeta(doc, element, props, paragraphMeta) {
-    const indentPx = paragraphMeta.indentLevel * element.fontSize * 0.5;
-    const markerText = paragraphMeta.type === 'ul' ? '•' : `${paragraphMeta.index.toString()}.`;
-    const previousFontSize = doc._fontSize !== undefined
-        ? doc._fontSize
-        : element.fontSize;
-    const markerFontSize = paragraphMeta.type === 'ul' ? element.fontSize * 1.2 : element.fontSize;
-    doc.fontSize(markerFontSize);
-    const markerLabelWidth = doc.widthOfString(markerText, {
-        ...props,
-        width: undefined,
-    });
-    doc.fontSize(previousFontSize);
-    const markerGapPx = element.fontSize * (paragraphMeta.type === 'ul' ? 1.5 : 0.8);
-    const markerBoxMinPx = element.fontSize * (paragraphMeta.type === 'ul' ? 2.5 : 2.8);
-    const markerBoxWidth = Math.max(markerLabelWidth + markerGapPx, markerBoxMinPx);
-    const textStartPx = indentPx + markerBoxWidth;
-    return {
-        type: paragraphMeta.type,
-        markerText,
-        indentPx,
-        markerBoxWidth,
-        markerFontSize,
-        markerAlignment: paragraphMeta.type === 'ul' ? 'center' : 'right',
-        showMarker: paragraphMeta.displayMarker,
-        textStartPx,
-    };
-}
-function encodeHtmlEntities(text) {
-    return text
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-export function splitTextIntoLines(doc, element, props) {
-    const lines = [];
-    const rawText = typeof element.text === 'string'
-        ? element.text
-        : String(element.text ?? '');
-    const paragraphs = parseHtmlToParagraphs(rawText);
-    const lineHeightPx = element.lineHeight * element.fontSize;
-    // Calculate max allowed lines. Ensure at least 1 line is allowed.
-    // Use a very large number if height check is disabled or infinite
-    // If element.height is very large (like in 8.json which is a page), we should treat it as effectively infinite for text
-    // But wait, the element in 8.json has specific height:
-    // "height": 60 for title, 40 for subtitle, 40 for chapter title, 600 for content text.
-    // The content text has height 600 and font size 14. Line height 1.5 -> 21px per line.
-    // 600 / 21 = ~28 lines.
-    // So maxLines is finite.
-    const maxLines = element.height > 0
-        ? Math.max(1, Math.round(element.height / lineHeightPx))
-        : Infinity;
-    if (paragraphs.length === 0) {
-        paragraphs.push({ html: '' });
-    }
-    for (const paragraph of paragraphs) {
-        // Tokenize the paragraph
-        const tokens = tokenizeHTML(paragraph.html);
-        // Extract plain text for width calculation
-        // Expand tabs to tab stops for accurate width measurement
-        const plainText = expandTabsToTabStops(tokens
-            .filter((t) => t.type === 'text')
-            .map((t) => t.decodedContent ?? decodeHtmlEntities(t.content))
-            .join(''), 8);
-        const baseMeta = paragraph.listMeta
-            ? createListLineMeta(doc, element, props, paragraph.listMeta)
-            : undefined;
-        const availableWidthRaw = element.width - (baseMeta ? baseMeta.textStartPx : 0);
-        const availableWidth = element.align === 'justify'
-            ? Math.max(availableWidthRaw, 1)
-            : Math.max(availableWidthRaw, element.width * 0.1, 1);
-        const paragraphWidth = doc.widthOfString(plainText, props);
-        let showMarkerForLine = baseMeta?.showMarker ?? false;
-        // Justify alignment using native pdfkit instruments
-        if (paragraphWidth <= availableWidth || element.align === 'justify') {
-            // Paragraph fits on one line
-            const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-            lines.push({
-                text: paragraph.html,
-                width: paragraphWidth,
-                fullWidth: paragraphWidth + (listMeta ? listMeta.textStartPx : 0),
-                listMeta,
-            });
-        }
-        else {
-            // Need to split paragraph into multiple lines
-            let currentLineDecoded = '';
-            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
-                // Don't expand tabs here - we need to preserve tabs for proper alignment
-                const rawWords = token.content.split(' ');
-                const decodedText = token.decodedContent ?? decodeHtmlEntities(token.content);
-                const decodedWords = decodedText.split(' ');
-                for (let i = 0; i < rawWords.length; i++) {
-                    const rawWord = rawWords[i];
-                    const decodedWord = decodedWords[i] ?? decodeHtmlEntities(rawWord);
-                    const separator = i > 0 ? ' ' : '';
-                    const hasCurrentLine = currentLineDecoded.length > 0;
-                    const testLineDecoded = hasCurrentLine
-                        ? `${currentLineDecoded}${separator}${decodedWord}`
-                        : decodedWord;
-                    // Expand tabs in test line for accurate width measurement
-                    // Tabs are expanded based on the full line position, maintaining tab stop alignment
-                    const testLineExpanded = expandTabsToTabStops(testLineDecoded, 8);
-                    const testWidth = doc.widthOfString(testLineExpanded, props);
-                    if (testWidth <= availableWidth) {
-                        currentLineDecoded = testLineDecoded;
-                        currentWidth = testWidth;
-                        // Add text token (with space if not first word in token)
-                        const rawContent = separator.length > 0 ? `${separator}${rawWord}` : rawWord;
-                        const decodedContent = separator.length > 0 ? `${separator}${decodedWord}` : decodedWord;
-                        currentTokens.push({
-                            type: 'text',
-                            content: rawContent,
-                            decodedContent,
-                        });
-                    }
-                    else {
-                        // Line is too long, save current line and start new one
-                        // Check if we can add a new line (wrapping).
-                        // If we wrap, we push the current line and start a new one.
-                        // So we will have lines.length + 1 lines + the new one we are starting.
-                        // We can wrap only if lines.length + 1 <= maxLines.
-                        if (lines.length < maxLines - 1) {
-                            // Case 1: Line has content, so we wrap to next line
-                            if (currentLineDecoded.length > 0) {
-                                const result = tokensToHTML(currentTokens, openTags);
-                                const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-                                lines.push({
-                                    text: result.html,
-                                    width: currentWidth,
-                                    fullWidth: currentWidth + (listMeta ? listMeta.textStartPx : 0),
-                                    listMeta,
-                                });
-                                openTags = result.openTags;
-                                currentTokens = [];
-                                showMarkerForLine = false;
-                                // Handle the current word on the new line
-                                currentLineDecoded = decodedWord;
-                                // Expand tabs for accurate width measurement
-                                const decodedWordExpanded = expandTabsToTabStops(decodedWord, 8);
-                                currentWidth = doc.widthOfString(decodedWordExpanded, props);
-                                currentTokens.push({
-                                    type: 'text',
-                                    content: rawWord,
-                                    decodedContent: decodedWord,
-                                });
-                            }
-                            else {
-                                // Case 2: Line is empty (start of line), but word is too big for line
-                                // Since we can wrap (have height), but the word itself is wider than line width,
-                                // we must split the word across lines.
-                                // The original logic for splitting word was inside "else if (currentLineDecoded.length === 0)" block
-                                // which is technically this else block if lines.length check was outside.
-                                const word = decodedWord;
-                                // logic for splitting word...
-                                let processedWord = '';
-                                let processedWidth = 0;
-                                for (const char of word) {
-                                    const testChunk = processedWord + char;
-                                    const testChunkExpanded = expandTabsToTabStops(testChunk, 8);
-                                    const testChunkWidth = doc.widthOfString(testChunkExpanded, props);
-                                    if (testChunkWidth > availableWidth) {
-                                        if (processedWord.length > 0 &&
-                                            lines.length < maxLines - 1) {
-                                            const chunkContent = encodeHtmlEntities(processedWord);
-                                            currentTokens.push({
-                                                type: 'text',
-                                                content: chunkContent,
-                                                decodedContent: processedWord,
-                                            });
-                                            const result = tokensToHTML(currentTokens, openTags);
-                                            const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-                                            lines.push({
-                                                text: result.html,
-                                                width: processedWidth,
-                                                fullWidth: processedWidth +
-                                                    (listMeta ? listMeta.textStartPx : 0),
-                                                listMeta,
-                                            });
-                                            openTags = result.openTags;
-                                            currentTokens = [];
-                                            showMarkerForLine = false;
-                                            processedWord = char;
-                                            processedWidth = doc.widthOfString(expandTabsToTabStops(char, 8), props);
-                                        }
-                                        else {
-                                            processedWord += char;
-                                            processedWidth = testChunkWidth;
-                                        }
-                                    }
-                                    else {
-                                        processedWord += char;
-                                        processedWidth = testChunkWidth;
-                                    }
-                                }
-                                currentLineDecoded = processedWord;
-                                currentWidth = processedWidth;
-                                const chunkContent = encodeHtmlEntities(processedWord);
-                                currentTokens.push({
-                                    type: 'text',
-                                    content: chunkContent,
-                                    decodedContent: processedWord,
-                                });
-                            }
-                        }
-                        else {
-                            // Cannot wrap anymore (max lines reached).
-                            // Append to current line regardless of width.
-                            if (currentLineDecoded.length > 0) {
-                                currentLineDecoded = testLineDecoded;
-                                currentWidth = testWidth;
-                                const rawContent = separator.length > 0 ? `${separator}${rawWord}` : rawWord;
-                                const decodedContent = separator.length > 0
-                                    ? `${separator}${decodedWord}`
-                                    : decodedWord;
-                                currentTokens.push({
-                                    type: 'text',
-                                    content: rawContent,
-                                    decodedContent: decodedContent,
-                                });
-                            }
-                            else {
-                                // Edge case: Start of line, can't wrap, but word is too big.
-                                // Since we can't wrap, we just force it in.
-                                currentLineDecoded = decodedWord;
-                                const decodedWordExpanded = expandTabsToTabStops(decodedWord, 8);
-                                currentWidth = doc.widthOfString(decodedWordExpanded, props);
-                                currentTokens.push({
-                                    type: 'text',
-                                    content: rawWord,
-                                    decodedContent: decodedWord,
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            // Add the last line
-            if (currentLineDecoded.length > 0) {
-                const result = tokensToHTML(currentTokens, openTags);
-                const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-                lines.push({
-                    text: result.html,
-                    width: currentWidth,
-                    fullWidth: currentWidth + (listMeta ? listMeta.textStartPx : 0),
-                    listMeta,
-                });
-            }
-            else if (currentTokens.length === 0) {
-                // Handle case when paragraph becomes empty after wrapping logic
-                const listMeta = cloneListMetaForLine(baseMeta, showMarkerForLine);
-                lines.push({
-                    text: '',
-                    width: 0,
-                    fullWidth: listMeta ? listMeta.textStartPx : 0,
-                    listMeta,
-                });
-            }
-        }
-    }
-    return lines;
-}
-export 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,
-    };
-}
-export 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;
-}
-export 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;
-        }
-    }
-}
-/**
- * Calculate X offset for list markers (not used for text content positioning)
- */
-export function calculateLineXOffset(element, line) {
-    // Markers are always at the left edge, regardless of text alignment
-    if (line.listMeta) {
-        return 0;
-    }
-    // For non-list lines, markers follow text alignment
-    const align = element.align;
-    const targetWidth = line.width;
-    if (align === 'right') {
-        return element.width - targetWidth;
-    }
-    else if (align === 'center') {
-        return (element.width - targetWidth) / 2;
-    }
-    // left or justify: markers at position 0
-    return 0;
-}
-export function calculateTextContentXOffset(element, line) {
-    const align = element.align;
-    const textWidth = line.width;
-    const baseStart = line.listMeta?.textStartPx ?? 0;
-    const availableWidth = Math.max(element.width - baseStart, 0);
-    if (align === 'right') {
-        return baseStart + Math.max(availableWidth - textWidth, 0);
-    }
-    else if (align === 'center') {
-        return baseStart + Math.max((availableWidth - textWidth) / 2, 0);
-    }
-    return baseStart;
-}
-/**
- * Calculate effective width for text rendering, considering justify and underline constraints
- */
-export function calculateEffectiveWidth(element, line, widthOption, hasUnderline) {
-    if (widthOption !== undefined) {
-        return widthOption;
-    }
-    if (hasUnderline) {
-        return element.width;
-    }
-    return undefined;
-}

package/lib/text/parser.d.ts

@@ -1,46 +0,0 @@
-import { TextElement, TextSegment, ListParagraphMeta } from './types.js';
-export declare function decodeHtmlEntities(text: string): string;
-/**
- * Normalize rich text HTML by converting block-level line breaks into newline characters
- * while preserving inline formatting tags.
- */
-export declare function normalizeRichText(text: string): string;
-/**
- * Parse HTML text into styled segments
- */
-export declare function parseHTMLToSegments(html: string, baseElement: TextElement): TextSegment[];
-/**
- * Represents a parsed HTML token (either text content or a tag)
- */
-export interface Token {
-    type: 'text' | 'tag';
-    content: string;
-    decodedContent?: string;
-    tagName?: string;
-    isClosing?: boolean;
-}
-/**
- * Parse HTML into tokens (text and tags)
- */
-export declare function tokenizeHTML(html: string): Token[];
-export interface ParagraphDefinition {
-    html: string;
-    listMeta?: ListParagraphMeta;
-}
-export declare function parseHtmlToParagraphs(html: string): ParagraphDefinition[];
-/**
- * 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
- */
-export declare function tokensToHTML(tokens: Token[], openTags: Array<{
-    name: string;
-    fullTag: string;
-}>): {
-    html: string;
-    openTags: Array<{
-        name: string;
-        fullTag: string;
-    }>;
-};