pdf-lite 1.3.3 → 1.5.0

package/dist/acroform/fields/pdf-button-form-field.d.ts

@@ -0,0 +1,23 @@
+import { PdfFormField } from './pdf-form-field.js';
+import { PdfString } from '../../core/objects/pdf-string.js';
+import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
+import type { PdfAppearanceStream } from '../appearance/pdf-appearance-stream.js';
+import type { PdfStream } from '../../core/objects/pdf-stream.js';
+/**
+ * Button form field subtype (checkboxes, radio buttons, push buttons).
+ */
+export declare class PdfButtonFormField extends PdfFormField {
+    set defaultValue(val: string);
+    protected _storeValue(val: string | PdfString, fieldParent: PdfFormField | undefined): boolean;
+    get checked(): boolean;
+    set checked(isChecked: boolean);
+    getAppearanceStream(): PdfStream | undefined;
+    getAppearanceStreamsForWriting(): {
+        primary: PdfAppearanceStream;
+        secondary?: PdfAppearanceStream;
+    } | undefined;
+    setAppearanceReference(appearanceStreamRef: PdfObjectReference, appearanceStreamYesRef?: PdfObjectReference): void;
+    generateAppearance(options?: {
+        makeReadOnly?: boolean;
+    }): boolean;
+}

package/dist/acroform/fields/pdf-button-form-field.js

@@ -0,0 +1,102 @@
+import { PdfFormField } from './pdf-form-field.js';
+import { PdfButtonAppearanceStream } from '../appearance/pdf-button-appearance-stream.js';
+import { PdfName } from '../../core/objects/pdf-name.js';
+import { PdfString } from '../../core/objects/pdf-string.js';
+import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+/**
+ * Button form field subtype (checkboxes, radio buttons, push buttons).
+ */
+export class PdfButtonFormField extends PdfFormField {
+    static {
+        PdfFormField.registerFieldType('Btn', PdfButtonFormField);
+    }
+    set defaultValue(val) {
+        this.content.set('DV', new PdfName(val));
+    }
+    _storeValue(val, fieldParent) {
+        const strVal = val instanceof PdfString ? val.value : val;
+        if (strVal.trim() === '') {
+            this.content.delete('V');
+            fieldParent?.content.delete('V');
+            this.content.delete('AS');
+            return false;
+        }
+        this.content.set('V', new PdfName(strVal));
+        fieldParent?.content.set('V', new PdfName(strVal));
+        this.content.set('AS', new PdfName(strVal));
+        return true;
+    }
+    get checked() {
+        const v = this.content.get('V') ?? this.parent?.content.get('V');
+        return v instanceof PdfName && v.value === 'Yes';
+    }
+    set checked(isChecked) {
+        const target = this.parent ?? this;
+        if (isChecked) {
+            target.content.set('V', new PdfName('Yes'));
+            this.content.set('AS', new PdfName('Yes'));
+        }
+        else {
+            target.content.set('V', new PdfName('Off'));
+            this.content.set('AS', new PdfName('Off'));
+        }
+    }
+    getAppearanceStream() {
+        if (this.checked && this._appearanceStreamYes) {
+            return this._appearanceStreamYes.content;
+        }
+        return this._appearanceStream?.content;
+    }
+    getAppearanceStreamsForWriting() {
+        if (!this._appearanceStream)
+            return undefined;
+        return {
+            primary: this._appearanceStream,
+            secondary: this._appearanceStreamYes,
+        };
+    }
+    setAppearanceReference(appearanceStreamRef, appearanceStreamYesRef) {
+        let apDict = this.appearanceStreamDict;
+        if (!apDict) {
+            apDict = new PdfDictionary();
+            this.appearanceStreamDict = apDict;
+        }
+        if (appearanceStreamYesRef) {
+            const stateDict = new PdfDictionary();
+            stateDict.set('Off', appearanceStreamRef);
+            stateDict.set('Yes', appearanceStreamYesRef);
+            apDict.set('N', stateDict);
+        }
+        else {
+            apDict.set('N', appearanceStreamRef);
+        }
+    }
+    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: '',
+        });
+        // Merge own flags with parent flags so inherited bits (e.g. Radio) are
+        // not lost when a child widget has its own Ff entry (even Ff: 0).
+        const effectiveFlags = this.flags.flags | (this.parent?.flags?.flags ?? 0);
+        const yesContent = PdfButtonAppearanceStream.buildYesContent(width, height, effectiveFlags);
+        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/pdf-choice-form-field.d.ts

@@ -0,0 +1,18 @@
+import { PdfFormField } from './pdf-form-field.js';
+/**
+ * Choice form field subtype (dropdowns, list boxes).
+ */
+export declare class PdfChoiceFormField extends PdfFormField {
+    get selectedIndex(): number;
+    get options(): {
+        label: string;
+        value: string;
+    }[];
+    set options(values: {
+        label: string;
+        value: string;
+    }[] | string[] | undefined);
+    generateAppearance(options?: {
+        makeReadOnly?: boolean;
+    }): boolean;
+}

package/dist/acroform/fields/pdf-choice-form-field.js

@@ -0,0 +1,131 @@
+import { PdfFormField } from './pdf-form-field.js';
+import { PdfDefaultAppearance } from './pdf-default-appearance.js';
+import { PdfChoiceAppearanceStream } from '../appearance/pdf-choice-appearance-stream.js';
+import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
+import { PdfArray } from '../../core/objects/pdf-array.js';
+import { PdfString } from '../../core/objects/pdf-string.js';
+/**
+ * Choice form field subtype (dropdowns, list boxes).
+ */
+export class PdfChoiceFormField extends PdfFormField {
+    static {
+        PdfFormField.registerFieldType('Ch', PdfChoiceFormField);
+    }
+    get selectedIndex() {
+        return this.options.findIndex((opt) => opt.value === this.value);
+    }
+    get options() {
+        const opt = this.content
+            .get('Opt')
+            ?.as((PdfArray)) ??
+            this.parent?.content
+                .get('Opt')
+                ?.as((PdfArray));
+        if (!opt)
+            return [];
+        return opt.items.map((item) => {
+            if (item instanceof PdfArray && item.items.length >= 2) {
+                const label = item.items[1] instanceof PdfString
+                    ? item.items[1].value
+                    : '';
+                const value = item.items[0] instanceof PdfString
+                    ? item.items[0].value
+                    : '';
+                return { label, value };
+            }
+            else if (item instanceof PdfString) {
+                return { label: item.value, value: item.value };
+            }
+            else {
+                return { label: '', value: '' };
+            }
+        });
+    }
+    set options(values) {
+        if (values === undefined) {
+            this.content.delete('Opt');
+            return;
+        }
+        if (values.length === 0) {
+            this.content.delete('Opt');
+            return;
+        }
+        const optArray = new PdfArray();
+        for (const option of values) {
+            if (typeof option === 'string') {
+                optArray.items.push(new PdfString(option));
+            }
+            else if (option.label === option.value) {
+                optArray.items.push(new PdfString(option.value));
+            }
+            else {
+                const pair = new PdfArray();
+                pair.items.push(new PdfString(option.value));
+                pair.items.push(new PdfString(option.label));
+                optArray.items.push(pair);
+            }
+        }
+        this.content.set('Opt', optArray);
+    }
+    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;
+        const daFontRef = this.form?.fontRefs?.get(parsed.fontName);
+        if (drFonts || daFontRef) {
+            // Build a fresh font dict using clean PdfObjectReferences (no
+            // pre/postTokens inherited from the original parse context).
+            const fontDict = new PdfDictionary();
+            if (drFonts) {
+                for (const [key, val] of drFonts.entries()) {
+                    if (val instanceof PdfObjectReference) {
+                        fontDict.set(key, new PdfObjectReference(val.objectNumber, val.generationNumber));
+                    }
+                    else if (val != null) {
+                        fontDict.set(key, val);
+                    }
+                }
+            }
+            if (daFontRef && !fontDict.has(parsed.fontName)) {
+                fontDict.set(parsed.fontName, new PdfObjectReference(daFontRef.objectNumber, daFontRef.generationNumber));
+            }
+            fontResources = new PdfDictionary();
+            fontResources.set('Font', fontDict);
+        }
+        const isUnicode = this.form?.isFontUnicode(parsed.fontName) ?? false;
+        const encodingMap = this.form?.fontEncodingMaps?.get(parsed.fontName);
+        const reverseEncodingMap = encodingMap
+            ? new Map(Array.from(encodingMap, ([code, char]) => [char, code]))
+            : undefined;
+        this._appearanceStream = new PdfChoiceAppearanceStream({
+            rect: rect,
+            value,
+            da: parsed,
+            flags: this.flags,
+            fontResources,
+            isUnicode,
+            reverseEncodingMap,
+            displayOptions: this.options.map((opt) => opt.label),
+            selectedIndex: this.selectedIndex,
+        });
+        if (options?.makeReadOnly) {
+            this.readOnly = true;
+            this.print = true;
+            this.noZoom = true;
+        }
+        return true;
+    }
+}

package/dist/acroform/fields/pdf-default-appearance.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/pdf-default-appearance.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/pdf-form-field-flags.d.ts

@@ -0,0 +1,45 @@
+import { PdfNumber } from '../../core/objects/pdf-number.js';
+/**
+ * Field-specific Ff flag accessors for form fields.
+ * These are separate from annotation flags (F field).
+ * Extends PdfNumber so it can be stored directly in a PDF dictionary.
+ */
+export declare class PdfFormFieldFlags extends PdfNumber {
+    constructor(value?: number | PdfNumber | PdfFormFieldFlags);
+    get flags(): number;
+    set flags(v: number | PdfFormFieldFlags);
+    private getFlag;
+    private setFlag;
+    get readOnly(): boolean;
+    set readOnly(v: boolean);
+    get required(): boolean;
+    set required(v: boolean);
+    get noExport(): boolean;
+    set noExport(v: boolean);
+    get multiline(): boolean;
+    set multiline(v: boolean);
+    get password(): boolean;
+    set password(v: boolean);
+    get noToggleToOff(): boolean;
+    set noToggleToOff(v: boolean);
+    get radio(): boolean;
+    set radio(v: boolean);
+    get pushButton(): boolean;
+    set pushButton(v: boolean);
+    get combo(): boolean;
+    set combo(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 comb(): boolean;
+    set comb(v: boolean);
+    get commitOnSelChange(): boolean;
+    set commitOnSelChange(v: boolean);
+}

package/dist/acroform/fields/pdf-form-field-flags.js

@@ -0,0 +1,122 @@
+import { PdfNumber } from '../../core/objects/pdf-number.js';
+/**
+ * Field-specific Ff flag accessors for form fields.
+ * These are separate from annotation flags (F field).
+ * Extends PdfNumber so it can be stored directly in a PDF dictionary.
+ */
+export class PdfFormFieldFlags extends PdfNumber {
+    constructor(value = 0) {
+        super(value);
+        this.preTokens = typeof value === 'number' ? undefined : value.preTokens;
+        this.postTokens =
+            typeof value === 'number' ? undefined : value.postTokens;
+    }
+    get flags() {
+        return this.value;
+    }
+    set flags(v) {
+        this.value = v instanceof PdfFormFieldFlags ? v.value : v;
+    }
+    getFlag(bit) {
+        return (this.flags & bit) !== 0;
+    }
+    setFlag(bit, val) {
+        this.flags = val ? this.flags | bit : this.flags & ~bit;
+    }
+    get readOnly() {
+        return this.getFlag(1);
+    }
+    set readOnly(v) {
+        this.setFlag(1, v);
+    }
+    get required() {
+        return this.getFlag(2);
+    }
+    set required(v) {
+        this.setFlag(2, v);
+    }
+    get noExport() {
+        return this.getFlag(4);
+    }
+    set noExport(v) {
+        this.setFlag(4, v);
+    }
+    get multiline() {
+        return this.getFlag(4096);
+    }
+    set multiline(v) {
+        this.setFlag(4096, v);
+    }
+    get password() {
+        return this.getFlag(8192);
+    }
+    set password(v) {
+        this.setFlag(8192, v);
+    }
+    get noToggleToOff() {
+        return this.getFlag(16384);
+    }
+    set noToggleToOff(v) {
+        this.setFlag(16384, v);
+    }
+    get radio() {
+        return this.getFlag(32768);
+    }
+    set radio(v) {
+        this.setFlag(32768, v);
+    }
+    get pushButton() {
+        return this.getFlag(65536);
+    }
+    set pushButton(v) {
+        this.setFlag(65536, v);
+    }
+    get combo() {
+        return this.getFlag(131072);
+    }
+    set combo(v) {
+        this.setFlag(131072, v);
+    }
+    get edit() {
+        return this.getFlag(262144);
+    }
+    set edit(v) {
+        this.setFlag(262144, v);
+    }
+    get sort() {
+        return this.getFlag(524288);
+    }
+    set sort(v) {
+        this.setFlag(524288, v);
+    }
+    get multiSelect() {
+        return this.getFlag(2097152);
+    }
+    set multiSelect(v) {
+        this.setFlag(2097152, v);
+    }
+    get doNotSpellCheck() {
+        return this.getFlag(4194304);
+    }
+    set doNotSpellCheck(v) {
+        this.setFlag(4194304, v);
+    }
+    get doNotScroll() {
+        return this.getFlag(8388608);
+    }
+    set doNotScroll(v) {
+        this.setFlag(8388608, v);
+    }
+    get comb() {
+        return this.getFlag(16777216);
+    }
+    set comb(v) {
+        this.setFlag(16777216, v);
+    }
+    get commitOnSelChange() {
+        return this.getFlag(67108864);
+    }
+    set commitOnSelChange(v) {
+        this.setFlag(67108864, v);
+    }
+}

package/dist/acroform/fields/pdf-form-field.d.ts

@@ -0,0 +1,123 @@
+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/pdf-widget-annotation.js';
+import type { PdfAppearanceStream } from '../appearance/pdf-appearance-stream.js';
+import type { FormContext, PdfFieldType } from './types.js';
+import { PdfFormFieldFlags } from './pdf-form-field-flags.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);
+    /**
+     * Writes the value to the dictionary. Returns true if appearance generation
+     * should proceed, false to skip it (e.g. when value was cleared).
+     * Override in subclasses to change the stored representation.
+     */
+    protected _storeValue(val: string | PdfString, fieldParent: PdfFormField | undefined): boolean;
+    protected tryGenerateAppearance(field: PdfFormField): void;
+    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(): PdfFormFieldFlags;
+    set flags(v: PdfFormFieldFlags);
+    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 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: 'Sig' | 'Btn' | 'Tx' | 'Ch', 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 };