pdf-lite 1.5.0 → 1.6.1

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

@@ -1,8 +1,12 @@
 import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
 import { PdfArray } from '../../core/objects/pdf-array.js';
 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 { PdfName } from '../../core/objects/pdf-name.js';
 import { PdfNumber } from '../../core/objects/pdf-number.js';
+import { PdfFont } from '../../fonts/pdf-font.js';
+import { PdfStream } from '../../core/objects/pdf-stream.js';
 import { decodeWithFontEncoding } from '../../utils/decodeWithFontEncoding.js';
 import { PdfWidgetAnnotation } from '../../annotations/pdf-widget-annotation.js';
 import { PdfDefaultAppearance } from './pdf-default-appearance.js';
@@ -14,63 +18,141 @@ import { PdfFormFieldFlags } from './pdf-form-field-flags.js';
  * Subclasses must implement generateAppearance().
  */
 export class PdfFormField extends PdfWidgetAnnotation {
-    _parent;
     defaultGenerateAppearance = true;
-    _appearanceStream;
-    _appearanceStreamYes;
-    form;
-    constructor(options) {
-        super({ other: options?.other });
-        this.form = options?.form;
-        if (options?.parent) {
-            this._parent = options.parent;
+    /** @internal */
+    _form;
+    constructor(other) {
+        super();
+        if (other && !(other instanceof PdfIndirectObject)) {
+            this._form = other.form;
         }
     }
+    set form(f) {
+        this._form = f;
+    }
+    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 cls = ft ? PdfFormField._registry.get(ft) : undefined;
+        if (!cls) {
+            if (PdfFormField._fallbackCtor) {
+                return other.becomes(PdfFormField._fallbackCtor);
+            }
+            throw new Error(`Unsupported form field type: ${ft ?? 'unknown'}`);
+        }
+        return other.becomes(cls);
+    }
     get parent() {
-        if (this._parent)
-            return this._parent;
-        if (!this.form)
+        const resolved = this.content.get('Parent')?.resolve();
+        if (!resolved || !(resolved.content instanceof PdfDictionary))
             return undefined;
-        return this.form.fields.find((f) => f !== this &&
-            f.kids.some((k) => k.objectNumber === this.objectNumber &&
-                k.generationNumber === this.generationNumber));
+        return PdfFormField.create(resolved);
     }
     set parent(field) {
-        if (this._parent) {
-            this._parent.kids = this._parent.kids.filter((k) => k.objectNumber !== this.objectNumber ||
-                k.generationNumber !== this.generationNumber);
-        }
-        this._parent = field;
-        if (field) {
-            const alreadyInKids = field.kids.some((k) => k.objectNumber === this.objectNumber &&
-                k.generationNumber === this.generationNumber);
-            if (!alreadyInKids) {
-                field.kids = [...field.kids, this.reference];
-            }
+        if (!field) {
+            this.content.delete('Parent');
+            return;
+        }
+        this.content.set('Parent', field.reference);
+        if (field instanceof PdfFormField) {
+            field.children = [...field.children, this];
         }
     }
     get children() {
-        if (!this.form)
-            return [];
-        return this.form.fields.filter((f) => f.parent === this);
+        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;
     }
     set children(fields) {
-        for (const child of this.children) {
-            child._parent = undefined;
+        if (fields.length === 0) {
+            this.content.delete('Kids');
+            return;
         }
-        this.kids = fields.map((f) => f.reference);
+        this.content.set('Kids', PdfArray.refs(fields));
         for (const child of fields) {
-            child._parent = this;
+            child.content.set('Parent', this.reference);
         }
     }
     get siblings() {
         return this.parent?.children ?? [];
     }
-    get encodingMap() {
+    get font() {
         const fontName = this.fontName;
         if (!fontName)
-            return undefined;
-        return this.form?.fontEncodingMaps?.get(fontName);
+            return null;
+        // Try resolving from default resources (DR) dict
+        const dr = this.defaultResources;
+        const fontDict = dr?.get('Font');
+        if (fontDict instanceof PdfDictionary) {
+            const fontEntry = fontDict.get(fontName);
+            if (fontEntry instanceof PdfObjectReference) {
+                const resolved = fontEntry.resolve();
+                if (resolved?.content instanceof PdfDictionary) {
+                    const font = resolved.becomes(PdfFont);
+                    font.resourceName = fontName;
+                    return font;
+                }
+            }
+        }
+        // Fallback: standard font lookup (Helv, Helvetica, ZaDb, etc.)
+        return PdfFont.getStandardFont(fontName) ?? null;
+    }
+    get defaultResources() {
+        const dr = this.content.get('DR');
+        const drDict = dr instanceof PdfObjectReference ? dr.resolve()?.content : dr;
+        return ((drDict instanceof PdfDictionary ? drDict : null) ??
+            this.parent?.defaultResources ??
+            this._form?.defaultResources ??
+            null);
+    }
+    set defaultResources(resources) {
+        if (resources === null) {
+            this.content.delete('DR');
+        }
+        else {
+            this.content.set('DR', resources);
+        }
+    }
+    /**
+     * Builds a Resources dictionary containing the font entry for `fontName`,
+     * resolved from DR (handling indirect references) or from a loaded font.
+     * Returns undefined if neither source provides the font.
+     */
+    buildFontResources(fontName) {
+        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;
+        }
+        if (drFontDict && drFontDict.get(fontName)) {
+            const resFontDict = new PdfDictionary();
+            resFontDict.set(fontName, drFontDict.get(fontName));
+            const resources = new PdfDictionary();
+            resources.set('Font', resFontDict);
+            return resources;
+        }
+        const font = this.font;
+        if (font && !PdfFont.getStandardFont(fontName)) {
+            const fontDict = new PdfDictionary();
+            fontDict.set(fontName, font.reference);
+            const resources = new PdfDictionary();
+            resources.set('Font', fontDict);
+            return resources;
+        }
+        return undefined;
     }
     get fieldType() {
         const ft = this.content.get('FT')?.as(PdfName)?.value ??
@@ -123,8 +205,12 @@ export class PdfFormField extends PdfWidgetAnnotation {
         if (v instanceof PdfString) {
             if (v.isUTF16BE)
                 return v.value;
-            if (this.encodingMap) {
-                return decodeWithFontEncoding(v.raw, this.encodingMap);
+            const encodingMap = this.font?.encodingMap ??
+                (this.fontName
+                    ? this._form?.fontEncodingMaps?.get(this.fontName)
+                    : undefined);
+            if (encodingMap) {
+                return decodeWithFontEncoding(v.raw, encodingMap);
             }
             return v.value;
         }
@@ -141,15 +227,29 @@ export class PdfFormField extends PdfWidgetAnnotation {
             : undefined;
         const generateAppearance = this._storeValue(val, fieldParent);
         if (generateAppearance && this.defaultGenerateAppearance) {
-            this.tryGenerateAppearance(this);
+            this.generateAppearance();
             for (const sibling of this.siblings) {
                 if (sibling !== this &&
                     sibling.rect &&
                     sibling.defaultGenerateAppearance) {
-                    this.tryGenerateAppearance(sibling);
+                    sibling.generateAppearance();
+                }
+            }
+            // 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();
+                    }
                 }
             }
         }
+        if (this._form) {
+            this._form.xfa?.datasets?.updateField(this.name, this.value);
+        }
     }
     /**
      * Writes the value to the dictionary. Returns true if appearance generation
@@ -162,15 +262,6 @@ export class PdfFormField extends PdfWidgetAnnotation {
         fieldParent?.content.set('V', pdfVal);
         return true;
     }
-    tryGenerateAppearance(field) {
-        field.generateAppearance();
-    }
-    get checked() {
-        return false;
-    }
-    set checked(_isChecked) {
-        // no-op for non-button fields; overridden in PdfButtonFormField
-    }
     get fontSize() {
         const da = this.defaultAppearance || '';
         const parsed = PdfDefaultAppearance.parse(da);
@@ -342,8 +433,8 @@ export class PdfFormField extends PdfWidgetAnnotation {
     }
     get defaultAppearance() {
         return (this.content.get('DA')?.as(PdfString)?.value ??
-            this.parent?.content.get('DA')?.as(PdfString)?.value ??
-            this.form?.defaultAppearance ??
+            this.parent?.defaultAppearance ??
+            this._form?.defaultAppearance ??
             null);
     }
     set defaultAppearance(da) {
@@ -365,8 +456,8 @@ export class PdfFormField extends PdfWidgetAnnotation {
             .get('Kids')
             ?.as((PdfArray));
         if (!kidsArray)
-            return [];
-        return kidsArray.items;
+            return undefined;
+        return kidsArray;
     }
     set kids(kids) {
         if (kids.length === 0) {
@@ -376,21 +467,44 @@ export class PdfFormField extends PdfWidgetAnnotation {
         const kidsArray = new PdfArray(kids);
         this.content.set('Kids', kidsArray);
     }
-    getAppearanceStream() {
-        return this._appearanceStream?.content;
-    }
-    getAppearanceStreamsForWriting() {
-        if (!this._appearanceStream)
-            return undefined;
-        return { primary: this._appearanceStream };
+    setAppearanceStream(stream) {
+        this.appearanceStreamDict ||= new PdfDictionary();
+        if (stream instanceof PdfIndirectObject) {
+            this.appearanceStreamDict.set('N', stream.reference);
+        }
+        else {
+            const dict = new PdfDictionary();
+            for (const key in stream) {
+                dict.set(key, stream[key].reference);
+            }
+            this.appearanceStreamDict.set('N', dict);
+        }
     }
-    setAppearanceReference(appearanceStreamRef, _appearanceStreamYesRef) {
-        let apDict = this.appearanceStreamDict;
-        if (!apDict) {
-            apDict = new PdfDictionary();
-            this.appearanceStreamDict = apDict;
+    getAppearanceStream(setting) {
+        const n = this.appearanceStreamDict?.get('N');
+        if (!n)
+            return null;
+        if (n instanceof PdfObjectReference) {
+            const resolved = n.resolve();
+            if (resolved?.content instanceof PdfStream) {
+                return resolved;
+            }
+        }
+        else if (n instanceof PdfDictionary) {
+            const key = setting ??
+                this.content.get('AS')?.as(PdfName)?.value ??
+                undefined;
+            if (key) {
+                const entry = n.get(key);
+                if (entry instanceof PdfObjectReference) {
+                    const resolved = entry.resolve();
+                    if (resolved?.content instanceof PdfStream) {
+                        return resolved;
+                    }
+                }
+            }
         }
-        apDict.set('N', appearanceStreamRef);
+        return null;
     }
     static _fallbackCtor;
     static _registry = new Map();
@@ -400,34 +514,6 @@ export class PdfFormField extends PdfWidgetAnnotation {
             PdfFormField._fallbackCtor = ctor;
         }
     }
-    static create(options) {
-        let ft;
-        try {
-            const dict = options.other.content.as(PdfDictionary);
-            ft = dict.get('FT')?.as(PdfName)?.value;
-        }
-        catch {
-            // content may not be a dictionary
-        }
-        if (!ft && options.parent) {
-            try {
-                ft = options.parent.content.get('FT')?.as(PdfName)?.value;
-            }
-            catch {
-                // ignore
-            }
-        }
-        const Ctor = ft ? PdfFormField._registry.get(ft) : undefined;
-        if (!Ctor) {
-            // Fields without FT are parent/container nodes — use the
-            // fallback type (typically Text) as a concrete stand-in.
-            if (!PdfFormField._fallbackCtor) {
-                throw new Error(`Unknown field type: ${ft ?? '(none)'}`);
-            }
-            return new PdfFormField._fallbackCtor(options);
-        }
-        return new Ctor(options);
-    }
 }
 /** Backward compatible alias */
 export { PdfFormField as PdfAcroFormField };

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

@@ -1,8 +1,6 @@
 import { PdfFormField } from './pdf-form-field.js';
 import { PdfDefaultAppearance } from './pdf-default-appearance.js';
 import { PdfTextAppearanceStream } from '../appearance/pdf-text-appearance-stream.js';
-import { PdfDictionary } from '../../core/objects/pdf-dictionary.js';
-import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
 /**
  * Text form field subtype.
  */
@@ -22,36 +20,11 @@ export class PdfTextFormField extends PdfFormField {
         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 PdfTextAppearanceStream({
+        const font = this.font;
+        const fontResources = this.buildFontResources(parsed.fontName);
+        const isUnicode = font?.isUnicode ?? false;
+        const reverseEncodingMap = font?.reverseEncodingMap;
+        this.setAppearanceStream(new PdfTextAppearanceStream({
             rect: rect,
             value: this.value,
             da: parsed,
@@ -61,7 +34,7 @@ export class PdfTextFormField extends PdfFormField {
             fontResources,
             isUnicode,
             reverseEncodingMap,
-        });
+        }));
         if (options?.makeReadOnly) {
             this.readOnly = true;
             if (!this.print)

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

@@ -1,4 +1,4 @@
-import type { PdfDefaultResourcesDictionary } from '../acroform.js';
+import { PdfDefaultResourcesDictionary } from '../../annotations/pdf-default-resources.js';
 import type { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
 /**
  * Field types for AcroForm fields

package/dist/acroform/index.d.ts

@@ -1,6 +1,4 @@
-export * from './manager.js';
 export * from './pdf-acro-form.js';
 export * from './fields/index.js';
 export * from './appearance/index.js';
 export * from './xfa/index.js';
-export { PdfFontEncodingCache } from './pdf-font-encoding-cache.js';

package/dist/acroform/index.js

@@ -1,6 +1,4 @@
-export * from './manager.js';
 export * from './pdf-acro-form.js';
 export * from './fields/index.js';
 export * from './appearance/index.js';
 export * from './xfa/index.js';
-export { PdfFontEncodingCache } from './pdf-font-encoding-cache.js';

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

@@ -1,4 +1,3 @@
-import { PdfDocument } from '../pdf/pdf-document.js';
 import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
 import { PdfArray } from '../core/objects/pdf-array.js';
 import { PdfString } from '../core/objects/pdf-string.js';
@@ -6,46 +5,24 @@ import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
 import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
 import { PdfBoolean } from '../core/objects/pdf-boolean.js';
 import { PdfNumber } from '../core/objects/pdf-number.js';
-import { PdfXfaForm } from './xfa/pdf-xfa-form.js';
 import { PdfFormField } from './fields/pdf-form-field.js';
 import './fields/pdf-text-form-field.js';
 import './fields/pdf-button-form-field.js';
 import './fields/pdf-choice-form-field.js';
 import './fields/pdf-signature-form-field.js';
-import type { FormContext } from './fields/types.js';
-export type PdfDefaultResourcesDictionary = PdfDictionary<{
-    Font?: PdfDictionary;
-    ProcSet?: PdfArray;
-    ExtGState?: PdfDictionary;
-    ColorSpace?: PdfDictionary;
-    Pattern?: PdfDictionary;
-    Shading?: PdfDictionary;
-    XObject?: PdfDictionary;
-}>;
+import { PdfDefaultResourcesDictionary } from '../annotations/pdf-default-resources.js';
+import { PdfXfaForm } from './xfa/pdf-xfa-form.js';
 export declare class PdfAcroForm<T extends Record<string, string> = Record<string, string>> extends PdfIndirectObject<PdfDictionary<{
-    Fields: PdfArray<PdfObjectReference>;
+    Fields: PdfArray<PdfObjectReference> | PdfObjectReference;
     NeedAppearances?: PdfBoolean;
     SigFlags?: PdfNumber;
     CO?: PdfArray<PdfObjectReference>;
     DR?: PdfDefaultResourcesDictionary;
     DA?: PdfString;
     Q?: PdfNumber;
-    XFA?: PdfDictionary;
-}>> implements FormContext<PdfFormField> {
-    fields: PdfFormField[];
-    private _fontEncodingCache?;
-    private document?;
-    private _xfa?;
-    constructor(options?: {
-        other?: PdfIndirectObject;
-        fields?: PdfFormField[];
-        document?: PdfDocument;
-    });
-    private get fontEncodingCache();
-    get fontEncodingMaps(): Map<string, Map<number, string>>;
-    get fontRefs(): Map<string, PdfObjectReference>;
-    setXfa(xfa: PdfXfaForm | null): void;
-    isModified(): boolean;
+    XFA?: PdfArray<PdfObjectReference>;
+}>> {
+    constructor(options?: PdfIndirectObject);
     get needAppearances(): boolean;
     set needAppearances(value: boolean);
     get signatureFlags(): number;
@@ -56,14 +33,13 @@ export declare class PdfAcroForm<T extends Record<string, string> = Record<strin
     set defaultQuadding(q: number);
     get defaultResources(): PdfDefaultResourcesDictionary | null;
     set defaultResources(resources: PdfDefaultResourcesDictionary | null);
+    get fields(): ReadonlyArray<PdfFormField>;
+    addField(...fields: PdfFormField[]): void;
+    set fields(newFields: PdfFormField[]);
     setValues(values: Partial<T>): void;
     importData(fields: T): void;
     exportData(): Partial<T>;
-    getFontEncodingMap(fontName: string): Promise<Map<number, string> | null>;
-    isFontUnicode(fontName: string): boolean;
-    static fromDocument(document: PdfDocument): Promise<PdfAcroForm | null>;
-    private cacheAllFontEncodings;
-    private updatePageAnnotations;
-    getXfa(document?: PdfDocument): Promise<PdfXfaForm | null>;
-    write(document?: PdfDocument): Promise<void>;
+    fontEncodingMaps: Map<string, Map<number, string>>;
+    getFontEncodingMap(fontName: string): Map<number, string> | null;
+    get xfa(): PdfXfaForm | null;
 }