react-native-pdf-jsi 4.2.0 → 4.2.2

package/README.md

@@ -410,6 +410,21 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ## 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
+
 ### iOS Performance - Unnecessary Path Handlers (v4.2.0)
 Fixed performance issue where path-related handlers were running unnecessarily when the path value hadn't actually changed. The fix filters out "path" from effectiveChangedProps when pathActuallyChanged=NO, preventing unnecessary reconfigurations of spacing, display direction, scroll views, usePageViewController, and other path-dependent handlers. This reduces unnecessary rerenders and improves performance, especially when navigating between pages. Addresses issue #7 (Page Prop Causes Full Rerender).
 

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/ios/RNPDFPdf/RNPDFPdfView.mm

@@ -399,29 +399,6 @@ using namespace facebook::react;
     _currentUsePageViewController = NO;
     _usePageViewControllerStateInitialized = NO;
     
-    // #region agent log
-    {
-        NSString *logPath0 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-        NSDictionary *logEntry0 = @{
-            @"sessionId": @"debug-session",
-            @"runId": @"init",
-            @"hypothesisId": @"F",
-            @"location": @"RNPDFPdfView.mm:393",
-            @"message": @"initCommonProps completed",
-            @"data": @{
-                @"horizontal": @(_horizontal),
-                @"enablePaging": @(_enablePaging),
-                @"scrollEnabled": @(_scrollEnabled),
-                @"singlePage": @(_singlePage)
-            },
-            @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-        };
-        NSData *logData0 = [NSJSONSerialization dataWithJSONObject:logEntry0 options:0 error:nil];
-        NSString *logLine0 = [[NSString alloc] initWithData:logData0 encoding:NSUTF8StringEncoding];
-        [[logLine0 stringByAppendingString:@"\n"] writeToFile:logPath0 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-    }
-    // #endregion
-
     // Enhanced properties
     _enableCaching = YES;
     _enablePreloading = YES;
@@ -802,38 +779,6 @@ using namespace facebook::react;
                                      _page > 0 &&
                                      _page <= (int)_pdfDocument.pageCount;
         
-        // #region agent log
-        if ([changedProps containsObject:@"page"]) {
-            NSString *logPath14 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-            NSDictionary *logEntry14 = @{
-                @"sessionId": @"debug-session",
-                @"runId": @"init",
-                @"hypothesisId": @"A,C,D",
-                @"location": @"RNPDFPdfView.mm:803",
-                @"message": @"updateProps: page prop changed - checking shouldNavigateToPage",
-                @"data": @{
-                    @"_page": @(_page),
-                    @"_previousPage": @(_previousPage),
-                    @"documentLoaded": @(_documentLoaded),
-                    @"isNavigating": @(_isNavigating),
-                    @"shouldNavigateToPage": @(shouldNavigateToPage),
-                    @"contentOffsetBeforeNav": _internalScrollView ? @{@"x": @(_internalScrollView.contentOffset.x), @"y": @(_internalScrollView.contentOffset.y)} : @"noScrollView"
-                },
-                @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-            };
-            NSData *logData14 = [NSJSONSerialization dataWithJSONObject:logEntry14 options:0 error:nil];
-            NSString *logLine14 = [[NSString alloc] initWithData:logData14 encoding:NSUTF8StringEncoding];
-            NSFileHandle *fileHandle14 = [NSFileHandle fileHandleForWritingAtPath:logPath14];
-            if (fileHandle14) {
-                [fileHandle14 seekToEndOfFile];
-                [fileHandle14 writeData:[[logLine14 stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                [fileHandle14 closeFile];
-            } else {
-                [[logLine14 stringByAppendingString:@"\n"] writeToFile:logPath14 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-            }
-        }
-        // #endregion
-        
         if (shouldNavigateToPage) {
             _isNavigating = YES;
             PDFPage *pdfPage = [_pdfDocument pageAtIndex:_page-1];
@@ -841,35 +786,6 @@ using namespace facebook::react;
             if (pdfPage) {
                 // Use smooth navigation instead of instant jump to prevent full rerender
                 dispatch_async(dispatch_get_main_queue(), ^{
-                    // #region agent log
-                    CGPoint contentOffsetBefore = self->_internalScrollView ? self->_internalScrollView.contentOffset : CGPointMake(0, 0);
-                    NSString *logPath15 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-                    NSDictionary *logEntry15 = @{
-                        @"sessionId": @"debug-session",
-                        @"runId": @"init",
-                        @"hypothesisId": @"B,C",
-                        @"location": @"RNPDFPdfView.mm:812",
-                        @"message": @"goToDestination: BEFORE navigation call",
-                        @"data": @{
-                            @"targetPage": @(self->_page),
-                            @"enablePaging": @(self->_enablePaging),
-                            @"contentOffsetBefore": @{@"x": @(contentOffsetBefore.x), @"y": @(contentOffsetBefore.y)},
-                            @"isNavigating": @(self->_isNavigating)
-                        },
-                        @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-                    };
-                    NSData *logData15 = [NSJSONSerialization dataWithJSONObject:logEntry15 options:0 error:nil];
-                    NSString *logLine15 = [[NSString alloc] initWithData:logData15 encoding:NSUTF8StringEncoding];
-                    NSFileHandle *fileHandle15 = [NSFileHandle fileHandleForWritingAtPath:logPath15];
-                    if (fileHandle15) {
-                        [fileHandle15 seekToEndOfFile];
-                        [fileHandle15 writeData:[[logLine15 stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                        [fileHandle15 closeFile];
-                    } else {
-                        [[logLine15 stringByAppendingString:@"\n"] writeToFile:logPath15 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-                    }
-                    // #endregion
-                    
                     if (!self->_enablePaging) {
                         // For non-paging mode, use animated navigation
                         CGRect pdfPageRect = [pdfPage boundsForBox:kPDFDisplayBoxCropBox];
@@ -904,38 +820,6 @@ using namespace facebook::react;
                     
                     self->_previousPage = self->_page;
                     self->_isNavigating = NO;
-                    
-                    // #region agent log
-                    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-                        CGPoint contentOffsetAfter = self->_internalScrollView ? self->_internalScrollView.contentOffset : CGPointMake(0, 0);
-                        NSString *logPath16 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-                        NSDictionary *logEntry16 = @{
-                            @"sessionId": @"debug-session",
-                            @"runId": @"init",
-                            @"hypothesisId": @"B,C",
-                            @"location": @"RNPDFPdfView.mm:845",
-                            @"message": @"goToDestination: AFTER navigation call (100ms delay)",
-                            @"data": @{
-                                @"targetPage": @(self->_page),
-                                @"previousPage": @(self->_previousPage),
-                                @"contentOffsetBefore": @{@"x": @(contentOffsetBefore.x), @"y": @(contentOffsetBefore.y)},
-                                @"contentOffsetAfter": @{@"x": @(contentOffsetAfter.x), @"y": @(contentOffsetAfter.y)},
-                                @"offsetChanged": @(fabs(contentOffsetBefore.x - contentOffsetAfter.x) > 1 || fabs(contentOffsetBefore.y - contentOffsetAfter.y) > 1)
-                            },
-                            @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-                        };
-                        NSData *logData16 = [NSJSONSerialization dataWithJSONObject:logEntry16 options:0 error:nil];
-                        NSString *logLine16 = [[NSString alloc] initWithData:logData16 encoding:NSUTF8StringEncoding];
-                        NSFileHandle *fileHandle16 = [NSFileHandle fileHandleForWritingAtPath:logPath16];
-                        if (fileHandle16) {
-                            [fileHandle16 seekToEndOfFile];
-                            [fileHandle16 writeData:[[logLine16 stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                            [fileHandle16 closeFile];
-                        } else {
-                            [[logLine16 stringByAppendingString:@"\n"] writeToFile:logPath16 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-                        }
-                    });
-                    // #endregion
                 });
             } else {
                 _isNavigating = NO;
@@ -1415,40 +1299,6 @@ using namespace facebook::react;
                   NSStringFromCGSize(scrollView.contentSize),
                   enabled);
         
-        // #region agent log
-        {
-            NSString *logPath1 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-            NSDictionary *logEntry1 = @{
-                @"sessionId": @"debug-session",
-                @"runId": @"init",
-                @"hypothesisId": @"D,F",
-                @"location": @"RNPDFPdfView.mm:1307",
-                @"message": @"Found UIScrollView in hierarchy",
-                @"data": @{
-                    @"depth": @(depth),
-                    @"contentSize": @{@"width": @(scrollView.contentSize.width), @"height": @(scrollView.contentSize.height)},
-                    @"frame": @{@"x": @(scrollView.frame.origin.x), @"y": @(scrollView.frame.origin.y), @"width": @(scrollView.frame.size.width), @"height": @(scrollView.frame.size.height)},
-                    @"scrollEnabled": @(scrollView.scrollEnabled),
-                    @"alwaysBounceHorizontal": @(scrollView.alwaysBounceHorizontal),
-                    @"userInteractionEnabled": @(scrollView.userInteractionEnabled),
-                    @"horizontal": @(_horizontal),
-                    @"enablePaging": @(_enablePaging)
-                },
-                @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-            };
-            NSData *logData1 = [NSJSONSerialization dataWithJSONObject:logEntry1 options:0 error:nil];
-            NSString *logLine1 = [[NSString alloc] initWithData:logData1 encoding:NSUTF8StringEncoding];
-            NSFileHandle *fileHandle1 = [NSFileHandle fileHandleForWritingAtPath:logPath1];
-            if (fileHandle1) {
-                [fileHandle1 seekToEndOfFile];
-                [fileHandle1 writeData:[[logLine1 stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                [fileHandle1 closeFile];
-            } else {
-                [[logLine1 stringByAppendingString:@"\n"] writeToFile:logPath1 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-            }
-        }
-        // #endregion
-        
         // Since we're starting the recursion from _pdfView, all scroll views found are within its hierarchy
         // Configure scroll properties
         BOOL previousScrollEnabled = scrollView.scrollEnabled;
@@ -1484,40 +1334,6 @@ using namespace facebook::react;
                   scrollView.bounces,
                   scrollView.delegate != nil ? @"set" : @"nil");
         
-        // #region agent log
-        {
-            NSString *logPath3 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-            NSDictionary *logEntry3 = @{
-                @"sessionId": @"debug-session",
-                @"runId": @"init",
-                @"hypothesisId": @"A,B,C,D,E",
-                @"location": @"RNPDFPdfView.mm:1374",
-                @"message": @"ScrollView configuration completed",
-                @"data": @{
-                    @"scrollEnabled": @(scrollView.scrollEnabled),
-                    @"alwaysBounceHorizontal": @(scrollView.alwaysBounceHorizontal),
-                    @"bounces": @(scrollView.bounces),
-                    @"contentSize": @{@"width": @(scrollView.contentSize.width), @"height": @(scrollView.contentSize.height)},
-                    @"userInteractionEnabled": @(scrollView.userInteractionEnabled),
-                    @"delegate": scrollView.delegate != nil ? @"set" : @"nil",
-                    @"horizontal": @(_horizontal),
-                    @"enablePaging": @(_enablePaging)
-                },
-                @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-            };
-            NSData *logData3 = [NSJSONSerialization dataWithJSONObject:logEntry3 options:0 error:nil];
-            NSString *logLine3 = [[NSString alloc] initWithData:logData3 encoding:NSUTF8StringEncoding];
-            NSFileHandle *fileHandle3 = [NSFileHandle fileHandleForWritingAtPath:logPath3];
-            if (fileHandle3) {
-                [fileHandle3 seekToEndOfFile];
-                [fileHandle3 writeData:[[logLine3 stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                [fileHandle3 closeFile];
-            } else {
-                [[logLine3 stringByAppendingString:@"\n"] writeToFile:logPath3 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-            }
-        }
-        // #endregion
-
         // IMPORTANT: PDFKit relies on the scrollView delegate for pinch-zoom (viewForZoomingInScrollView).
         // Install a proxy delegate that forwards to the original delegate, while still letting us observe scroll events.
         if (!_internalScrollView) {
@@ -1549,41 +1365,6 @@ using namespace facebook::react;
         RCTLogWarn(@"⚠️ [iOS Scroll] No UIScrollView found in view hierarchy (view=%@, subviewCount=%lu)", 
                   NSStringFromClass([view class]), 
                   (unsigned long)[view.subviews count]);
-        
-        // #region agent log
-        {
-            NSString *logPath6 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-            NSMutableArray *subviewClasses = [NSMutableArray array];
-            for (UIView *subview in view.subviews) {
-                [subviewClasses addObject:NSStringFromClass([subview class])];
-            }
-            NSDictionary *logEntry6 = @{
-                @"sessionId": @"debug-session",
-                @"runId": @"init",
-                @"hypothesisId": @"F",
-                @"location": @"RNPDFPdfView.mm:1446",
-                @"message": @"No UIScrollView found in hierarchy",
-                @"data": @{
-                    @"viewClass": NSStringFromClass([view class]),
-                    @"subviewCount": @([view.subviews count]),
-                    @"subviewClasses": subviewClasses,
-                    @"horizontal": @(_horizontal),
-                    @"enablePaging": @(_enablePaging)
-                },
-                @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-            };
-            NSData *logData6 = [NSJSONSerialization dataWithJSONObject:logEntry6 options:0 error:nil];
-            NSString *logLine6 = [[NSString alloc] initWithData:logData6 encoding:NSUTF8StringEncoding];
-            NSFileHandle *fileHandle6 = [NSFileHandle fileHandleForWritingAtPath:logPath6];
-            if (fileHandle6) {
-                [fileHandle6 seekToEndOfFile];
-                [fileHandle6 writeData:[[logLine6 stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                [fileHandle6 closeFile];
-            } else {
-                [[logLine6 stringByAppendingString:@"\n"] writeToFile:logPath6 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-            }
-        }
-        // #endregion
     }
 }
 
@@ -1604,38 +1385,6 @@ using namespace facebook::react;
                   scrollView.bounds.size.width,
                   scrollView.bounds.size.height,
                   scrollView.scrollEnabled);
-        
-        // #region agent log
-        {
-            NSString *logPath2 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-            NSDictionary *logEntry2 = @{
-                @"sessionId": @"debug-session",
-                @"runId": @"init",
-                @"hypothesisId": @"B",
-                @"location": @"RNPDFPdfView.mm:1300",
-                @"message": @"scrollViewDidScroll called",
-                @"data": @{
-                    @"eventCount": @(scrollEventCount),
-                    @"contentOffset": @{@"x": @(scrollView.contentOffset.x), @"y": @(scrollView.contentOffset.y)},
-                    @"contentSize": @{@"width": @(scrollView.contentSize.width), @"height": @(scrollView.contentSize.height)},
-                    @"bounds": @{@"width": @(scrollView.bounds.size.width), @"height": @(scrollView.bounds.size.height)},
-                    @"scrollEnabled": @(scrollView.scrollEnabled),
-                    @"alwaysBounceHorizontal": @(scrollView.alwaysBounceHorizontal)
-                },
-                @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-            };
-            NSData *logData2 = [NSJSONSerialization dataWithJSONObject:logEntry2 options:0 error:nil];
-            NSString *logLine2 = [[NSString alloc] initWithData:logData2 encoding:NSUTF8StringEncoding];
-            NSFileHandle *fileHandle2 = [NSFileHandle fileHandleForWritingAtPath:logPath2];
-            if (fileHandle2) {
-                [fileHandle2 seekToEndOfFile];
-                [fileHandle2 writeData:[[logLine2 stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                [fileHandle2 closeFile];
-            } else {
-                [[logLine2 stringByAppendingString:@"\n"] writeToFile:logPath2 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-            }
-        }
-        // #endregion
     }
 
     if (!_pdfDocument || _singlePage) {
@@ -1664,36 +1413,6 @@ using namespace facebook::react;
         // Only update if page actually changed and is valid
         if (newPage != _page && newPage > 0 && newPage <= (int)_pdfDocument.pageCount) {
             RCTLogInfo(@"📄 [iOS Scroll] Page changed: %d -> %d (from scroll position)", _page, newPage);
-            // #region agent log
-            {
-                NSString *logPath12 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-                NSDictionary *logEntry12 = @{
-                    @"sessionId": @"debug-session",
-                    @"runId": @"init",
-                    @"hypothesisId": @"A,C,D",
-                    @"location": @"RNPDFPdfView.mm:1558",
-                    @"message": @"scrollViewDidScroll detected page change - BEFORE updating _page",
-                    @"data": @{
-                        @"oldPage": @(_page),
-                        @"newPage": @(newPage),
-                        @"previousPage": @(_previousPage),
-                        @"contentOffset": @{@"x": @(scrollView.contentOffset.x), @"y": @(scrollView.contentOffset.y)},
-                        @"isNavigating": @(_isNavigating)
-                    },
-                    @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-                };
-                NSData *logData12 = [NSJSONSerialization dataWithJSONObject:logEntry12 options:0 error:nil];
-                NSString *logLine12 = [[NSString alloc] initWithData:logData12 encoding:NSUTF8StringEncoding];
-                NSFileHandle *fileHandle12 = [NSFileHandle fileHandleForWritingAtPath:logPath12];
-                if (fileHandle12) {
-                    [fileHandle12 seekToEndOfFile];
-                    [fileHandle12 writeData:[[logLine12 stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                    [fileHandle12 closeFile];
-                } else {
-                    [[logLine12 stringByAppendingString:@"\n"] writeToFile:logPath12 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-                }
-            }
-            // #endregion
             
             // CRITICAL FIX: Update _previousPage to the new page value when page changes from user scrolling
             // This prevents updateProps from triggering programmatic navigation when React Native
@@ -1712,34 +1431,6 @@ using namespace facebook::react;
             
             // Notify about page change
             [self notifyOnChangeWithMessage:[[NSString alloc] initWithString:[NSString stringWithFormat:@"pageChanged|%d|%lu", newPage, _pdfDocument.pageCount]]];
-            // #region agent log
-            {
-                NSString *logPath13 = @"/Users/punithmanthri/Documents/github jsi folder /react-native-enhanced-pdf/.cursor/debug.log";
-                NSDictionary *logEntry13 = @{
-                    @"sessionId": @"debug-session",
-                    @"runId": @"init",
-                    @"hypothesisId": @"A,C,D",
-                    @"location": @"RNPDFPdfView.mm:1570",
-                    @"message": @"scrollViewDidScroll detected page change - AFTER updating _page and _previousPage (to prevent navigation loop)",
-                    @"data": @{
-                        @"_page": @(_page),
-                        @"_previousPage": @(_previousPage),
-                        @"notificationSent": @YES
-                    },
-                    @"timestamp": @((long long)([[NSDate date] timeIntervalSince1970] * 1000))
-                };
-                NSData *logData13 = [NSJSONSerialization dataWithJSONObject:logEntry13 options:0 error:nil];
-                NSString *logLine13 = [[NSString alloc] initWithData:logData13 encoding:NSUTF8StringEncoding];
-                NSFileHandle *fileHandle13 = [NSFileHandle fileHandleForWritingAtPath:logPath13];
-                if (fileHandle13) {
-                    [fileHandle13 seekToEndOfFile];
-                    [fileHandle13 writeData:[[logLine13 stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding]];
-                    [fileHandle13 closeFile];
-                } else {
-                    [[logLine13 stringByAppendingString:@"\n"] writeToFile:logPath13 atomically:YES encoding:NSUTF8StringEncoding error:nil];
-                }
-            }
-            // #endregion
         }
     } else {
         if (scrollEventCount % 50 == 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-pdf-jsi",
-    "version": "4.2.0",
+    "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';