react-native-pdf-jsi 1.0.1

package/src/examples/PDFJSIExample.js

@@ -0,0 +1,296 @@
+/**
+ * Copyright (c) 2025-present, Punith M (punithm300@gmail.com)
+ * Enhanced PDF JSI Example Usage
+ * All rights reserved.
+ * 
+ * Example demonstrating how to use the enhanced PDF JSI components
+ */
+
+import React, { useState, useRef } from 'react';
+import { View, Text, Button, StyleSheet, Alert, ScrollView } from 'react-native';
+import { usePDFJSI, EnhancedPdfView, EnhancedPdfUtils } from '../index';
+
+const PDFJSIExample = () => {
+    const pdfRef = useRef(null);
+    const [jsiStats, setJsiStats] = useState(null);
+    const [performanceHistory, setPerformanceHistory] = useState([]);
+    
+    // Initialize JSI hook
+    const {
+        isJSIAvailable,
+        isInitialized,
+        renderPage,
+        getPageMetrics,
+        preloadPages,
+        searchText,
+        getCacheMetrics,
+        clearCache,
+        optimizeMemory,
+        setRenderQuality,
+        updatePerformanceMetrics,
+        getPerformanceHistory,
+        createPDFInstance
+    } = usePDFJSI({
+        autoInitialize: true,
+        enablePerformanceTracking: true,
+        enableCaching: true
+    });
+
+    const handleCheckJSI = async () => {
+        try {
+            const stats = await EnhancedPdfUtils.getPerformanceBenchmark();
+            setJsiStats(stats);
+            Alert.alert('JSI Status', `Available: ${stats.jsiAvailable}\nLevel: ${stats.performanceLevel}`);
+        } catch (error) {
+            Alert.alert('Error', 'Failed to get JSI stats');
+        }
+    };
+
+    const handleRenderPage = async () => {
+        try {
+            const pdfId = 'example_pdf';
+            const result = await renderPage(pdfId, 1, 1.5, 'base64data');
+            Alert.alert('Success', `Page rendered: ${JSON.stringify(result)}`);
+        } catch (error) {
+            Alert.alert('Error', `Render failed: ${error.message}`);
+        }
+    };
+
+    const handleGetMetrics = async () => {
+        try {
+            const pdfId = 'example_pdf';
+            const metrics = await getPageMetrics(pdfId, 1);
+            Alert.alert('Page Metrics', JSON.stringify(metrics, null, 2));
+        } catch (error) {
+            Alert.alert('Error', `Failed to get metrics: ${error.message}`);
+        }
+    };
+
+    const handlePreloadPages = async () => {
+        try {
+            const pdfId = 'example_pdf';
+            const success = await preloadPages(pdfId, 1, 5);
+            Alert.alert('Preload', `Success: ${success}`);
+        } catch (error) {
+            Alert.alert('Error', `Preload failed: ${error.message}`);
+        }
+    };
+
+    const handleSearchText = async () => {
+        try {
+            const pdfId = 'example_pdf';
+            const results = await searchText(pdfId, 'example', 1, 10);
+            Alert.alert('Search Results', `Found ${results.length} matches`);
+        } catch (error) {
+            Alert.alert('Error', `Search failed: ${error.message}`);
+        }
+    };
+
+    const handleClearCache = async () => {
+        try {
+            const pdfId = 'example_pdf';
+            const success = await clearCache(pdfId, 'all');
+            Alert.alert('Cache', `Cleared: ${success}`);
+        } catch (error) {
+            Alert.alert('Error', `Clear cache failed: ${error.message}`);
+        }
+    };
+
+    const handleOptimizeMemory = async () => {
+        try {
+            const pdfId = 'example_pdf';
+            const success = await optimizeMemory(pdfId);
+            Alert.alert('Memory', `Optimized: ${success}`);
+        } catch (error) {
+            Alert.alert('Error', `Memory optimization failed: ${error.message}`);
+        }
+    };
+
+    const handleSetQuality = async () => {
+        try {
+            const pdfId = 'example_pdf';
+            const success = await setRenderQuality(pdfId, 3);
+            Alert.alert('Quality', `Set to high: ${success}`);
+        } catch (error) {
+            Alert.alert('Error', `Set quality failed: ${error.message}`);
+        }
+    };
+
+    const handleGetPerformanceHistory = () => {
+        const history = getPerformanceHistory();
+        setPerformanceHistory(history);
+        Alert.alert('Performance History', `${history.length} operations recorded`);
+    };
+
+    const handleCreateInstance = () => {
+        const instance = createPDFInstance('example_pdf', { quality: 2 });
+        Alert.alert('Instance Created', `ID: ${instance.id}`);
+    };
+
+    return (
+        <ScrollView style={styles.container}>
+            <Text style={styles.title}>Enhanced PDF JSI Example</Text>
+            
+            <View style={styles.statusContainer}>
+                <Text style={styles.statusText}>
+                    JSI Available: {isJSIAvailable ? '✅ Yes' : '❌ No'}
+                </Text>
+                <Text style={styles.statusText}>
+                    Initialized: {isInitialized ? '✅ Yes' : '⏳ No'}
+                </Text>
+            </View>
+
+            <View style={styles.buttonContainer}>
+                <Button title="Check JSI Status" onPress={handleCheckJSI} />
+                <Button title="Render Page" onPress={handleRenderPage} />
+                <Button title="Get Page Metrics" onPress={handleGetMetrics} />
+                <Button title="Preload Pages" onPress={handlePreloadPages} />
+                <Button title="Search Text" onPress={handleSearchText} />
+                <Button title="Clear Cache" onPress={handleClearCache} />
+                <Button title="Optimize Memory" onPress={handleOptimizeMemory} />
+                <Button title="Set High Quality" onPress={handleSetQuality} />
+                <Button title="Get Performance History" onPress={handleGetPerformanceHistory} />
+                <Button title="Create PDF Instance" onPress={handleCreateInstance} />
+            </View>
+
+            {jsiStats && (
+                <View style={styles.statsContainer}>
+                    <Text style={styles.statsTitle}>JSI Statistics:</Text>
+                    <Text>Available: {jsiStats.jsiAvailable ? 'Yes' : 'No'}</Text>
+                    <Text>Performance Level: {jsiStats.performanceLevel}</Text>
+                    <Text>Direct Memory Access: {jsiStats.directMemoryAccess ? 'Yes' : 'No'}</Text>
+                    <Text>Bridge Optimized: {jsiStats.bridgeOptimized ? 'Yes' : 'No'}</Text>
+                    <Text>Operations: {jsiStats.operationHistory.length}</Text>
+                </View>
+            )}
+
+            {performanceHistory.length > 0 && (
+                <View style={styles.historyContainer}>
+                    <Text style={styles.historyTitle}>Performance History:</Text>
+                    {performanceHistory.slice(-5).map((entry, index) => (
+                        <Text key={index} style={styles.historyEntry}>
+                            {entry.operation}: {entry.duration.toFixed(2)}ms ({entry.mode})
+                        </Text>
+                    ))}
+                </View>
+            )}
+
+            <View style={styles.enhancedViewContainer}>
+                <Text style={styles.enhancedTitle}>Enhanced PDF View:</Text>
+                <EnhancedPdfView
+                    ref={pdfRef}
+                    source={{ uri: 'https://example.com/sample.pdf' }}
+                    style={styles.pdfView}
+                    onLoadComplete={(numberOfPages) => {
+                        console.log(`PDF loaded with ${numberOfPages} pages`);
+                    }}
+                    onPageChanged={(page, numberOfPages) => {
+                        console.log(`Page changed to ${page} of ${numberOfPages}`);
+                    }}
+                    onError={(error) => {
+                        console.error('PDF error:', error);
+                    }}
+                />
+            </View>
+        </ScrollView>
+    );
+};
+
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        padding: 20,
+        backgroundColor: '#f5f5f5',
+    },
+    title: {
+        fontSize: 24,
+        fontWeight: 'bold',
+        textAlign: 'center',
+        marginBottom: 20,
+        color: '#333',
+    },
+    statusContainer: {
+        backgroundColor: '#fff',
+        padding: 15,
+        borderRadius: 8,
+        marginBottom: 20,
+        elevation: 2,
+        shadowColor: '#000',
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.1,
+        shadowRadius: 4,
+    },
+    statusText: {
+        fontSize: 16,
+        marginBottom: 5,
+        color: '#666',
+    },
+    buttonContainer: {
+        gap: 10,
+        marginBottom: 20,
+    },
+    statsContainer: {
+        backgroundColor: '#fff',
+        padding: 15,
+        borderRadius: 8,
+        marginBottom: 20,
+        elevation: 2,
+        shadowColor: '#000',
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.1,
+        shadowRadius: 4,
+    },
+    statsTitle: {
+        fontSize: 18,
+        fontWeight: 'bold',
+        marginBottom: 10,
+        color: '#333',
+    },
+    historyContainer: {
+        backgroundColor: '#fff',
+        padding: 15,
+        borderRadius: 8,
+        marginBottom: 20,
+        elevation: 2,
+        shadowColor: '#000',
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.1,
+        shadowRadius: 4,
+    },
+    historyTitle: {
+        fontSize: 18,
+        fontWeight: 'bold',
+        marginBottom: 10,
+        color: '#333',
+    },
+    historyEntry: {
+        fontSize: 14,
+        marginBottom: 5,
+        color: '#666',
+        fontFamily: 'monospace',
+    },
+    enhancedViewContainer: {
+        backgroundColor: '#fff',
+        padding: 15,
+        borderRadius: 8,
+        marginBottom: 20,
+        elevation: 2,
+        shadowColor: '#000',
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.1,
+        shadowRadius: 4,
+    },
+    enhancedTitle: {
+        fontSize: 18,
+        fontWeight: 'bold',
+        marginBottom: 10,
+        color: '#333',
+    },
+    pdfView: {
+        height: 400,
+        backgroundColor: '#f0f0f0',
+        borderRadius: 4,
+    },
+});
+
+export default PDFJSIExample;

package/src/hooks/usePDFJSI.js

@@ -0,0 +1,346 @@
+/**
+ * Copyright (c) 2025-present, Punith M (punithm300@gmail.com)
+ * Enhanced PDF JSI Hook with high-performance operations
+ * All rights reserved.
+ * 
+ * React Hook for easy JSI integration in functional components
+ * Provides automatic JSI availability detection and fallback handling
+ */
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { Platform } from 'react-native';
+import PDFJSI from '../PDFJSI';
+
+/**
+ * Hook for PDF JSI functionality
+ * @param {Object} options - Configuration options
+ * @returns {Object} JSI utilities and state
+ */
+export const usePDFJSI = (options = {}) => {
+    const {
+        autoInitialize = true,
+        enablePerformanceTracking = true,
+        enableCaching = true,
+        maxCacheSize = 100
+    } = options;
+    
+    // State management
+    const [isJSIAvailable, setIsJSIAvailable] = useState(false);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const [performanceMetrics, setPerformanceMetrics] = useState(null);
+    const [jsiStats, setJsiStats] = useState(null);
+    
+    // Refs for tracking
+    const pdfInstancesRef = useRef(new Map());
+    const performanceHistoryRef = useRef([]);
+    
+    /**
+     * Initialize JSI availability check
+     */
+    const initializeJSI = useCallback(async () => {
+        try {
+            // Enable JSI for both Android and iOS
+            // iOS will get enhanced caching and performance optimizations
+            if (Platform.OS === 'android') {
+                // Android gets full JSI support
+                const isAvailable = await PDFJSI.checkJSIAvailability();
+                setIsJSIAvailable(isAvailable);
+                setIsInitialized(true);
+                return isAvailable;
+            } else {
+                // iOS gets enhanced caching support (bridge mode with optimizations)
+                setIsJSIAvailable(true); // Enable enhanced features for iOS
+                setIsInitialized(true);
+                return true;
+            }
+            
+            // Get JSI stats for performance tracking (Android only)
+            if (Platform.OS === 'android' && isJSIAvailable && enablePerformanceTracking) {
+                const stats = await PDFJSI.getJSIStats();
+                setJsiStats(stats);
+            }
+        } catch (error) {
+            console.error('📱 usePDFJSI: Error initializing JSI:', error);
+            setIsJSIAvailable(false);
+            setIsInitialized(true);
+            return false;
+        }
+    }, [enablePerformanceTracking]);
+    
+    /**
+     * Render page with JSI or fallback
+     */
+    const renderPage = useCallback(async (pdfId, pageNumber, scale, base64Data) => {
+        const startTime = performance.now();
+        
+        try {
+            if (isJSIAvailable) {
+                const result = await PDFJSI.renderPageDirect(pdfId, pageNumber, scale, base64Data);
+                
+                const endTime = performance.now();
+                const renderTime = endTime - startTime;
+                
+                // Track performance
+                if (enablePerformanceTracking) {
+                    performanceHistoryRef.current.push({
+                        operation: 'renderPage',
+                        duration: renderTime,
+                        timestamp: Date.now(),
+                        pdfId,
+                        pageNumber,
+                        scale,
+                        mode: 'JSI'
+                    });
+                }
+                
+                return result;
+            } else {
+                // Fallback to bridge mode (would need to implement)
+                throw new Error('JSI not available and bridge fallback not implemented');
+            }
+        } catch (error) {
+            const endTime = performance.now();
+            const renderTime = endTime - startTime;
+            
+            if (enablePerformanceTracking) {
+                performanceHistoryRef.current.push({
+                    operation: 'renderPage',
+                    duration: renderTime,
+                    timestamp: Date.now(),
+                    pdfId,
+                    pageNumber,
+                    scale,
+                    mode: 'JSI_ERROR',
+                    error: error.message
+                });
+            }
+            
+            throw error;
+        }
+    }, [isJSIAvailable, enablePerformanceTracking]);
+    
+    /**
+     * Get page metrics
+     */
+    const getPageMetrics = useCallback(async (pdfId, pageNumber) => {
+        try {
+            if (isJSIAvailable) {
+                return await PDFJSI.getPageMetrics(pdfId, pageNumber);
+            } else {
+                throw new Error('JSI not available');
+            }
+        } catch (error) {
+            console.error('📱 usePDFJSI: Error getting page metrics:', error);
+            throw error;
+        }
+    }, [isJSIAvailable]);
+    
+    /**
+     * Preload pages
+     */
+    const preloadPages = useCallback(async (pdfId, startPage, endPage) => {
+        try {
+            if (isJSIAvailable) {
+                return await PDFJSI.preloadPagesDirect(pdfId, startPage, endPage);
+            } else {
+                throw new Error('JSI not available');
+            }
+        } catch (error) {
+            console.error('📱 usePDFJSI: Error preloading pages:', error);
+            throw error;
+        }
+    }, [isJSIAvailable]);
+    
+    /**
+     * Search text
+     */
+    const searchText = useCallback(async (pdfId, searchTerm, startPage, endPage) => {
+        try {
+            if (isJSIAvailable) {
+                return await PDFJSI.searchTextDirect(pdfId, searchTerm, startPage, endPage);
+            } else {
+                throw new Error('JSI not available');
+            }
+        } catch (error) {
+            console.error('📱 usePDFJSI: Error searching text:', error);
+            throw error;
+        }
+    }, [isJSIAvailable]);
+    
+    /**
+     * Get cache metrics
+     */
+    const getCacheMetrics = useCallback(async (pdfId) => {
+        try {
+            if (isJSIAvailable) {
+                return await PDFJSI.getCacheMetrics(pdfId);
+            } else {
+                throw new Error('JSI not available');
+            }
+        } catch (error) {
+            console.error('📱 usePDFJSI: Error getting cache metrics:', error);
+            throw error;
+        }
+    }, [isJSIAvailable]);
+    
+    /**
+     * Clear cache
+     */
+    const clearCache = useCallback(async (pdfId, cacheType = 'all') => {
+        try {
+            if (isJSIAvailable) {
+                return await PDFJSI.clearCacheDirect(pdfId, cacheType);
+            } else {
+                throw new Error('JSI not available');
+            }
+        } catch (error) {
+            console.error('📱 usePDFJSI: Error clearing cache:', error);
+            throw error;
+        }
+    }, [isJSIAvailable]);
+    
+    /**
+     * Optimize memory
+     */
+    const optimizeMemory = useCallback(async (pdfId) => {
+        try {
+            if (isJSIAvailable) {
+                return await PDFJSI.optimizeMemory(pdfId);
+            } else {
+                throw new Error('JSI not available');
+            }
+        } catch (error) {
+            console.error('📱 usePDFJSI: Error optimizing memory:', error);
+            throw error;
+        }
+    }, [isJSIAvailable]);
+    
+    /**
+     * Set render quality
+     */
+    const setRenderQuality = useCallback(async (pdfId, quality) => {
+        try {
+            if (isJSIAvailable) {
+                return await PDFJSI.setRenderQuality(pdfId, quality);
+            } else {
+                throw new Error('JSI not available');
+            }
+        } catch (error) {
+            console.error('📱 usePDFJSI: Error setting render quality:', error);
+            throw error;
+        }
+    }, [isJSIAvailable]);
+    
+    /**
+     * Update performance metrics
+     */
+    const updatePerformanceMetrics = useCallback(async (pdfId) => {
+        try {
+            if (isJSIAvailable) {
+                const metrics = await PDFJSI.getPerformanceMetrics(pdfId);
+                setPerformanceMetrics(metrics);
+                return metrics;
+            }
+        } catch (error) {
+            console.error('📱 usePDFJSI: Error updating performance metrics:', error);
+        }
+        return null;
+    }, [isJSIAvailable]);
+    
+    /**
+     * Get performance history
+     */
+    const getPerformanceHistory = useCallback(() => {
+        return [...performanceHistoryRef.current];
+    }, []);
+    
+    /**
+     * Clear performance history
+     */
+    const clearPerformanceHistory = useCallback(() => {
+        performanceHistoryRef.current = [];
+    }, []);
+    
+    /**
+     * Create PDF instance with tracking
+     */
+    const createPDFInstance = useCallback((pdfId, options = {}) => {
+        const instance = {
+            id: pdfId,
+            created: Date.now(),
+            options,
+            metrics: null,
+            cacheMetrics: null
+        };
+        
+        pdfInstancesRef.current.set(pdfId, instance);
+        return instance;
+    }, []);
+    
+    /**
+     * Remove PDF instance
+     */
+    const removePDFInstance = useCallback((pdfId) => {
+        pdfInstancesRef.current.delete(pdfId);
+    }, []);
+    
+    /**
+     * Get all PDF instances
+     */
+    const getPDFInstances = useCallback(() => {
+        return Array.from(pdfInstancesRef.current.values());
+    }, []);
+    
+    // Initialize JSI on mount if autoInitialize is enabled
+    useEffect(() => {
+        if (autoInitialize && !isInitialized) {
+            initializeJSI();
+        }
+    }, [autoInitialize, isInitialized, initializeJSI]);
+    
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            // Cleanup PDF instances
+            pdfInstancesRef.current.clear();
+            
+            // Clear performance history if needed
+            if (!enablePerformanceTracking) {
+                performanceHistoryRef.current = [];
+            }
+        };
+    }, [enablePerformanceTracking]);
+    
+    return {
+        // State
+        isJSIAvailable,
+        isInitialized,
+        performanceMetrics,
+        jsiStats,
+        
+        // Core functions
+        renderPage,
+        getPageMetrics,
+        preloadPages,
+        searchText,
+        getCacheMetrics,
+        clearCache,
+        optimizeMemory,
+        setRenderQuality,
+        
+        // Performance tracking
+        updatePerformanceMetrics,
+        getPerformanceHistory,
+        clearPerformanceHistory,
+        
+        // Instance management
+        createPDFInstance,
+        removePDFInstance,
+        getPDFInstances,
+        
+        // Utilities
+        initializeJSI
+    };
+};
+
+export default usePDFJSI;

package/src/index.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2025-present, Punith M (punithm300@gmail.com)
+ * Enhanced PDF JSI Integration - Main Export
+ * All rights reserved.
+ * 
+ * Main export file for enhanced PDF JSI components and utilities
+ */
+
+// Core JSI functionality
+export { default as PDFJSI } from './PDFJSI';
+
+// Enhanced PDF View component
+export { default as EnhancedPdfView, EnhancedPdfUtils } from './EnhancedPdfView';
+
+// React hooks
+export { default as usePDFJSI } from './hooks/usePDFJSI';
+
+// Re-export individual JSI methods for convenience
+export {
+    renderPageDirect,
+    getPageMetrics,
+    preloadPagesDirect,
+    getCacheMetrics,
+    clearCacheDirect,
+    optimizeMemory,
+    searchTextDirect,
+    getPerformanceMetrics,
+    setRenderQuality,
+    getJSIStats,
+    getPerformanceHistory,
+    clearPerformanceHistory
+} from './PDFJSI';

package/windows/RCTPdf/PropertySheet.props

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <!--
+    To customize common C++/WinRT project properties: 
+    * right-click the project node
+    * expand the Common Properties item
+    * select the C++/WinRT property page
+
+    For more advanced scenarios, and complete documentation, please see:
+    https://github.com/Microsoft/xlang/tree/master/src/package/cppwinrt/nuget 
+    -->
+  <PropertyGroup />
+  <ItemDefinitionGroup />
+</Project>

package/windows/RCTPdf/RCTPdf.def

@@ -0,0 +1,3 @@
+EXPORTS
+DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
+DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE