react-native-pdf-jsi 3.2.0 → 3.3.0

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

@@ -475,3 +475,4 @@ public class FileDownloader extends ReactContextBaseJavaModule {
         }).start();
     }
 }
+

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

@@ -214,3 +214,4 @@ public class FileManager extends ReactContextBaseJavaModule {
     }
 }
 
+

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

@@ -153,7 +153,7 @@ public class PdfManager extends SimpleViewManager<PdfView> implements RNPDFPdfVi
     public void setSinglePage(PdfView pdfView, boolean singlePage) {
         pdfView.setSinglePage(singlePage);
     }
-
+    
     // It seems funny, but this method is called through delegate on Paper, but on Fabric we need to
     // use `receiveCommand` method and call this one there
     @Override
@@ -174,7 +174,8 @@ public class PdfManager extends SimpleViewManager<PdfView> implements RNPDFPdfVi
     @Override
     public void onAfterUpdateTransaction(PdfView pdfView) {
         super.onAfterUpdateTransaction(pdfView);
-        pdfView.drawPdf();
+        // Removed pdfView.drawPdf() - PdfView now manages reload internally
+        // to prevent unnecessary document recreation on scroll/prop updates
     }
 
 }

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

@@ -75,9 +75,15 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
     private FitPolicy fitPolicy = FitPolicy.WIDTH;
     private boolean singlePage = false;
     private boolean scrollEnabled = true;
+    
+    private String decelerationRate = "normal"; // "normal", "fast", "slow"
 
     private float originalWidth = 0;
     private float lastPageWidth = 0;
+    
+    // Track if document needs reload (FIX: Prevent recreation on prop changes)
+    private boolean needsReload = true;
+    private String lastLoadedPath = null;
     private float lastPageHeight = 0;
 
     // used to store the parameters for `super.onSizeChanged`
@@ -279,6 +285,17 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
     }
 
     public void drawPdf() {
+        
+        // FIX: Check if we actually need to reload the document
+        // Only reload if path changed or this is first load
+        if (!needsReload && this.path != null && this.path.equals(lastLoadedPath)) {
+            showLog(format("drawPdf: Skipping reload, path unchanged: %s", this.path));
+            // Just jump to the page if needed, dont reload entire document
+            if (this.page > 0 && !this.isRecycled()) {
+                this.jumpTo(this.page - 1, false);
+            }
+            return;
+        }
         showLog(format("drawPdf path:%s %s", this.path, this.page));
 
         if (this.path != null){
@@ -333,6 +350,10 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
             }
 
             configurator.load();
+            
+            // Mark as loaded, clear reload flag
+            lastLoadedPath = this.path;
+            needsReload = false;
         }
     }
 
@@ -341,6 +362,8 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
     }
 
     public void setPath(String path) {
+        // Path changed - need to reload document
+        needsReload = true;
         this.path = path;
     }
 
@@ -419,6 +442,12 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
     public void setSinglePage(boolean singlePage) {
         this.singlePage = singlePage;
     }
+    
+    /**
+    
+    /**
+    
+    /**
 
     /**
      * @see https://github.com/barteksc/AndroidPdfViewer/blob/master/android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/link/DefaultLinkHandler.java

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

@@ -0,0 +1,236 @@
+/**
+ * Streaming Base64 Decoder for Large PDFs
+ * Eliminates OOM crashes by processing base64 data in chunks
+ * 
+ * Features:
+ * - O(1) constant memory usage (8KB chunks)
+ * - Progress callback support
+ * - PDF header validation
+ * - Error handling and recovery
+ * 
+ * Usage:
+ *   StreamingBase64Decoder.decodeToFile(base64String, outputFile);
+ *   StreamingBase64Decoder.decodeToFileWithProgress(base64String, outputFile, progress -> {
+ *       Log.i("Decode", "Progress: " + (progress * 100) + "%");
+ *   });
+ */
+
+package org.wonday.pdf;
+
+import android.util.Base64;
+import android.util.Log;
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+
+public class StreamingBase64Decoder {
+    private static final String TAG = "StreamingBase64Decoder";
+    
+    // Chunk size for processing (8KB = optimal for memory/performance balance)
+    private static final int CHUNK_SIZE = 8192;
+    
+    // PDF file signature (magic bytes)
+    private static final byte[] PDF_HEADER = {0x25, 0x50, 0x44, 0x46}; // "%PDF"
+    
+    /**
+     * Progress callback interface
+     */
+    public interface ProgressCallback {
+        void onProgress(float progress);
+    }
+    
+    /**
+     * Decode base64 string to file using streaming (O(1) memory)
+     * 
+     * @param base64Data Base64 encoded PDF data
+     * @param outputFile Output file to write decoded data
+     * @throws IOException If I/O error occurs
+     * @throws IllegalArgumentException If invalid base64 or not a PDF
+     */
+    public static void decodeToFile(String base64Data, File outputFile) throws IOException {
+        decodeToFileWithProgress(base64Data, outputFile, null);
+    }
+    
+    /**
+     * Decode base64 string to file with progress callback
+     * 
+     * @param base64Data Base64 encoded PDF data
+     * @param outputFile Output file to write decoded data
+     * @param callback Progress callback (0.0 to 1.0)
+     * @throws IOException If I/O error occurs
+     * @throws IllegalArgumentException If invalid base64 or not a PDF
+     */
+    public static void decodeToFileWithProgress(
+            String base64Data, 
+            File outputFile,
+            ProgressCallback callback) throws IOException {
+        
+        long startTime = System.currentTimeMillis();
+        Log.i(TAG, "[PERF] [decodeToFileWithProgress] 🔵 ENTER - Input size: " + base64Data.length() + " chars");
+        
+        if (base64Data == null || base64Data.trim().isEmpty()) {
+            throw new IllegalArgumentException("Base64 data is null or empty");
+        }
+        
+        // Clean base64 data - remove data URI prefix if present
+        long cleanStart = System.currentTimeMillis();
+        String cleanBase64 = cleanBase64Data(base64Data);
+        long cleanTime = System.currentTimeMillis() - cleanStart;
+        Log.i(TAG, "[PERF] [decodeToFileWithProgress]   Clean data: " + cleanTime + "ms");
+        
+        int totalLength = cleanBase64.length();
+        int offset = 0;
+        boolean isFirstChunk = true;
+        
+        try (FileOutputStream fos = new FileOutputStream(outputFile);
+             BufferedOutputStream bos = new BufferedOutputStream(fos, 16384)) {
+            
+            long decodeStart = System.currentTimeMillis();
+            int chunksProcessed = 0;
+            
+            // Process base64 data in chunks
+            while (offset < totalLength) {
+                // Calculate chunk boundaries (must be multiple of 4 for base64)
+                int chunkEnd = Math.min(offset + CHUNK_SIZE, totalLength);
+                
+                // Adjust chunk end to be on a base64 boundary (multiple of 4)
+                // Exception: last chunk can be any size
+                if (chunkEnd < totalLength) {
+                    int remainder = (chunkEnd - offset) % 4;
+                    if (remainder != 0) {
+                        chunkEnd -= remainder;
+                    }
+                }
+                
+                // Extract and decode chunk
+                String chunk = cleanBase64.substring(offset, chunkEnd);
+                byte[] decodedChunk;
+                
+                try {
+                    decodedChunk = Base64.decode(chunk, Base64.DEFAULT);
+                } catch (IllegalArgumentException e) {
+                    Log.e(TAG, "Invalid base64 data at offset " + offset, e);
+                    throw new IllegalArgumentException("Invalid base64 encoding at position " + offset, e);
+                }
+                
+                // Validate PDF header on first chunk
+                if (isFirstChunk) {
+                    if (!validatePDFHeader(decodedChunk)) {
+                        throw new IllegalArgumentException("Invalid PDF data - missing or corrupt PDF header");
+                    }
+                    isFirstChunk = false;
+                    Log.i(TAG, "[PERF] [decodeToFileWithProgress]   PDF header validated ✓");
+                }
+                
+                // Write decoded chunk to file
+                bos.write(decodedChunk);
+                
+                offset = chunkEnd;
+                chunksProcessed++;
+                
+                // Report progress
+                if (callback != null && chunksProcessed % 10 == 0) {
+                    float progress = (float) offset / totalLength;
+                    callback.onProgress(progress);
+                }
+            }
+            
+            bos.flush();
+            fos.getFD().sync(); // Force sync to disk for durability
+            
+            long decodeTime = System.currentTimeMillis() - decodeStart;
+            long totalTime = System.currentTimeMillis() - startTime;
+            
+            Log.i(TAG, "[PERF] [decodeToFileWithProgress]   Decode time: " + decodeTime + "ms");
+            Log.i(TAG, "[PERF] [decodeToFileWithProgress]   Chunks processed: " + chunksProcessed);
+            Log.i(TAG, "[PERF] [decodeToFileWithProgress]   Output size: " + outputFile.length() + " bytes");
+            Log.i(TAG, "[PERF] [decodeToFileWithProgress] 🔴 EXIT - Total: " + totalTime + "ms");
+            
+            // Final progress callback
+            if (callback != null) {
+                callback.onProgress(1.0f);
+            }
+            
+        } catch (IOException e) {
+            // Clean up partial file on error
+            if (outputFile.exists()) {
+                outputFile.delete();
+            }
+            Log.e(TAG, "Failed to decode base64 to file", e);
+            throw e;
+        }
+    }
+    
+    /**
+     * Clean base64 data - remove whitespace, newlines, and data URI prefix
+     */
+    private static String cleanBase64Data(String base64Data) {
+        String cleaned = base64Data.trim();
+        
+        // Remove data URI prefix if present (e.g., "data:application/pdf;base64,")
+        int commaIndex = cleaned.indexOf(',');
+        if (commaIndex != -1 && cleaned.substring(0, commaIndex).contains("base64")) {
+            cleaned = cleaned.substring(commaIndex + 1);
+        }
+        
+        // Remove all whitespace and newlines (some base64 strings have line breaks)
+        cleaned = cleaned.replaceAll("\\s+", "");
+        
+        return cleaned;
+    }
+    
+    /**
+     * Validate PDF header (magic bytes: %PDF)
+     */
+    private static boolean validatePDFHeader(byte[] data) {
+        if (data == null || data.length < PDF_HEADER.length) {
+            return false;
+        }
+        
+        // Check for PDF magic bytes at start
+        for (int i = 0; i < PDF_HEADER.length; i++) {
+            if (data[i] != PDF_HEADER[i]) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+    
+    /**
+     * Validate PDF file header
+     */
+    public static boolean validatePDFFile(File file) throws IOException {
+        if (file == null || !file.exists() || file.length() < PDF_HEADER.length) {
+            return false;
+        }
+        
+        try (FileInputStream fis = new FileInputStream(file)) {
+            byte[] header = new byte[PDF_HEADER.length];
+            int bytesRead = fis.read(header);
+            
+            if (bytesRead < PDF_HEADER.length) {
+                return false;
+            }
+            
+            return validatePDFHeader(header);
+        }
+    }
+    
+    /**
+     * Estimate decoded size from base64 length
+     * Base64 encoding increases size by ~33%, so decoded size is ~75% of encoded
+     */
+    public static long estimateDecodedSize(int base64Length) {
+        return (long) (base64Length * 0.75);
+    }
+    
+    /**
+     * Calculate number of chunks for given base64 data
+     */
+    public static int calculateChunkCount(int base64Length) {
+        return (int) Math.ceil((double) base64Length / CHUNK_SIZE);
+    }
+}
+
+
+

package/index.d.ts

@@ -39,6 +39,9 @@ export interface PdfProps {
     showsHorizontalScrollIndicator?: boolean,
     showsVerticalScrollIndicator?: boolean,
     scrollEnabled?: boolean,
+    /**
+    /**
+    /**
     spacing?: number,
     password?: string,
     renderActivityIndicator?: (progress: number) => React.ReactElement,
@@ -70,3 +73,127 @@ declare class Pdf extends React.Component<PdfProps, any> {
 }
 
 export default Pdf;
+
+// ========================================
+// PDFCache (Streaming Base64 Decoder)
+// ========================================
+
+/**
+ * Cache info returned from storage operations
+ */
+export interface CacheInfo {
+    cacheId: string;
+    filePath: string;
+    fileSize: number;
+    createdAt: number;
+    lastAccessed?: number;
+    expired?: boolean;
+}
+
+/**
+ * Options for storing base64 PDF with streaming decoder
+ */
+export interface StoreBase64Options {
+    /**
+     * Base64 PDF data (with or without data URI prefix)
+     */
+    base64: string;
+    /**
+     * Custom cache identifier (optional, auto-generated if not provided)
+     */
+    identifier?: string;
+    /**
+     * Cache TTL in milliseconds
+     * @default 2592000000 (30 days)
+     */
+    maxAge?: number;
+    /**
+     * Maximum cache size in bytes
+     * @default 524288000 (500MB)
+     */
+    maxSize?: number;
+    /**
+     * Progress callback (0.0 to 1.0)
+     */
+    onProgress?: (progress: number) => void;
+}
+
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+    totalSize: number;
+    fileCount: number;
+    hitRate: number;
+    cacheHits: number;
+    cacheMisses: number;
+    averageLoadTime: number;
+}
+
+/**
+ * PDFCache Manager for streaming base64 decoding
+ * Eliminates OOM crashes with large PDFs (60MB-200MB+)
+ */
+export interface PDFCacheManager {
+    /**
+     * Store base64 PDF with streaming decoder (O(1) constant memory)
+     * @param options Storage options
+     * @returns Promise resolving to cache info
+     */
+    storeBase64(options: StoreBase64Options): Promise<CacheInfo>;
+    
+    /**
+     * Get cached PDF by identifier
+     * @param identifier Cache identifier
+     * @returns Promise resolving to cache info or null if not found
+     */
+    get(identifier: string): Promise<CacheInfo | null>;
+    
+    /**
+     * Check if PDF is cached and not expired
+     * @param identifier Cache identifier
+     * @returns Promise resolving to true if cached and valid
+     */
+    has(identifier: string): Promise<boolean>;
+    
+    /**
+     * Remove cached PDF
+     * @param identifier Cache identifier
+     * @returns Promise resolving to true if removed successfully
+     */
+    remove(identifier: string): Promise<boolean>;
+    
+    /**
+     * Clear all cached PDFs
+     */
+    clear(): Promise<void>;
+    
+    /**
+     * Clear expired PDFs only
+     * @returns Promise resolving to number of entries removed
+     */
+    clearExpired(): Promise<number>;
+    
+    /**
+     * Get cache statistics
+     * @returns Promise resolving to cache stats
+     */
+    getStats(): Promise<CacheStats>;
+    
+    /**
+     * Estimate decoded size from base64 length
+     * @param base64Length Length of base64 string
+     * @returns Estimated decoded size in bytes
+     */
+    estimateDecodedSize(base64Length: number): number;
+}
+
+/**
+ * PDFCache singleton instance
+ */
+export const PDFCache: PDFCacheManager;
+
+/**
+ * CacheManager (alias for PDFCache)
+ */
+export const CacheManager: PDFCacheManager;

package/index.js

@@ -610,12 +610,17 @@ import ExportManager from './src/managers/ExportManager';
 import BookmarkManager from './src/managers/BookmarkManager';
 import AnalyticsManager from './src/managers/AnalyticsManager';
 import FileManager from './src/managers/FileManager';
+import CacheManager from './src/managers/CacheManager';
+
+// Alias for backward compatibility and intuitive naming
+export const PDFCache = CacheManager;
 
 export {
     ExportManager,
     BookmarkManager,
     AnalyticsManager,
-    FileManager
+    FileManager,
+    CacheManager
 };
 
 // ========================================

package/ios/RNPDFPdf/PDFExporter.m

@@ -2,16 +2,14 @@
 #import <PDFKit/PDFKit.h>
 #import <UIKit/UIKit.h>
 
-@implementation PDFExporter {
-    LicenseVerifier *_licenseVerifier;
-}
+@implementation PDFExporter
 
 RCT_EXPORT_MODULE();
 
 - (instancetype)init {
     self = [super init];
     if (self) {
-        _licenseVerifier = [[LicenseVerifier alloc] init];
+        // All features are FREE - no license verification needed
     }
     return self;
 }
@@ -22,11 +20,7 @@ RCT_EXPORT_METHOD(exportToImages:(NSString *)filePath
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     
-    
-    if (![_licenseVerifier isProActive]) {
-        reject(@"LICENSE_REQUIRED", @"Export to Images requires a Pro license", nil);
-        return;
-    }
+    // All features are FREE - no license verification needed
     
     if (!filePath || filePath.length == 0) {
         reject(@"INVALID_PATH", @"File path is required", nil);
@@ -200,11 +194,7 @@ RCT_EXPORT_METHOD(mergePDFs:(NSArray *)filePaths
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     
-    // Check Pro license
-    if (![_licenseVerifier isProActive]) {
-        reject(@"LICENSE_REQUIRED", @"PDF Operations requires a Pro license", nil);
-        return;
-    }
+    // All features are FREE - no license verification needed
     
     if (!filePaths || filePaths.count < 2) {
         reject(@"INVALID_INPUT", @"At least 2 PDF files are required for merging", nil);
@@ -251,15 +241,7 @@ RCT_EXPORT_METHOD(splitPDF:(NSString *)filePath
     
     NSLog(@"✂️ [SPLIT] splitPDF - START - file: %@, ranges: %lu", filePath, (unsigned long)pageRanges.count);
     
-    // Check Pro license
-    BOOL licenseActive = [_licenseVerifier isProActive];
-    NSLog(@"🔑 [LICENSE] isProActive: %d", licenseActive);
-    
-    if (!licenseActive) {
-        NSLog(@"❌ [SPLIT] License required");
-        reject(@"LICENSE_REQUIRED", @"PDF Operations requires a Pro license", nil);
-        return;
-    }
+    // All features are FREE - no license verification needed
     
     if (!filePath || filePath.length == 0) {
         NSLog(@"❌ [SPLIT] Invalid path");
@@ -341,15 +323,7 @@ RCT_EXPORT_METHOD(extractPages:(NSString *)filePath
     
     NSLog(@"✂️ [EXTRACT] extractPages - START - file: %@, pages: %lu", filePath, (unsigned long)pageNumbers.count);
     
-    // Check Pro license
-    BOOL licenseActive = [_licenseVerifier isProActive];
-    NSLog(@"🔑 [LICENSE] isProActive: %d", licenseActive);
-    
-    if (!licenseActive) {
-        NSLog(@"❌ [EXTRACT] License required");
-        reject(@"LICENSE_REQUIRED", @"PDF Operations requires a Pro license", nil);
-        return;
-    }
+    // All features are FREE - no license verification needed
     
     if (!filePath || filePath.length == 0) {
         NSLog(@"❌ [EXTRACT] Invalid path");
@@ -420,11 +394,7 @@ RCT_EXPORT_METHOD(rotatePage:(NSString *)filePath
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     
-    // Check Pro license
-    if (![_licenseVerifier isProActive]) {
-        reject(@"LICENSE_REQUIRED", @"PDF Operations requires a Pro license", nil);
-        return;
-    }
+    // All features are FREE - no license verification needed
     
     if (!filePath || filePath.length == 0) {
         reject(@"INVALID_PATH", @"File path is required", nil);
@@ -473,11 +443,7 @@ RCT_EXPORT_METHOD(deletePage:(NSString *)filePath
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     
-    // Check Pro license
-    if (![_licenseVerifier isProActive]) {
-        reject(@"LICENSE_REQUIRED", @"PDF Operations requires a Pro license", nil);
-        return;
-    }
+    // All features are FREE - no license verification needed
     
     if (!filePath || filePath.length == 0) {
         reject(@"INVALID_PATH", @"File path is required", nil);

package/ios/RNPDFPdf/RNPDFPdfView.h

@@ -42,6 +42,9 @@ UIView
 @property(nonatomic) BOOL showsHorizontalScrollIndicator;
 @property(nonatomic) BOOL scrollEnabled;
 @property(nonatomic) BOOL enablePaging;
+@property(nonatomic) float scrollVelocity;
+@property(nonatomic) BOOL enableMomentum;
+@property(nonatomic, strong) NSString *decelerationRate;
 @property(nonatomic) BOOL enableRTL;
 @property(nonatomic) BOOL enableAnnotationRendering;
 @property(nonatomic) BOOL enableDoubleTapZoom;

package/ios/RNPDFPdf/RNPDFPdfView.mm

@@ -195,6 +195,20 @@ using namespace facebook::react;
         _scrollEnabled = newProps.scrollEnabled;
         [updatedPropNames addObject:@"scrollEnabled"];
     }
+    
+    // Scroll control properties (Issue #607)
+    if (_scrollVelocity != newProps.scrollVelocity) {
+        _scrollVelocity = newProps.scrollVelocity;
+        [updatedPropNames addObject:@"scrollVelocity"];
+    }
+    if (_enableMomentum != newProps.enableMomentum) {
+        _enableMomentum = newProps.enableMomentum;
+        [updatedPropNames addObject:@"enableMomentum"];
+    }
+    if (_decelerationRate != RCTNSStringFromStringNilIfEmpty(newProps.decelerationRate)) {
+        _decelerationRate = RCTNSStringFromStringNilIfEmpty(newProps.decelerationRate);
+        [updatedPropNames addObject:@"decelerationRate"];
+    }
 
     [super updateProps:props oldProps:oldProps];
     [self didSetProps:updatedPropNames];
@@ -284,6 +298,11 @@ using namespace facebook::react;
     _showsHorizontalScrollIndicator = YES;
     _showsVerticalScrollIndicator = YES;
     _scrollEnabled = YES;
+    
+    // Scroll control properties (Issue #607)
+    _scrollVelocity = 1.0f;
+    _enableMomentum = YES;
+    _decelerationRate = @"normal";
 
     // Enhanced properties
     _enableCaching = YES;
@@ -540,6 +559,33 @@ using namespace facebook::react;
                 }
             }
         }
+        
+        // Apply scroll control properties (Issue #607)
+        if (_pdfDocument && ([changedProps containsObject:@"path"] || 
+                             [changedProps containsObject:@"enableMomentum"] || 
+                             [changedProps containsObject:@"decelerationRate"])) {
+            for (UIView *subview in _pdfView.subviews) {
+                if ([subview isKindOfClass:[UIScrollView class]]) {
+                    UIScrollView *scrollView = (UIScrollView *)subview;
+                    
+                    // Apply momentum (bounces)
+                    scrollView.bounces = _enableMomentum;
+                    scrollView.alwaysBounceVertical = _enableMomentum;
+                    scrollView.alwaysBounceHorizontal = _enableMomentum;
+                    
+                    // Apply deceleration rate
+                    if ([_decelerationRate isEqualToString:@"fast"]) {
+                        scrollView.decelerationRate = UIScrollViewDecelerationRateFast;
+                    } else if ([_decelerationRate isEqualToString:@"slow"]) {
+                        scrollView.decelerationRate = UIScrollViewDecelerationRateNormal;
+                    } else {
+                        scrollView.decelerationRate = UIScrollViewDecelerationRateNormal;
+                    }
+                    
+                    NSLog(@"[RNPDFPdf] Applied scroll controls: momentum=%d, deceleration=%@", _enableMomentum, _decelerationRate);
+                }
+            }
+        }
 
         if (_pdfDocument && ([changedProps containsObject:@"path"] || [changedProps containsObject:@"enablePaging"] || [changedProps containsObject:@"horizontal"] || [changedProps containsObject:@"page"])) {
 

package/ios/RNPDFPdf/RNPDFPdfViewManager.mm

@@ -43,6 +43,9 @@ RCT_EXPORT_VIEW_PROPERTY(showsHorizontalScrollIndicator, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(showsVerticalScrollIndicator, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(scrollEnabled, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(enablePaging, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(scrollVelocity, float);
+RCT_EXPORT_VIEW_PROPERTY(enableMomentum, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(decelerationRate, NSString);
 RCT_EXPORT_VIEW_PROPERTY(enableRTL, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(enableAnnotationRendering, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(enableDoubleTapZoom, BOOL);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-pdf-jsi",
-    "version": "3.2.0",
+    "version": "3.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",

package/src/managers/CacheManager.js

@@ -0,0 +1,271 @@
+/**
+ * PDFCache Manager
+ * Handles base64 PDF caching with streaming decoder
+ * Eliminates OOM crashes for large PDFs (60MB-200MB+)
+ * 
+ * Features:
+ * - Streaming base64 decoder (O(1) memory)
+ * - Progress callbacks
+ * - Native persistent cache
+ * - 30-day TTL
+ * - LRU eviction
+ */
+
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+const { PDFJSIManager } = NativeModules;
+
+// Event emitter for progress updates
+const eventEmitter = PDFJSIManager ? new NativeEventEmitter(PDFJSIManager) : null;
+
+class CacheManager {
+    constructor() {
+        this.progressListeners = new Map();
+    }
+
+    /**
+     * Store base64 PDF with streaming decoder
+     * Eliminates OOM crashes - uses O(1) constant memory
+     * 
+     * @param {Object} options - Storage options
+     * @param {string} options.base64 - Base64 PDF data (with or without data URI prefix)
+     * @param {string} [options.identifier] - Custom cache identifier (optional)
+     * @param {number} [options.maxAge] - Cache TTL in milliseconds (default: 30 days)
+     * @param {number} [options.maxSize] - Max cache size in bytes (default: 500MB)
+     * @param {function} [options.onProgress] - Progress callback (0.0 to 1.0)
+     * @returns {Promise<Object>} Cache info { cacheId, filePath, fileSize }
+     */
+    async storeBase64(options) {
+        if (!options || !options.base64) {
+            throw new Error('base64 data is required');
+        }
+
+        const {
+            base64,
+            identifier,
+            maxAge = 30 * 24 * 60 * 60 * 1000, // 30 days default
+            maxSize = 500 * 1024 * 1024, // 500MB default
+            onProgress
+        } = options;
+
+        // Register progress listener if provided
+        let progressSubscription;
+        if (onProgress && eventEmitter) {
+            progressSubscription = eventEmitter.addListener(
+                'PDFCacheProgress',
+                (event) => {
+                    if (event.identifier === identifier) {
+                        onProgress(event.progress);
+                    }
+                }
+            );
+        }
+
+        try {
+            // Platform-specific implementation
+            if (Platform.OS === 'android') {
+                // Android: Use native PDFNativeCacheManager with streaming decoder
+                const result = await PDFJSIManager.storePDFBase64({
+                    base64: base64,
+                    identifier: identifier || this._generateIdentifier(base64),
+                    maxAge: maxAge,
+                    maxSize: maxSize,
+                    withProgress: !!onProgress
+                });
+
+                return {
+                    cacheId: result.cacheId,
+                    filePath: result.filePath,
+                    fileSize: result.fileSize,
+                    createdAt: result.createdAt || Date.now()
+                };
+            } else if (Platform.OS === 'ios') {
+                // iOS: Similar implementation (to be added)
+                const result = await PDFJSIManager.storePDFBase64({
+                    base64: base64,
+                    identifier: identifier || this._generateIdentifier(base64),
+                    maxAge: maxAge,
+                    maxSize: maxSize
+                });
+
+                return {
+                    cacheId: result.cacheId,
+                    filePath: result.filePath,
+                    fileSize: result.fileSize,
+                    createdAt: result.createdAt || Date.now()
+                };
+            } else {
+                throw new Error(`Platform ${Platform.OS} not supported`);
+            }
+        } catch (error) {
+            console.error('[CacheManager] Failed to store base64 PDF:', error);
+            throw error;
+        } finally {
+            // Clean up progress listener
+            if (progressSubscription) {
+                progressSubscription.remove();
+            }
+        }
+    }
+
+    /**
+     * Get cached PDF by identifier
+     * 
+     * @param {string} identifier - Cache identifier
+     * @returns {Promise<Object|null>} Cache info or null if not found/expired
+     */
+    async get(identifier) {
+        if (!identifier) {
+            throw new Error('identifier is required');
+        }
+
+        try {
+            const result = await PDFJSIManager.getCachedPDF(identifier);
+            
+            if (!result || result.expired) {
+                return null;
+            }
+
+            return {
+                cacheId: result.cacheId,
+                filePath: result.filePath,
+                fileSize: result.fileSize,
+                createdAt: result.createdAt,
+                lastAccessed: result.lastAccessed,
+                expired: result.expired
+            };
+        } catch (error) {
+            console.warn('[CacheManager] Failed to get cached PDF:', error);
+            return null;
+        }
+    }
+
+    /**
+     * Check if PDF is cached and not expired
+     * 
+     * @param {string} identifier - Cache identifier
+     * @returns {Promise<boolean>} True if cached and valid
+     */
+    async has(identifier) {
+        const cached = await this.get(identifier);
+        return cached !== null && !cached.expired;
+    }
+
+    /**
+     * Remove cached PDF
+     * 
+     * @param {string} identifier - Cache identifier
+     * @returns {Promise<boolean>} True if removed successfully
+     */
+    async remove(identifier) {
+        if (!identifier) {
+            throw new Error('identifier is required');
+        }
+
+        try {
+            await PDFJSIManager.removeCachedPDF(identifier);
+            return true;
+        } catch (error) {
+            console.warn('[CacheManager] Failed to remove cached PDF:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Clear all cached PDFs
+     * 
+     * @returns {Promise<void>}
+     */
+    async clear() {
+        try {
+            await PDFJSIManager.clearPDFCache();
+        } catch (error) {
+            console.error('[CacheManager] Failed to clear cache:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Clear expired PDFs only
+     * 
+     * @returns {Promise<number>} Number of entries removed
+     */
+    async clearExpired() {
+        try {
+            const result = await PDFJSIManager.clearExpiredPDFs();
+            return result.removedCount || 0;
+        } catch (error) {
+            console.warn('[CacheManager] Failed to clear expired:', error);
+            return 0;
+        }
+    }
+
+    /**
+     * Get cache statistics
+     * 
+     * @returns {Promise<Object>} Cache stats { totalSize, fileCount, hitRate }
+     */
+    async getStats() {
+        try {
+            const stats = await PDFJSIManager.getPDFCacheStats();
+            return {
+                totalSize: stats.totalSize || 0,
+                fileCount: stats.fileCount || 0,
+                hitRate: stats.hitRate || 0,
+                cacheHits: stats.cacheHits || 0,
+                cacheMisses: stats.cacheMisses || 0,
+                averageLoadTime: stats.averageLoadTimeMs || 0
+            };
+        } catch (error) {
+            console.warn('[CacheManager] Failed to get stats:', error);
+            return {
+                totalSize: 0,
+                fileCount: 0,
+                hitRate: 0,
+                cacheHits: 0,
+                cacheMisses: 0,
+                averageLoadTime: 0
+            };
+        }
+    }
+
+    /**
+     * Estimate decoded size from base64 length
+     * Base64 encoding increases size by ~33%, so decoded is ~75%
+     * 
+     * @param {number} base64Length - Length of base64 string
+     * @returns {number} Estimated decoded size in bytes
+     */
+    estimateDecodedSize(base64Length) {
+        return Math.floor(base64Length * 0.75);
+    }
+
+    /**
+     * Generate identifier from base64 fingerprint
+     * Uses first 100 chars + last 100 chars + length
+     * 
+     * @private
+     */
+    _generateIdentifier(base64) {
+        const length = base64.length;
+        const fingerprint = base64.substring(0, Math.min(100, length)) +
+                          base64.substring(Math.max(0, length - 100)) +
+                          length;
+        
+        // Simple hash (can be improved with crypto-js)
+        let hash = 0;
+        for (let i = 0; i < fingerprint.length; i++) {
+            const char = fingerprint.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        
+        return `pdf_${Math.abs(hash).toString(36)}_${Date.now()}`;
+    }
+}
+
+// Export singleton instance
+export default new CacheManager();
+
+
+

package/src/managers/FileManager.js

@@ -87,3 +87,4 @@ export default FileManager;
 
 
 
+

package/src/utils/PerformanceLogger.js

@@ -282,3 +282,6 @@ export default performanceLogger;
 
 
 
+
+
+