pdf-oxide-fips 0.3.47

package/lib/managers/compliance-manager.js

@@ -0,0 +1,453 @@
+/**
+ * ComplianceManager - Canonical Compliance Manager (merged from 2 implementations)
+ *
+ * Consolidates:
+ * - src/compliance-manager.ts ComplianceManager (validation + issue analysis + native FFI)
+ * - src/managers/ocr-compliance-cache.ts ComplianceManager (validation + conversion + fixing)
+ *
+ * Provides complete PDF/A, PDF/X, PDF/UA compliance operations.
+ */
+import { EventEmitter } from 'events';
+import { promises as fs } from 'fs';
+import { dirname } from 'path';
+// =============================================================================
+// Type Definitions (from root-level compliance-manager.ts)
+// =============================================================================
+export var PdfALevel;
+(function (PdfALevel) {
+    PdfALevel["A1a"] = "PDF/A-1a";
+    PdfALevel["A1b"] = "PDF/A-1b";
+    PdfALevel["A2a"] = "PDF/A-2a";
+    PdfALevel["A2b"] = "PDF/A-2b";
+    PdfALevel["A3a"] = "PDF/A-3a";
+    PdfALevel["A3b"] = "PDF/A-3b";
+})(PdfALevel || (PdfALevel = {}));
+export var PdfXLevel;
+(function (PdfXLevel) {
+    PdfXLevel["X1a"] = "PDF/X-1a";
+    PdfXLevel["X1a2001"] = "PDF/X-1a:2001";
+    PdfXLevel["X1a2003"] = "PDF/X-1a:2003";
+    PdfXLevel["X3"] = "PDF/X-3";
+    PdfXLevel["X3_2002"] = "PDF/X-3:2002";
+    PdfXLevel["X3_2003"] = "PDF/X-3:2003";
+    PdfXLevel["X4"] = "PDF/X-4";
+})(PdfXLevel || (PdfXLevel = {}));
+export var PdfUALevel;
+(function (PdfUALevel) {
+    PdfUALevel["UA1"] = "PDF/UA-1";
+    PdfUALevel["UA2"] = "PDF/UA-2";
+})(PdfUALevel || (PdfUALevel = {}));
+export var ComplianceIssueType;
+(function (ComplianceIssueType) {
+    ComplianceIssueType["FontNotEmbedded"] = "font_not_embedded";
+    ComplianceIssueType["InvalidColorSpace"] = "invalid_color_space";
+    ComplianceIssueType["MissingAltText"] = "missing_alt_text";
+    ComplianceIssueType["MissingLanguage"] = "missing_language";
+    ComplianceIssueType["MissingTitle"] = "missing_title";
+    ComplianceIssueType["InvalidAnnotation"] = "invalid_annotation";
+    ComplianceIssueType["MissingStructure"] = "missing_structure";
+    ComplianceIssueType["InvalidLink"] = "invalid_link";
+    ComplianceIssueType["Other"] = "other";
+})(ComplianceIssueType || (ComplianceIssueType = {}));
+export var IssueSeverity;
+(function (IssueSeverity) {
+    IssueSeverity["Error"] = "error";
+    IssueSeverity["Warning"] = "warning";
+    IssueSeverity["Info"] = "info";
+})(IssueSeverity || (IssueSeverity = {}));
+// =============================================================================
+// Canonical ComplianceManager
+// =============================================================================
+export class ComplianceManager extends EventEmitter {
+    constructor(document) {
+        super();
+        this.resultCache = new Map();
+        this.maxCacheSize = 100;
+        this.document = document;
+        try {
+            this.native = require('../../index.node');
+        }
+        catch {
+            this.native = null;
+        }
+    }
+    // ===========================================================================
+    // Validation (from root-level with native FFI)
+    // ===========================================================================
+    async validatePdfA(level = PdfALevel.A1b) {
+        const cacheKey = `compliance:pdfa:${level}`;
+        if (this.resultCache.has(cacheKey))
+            return this.resultCache.get(cacheKey);
+        let isCompliant = true;
+        let issues = [];
+        let validationTime = 0;
+        if (this.native?.validate_pdf_a) {
+            try {
+                const nativeResult = this.native.validate_pdf_a(level);
+                isCompliant = nativeResult.is_compliant ?? true;
+                validationTime = nativeResult.validation_time ?? 0;
+                if (nativeResult.issues_json) {
+                    try {
+                        issues = JSON.parse(nativeResult.issues_json);
+                    }
+                    catch {
+                        issues = [];
+                    }
+                }
+            }
+            catch {
+                isCompliant = true;
+                issues = [];
+            }
+        }
+        else if (this.document?.validatePdfA) {
+            try {
+                const valid = await this.document.validatePdfA(typeof level === 'string' ? level : '1b');
+                isCompliant = !!valid;
+            }
+            catch {
+                isCompliant = true;
+            }
+        }
+        const result = {
+            isCompliant,
+            level: typeof level === 'string' ? level : level,
+            issues,
+            validationTime,
+        };
+        this.setCached(cacheKey, result);
+        this.emit('pdfAValidated', { level, isCompliant, issueCount: issues.length });
+        return result;
+    }
+    async validatePdfX(level = PdfXLevel.X1a) {
+        const cacheKey = `compliance:pdfx:${level}`;
+        if (this.resultCache.has(cacheKey))
+            return this.resultCache.get(cacheKey);
+        let isCompliant = true;
+        let issues = [];
+        let validationTime = 0;
+        if (this.native?.validate_pdf_x) {
+            try {
+                const nativeResult = this.native.validate_pdf_x(level);
+                isCompliant = nativeResult.is_compliant ?? true;
+                validationTime = nativeResult.validation_time ?? 0;
+                if (nativeResult.issues_json) {
+                    try {
+                        issues = JSON.parse(nativeResult.issues_json);
+                    }
+                    catch {
+                        issues = [];
+                    }
+                }
+            }
+            catch {
+                isCompliant = true;
+                issues = [];
+            }
+        }
+        else if (this.document?.validatePdfX) {
+            try {
+                const valid = await this.document.validatePdfX(typeof level === 'string' ? level : '1a');
+                isCompliant = !!valid;
+            }
+            catch {
+                isCompliant = true;
+            }
+        }
+        const result = {
+            isCompliant,
+            level: typeof level === 'string' ? level : level,
+            issues,
+            validationTime,
+        };
+        this.setCached(cacheKey, result);
+        this.emit('pdfXValidated', { level, isCompliant, issueCount: issues.length });
+        return result;
+    }
+    async validatePdfUA(level = PdfUALevel.UA1) {
+        const cacheKey = `compliance:pdfua:${level}`;
+        if (this.resultCache.has(cacheKey))
+            return this.resultCache.get(cacheKey);
+        let isCompliant = true;
+        let issues = [];
+        let validationTime = 0;
+        if (this.native?.validate_pdf_ua) {
+            try {
+                const nativeResult = this.native.validate_pdf_ua(level);
+                isCompliant = nativeResult.is_compliant ?? true;
+                validationTime = nativeResult.validation_time ?? 0;
+                if (nativeResult.issues_json) {
+                    try {
+                        issues = JSON.parse(nativeResult.issues_json);
+                    }
+                    catch {
+                        issues = [];
+                    }
+                }
+            }
+            catch {
+                isCompliant = true;
+                issues = [];
+            }
+        }
+        else if (this.document?.validatePdfUA) {
+            try {
+                isCompliant = !!(await this.document.validatePdfUA());
+            }
+            catch {
+                isCompliant = true;
+            }
+        }
+        const result = {
+            isCompliant,
+            level: typeof level === 'string' ? level : level,
+            issues,
+            validationTime,
+        };
+        this.setCached(cacheKey, result);
+        this.emit('pdfUAValidated', { level, isCompliant, issueCount: issues.length });
+        return result;
+    }
+    // ===========================================================================
+    // Issue Analysis (from root-level)
+    // ===========================================================================
+    async getAllIssues() {
+        const cacheKey = 'compliance:all_issues';
+        if (this.resultCache.has(cacheKey))
+            return this.resultCache.get(cacheKey);
+        let issues = [];
+        if (this.native?.compliance_get_all_issues) {
+            try {
+                issues = JSON.parse(this.native.compliance_get_all_issues()) || [];
+            }
+            catch {
+                issues = [];
+            }
+        }
+        this.setCached(cacheKey, issues);
+        this.emit('issuesRetrieved', { count: issues.length });
+        return issues;
+    }
+    async getIssuesOfType(type) {
+        const allIssues = await this.getAllIssues();
+        return allIssues.filter((issue) => issue.type === type);
+    }
+    async getIssueCount() {
+        return (await this.getAllIssues()).length;
+    }
+    async getErrorCount() {
+        return (await this.getAllIssues()).filter((i) => i.severity === IssueSeverity.Error).length;
+    }
+    async getWarningCount() {
+        return (await this.getAllIssues()).filter((i) => i.severity === IssueSeverity.Warning).length;
+    }
+    // ===========================================================================
+    // Conversion & Fixing (from managers version)
+    // ===========================================================================
+    async convertToPdfA(level = '1b') {
+        try {
+            const result = await this.document?.convertToPdfA?.(level);
+            this.resultCache.delete(`compliance:pdfa:${level}`);
+            this.emit('conversion-complete', { type: 'PDF/A', level, success: result });
+            return !!result;
+        }
+        catch (error) {
+            this.emit('error', error);
+            return false;
+        }
+    }
+    async convertToPdfUA() {
+        try {
+            const result = await this.document?.convertToPdfUA?.();
+            this.resultCache.delete('compliance:pdfua:');
+            this.emit('conversion-complete', { type: 'PDF/UA', success: result });
+            return !!result;
+        }
+        catch (error) {
+            this.emit('error', error);
+            return false;
+        }
+    }
+    async getComplianceReport(complianceType = 'all') {
+        try {
+            return (await this.document?.getComplianceReport?.(complianceType)) ?? '';
+        }
+        catch (error) {
+            this.emit('error', error);
+            return '';
+        }
+    }
+    async checkFontEmbedding() {
+        const cacheKey = 'compliance:fonts_embedded';
+        if (this.resultCache.has(cacheKey))
+            return this.resultCache.get(cacheKey);
+        const result = this.document?.checkFontEmbedding?.() ??
+            this.native?.compliance_has_embedded_fonts?.() ??
+            true;
+        this.setCached(cacheKey, result);
+        return result;
+    }
+    /** @deprecated Use checkFontEmbedding() instead */
+    async hasFontsEmbedded() {
+        return this.checkFontEmbedding();
+    }
+    async checkColorSpace() {
+        const cacheKey = 'compliance:valid_color_space';
+        if (this.resultCache.has(cacheKey))
+            return this.resultCache.get(cacheKey);
+        const result = this.document?.checkColorSpace?.() ??
+            this.native?.compliance_has_valid_color_space?.() ??
+            true;
+        this.setCached(cacheKey, result);
+        return result;
+    }
+    /** @deprecated Use checkColorSpace() instead */
+    async hasValidColorSpace() {
+        return this.checkColorSpace();
+    }
+    async checkTaggedContent() {
+        try {
+            return (await this.document?.checkTaggedContent?.()) ?? false;
+        }
+        catch (error) {
+            this.emit('error', error);
+            return false;
+        }
+    }
+    async addMissingTags() {
+        try {
+            const result = await this.document?.addMissingTags?.();
+            this.emit('tags-added');
+            return !!result;
+        }
+        catch (error) {
+            this.emit('error', error);
+            return false;
+        }
+    }
+    async fixFontIssues() {
+        try {
+            const count = (await this.document?.fixFontIssues?.()) ?? 0;
+            this.emit('fonts-fixed', { count });
+            return count;
+        }
+        catch (error) {
+            this.emit('error', error);
+            return 0;
+        }
+    }
+    async fixColorIssues() {
+        try {
+            const count = (await this.document?.fixColorIssues?.()) ?? 0;
+            this.emit('colors-fixed', { count });
+            return count;
+        }
+        catch (error) {
+            this.emit('error', error);
+            return 0;
+        }
+    }
+    async removeUnsupportedFeatures() {
+        try {
+            const count = (await this.document?.removeUnsupportedFeatures?.()) ?? 0;
+            this.emit('features-removed', { count });
+            return count;
+        }
+        catch (error) {
+            this.emit('error', error);
+            return 0;
+        }
+    }
+    async getComplianceIssues() {
+        try {
+            const issues = [];
+            const pdfA = await this.validatePdfA(PdfALevel.A1b);
+            if (!pdfA.isCompliant)
+                issues.push('PDF/A non-compliant');
+            const pdfX = await this.validatePdfX(PdfXLevel.X1a);
+            if (!pdfX.isCompliant)
+                issues.push('PDF/X non-compliant');
+            const pdfUA = await this.validatePdfUA(PdfUALevel.UA1);
+            if (!pdfUA.isCompliant)
+                issues.push('PDF/UA non-accessible');
+            const fontEmbedded = await this.checkFontEmbedding();
+            if (!fontEmbedded)
+                issues.push('Fonts not properly embedded');
+            const taggedContent = await this.checkTaggedContent();
+            if (!taggedContent)
+                issues.push('Missing proper tagging');
+            this.emit('issues-analyzed', { count: issues.length });
+            return issues;
+        }
+        catch (error) {
+            this.emit('error', error);
+            return [];
+        }
+    }
+    getIssueSeverity(issue) {
+        if (issue.includes('Font') || issue.includes('PDF/UA'))
+            return 'critical';
+        if (issue.includes('PDF/A') || issue.includes('PDF/X'))
+            return 'high';
+        if (issue.includes('tagging'))
+            return 'medium';
+        return 'low';
+    }
+    async createComplianceReportFile(filePath) {
+        try {
+            const report = await this.getComplianceReport('all');
+            await fs.mkdir(dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, report, 'utf8');
+            this.emit('report-created', { filePath });
+            return true;
+        }
+        catch (error) {
+            this.emit('error', error);
+            return false;
+        }
+    }
+    async getComplianceSummary() {
+        try {
+            return {
+                pdfA: await this.validatePdfA(PdfALevel.A1b),
+                pdfX: await this.validatePdfX(PdfXLevel.X1a),
+                pdfUA: await this.validatePdfUA(PdfUALevel.UA1),
+                fontEmbedded: await this.checkFontEmbedding(),
+                colorSpace: await this.checkColorSpace(),
+                taggedContent: await this.checkTaggedContent(),
+                issues: await this.getComplianceIssues(),
+            };
+        }
+        catch (error) {
+            this.emit('error', error);
+            return {};
+        }
+    }
+    // ===========================================================================
+    // Cache
+    // ===========================================================================
+    clearCache() {
+        this.resultCache.clear();
+        this.emit('cacheCleared');
+    }
+    getCacheStats() {
+        return {
+            cacheSize: this.resultCache.size,
+            maxCacheSize: this.maxCacheSize,
+            entries: Array.from(this.resultCache.keys()),
+        };
+    }
+    destroy() {
+        this.resultCache.clear();
+        this.removeAllListeners();
+    }
+    setCached(key, value) {
+        this.resultCache.set(key, value);
+        if (this.resultCache.size > this.maxCacheSize) {
+            const firstKey = this.resultCache.keys().next().value;
+            if (firstKey !== undefined)
+                this.resultCache.delete(firstKey);
+        }
+    }
+}
+export default ComplianceManager;

package/lib/managers/content-manager.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Manager for page-level content analysis
+ *
+ * Provides methods to analyze content type, complexity, and characteristics of PDF pages.
+ * This manager operates on a specific page, unlike document-level managers.
+ *
+ * @example
+ * ```typescript
+ * import { ContentManager } from 'pdf_oxide';
+ *
+ * const doc = PdfDocument.open('document.pdf');
+ * const contentManager = new ContentManager(doc, 0);
+ *
+ * if (!contentManager.isBlank()) {
+ *   console.log(contentManager.getContentSummary());
+ * }
+ * ```
+ */
+export interface ContentAnalysis {
+    pageIndex: number;
+    hasContent: boolean;
+    isBlank: boolean;
+    contentSize: number;
+    complexityScore: number;
+    dimensions: string;
+    contentTypes: string[];
+    likelyHasForms: boolean;
+    likelyHasTables: boolean;
+    likelyHasImages: boolean;
+}
+export declare class ContentManager {
+    private _document;
+    private _pageIndex;
+    private _cache;
+    /**
+     * Creates a new ContentManager for a specific page
+     * @param document - The PDF document
+     * @param pageIndex - Page index to analyze (0-based)
+     * @throws Error if document is null or undefined
+     */
+    constructor(document: any, pageIndex: number);
+    /**
+     * Gets the page index this manager operates on
+     * @returns Page index
+     */
+    get pageIndex(): number;
+    /**
+     * Clears the content cache
+     */
+    clearCache(): void;
+    /**
+     * Checks if the page has any content
+     * @returns True if the page has content
+     */
+    hasContent(): boolean;
+    /**
+     * Gets the approximate size of the content stream in bytes
+     * @returns Content size in bytes
+     */
+    getContentSize(): number;
+    /**
+     * Checks if the page appears to be blank (no visible content)
+     * @returns True if the page is blank
+     */
+    isBlank(): boolean;
+    /**
+     * Gets a complexity score for the page (0-100)
+     * Higher scores indicate more complex content.
+     * @returns Complexity score from 0 to 100
+     */
+    getComplexityScore(): number;
+    /**
+     * Gets a human-readable summary of page dimensions
+     * @returns Formatted dimensions string
+     */
+    getDimensionsSummary(): string;
+    /**
+     * Checks if the page likely contains form fields
+     * @returns True if the page likely has forms
+     */
+    likelyHasForms(): boolean;
+    /**
+     * Checks if the page likely contains tables
+     * @returns True if the page likely has tables
+     */
+    likelyHasTables(): boolean;
+    /**
+     * Checks if the page likely contains images
+     * @returns True if the page likely has images
+     */
+    likelyHasImages(): boolean;
+    /**
+     * Gets a list of content types detected on the page
+     * @returns Array of content type strings
+     *
+     * @example
+     * ```typescript
+     * const types = manager.getContentTypes();
+     * console.log(`Content types: ${types.join(', ')}`);
+     * ```
+     */
+    getContentTypes(): string[];
+    /**
+     * Gets a human-readable summary of the page content
+     * @returns Formatted content summary string
+     *
+     * @example
+     * ```typescript
+     * const summary = manager.getContentSummary();
+     * console.log(summary);
+     * // Output: "Dimensions: 612 x 792 pt; Content: text, images; Complexity: 45/100"
+     * ```
+     */
+    getContentSummary(): string;
+    /**
+     * Analyzes page content thoroughly
+     * @returns Detailed content analysis
+     */
+    analyze(): ContentAnalysis;
+}