pdf-lite 1.3.2 → 1.4.0

package/dist/acroform/PdfAcroForm.d.ts

@@ -0,0 +1,63 @@
+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';
+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 { PdfFormField } from './fields/PdfFormField.js';
+import './fields/PdfTextFormField.js';
+import './fields/PdfButtonFormField.js';
+import './fields/PdfChoiceFormField.js';
+import './fields/PdfSignatureFormField.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;
+}>;
+export declare class PdfAcroForm<T extends Record<string, string> = Record<string, string>> extends PdfIndirectObject<PdfDictionary<{
+    Fields: PdfArray<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?;
+    constructor(options?: {
+        other?: PdfIndirectObject;
+        fields?: PdfFormField[];
+        document?: PdfDocument;
+    });
+    private get fontEncodingCache();
+    get fontEncodingMaps(): Map<string, Map<number, string>>;
+    isModified(): boolean;
+    get needAppearances(): boolean;
+    set needAppearances(value: boolean);
+    get signatureFlags(): number;
+    set signatureFlags(flags: number);
+    get defaultAppearance(): string | null;
+    set defaultAppearance(da: string);
+    get defaultQuadding(): number;
+    set defaultQuadding(q: number);
+    get defaultResources(): PdfDefaultResourcesDictionary | null;
+    set defaultResources(resources: PdfDefaultResourcesDictionary | null);
+    setValues(values: Partial<T>): void;
+    importData(fields: T): void;
+    exportData(): Partial<T>;
+    getFontEncodingMap(fontName: string): Promise<Map<number, string> | null>;
+    static fromDocument(document: PdfDocument): Promise<PdfAcroForm | null>;
+    private cacheAllFontEncodings;
+    private updatePageAnnotations;
+    write(document: PdfDocument): Promise<void>;
+}

package/dist/acroform/PdfAcroForm.js

@@ -0,0 +1,279 @@
+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 { PdfBoolean } from '../core/objects/pdf-boolean.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfFontEncodingCache } from './PdfFontEncodingCache.js';
+import { PdfAnnotationWriter } from '../annotations/PdfAnnotationWriter.js';
+import { PdfXfaForm } from './xfa/PdfXfaForm.js';
+import { PdfFormField } from './fields/PdfFormField.js';
+// Import subclasses to trigger static registration blocks
+import './fields/PdfTextFormField.js';
+import './fields/PdfButtonFormField.js';
+import './fields/PdfChoiceFormField.js';
+import './fields/PdfSignatureFormField.js';
+export class PdfAcroForm extends PdfIndirectObject {
+    fields;
+    _fontEncodingCache;
+    document;
+    constructor(options) {
+        super(options?.other ??
+            new PdfIndirectObject({
+                content: new PdfDictionary(),
+            }));
+        this.fields = options?.fields ?? [];
+        this.document = options?.document;
+    }
+    get fontEncodingCache() {
+        if (!this._fontEncodingCache) {
+            this._fontEncodingCache = new PdfFontEncodingCache(this.document, this.defaultResources);
+        }
+        return this._fontEncodingCache;
+    }
+    get fontEncodingMaps() {
+        return this.fontEncodingCache.fontEncodingMaps;
+    }
+    isModified() {
+        return this.content.isModified();
+    }
+    get needAppearances() {
+        return (this.content.get('NeedAppearances')?.as(PdfBoolean)?.value ?? false);
+    }
+    set needAppearances(value) {
+        this.content.set('NeedAppearances', new PdfBoolean(value));
+    }
+    get signatureFlags() {
+        return this.content.get('SigFlags')?.as(PdfNumber)?.value ?? 0;
+    }
+    set signatureFlags(flags) {
+        this.content.set('SigFlags', new PdfNumber(flags));
+    }
+    get defaultAppearance() {
+        return this.content.get('DA')?.as(PdfString)?.value ?? null;
+    }
+    set defaultAppearance(da) {
+        this.content.set('DA', new PdfString(da));
+    }
+    get defaultQuadding() {
+        return this.content.get('Q')?.as(PdfNumber)?.value ?? 0;
+    }
+    set defaultQuadding(q) {
+        this.content.set('Q', new PdfNumber(q));
+    }
+    get defaultResources() {
+        return this.content.get('DR')?.as(PdfDictionary) ?? null;
+    }
+    set defaultResources(resources) {
+        if (resources === null) {
+            this.content.delete('DR');
+        }
+        else {
+            this.content.set('DR', resources);
+        }
+    }
+    setValues(values) {
+        for (const field of this.fields) {
+            const name = field.name;
+            if (name in values && values[name] !== undefined) {
+                field.value = values[name];
+            }
+        }
+    }
+    importData(fields) {
+        for (const field of this.fields) {
+            const name = field.name;
+            if (name && name in fields) {
+                field.value = fields[name];
+            }
+        }
+    }
+    exportData() {
+        const result = {};
+        for (const field of this.fields) {
+            const name = field.name;
+            if (name) {
+                result[name] = field.value;
+            }
+        }
+        return result;
+    }
+    async getFontEncodingMap(fontName) {
+        return this.fontEncodingCache.getFontEncodingMap(fontName);
+    }
+    static async fromDocument(document) {
+        const catalog = document.root;
+        if (!catalog)
+            return null;
+        const acroFormRef = catalog.content.get('AcroForm');
+        if (!acroFormRef)
+            return null;
+        let acroFormDict;
+        let acroFormContainer;
+        if (acroFormRef instanceof PdfObjectReference) {
+            const acroFormObject = await document.readObject({
+                objectNumber: acroFormRef.objectNumber,
+                generationNumber: acroFormRef.generationNumber,
+            });
+            if (!acroFormObject)
+                return null;
+            if (!(acroFormObject.content instanceof PdfDictionary))
+                throw new Error('AcroForm content must be a dictionary');
+            acroFormDict = acroFormObject.content;
+            acroFormContainer = acroFormObject;
+        }
+        else if (acroFormRef instanceof PdfDictionary) {
+            acroFormDict = acroFormRef;
+            acroFormContainer = new PdfIndirectObject({ content: acroFormDict });
+        }
+        else {
+            return null;
+        }
+        const acroForm = new PdfAcroForm({ other: acroFormContainer, document });
+        // Pre-cache font encoding maps for all fonts used in fields
+        await acroForm.cacheAllFontEncodings();
+        const fields = new Map();
+        const getFields = async (fieldRefs, parent) => {
+            for (const fieldRef of fieldRefs) {
+                const refKey = fieldRef.toString().trim();
+                if (fields.has(refKey)) {
+                    fields.get(refKey).parent = parent;
+                    continue;
+                }
+                const fieldObject = await document.readObject({
+                    objectNumber: fieldRef.objectNumber,
+                    generationNumber: fieldRef.generationNumber,
+                });
+                if (!fieldObject)
+                    continue;
+                if (!(fieldObject.content instanceof PdfDictionary))
+                    continue;
+                const field = PdfFormField.create({
+                    other: fieldObject,
+                    form: acroForm,
+                    parent,
+                });
+                const kids = field.kids;
+                if (kids.length > 0) {
+                    await getFields(kids, field);
+                }
+                acroForm.fields.push(field);
+                fields.set(refKey, field);
+            }
+        };
+        const fieldsArray = new PdfArray();
+        if (acroForm.content.get('Fields') instanceof PdfArray) {
+            fieldsArray.items.push(...acroForm.content
+                .get('Fields')
+                .as((PdfArray)).items);
+        }
+        else if (acroForm.content.get('Fields') instanceof PdfObjectReference) {
+            const fieldsObj = await document.readObject({
+                objectNumber: acroForm.content
+                    .get('Fields')
+                    .as(PdfObjectReference).objectNumber,
+                generationNumber: acroForm.content
+                    .get('Fields')
+                    .as(PdfObjectReference).generationNumber,
+            });
+            if (fieldsObj && fieldsObj.content instanceof PdfArray) {
+                fieldsArray.items.push(...fieldsObj.content.as((PdfArray)).items);
+            }
+        }
+        await getFields(fieldsArray.items);
+        // Reset field-level modified flag so only explicitly changed fields are detected
+        for (const field of acroForm.fields) {
+            field.setModified(false);
+        }
+        return acroForm;
+    }
+    async cacheAllFontEncodings() {
+        await this.fontEncodingCache.cacheAllFontEncodings(this.fields);
+    }
+    async updatePageAnnotations(document, fieldsByPage) {
+        await PdfAnnotationWriter.updatePageAnnotations(document, fieldsByPage);
+    }
+    async write(document) {
+        const catalog = document.root;
+        const isIncremental = document.isIncremental();
+        document.setIncremental(true);
+        const xfaForm = await PdfXfaForm.fromDocument(document);
+        if (xfaForm) {
+            // Only send fields whose value was explicitly changed (field.isModified())
+            const xfaFields = this.fields
+                .filter((f) => f.isModified() && f.fieldType !== 'Signature' && f.name)
+                .map((f) => ({ name: f.name, value: f.value }));
+            if (xfaFields.length > 0) {
+                xfaForm.datasets?.updateFields(xfaFields);
+            }
+        }
+        const fieldsArray = new PdfArray();
+        this.content.set('Fields', fieldsArray);
+        const fieldsByPage = new Map();
+        // Phase 1: add appearance streams standalone (PdfStream — cannot go in ObjStm)
+        // and collect field dicts for ObjStm batching.
+        const compressibleFields = [];
+        for (const field of this.fields) {
+            if (field.content.isModified()) {
+                const appearances = field.getAppearanceStreamsForWriting();
+                if (appearances) {
+                    document.add(appearances.primary);
+                    if (appearances.secondary) {
+                        document.add(appearances.secondary);
+                    }
+                    field.setAppearanceReference(appearances.primary.reference, appearances.secondary?.reference);
+                    if (!field.print) {
+                        field.print = true;
+                    }
+                }
+                compressibleFields.push(field);
+            }
+        }
+        // Phase 2: pack field dicts into ObjStm — pre-assigns their object numbers.
+        document.addObjectsAsStream(compressibleFields);
+        // Phase 3: build fieldsArray now that field object numbers are stable.
+        for (const field of this.fields) {
+            let fieldReference;
+            if (field.content.isModified()) {
+                fieldReference = new PdfObjectReference(field.objectNumber, field.generationNumber);
+                const parentRef = field.parentRef;
+                const isWidget = field.isWidget;
+                if (parentRef && isWidget) {
+                    const pageKey = `${parentRef.objectNumber}_${parentRef.generationNumber}`;
+                    if (!fieldsByPage.has(pageKey)) {
+                        fieldsByPage.set(pageKey, {
+                            pageRef: parentRef,
+                            fieldRefs: [],
+                        });
+                    }
+                    fieldsByPage.get(pageKey).fieldRefs.push(fieldReference);
+                }
+            }
+            else {
+                fieldReference = field.reference;
+            }
+            fieldsArray.push(fieldReference);
+        }
+        await this.updatePageAnnotations(document, fieldsByPage);
+        // Phase 4: pack AcroForm dict into ObjStm AFTER fieldsArray is populated,
+        // so the dict is serialized with the correct Fields array.
+        if (this.isModified()) {
+            document.addObjectsAsStream([this]);
+            if (!catalog.content.has('AcroForm')) {
+                let updatableCatalog = catalog;
+                if (catalog.isImmutable()) {
+                    updatableCatalog = catalog.clone();
+                    document.add(updatableCatalog);
+                }
+                updatableCatalog.content.set('AcroForm', this.reference);
+            }
+        }
+        // XFA datasets stream — PdfXfaData extends PdfIndirectObject<PdfStream>, must stay standalone
+        if (xfaForm) {
+            xfaForm.write(document);
+        }
+        await document.commit();
+        document.setIncremental(isIncremental);
+    }
+}

package/dist/acroform/PdfFontEncodingCache.d.ts

@@ -0,0 +1,16 @@
+import { PdfDocument } from '../pdf/pdf-document.js';
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import type { PdfDefaultResourcesDictionary } from './acroform.js';
+/**
+ * Resolves and caches font encoding maps from the form's default resources.
+ */
+export declare class PdfFontEncodingCache {
+    readonly fontEncodingMaps: Map<string, Map<number, string>>;
+    private document?;
+    private defaultResources;
+    constructor(document: PdfDocument | undefined, defaultResources: PdfDefaultResourcesDictionary | null);
+    getFontEncodingMap(fontName: string): Promise<Map<number, string> | null>;
+    cacheAllFontEncodings(fields: Array<{
+        content: PdfDictionary;
+    }>): Promise<void>;
+}

package/dist/acroform/PdfFontEncodingCache.js

@@ -0,0 +1,75 @@
+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 { buildEncodingMap } from '../utils/decodeWithFontEncoding.js';
+/**
+ * Resolves and caches font encoding maps from the form's default resources.
+ */
+export class PdfFontEncodingCache {
+    fontEncodingMaps = new Map();
+    document;
+    defaultResources;
+    constructor(document, defaultResources) {
+        this.document = document;
+        this.defaultResources = defaultResources;
+    }
+    async getFontEncodingMap(fontName) {
+        if (this.fontEncodingMaps.has(fontName)) {
+            return this.fontEncodingMaps.get(fontName);
+        }
+        const dr = this.defaultResources;
+        if (!dr)
+            return null;
+        const fonts = dr.get('Font')?.as(PdfDictionary);
+        if (!fonts)
+            return null;
+        const fontRef = fonts.get(fontName)?.as(PdfObjectReference);
+        if (!fontRef || !this.document)
+            return null;
+        const fontObj = await this.document.readObject({
+            objectNumber: fontRef.objectNumber,
+            generationNumber: fontRef.generationNumber,
+        });
+        if (!fontObj)
+            return null;
+        const fontDict = fontObj.content.as(PdfDictionary);
+        const encoding = fontDict.get('Encoding');
+        let encodingDict = null;
+        if (encoding instanceof PdfObjectReference) {
+            const encodingObj = await this.document.readObject({
+                objectNumber: encoding.objectNumber,
+                generationNumber: encoding.generationNumber,
+            });
+            encodingDict = encodingObj?.content.as(PdfDictionary) ?? null;
+        }
+        else if (encoding instanceof PdfDictionary) {
+            encodingDict = encoding;
+        }
+        if (!encodingDict)
+            return null;
+        const differences = encodingDict.get('Differences')?.as(PdfArray);
+        if (!differences)
+            return null;
+        const encodingMap = buildEncodingMap(differences);
+        if (!encodingMap)
+            return null;
+        this.fontEncodingMaps.set(fontName, encodingMap);
+        return encodingMap;
+    }
+    async cacheAllFontEncodings(fields) {
+        const fontNames = new Set();
+        for (const field of fields) {
+            const da = field.content.get('DA')?.as(PdfString)?.value;
+            if (da) {
+                const fontMatch = da.match(/\/(\w+)\s+[\d.]+\s+Tf/);
+                if (fontMatch) {
+                    fontNames.add(fontMatch[1]);
+                }
+            }
+        }
+        for (const fontName of fontNames) {
+            await this.getFontEncodingMap(fontName);
+        }
+    }
+}