react-native-pdf-jsi 4.2.1 → 4.3.0

package/README.md

@@ -9,6 +9,7 @@
 ---
 
 [![npm version](https://img.shields.io/npm/v/react-native-pdf-jsi?style=flat-square&logo=npm&color=cb3837)](https://www.npmjs.com/package/react-native-pdf-jsi)
+[![Expo Compatible](https://img.shields.io/badge/Expo-Compatible-4630EB?style=flat-square&logo=expo)](https://expo.dev)
 [![total downloads](https://img.shields.io/npm/dt/react-native-pdf-jsi?style=flat-square&logo=npm&color=cb3837)](https://www.npmjs.com/package/react-native-pdf-jsi)
 [![weekly downloads](https://img.shields.io/npm/dw/react-native-pdf-jsi?style=flat-square&logo=npm&color=cb3837)](https://www.npmjs.com/package/react-native-pdf-jsi)
 [![GitHub stars](https://img.shields.io/github/stars/126punith/react-native-pdf-jsi?style=flat-square&logo=github&color=181717)](https://github.com/126punith/react-native-pdf-jsi)
@@ -111,6 +112,51 @@ react-native link react-native-blob-util
 react-native link react-native-pdf-jsi
 ```
 
+### Expo Installation
+
+This package works with **Expo development builds** (not Expo Go, as it requires native code).
+
+**1. Install the package and peer dependencies:**
+
+```bash
+npx expo install react-native-pdf-jsi react-native-blob-util @react-native-async-storage/async-storage
+```
+
+**2. Add the config plugin to your `app.json` or `app.config.js`:**
+
+```json
+{
+  "expo": {
+    "plugins": ["react-native-pdf-jsi"]
+  }
+}
+```
+
+**3. Rebuild your development build:**
+
+```bash
+# Generate native projects
+npx expo prebuild
+
+# Run on iOS
+npx expo run:ios
+
+# Run on Android
+npx expo run:android
+```
+
+> **Note:** The config plugin automatically configures:
+> - Android: Adds Jitpack repository for PDF rendering dependencies
+> - iOS: Ensures PDFKit framework is properly linked
+
+**For EAS Build users:**
+
+```bash
+# Build development client
+eas build --profile development --platform ios
+eas build --profile development --platform android
+```
+
 ### Windows Installation
 
 1. Open your solution in Visual Studio 2019 (e.g., `windows\yourapp.sln`)
@@ -409,6 +455,38 @@ MIT License - see [LICENSE](LICENSE) file for details.
 - **Author**: Punith M ([@126punith](https://github.com/126punith))
 
 ## Recent Fixes
+
+### Expo Support (v4.3.0)
+Added Expo config plugin for seamless integration with Expo development builds. The package now works with `npx expo prebuild` and `npx expo run:ios/android`.
+
+**Installation:**
+```bash
+npx expo install react-native-pdf-jsi react-native-blob-util @react-native-async-storage/async-storage
+```
+
+**Configuration (app.json):**
+```json
+{
+  "expo": {
+    "plugins": ["react-native-pdf-jsi"]
+  }
+}
+```
+
+**Note:** Expo Go is NOT supported (requires native code). Use Expo development builds.
+
+### 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/app.plugin.js

@@ -0,0 +1,2 @@
+// Expo config plugin entry point
+module.exports = require('./plugin/build').default;

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,10 +1,13 @@
 {
     "name": "react-native-pdf-jsi",
-    "version": "4.2.1",
+    "version": "4.3.0",
     "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",
     "typings": "./index.d.ts",
+    "app": {
+        "plugin": "./plugin/build"
+    },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/126punith/react-native-pdf-jsi.git"
@@ -50,7 +53,9 @@
         "optimization",
         "caching",
         "persistent-cache",
-        "react-native-pdf-jsi-enhanced"
+        "react-native-pdf-jsi-enhanced",
+        "expo",
+        "expo-plugin"
     ],
     "author": {
         "name": "Punith M",
@@ -69,7 +74,13 @@
     "devDependencies": {
         "@babel/core": "^7.20.2",
         "@babel/runtime": "^7.20.1",
-        "prop-types": "^15.7.2"
+        "@expo/config-plugins": "^9.0.0",
+        "prop-types": "^15.7.2",
+        "typescript": "^5.0.0"
+    },
+    "scripts": {
+        "build:plugin": "tsc -p plugin/tsconfig.json",
+        "prepublishOnly": "npm run build:plugin"
     },
     "peerDependencies": {
         "@react-native-async-storage/async-storage": ">=1.17.0",
@@ -82,6 +93,8 @@
         "ios/",
         "windows/",
         "src/",
+        "plugin/",
+        "app.plugin.js",
         "DoubleTapView.js",
         "index.d.ts",
         "index.js",

package/plugin/build/index.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+declare const _default: ConfigPlugin<void>;
+export default _default;

package/plugin/build/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const withPdfJsiAndroid_1 = require("./withPdfJsiAndroid");
+const withPdfJsiIos_1 = require("./withPdfJsiIos");
+const pkg = require('../../package.json');
+/**
+ * Expo config plugin for react-native-pdf-jsi
+ *
+ * This plugin configures the native projects for Expo development builds.
+ * It handles:
+ * - Android: Jitpack repository for AndroidPdfViewer, NDK configuration
+ * - iOS: PDFKit framework linking
+ *
+ * Note: This package requires development builds and won't work with Expo Go.
+ */
+const withPdfJsi = (config) => {
+    // Warn about peer dependencies
+    console.log('[react-native-pdf-jsi] Remember to install peer dependencies:\n' +
+        '  - react-native-blob-util\n' +
+        '  - @react-native-async-storage/async-storage');
+    config = (0, withPdfJsiAndroid_1.withPdfJsiAndroid)(config);
+    config = (0, withPdfJsiIos_1.withPdfJsiIos)(config);
+    return config;
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withPdfJsi, pkg.name, pkg.version);

package/plugin/build/withPdfJsiAndroid.d.ts

@@ -0,0 +1,8 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+/**
+ * Android config plugin for react-native-pdf-jsi
+ *
+ * Configures the Android project to support the PDF library:
+ * - Adds Jitpack repository for AndroidPdfViewer dependency
+ */
+export declare const withPdfJsiAndroid: ConfigPlugin;