pdf-lite 1.3.3 → 1.4.0

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

@@ -0,0 +1,15 @@
+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';
+/**
+ * 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;
+        resources?: PdfDictionary;
+    });
+}

package/dist/acroform/appearance/PdfAppearanceStream.js

@@ -0,0 +1,32 @@
+import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../../core/objects/pdf-array.js';
+import { PdfName } from '../../core/objects/pdf-name.js';
+import { PdfNumber } from '../../core/objects/pdf-number.js';
+import { PdfStream } from '../../core/objects/pdf-stream.js';
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.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 class PdfAppearanceStream extends PdfIndirectObject {
+    constructor(options) {
+        const appearanceDict = new PdfDictionary();
+        appearanceDict.set('Type', new PdfName('XObject'));
+        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),
+        ]));
+        if (options.resources) {
+            appearanceDict.set('Resources', options.resources);
+        }
+        const stream = new PdfStream({
+            header: appearanceDict,
+            original: options.contentStream,
+        });
+        super({ content: stream });
+    }
+}

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

@@ -0,0 +1,12 @@
+import { PdfAppearanceStream } from './PdfAppearanceStream.js';
+/**
+ * Appearance stream for button fields (checkboxes, radio buttons).
+ */
+export declare class PdfButtonAppearanceStream extends PdfAppearanceStream {
+    constructor(ctx: {
+        width: number;
+        height: number;
+        contentStream: string;
+    });
+    static buildYesContent(width: number, height: number, flags: number): string;
+}

package/dist/acroform/appearance/PdfButtonAppearanceStream.js

@@ -0,0 +1,54 @@
+import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import { PdfName } from '../../core/objects/pdf-name.js';
+import { PdfAppearanceStream } from './PdfAppearanceStream.js';
+/**
+ * Appearance stream for button fields (checkboxes, radio buttons).
+ */
+export class PdfButtonAppearanceStream extends PdfAppearanceStream {
+    constructor(ctx) {
+        const resources = new PdfDictionary();
+        const fonts = new PdfDictionary();
+        const zapfFont = new PdfDictionary();
+        zapfFont.set('Type', new PdfName('Font'));
+        zapfFont.set('Subtype', new PdfName('Type1'));
+        zapfFont.set('BaseFont', new PdfName('ZapfDingbats'));
+        fonts.set('ZaDb', zapfFont);
+        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 = (flags & 32768) !== 0;
+        if (isRadio) {
+            const center = size / 2;
+            const radius = size * 0.35;
+            const k = 0.5522847498;
+            const kRadius = k * radius;
+            return `q
+0 0 0 rg
+${center} ${center + radius} m
+${center + kRadius} ${center + radius} ${center + radius} ${center + kRadius} ${center + radius} ${center} c
+${center + radius} ${center - kRadius} ${center + kRadius} ${center - radius} ${center} ${center - radius} c
+${center - kRadius} ${center - radius} ${center - radius} ${center - kRadius} ${center - radius} ${center} c
+${center - radius} ${center + kRadius} ${center - kRadius} ${center + radius} ${center} ${center + radius} c
+f
+Q
+`;
+        }
+        const checkSize = size * 0.8;
+        const offset = (size - checkSize) / 2;
+        return `q
+BT
+/ZaDb ${checkSize} Tf
+${offset} ${offset} Td
+(4) Tj
+ET
+Q
+`;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { PdfDefaultAppearance } from '../fields/PdfDefaultAppearance.js';
+import { PdfAppearanceStream } from './PdfAppearanceStream.js';
+import type { PdfDictionary } from '../../core/objects/pdf-dictionary.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;
+        fontResources?: PdfDictionary;
+    });
+}

package/dist/acroform/appearance/PdfChoiceAppearanceStream.js

@@ -0,0 +1,48 @@
+import { PdfAppearanceStream } from './PdfAppearanceStream.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;
+        const colorOp = '0 g';
+        const reconstructedDA = `/${ctx.da.fontName} ${ctx.da.fontSize} Tf ${colorOp}`;
+        const padding = 2;
+        const textY = (height - ctx.da.fontSize) / 2 + ctx.da.fontSize * 0.2;
+        const textX = padding;
+        const escapedValue = ctx.value
+            .replace(/\\/g, '\\\\')
+            .replace(/\(/g, '\\(')
+            .replace(/\)/g, '\\)');
+        const isCombo = (ctx.flags & 131072) !== 0;
+        let arrowGraphics = '';
+        if (isCombo) {
+            const arrowWidth = height * 0.8;
+            const arrowX = width - arrowWidth - 2;
+            const arrowY = height / 2;
+            const arrowSize = height * 0.3;
+            arrowGraphics = `
+q
+0.5 0.5 0.5 rg
+${arrowX + arrowWidth / 2} ${arrowY - arrowSize / 3} m
+${arrowX + arrowWidth / 2 - arrowSize / 2} ${arrowY + arrowSize / 3} l
+${arrowX + arrowWidth / 2 + arrowSize / 2} ${arrowY + arrowSize / 3} l
+f
+Q
+`;
+        }
+        const contentStream = `/Tx BMC
+q
+BT
+${reconstructedDA}
+${textX} ${textY} Td
+(${escapedValue}) Tj
+ET
+${arrowGraphics}Q
+EMC
+`;
+        super({ width, height, contentStream, resources: ctx.fontResources });
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PdfDefaultAppearance } from '../fields/PdfDefaultAppearance.js';
+import { PdfAppearanceStream } from './PdfAppearanceStream.js';
+import type { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+/**
+ * Appearance stream for text fields (single-line, multiline, comb).
+ */
+export declare class PdfTextAppearanceStream extends PdfAppearanceStream {
+    constructor(ctx: {
+        rect: [number, number, number, number];
+        value: string;
+        da: PdfDefaultAppearance;
+        multiline: boolean;
+        comb: boolean;
+        maxLen: number | null;
+        fontResources?: PdfDictionary;
+    });
+}

package/dist/acroform/appearance/PdfTextAppearanceStream.js

@@ -0,0 +1,75 @@
+import { PdfAppearanceStream } from './PdfAppearanceStream.js';
+/**
+ * Appearance stream for text fields (single-line, multiline, comb).
+ */
+export class PdfTextAppearanceStream extends PdfAppearanceStream {
+    constructor(ctx) {
+        const [x1, y1, x2, y2] = ctx.rect;
+        const width = x2 - x1;
+        const height = y2 - y1;
+        const value = ctx.value;
+        const reconstructedDA = ctx.da.toString();
+        const fontSize = ctx.da.fontSize;
+        const padding = 2;
+        const textY = (height - fontSize) / 2 + fontSize * 0.2;
+        const escapedValue = value
+            .replace(/\\/g, '\\\\')
+            .replace(/\(/g, '\\(')
+            .replace(/\)/g, '\\)')
+            .replace(/\r/g, '\\r')
+            .replace(/\n/g, '\\n');
+        let textContent;
+        if (ctx.multiline) {
+            const lines = value.split('\n');
+            const lineHeight = fontSize * 1.2;
+            const startY = height - padding - fontSize;
+            textContent = 'BT\n';
+            textContent += `${reconstructedDA}\n`;
+            textContent += `${padding} ${startY} Td\n`;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i]
+                    .replace(/\\/g, '\\\\')
+                    .replace(/\(/g, '\\(')
+                    .replace(/\)/g, '\\)')
+                    .replace(/\r/g, '');
+                if (i > 0) {
+                    textContent += `0 ${-lineHeight} Td\n`;
+                }
+                textContent += `(${line}) Tj\n`;
+            }
+            textContent += 'ET\n';
+        }
+        else if (ctx.comb && ctx.maxLen) {
+            const cellWidth = width / ctx.maxLen;
+            const chars = value.split('');
+            textContent = 'BT\n';
+            textContent += `${reconstructedDA}\n`;
+            for (let i = 0; i < chars.length && i < ctx.maxLen; i++) {
+                const cellX = cellWidth * i + cellWidth / 2 - fontSize * 0.3;
+                const escapedChar = chars[i]
+                    .replace(/\\/g, '\\\\')
+                    .replace(/\(/g, '\\(')
+                    .replace(/\)/g, '\\)');
+                textContent += `${cellX} ${textY} Td\n`;
+                textContent += `(${escapedChar}) Tj\n`;
+                textContent += `${-cellX} ${-textY} Td\n`;
+            }
+            textContent += 'ET\n';
+        }
+        else {
+            const textX = padding;
+            textContent = `BT
+${reconstructedDA}
+${textX} ${textY} Td
+(${escapedValue}) Tj
+ET
+`;
+        }
+        const contentStream = `/Tx BMC
+q
+${textContent}Q
+EMC
+`;
+        super({ width, height, contentStream, resources: ctx.fontResources });
+    }
+}

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

@@ -0,0 +1,4 @@
+export { PdfAppearanceStream } from './PdfAppearanceStream.js';
+export { PdfTextAppearanceStream } from './PdfTextAppearanceStream.js';
+export { PdfButtonAppearanceStream } from './PdfButtonAppearanceStream.js';
+export { PdfChoiceAppearanceStream } from './PdfChoiceAppearanceStream.js';

package/dist/acroform/appearance/index.js

@@ -0,0 +1,4 @@
+export { PdfAppearanceStream } from './PdfAppearanceStream.js';
+export { PdfTextAppearanceStream } from './PdfTextAppearanceStream.js';
+export { PdfButtonAppearanceStream } from './PdfButtonAppearanceStream.js';
+export { PdfChoiceAppearanceStream } from './PdfChoiceAppearanceStream.js';

package/dist/acroform/fields/PdfButtonFormField.d.ts

@@ -0,0 +1,9 @@
+import { PdfFormField } from './PdfFormField.js';
+/**
+ * Button form field subtype (checkboxes, radio buttons, push buttons).
+ */
+export declare class PdfButtonFormField extends PdfFormField {
+    generateAppearance(options?: {
+        makeReadOnly?: boolean;
+    }): boolean;
+}

package/dist/acroform/fields/PdfButtonFormField.js

@@ -0,0 +1,35 @@
+import { PdfFormField } from './PdfFormField.js';
+import { PdfButtonAppearanceStream } from '../appearance/PdfButtonAppearanceStream.js';
+/**
+ * Button form field subtype (checkboxes, radio buttons, push buttons).
+ */
+export class PdfButtonFormField extends PdfFormField {
+    static {
+        PdfFormField.registerFieldType('Btn', PdfButtonFormField);
+    }
+    generateAppearance(options) {
+        const rect = this.rect;
+        if (!rect || rect.length !== 4)
+            return false;
+        const [x1, y1, x2, y2] = rect;
+        const width = x2 - x1;
+        const height = y2 - y1;
+        this._appearanceStream = new PdfButtonAppearanceStream({
+            width,
+            height,
+            contentStream: '',
+        });
+        const yesContent = PdfButtonAppearanceStream.buildYesContent(width, height, this.flags);
+        this._appearanceStreamYes = new PdfButtonAppearanceStream({
+            width,
+            height,
+            contentStream: yesContent,
+        });
+        if (options?.makeReadOnly) {
+            this.readOnly = true;
+            this.print = true;
+            this.noZoom = true;
+        }
+        return true;
+    }
+}

package/dist/acroform/fields/PdfChoiceFormField.d.ts

@@ -0,0 +1,9 @@
+import { PdfFormField } from './PdfFormField.js';
+/**
+ * Choice form field subtype (dropdowns, list boxes).
+ */
+export declare class PdfChoiceFormField extends PdfFormField {
+    generateAppearance(options?: {
+        makeReadOnly?: boolean;
+    }): boolean;
+}

package/dist/acroform/fields/PdfChoiceFormField.js

@@ -0,0 +1,46 @@
+import { PdfFormField } from './PdfFormField.js';
+import { PdfDefaultAppearance } from './PdfDefaultAppearance.js';
+import { PdfChoiceAppearanceStream } from '../appearance/PdfChoiceAppearanceStream.js';
+import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+/**
+ * Choice form field subtype (dropdowns, list boxes).
+ */
+export class PdfChoiceFormField extends PdfFormField {
+    static {
+        PdfFormField.registerFieldType('Ch', PdfChoiceFormField);
+    }
+    generateAppearance(options) {
+        const rect = this.rect;
+        if (!rect || rect.length !== 4)
+            return false;
+        const da = this.defaultAppearance;
+        if (!da)
+            return false;
+        const value = this.value;
+        if (!value)
+            return false;
+        const parsed = PdfDefaultAppearance.parse(da);
+        if (!parsed)
+            return false;
+        let fontResources;
+        const drFontValue = this.form?.defaultResources?.get('Font');
+        const drFonts = drFontValue instanceof PdfDictionary ? drFontValue : undefined;
+        if (drFonts) {
+            fontResources = new PdfDictionary();
+            fontResources.set('Font', drFonts);
+        }
+        this._appearanceStream = new PdfChoiceAppearanceStream({
+            rect: rect,
+            value,
+            da: parsed,
+            flags: this.flags,
+            fontResources,
+        });
+        if (options?.makeReadOnly) {
+            this.readOnly = true;
+            this.print = true;
+            this.noZoom = true;
+        }
+        return true;
+    }
+}

package/dist/acroform/fields/PdfDefaultAppearance.d.ts

@@ -0,0 +1,23 @@
+import { PdfString } from '../../core/objects/pdf-string.js';
+/**
+ * Value object that parses and builds DA (Default Appearance) strings.
+ * DA format: "/FontName FontSize Tf ColorOp"
+ *
+ * Extends PdfString so it can be stored directly in dictionaries
+ * without additional wrapping.
+ */
+export declare class PdfDefaultAppearance extends PdfString {
+    private _fontName;
+    private _fontSize;
+    private _colorOp;
+    constructor(fontName: string, fontSize: number, colorOp: string);
+    get fontName(): string;
+    set fontName(name: string);
+    get fontSize(): number;
+    set fontSize(size: number);
+    get colorOp(): string;
+    set colorOp(op: string);
+    private syncRaw;
+    toString(): string;
+    static parse(da: string): PdfDefaultAppearance | null;
+}

package/dist/acroform/fields/PdfDefaultAppearance.js

@@ -0,0 +1,68 @@
+import { PdfString } from '../../core/objects/pdf-string.js';
+import { encodeToPDFDocEncoding } from '../../utils/encodeToPDFDocEncoding.js';
+/**
+ * Value object that parses and builds DA (Default Appearance) strings.
+ * DA format: "/FontName FontSize Tf ColorOp"
+ *
+ * Extends PdfString so it can be stored directly in dictionaries
+ * without additional wrapping.
+ */
+export class PdfDefaultAppearance extends PdfString {
+    _fontName;
+    _fontSize;
+    _colorOp;
+    constructor(fontName, fontSize, colorOp) {
+        super(`/${fontName} ${fontSize} Tf ${colorOp}`);
+        this._fontName = fontName;
+        this._fontSize = fontSize;
+        this._colorOp = colorOp;
+    }
+    get fontName() {
+        return this._fontName;
+    }
+    set fontName(name) {
+        this._fontName = name;
+        this.syncRaw();
+    }
+    get fontSize() {
+        return this._fontSize;
+    }
+    set fontSize(size) {
+        this._fontSize = size;
+        this.syncRaw();
+    }
+    get colorOp() {
+        return this._colorOp;
+    }
+    set colorOp(op) {
+        this._colorOp = op;
+        this.syncRaw();
+    }
+    syncRaw() {
+        // DA strings are always ASCII, so simple PDFDocEncoding works
+        this.raw = encodeToPDFDocEncoding(this.toString());
+    }
+    toString() {
+        return `/${this._fontName} ${this._fontSize} Tf ${this._colorOp}`;
+    }
+    static parse(da) {
+        const fontMatch = da.match(/\/(\w+)\s+([\d.]+)\s+Tf/);
+        if (!fontMatch)
+            return null;
+        const fontName = fontMatch[1];
+        let fontSize = parseFloat(fontMatch[2]);
+        if (!fontSize || fontSize <= 0) {
+            fontSize = 12;
+        }
+        let colorOp = '0 g';
+        const rgMatch = da.match(/([\d.]+\s+[\d.]+\s+[\d.]+)\s+rg/);
+        const gMatch = da.match(/([\d.]+)\s+g/);
+        if (rgMatch) {
+            colorOp = `${rgMatch[1]} rg`;
+        }
+        else if (gMatch) {
+            colorOp = `${gMatch[1]} g`;
+        }
+        return new PdfDefaultAppearance(fontName, fontSize, colorOp);
+    }
+}

package/dist/acroform/fields/PdfFormField.d.ts

@@ -0,0 +1,119 @@
+import { PdfString } from '../../core/objects/pdf-string.js';
+import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
+import { PdfFont } from '../../fonts/pdf-font.js';
+import { PdfStream } from '../../core/objects/pdf-stream.js';
+import { PdfWidgetAnnotation } from '../../annotations/PdfWidgetAnnotation.js';
+import type { PdfAppearanceStream } from '../appearance/PdfAppearanceStream.js';
+import type { FormContext, PdfFieldType } from './types.js';
+/**
+ * Abstract base form field class. Extends PdfWidgetAnnotation with form-specific properties:
+ * FT, V, DA, Ff, T (name), field hierarchy (parent/children/siblings).
+ * Subclasses must implement generateAppearance().
+ */
+export declare abstract class PdfFormField extends PdfWidgetAnnotation {
+    private _parent?;
+    defaultGenerateAppearance: boolean;
+    protected _appearanceStream?: PdfAppearanceStream;
+    protected _appearanceStreamYes?: PdfAppearanceStream;
+    form?: FormContext<PdfFormField>;
+    constructor(options?: {
+        other?: PdfIndirectObject;
+        form?: FormContext<PdfFormField>;
+        parent?: PdfFormField;
+    });
+    get parent(): PdfFormField | undefined;
+    set parent(field: PdfFormField | undefined);
+    get children(): PdfFormField[];
+    set children(fields: PdfFormField[]);
+    get siblings(): PdfFormField[];
+    get encodingMap(): Map<number, string> | undefined;
+    get fieldType(): PdfFieldType | null;
+    set fieldType(type: PdfFieldType | null);
+    get name(): string;
+    set name(name: string);
+    get defaultValue(): string;
+    set defaultValue(val: string);
+    get value(): string;
+    set value(val: string | PdfString);
+    get checked(): boolean;
+    set checked(isChecked: boolean);
+    get fontSize(): number | null;
+    set fontSize(size: number);
+    get fontName(): string | null;
+    set fontName(fontName: string);
+    set font(font: PdfFont | null);
+    get flags(): number;
+    set flags(flags: number);
+    private getFlag;
+    private setFlag;
+    get readOnly(): boolean;
+    set readOnly(v: boolean);
+    get required(): boolean;
+    set required(v: boolean);
+    get multiline(): boolean;
+    set multiline(v: boolean);
+    get password(): boolean;
+    set password(v: boolean);
+    get comb(): boolean;
+    get combField(): boolean;
+    set combField(v: boolean);
+    get combo(): boolean;
+    set combo(v: boolean);
+    get radio(): boolean;
+    set radio(v: boolean);
+    get noToggleToOff(): boolean;
+    set noToggleToOff(v: boolean);
+    get noExport(): boolean;
+    set noExport(v: boolean);
+    get pushButton(): boolean;
+    set pushButton(v: boolean);
+    get edit(): boolean;
+    set edit(v: boolean);
+    get sort(): boolean;
+    set sort(v: boolean);
+    get multiSelect(): boolean;
+    set multiSelect(v: boolean);
+    get doNotSpellCheck(): boolean;
+    set doNotSpellCheck(v: boolean);
+    get doNotScroll(): boolean;
+    set doNotScroll(v: boolean);
+    get commitOnSelChange(): boolean;
+    set commitOnSelChange(v: boolean);
+    get quadding(): number;
+    set quadding(q: number);
+    get options(): string[];
+    set options(options: string[]);
+    get defaultAppearance(): string | null;
+    set defaultAppearance(da: string);
+    get maxLen(): number | null;
+    set maxLen(maxLen: number | null);
+    get kids(): PdfObjectReference[];
+    set kids(kids: PdfObjectReference[]);
+    abstract generateAppearance(options?: {
+        makeReadOnly?: boolean;
+        textYOffset?: number;
+    }): boolean;
+    getAppearanceStream(): PdfStream | undefined;
+    getAppearanceStreamsForWriting(): {
+        primary: PdfAppearanceStream;
+        secondary?: PdfAppearanceStream;
+    } | undefined;
+    setAppearanceReference(appearanceStreamRef: PdfObjectReference, appearanceStreamYesRef?: PdfObjectReference): void;
+    private static _fallbackCtor?;
+    private static _registry;
+    static registerFieldType(ft: string, ctor: new (options?: {
+        other?: PdfIndirectObject;
+        form?: FormContext<PdfFormField>;
+        parent?: PdfFormField;
+    }) => PdfFormField, options?: {
+        fallback?: boolean;
+    }): void;
+    static create(options: {
+        other: PdfIndirectObject;
+        form: FormContext<PdfFormField>;
+        parent?: PdfFormField;
+    }): PdfFormField;
+}
+/** Backward compatible alias */
+export { PdfFormField as PdfAcroFormField };