react-native-pdf-jsi 4.2.1 → 4.2.2

package/README.md

@@ -409,6 +409,19 @@ MIT License - see [LICENSE](LICENSE) file for details.
 - **Author**: Punith M ([@126punith](https://github.com/126punith))
 
 ## Recent Fixes
+
+### PDFCompressor Module Fix (v4.2.2)
+Fixed "Unable to resolve module react-native-pdf-jsi/src/PDFCompressor" error ([#17](https://github.com/126punith/react-native-pdf-jsi/issues/17)). The PDFCompressor module is now properly exported and accessible. Also fixed iOS compilation error for missing `RCTLogInfo` import. The compression feature now works correctly with accurate size estimates (~15-18% compression using native zlib deflate).
+
+**Usage:**
+```jsx
+import { PDFCompressor, CompressionPreset } from 'react-native-pdf-jsi';
+
+// Compress a PDF
+const result = await PDFCompressor.compressWithPreset(pdfPath, CompressionPreset.WEB);
+console.log(`Compressed: ${result.originalSizeMB}MB → ${result.compressedSizeMB}MB`);
+```
+
 ### iOS Performance - Unnecessary Path Handlers (v4.2.1)
 Use v4.2.1 it contains stable fixes for IOS with unwanted debug logs removed
 

package/android/src/main/java/org/wonday/pdf/PDFExporter.java

@@ -734,4 +734,78 @@ public class PDFExporter extends ReactContextBaseJavaModule {
             promise.reject("PAGE_COUNT_ERROR", e.getMessage());
         }
     }
+
+    /**
+     * Compress PDF using streaming processor
+     * Uses O(1) constant memory regardless of file size
+     * @param inputPath Input PDF file path
+     * @param outputPath Output compressed PDF file path
+     * @param compressionLevel Compression level (0-9, 9 is maximum compression)
+     * @param promise Promise to resolve with compression result
+     */
+    @ReactMethod
+    public void compressPDF(String inputPath, String outputPath, int compressionLevel, Promise promise) {
+        try {
+            Log.d(TAG, "compressPDF called with inputPath: " + inputPath + ", outputPath: " + outputPath + ", level: " + compressionLevel);
+            
+            if (inputPath == null || inputPath.isEmpty()) {
+                promise.reject("INVALID_PATH", "Input file path is required");
+                return;
+            }
+
+            File inputFile = new File(inputPath);
+            if (!inputFile.exists()) {
+                promise.reject("FILE_NOT_FOUND", "Input PDF file not found: " + inputPath);
+                return;
+            }
+
+            // Generate output path if not provided
+            File outputFile;
+            if (outputPath == null || outputPath.isEmpty()) {
+                String baseName = inputFile.getName().replaceAll("\\.pdf$", "");
+                String outputFileName = generateTimestampedFileName(baseName + "_compressed", -1, "pdf");
+                outputFile = new File(inputFile.getParent(), outputFileName);
+            } else {
+                outputFile = new File(outputPath);
+            }
+
+            // Ensure output directory exists
+            File outputDir = outputFile.getParentFile();
+            if (outputDir != null && !outputDir.exists()) {
+                outputDir.mkdirs();
+            }
+
+            Log.d(TAG, "Starting compression: " + inputFile.getAbsolutePath() + " -> " + outputFile.getAbsolutePath());
+
+            // Use StreamingPDFProcessor for O(1) memory compression
+            StreamingPDFProcessor processor = new StreamingPDFProcessor();
+            StreamingPDFProcessor.CompressionResult result = processor.compressPDFStreaming(
+                inputFile, 
+                outputFile, 
+                compressionLevel
+            );
+
+            // Build response
+            WritableMap response = Arguments.createMap();
+            response.putDouble("originalSize", result.originalSize);
+            response.putDouble("compressedSize", result.compressedSize);
+            response.putDouble("durationMs", result.durationMs);
+            response.putDouble("compressionRatio", result.compressionRatio);
+            response.putDouble("spaceSavedPercent", result.spaceSavedPercent);
+            response.putString("outputPath", outputFile.getAbsolutePath());
+            response.putBoolean("success", true);
+
+            Log.d(TAG, String.format("Compression complete: %.2f MB -> %.2f MB (%.1f%% saved) in %dms",
+                result.originalSize / (1024.0 * 1024.0),
+                result.compressedSize / (1024.0 * 1024.0),
+                result.spaceSavedPercent,
+                result.durationMs));
+
+            promise.resolve(response);
+
+        } catch (Exception e) {
+            Log.e(TAG, "Error compressing PDF", e);
+            promise.reject("COMPRESSION_ERROR", e.getMessage(), e);
+        }
+    }
 }

package/index.d.ts

@@ -219,3 +219,247 @@ export const PDFCache: PDFCacheManager;
  * CacheManager (alias for PDFCache)
  */
 export const CacheManager: PDFCacheManager;
+
+// ========================================
+// PDFCompressor (PDF Compression)
+// ========================================
+
+/**
+ * Compression presets for different use cases
+ */
+export enum CompressionPreset {
+    /** Optimized for email attachments (high compression, smaller file) */
+    EMAIL = 'email',
+    /** Optimized for web viewing (balanced compression) */
+    WEB = 'web',
+    /** Optimized for mobile devices (good compression, fast decompression) */
+    MOBILE = 'mobile',
+    /** Optimized for printing (low compression, high quality) */
+    PRINT = 'print',
+    /** Optimized for long-term archival (maximum compression) */
+    ARCHIVE = 'archive',
+    /** Custom compression settings */
+    CUSTOM = 'custom'
+}
+
+/**
+ * Compression levels (0-9, higher = more compression but slower)
+ */
+export enum CompressionLevel {
+    NONE = 0,
+    FASTEST = 1,
+    FAST = 3,
+    BALANCED = 5,
+    DEFAULT = 6,
+    GOOD = 7,
+    BETTER = 8,
+    BEST = 9
+}
+
+/**
+ * Compression options
+ */
+export interface CompressionOptions {
+    /** Compression preset (from CompressionPreset) */
+    preset?: CompressionPreset;
+    /** Compression level (0-9), overrides preset */
+    level?: number;
+    /** Output file path (optional, auto-generated if not provided) */
+    outputPath?: string;
+    /** Progress callback function */
+    onProgress?: (progress: { progress: number; bytesProcessed: number; totalBytes: number }) => void;
+}
+
+/**
+ * Compression result
+ */
+export interface CompressionResult {
+    /** Whether compression was successful */
+    success: boolean;
+    /** Input file path */
+    inputPath: string;
+    /** Output file path */
+    outputPath: string;
+    /** Original file size in bytes */
+    originalSize: number;
+    /** Compressed file size in bytes */
+    compressedSize: number;
+    /** Original file size in MB */
+    originalSizeMB: number;
+    /** Compressed file size in MB */
+    compressedSizeMB: number;
+    /** Compression ratio (0-1, lower is better) */
+    compressionRatio: number;
+    /** Space saved percentage */
+    spaceSavedPercent: number;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Throughput in MB/s */
+    throughputMBps: number;
+    /** Preset used */
+    preset: CompressionPreset;
+    /** Compression level used */
+    compressionLevel: number;
+    /** Method used (native_streaming or fallback) */
+    method: string;
+}
+
+/**
+ * Compression estimate result
+ */
+export interface CompressionEstimate {
+    /** Input file path */
+    inputPath: string;
+    /** Original file size in bytes */
+    originalSize: number;
+    /** Original file size in MB */
+    originalSizeMB: number;
+    /** Estimated compressed size in bytes */
+    estimatedCompressedSize: number;
+    /** Estimated compressed size in MB */
+    estimatedCompressedSizeMB: number;
+    /** Estimated compression ratio */
+    estimatedCompressionRatio: number;
+    /** Estimated space savings percentage */
+    estimatedSavingsPercent: number;
+    /** Estimated duration in milliseconds */
+    estimatedDurationMs: number;
+    /** Preset used for estimate */
+    preset: CompressionPreset;
+    /** Description of the preset */
+    presetDescription: string;
+    /** Confidence level of the estimate */
+    confidence: 'low' | 'medium' | 'high';
+    /** Additional notes */
+    note: string;
+}
+
+/**
+ * PDFCompressor capabilities
+ */
+export interface CompressionCapabilities {
+    /** Whether streaming compression is available */
+    streamingCompression: boolean;
+    /** Available presets */
+    presets: CompressionPreset[];
+    /** Maximum file size in MB */
+    maxFileSizeMB: number;
+    /** Supported platforms */
+    supportedPlatforms: string[];
+    /** Current platform */
+    currentPlatform: string;
+    /** Whether native module is available */
+    nativeModuleAvailable: boolean;
+}
+
+/**
+ * PDFCompressor Manager for PDF compression
+ * Uses native streaming for O(1) memory operations on large files (1GB+)
+ */
+export interface PDFCompressorManager {
+    /**
+     * Check if compression functionality is available
+     * @returns True if compression is available
+     */
+    isAvailable(): boolean;
+    
+    /**
+     * Get compression capabilities
+     * @returns Capabilities object
+     */
+    getCapabilities(): CompressionCapabilities;
+    
+    /**
+     * Compress a PDF file
+     * @param inputPath Path to input PDF file
+     * @param options Compression options
+     * @returns Promise resolving to compression result
+     */
+    compress(inputPath: string, options?: CompressionOptions): Promise<CompressionResult>;
+    
+    /**
+     * Compress PDF with a specific preset
+     * @param inputPath Path to input PDF file
+     * @param preset Compression preset
+     * @param outputPath Output file path (optional)
+     * @returns Promise resolving to compression result
+     */
+    compressWithPreset(inputPath: string, preset: CompressionPreset, outputPath?: string): Promise<CompressionResult>;
+    
+    /**
+     * Compress PDF for email (maximum compression)
+     * @param inputPath Path to input PDF file
+     * @param outputPath Output file path (optional)
+     * @returns Promise resolving to compression result
+     */
+    compressForEmail(inputPath: string, outputPath?: string): Promise<CompressionResult>;
+    
+    /**
+     * Compress PDF for web viewing
+     * @param inputPath Path to input PDF file
+     * @param outputPath Output file path (optional)
+     * @returns Promise resolving to compression result
+     */
+    compressForWeb(inputPath: string, outputPath?: string): Promise<CompressionResult>;
+    
+    /**
+     * Compress PDF for mobile viewing
+     * @param inputPath Path to input PDF file
+     * @param outputPath Output file path (optional)
+     * @returns Promise resolving to compression result
+     */
+    compressForMobile(inputPath: string, outputPath?: string): Promise<CompressionResult>;
+    
+    /**
+     * Compress PDF for archival (maximum compression)
+     * @param inputPath Path to input PDF file
+     * @param outputPath Output file path (optional)
+     * @returns Promise resolving to compression result
+     */
+    compressForArchive(inputPath: string, outputPath?: string): Promise<CompressionResult>;
+    
+    /**
+     * Estimate compression result without actually compressing
+     * @param inputPath Path to input PDF file
+     * @param preset Compression preset
+     * @returns Promise resolving to estimated compression result
+     */
+    estimateCompression(inputPath: string, preset?: CompressionPreset): Promise<CompressionEstimate>;
+    
+    /**
+     * Delete a compressed file
+     * @param filePath Path to file to delete
+     * @returns Promise resolving to true if deleted successfully
+     */
+    deleteCompressedFile(filePath: string): Promise<boolean>;
+    
+    /**
+     * Get preset configuration
+     * @param preset Preset name
+     * @returns Preset configuration
+     */
+    getPresetConfig(preset: CompressionPreset): {
+        level: CompressionLevel;
+        targetSizeKB: number | null;
+        description: string;
+    };
+    
+    /**
+     * Get module information
+     * @returns Module info object
+     */
+    getModuleInfo(): {
+        name: string;
+        version: string;
+        platform: string;
+        nativeAvailable: boolean;
+        presets: string[];
+        compressionLevels: string[];
+        capabilities: CompressionCapabilities;
+    };
+}
+
+/**
+ * PDFCompressor singleton instance
+ */
+export const PDFCompressor: PDFCompressorManager;

package/index.js

@@ -742,6 +742,7 @@ import BookmarkManager from './src/managers/BookmarkManager';
 import AnalyticsManager from './src/managers/AnalyticsManager';
 import FileManager from './src/managers/FileManager';
 import CacheManager from './src/managers/CacheManager';
+import PDFCompressor, { CompressionPreset, CompressionLevel } from './src/PDFCompressor';
 
 // Alias for backward compatibility and intuitive naming
 export const PDFCache = CacheManager;
@@ -751,7 +752,10 @@ export {
     BookmarkManager,
     AnalyticsManager,
     FileManager,
-    CacheManager
+    CacheManager,
+    PDFCompressor,
+    CompressionPreset,
+    CompressionLevel
 };
 
 // ========================================

package/ios/RNPDFPdf/PDFExporter.m

@@ -1,5 +1,7 @@
 #import "PDFExporter.h"
 #import "ImagePool.h"
+#import "StreamingPDFProcessor.h"
+#import <React/RCTLog.h>
 #import <PDFKit/PDFKit.h>
 #import <UIKit/UIKit.h>
 
@@ -956,4 +958,85 @@ RCT_EXPORT_METHOD(getPageCount:(NSString *)filePath
     resolve(@(pageCount));
 }
 
+/**
+ * Compress PDF using streaming processor
+ * Uses O(1) constant memory regardless of file size
+ * @param inputPath Input PDF file path
+ * @param outputPath Output compressed PDF file path
+ * @param compressionLevel Compression level (0-9, 9 is maximum compression)
+ */
+RCT_EXPORT_METHOD(compressPDF:(NSString *)inputPath
+                  outputPath:(NSString *)outputPath
+                  compressionLevel:(int)compressionLevel
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    
+    RCTLogInfo(@"compressPDF called with inputPath: %@, outputPath: %@, level: %d", inputPath, outputPath, compressionLevel);
+    
+    if (!inputPath || inputPath.length == 0) {
+        reject(@"INVALID_PATH", @"Input file path is required", nil);
+        return;
+    }
+    
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    if (![fileManager fileExistsAtPath:inputPath]) {
+        reject(@"FILE_NOT_FOUND", [NSString stringWithFormat:@"Input PDF file not found: %@", inputPath], nil);
+        return;
+    }
+    
+    // Generate output path if not provided
+    NSString *finalOutputPath = outputPath;
+    if (!finalOutputPath || finalOutputPath.length == 0) {
+        NSString *directory = [inputPath stringByDeletingLastPathComponent];
+        NSString *baseName = [[inputPath lastPathComponent] stringByDeletingPathExtension];
+        NSString *outputFileName = [self generateTimestampedFileName:[baseName stringByAppendingString:@"_compressed"] pageNum:-1 extension:@"pdf"];
+        finalOutputPath = [directory stringByAppendingPathComponent:outputFileName];
+    }
+    
+    // Ensure output directory exists
+    NSString *outputDir = [finalOutputPath stringByDeletingLastPathComponent];
+    if (![fileManager fileExistsAtPath:outputDir]) {
+        NSError *error;
+        [fileManager createDirectoryAtPath:outputDir withIntermediateDirectories:YES attributes:nil error:&error];
+        if (error) {
+            reject(@"DIR_CREATE_ERROR", @"Failed to create output directory", error);
+            return;
+        }
+    }
+    
+    RCTLogInfo(@"Starting compression: %@ -> %@", inputPath, finalOutputPath);
+    
+    // Use StreamingPDFProcessor for O(1) memory compression
+    StreamingPDFProcessor *processor = [StreamingPDFProcessor sharedInstance];
+    NSError *error;
+    CompressionResult *result = [processor compressPDFStreaming:inputPath
+                                                     outputPath:finalOutputPath
+                                               compressionLevel:compressionLevel
+                                                          error:&error];
+    
+    if (error || !result) {
+        reject(@"COMPRESSION_ERROR", error ? error.localizedDescription : @"Compression failed", error);
+        return;
+    }
+    
+    // Build response
+    NSDictionary *response = @{
+        @"originalSize": @(result.originalSize),
+        @"compressedSize": @(result.compressedSize),
+        @"durationMs": @(result.durationMs),
+        @"compressionRatio": @(result.compressionRatio),
+        @"spaceSavedPercent": @(result.spaceSavedPercent),
+        @"outputPath": finalOutputPath,
+        @"success": @YES
+    };
+    
+    RCTLogInfo(@"Compression complete: %.2f MB -> %.2f MB (%.1f%% saved) in %.0fms",
+              result.originalSize / (1024.0 * 1024.0),
+              result.compressedSize / (1024.0 * 1024.0),
+              result.spaceSavedPercent,
+              result.durationMs);
+    
+    resolve(response);
+}
+
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-pdf-jsi",
-    "version": "4.2.1",
+    "version": "4.2.2",
     "summary": "High-performance React Native PDF viewer with JSI acceleration - up to 80x faster than traditional bridge",
     "description": "🚀 Ultra-fast React Native PDF viewer with JSI (JavaScript Interface) integration for maximum performance. Features lazy loading, smart caching, progressive loading, and zero-bridge overhead operations. Perfect for large PDF files with 30-day persistent cache and advanced memory optimization. Google Play 16KB page size compliant for Android 15+. Supports iOS, Android, and Windows platforms.",
     "main": "index.js",

package/src/PDFCompressor.js

@@ -0,0 +1,476 @@
+/**
+ * PDFCompressor - PDF Compression Manager
+ * Handles PDF file compression with streaming support for large files
+ * 
+ * Uses native StreamingPDFProcessor for O(1) memory operations
+ * Can compress 1GB+ PDFs without memory issues
+ * 
+ * @author Punith M
+ * @version 1.0.0
+ */
+
+import { NativeModules, Platform } from 'react-native';
+import ReactNativeBlobUtil from 'react-native-blob-util';
+
+const { PDFExporter, StreamingPDFProcessor } = NativeModules;
+
+/**
+ * Compression presets for different use cases
+ */
+export const CompressionPreset = {
+    /** Optimized for email attachments (high compression, smaller file) */
+    EMAIL: 'email',
+    /** Optimized for web viewing (balanced compression) */
+    WEB: 'web',
+    /** Optimized for mobile devices (good compression, fast decompression) */
+    MOBILE: 'mobile',
+    /** Optimized for printing (low compression, high quality) */
+    PRINT: 'print',
+    /** Optimized for long-term archival (maximum compression) */
+    ARCHIVE: 'archive',
+    /** Custom compression settings */
+    CUSTOM: 'custom'
+};
+
+/**
+ * Compression levels (0-9, higher = more compression but slower)
+ */
+export const CompressionLevel = {
+    NONE: 0,
+    FASTEST: 1,
+    FAST: 3,
+    BALANCED: 5,
+    DEFAULT: 6,
+    GOOD: 7,
+    BETTER: 8,
+    BEST: 9
+};
+
+/**
+ * Preset configurations
+ */
+const PRESET_CONFIGS = {
+    [CompressionPreset.EMAIL]: {
+        level: CompressionLevel.BEST,
+        targetSizeKB: 10000, // 10MB target
+        description: 'Maximum compression for email attachments'
+    },
+    [CompressionPreset.WEB]: {
+        level: CompressionLevel.GOOD,
+        targetSizeKB: 50000, // 50MB target
+        description: 'Balanced compression for web delivery'
+    },
+    [CompressionPreset.MOBILE]: {
+        level: CompressionLevel.BALANCED,
+        targetSizeKB: 25000, // 25MB target
+        description: 'Optimized for mobile viewing'
+    },
+    [CompressionPreset.PRINT]: {
+        level: CompressionLevel.FAST,
+        targetSizeKB: null, // No size limit
+        description: 'Low compression for print quality'
+    },
+    [CompressionPreset.ARCHIVE]: {
+        level: CompressionLevel.BEST,
+        targetSizeKB: null, // No size limit, just maximum compression
+        description: 'Maximum compression for archival'
+    }
+};
+
+/**
+ * PDFCompressor Class
+ * Provides PDF compression functionality with streaming support
+ */
+export class PDFCompressor {
+    constructor() {
+        this.isNativeAvailable = this._checkNativeAvailability();
+        
+        if (this.isNativeAvailable) {
+            console.log('📦 PDFCompressor: Native streaming compression available');
+        } else {
+            console.warn('📦 PDFCompressor: Native module not available - compression may be limited');
+        }
+    }
+
+    /**
+     * Check if native compression module is available
+     * @private
+     * @returns {boolean} True if native module is available
+     */
+    _checkNativeAvailability() {
+        // Check if PDFExporter module exists and has the compressPDF method
+        const hasCompressPDF = PDFExporter && typeof PDFExporter.compressPDF === 'function';
+        console.log('📦 PDFCompressor: Checking native availability...');
+        console.log('📦 PDFCompressor: PDFExporter exists:', !!PDFExporter);
+        console.log('📦 PDFCompressor: PDFExporter.compressPDF exists:', hasCompressPDF);
+        return hasCompressPDF;
+    }
+
+    /**
+     * Check if compression is available
+     * @returns {boolean} True if compression functionality is available
+     */
+    isAvailable() {
+        return this.isNativeAvailable;
+    }
+
+    /**
+     * Get compression capabilities
+     * @returns {Object} Capabilities object
+     */
+    getCapabilities() {
+        return {
+            streamingCompression: this.isNativeAvailable,
+            presets: Object.values(CompressionPreset),
+            maxFileSizeMB: this.isNativeAvailable ? 1024 : 100, // 1GB+ with native, 100MB without
+            supportedPlatforms: ['ios', 'android'],
+            currentPlatform: Platform.OS,
+            nativeModuleAvailable: this.isNativeAvailable
+        };
+    }
+
+    /**
+     * Get preset configuration
+     * @param {string} preset - Preset name from CompressionPreset
+     * @returns {Object} Preset configuration
+     */
+    getPresetConfig(preset) {
+        return PRESET_CONFIGS[preset] || PRESET_CONFIGS[CompressionPreset.WEB];
+    }
+
+    /**
+     * Compress a PDF file
+     * @param {string} inputPath - Path to input PDF file
+     * @param {Object} options - Compression options
+     * @param {string} options.preset - Compression preset (from CompressionPreset)
+     * @param {number} options.level - Compression level (0-9), overrides preset
+     * @param {string} options.outputPath - Output file path (optional, auto-generated if not provided)
+     * @param {Function} options.onProgress - Progress callback function
+     * @returns {Promise<Object>} Compression result
+     */
+    async compress(inputPath, options = {}) {
+        const {
+            preset = CompressionPreset.WEB,
+            level = null,
+            outputPath = null,
+            onProgress = null
+        } = options;
+
+        console.log(`📦 PDFCompressor: Starting compression with preset '${preset}'`);
+
+        // Validate input file exists
+        const fileExists = await this._fileExists(inputPath);
+        if (!fileExists) {
+            throw new Error(`Input file not found: ${inputPath}`);
+        }
+
+        // Get file size
+        const inputStats = await this._getFileStats(inputPath);
+        const inputSizeMB = inputStats.size / (1024 * 1024);
+        
+        console.log(`📦 PDFCompressor: Input file size: ${inputSizeMB.toFixed(2)} MB`);
+
+        // Determine compression level
+        const presetConfig = this.getPresetConfig(preset);
+        const compressionLevel = level !== null ? level : presetConfig.level;
+
+        // Generate output path if not provided
+        const finalOutputPath = outputPath || this._generateOutputPath(inputPath);
+
+        // Perform compression
+        const startTime = Date.now();
+        let result;
+
+        if (this.isNativeAvailable) {
+            result = await this._compressNative(inputPath, finalOutputPath, compressionLevel, onProgress);
+        } else {
+            result = await this._compressFallback(inputPath, finalOutputPath, compressionLevel, onProgress);
+        }
+
+        const duration = Date.now() - startTime;
+
+        // Get output file stats
+        const outputStats = await this._getFileStats(finalOutputPath);
+        const outputSizeMB = outputStats.size / (1024 * 1024);
+        const compressionRatio = inputStats.size > 0 ? outputStats.size / inputStats.size : 1;
+        const spaceSavedPercent = (1 - compressionRatio) * 100;
+        const throughputMBps = duration > 0 ? (inputSizeMB / (duration / 1000)) : 0;
+
+        const compressionResult = {
+            success: true,
+            inputPath,
+            outputPath: finalOutputPath,
+            originalSize: inputStats.size,
+            compressedSize: outputStats.size,
+            originalSizeMB: inputSizeMB,
+            compressedSizeMB: outputSizeMB,
+            compressionRatio,
+            spaceSavedPercent,
+            durationMs: duration,
+            throughputMBps,
+            preset,
+            compressionLevel,
+            method: this.isNativeAvailable ? 'native_streaming' : 'fallback'
+        };
+
+        console.log(`📦 PDFCompressor: Compression complete!`);
+        console.log(`   📊 ${inputSizeMB.toFixed(2)} MB → ${outputSizeMB.toFixed(2)} MB (${spaceSavedPercent.toFixed(1)}% saved)`);
+        console.log(`   ⏱️ ${duration}ms (${throughputMBps.toFixed(1)} MB/s)`);
+
+        return compressionResult;
+    }
+
+    /**
+     * Compress PDF with a specific preset
+     * @param {string} inputPath - Path to input PDF file
+     * @param {string} preset - Compression preset
+     * @param {string} outputPath - Output file path (optional)
+     * @returns {Promise<Object>} Compression result
+     */
+    async compressWithPreset(inputPath, preset, outputPath = null) {
+        return this.compress(inputPath, { preset, outputPath });
+    }
+
+    /**
+     * Compress PDF for email (maximum compression)
+     * @param {string} inputPath - Path to input PDF file
+     * @param {string} outputPath - Output file path (optional)
+     * @returns {Promise<Object>} Compression result
+     */
+    async compressForEmail(inputPath, outputPath = null) {
+        return this.compress(inputPath, { 
+            preset: CompressionPreset.EMAIL, 
+            outputPath 
+        });
+    }
+
+    /**
+     * Compress PDF for web viewing
+     * @param {string} inputPath - Path to input PDF file
+     * @param {string} outputPath - Output file path (optional)
+     * @returns {Promise<Object>} Compression result
+     */
+    async compressForWeb(inputPath, outputPath = null) {
+        return this.compress(inputPath, { 
+            preset: CompressionPreset.WEB, 
+            outputPath 
+        });
+    }
+
+    /**
+     * Compress PDF for mobile viewing
+     * @param {string} inputPath - Path to input PDF file
+     * @param {string} outputPath - Output file path (optional)
+     * @returns {Promise<Object>} Compression result
+     */
+    async compressForMobile(inputPath, outputPath = null) {
+        return this.compress(inputPath, { 
+            preset: CompressionPreset.MOBILE, 
+            outputPath 
+        });
+    }
+
+    /**
+     * Compress PDF for archival (maximum compression)
+     * @param {string} inputPath - Path to input PDF file
+     * @param {string} outputPath - Output file path (optional)
+     * @returns {Promise<Object>} Compression result
+     */
+    async compressForArchive(inputPath, outputPath = null) {
+        return this.compress(inputPath, { 
+            preset: CompressionPreset.ARCHIVE, 
+            outputPath 
+        });
+    }
+
+    /**
+     * Estimate compression result without actually compressing
+     * @param {string} inputPath - Path to input PDF file
+     * @param {string} preset - Compression preset
+     * @returns {Promise<Object>} Estimated compression result
+     */
+    async estimateCompression(inputPath, preset = CompressionPreset.WEB) {
+        const fileExists = await this._fileExists(inputPath);
+        if (!fileExists) {
+            throw new Error(`Input file not found: ${inputPath}`);
+        }
+
+        const inputStats = await this._getFileStats(inputPath);
+        const inputSizeMB = inputStats.size / (1024 * 1024);
+        const presetConfig = this.getPresetConfig(preset);
+
+        // IMPORTANT: Native module uses zlib deflate which produces ~15-18% compression
+        // on PDFs regardless of compression level, because PDFs already contain 
+        // compressed content (JPEG images, embedded fonts, compressed streams).
+        // All presets produce approximately the same result.
+        const estimatedRatio = 0.84; // ~16% reduction - same for all presets
+        const estimatedSize = inputStats.size * estimatedRatio;
+        const estimatedSizeMB = estimatedSize / (1024 * 1024);
+        const estimatedSavingsPercent = (1 - estimatedRatio) * 100;
+
+        // Estimate time based on file size (actual ~25ms/MB with native streaming)
+        const msPerMB = this.isNativeAvailable ? 25 : 100;
+        const estimatedTimeMs = inputSizeMB * msPerMB;
+
+        return {
+            inputPath,
+            originalSize: inputStats.size,
+            originalSizeMB: inputSizeMB,
+            estimatedCompressedSize: estimatedSize,
+            estimatedCompressedSizeMB: estimatedSizeMB,
+            estimatedCompressionRatio: estimatedRatio,
+            estimatedSavingsPercent,
+            estimatedDurationMs: estimatedTimeMs,
+            preset,
+            presetDescription: presetConfig.description,
+            confidence: 'low',
+            note: 'All presets produce ~15-18% compression. Native uses zlib deflate which has minimal effect on already-compressed PDF content.'
+        };
+    }
+
+    /**
+     * Native compression using PDFExporter.compressPDF
+     * @private
+     */
+    async _compressNative(inputPath, outputPath, compressionLevel, onProgress) {
+        console.log(`📦 PDFCompressor: Using native streaming compression (level: ${compressionLevel})`);
+
+        try {
+            // Use PDFExporter.compressPDF - the main native compression method
+            if (PDFExporter && typeof PDFExporter.compressPDF === 'function') {
+                console.log('📦 PDFCompressor: Calling PDFExporter.compressPDF...');
+                const result = await PDFExporter.compressPDF(
+                    inputPath, 
+                    outputPath, 
+                    compressionLevel
+                );
+                console.log('📦 PDFCompressor: Native compression result:', result);
+                return result;
+            } else {
+                // Native module not available - use fallback
+                console.warn('📦 PDFCompressor: PDFExporter.compressPDF not available, using fallback');
+                console.warn('📦 PDFCompressor: PDFExporter available:', !!PDFExporter);
+                console.warn('📦 PDFCompressor: PDFExporter.compressPDF:', PDFExporter ? typeof PDFExporter.compressPDF : 'N/A');
+                return this._compressFallback(inputPath, outputPath, compressionLevel, onProgress);
+            }
+        } catch (error) {
+            console.error('📦 PDFCompressor: Native compression failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Fallback compression (file copy with potential optimization)
+     * @private
+     */
+    async _compressFallback(inputPath, outputPath, compressionLevel, onProgress) {
+        console.log('📦 PDFCompressor: Using fallback compression (limited functionality)');
+
+        try {
+            // For fallback, we simply copy the file
+            // Real compression requires native code
+            await ReactNativeBlobUtil.fs.cp(inputPath, outputPath);
+
+            if (onProgress) {
+                onProgress({
+                    progress: 1.0,
+                    bytesProcessed: 0,
+                    totalBytes: 0
+                });
+            }
+
+            console.warn('📦 PDFCompressor: Fallback mode - file copied without compression');
+            console.warn('📦 PDFCompressor: For actual compression, ensure native module is properly linked');
+
+            return {
+                success: true,
+                method: 'fallback_copy',
+                note: 'Native compression not available - file was copied without compression'
+            };
+        } catch (error) {
+            console.error('📦 PDFCompressor: Fallback compression failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Check if file exists
+     * @private
+     */
+    async _fileExists(filePath) {
+        try {
+            return await ReactNativeBlobUtil.fs.exists(filePath);
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Get file statistics
+     * @private
+     */
+    async _getFileStats(filePath) {
+        try {
+            const stats = await ReactNativeBlobUtil.fs.stat(filePath);
+            return {
+                size: parseInt(stats.size, 10),
+                lastModified: stats.lastModified,
+                path: stats.path
+            };
+        } catch (error) {
+            console.error('📦 PDFCompressor: Failed to get file stats:', error);
+            return { size: 0, lastModified: 0, path: filePath };
+        }
+    }
+
+    /**
+     * Generate output path based on input path
+     * @private
+     */
+    _generateOutputPath(inputPath) {
+        const timestamp = Date.now();
+        const baseName = inputPath.replace(/\.pdf$/i, '');
+        return `${baseName}_compressed_${timestamp}.pdf`;
+    }
+
+    /**
+     * Delete a compressed file
+     * @param {string} filePath - Path to file to delete
+     * @returns {Promise<boolean>} Success status
+     */
+    async deleteCompressedFile(filePath) {
+        try {
+            const exists = await this._fileExists(filePath);
+            if (exists) {
+                await ReactNativeBlobUtil.fs.unlink(filePath);
+                console.log(`📦 PDFCompressor: Deleted file: ${filePath}`);
+                return true;
+            }
+            return false;
+        } catch (error) {
+            console.error('📦 PDFCompressor: Failed to delete file:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Get module information
+     * @returns {Object} Module info
+     */
+    getModuleInfo() {
+        return {
+            name: 'PDFCompressor',
+            version: '1.0.0',
+            platform: Platform.OS,
+            nativeAvailable: this.isNativeAvailable,
+            presets: Object.keys(CompressionPreset),
+            compressionLevels: Object.keys(CompressionLevel),
+            capabilities: this.getCapabilities()
+        };
+    }
+}
+
+// Create singleton instance
+const pdfCompressor = new PDFCompressor();
+
+export default pdfCompressor;

package/src/index.js

@@ -9,6 +9,14 @@
 // Core JSI functionality
 export { default as PDFJSI } from './PDFJSI';
 
+// PDF Compression
+export { 
+    default as PDFCompressor, 
+    PDFCompressor as PDFCompressorClass,
+    CompressionPreset, 
+    CompressionLevel 
+} from './PDFCompressor';
+
 // Enhanced PDF View component
 export { default as EnhancedPdfView, EnhancedPdfUtils } from './EnhancedPdfView';
 
@@ -29,4 +37,10 @@ export {
     getJSIStats,
     getPerformanceHistory,
     clearPerformanceHistory
-} from './PDFJSI';
+} from './PDFJSI';
+
+// Re-export compression utilities
+export {
+    CompressionPreset,
+    CompressionLevel
+} from './PDFCompressor';