pdf-oxide-fips 0.3.47

package/lib/form-field-manager.js

@@ -0,0 +1,568 @@
+/**
+ * FormFieldManager for form field operations
+ *
+ * Manages form fields in PDF documents including retrieval, modification, and flattening.
+ * API is consistent with Python, Java, C#, Go, and Swift implementations.
+ */
+import { EventEmitter } from 'events';
+/**
+ * Types of form fields
+ */
+export var FormFieldType;
+(function (FormFieldType) {
+    FormFieldType["Text"] = "Text";
+    FormFieldType["CheckBox"] = "CheckBox";
+    FormFieldType["RadioButton"] = "RadioButton";
+    FormFieldType["ComboBox"] = "ComboBox";
+    FormFieldType["ListBox"] = "ListBox";
+    FormFieldType["Button"] = "Button";
+    FormFieldType["Signature"] = "Signature";
+    FormFieldType["TextArea"] = "TextArea";
+})(FormFieldType || (FormFieldType = {}));
+/**
+ * Field visibility options
+ */
+export var FieldVisibility;
+(function (FieldVisibility) {
+    FieldVisibility["Visible"] = "Visible";
+    FieldVisibility["Hidden"] = "Hidden";
+    FieldVisibility["PrintOnly"] = "PrintOnly";
+    FieldVisibility["NoView"] = "NoView";
+})(FieldVisibility || (FieldVisibility = {}));
+/**
+ * Form Field Manager for form operations
+ *
+ * Provides methods to:
+ * - Retrieve form field information
+ * - Get and set field values
+ * - Create new form fields
+ * - Manage field properties
+ * - Flatten forms
+ */
+export class FormFieldManager extends EventEmitter {
+    constructor(document) {
+        super();
+        this.resultCache = new Map();
+        this.maxCacheSize = 100;
+        this.document = document;
+    }
+    /**
+     * Gets all form fields in the document
+     * Matches: Python getAllFields(), Java getAllFields(), C# GetAllFields()
+     */
+    async getAllFields() {
+        const cacheKey = 'formfields:all';
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // Call native PdfDocument method
+        try {
+            const fields = this.document.getFormFields?.() ?? [];
+            this.setCached(cacheKey, fields);
+            this.emit('fieldsRetrieved', fields.length);
+            return fields;
+        }
+        catch (err) {
+            this.emit('error', err);
+            return [];
+        }
+    }
+    /**
+     * Gets a specific form field by name
+     * Matches: Python getField(), Java getField(), C# GetField()
+     */
+    async getField(fieldName) {
+        const allFields = await this.getAllFields();
+        return allFields.find((f) => f.fieldName === fieldName);
+    }
+    /**
+     * Gets fields of a specific type
+     * Matches: Python getFieldsOfType(), Java getFieldsOfType(), C# GetFieldsOfType()
+     */
+    async getFieldsOfType(fieldType) {
+        const allFields = await this.getAllFields();
+        return allFields.filter((f) => f.fieldType === fieldType);
+    }
+    /**
+     * Gets the value of a form field
+     * Matches: Python getFieldValue(), Java getFieldValue(), C# GetFieldValue()
+     */
+    async getFieldValue(fieldName) {
+        const cacheKey = `formfields:value:${fieldName}`;
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // Call native PdfDocument method
+        try {
+            const value = this.document.getFieldValue?.(fieldName);
+            this.setCached(cacheKey, value);
+            return value || undefined;
+        }
+        catch (err) {
+            this.emit('error', err);
+            return undefined;
+        }
+    }
+    /**
+     * Sets the value of a form field
+     * Matches: Python setFieldValue(), Java setFieldValue(), C# SetFieldValue()
+     */
+    async setFieldValue(fieldName, value) {
+        // Call native PdfDocument method
+        try {
+            this.document.setFieldValue?.(fieldName, value);
+            this.clearCachePattern(`formfields:value:${fieldName}`);
+            this.emit('fieldValueChanged', fieldName, value);
+        }
+        catch (err) {
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    /**
+     * Gets field count
+     * Matches: Python getFieldCount(), Java getFieldCount(), C# GetFieldCount()
+     */
+    async getFieldCount() {
+        const cacheKey = 'formfields:count';
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // Call native PdfDocument method via getAllFields
+        try {
+            const fields = await this.getAllFields();
+            const count = fields.length;
+            this.setCached(cacheKey, count);
+            return count;
+        }
+        catch (err) {
+            this.emit('error', err);
+            return 0;
+        }
+    }
+    /**
+     * Checks if form has fields
+     * Matches: Python hasForm(), Java hasForm(), C# HasForm()
+     */
+    async hasForm() {
+        const count = await this.getFieldCount();
+        return count > 0;
+    }
+    /**
+     * Creates a new form field
+     * Matches: Python createField(), Java createField(), C# CreateField()
+     */
+    async createField(config) {
+        // In real implementation, would call native FFI
+        this.clearCachePattern('formfields:.*');
+        this.emit('fieldCreated', config.fieldName);
+    }
+    /**
+     * Removes a form field
+     * Matches: Python removeField(), Java removeField(), C# RemoveField()
+     */
+    async removeField(fieldName) {
+        // In real implementation, would call native FFI
+        this.clearCachePattern('formfields:.*');
+        this.emit('fieldRemoved', fieldName);
+    }
+    /**
+     * Flattens form fields (convert to content)
+     * Matches: Python flattenForm(), Java flattenForm(), C# FlattenForm()
+     */
+    async flattenForm() {
+        // In real implementation, would call native FFI
+        this.clearCachePattern('formfields:.*');
+        this.emit('formFlattened');
+    }
+    /**
+     * Resets all form fields to defaults
+     * Matches: Python resetForm(), Java resetForm(), C# ResetForm()
+     */
+    async resetForm() {
+        // In real implementation, would call native FFI
+        this.clearCachePattern('formfields:.*');
+        this.emit('formReset');
+    }
+    /**
+     * Clears the result cache
+     * Matches: Python clearCache(), Java clearCache(), C# ClearCache()
+     */
+    clearCache() {
+        this.resultCache.clear();
+        this.emit('cacheCleared');
+    }
+    /**
+     * Gets cache statistics
+     * Matches: Python getCacheStats(), Java getCacheStats(), C# GetCacheStats()
+     */
+    getCacheStats() {
+        return {
+            cacheSize: this.resultCache.size,
+            maxCacheSize: this.maxCacheSize,
+            entries: Array.from(this.resultCache.keys()),
+        };
+    }
+    // ========== New FFI-based Form Operations (22 new methods) ==========
+    /**
+     * Gets the AcroForm handle from the document
+     * Provides access to lower-level form operations
+     * @returns AcroForm handle
+     */
+    async getFormAcroform() {
+        const cacheKey = 'form:acroform';
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would call native FFI
+        // FormFieldFFI.documentGetAcroform(docHandle)
+        const acroformHandle = null;
+        this.setCached(cacheKey, acroformHandle);
+        return acroformHandle;
+    }
+    /**
+     * Exports form data to a file
+     * Supports FDF (0), XFDF (1), and JSON (2) formats
+     * @param filename Path to output file
+     * @param format Format type (0=FDF, 1=XFDF, 2=JSON)
+     * @returns Number of fields exported
+     */
+    async exportFormData(filename, format = 0) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldExportFormData(acroformHandle, filename, format)
+        this.clearCachePattern('form:.*');
+        this.emit('formDataExported', filename, format);
+        return 0;
+    }
+    /**
+     * Exports form data to bytes in memory
+     * Supports FDF (0), XFDF (1), and JSON (2) formats
+     * @param format Format type (0=FDF, 1=XFDF, 2=JSON)
+     * @returns Form data as byte array
+     */
+    async exportFormDataBytes(format = 0) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldExportFormDataBytes(acroformHandle, format)
+        this.emit('formDataExportedToBytes', format);
+        return new Uint8Array();
+    }
+    /**
+     * Imports form data from a file
+     * Supports FDF, XFDF, and JSON formats (auto-detected)
+     * @param filename Path to form data file
+     * @returns Number of fields updated
+     */
+    async importFormData(filename) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldImportFormData(acroformHandle, filename)
+        this.clearCachePattern('form:.*');
+        this.emit('formDataImported', filename);
+        return 0;
+    }
+    /**
+     * Resets all form fields to their default values
+     * @returns Number of fields reset
+     */
+    async resetAllFields() {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.documentResetFormFields(docHandle)
+        this.clearCachePattern('form:.*');
+        this.emit('allFieldsReset');
+        return 0;
+    }
+    /**
+     * Gets the default value of a form field
+     * @param fieldName Name of the field
+     * @returns Default value or empty string
+     */
+    async getFieldDefaultValue(fieldName) {
+        const cacheKey = `form:defaultvalue:${fieldName}`;
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldGetDefaultValue(fieldHandle)
+        const value = '';
+        this.setCached(cacheKey, value);
+        return value;
+    }
+    /**
+     * Sets the default value of a form field
+     * @param fieldName Name of the field
+     * @param value New default value
+     */
+    async setFieldDefaultValue(fieldName, value) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldSetDefaultValue(fieldHandle, value)
+        this.clearCachePattern(`form:defaultvalue:${fieldName}`);
+        this.emit('fieldDefaultValueChanged', fieldName, value);
+    }
+    /**
+     * Gets the flags of a form field (combination of bit flags)
+     * @param fieldName Name of the field
+     * @returns Field flags as integer
+     */
+    async getFieldFlags(fieldName) {
+        const cacheKey = `form:flags:${fieldName}`;
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldGetFlags(fieldHandle)
+        const flags = 0;
+        this.setCached(cacheKey, flags);
+        return flags;
+    }
+    /**
+     * Sets the flags of a form field
+     * Flags control field properties like readonly, required, etc.
+     * @param fieldName Name of the field
+     * @param flags New flags value
+     */
+    async setFieldFlags(fieldName, flags) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldSetFlags(fieldHandle, flags)
+        this.clearCachePattern(`form:flags:${fieldName}`);
+        this.emit('fieldFlagsChanged', fieldName, flags);
+    }
+    /**
+     * Gets the tooltip text for a form field
+     * @param fieldName Name of the field
+     * @returns Tooltip text or empty string
+     */
+    async getFieldTooltip(fieldName) {
+        const cacheKey = `form:tooltip:${fieldName}`;
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldGetTooltip(fieldHandle)
+        const tooltip = '';
+        this.setCached(cacheKey, tooltip);
+        return tooltip;
+    }
+    /**
+     * Sets the tooltip text for a form field
+     * @param fieldName Name of the field
+     * @param tooltip New tooltip text
+     */
+    async setFieldTooltip(fieldName, tooltip) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldSetTooltip(fieldHandle, tooltip)
+        this.clearCachePattern(`form:tooltip:${fieldName}`);
+        this.emit('fieldTooltipChanged', fieldName, tooltip);
+    }
+    /**
+     * Gets the alternate name (UI name) for a form field
+     * @param fieldName Name of the field
+     * @returns Alternate name or empty string
+     */
+    async getFieldAlternateName(fieldName) {
+        const cacheKey = `form:altname:${fieldName}`;
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldGetAlternateName(fieldHandle)
+        const name = '';
+        this.setCached(cacheKey, name);
+        return name;
+    }
+    /**
+     * Sets the alternate name (UI name) for a form field
+     * @param fieldName Name of the field
+     * @param alternateName New alternate name
+     */
+    async setFieldAlternateName(fieldName, alternateName) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldSetAlternateName(fieldHandle, alternateName)
+        this.clearCachePattern(`form:altname:${fieldName}`);
+        this.emit('fieldAlternateNameChanged', fieldName, alternateName);
+    }
+    /**
+     * Checks if a form field is read-only
+     * @param fieldName Name of the field
+     * @returns True if field is read-only
+     */
+    async isFieldReadonly(fieldName) {
+        const cacheKey = `form:readonly:${fieldName}`;
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldIsReadonly(fieldHandle)
+        const readonly = false;
+        this.setCached(cacheKey, readonly);
+        return readonly;
+    }
+    /**
+     * Sets the read-only status of a form field
+     * @param fieldName Name of the field
+     * @param readonly True to make field read-only
+     */
+    async setFieldReadonly(fieldName, readonly) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldSetReadonly(fieldHandle, readonly)
+        this.clearCachePattern(`form:readonly:${fieldName}`);
+        this.emit('fieldReadonlyChanged', fieldName, readonly);
+    }
+    /**
+     * Checks if a form field is required
+     * @param fieldName Name of the field
+     * @returns True if field is required
+     */
+    async isFieldRequired(fieldName) {
+        const cacheKey = `form:required:${fieldName}`;
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldIsRequired(fieldHandle)
+        const required = false;
+        this.setCached(cacheKey, required);
+        return required;
+    }
+    /**
+     * Sets the required status of a form field
+     * @param fieldName Name of the field
+     * @param required True to make field required
+     */
+    async setFieldRequired(fieldName, required) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldSetRequired(fieldHandle, required)
+        this.clearCachePattern(`form:required:${fieldName}`);
+        this.emit('fieldRequiredChanged', fieldName, required);
+    }
+    /**
+     * Gets the background color of a form field
+     * @param fieldName Name of the field
+     * @returns Color as [R, G, B] array (0-255) or null if no color
+     */
+    async getFieldBackgroundColor(fieldName) {
+        const cacheKey = `form:bgcolor:${fieldName}`;
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldGetBackgroundColor(fieldHandle) -> packed RGB
+        // Unpack: [(rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF]
+        const color = null;
+        this.setCached(cacheKey, color);
+        return color;
+    }
+    /**
+     * Sets the background color of a form field
+     * @param fieldName Name of the field
+     * @param red Red component (0-255)
+     * @param green Green component (0-255)
+     * @param blue Blue component (0-255)
+     */
+    async setFieldBackgroundColor(fieldName, red, green, blue) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldSetBackgroundColor(fieldHandle, red, green, blue)
+        this.clearCachePattern(`form:bgcolor:${fieldName}`);
+        this.emit('fieldBackgroundColorChanged', fieldName, [red, green, blue]);
+    }
+    /**
+     * Gets the text color of a form field
+     * @param fieldName Name of the field
+     * @returns Color as [R, G, B] array (0-255) or null if no color
+     */
+    async getFieldTextColor(fieldName) {
+        const cacheKey = `form:textcolor:${fieldName}`;
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldGetTextColor(fieldHandle) -> packed RGB
+        // Unpack: [(rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF]
+        const color = null;
+        this.setCached(cacheKey, color);
+        return color;
+    }
+    /**
+     * Sets the text color of a form field
+     * @param fieldName Name of the field
+     * @param red Red component (0-255)
+     * @param green Green component (0-255)
+     * @param blue Blue component (0-255)
+     */
+    async setFieldTextColor(fieldName, red, green, blue) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldSetTextColor(fieldHandle, red, green, blue)
+        this.clearCachePattern(`form:textcolor:${fieldName}`);
+        this.emit('fieldTextColorChanged', fieldName, [red, green, blue]);
+    }
+    /**
+     * Validates a form field
+     * Checks field consistency and compliance
+     * @param fieldName Name of the field
+     * @returns True if field is valid
+     */
+    async validateField(fieldName) {
+        // In real implementation, would call native FFI
+        // FormFieldFFI.formFieldValidate(fieldHandle)
+        this.emit('fieldValidated', fieldName);
+        return true;
+    }
+    /**
+     * Gets form statistics
+     * @returns Object with form statistics
+     */
+    async getFormStatistics() {
+        const cacheKey = 'form:statistics';
+        if (this.resultCache.has(cacheKey)) {
+            return this.resultCache.get(cacheKey);
+        }
+        // In real implementation, would combine multiple FFI calls
+        const stats = {
+            total_fields: 0,
+            required_fields: 0,
+            readonly_fields: 0,
+        };
+        this.setCached(cacheKey, stats);
+        return stats;
+    }
+    /**
+     * Batch sets multiple field values
+     * @param values Map of field names to values
+     * @returns Number of fields updated
+     */
+    async batchSetValues(values) {
+        // In real implementation, would call FFI for each field
+        this.clearCachePattern('form:.*');
+        this.emit('batchValuesSet', Object.keys(values).length);
+        return Object.keys(values).length;
+    }
+    /**
+     * Batch gets multiple field values
+     * @param fieldNames Array of field names
+     * @returns Map of field names to values
+     */
+    async getBatchValues(fieldNames) {
+        const result = {};
+        for (const name of fieldNames) {
+            result[name] = '';
+        }
+        return result;
+    }
+    // Private helper methods
+    setCached(key, value) {
+        this.resultCache.set(key, value);
+        // Simple LRU eviction
+        if (this.resultCache.size > this.maxCacheSize) {
+            const firstKey = this.resultCache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.resultCache.delete(firstKey);
+            }
+        }
+    }
+    clearCachePattern(pattern) {
+        const regex = new RegExp(pattern);
+        const keysToDelete = Array.from(this.resultCache.keys()).filter((key) => regex.test(key));
+        keysToDelete.forEach((key) => {
+            this.resultCache.delete(key);
+        });
+    }
+}
+export default FormFieldManager;

package/lib/hybrid-ml-manager.d.ts

@@ -0,0 +1,142 @@
+/**
+ * HybridMLManager for advanced PDF analysis using machine learning
+ *
+ * Analyzes PDF pages for complexity, content type, and optimal extraction strategies.
+ * API is consistent with Python, Java, C#, Go, and Swift implementations.
+ */
+import { EventEmitter } from 'events';
+/**
+ * Page complexity levels
+ */
+export declare enum PageComplexity {
+    Simple = "simple",
+    Moderate = "moderate",
+    Complex = "complex",
+    VeryComplex = "very_complex"
+}
+/**
+ * Content type classifications
+ */
+export declare enum ContentType {
+    TextOnly = "text_only",
+    TextImages = "text_images",
+    Tables = "tables",
+    MixedLayout = "mixed_layout",
+    Scanned = "scanned",
+    Form = "form",
+    VectorGraphics = "vector_graphics"
+}
+/**
+ * Page analysis result
+ */
+export interface PageAnalysisResult {
+    pageIndex: number;
+    complexity: PageComplexity;
+    complexityScore: number;
+    contentType: ContentType;
+    textDensity: number;
+    imageDensity: number;
+    hasText: boolean;
+    hasImages: boolean;
+    hasTables: boolean;
+    estimatedProcessingTime: number;
+}
+/**
+ * Extraction strategy recommendation
+ */
+export interface ExtractionStrategy {
+    pageIndex: number;
+    description: string;
+    recommendsOcr: boolean;
+    recommendedMethod: string;
+    confidence: number;
+}
+/**
+ * Table region information
+ */
+export interface TableRegion {
+    pageIndex: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rowCount: number;
+    columnCount: number;
+    confidence: number;
+}
+/**
+ * Column region information
+ */
+export interface ColumnRegion {
+    x: number;
+    width: number;
+    confidence: number;
+}
+/**
+ * Hybrid ML Manager for advanced PDF analysis
+ *
+ * Provides methods to:
+ * - Analyze page complexity
+ * - Detect content types
+ * - Recommend extraction strategies
+ * - Detect tables and columns
+ * - Estimate processing time
+ */
+export declare class HybridMLManager extends EventEmitter {
+    private document;
+    private resultCache;
+    private maxCacheSize;
+    constructor(document: any);
+    /**
+     * Analyzes a specific page
+     * Matches: Python analyzePage(), Java analyzePage(), C# AnalyzePage()
+     */
+    analyzePage(pageIndex: number): Promise<PageAnalysisResult>;
+    /**
+     * Analyzes all pages in the document
+     * Matches: Python analyzeDocument(), Java analyzeDocument(), C# AnalyzeDocument()
+     */
+    analyzeDocument(): Promise<PageAnalysisResult[]>;
+    /**
+     * Gets extraction strategy recommendation for a page
+     * Matches: Python getExtractionStrategy(), Java getExtractionStrategy(), C# GetExtractionStrategy()
+     */
+    getExtractionStrategy(pageIndex: number): Promise<ExtractionStrategy>;
+    /**
+     * Detects tables on a page
+     * Matches: Python detectTables(), Java detectTables(), C# DetectTables()
+     */
+    detectTables(pageIndex: number): Promise<TableRegion[]>;
+    /**
+     * Detects columns on a page
+     * Matches: Python detectColumns(), Java detectColumns(), C# DetectColumns()
+     */
+    detectColumns(pageIndex: number): Promise<ColumnRegion[]>;
+    /**
+     * Gets average page complexity in document
+     * Matches: Python getAverageComplexity(), Java getAverageComplexity(), C# GetAverageComplexity()
+     */
+    getAverageComplexity(): Promise<number>;
+    /**
+     * Gets most common content type
+     * Matches: Python getMostCommonContentType(), Java getMostCommonContentType(), C# GetMostCommonContentType()
+     */
+    getMostCommonContentType(): Promise<ContentType>;
+    /**
+     * Estimates total document processing time
+     * Matches: Python estimateProcessingTime(), Java estimateProcessingTime(), C# EstimateProcessingTime()
+     */
+    estimateProcessingTime(): Promise<number>;
+    /**
+     * Clears the result cache
+     * Matches: Python clearCache(), Java clearCache(), C# ClearCache()
+     */
+    clearCache(): void;
+    /**
+     * Gets cache statistics
+     * Matches: Python getCacheStats(), Java getCacheStats(), C# GetCacheStats()
+     */
+    getCacheStats(): Record<string, any>;
+    private setCached;
+}
+export default HybridMLManager;