pdf-lite 1.6.4 → 1.7.1

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

@@ -91,7 +91,7 @@ export class PdfChoiceFormField extends PdfFormField {
         const fontResources = this.buildFontResources(parsed.fontName);
         const isUnicode = font?.isUnicode ?? false;
         const reverseEncodingMap = font?.reverseEncodingMap;
-        this.setAppearanceStream(new PdfChoiceAppearanceStream({
+        this.appearanceStream = new PdfChoiceAppearanceStream({
             rect: rect,
             value,
             da: parsed,
@@ -101,7 +101,7 @@ export class PdfChoiceFormField extends PdfFormField {
             reverseEncodingMap,
             displayOptions: this.options.map((opt) => opt.label),
             selectedIndex: this.selectedIndex,
-        }));
+        });
         if (options?.makeReadOnly) {
             this.readOnly = true;
             this.print = true;

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

@@ -4,6 +4,7 @@ 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 type { FontFamily } from '../../fonts/font-family.js';
 import { PdfStream } from '../../core/objects/pdf-stream.js';
 import { PdfWidgetAnnotation } from '../../annotations/pdf-widget-annotation.js';
 import type { PdfFieldType } from './types.js';
@@ -19,12 +20,16 @@ import { PdfJavaScriptAction } from '../js/pdf-javascript-action.js';
  */
 export declare abstract class PdfFormField extends PdfWidgetAnnotation {
     defaultGenerateAppearance: boolean;
+    /** Raw markdown string set by markdownValue; cleared by setRawValue. */
+    protected _markdownValue?: string;
+    private _fontFamily?;
     /** @internal */
     _form?: PdfAcroForm;
     constructor(other?: PdfIndirectObject | {
         form?: PdfAcroForm;
     });
     set form(f: PdfAcroForm);
+    static getFieldType(other: PdfIndirectObject): 'Btn' | 'Sig' | 'Tx' | 'Ch' | null;
     static create(other?: PdfIndirectObject): PdfFormField;
     get parent(): PdfFormField | undefined;
     set parent(field: PdfFormField | PdfIndirectObject | undefined);
@@ -40,25 +45,43 @@ export declare abstract class PdfFormField extends PdfWidgetAnnotation {
      * Returns undefined if neither source provides the font.
      */
     buildFontResources(fontName: string): PdfDictionary | undefined;
+    /**
+     * Like buildFontResources but includes multiple font names (regular +
+     * variant fonts) in a single Resources/Font dictionary. Falls through to
+     * buildFontResources when only one name is provided.
+     */
+    buildAllFontResources(fontNames: string[]): PdfDictionary | 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 onStates(): string[];
+    get onState(): string | null;
+    set onState(state: string);
     get value(): string;
+    protected setRawValue(val: string | PdfString): void;
     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;
+    set markdownValue(val: string);
     get fontSize(): number | null;
     set fontSize(size: number);
     get fontName(): string | null;
     set fontName(fontName: string);
     set font(font: PdfFont | null);
+    private _embedFontInDR;
+    get fontFamily(): FontFamily | null;
+    set fontFamily(family: FontFamily | null);
+    get fontVariantNames(): {
+        bold?: string;
+        italic?: string;
+        boldItalic?: string;
+    };
+    protected get resolvedVariantFonts(): {
+        bold?: PdfFont;
+        italic?: PdfFont;
+        boldItalic?: PdfFont;
+    };
     get flags(): PdfFormFieldFlags;
     set flags(v: PdfFormFieldFlags);
     get readOnly(): boolean;
@@ -108,16 +131,23 @@ export declare abstract class PdfFormField extends PdfWidgetAnnotation {
     abstract generateAppearance(options?: {
         makeReadOnly?: boolean;
         textYOffset?: number;
+        onStateName?: string;
     }): boolean;
-    setAppearanceStream(stream: PdfIndirectObject | {
+    set appearanceStream(stream: PdfIndirectObject | {
         [key: string]: PdfIndirectObject;
-    }): void;
+    });
+    set downAppearanceStream(stream: PdfIndirectObject | {
+        [key: string]: PdfIndirectObject;
+    });
+    get appearanceState(): string | null;
+    set appearanceState(state: string | null);
     /**
      * Returns the list of appearance state names from the normal appearance
      * dictionary (e.g. ["Yes", "Off"] for a checkbox).
      */
-    get appearanceStates(): string[];
+    get appearanceStates(): ReadonlyArray<string>;
     getAppearanceStream(setting?: string): PdfIndirectObject<PdfStream> | null;
+    hasAppearanceStream(setting: string): boolean;
     private static _fallbackCtor?;
     private static _registry;
     static registerFieldType(ft: 'Sig' | 'Btn' | 'Tx' | 'Ch', ctor: new (other?: PdfIndirectObject) => PdfFormField, options?: {

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

@@ -14,6 +14,7 @@ import { PdfFieldType as PdfFieldTypeConst } from './types.js';
 import { PdfFormFieldFlags } from './pdf-form-field-flags.js';
 import { PdfFieldActions } from '../js/pdf-field-actions.js';
 import { PdfJavaScriptAction } from '../js/pdf-javascript-action.js';
+import { parseMarkdownSegments } from '../../utils/parse-markdown-segments.js';
 /**
  * Abstract base form field class. Extends PdfWidgetAnnotation with form-specific properties:
  * FT, V, DA, Ff, T (name), field hierarchy (parent/children/siblings).
@@ -21,6 +22,9 @@ import { PdfJavaScriptAction } from '../js/pdf-javascript-action.js';
  */
 export class PdfFormField extends PdfWidgetAnnotation {
     defaultGenerateAppearance = true;
+    /** Raw markdown string set by markdownValue; cleared by setRawValue. */
+    _markdownValue;
+    _fontFamily;
     /** @internal */
     _form;
     constructor(other) {
@@ -32,10 +36,25 @@ export class PdfFormField extends PdfWidgetAnnotation {
     set form(f) {
         this._form = f;
     }
+    static getFieldType(other) {
+        if (!(other.content instanceof PdfDictionary))
+            return null;
+        const ft = other.content.get('FT')?.as(PdfName)?.value;
+        if (ft)
+            return ft;
+        const parentRef = other.content.get('Parent');
+        if (parentRef instanceof PdfObjectReference) {
+            const parentResolved = parentRef.resolve();
+            if (parentResolved?.content instanceof PdfDictionary) {
+                return (parentResolved.content.get('FT')?.as(PdfName)?.value ?? null);
+            }
+        }
+        return null;
+    }
     static create(other) {
         if (!(other?.content instanceof PdfDictionary))
             throw new Error('Invalid form field object');
-        const ft = other?.content.get('FT')?.as(PdfName)?.value;
+        const ft = PdfFormField.getFieldType(other);
         const cls = ft ? PdfFormField._registry.get(ft) : undefined;
         if (!cls) {
             if (PdfFormField._fallbackCtor) {
@@ -60,14 +79,23 @@ export class PdfFormField extends PdfWidgetAnnotation {
         if (field instanceof PdfFormField) {
             field.children = [...field.children, this];
         }
+        // Auto-add widget to page's Annots array
+        const page = this.page;
+        if (page) {
+            const annots = page.annotations;
+            const ref = this.reference;
+            const key = ref.key;
+            const alreadyPresent = annots.items.some((r) => r instanceof PdfObjectReference && r.key === key);
+            if (!alreadyPresent) {
+                annots.items.push(ref);
+            }
+        }
     }
     get children() {
         const kids = this.content.get('Kids')?.items ?? [];
         const result = [];
         for (const ref of kids) {
             const resolved = ref.resolve();
-            if (!resolved || !(resolved.content instanceof PdfDictionary))
-                continue;
             result.push(PdfFormField.create(resolved));
         }
         return result;
@@ -156,9 +184,41 @@ export class PdfFormField extends PdfWidgetAnnotation {
         }
         return undefined;
     }
+    /**
+     * Like buildFontResources but includes multiple font names (regular +
+     * variant fonts) in a single Resources/Font dictionary. Falls through to
+     * buildFontResources when only one name is provided.
+     */
+    buildAllFontResources(fontNames) {
+        if (fontNames.length <= 1)
+            return this.buildFontResources(fontNames[0]);
+        const dr = this.defaultResources;
+        const fontRaw = dr?.get('Font');
+        let drFontDict;
+        if (fontRaw instanceof PdfObjectReference) {
+            const resolved = fontRaw.resolve()?.content;
+            if (resolved instanceof PdfDictionary)
+                drFontDict = resolved;
+        }
+        else if (fontRaw instanceof PdfDictionary) {
+            drFontDict = fontRaw;
+        }
+        const resFontDict = new PdfDictionary();
+        for (const name of fontNames) {
+            if (drFontDict?.get(name)) {
+                resFontDict.set(name, drFontDict.get(name));
+            }
+        }
+        if (resFontDict.keys().length > 0) {
+            const resources = new PdfDictionary();
+            resources.set('Font', resFontDict);
+            return resources;
+        }
+        // Fallback to single-font path for the primary font name
+        return this.buildFontResources(fontNames[0]);
+    }
     get fieldType() {
-        const ft = this.content.get('FT')?.as(PdfName)?.value ??
-            this.parent?.content.get('FT')?.as(PdfName)?.value;
+        const ft = PdfFormField.getFieldType(this);
         switch (ft) {
             case 'Tx':
                 return 'Text';
@@ -202,6 +262,27 @@ export class PdfFormField extends PdfWidgetAnnotation {
     set defaultValue(val) {
         this.content.set('DV', new PdfString(val));
     }
+    get onStates() {
+        return this.appearanceStates.filter((s) => s !== 'Off');
+    }
+    get onState() {
+        return this.appearanceStates.find((s) => s !== 'Off') || null;
+    }
+    set onState(state) {
+        if (!this.appearanceStates.includes(state)) {
+            const currentOnState = this.onState;
+            if (currentOnState) {
+                this.appearanceStreamDict
+                    ?.get('N')
+                    ?.as(PdfDictionary)
+                    ?.move(currentOnState, state);
+            }
+            else {
+                // No existing on-state; generate a new appearance stream for the new state
+                this.generateAppearance({ onStateName: state });
+            }
+        }
+    }
     get value() {
         const v = this.content.get('V') ?? this.parent?.content.get('V');
         if (v instanceof PdfString) {
@@ -221,48 +302,67 @@ export class PdfFormField extends PdfWidgetAnnotation {
         }
         return '';
     }
-    set value(val) {
-        if (this.value === val)
-            return;
-        const fieldParent = this.parent?.content.get('FT')
-            ? this.parent
-            : undefined;
-        const generateAppearance = this._storeValue(val, fieldParent);
-        if (generateAppearance && this.defaultGenerateAppearance) {
-            this.generateAppearance();
-            for (const sibling of this.siblings) {
-                if (sibling !== this &&
-                    sibling.rect &&
-                    sibling.defaultGenerateAppearance) {
-                    sibling.generateAppearance();
-                }
+    setRawValue(val) {
+        this._markdownValue = undefined;
+        const targets = [this];
+        const parent = this.parent;
+        if (parent?.fieldType) {
+            targets.push(parent);
+        }
+        const pdfVal = val instanceof PdfString ? val : new PdfString(val);
+        const isEmpty = pdfVal.length === 0;
+        for (const target of targets) {
+            if (isEmpty) {
+                target.content.delete('V');
+                target.appearanceState = null;
             }
-            // Separated field/widget structure: field has no Rect but its Kids
-            // are widget annotations that do. Generate appearances for them.
-            if (!this.rect) {
-                for (const child of this.children) {
-                    if (child.rect && child.defaultGenerateAppearance) {
-                        if (this._form)
-                            child.form = this._form;
-                        child.generateAppearance();
-                    }
-                }
+            else {
+                target.content.set('V', pdfVal);
             }
         }
-        if (this._form) {
-            this._form.xfa?.datasets?.updateField(this.name, this.value);
+        if (isEmpty) {
+            this._form?.xfa?.datasets?.updateField(this.name, '');
         }
+        if (this.defaultGenerateAppearance) {
+            this.generateAppearance();
+        }
+        for (const sibling of this.siblings) {
+            if (sibling !== this && sibling.defaultGenerateAppearance) {
+                sibling.generateAppearance();
+            }
+        }
+        // Separated field/widget structure: field has no Rect but its Kids
+        // are widget annotations that do. Clear stale V entries on children
+        // so they inherit the parent's value, then generate appearances.
+        for (const child of this.children) {
+            if (child.content.has('V')) {
+                child.content.delete('V');
+            }
+            if (child.defaultGenerateAppearance) {
+                if (this._form)
+                    child.form = this._form;
+                child.generateAppearance();
+            }
+        }
+        this._form?.xfa?.datasets?.updateField(this.name, this.value);
     }
-    /**
-     * 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.
-     */
-    _storeValue(val, fieldParent) {
-        const pdfVal = val instanceof PdfString ? val : new PdfString(val);
-        this.content.set('V', pdfVal);
-        fieldParent?.content.set('V', pdfVal);
-        return true;
+    set value(val) {
+        this.setRawValue(val);
+    }
+    set markdownValue(val) {
+        const plainText = parseMarkdownSegments(val)
+            .map((s) => s.text)
+            .join('');
+        // Store plain text as V without triggering appearance generation yet
+        const saved = this.defaultGenerateAppearance;
+        this.defaultGenerateAppearance = false;
+        this.setRawValue(plainText);
+        this.defaultGenerateAppearance = saved;
+        // setRawValue cleared _markdownValue; store the markdown string now
+        this._markdownValue = val;
+        if (this.defaultGenerateAppearance) {
+            this.generateAppearance();
+        }
     }
     get fontSize() {
         const da = this.defaultAppearance || '';
@@ -305,6 +405,8 @@ export class PdfFormField extends PdfWidgetAnnotation {
         }
         const resourceName = font.resourceName;
         const currentSize = this.fontSize ?? 12;
+        this._embedFontInDR(font);
+        // Update the DA string to use the font
         const da = this.defaultAppearance || '';
         if (!da) {
             this.content.set('DA', new PdfDefaultAppearance(resourceName, currentSize, '0 g'));
@@ -316,6 +418,62 @@ export class PdfFormField extends PdfWidgetAnnotation {
             this.content.set('DA', parsed);
         }
     }
+    _embedFontInDR(font) {
+        const resourceName = font.resourceName;
+        // Add font to field's default resources
+        const dr = this.content.get('DR') || new PdfDictionary();
+        let fontDict = dr.get('Font');
+        if (!fontDict) {
+            fontDict = new PdfDictionary();
+            dr.set('Font', fontDict);
+        }
+        fontDict.set(resourceName, font.reference);
+        this.content.set('DR', dr);
+        // Also add to form's default resources if available
+        if (this._form) {
+            const formDr = this._form.defaultResources ||
+                new PdfDictionary();
+            let formFontDict = formDr.get('Font');
+            if (!formFontDict) {
+                formFontDict = new PdfDictionary();
+                formDr.set('Font', formFontDict);
+            }
+            formFontDict.set(resourceName, font.reference);
+            this._form.defaultResources = formDr;
+        }
+    }
+    get fontFamily() {
+        return this._fontFamily ?? null;
+    }
+    set fontFamily(family) {
+        if (family === null) {
+            this._fontFamily = undefined;
+            return;
+        }
+        this._fontFamily = family;
+        // Setting regular via the existing setter keeps DA string in sync
+        this.font = family.regular;
+        if (family.bold)
+            this._embedFontInDR(family.bold);
+        if (family.italic)
+            this._embedFontInDR(family.italic);
+        if (family.boldItalic)
+            this._embedFontInDR(family.boldItalic);
+    }
+    get fontVariantNames() {
+        return {
+            bold: this._fontFamily?.bold?.resourceName,
+            italic: this._fontFamily?.italic?.resourceName,
+            boldItalic: this._fontFamily?.boldItalic?.resourceName,
+        };
+    }
+    get resolvedVariantFonts() {
+        return {
+            bold: this._fontFamily?.bold,
+            italic: this._fontFamily?.italic,
+            boldItalic: this._fontFamily?.boldItalic,
+        };
+    }
     get flags() {
         const flags = new PdfFormFieldFlags(this.content.get('Ff') ?? this.parent?.content.get('Ff') ?? 0);
         flags.onChange(() => {
@@ -499,7 +657,7 @@ export class PdfFormField extends PdfWidgetAnnotation {
             engine: this._form?.jsEngine,
         });
     }
-    setAppearanceStream(stream) {
+    set appearanceStream(stream) {
         this.appearanceStreamDict ||= new PdfDictionary();
         if (stream instanceof PdfIndirectObject) {
             this.appearanceStreamDict.set('N', stream.reference);
@@ -512,6 +670,35 @@ export class PdfFormField extends PdfWidgetAnnotation {
             this.appearanceStreamDict.set('N', dict);
         }
     }
+    set downAppearanceStream(stream) {
+        this.appearanceStreamDict ||= new PdfDictionary();
+        if (stream instanceof PdfIndirectObject) {
+            this.appearanceStreamDict.set('D', stream.reference);
+        }
+        else {
+            const dict = new PdfDictionary();
+            for (const key in stream) {
+                dict.set(key, stream[key].reference);
+            }
+            this.appearanceStreamDict.set('D', dict);
+        }
+    }
+    get appearanceState() {
+        return this.content.get('AS')?.as(PdfName)?.value ?? null;
+    }
+    set appearanceState(state) {
+        if (state === null) {
+            this.content.delete('AS');
+            return;
+        }
+        else {
+            this.content.set('AS', new PdfName(state));
+        }
+        if (this.defaultGenerateAppearance &&
+            !this.hasAppearanceStream(state)) {
+            this.generateAppearance();
+        }
+    }
     /**
      * Returns the list of appearance state names from the normal appearance
      * dictionary (e.g. ["Yes", "Off"] for a checkbox).
@@ -534,9 +721,7 @@ export class PdfFormField extends PdfWidgetAnnotation {
             }
         }
         else if (n instanceof PdfDictionary) {
-            const key = setting ??
-                this.content.get('AS')?.as(PdfName)?.value ??
-                undefined;
+            const key = setting ?? this.appearanceState ?? undefined;
             if (key) {
                 const entry = n.get(key);
                 if (entry instanceof PdfObjectReference) {
@@ -549,6 +734,9 @@ export class PdfFormField extends PdfWidgetAnnotation {
         }
         return null;
     }
+    hasAppearanceStream(setting) {
+        return this.appearanceStates.includes(setting);
+    }
     static _fallbackCtor;
     static _registry = new Map();
     static registerFieldType(ft, ctor, options) {

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

@@ -21,10 +21,27 @@ export class PdfTextFormField extends PdfFormField {
         if (!parsed)
             return false;
         const font = this.font;
-        const fontResources = this.buildFontResources(parsed.fontName);
+        const variantNames = this.fontVariantNames;
+        const variantFonts = this.resolvedVariantFonts;
+        const allFontNames = [
+            parsed.fontName,
+            variantNames.bold,
+            variantNames.italic,
+            variantNames.boldItalic,
+        ].filter((n) => !!n);
+        const fontResources = this.buildAllFontResources(allFontNames);
+        const resolvedFonts = new Map();
+        if (font)
+            resolvedFonts.set(parsed.fontName, font);
+        if (variantFonts.bold)
+            resolvedFonts.set(variantNames.bold, variantFonts.bold);
+        if (variantFonts.italic)
+            resolvedFonts.set(variantNames.italic, variantFonts.italic);
+        if (variantFonts.boldItalic)
+            resolvedFonts.set(variantNames.boldItalic, variantFonts.boldItalic);
         const isUnicode = font?.isUnicode ?? false;
         const reverseEncodingMap = font?.reverseEncodingMap;
-        this.setAppearanceStream(new PdfTextAppearanceStream({
+        this.appearanceStream = new PdfTextAppearanceStream({
             rect: rect,
             value: this.value,
             da: parsed,
@@ -32,9 +49,12 @@ export class PdfTextFormField extends PdfFormField {
             comb: this.comb,
             maxLen: this.maxLen,
             fontResources,
+            resolvedFonts,
             isUnicode,
             reverseEncodingMap,
-        }));
+            markdown: this._markdownValue,
+            fontVariantNames: variantNames,
+        });
         if (options?.makeReadOnly) {
             this.readOnly = true;
             if (!this.print)

package/dist/acroform/pdf-acro-form.d.ts

@@ -36,6 +36,7 @@ export declare class PdfAcroForm<T extends Record<string, string> = Record<strin
     set defaultResources(resources: PdfDefaultResourcesDictionary | null);
     get fields(): ReadonlyArray<PdfFormField>;
     addField(...fields: PdfFormField[]): void;
+    private _addWidgetToPage;
     set fields(newFields: PdfFormField[]);
     setValues(values: Partial<T>): void;
     importData(fields: T): void;

package/dist/acroform/pdf-acro-form.js

@@ -108,13 +108,24 @@ export class PdfAcroForm extends PdfIndirectObject {
         }
         for (const field of fields) {
             fieldsArray.items.push(field.reference);
-            // Auto-add to the page's Annots array
-            const page = field.page;
-            if (page) {
-                page.annotations.items.push(field.reference);
+            this._addWidgetToPage(field);
+            // Also register any child widgets (e.g. radio button group kids)
+            for (const child of field.children) {
+                this._addWidgetToPage(child);
             }
         }
     }
+    _addWidgetToPage(field) {
+        const page = field.page;
+        if (!page)
+            return;
+        const ref = field.reference;
+        const key = ref.key;
+        const alreadyPresent = page.annotations.items.some((r) => r instanceof PdfObjectReference && r.key === key);
+        if (!alreadyPresent) {
+            page.annotations.items.push(ref);
+        }
+    }
     set fields(newFields) {
         this.content.set('Fields', PdfArray.refs(newFields));
     }

package/dist/acroform/xfa/pdf-xfa-data.d.ts

@@ -17,5 +17,6 @@ export declare class PdfXfaData extends PdfIndirectObject<PdfStream> {
     getFieldValue(name: string): string | null;
     importData(fields: Record<string, string | undefined>): void;
     private static updateFieldValue;
-    private static escapeRegex;
+    private static leafName;
+    private static cleanSegments;
 }