pdf-lite 1.4.0 → 1.5.0

package/dist/acroform/acroform.d.ts

@@ -2,8 +2,8 @@
  * Backward-compatible re-export shim.
  * All classes have been moved to dedicated modules.
  */
-export { PdfFormField as PdfAcroFormField } from './fields/PdfFormField.js';
-export { PdfAcroForm } from './PdfAcroForm.js';
-export type { PdfDefaultResourcesDictionary } from './PdfAcroForm.js';
+export { PdfFormField as PdfAcroFormField } from './fields/pdf-form-field.js';
+export { PdfAcroForm } from './pdf-acro-form.js';
+export type { PdfDefaultResourcesDictionary } from './pdf-acro-form.js';
 export { PdfFieldType } from './fields/types.js';
 export type { PdfAppearanceStreamDictionary } from '../annotations/index.js';

package/dist/acroform/acroform.js

@@ -2,6 +2,6 @@
  * Backward-compatible re-export shim.
  * All classes have been moved to dedicated modules.
  */
-export { PdfFormField as PdfAcroFormField } from './fields/PdfFormField.js';
-export { PdfAcroForm } from './PdfAcroForm.js';
+export { PdfFormField as PdfAcroFormField } from './fields/pdf-form-field.js';
+export { PdfAcroForm } from './pdf-acro-form.js';
 export { PdfFieldType } from './fields/types.js';

package/dist/acroform/appearance/index.d.ts

@@ -1,4 +1,4 @@
-export { PdfAppearanceStream } from './PdfAppearanceStream.js';
-export { PdfTextAppearanceStream } from './PdfTextAppearanceStream.js';
-export { PdfButtonAppearanceStream } from './PdfButtonAppearanceStream.js';
-export { PdfChoiceAppearanceStream } from './PdfChoiceAppearanceStream.js';
+export { PdfAppearanceStream } from './pdf-appearance-stream.js';
+export { PdfTextAppearanceStream } from './pdf-text-appearance-stream.js';
+export { PdfButtonAppearanceStream } from './pdf-button-appearance-stream.js';
+export { PdfChoiceAppearanceStream } from './pdf-choice-appearance-stream.js';

package/dist/acroform/appearance/index.js

@@ -1,4 +1,4 @@
-export { PdfAppearanceStream } from './PdfAppearanceStream.js';
-export { PdfTextAppearanceStream } from './PdfTextAppearanceStream.js';
-export { PdfButtonAppearanceStream } from './PdfButtonAppearanceStream.js';
-export { PdfChoiceAppearanceStream } from './PdfChoiceAppearanceStream.js';
+export { PdfAppearanceStream } from './pdf-appearance-stream.js';
+export { PdfTextAppearanceStream } from './pdf-text-appearance-stream.js';
+export { PdfButtonAppearanceStream } from './pdf-button-appearance-stream.js';
+export { PdfChoiceAppearanceStream } from './pdf-choice-appearance-stream.js';

package/dist/acroform/appearance/{PdfAppearanceStream.d.ts → pdf-appearance-stream.d.ts}

@@ -1,15 +1,21 @@
 import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
 import { PdfStream } from '../../core/objects/pdf-stream.js';
 import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
+import { PdfGraphics } from './pdf-graphics.js';
 /**
  * Base class for PDF appearance streams (Form XObjects).
  * Wraps a PdfStream as a PdfIndirectObject so it can be added directly to a document.
  */
 export declare class PdfAppearanceStream extends PdfIndirectObject<PdfStream> {
     constructor(options: {
-        width: number;
-        height: number;
-        contentStream: string;
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        contentStream?: string;
         resources?: PdfDictionary;
     });
+    get contentStream(): string;
+    set contentStream(newContent: string);
+    set graphics(g: PdfGraphics);
 }

package/dist/acroform/appearance/{PdfAppearanceStream.js → pdf-appearance-stream.js}

@@ -15,18 +15,27 @@ export class PdfAppearanceStream extends PdfIndirectObject {
         appearanceDict.set('Subtype', new PdfName('Form'));
         appearanceDict.set('FormType', new PdfNumber(1));
         appearanceDict.set('BBox', new PdfArray([
-            new PdfNumber(0),
-            new PdfNumber(0),
-            new PdfNumber(options.width),
-            new PdfNumber(options.height),
+            new PdfNumber(options.x ?? 0),
+            new PdfNumber(options.y ?? 0),
+            new PdfNumber(options.width ?? 100),
+            new PdfNumber(options.height ?? 100),
         ]));
         if (options.resources) {
             appearanceDict.set('Resources', options.resources);
         }
         const stream = new PdfStream({
             header: appearanceDict,
-            original: options.contentStream,
+            original: options.contentStream ?? '',
         });
         super({ content: stream });
     }
+    get contentStream() {
+        return this.content.rawAsString;
+    }
+    set contentStream(newContent) {
+        this.content.rawAsString = newContent;
+    }
+    set graphics(g) {
+        this.contentStream = g.build();
+    }
 }

package/dist/acroform/appearance/{PdfButtonAppearanceStream.d.ts → pdf-button-appearance-stream.d.ts}

@@ -1,4 +1,5 @@
-import { PdfAppearanceStream } from './PdfAppearanceStream.js';
+import { PdfAppearanceStream } from './pdf-appearance-stream.js';
+import { PdfFormFieldFlags } from '../fields/pdf-form-field-flags.js';
 /**
  * Appearance stream for button fields (checkboxes, radio buttons).
  */
@@ -8,5 +9,5 @@ export declare class PdfButtonAppearanceStream extends PdfAppearanceStream {
         height: number;
         contentStream: string;
     });
-    static buildYesContent(width: number, height: number, flags: number): string;
+    static buildYesContent(width: number, height: number, flags: number | PdfFormFieldFlags): string;
 }

package/dist/acroform/appearance/pdf-button-appearance-stream.js

@@ -0,0 +1,54 @@
+import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import { PdfAppearanceStream } from './pdf-appearance-stream.js';
+import { PdfGraphics } from './pdf-graphics.js';
+import { PdfFont } from '../../fonts/pdf-font.js';
+import { PdfFormFieldFlags } from '../fields/pdf-form-field-flags.js';
+/**
+ * Appearance stream for button fields (checkboxes, radio buttons).
+ */
+export class PdfButtonAppearanceStream extends PdfAppearanceStream {
+    constructor(ctx) {
+        const resources = new PdfDictionary();
+        const fonts = new PdfDictionary();
+        fonts.set('ZaDb', PdfFont.ZAPF_DINGBATS);
+        resources.set('Font', fonts);
+        super({
+            width: ctx.width,
+            height: ctx.height,
+            contentStream: ctx.contentStream,
+            resources,
+        });
+    }
+    static buildYesContent(width, height, flags) {
+        const size = Math.min(width, height);
+        const isRadio = new PdfFormFieldFlags(flags).radio;
+        const g = new PdfGraphics();
+        if (isRadio) {
+            const center = size / 2;
+            const radius = size * 0.35;
+            const k = 0.5522847498;
+            const kRadius = k * radius;
+            g.save();
+            g.setFillRGB(0, 0, 0);
+            g.movePath(center, center + radius);
+            g.curveTo(center + kRadius, center + radius, center + radius, center + kRadius, center + radius, center);
+            g.curveTo(center + radius, center - kRadius, center + kRadius, center - radius, center, center - radius);
+            g.curveTo(center - kRadius, center - radius, center - radius, center - kRadius, center - radius, center);
+            g.curveTo(center - radius, center + kRadius, center - kRadius, center + radius, center, center + radius);
+            g.fill();
+            g.restore();
+        }
+        else {
+            const checkSize = size * 0.8;
+            const offset = (size - checkSize) / 2;
+            g.save();
+            g.beginText();
+            g.setFont('ZaDb', checkSize);
+            g.moveTo(offset, offset);
+            g.showLiteralText('4'); // Checkmark character in Zapf Dingbats
+            g.endText();
+            g.restore();
+        }
+        return g.build();
+    }
+}

package/dist/acroform/appearance/pdf-choice-appearance-stream.d.ts

@@ -0,0 +1,22 @@
+import { PdfDefaultAppearance } from '../fields/pdf-default-appearance.js';
+import { PdfAppearanceStream } from './pdf-appearance-stream.js';
+import type { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import type { PdfFont } from '../../fonts/pdf-font.js';
+import { PdfFormFieldFlags } from '../fields/pdf-form-field-flags.js';
+/**
+ * Appearance stream for choice fields (dropdowns, list boxes).
+ */
+export declare class PdfChoiceAppearanceStream extends PdfAppearanceStream {
+    constructor(ctx: {
+        rect: [number, number, number, number];
+        value: string;
+        da: PdfDefaultAppearance;
+        flags: number | PdfFormFieldFlags;
+        fontResources?: PdfDictionary;
+        resolvedFonts?: Map<string, PdfFont>;
+        isUnicode?: boolean;
+        reverseEncodingMap?: Map<string, number>;
+        displayOptions?: string[];
+        selectedIndex?: number;
+    });
+}

package/dist/acroform/appearance/pdf-choice-appearance-stream.js

@@ -0,0 +1,75 @@
+import { PdfAppearanceStream } from './pdf-appearance-stream.js';
+import { PdfGraphics } from './pdf-graphics.js';
+import { PdfFormFieldFlags } from '../fields/pdf-form-field-flags.js';
+/**
+ * Appearance stream for choice fields (dropdowns, list boxes).
+ */
+export class PdfChoiceAppearanceStream extends PdfAppearanceStream {
+    constructor(ctx) {
+        const [x1, y1, x2, y2] = ctx.rect;
+        const width = x2 - x1;
+        const height = y2 - y1;
+        super({
+            width,
+            height,
+            resources: ctx.fontResources,
+        });
+        const isUnicode = ctx.isUnicode ?? false;
+        const reverseEncodingMap = ctx.reverseEncodingMap;
+        const padding = 2;
+        const isCombo = new PdfFormFieldFlags(ctx.flags).combo;
+        const g = new PdfGraphics({ resolvedFonts: ctx.resolvedFonts });
+        g.beginMarkedContent();
+        g.save();
+        if (!isCombo && ctx.displayOptions && ctx.displayOptions.length > 0) {
+            // Listbox: render all items, highlight the selected one
+            const lineHeight = ctx.da.fontSize + 4;
+            const selectedIndex = ctx.selectedIndex ?? -1;
+            for (let i = 0; i < ctx.displayOptions.length; i++) {
+                const itemY = height - (i + 1) * lineHeight;
+                // Stop rendering if we've gone below the visible area
+                if (itemY + lineHeight < 0)
+                    break;
+                if (i === selectedIndex) {
+                    // Draw highlight background using the PDF re (rectangle) operator
+                    g.save();
+                    g.setFillRGB(0.376, 0.62, 0.671);
+                    g.raw(`0 ${itemY} ${width} ${lineHeight} re`);
+                    g.fill();
+                    g.restore();
+                }
+                const textY = itemY + lineHeight * 0.25;
+                g.beginText();
+                g.setDefaultAppearance(ctx.da);
+                g.moveTo(padding, textY);
+                g.showText(ctx.displayOptions[i], isUnicode, reverseEncodingMap);
+                g.endText();
+            }
+        }
+        else {
+            // Combo (dropdown) or no options: show selected value only
+            const textY = (height - ctx.da.fontSize) / 2 + ctx.da.fontSize * 0.2;
+            g.beginText();
+            g.setDefaultAppearance(ctx.da);
+            g.moveTo(padding, textY);
+            g.showText(ctx.value, isUnicode, reverseEncodingMap);
+            g.endText();
+            if (isCombo) {
+                const arrowWidth = height * 0.8;
+                const arrowX = width - arrowWidth - 2;
+                const arrowY = height / 2;
+                const arrowSize = height * 0.3;
+                g.save();
+                g.setFillGray(0.5);
+                g.movePath(arrowX + arrowWidth / 2, arrowY - arrowSize / 3);
+                g.lineTo(arrowX + arrowWidth / 2 - arrowSize / 2, arrowY + arrowSize / 3);
+                g.lineTo(arrowX + arrowWidth / 2 + arrowSize / 2, arrowY + arrowSize / 3);
+                g.fill();
+                g.restore();
+            }
+        }
+        g.restore();
+        g.endMarkedContent();
+        this.graphics = g;
+    }
+}

package/dist/acroform/appearance/pdf-graphics.d.ts

@@ -0,0 +1,51 @@
+import type { PdfDefaultAppearance } from '../fields/pdf-default-appearance.js';
+import { PdfFont } from '../../fonts/pdf-font.js';
+/**
+ * Lightweight builder for PDF content streams.
+ * Chains PDF operators via a fluent API and emits the final stream with build().
+ * Enhanced with text measurement capabilities for layout calculations.
+ */
+export declare class PdfGraphics {
+    private lines;
+    private resolvedFonts?;
+    private defaultAppearance?;
+    constructor(options?: {
+        resolvedFonts?: Map<string, PdfFont>;
+        defaultAppearance?: PdfDefaultAppearance;
+    });
+    save(): this;
+    restore(): this;
+    beginText(): this;
+    endText(): this;
+    setDefaultAppearance(da: PdfDefaultAppearance): this;
+    moveTo(x: number, y: number): this;
+    showText(text: string, isUnicode: boolean, reverseEncodingMap?: Map<string, number>): this;
+    showLiteralText(text: string): this;
+    beginMarkedContent(): this;
+    endMarkedContent(): this;
+    raw(op: string): this;
+    setFillRGB(r: number, g: number, b: number): this;
+    setFillGray(v: number): this;
+    setFont(name: string, size: number): this;
+    movePath(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    curveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): this;
+    fill(): this;
+    stroke(): this;
+    closePath(): this;
+    build(): string;
+    private get currentFont();
+    /**
+     * Calculate the width of text using the current font and size.
+     */
+    measureTextWidth(text: string, fontSize?: number): number;
+    /**
+     * Wrap text to fit within the specified width, breaking at word boundaries.
+     */
+    wrapTextToLines(text: string, maxWidth: number, fontSize?: number): string[];
+    /**
+     * Calculate the minimum font size needed to fit text within given constraints.
+     */
+    calculateFittingFontSize(text: string, maxWidth: number, maxHeight?: number, lineHeight?: number): number;
+    private breakLongWord;
+}

package/dist/acroform/appearance/pdf-graphics.js

@@ -0,0 +1,239 @@
+import { encodePdfText } from '../../utils/encodePdfText.js';
+import { PdfFont } from '../../fonts/pdf-font.js';
+/**
+ * Lightweight builder for PDF content streams.
+ * Chains PDF operators via a fluent API and emits the final stream with build().
+ * Enhanced with text measurement capabilities for layout calculations.
+ */
+export class PdfGraphics {
+    lines = [];
+    resolvedFonts;
+    defaultAppearance;
+    constructor(options) {
+        this.resolvedFonts = options?.resolvedFonts;
+        this.defaultAppearance = options?.defaultAppearance;
+    }
+    save() {
+        this.lines.push('q');
+        return this;
+    }
+    restore() {
+        this.lines.push('Q');
+        return this;
+    }
+    beginText() {
+        this.lines.push('BT');
+        return this;
+    }
+    endText() {
+        this.lines.push('ET');
+        return this;
+    }
+    setDefaultAppearance(da) {
+        this.lines.push(da.toString());
+        this.defaultAppearance = da;
+        return this;
+    }
+    moveTo(x, y) {
+        this.lines.push(`${x} ${y} Td`);
+        return this;
+    }
+    showText(text, isUnicode, reverseEncodingMap) {
+        this.lines.push(`${encodePdfText(text, isUnicode, reverseEncodingMap)} Tj`);
+        return this;
+    }
+    showLiteralText(text) {
+        this.lines.push(`(${text}) Tj`);
+        return this;
+    }
+    beginMarkedContent() {
+        this.lines.push('/Tx BMC');
+        return this;
+    }
+    endMarkedContent() {
+        this.lines.push('EMC');
+        return this;
+    }
+    raw(op) {
+        this.lines.push(op);
+        return this;
+    }
+    setFillRGB(r, g, b) {
+        this.lines.push(`${r} ${g} ${b} rg`);
+        return this;
+    }
+    setFillGray(v) {
+        this.lines.push(`${v} g`);
+        return this;
+    }
+    setFont(name, size) {
+        this.lines.push(`/${name} ${size} Tf`);
+        return this;
+    }
+    movePath(x, y) {
+        this.lines.push(`${x} ${y} m`);
+        return this;
+    }
+    lineTo(x, y) {
+        this.lines.push(`${x} ${y} l`);
+        return this;
+    }
+    curveTo(x1, y1, x2, y2, x3, y3) {
+        this.lines.push(`${x1} ${y1} ${x2} ${y2} ${x3} ${y3} c`);
+        return this;
+    }
+    fill() {
+        this.lines.push('f');
+        return this;
+    }
+    stroke() {
+        this.lines.push('S');
+        return this;
+    }
+    closePath() {
+        this.lines.push('h');
+        return this;
+    }
+    build() {
+        return this.lines.join('\n') + '\n';
+    }
+    get currentFont() {
+        if (!this.defaultAppearance) {
+            return null;
+        }
+        const fontName = this.defaultAppearance.fontName;
+        const size = this.defaultAppearance.fontSize;
+        const fontObject = this.resolvedFonts?.get(fontName);
+        return { fontObject, size };
+    }
+    /**
+     * Calculate the width of text using the current font and size.
+     */
+    measureTextWidth(text, fontSize) {
+        if (!this.currentFont) {
+            throw new Error('No font set - call setDefaultAppearance() first');
+        }
+        const { fontObject, size: currentSize } = this.currentFont;
+        const size = fontSize ?? currentSize;
+        const fontName = this.defaultAppearance.fontName;
+        const effectiveFontObject = fontObject ?? PdfFont.getStandardFont(fontName);
+        if (effectiveFontObject?.widths &&
+            effectiveFontObject.firstChar !== undefined) {
+            let width = 0;
+            for (const char of text) {
+                const charCode = char.charCodeAt(0);
+                const charWidth = effectiveFontObject.getCharacterWidth(charCode, size);
+                if (charWidth !== null) {
+                    width += charWidth;
+                }
+                else {
+                    width += size * 0.6;
+                }
+            }
+            return width;
+        }
+        // Unknown font — use Helvetica as best-effort approximation
+        let width = 0;
+        for (const char of text) {
+            const charWidth = PdfFont.HELVETICA.getCharacterWidth(char.charCodeAt(0), size);
+            width += charWidth !== null ? charWidth : size * 0.6;
+        }
+        return width;
+    }
+    /**
+     * Wrap text to fit within the specified width, breaking at word boundaries.
+     */
+    wrapTextToLines(text, maxWidth, fontSize) {
+        if (!this.currentFont) {
+            throw new Error('No font set - call setDefaultAppearance() first');
+        }
+        // Handle explicit line breaks first
+        const paragraphs = text.split('\n');
+        const wrappedLines = [];
+        for (const paragraph of paragraphs) {
+            if (this.measureTextWidth(paragraph, fontSize) <= maxWidth) {
+                wrappedLines.push(paragraph);
+                continue;
+            }
+            // Word wrapping needed
+            const words = paragraph.split(' ');
+            let currentLine = '';
+            for (const word of words) {
+                const testLine = currentLine ? `${currentLine} ${word}` : word;
+                if (this.measureTextWidth(testLine, fontSize) <= maxWidth) {
+                    currentLine = testLine;
+                }
+                else {
+                    if (currentLine) {
+                        wrappedLines.push(currentLine);
+                        currentLine = word;
+                    }
+                    else {
+                        // Single word is too long, break it
+                        const brokenLines = this.breakLongWord(word, maxWidth, fontSize);
+                        wrappedLines.push(...brokenLines.slice(0, -1));
+                        currentLine = brokenLines[brokenLines.length - 1];
+                    }
+                }
+            }
+            if (currentLine) {
+                wrappedLines.push(currentLine);
+            }
+        }
+        return wrappedLines;
+    }
+    /**
+     * Calculate the minimum font size needed to fit text within given constraints.
+     */
+    calculateFittingFontSize(text, maxWidth, maxHeight, lineHeight = 1.2) {
+        if (!this.currentFont) {
+            throw new Error('No font set - call setDefaultAppearance() first');
+        }
+        const startSize = this.currentFont.size;
+        const minSize = 0.5;
+        const fits = (size) => {
+            if (this.measureTextWidth(text, size) > maxWidth)
+                return false;
+            if (maxHeight !== undefined) {
+                const lines = this.wrapTextToLines(text, maxWidth, size);
+                return lines.length * size * lineHeight <= maxHeight;
+            }
+            return true;
+        };
+        if (fits(startSize))
+            return startSize;
+        if (!fits(minSize))
+            return minSize;
+        // Binary search on 0.5pt grid: lo fits, hi does not
+        let lo = minSize;
+        let hi = startSize;
+        while (hi - lo > 0.5) {
+            const mid = Math.round((lo + hi) / 2 / 0.5) * 0.5;
+            if (fits(mid))
+                lo = mid;
+            else
+                hi = mid;
+        }
+        return lo;
+    }
+    breakLongWord(word, maxWidth, fontSize) {
+        const lines = [];
+        let currentLine = '';
+        for (const char of word) {
+            const testLine = currentLine + char;
+            if (this.measureTextWidth(testLine, fontSize) <= maxWidth) {
+                currentLine = testLine;
+            }
+            else {
+                if (currentLine) {
+                    lines.push(currentLine);
+                }
+                currentLine = char;
+            }
+        }
+        if (currentLine) {
+            lines.push(currentLine);
+        }
+        return lines.length > 0 ? lines : [word];
+    }
+}

package/dist/acroform/appearance/{PdfTextAppearanceStream.d.ts → pdf-text-appearance-stream.d.ts}

@@ -1,8 +1,10 @@
-import { PdfDefaultAppearance } from '../fields/PdfDefaultAppearance.js';
-import { PdfAppearanceStream } from './PdfAppearanceStream.js';
+import { PdfDefaultAppearance } from '../fields/pdf-default-appearance.js';
+import { PdfAppearanceStream } from './pdf-appearance-stream.js';
 import type { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import type { PdfFont } from '../../fonts/pdf-font.js';
 /**
  * Appearance stream for text fields (single-line, multiline, comb).
+ * Enhanced with word wrapping and automatic font scaling.
  */
 export declare class PdfTextAppearanceStream extends PdfAppearanceStream {
     constructor(ctx: {
@@ -13,5 +15,8 @@ export declare class PdfTextAppearanceStream extends PdfAppearanceStream {
         comb: boolean;
         maxLen: number | null;
         fontResources?: PdfDictionary;
+        resolvedFonts?: Map<string, PdfFont>;
+        isUnicode?: boolean;
+        reverseEncodingMap?: Map<string, number>;
     });
 }