react-native-pdf-jsi 1.0.2 → 2.0.0

package/package.json

@@ -1,28 +1,56 @@
 {
     "name": "react-native-pdf-jsi",
-    "version": "1.0.2",
-    "summary": "A react native PDF view component with JSI performance enhancements",
-    "description": "A high-performance react native PDF view component with JSI (JavaScript Interface) integration for enhanced speed and efficiency. Supports iOS, Android, and Windows platforms with zero-bridge overhead operations.",
+    "version": "2.0.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. Supports iOS, Android, and Windows platforms.",
     "main": "index.js",
     "typings": "./index.d.ts",
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/126punith/react-native-pdf-enhanced.git"
+        "url": "git+https://github.com/126punith/react-native-enhanced-pdf.git"
     },
     "keywords": [
+        "react-native-pdf",
+        "react-native-pdf-viewer",
+        "react-native-pdf-jsi",
+        "react-native-pdf-enhanced",
+        "pdf-viewer",
+        "pdf-reader",
+        "pdf-view",
         "react-component",
         "react-native",
+        "react-native-module",
+        "react-native-library",
         "android",
         "ios",
+        "windows",
         "pdf",
         "view",
         "viewer",
         "jsi",
+        "javascript-interface",
         "performance",
         "enhanced",
         "native",
         "bridge",
-        "high-performance"
+        "high-performance",
+        "fast-pdf",
+        "lazy-loading",
+        "smart-caching",
+        "progressive-loading",
+        "memory-optimization",
+        "zero-bridge",
+        "native-module",
+        "cross-platform",
+        "mobile",
+        "document-viewer",
+        "pdf-renderer",
+        "pdf-display",
+        "large-files",
+        "optimization",
+        "caching",
+        "persistent-cache",
+        "react-native-pdf-jsi-enhanced"
     ],
     "author": {
         "name": "Punith M",
@@ -30,9 +58,9 @@
         "url": "https://github.com/126punith"
     },
     "license": "MIT",
-    "homepage": "https://github.com/126punith/react-native-pdf-enhanced",
+        "homepage": "https://github.com/126punith/react-native-enhanced-pdf",
     "bugs": {
-        "url": "https://github.com/126punith/react-native-pdf-enhanced/issues"
+        "url": "https://github.com/126punith/react-native-enhanced-pdf/issues"
     },
     "dependencies": {
         "crypto-js": "4.2.0",

package/src/EnhancedPdfView.js

@@ -1,6 +1,5 @@
 /**
- * Copyright (c) 2025-present, Punith M (punithm300@gmail.com)
- * Enhanced PDF View with JSI integration
+ * Copyright (c) 2025-present, Enhanced PDF View with JSI
  * All rights reserved.
  * 
  * Enhanced PDF View component that automatically uses JSI when available
@@ -273,6 +272,57 @@ export default class EnhancedPdfView extends Component {
         }
     };
     
+    /**
+     * Lazy load pages for large PDF files
+     */
+    lazyLoadPages = async (currentPage, preloadRadius = 3, totalPages = null) => {
+        try {
+            const pdfId = `pdf_${Date.now()}`;
+            const result = await PDFJSI.lazyLoadPages(pdfId, currentPage, preloadRadius, totalPages);
+            
+            if (result.success) {
+                console.log(`📱 EnhancedPdfView: Lazy loaded pages around ${currentPage} via JSI`);
+            }
+            
+            return result;
+        } catch (error) {
+            console.error('📱 EnhancedPdfView: JSI lazy load error:', error);
+            throw error;
+        }
+    };
+    
+    /**
+     * Progressive loading for large PDF files
+     */
+    progressiveLoadPages = async (startPage = 1, batchSize = 5, onProgress = null) => {
+        try {
+            const pdfId = `pdf_${Date.now()}`;
+            const result = await PDFJSI.progressiveLoadPages(pdfId, startPage, batchSize, onProgress);
+            
+            console.log(`📱 EnhancedPdfView: Progressive loaded ${result.totalLoaded} pages via JSI`);
+            return result;
+        } catch (error) {
+            console.error('📱 EnhancedPdfView: JSI progressive load error:', error);
+            throw error;
+        }
+    };
+    
+    /**
+     * Smart caching for frequently accessed pages
+     */
+    smartCacheFrequentPages = async (frequentPages = []) => {
+        try {
+            const pdfId = `pdf_${Date.now()}`;
+            const result = await PDFJSI.smartCacheFrequentPages(pdfId, frequentPages);
+            
+            console.log(`📱 EnhancedPdfView: Smart cached ${result.successfulCaches}/${result.totalPages} frequent pages via JSI`);
+            return result;
+        } catch (error) {
+            console.error('📱 EnhancedPdfView: JSI smart cache error:', error);
+            throw error;
+        }
+    };
+    
     render() {
         const { isJSIAvailable, jsiInitialized, renderMode } = this.state;
         

package/src/PDFJSI.js

@@ -1,6 +1,5 @@
 /**
- * Copyright (c) 2025-present, Punith M (punithm300@gmail.com)
- * Enhanced PDF JSI JavaScript Bridge with high-performance operations
+ * Copyright (c) 2025-present, Enhanced PDF JSI JavaScript Bridge
  * All rights reserved.
  * 
  * JavaScript interface for high-performance PDF operations via JSI
@@ -495,6 +494,248 @@ class PDFJSIManager {
         this.performanceMetrics.clear();
         console.log('📱 PDFJSI: Performance history cleared');
     }
+    
+    /**
+     * Lazy load PDF pages for large files
+     * @param {string} pdfId - PDF identifier
+     * @param {number} currentPage - Current page number
+     * @param {number} preloadRadius - Number of pages to preload around current page
+     * @param {number} totalPages - Total number of pages in PDF
+     * @returns {Promise<Object>} Lazy load result
+     */
+    async lazyLoadPages(pdfId, currentPage, preloadRadius = 3, totalPages = null) {
+        if (!this.isJSIAvailable) {
+            throw new Error('JSI not available - falling back to bridge mode');
+        }
+        
+        const startTime = performance.now();
+        
+        try {
+            console.log(`📱 PDFJSI: Lazy loading pages around page ${currentPage} for PDF ${pdfId}`);
+            
+            // Calculate pages to preload
+            const startPage = Math.max(1, currentPage - preloadRadius);
+            const endPage = totalPages ? Math.min(totalPages, currentPage + preloadRadius) : currentPage + preloadRadius;
+            
+            // Preload pages in background
+            const preloadResult = await this.preloadPagesDirect(pdfId, startPage, endPage);
+            
+            const endTime = performance.now();
+            const lazyLoadTime = endTime - startTime;
+            
+            // Track performance
+            this.trackPerformance('lazyLoadPages', lazyLoadTime, {
+                pdfId,
+                currentPage,
+                startPage,
+                endPage,
+                preloadRadius,
+                success: preloadResult
+            });
+            
+            console.log(`📱 PDFJSI: Lazy loaded pages ${startPage}-${endPage} in ${lazyLoadTime.toFixed(2)}ms`);
+            
+            return {
+                success: preloadResult,
+                currentPage,
+                preloadedRange: { startPage, endPage },
+                lazyLoadTime,
+                preloadRadius
+            };
+            
+        } catch (error) {
+            const endTime = performance.now();
+            const lazyLoadTime = endTime - startTime;
+            
+            console.error(`📱 PDFJSI: Error lazy loading pages in ${lazyLoadTime.toFixed(2)}ms:`, error);
+            
+            this.trackPerformance('lazyLoadPages', lazyLoadTime, {
+                pdfId,
+                currentPage,
+                preloadRadius,
+                success: false,
+                error: error.message
+            });
+            
+            throw error;
+        }
+    }
+    
+    /**
+     * Progressive loading for large PDF files
+     * @param {string} pdfId - PDF identifier
+     * @param {number} startPage - Starting page number
+     * @param {number} batchSize - Number of pages to load in each batch
+     * @param {Function} onProgress - Progress callback function
+     * @returns {Promise<Object>} Progressive load result
+     */
+    async progressiveLoadPages(pdfId, startPage = 1, batchSize = 5, onProgress = null) {
+        if (!this.isJSIAvailable) {
+            throw new Error('JSI not available - falling back to bridge mode');
+        }
+        
+        const startTime = performance.now();
+        
+        try {
+            console.log(`📱 PDFJSI: Progressive loading starting from page ${startPage} for PDF ${pdfId}`);
+            
+            let currentPage = startPage;
+            let totalLoaded = 0;
+            const loadResults = [];
+            
+            // Load pages in batches
+            while (true) {
+                const batchStartPage = currentPage;
+                const batchEndPage = currentPage + batchSize - 1;
+                
+                console.log(`📱 PDFJSI: Loading batch ${batchStartPage}-${batchEndPage}`);
+                
+                const batchResult = await this.preloadPagesDirect(pdfId, batchStartPage, batchEndPage);
+                
+                if (!batchResult) {
+                    console.log(`📱 PDFJSI: Batch loading failed at page ${currentPage}`);
+                    break;
+                }
+                
+                loadResults.push({
+                    startPage: batchStartPage,
+                    endPage: batchEndPage,
+                    success: batchResult
+                });
+                
+                totalLoaded += batchSize;
+                currentPage += batchSize;
+                
+                // Call progress callback if provided
+                if (onProgress && typeof onProgress === 'function') {
+                    onProgress({
+                        currentPage,
+                        totalLoaded,
+                        batchStartPage,
+                        batchEndPage,
+                        success: batchResult
+                    });
+                }
+                
+                // Small delay between batches to prevent blocking
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            
+            const endTime = performance.now();
+            const progressiveLoadTime = endTime - startTime;
+            
+            // Track performance
+            this.trackPerformance('progressiveLoadPages', progressiveLoadTime, {
+                pdfId,
+                startPage,
+                batchSize,
+                totalLoaded,
+                batchesLoaded: loadResults.length
+            });
+            
+            console.log(`📱 PDFJSI: Progressive loading completed: ${totalLoaded} pages in ${progressiveLoadTime.toFixed(2)}ms`);
+            
+            return {
+                success: true,
+                totalLoaded,
+                batchesLoaded: loadResults.length,
+                loadResults,
+                progressiveLoadTime
+            };
+            
+        } catch (error) {
+            const endTime = performance.now();
+            const progressiveLoadTime = endTime - startTime;
+            
+            console.error(`📱 PDFJSI: Error in progressive loading in ${progressiveLoadTime.toFixed(2)}ms:`, error);
+            
+            this.trackPerformance('progressiveLoadPages', progressiveLoadTime, {
+                pdfId,
+                startPage,
+                batchSize,
+                success: false,
+                error: error.message
+            });
+            
+            throw error;
+        }
+    }
+    
+    /**
+     * Smart caching for frequently accessed pages
+     * @param {string} pdfId - PDF identifier
+     * @param {Array<number>} frequentPages - Array of frequently accessed page numbers
+     * @returns {Promise<Object>} Smart cache result
+     */
+    async smartCacheFrequentPages(pdfId, frequentPages = []) {
+        if (!this.isJSIAvailable) {
+            throw new Error('JSI not available - falling back to bridge mode');
+        }
+        
+        const startTime = performance.now();
+        
+        try {
+            console.log(`📱 PDFJSI: Smart caching ${frequentPages.length} frequent pages for PDF ${pdfId}`);
+            
+            const cacheResults = [];
+            
+            // Cache each frequent page
+            for (const pageNumber of frequentPages) {
+                try {
+                    const cacheResult = await this.preloadPagesDirect(pdfId, pageNumber, pageNumber);
+                    cacheResults.push({
+                        pageNumber,
+                        success: cacheResult
+                    });
+                } catch (error) {
+                    console.warn(`📱 PDFJSI: Failed to cache page ${pageNumber}:`, error);
+                    cacheResults.push({
+                        pageNumber,
+                        success: false,
+                        error: error.message
+                    });
+                }
+            }
+            
+            const endTime = performance.now();
+            const smartCacheTime = endTime - startTime;
+            
+            const successfulCaches = cacheResults.filter(result => result.success).length;
+            
+            // Track performance
+            this.trackPerformance('smartCacheFrequentPages', smartCacheTime, {
+                pdfId,
+                totalPages: frequentPages.length,
+                successfulCaches,
+                cacheResults
+            });
+            
+            console.log(`📱 PDFJSI: Smart caching completed: ${successfulCaches}/${frequentPages.length} pages cached in ${smartCacheTime.toFixed(2)}ms`);
+            
+            return {
+                success: true,
+                totalPages: frequentPages.length,
+                successfulCaches,
+                cacheResults,
+                smartCacheTime
+            };
+            
+        } catch (error) {
+            const endTime = performance.now();
+            const smartCacheTime = endTime - startTime;
+            
+            console.error(`📱 PDFJSI: Error in smart caching in ${smartCacheTime.toFixed(2)}ms:`, error);
+            
+            this.trackPerformance('smartCacheFrequentPages', smartCacheTime, {
+                pdfId,
+                totalPages: frequentPages.length,
+                success: false,
+                error: error.message
+            });
+            
+            throw error;
+        }
+    }
 }
 
 // Create singleton instance
@@ -515,5 +756,8 @@ export const {
     setRenderQuality,
     getJSIStats,
     getPerformanceHistory,
-    clearPerformanceHistory
+    clearPerformanceHistory,
+    lazyLoadPages,
+    progressiveLoadPages,
+    smartCacheFrequentPages
 } = pdfJSIManager;