@polotno/pdf-export 0.1.37 → 0.1.39

package/lib/text/render.js

@@ -1,237 +0,0 @@
-import { stripHtml } from 'string-strip-html';
-import { parseColor } from '../utils.js';
-import { calculateLineXOffset, calculateTextContentXOffset, calculateEffectiveWidth, buildRenderSegmentsForLine, } from './layout.js';
-import { loadFontForSegment } from './fonts.js';
-export async function drawListMarker(doc, element, line, lineXOffset, lineYOffset, fonts, color, opacity, mode, textOptions) {
-    if (!line.listMeta || !line.listMeta.showMarker) {
-        return;
-    }
-    const markerSegment = {
-        text: line.listMeta.markerText,
-    };
-    const fontKey = await loadFontForSegment(doc, markerSegment, element, fonts);
-    const previousFontSize = doc._fontSize !== undefined
-        ? doc._fontSize
-        : element.fontSize;
-    doc.font(fontKey);
-    doc.fontSize(line.listMeta.markerFontSize);
-    if (mode === 'fill') {
-        doc.fillColor(color, opacity);
-    }
-    else {
-        doc.strokeColor(color, opacity);
-    }
-    doc.text(line.listMeta.markerText, lineXOffset + line.listMeta.indentPx, lineYOffset, {
-        ...textOptions,
-        width: line.listMeta.markerBoxWidth,
-        align: line.listMeta.markerAlignment,
-        continued: false,
-        lineBreak: false,
-        underline: false,
-        characterSpacing: 0,
-        stroke: mode === 'stroke',
-        fill: mode === 'fill',
-    });
-    doc.fontSize(previousFontSize);
-}
-export async function prepareLineForRendering(doc, element, line, lineIndex, yOffset, lineHeightPx, cumulativeYOffset, textOptions, fonts, markerColor, markerOpacity, markerMode) {
-    const markerXOffset = calculateLineXOffset(element, line);
-    const lineYOffset = yOffset + cumulativeYOffset;
-    const strippedLineText = stripHtml(line.text).result;
-    const heightOfLine = line.text === ''
-        ? lineHeightPx
-        : doc.heightOfString(strippedLineText, textOptions);
-    const contentStartX = calculateTextContentXOffset(element, line);
-    const isJustify = element.align === 'justify';
-    // Disable justification if line contains tabs - tabs position content precisely,
-    // and justification would interfere by spreading spaces
-    const hasTabs = line.text.includes('\t');
-    const widthOption = isJustify && !hasTabs
-        ? Math.max(element.width - (line.listMeta ? line.listMeta.textStartPx : 0), 1)
-        : undefined;
-    // Handle list markers if needed
-    if (line.listMeta?.showMarker) {
-        await drawListMarker(doc, element, line, markerXOffset, lineYOffset, fonts, markerColor, markerOpacity, markerMode, textOptions);
-        // Restore color after drawing marker (marker may have changed the color state)
-        if (markerMode === 'fill') {
-            doc.fillColor(markerColor, markerOpacity);
-        }
-        else {
-            doc.strokeColor(markerColor, markerOpacity);
-        }
-    }
-    return {
-        markerXOffset,
-        lineYOffset,
-        contentStartX,
-        widthOption,
-        heightOfLine,
-    };
-}
-export async function renderSegmentsForLine(doc, element, line, renderSegments, context, textOptions, options) {
-    const { mode, color, opacity = element.opacity, heightOfLine, offsetX = 0, offsetY = 0, applySegmentColor, } = options;
-    const totalTextSegments = renderSegments.filter((seg) => seg.type === 'text').length;
-    let processedTextSegments = 0;
-    // Position cursor at line start (with optional offset)
-    doc.x = context.contentStartX + offsetX;
-    doc.y = context.lineYOffset + offsetY;
-    for (const renderSegment of renderSegments) {
-        if (renderSegment.type === 'tab') {
-            const advanceWidth = renderSegment.advanceWidth ?? 0;
-            doc.x = context.contentStartX + advanceWidth + offsetX;
-            continue;
-        }
-        const { segment, text = '', wordSpacing = 0, fontKey } = renderSegment;
-        processedTextSegments += 1;
-        const isLastSegment = processedTextSegments === totalTextSegments;
-        doc.font(fontKey);
-        doc.fontSize(element.fontSize);
-        // Apply color (either segment-specific or global)
-        if (applySegmentColor) {
-            applySegmentColor(segment);
-        }
-        else if (color) {
-            if (mode === 'fill') {
-                doc.fillColor(color, opacity);
-            }
-            else {
-                doc.strokeColor(color, opacity);
-            }
-        }
-        const hasUnderline = segment.underline || textOptions.underline || false;
-        const effectiveWidth = calculateEffectiveWidth(element, line, context.widthOption, hasUnderline);
-        doc.text(text, {
-            ...textOptions,
-            width: effectiveWidth,
-            height: heightOfLine,
-            continued: !isLastSegment,
-            underline: hasUnderline,
-            lineBreak: hasUnderline,
-            stroke: mode === 'stroke',
-            fill: mode === 'fill',
-            wordSpacing,
-        });
-    }
-}
-export async function renderPDFX1aStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts) {
-    const strokeColor = parseColor(element.stroke).hex;
-    const strokeWidth = element.strokeWidth;
-    // Generate stroke offsets in a circle pattern (8 directions)
-    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 context = await prepareLineForRendering(doc, element, line, i, yOffset, lineHeightPx, i * lineHeightPx, textOptions, fonts, strokeColor, element.opacity, 'fill');
-        const renderSegments = await buildRenderSegmentsForLine(doc, element, line.text, textOptions, fonts);
-        // Render with each offset to create stroke effect
-        for (const offset of offsets) {
-            doc.text('', context.contentStartX + offset.x, context.lineYOffset + offset.y, {
-                height: 0,
-                width: 0,
-            });
-            await renderSegmentsForLine(doc, element, line, renderSegments, context, textOptions, {
-                mode: 'fill',
-                color: strokeColor,
-                opacity: element.opacity,
-                offsetX: offset.x,
-                offsetY: offset.y,
-            });
-        }
-    }
-    doc.restore();
-    await renderTextFill(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts);
-}
-export async function renderStandardStroke(doc, element, textLines, yOffset, lineHeightPx, textOptions, fonts) {
-    const strokeParsedColor = parseColor(element.stroke);
-    doc.save();
-    doc.lineWidth(element.strokeWidth);
-    doc.lineCap('round').lineJoin('round');
-    doc.strokeColor(strokeParsedColor.hex, element.opacity);
-    let cumulativeYOffset = 0;
-    for (let i = 0; i < textLines.length; i++) {
-        const line = textLines[i];
-        const context = await prepareLineForRendering(doc, element, line, i, yOffset, lineHeightPx, cumulativeYOffset, textOptions, fonts, strokeParsedColor.hex, element.opacity, 'stroke');
-        cumulativeYOffset += context.heightOfLine;
-        const renderSegments = await buildRenderSegmentsForLine(doc, element, line.text, textOptions, fonts);
-        await renderSegmentsForLine(doc, element, line, renderSegments, context, textOptions, {
-            mode: 'stroke',
-            color: strokeParsedColor.hex,
-            opacity: element.opacity,
-            heightOfLine: context.heightOfLine,
-        });
-    }
-    doc.restore();
-}
-export 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);
-    let cumulativeYOffset = 0;
-    for (let i = 0; i < textLines.length; i++) {
-        const line = textLines[i];
-        const context = await prepareLineForRendering(doc, element, line, i, yOffset, lineHeightPx, cumulativeYOffset, textOptions, fonts, baseParsedColor.hex, baseOpacity, 'fill');
-        cumulativeYOffset += context.heightOfLine;
-        const renderSegments = await buildRenderSegmentsForLine(doc, element, line.text, textOptions, fonts);
-        // Apply segment-specific colors for rich text
-        const applySegmentColor = (segment) => {
-            const segmentParsedColor = segment.color
-                ? parseColor(segment.color)
-                : parseColor(element.fill);
-            // Fallback to element fill if segment color parsing fails
-            const segmentColor = segmentParsedColor?.hex || parseColor(element.fill).hex || '#000000';
-            // Segment alpha can be NaN (e.g. rgba(..., var(--x, 1))) -> fallback to 1
-            const a = segmentParsedColor?.rgba?.[3];
-            const segmentOpacity = Math.min(typeof a === 'number' && a >= 0 && a <= 1 ? a : 1, element.opacity, 1);
-            doc.fillColor(segmentColor, segmentOpacity);
-        };
-        await renderSegmentsForLine(doc, element, line, renderSegments, context, textOptions, {
-            mode: 'fill',
-            heightOfLine: context.heightOfLine,
-            applySegmentColor,
-        });
-    }
-}
-export 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);
-}

package/lib/text/types.d.ts

@@ -1,91 +0,0 @@
-export interface TextElement {
-    fontFamily: string;
-    fontWeight?: string;
-    fontSize: number;
-    fontStyle?: string;
-    fill: string;
-    opacity: number;
-    strokeWidth: number;
-    stroke?: string;
-    align: string;
-    textDecoration: string;
-    letterSpacing?: number;
-    lineHeight: number;
-    text: string;
-    width: number;
-    height: number;
-    verticalAlign?: string;
-    backgroundEnabled?: boolean;
-    backgroundPadding?: number;
-    backgroundCornerRadius?: number;
-    backgroundColor?: string;
-}
-export interface RenderAttrs {
-    pdfx1a?: boolean;
-    textVerticalResizeEnabled?: boolean;
-}
-export interface TextSegment {
-    text: string;
-    bold?: boolean;
-    italic?: boolean;
-    underline?: boolean;
-    color?: string;
-}
-export interface TabExpansionSegment {
-    type: 'text' | 'tab';
-    text?: string;
-    wordSpacing?: number;
-    advanceWidth?: number;
-}
-export interface RenderSegment {
-    segment: TextSegment;
-    fontKey: string;
-    type: 'text' | 'tab';
-    text?: string;
-    wordSpacing?: number;
-    advanceWidth?: number;
-}
-export interface ListParagraphMeta {
-    type: 'ul' | 'ol';
-    index: number;
-    indentLevel: number;
-    displayMarker: boolean;
-}
-export interface ListLineMeta {
-    type: 'ul' | 'ol';
-    markerText: string;
-    indentPx: number;
-    markerBoxWidth: number;
-    markerFontSize: number;
-    markerAlignment: 'center' | 'right';
-    showMarker: boolean;
-    textStartPx: number;
-}
-export interface TextLine {
-    text: string;
-    width: number;
-    fullWidth: number;
-    listMeta?: ListLineMeta;
-}
-export interface LineRenderContext {
-    markerXOffset: number;
-    lineYOffset: number;
-    contentStartX: number;
-    widthOption: number | undefined;
-    heightOfLine: number;
-}
-export interface SegmentRenderOptions {
-    mode: 'fill' | 'stroke';
-    color?: string;
-    opacity?: number;
-    heightOfLine?: number;
-    offsetX?: number;
-    offsetY?: number;
-    applySegmentColor?: (segment: TextSegment) => void;
-}
-export interface TextMetrics {
-    textOptions: PDFKit.Mixins.TextOptions;
-    lineHeightPx: number;
-    baselineOffset: number;
-    textLines: TextLine[];
-}

package/lib/text/types.js

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

package/lib/text.d.ts

@@ -1,49 +0,0 @@
-export interface TextElement {
-    fontFamily: string;
-    fontWeight?: string;
-    fontSize: number;
-    fontStyle?: string;
-    fill: string;
-    opacity: number;
-    strokeWidth: number;
-    stroke?: string;
-    align: string;
-    textDecoration: string;
-    letterSpacing?: number;
-    lineHeight: number;
-    text: string;
-    width: number;
-    height: number;
-    verticalAlign?: string;
-    backgroundEnabled?: boolean;
-    backgroundPadding?: number;
-    backgroundCornerRadius?: number;
-    backgroundColor?: string;
-}
-export interface RenderAttrs {
-    pdfx1a?: boolean;
-    textVerticalResizeEnabled?: boolean;
-}
-export interface TextSegment {
-    text: string;
-    bold?: boolean;
-    italic?: boolean;
-    underline?: boolean;
-    color?: string;
-}
-/**
- * Normalize rich text HTML by converting block-level line breaks into newline characters
- * while preserving inline formatting tags.
- */
-declare function normalizeRichText(text: string): string;
-/**
- * Parse HTML text into styled segments
- */
-declare function parseHTMLToSegments(html: string, baseElement: TextElement): TextSegment[];
-export declare function getGoogleFontPath(fontFamily: string, fontWeight?: string, italic?: boolean): Promise<string>;
-export declare function loadFontIfNeeded(doc: any, element: TextElement, fonts: Record<string, boolean>): Promise<string>;
-/**
- * Main text rendering function
- */
-export declare function renderText(doc: PDFKit.PDFDocument, element: TextElement, fonts: Record<string, boolean>, attrs?: RenderAttrs): Promise<void>;
-export { normalizeRichText as __normalizeRichTextForTests, parseHTMLToSegments as __parseHTMLToSegmentsForTests, };