pdf-lite 1.4.0 → 1.5.0

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

@@ -0,0 +1,104 @@
+import { PdfDefaultAppearance } from '../fields/pdf-default-appearance.js';
+import { PdfAppearanceStream } from './pdf-appearance-stream.js';
+import { PdfGraphics } from './pdf-graphics.js';
+/**
+ * Appearance stream for text fields (single-line, multiline, comb).
+ * Enhanced with word wrapping and automatic font scaling.
+ */
+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 isUnicode = ctx.isUnicode ?? false;
+        const reverseEncodingMap = ctx.reverseEncodingMap;
+        const padding = 2;
+        const availableWidth = width - 2 * padding;
+        const availableHeight = height - 2 * padding;
+        // Create graphics with font context for text measurement
+        const g = new PdfGraphics({
+            resolvedFonts: ctx.resolvedFonts,
+        });
+        g.beginMarkedContent();
+        g.save();
+        // Set initial font to enable measurement
+        g.setDefaultAppearance(ctx.da);
+        let finalFontSize = ctx.da.fontSize;
+        let lines = [];
+        if (ctx.multiline) {
+            const testLines = g.wrapTextToLines(value, availableWidth);
+            const lineHeight = finalFontSize * 1.2;
+            if (testLines.length * lineHeight > availableHeight) {
+                // Scale font down to fit
+                finalFontSize = g.calculateFittingFontSize(value, availableWidth, availableHeight, 1.2);
+                const adjustedDA = new PdfDefaultAppearance(ctx.da.fontName, finalFontSize, ctx.da.colorOp);
+                g.setDefaultAppearance(adjustedDA);
+                lines = g.wrapTextToLines(value, availableWidth);
+            }
+            else {
+                lines = testLines;
+            }
+            const renderLineHeight = finalFontSize * 1.2;
+            const startY = height - padding - finalFontSize;
+            g.beginText();
+            g.moveTo(padding, startY);
+            for (let i = 0; i < lines.length; i++) {
+                if (i > 0)
+                    g.moveTo(0, -renderLineHeight);
+                g.showText(lines[i].replace(/\r/g, ''), isUnicode, reverseEncodingMap);
+            }
+            g.endText();
+        }
+        else if (ctx.comb && ctx.maxLen) {
+            const cellWidth = width / ctx.maxLen;
+            const chars = [...value];
+            // Calculate font size to fit the widest character in its cell
+            let maxCharWidth = 0;
+            let widestChar = chars[0] ?? '';
+            for (const char of chars) {
+                const charWidth = g.measureTextWidth(char);
+                if (charWidth > maxCharWidth) {
+                    maxCharWidth = charWidth;
+                    widestChar = char;
+                }
+            }
+            if (maxCharWidth > cellWidth) {
+                finalFontSize = g.calculateFittingFontSize(widestChar, cellWidth);
+                const adjustedDA = new PdfDefaultAppearance(ctx.da.fontName, finalFontSize, ctx.da.colorOp);
+                g.setDefaultAppearance(adjustedDA);
+            }
+            const textY = (height - finalFontSize) / 2 + finalFontSize * 0.2;
+            g.beginText();
+            for (let i = 0; i < chars.length && i < ctx.maxLen; i++) {
+                const cellX = cellWidth * i + cellWidth / 2 - finalFontSize * 0.3;
+                g.moveTo(cellX, textY);
+                g.showText(chars[i], isUnicode, reverseEncodingMap);
+                g.moveTo(-cellX, -textY);
+            }
+            g.endText();
+        }
+        else {
+            // Single line text
+            const textWidth = g.measureTextWidth(value);
+            if (textWidth > availableWidth) {
+                finalFontSize = g.calculateFittingFontSize(value, availableWidth);
+                const adjustedDA = new PdfDefaultAppearance(ctx.da.fontName, finalFontSize, ctx.da.colorOp);
+                g.setDefaultAppearance(adjustedDA);
+            }
+            const textY = (height - finalFontSize) / 2 + finalFontSize * 0.2;
+            g.beginText();
+            g.moveTo(padding, textY);
+            g.showText(value, isUnicode, reverseEncodingMap);
+            g.endText();
+        }
+        g.restore();
+        g.endMarkedContent();
+        super({
+            width,
+            height,
+            contentStream: g.build(),
+            resources: ctx.fontResources,
+        });
+    }
+}

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

@@ -1,8 +1,8 @@
-export { PdfFormField, PdfAcroFormField } from './PdfFormField.js';
-export { PdfFormFieldFlags } from './PdfFormFieldFlags.js';
-export { PdfDefaultAppearance } from './PdfDefaultAppearance.js';
-export { PdfTextFormField } from './PdfTextFormField.js';
-export { PdfButtonFormField } from './PdfButtonFormField.js';
-export { PdfChoiceFormField } from './PdfChoiceFormField.js';
-export { PdfSignatureFormField } from './PdfSignatureFormField.js';
+export { PdfFormField, PdfAcroFormField } from './pdf-form-field.js';
+export { PdfFormFieldFlags } from './pdf-form-field-flags.js';
+export { PdfDefaultAppearance } from './pdf-default-appearance.js';
+export { PdfTextFormField } from './pdf-text-form-field.js';
+export { PdfButtonFormField } from './pdf-button-form-field.js';
+export { PdfChoiceFormField } from './pdf-choice-form-field.js';
+export { PdfSignatureFormField } from './pdf-signature-form-field.js';
 export { PdfFieldType, type FormContext } from './types.js';

package/dist/acroform/fields/index.js

@@ -1,8 +1,8 @@
-export { PdfFormField, PdfAcroFormField } from './PdfFormField.js';
-export { PdfFormFieldFlags } from './PdfFormFieldFlags.js';
-export { PdfDefaultAppearance } from './PdfDefaultAppearance.js';
-export { PdfTextFormField } from './PdfTextFormField.js';
-export { PdfButtonFormField } from './PdfButtonFormField.js';
-export { PdfChoiceFormField } from './PdfChoiceFormField.js';
-export { PdfSignatureFormField } from './PdfSignatureFormField.js';
+export { PdfFormField, PdfAcroFormField } from './pdf-form-field.js';
+export { PdfFormFieldFlags } from './pdf-form-field-flags.js';
+export { PdfDefaultAppearance } from './pdf-default-appearance.js';
+export { PdfTextFormField } from './pdf-text-form-field.js';
+export { PdfButtonFormField } from './pdf-button-form-field.js';
+export { PdfChoiceFormField } from './pdf-choice-form-field.js';
+export { PdfSignatureFormField } from './pdf-signature-form-field.js';
 export { PdfFieldType } from './types.js';

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/{PdfFormFieldFlags.d.ts → pdf-form-field-flags.d.ts}

@@ -1,14 +1,13 @@
-import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
+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 {
-    dict: PdfDictionary;
-    parentDict?: PdfDictionary;
-    constructor(dict: PdfDictionary, parentDict?: PdfDictionary);
+export declare class PdfFormFieldFlags extends PdfNumber {
+    constructor(value?: number | PdfNumber | PdfFormFieldFlags);
     get flags(): number;
-    set flags(flags: number);
+    set flags(v: number | PdfFormFieldFlags);
     private getFlag;
     private setFlag;
     get readOnly(): boolean;

package/dist/acroform/fields/{PdfFormFieldFlags.js → pdf-form-field-flags.js}

@@ -2,32 +2,26 @@ 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 {
-    dict;
-    parentDict;
-    constructor(dict, parentDict) {
-        this.dict = dict;
-        this.parentDict = parentDict;
+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.dict.get('Ff')?.as(PdfNumber)?.value ??
-            this.parentDict?.get('Ff')?.as(PdfNumber)?.value ??
-            0);
+        return this.value;
     }
-    set flags(flags) {
-        this.dict.set('Ff', new PdfNumber(flags));
+    set flags(v) {
+        this.value = v instanceof PdfFormFieldFlags ? v.value : v;
     }
     getFlag(bit) {
         return (this.flags & bit) !== 0;
     }
-    setFlag(bit, value) {
-        if (value) {
-            this.flags = this.flags | bit;
-        }
-        else {
-            this.flags = this.flags & ~bit;
-        }
+    setFlag(bit, val) {
+        this.flags = val ? this.flags | bit : this.flags & ~bit;
     }
     get readOnly() {
         return this.getFlag(1);

package/dist/acroform/fields/{PdfFormField.d.ts → pdf-form-field.d.ts}

@@ -3,9 +3,10 @@ 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 { 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).
@@ -36,17 +37,22 @@ export declare abstract class PdfFormField extends PdfWidgetAnnotation {
     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);
+    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 flags(): PdfFormFieldFlags;
+    set flags(v: PdfFormFieldFlags);
     get readOnly(): boolean;
     set readOnly(v: boolean);
     get required(): boolean;
@@ -82,8 +88,6 @@ export declare abstract class PdfFormField extends PdfWidgetAnnotation {
     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;
@@ -99,10 +103,10 @@ export declare abstract class PdfFormField extends PdfWidgetAnnotation {
         primary: PdfAppearanceStream;
         secondary?: PdfAppearanceStream;
     } | undefined;
-    setAppearanceReference(appearanceStreamRef: PdfObjectReference, appearanceStreamYesRef?: PdfObjectReference): void;
+    setAppearanceReference(appearanceStreamRef: PdfObjectReference, _appearanceStreamYesRef?: PdfObjectReference): void;
     private static _fallbackCtor?;
     private static _registry;
-    static registerFieldType(ft: string, ctor: new (options?: {
+    static registerFieldType(ft: 'Sig' | 'Btn' | 'Tx' | 'Ch', ctor: new (options?: {
         other?: PdfIndirectObject;
         form?: FormContext<PdfFormField>;
         parent?: PdfFormField;