react-native-pdf-jsi 4.3.1 → 4.4.0

package/PdfView.js

@@ -393,7 +393,7 @@ export default class PdfView extends Component {
                 renderScrollComponent={(props) => <ScrollView
                     {...props}
                     centerContent={this.state.centerContent}
-                    pinchGestureEnabled={false}
+                    pinchGestureEnabled={true}
                 />}
                 initialScrollIndex={this.props.page < 1 ? 0 : this.props.page - 1}
                 onViewableItemsChanged={this._onViewableItemsChanged}

package/README.md

@@ -41,7 +41,7 @@ High-performance React Native PDF viewer with JSI (JavaScript Interface) acceler
 - **Export Operations**: Export pages to PNG/JPEG with quality control
 - **PDF Operations**: Split, merge, extract, rotate, and delete pages
 - **PDF Compression**: Reduce file sizes with 5 smart presets (EMAIL, WEB, MOBILE, PRINT, ARCHIVE)
-- **Text Extraction**: Extract and search text with statistics and context
+- **Text Extraction & Search**: Extract and search text with statistics and context; **programmatic search** via `searchTextDirect(pdfId, term, startPage, endPage)` with bounding rects, and **highlight rendering** via `pdfId` + `highlightRects` props (Android & iOS)
 - **File Management** (Android): Download to public storage, open folders with MediaStore API
 
 ### Compliance & Compatibility
@@ -261,6 +261,8 @@ The documentation includes:
 | `enableAnnotationRendering` | boolean | true | Enable annotation rendering |
 | `enableDoubleTapZoom` | boolean | true | Enable double tap to zoom |
 | `singlePage` | boolean | false | Show only first page (thumbnail mode) |
+| `pdfId` | string | undefined | Stable ID for this PDF (e.g. `"main-pdf"`); required for `searchTextDirect()` so native code can resolve the document path |
+| `highlightRects` | array | undefined | Array of `{ page: number, rect: string }` (rect: `"left,top,right,bottom"` in PDF points) to draw yellow highlights; use with `searchTextDirect()` results |
 | `trustAllCerts` | boolean | true | Allow self-signed certificates |
 | `onLoadProgress` | function(percent) | null | Loading progress callback (0-1) |
 | `onLoadComplete` | function(pages, path, size, tableContents) | null | Called when PDF loads |
@@ -304,6 +306,30 @@ const pdfRef = useRef(null);
 pdfRef.current?.setPage(42);
 ```
 
+#### searchTextDirect(pdfId, searchTerm, startPage, endPage)
+
+Programmatic PDF text search. Returns a promise that resolves to an array of `{ page, text, rect }` (rect is `"left,top,right,bottom"` in PDF coordinates). Use with `pdfId` and `highlightRects` to show highlights.
+
+```jsx
+import Pdf, { searchTextDirect } from 'react-native-pdf-jsi';
+
+const PDF_ID = 'main-pdf';
+const [highlights, setHighlights] = useState([]);
+
+<Pdf
+  pdfId={PDF_ID}
+  source={source}
+  highlightRects={highlights.filter(r => r.rect).map(r => ({ page: r.page, rect: r.rect }))}
+  onLoadComplete={(pages, path) => { /* path is registered for search */ }}
+/>
+
+// After PDF has loaded, e.g. on button press:
+const results = await searchTextDirect(PDF_ID, 'Lorem', 1, 999);
+setHighlights(results);
+```
+
+On iOS, the path is registered when the document loads (local file only); you can also call `NativeModules.PDFJSIManager.registerPathForSearch(pdfId, path)` after `onLoadComplete` if needed. Highlights stay aligned when zooming and scrolling on both Android and iOS.
+
 ## ProGuard / R8 Configuration (Android Release Builds)
 
 **IMPORTANT:** If you're using ProGuard or R8 code shrinking in your release builds, you must add the following rules to prevent crashes. These rules preserve JSI classes and native module interfaces that are required at runtime.
@@ -457,6 +483,9 @@ MIT License - see [LICENSE](LICENSE) file for details.
 
 ## Recent Fixes
 
+### iOS Pinch-to-Zoom (v4.3.2)
+Fixed iOS pinch-to-zoom not working when the scroll view delegate was set to the view itself or when the delegate proxy's primary didn't implement `viewForZoomingInScrollView`. Implemented the missing `viewForZoomingInScrollView:` in RNPDFPdfView so the scroll view receives the correct zoomable view. Fixes [#23](https://github.com/126punith/react-native-pdf-jsi/issues/23) (PR [#22](https://github.com/126punith/react-native-pdf-jsi/pull/22)).
+
 ### Android PDF Preserved on Navigation (v4.3.1)
 Fixed issue where the PDF instance was destroyed on Android when navigating away and returning to the screen ([#20](https://github.com/126punith/react-native-pdf-jsi/issues/20)). The PDF is now preserved in memory during navigation (matching iOS behavior) and only recycled when the component unmounts.
 

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

@@ -18,15 +18,27 @@ import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.Arguments;
 
 // import com.facebook.react.turbomodule.core.CallInvokerHolder; // Not available in this RN version
 import com.facebook.soloader.SoLoader;
 
+import java.io.File;
+import java.io.IOException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
+import android.graphics.RectF;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+
+import io.legere.pdfiumandroid.PdfiumCore;
+import io.legere.pdfiumandroid.PdfDocument;
+import io.legere.pdfiumandroid.PdfPage;
+import io.legere.pdfiumandroid.PdfTextPage;
+
 public class PDFJSIManager extends ReactContextBaseJavaModule {
     private static final String MODULE_NAME = "PDFJSIManager";
     private static final String TAG = "PDFJSI";
@@ -220,9 +232,24 @@ public class PDFJSIManager extends ReactContextBaseJavaModule {
             }
         });
     }
+
+    /**
+     * Register a path for search by pdfId. Called from JS when loadComplete fires so search works
+     * even if the native view has not received pdfId yet. On Android the view also registers; this is for parity with iOS.
+     */
+    @ReactMethod
+    public void registerPathForSearch(String pdfId, String path, Promise promise) {
+        if (pdfId != null && !pdfId.isEmpty() && path != null && !path.isEmpty()) {
+            SearchRegistry.registerPath(pdfId, path);
+            promise.resolve(true);
+        } else {
+            promise.resolve(false);
+        }
+    }
     
     /**
-     * Search text directly via JSI
+     * Search text directly via JSI.
+     * Uses SearchRegistry to get path for pdfId, then io.legere PdfiumCore to extract text and find matches.
      */
     @ReactMethod
     public void searchTextDirect(String pdfId, String searchTerm, int startPage, int endPage, Promise promise) {
@@ -230,11 +257,20 @@ public class PDFJSIManager extends ReactContextBaseJavaModule {
             promise.reject("JSI_NOT_INITIALIZED", "JSI is not initialized");
             return;
         }
-        
+        if (searchTerm == null || searchTerm.isEmpty()) {
+            promise.resolve(Arguments.createArray());
+            return;
+        }
         backgroundExecutor.execute(() -> {
             try {
                 Log.d(TAG, "Searching text via JSI: '" + searchTerm + "' in pages " + startPage + "-" + endPage);
-                ReadableArray results = nativeSearchTextDirect(pdfId, searchTerm, startPage, endPage);
+                String path = SearchRegistry.getPath(pdfId);
+                if (path == null || path.isEmpty()) {
+                    Log.w(TAG, "No path registered for pdfId: " + pdfId + " - pass pdfId to Pdf view to enable search");
+                    promise.resolve(Arguments.createArray());
+                    return;
+                }
+                WritableArray results = searchInPdf(pdfId, path, searchTerm, startPage, endPage);
                 promise.resolve(results);
             } catch (Exception e) {
                 Log.e(TAG, "Error searching text via JSI", e);
@@ -242,6 +278,105 @@ public class PDFJSIManager extends ReactContextBaseJavaModule {
             }
         });
     }
+
+    private WritableArray searchInPdf(String pdfId, String path, String searchTerm, int startPage, int endPage) {
+        WritableArray out = Arguments.createArray();
+        ParcelFileDescriptor pfd = null;
+        PdfDocument doc = null;
+        try {
+            if (path.startsWith("content://")) {
+                pfd = getReactApplicationContext().getContentResolver()
+                    .openFileDescriptor(Uri.parse(path), "r");
+            } else {
+                File file = new File(path);
+                if (!file.exists() || !file.canRead()) {
+                    return out;
+                }
+                pfd = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
+            }
+            if (pfd == null) return out;
+            PdfiumCore core = new PdfiumCore();
+            doc = core.newDocument(pfd);
+            int pageCount = doc.getPageCount();
+            int from = Math.max(1, startPage);
+            int to = Math.min(endPage, pageCount);
+            String termLower = searchTerm.toLowerCase();
+            for (int pageIndex = from; pageIndex <= to; pageIndex++) {
+                int zeroBased = pageIndex - 1;
+                PdfPage page = doc.openPage(zeroBased);
+                if (page == null) continue;
+                try {
+                    // Store page size in PDF points for highlight scaling in PdfView
+                    try {
+                        int wPt = page.getPageWidthPoint();
+                        int hPt = page.getPageHeightPoint();
+                        if (wPt > 0 && hPt > 0) {
+                            SearchRegistry.registerPageSizePoints(pdfId, zeroBased, (float) wPt, (float) hPt);
+                        }
+                    } catch (Exception ignored) {}
+                    PdfTextPage textPage = page.openTextPage();
+                    if (textPage == null) continue;
+                    try {
+                        int chars = textPage.textPageCountChars();
+                        if (chars <= 0) continue;
+                        String text = textPage.textPageGetText(0, chars);
+                        if (text == null) continue;
+                        String textLower = text.toLowerCase();
+                        int idx = 0;
+                        while ((idx = textLower.indexOf(termLower, idx)) >= 0) {
+                            int end = Math.min(idx + searchTerm.length(), text.length());
+                            int len = end - idx;
+                            String snippet = text.substring(idx, end);
+                            WritableMap item = Arguments.createMap();
+                            item.putInt("page", pageIndex);
+                            item.putString("text", snippet);
+                            String rectStr = "{}";
+                            try {
+                                int rectCount = textPage.textPageCountRects(idx, len);
+                                if (rectCount > 0) {
+                                    RectF first = textPage.textPageGetRect(0);
+                                    if (first != null) {
+                                        rectStr = first.left + "," + first.top + "," + first.right + "," + first.bottom;
+                                    }
+                                }
+                                if ("{}".equals(rectStr)) {
+                                    RectF charBox = textPage.textPageGetCharBox(idx);
+                                    if (charBox != null) {
+                                        rectStr = charBox.left + "," + charBox.top + "," + charBox.right + "," + charBox.bottom;
+                                    }
+                                }
+                            } catch (Exception e) {
+                                Log.d(TAG, "Rect lookup for match at " + idx + ": " + e.getMessage());
+                            }
+                            item.putString("rect", rectStr);
+                            out.pushMap(item);
+                            idx = end;
+                        }
+                    } finally {
+                        textPage.close();
+                    }
+                } finally {
+                    page.close();
+                }
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "Search IO error", e);
+        } catch (Exception e) {
+            Log.e(TAG, "Search error", e);
+        } finally {
+            if (doc != null) {
+                try {
+                    doc.close();
+                } catch (Exception ignored) {}
+            }
+            if (pfd != null) {
+                try {
+                    pfd.close();
+                } catch (IOException ignored) {}
+            }
+        }
+        return out;
+    }
     
     /**
      * Get performance metrics via JSI

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

@@ -69,6 +69,16 @@ public class PdfManager extends SimpleViewManager<PdfView> implements RNPDFPdfVi
         pdfView.setPath(path);
     }
 
+    @ReactProp(name = "pdfId")
+    public void setPdfId(PdfView pdfView, String pdfId) {
+        pdfView.setPdfId(pdfId);
+    }
+
+    @ReactProp(name = "highlightRects")
+    public void setHighlightRects(PdfView pdfView, ReadableArray highlightRects) {
+        pdfView.setHighlightRects(highlightRects);
+    }
+
     // page start from 1
     @ReactProp(name = "page")
     public void setPage(PdfView pdfView, int page) {

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

@@ -20,7 +20,12 @@ import android.net.Uri;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
 import android.os.Handler;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
 import android.os.Looper;
 
 
@@ -52,6 +57,8 @@ import static java.lang.String.format;
 
 import java.io.FileNotFoundException;
 import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
 
 import com.google.gson.Gson;
 
@@ -77,7 +84,8 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
     private FitPolicy fitPolicy = FitPolicy.WIDTH;
     private boolean singlePage = false;
     private boolean scrollEnabled = true;
-    
+    private String pdfId = null;
+
     private String decelerationRate = "normal"; // "normal", "fast", "slow"
 
     private float originalWidth = 0;
@@ -94,8 +102,29 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
     private int oldW = 0;
     private int oldH = 0;
 
+    /** Search highlight rects: list of { page (1-based), rect "left,top,right,bottom" in PDF points } */
+    private List<HighlightRect> highlightRects = new ArrayList<>();
+    private static final int HIGHLIGHT_COLOR = Color.argb(80, 255, 255, 0);
+    private final Paint highlightPaint = new Paint();
+
     public PdfView(Context context, AttributeSet set){
         super(context, set);
+        highlightPaint.setColor(HIGHLIGHT_COLOR);
+        highlightPaint.setStyle(Paint.Style.FILL);
+    }
+
+    /** Entry for one highlight: page (1-based) and rect in PDF points "left,top,right,bottom". */
+    private static class HighlightRect {
+        final int page;
+        final float left, top, right, bottom;
+
+        HighlightRect(int page, float left, float top, float right, float bottom) {
+            this.page = page;
+            this.left = left;
+            this.top = top;
+            this.right = right;
+            this.bottom = bottom;
+        }
     }
 
     @Override
@@ -225,6 +254,9 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
                         self.loadCompleteDispatched = true;
                         showLog("loadComplete: Event dispatched successfully (delayed)");
                     }
+                    if (self.pdfId != null && self.path != null) {
+                        SearchRegistry.registerPath(self.pdfId, self.path);
+                    }
                 }
             });
         } else {
@@ -340,6 +372,42 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
 
         lastPageWidth = pageWidth;
         lastPageHeight = pageHeight;
+
+        if (!highlightRects.isEmpty() && pdfId != null) {
+            int pageOneBased = displayedPage + 1;
+            try {
+                float pdfW = 0, pdfH = 0;
+                float[] sizePt = SearchRegistry.getPageSizePoints(pdfId, displayedPage);
+                if (sizePt != null && sizePt.length >= 2 && sizePt[0] > 0 && sizePt[1] > 0) {
+                    pdfW = sizePt[0];
+                    pdfH = sizePt[1];
+                }
+                if (pdfW <= 0 || pdfH <= 0) {
+                    SizeF fallback = getPageSize(displayedPage);
+                    if (fallback != null) {
+                        pdfW = fallback.getWidth();
+                        pdfH = fallback.getHeight();
+                    }
+                }
+                if (pdfW > 0 && pdfH > 0) {
+                    float scaleX = pageWidth / pdfW;
+                    float scaleY = pageHeight / pdfH;
+                    for (HighlightRect hr : highlightRects) {
+                        if (hr.page != pageOneBased) continue;
+                        float left = hr.left * scaleX;
+                        float right = hr.right * scaleX;
+                        float top = hr.top * scaleY;
+                        float bottom = hr.bottom * scaleY;
+                        // PDF coords: origin bottom-left, so top > bottom. Canvas: origin top-left.
+                        float canvasTop = pageHeight - top;
+                        float canvasBottom = pageHeight - bottom;
+                        canvas.drawRect(left, canvasTop, right, canvasBottom, highlightPaint);
+                    }
+                }
+            } catch (Exception e) {
+                showLog("Highlight draw error: " + e.getMessage());
+            }
+        }
     }
 
     @Override
@@ -361,6 +429,14 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
         // the PDF on navigation. We only recycle when PdfManager.onDropViewInstance is called.
     }
 
+    @Override
+    public void recycle() {
+        if (pdfId != null) {
+            SearchRegistry.unregisterPath(pdfId);
+        }
+        super.recycle();
+    }
+
     public void drawPdf() {
         
         // FIX: Check if we actually need to reload the document
@@ -444,14 +520,45 @@ public class PdfView extends PDFView implements OnPageChangeListener,OnLoadCompl
     }
 
     public void setPath(String path) {
-        // Path changed - need to reload document
+        if (pdfId != null) {
+            SearchRegistry.unregisterPath(pdfId);
+        }
         needsReload = true;
         this.path = path;
-        // Reset flags when path changes
         loadCompleteDispatched = false;
         lastKnownPageCount = 0;
     }
 
+    public void setPdfId(String pdfId) {
+        if (this.pdfId != null && !this.pdfId.equals(pdfId)) {
+            SearchRegistry.unregisterPath(this.pdfId);
+        }
+        this.pdfId = pdfId;
+    }
+
+    public void setHighlightRects(ReadableArray arr) {
+        highlightRects.clear();
+        if (arr == null) return;
+        for (int i = 0; i < arr.size(); i++) {
+            ReadableMap map = arr.getMap(i);
+            if (map == null || !map.hasKey("page") || !map.hasKey("rect")) continue;
+            int page = map.getInt("page");
+            String rectStr = map.getString("rect");
+            if (rectStr == null || rectStr.equals("{}")) continue;
+            String[] parts = rectStr.split(",");
+            if (parts.length != 4) continue;
+            try {
+                float left = Float.parseFloat(parts[0].trim());
+                float top = Float.parseFloat(parts[1].trim());
+                float right = Float.parseFloat(parts[2].trim());
+                float bottom = Float.parseFloat(parts[3].trim());
+                highlightRects.add(new HighlightRect(page, left, top, right, bottom));
+            } catch (NumberFormatException ignored) {}
+        }
+        invalidate();
+        postInvalidate();
+    }
+
     // page start from 1
     public void setPage(int page) {
         int newPage = page>1?page:1;

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

@@ -0,0 +1,44 @@
+/**
+ * Registry mapping pdfId to current PDF file path for programmatic search.
+ * PdfView registers when a document loads with pdfId; searchTextDirect looks up path by pdfId.
+ * Also stores PDF page sizes in points (per pdfId + pageIndex) for highlight coordinate scaling.
+ */
+package org.wonday.pdf;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+public final class SearchRegistry {
+    private static final ConcurrentHashMap<String, String> pdfIdToPath = new ConcurrentHashMap<>();
+    /** Key: pdfId + "_" + pageIndex0Based, value: float[2] = { widthPt, heightPt } */
+    private static final ConcurrentHashMap<String, float[]> pdfIdPageSizePoints = new ConcurrentHashMap<>();
+
+    public static void registerPath(String pdfId, String path) {
+        if (pdfId != null && !pdfId.isEmpty() && path != null && !path.isEmpty()) {
+            pdfIdToPath.put(pdfId, path);
+        }
+    }
+
+    public static void unregisterPath(String pdfId) {
+        if (pdfId != null && !pdfId.isEmpty()) {
+            pdfIdToPath.remove(pdfId);
+            // Clear page sizes for this pdfId
+            pdfIdPageSizePoints.keySet().removeIf(k -> k != null && k.startsWith(pdfId + "_"));
+        }
+    }
+
+    public static String getPath(String pdfId) {
+        return pdfId == null ? null : pdfIdToPath.get(pdfId);
+    }
+
+    /** Register page size in PDF points (for highlight scaling). */
+    public static void registerPageSizePoints(String pdfId, int pageIndex0Based, float widthPt, float heightPt) {
+        if (pdfId != null && !pdfId.isEmpty() && widthPt > 0 && heightPt > 0) {
+            pdfIdPageSizePoints.put(pdfId + "_" + pageIndex0Based, new float[] { widthPt, heightPt });
+        }
+    }
+
+    /** Get page size in PDF points; returns float[2] = { widthPt, heightPt } or null. */
+    public static float[] getPageSizePoints(String pdfId, int pageIndex0Based) {
+        return pdfId == null ? null : pdfIdPageSizePoints.get(pdfId + "_" + pageIndex0Based);
+    }
+}

package/fabric/RNPDFPdfNativeComponent.js

@@ -37,6 +37,8 @@
    password: ?string,
    onChange: ?BubblingEventHandler<ChangeEvent>,
    singlePage: ?boolean,
+   pdfId: ?string,
+   highlightRects: ?$ReadOnlyArray<$ReadOnly<{|page: Int32, rect: string|}>>,
  |}>;
 
  interface NativeCommands {

package/index.d.ts

@@ -88,6 +88,17 @@ export interface PdfProps {
     onPageSingleTap?: (page: number, x: number, y: number) => void,
     onScaleChanged?: (scale: number) => void,
     onPressLink?: (url: string) => void,
+    /**
+     * Optional. When set, use this id with searchTextDirect(pdfId, ...) for programmatic text search.
+     * On iOS, the same id must be passed to the Pdf view and to searchTextDirect. One view per pdfId.
+     */
+    pdfId?: string,
+    /**
+     * Optional. Array of rects to highlight on the PDF (e.g. from searchTextDirect results).
+     * Each item: { page: number, rect: string } where rect is "left,top,right,bottom" in PDF page coordinates.
+     * Supported on Android; iOS can be added later.
+     */
+    highlightRects?: Array<{ page: number; rect: string }>,
 }
 
 declare class Pdf extends React.Component<PdfProps, any> {
@@ -463,3 +474,26 @@ export interface PDFCompressorManager {
  * PDFCompressor singleton instance
  */
 export const PDFCompressor: PDFCompressorManager;
+
+// ========================================
+// JSI / Programmatic search
+// ========================================
+
+export interface PDFSearchResultItem {
+    page: number;
+    text: string;
+    /** Bounds of the match (format is platform-specific; on iOS a CGRect string). */
+    rect: string;
+}
+
+/**
+ * Search PDF text programmatically.
+ * On iOS: pass the same pdfId to the Pdf view (pdfId prop) so the view is registered for search.
+ * On Android: returns empty array until a native text-extraction implementation is added.
+ */
+export function searchTextDirect(
+    pdfId: string,
+    searchTerm: string,
+    startPage: number,
+    endPage: number
+): Promise<PDFSearchResultItem[]>;

package/index.js

@@ -18,6 +18,7 @@ import {
     StyleSheet,
     Image,
     Text,
+    NativeModules,
     requireNativeComponent
 } from 'react-native';
 // Codegen component variables - will be loaded lazily to prevent hooks errors
@@ -27,7 +28,7 @@ import ReactNativeBlobUtil from 'react-native-blob-util'
 import {ViewPropTypes} from 'deprecated-react-native-prop-types';
 const SHA1 = require('crypto-js/sha1');
 import PdfView from './PdfView';
-import PDFJSI from './src/PDFJSI';
+import PDFJSI, { searchTextDirect } from './src/PDFJSI';
 
 export default class Pdf extends Component {
 
@@ -67,6 +68,8 @@ export default class Pdf extends Component {
         onPageSingleTap: PropTypes.func,
         onScaleChanged: PropTypes.func,
         onPressLink: PropTypes.func,
+        pdfId: PropTypes.string,
+        highlightRects: PropTypes.arrayOf(PropTypes.shape({ page: PropTypes.number.isRequired, rect: PropTypes.string.isRequired })),
 
         // Props that are not available in the earlier react native version, added to prevent crashed on android
         accessibilityLabel: PropTypes.string,
@@ -111,6 +114,8 @@ export default class Pdf extends Component {
         },
         onPressLink: (url) => {
         },
+        pdfId: undefined,
+        highlightRects: undefined,
     };
 
     constructor(props) {
@@ -594,7 +599,24 @@ export default class Pdf extends Component {
                 if (!filePath || filePath.trim() === '') {
                     filePath = this.downloadedFilePath || this.state.path || '';
                 }
-                
+                // Register path for search (iOS: ensures SearchRegistry has path when pdfId may not reach native view)
+                if (this.props.pdfId && filePath) {
+                    const PDFJSIManager = NativeModules.PDFJSIManager;
+                    if (PDFJSIManager && typeof PDFJSIManager.registerPathForSearch === 'function') {
+                        if (__DEV__) {
+                            console.log('📌 [Pdf] Registering path for search:', this.props.pdfId, 'pathLength:', filePath.length);
+                        }
+                        PDFJSIManager.registerPathForSearch(this.props.pdfId, filePath).then(() => {
+                            if (__DEV__) console.log('✅ [Pdf] Path registered for search:', this.props.pdfId);
+                        }).catch((err) => {
+                            if (__DEV__) console.warn('⚠️ [Pdf] registerPathForSearch failed:', err);
+                        });
+                    } else if (__DEV__) {
+                        console.warn('⚠️ [Pdf] PDFJSIManager.registerPathForSearch not available');
+                    }
+                } else if (__DEV__) {
+                    console.log('📌 [Pdf] Skip path registration: pdfId=', this.props.pdfId, 'hasPath=', !!filePath);
+                }
                 // Log path extraction for debugging
                 if (__DEV__) {
                     console.log('📁 [Pdf] loadComplete - Path extraction:', {
@@ -758,6 +780,11 @@ export {
     CompressionLevel
 };
 
+// ========================================
+// Programmatic search and JSI API (fix #24)
+// ========================================
+export { searchTextDirect, PDFJSI };
+
 // ========================================
 // TIER 3: Pre-built UI Components
 // ========================================