react-native-optimized-pdf 1.1.0 → 1.3.1

package/ios/Core/PDFError.swift

@@ -3,29 +3,20 @@ import Foundation
 /// Errors that can occur during PDF operations.
 enum PDFError: Error, LocalizedError {
     case emptySource
-    case invalidPath(String)
     case documentLoadFailed(String)
     case passwordRequired
     case invalidPassword
-    case pageNotFound(Int)
-    case renderingFailed
 
     var errorDescription: String? {
         switch self {
         case .emptySource:
             return "PDF source path is empty"
-        case .invalidPath(let path):
-            return "Invalid PDF path: \(path)"
         case .documentLoadFailed(let path):
             return "Failed to open PDF at: \(path)"
         case .passwordRequired:
             return "PDF is password protected"
         case .invalidPassword:
             return "Invalid password for PDF"
-        case .pageNotFound(let index):
-            return "Page not found at index: \(index)"
-        case .renderingFailed:
-            return "Failed to render PDF page"
         }
     }
 

package/ios/ReactNative/OptimizedPDFViewManager.swift

@@ -17,32 +17,4 @@ final class OptimizedPDFViewManager: RCTViewManager {
     override static func requiresMainQueueSetup() -> Bool {
         true
     }
-
-    // MARK: - Exported Methods
-
-    /// Navigates to a specific page in the PDF.
-    /// - Parameters:
-    ///   - node: The React Native view tag.
-    ///   - page: The page index to navigate to (0-based).
-    @objc func goToPage(_ node: NSNumber, page: NSNumber) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self,
-                  let pdfView = self.bridge?.uiManager.view(forReactTag: node) as? OptimizedPDFView else {
-                return
-            }
-            pdfView.goToPage(page.intValue)
-        }
-    }
-
-    /// Resets the zoom level to fit the page.
-    /// - Parameter node: The React Native view tag.
-    @objc func resetZoom(_ node: NSNumber) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self,
-                  let pdfView = self.bridge?.uiManager.view(forReactTag: node) as? OptimizedPDFView else {
-                return
-            }
-            pdfView.resetZoom()
-        }
-    }
 }

package/ios/ReactNative/OptimizedPdfViewManager.m

@@ -6,8 +6,6 @@
  */
 
 #import <React/RCTViewManager.h>
-#import <React/RCTUIManager.h>
-#import <React/RCTBridgeModule.h>
 
 @interface RCT_EXTERN_MODULE(OptimizedPdfViewManager, RCTViewManager)
 
@@ -42,13 +40,4 @@ RCT_EXPORT_VIEW_PROPERTY(onPageCount, RCTDirectEventBlock)
 /// Called when the PDF requires a password to open.
 RCT_EXPORT_VIEW_PROPERTY(onPasswordRequired, RCTDirectEventBlock)
 
-#pragma mark - Native Methods
-
-/// Navigates to a specific page in the PDF.
-RCT_EXTERN_METHOD(goToPage:(nonnull NSNumber *)node
-                  page:(nonnull NSNumber *)page)
-
-/// Resets the zoom level to fit the page.
-RCT_EXTERN_METHOD(resetZoom:(nonnull NSNumber *)node)
-
 @end

package/ios/Views/OptimizedPDFView.swift

@@ -1,18 +1,16 @@
 import UIKit
 import React
-
-/// Protocol for receiving PDF view events.
-@objc protocol OptimizedPDFViewDelegate: AnyObject {
-    @objc optional func pdfView(_ pdfView: OptimizedPDFView, didFailWithError error: Error)
-    @objc optional func pdfView(_ pdfView: OptimizedPDFView, didLoadWithPageCount pageCount: Int)
-    @objc optional func pdfView(_ pdfView: OptimizedPDFView, didDisplayPage page: Int, size: CGSize)
-    @objc optional func pdfViewDidRequestPassword(_ pdfView: OptimizedPDFView)
-}
+import PDFKit
 
 /// A high-performance PDF view using CATiledLayer for smooth zooming and scrolling.
 ///
 /// This view is optimized for React Native integration, providing callbacks for
 /// load completion, errors, and page navigation events.
+///
+/// Naming note: the Swift type is `OptimizedPDFView` while its `@objc` export is
+/// `OptimizedPdfView`, and the Objective-C manager/registration is
+/// `OptimizedPdfViewManager`. The `Pdf` spellings are the native bridge contract
+/// with JavaScript and must not be renamed.
 @objc(OptimizedPdfView)
 final class OptimizedPDFView: UIScrollView {
 
@@ -33,7 +31,7 @@ final class OptimizedPDFView: UIScrollView {
     }
 
     /// Maximum zoom scale.
-    @objc var maximumZoom: NSNumber = 5.0 {
+    @objc var maximumZoom: NSNumber = 3 {
         didSet {
             configuration.maximumZoom = CGFloat(truncating: maximumZoom)
             applyZoomConfiguration()
@@ -44,7 +42,7 @@ final class OptimizedPDFView: UIScrollView {
     @objc var enableAntialiasing: Bool = true {
         didSet {
             configuration.enableAntialiasing = enableAntialiasing
-            tiledPageView.enableAntialiasing = enableAntialiasing
+            tiledPageView?.enableAntialiasing = enableAntialiasing
         }
     }
 
@@ -65,15 +63,14 @@ final class OptimizedPDFView: UIScrollView {
 
     // MARK: - Public Properties
 
-    weak var pdfDelegate: OptimizedPDFViewDelegate?
-
     /// Current number of pages in the document.
     private(set) var pageCount: Int = 0
 
     // MARK: - Private Properties
 
     private var pdfDocument: CGPDFDocument?
-    private let tiledPageView: TiledPDFPageView
+    private var tiledPageView: TiledPDFPageView!
+    private var pdfURL: URL?
     private var configuration = PDFConfiguration.default
     private let documentLoader: PDFDocumentLoading
 
@@ -81,7 +78,6 @@ final class OptimizedPDFView: UIScrollView {
     private var needsLoad = false
     private var lastBoundsSize: CGSize = .zero
     private var currentPageRect: CGRect?
-    private var initialZoomScale: CGFloat = 1.0
 
     // MARK: - Initialization
 
@@ -99,14 +95,6 @@ final class OptimizedPDFView: UIScrollView {
         setupView()
     }
 
-    /// Initializes with a custom document loader (useful for testing).
-    init(frame: CGRect, documentLoader: PDFDocumentLoading) {
-        self.tiledPageView = TiledPDFPageView(frame: frame)
-        self.documentLoader = documentLoader
-        super.init(frame: frame)
-        setupView()
-    }
-
     // MARK: - Setup
 
     private func setupView() {
@@ -135,7 +123,6 @@ final class OptimizedPDFView: UIScrollView {
 
         let fitScale = calculateFitScale(for: pageRect)
         minimumZoomScale = fitScale
-        initialZoomScale = fitScale
     }
 }
 
@@ -145,6 +132,8 @@ private extension OptimizedPDFView {
 
     func handleSourceChange() {
         resetDocument()
+        pdfURL = nil
+        FlattenedPageCache.shared.removeAll()
         pendingPageIndex = page.intValue
         needsLoad = true
         setNeedsLayout()
@@ -173,6 +162,9 @@ private extension OptimizedPDFView {
     func loadDocument() {
         guard !source.isEmpty else { return }
 
+        let path = normalizedPDFPath(from: source)
+        pdfURL = URL(fileURLWithPath: path)
+
         let result = documentLoader.loadDocument(from: source, password: configuration.password)
 
         switch result {
@@ -192,7 +184,6 @@ private extension OptimizedPDFView {
         DispatchQueue.main.async { [weak self] in
             guard let self = self else { return }
             self.onPageCount?(["numberOfPages": NSNumber(value: self.pageCount)])
-            self.pdfDelegate?.pdfView?(self, didLoadWithPageCount: self.pageCount)
         }
 
         // Display pending or first page
@@ -207,12 +198,10 @@ private extension OptimizedPDFView {
             DispatchQueue.main.async { [weak self] in
                 guard let self = self else { return }
                 self.onPasswordRequired?([:])
-                self.pdfDelegate?.pdfViewDidRequestPassword?(self)
             }
         }
 
         onError?(error.eventPayload)
-        pdfDelegate?.pdfView?(self, didFailWithError: error)
     }
 
     func clampPageIndex(_ index: Int, for document: CGPDFDocument) -> Int {
@@ -234,7 +223,22 @@ private extension OptimizedPDFView {
         currentPageRect = pageRect
 
         prepareForPageDisplay()
-        configureTiledView(for: page, rect: pageRect)
+
+        tiledPageView?.cancel()
+        tiledPageView?.removeFromSuperview()
+
+        let newView = TiledPDFPageView(frame: CGRect(origin: .zero, size: pageRect.size))
+        newView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        newView.configuration = configuration
+        newView.pdfURL = pdfURL
+        newView.pageIndex = index
+        newView.pdfPage = page
+        addSubview(newView)
+        tiledPageView = newView
+
+        contentSize = pageRect.size
+        tiledPageView.preparePage()
+
         applyFitScale(for: pageRect)
         centerContent()
         notifyPageDisplayed(index: index, size: pageRect.size)
@@ -245,15 +249,9 @@ private extension OptimizedPDFView {
         contentOffset = .zero
     }
 
-    func configureTiledView(for page: CGPDFPage, rect: CGRect) {
-        tiledPageView.updateFrame(for: page)
-        contentSize = rect.size
-    }
-
     func applyFitScale(for pageRect: CGRect) {
         let fitScale = calculateFitScale(for: pageRect)
         minimumZoomScale = fitScale
-        initialZoomScale = fitScale
         setZoomScale(fitScale, animated: false)
     }
 
@@ -267,7 +265,6 @@ private extension OptimizedPDFView {
         DispatchQueue.main.async { [weak self] in
             guard let self = self else { return }
             self.onLoadComplete?(payload)
-            self.pdfDelegate?.pdfView?(self, didDisplayPage: index + 1, size: size)
         }
     }
 }
@@ -362,23 +359,3 @@ extension OptimizedPDFView {
         centerContent()
     }
 }
-
-// MARK: - Public Methods
-
-extension OptimizedPDFView {
-
-    /// Resets the zoom to fit the page.
-    @objc func resetZoom() {
-        UIView.animate(withDuration: configuration.zoomResetAnimationDuration) { [weak self] in
-            guard let self = self else { return }
-            self.setZoomScale(self.initialZoomScale, animated: false)
-            self.centerContent()
-        }
-    }
-
-    /// Navigates to a specific page.
-    /// - Parameter index: The page index (0-based).
-    @objc func goToPage(_ index: Int) {
-        page = NSNumber(value: index)
-    }
-}

package/ios/Views/TiledPDFPageView.swift

@@ -1,44 +1,100 @@
 import UIKit
 import CoreGraphics
+import PDFKit
 
 /// A view that renders a PDF page using CATiledLayer for efficient tiled rendering.
 ///
 /// CATiledLayer divides the content into tiles, allowing smooth zooming and scrolling
 /// without rendering the entire PDF at once. This is essential for large PDF documents.
+
+// MARK: - Global cache of flattened pages
+final class FlattenedPageCache {
+    static let shared = FlattenedPageCache()
+
+    private let cache = NSCache<NSString, FlattenedPageEntry>()
+
+    private init() {
+        cache.countLimit = 10
+    }
+
+    func entry(forKey key: String) -> FlattenedPageEntry? {
+        cache.object(forKey: key as NSString)
+    }
+
+    func setEntry(_ entry: FlattenedPageEntry, forKey key: String) {
+        cache.setObject(entry, forKey: key as NSString)
+    }
+
+    func removeAll() {
+        cache.removeAllObjects()
+    }
+}
+
+final class FlattenedPageEntry: NSObject {
+    let document: CGPDFDocument
+    let page: CGPDFPage
+
+    init(document: CGPDFDocument, page: CGPDFPage) {
+        self.document = document
+        self.page = page
+    }
+}
+
+// MARK: - Atomic flag for thread-safe cancellation
+
+final class OSAtomicFlag {
+    private var _value: Bool = false
+    private var _lock = os_unfair_lock()
+
+    func set() {
+        os_unfair_lock_lock(&_lock)
+        _value = true
+        os_unfair_lock_unlock(&_lock)
+    }
+
+    func reset() {
+        os_unfair_lock_lock(&_lock)
+        _value = false
+        os_unfair_lock_unlock(&_lock)
+    }
+
+    func isSet() -> Bool {
+        os_unfair_lock_lock(&_lock)
+        let v = _value
+        os_unfair_lock_unlock(&_lock)
+        return v
+    }
+}
+
+// MARK: - TiledPDFPageView
+
 final class TiledPDFPageView: UIView {
 
     // MARK: - Properties
 
-    /// The PDF page to render.
     var pdfPage: CGPDFPage? {
-        didSet {
-            setNeedsDisplay()
-        }
+        didSet { setNeedsDisplay() }
     }
 
-    /// Whether antialiasing is enabled for rendering.
+    var pdfURL: URL?
+    var pageIndex: Int = 0
+
     var enableAntialiasing: Bool = true {
-        didSet {
-            setNeedsDisplay()
-        }
+        didSet { setNeedsDisplay() }
     }
 
-    /// The configuration for tiled rendering.
     var configuration: PDFConfiguration = .default {
-        didSet {
-            applyConfiguration()
-        }
+        didSet { applyConfiguration() }
     }
 
-    /// Returns CATiledLayer as the backing layer.
-    override class var layerClass: AnyClass {
-        CATiledLayer.self
-    }
+    override class var layerClass: AnyClass { CATiledLayer.self }
 
-    /// Typed accessor for the tiled layer.
-    private var tiledLayer: CATiledLayer {
-        layer as! CATiledLayer
-    }
+    private var tiledLayer: CATiledLayer { layer as! CATiledLayer }
+
+    private var _activePage: CGPDFPage?
+    private var _pdfKitDocument: PDFDocument?
+    private var _generation: UInt = 0
+    private let _cancelled = OSAtomicFlag()
 
     // MARK: - Initialization
 
@@ -52,7 +108,6 @@ final class TiledPDFPageView: UIView {
         commonInit()
     }
 
-    /// Initializes with a specific configuration.
     convenience init(frame: CGRect, configuration: PDFConfiguration) {
         self.init(frame: frame)
         self.configuration = configuration
@@ -74,35 +129,139 @@ final class TiledPDFPageView: UIView {
         enableAntialiasing = configuration.enableAntialiasing
     }
 
+    // MARK: - Cancellation
+
+    func cancel() {
+        _cancelled.set()
+    }
+
+    private var currentCacheKey: String {
+        guard let url = pdfURL else { return "" }
+        return "\(url.absoluteString)_page\(pageIndex)"
+    }
+
+    // MARK: - Prepare Page (Flatten Pipeline)
+
+    func preparePage() {
+        _cancelled.reset()
+        _generation &+= 1
+        let currentGen = _generation
+
+        let cacheKey = currentCacheKey
+        if let cached = FlattenedPageCache.shared.entry(forKey: cacheKey) {
+            _activePage = cached.page
+            setNeedsDisplay()
+            return
+        }
+
+        _activePage = pdfPage
+
+        guard let url = pdfURL,
+              let originalPage = pdfPage else { return }
+
+        let idx = pageIndex
+        let originalCropBox = originalPage.getBoxRect(.cropBox)
+        let rotation = originalPage.rotationAngle
+
+        let pdfKitDoc: PDFDocument
+        if let existing = _pdfKitDocument {
+            pdfKitDoc = existing
+        } else if let newDoc = PDFDocument(url: url) {
+            _pdfKitDocument = newDoc
+            pdfKitDoc = newDoc
+        } else {
+            return
+        }
+
+        guard let pdfKitPage = pdfKitDoc.page(at: idx) else { return }
+        let annotations = pdfKitPage.annotations
+        if annotations.isEmpty { return }
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+
+            let entry = Self.createFlattenedEntry(
+                pdfKitPage: pdfKitPage,
+                originalCropBox: originalCropBox,
+                rotation: Int(rotation)
+            )
+
+            guard let entry = entry else { return }
+            FlattenedPageCache.shared.setEntry(entry, forKey: cacheKey)
+
+            DispatchQueue.main.async { [weak self] in
+                guard let self = self, self._generation == currentGen else { return }
+                self._activePage = entry.page
+                self.setNeedsDisplay()
+            }
+        }
+    }
+
+    // MARK: - Flattening Logic
+    private static func createFlattenedEntry(
+        pdfKitPage: PDFPage,
+        originalCropBox: CGRect,
+        rotation: Int
+    ) -> FlattenedPageEntry? {
+        let finalSize: CGSize
+        if rotation == 90 || rotation == 270 {
+            finalSize = CGSize(width: originalCropBox.height, height: originalCropBox.width)
+        } else {
+            finalSize = originalCropBox.size
+        }
+
+        var mediaBox = CGRect(origin: .zero, size: finalSize)
+
+        let pdfData = NSMutableData()
+        guard let consumer = CGDataConsumer(data: pdfData as CFMutableData),
+              let pdfContext = CGContext(consumer: consumer, mediaBox: &mediaBox, nil) else {
+            return nil
+        }
+
+        pdfContext.beginPage(mediaBox: &mediaBox)
+
+        if originalCropBox.origin.x != 0 || originalCropBox.origin.y != 0 {
+            pdfContext.translateBy(x: -originalCropBox.origin.x, y: -originalCropBox.origin.y)
+        }
+
+        pdfKitPage.draw(with: .cropBox, to: pdfContext)
+
+        pdfContext.endPage()
+        pdfContext.closePDF()
+
+        guard let provider = CGDataProvider(data: pdfData as CFData),
+              let flattenedDoc = CGPDFDocument(provider),
+              let flattenedCGPage = flattenedDoc.page(at: 1) else {
+            return nil
+        }
+
+        return FlattenedPageEntry(document: flattenedDoc, page: flattenedCGPage)
+    }
+
     // MARK: - Rendering
 
     override func draw(_ rect: CGRect) {
+        guard !_cancelled.isSet() else { return }
+
         guard let context = UIGraphicsGetCurrentContext(),
-              let page = pdfPage else {
-            return
-        }
+              let page = _activePage else { return }
 
         renderPage(page, in: context, rect: rect)
     }
 
-    /// Renders the PDF page in the given graphics context.
     private func renderPage(_ page: CGPDFPage, in context: CGContext, rect: CGRect) {
         context.saveGState()
         defer { context.restoreGState() }
 
-        // Configure rendering quality
         context.setShouldAntialias(enableAntialiasing)
         context.interpolationQuality = determineInterpolationQuality()
 
-        // Fill background
         context.setFillColor(UIColor.white.cgColor)
         context.fill(rect)
 
-        // Transform coordinate system (UIKit uses top-left origin, PDF uses bottom-left)
         context.translateBy(x: 0, y: bounds.height)
         context.scaleBy(x: 1.0, y: -1.0)
 
-        // Apply PDF transform to fit the page
         let pdfTransform = page.getDrawingTransform(
             .cropBox,
             rect: bounds,
@@ -110,31 +269,11 @@ final class TiledPDFPageView: UIView {
             preserveAspectRatio: true
         )
         context.concatenate(pdfTransform)
-
         // Draw the page
         context.drawPDFPage(page)
     }
 
-    /// Determines the interpolation quality based on zoom level.
     private func determineInterpolationQuality() -> CGInterpolationQuality {
         tiledLayer.levelsOfDetail == 1 ? .low : .high
     }
 }
-
-// MARK: - Public Methods
-
-extension TiledPDFPageView {
-
-    /// Prepares the view for displaying a new page.
-    func prepareForReuse() {
-        pdfPage = nil
-        layer.contents = nil
-    }
-
-    /// Updates the view size to match the page dimensions.
-    func updateFrame(for page: CGPDFPage) {
-        let pageRect = page.getBoxRect(.cropBox)
-        frame = CGRect(origin: .zero, size: pageRect.size)
-        pdfPage = page
-    }
-}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "react-native-optimized-pdf",
-  "version": "1.1.0",
-  "description": "Ultra high-performance PDF viewer for React Native. Renders massive PDFs (1000+ pages) with extreme zoom levels while using minimal memory. 10x faster than native PDFKit on iOS, prevents crashes on large documents. Uses CATiledLayer (iOS) and PdfRenderer (Android) for tile-based rendering.",
+  "version": "1.3.1",
+  "description": "React Native PDF viewer with high performance, zoom, and support for large PDF files. Fast, memory-efficient, and supports annotations (annots) on iOS and Android.",
   "main": "index.ts",
   "types": "index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
+    "test:coverage": "jest --coverage --coverageReporters=text",
     "lint": "eslint . --ext .ts,.tsx",
     "lint:fix": "eslint . --ext .ts,.tsx --fix",
     "format": "prettier --write \"**/*.{ts,tsx,js,json,md}\"",
@@ -14,21 +15,27 @@
   },
   "keywords": [
     "react-native",
+    "react-native-pdf",
     "pdf",
     "pdf-viewer",
-    "viewer",
+    "react-native-pdf-viewer",
+    "pdf-reader",
+    "pdf-renderer",
+    "pdf-display",
     "ios",
     "android",
-    "performance",
-    "high-performance",
     "large-pdf",
+    "big-pdf",
+    "pdf-performance",
+    "fast-pdf",
     "memory-efficient",
     "tiled-rendering",
     "zoom",
-    "catiled-layer",
-    "pdfrenderer",
-    "no-crash",
-    "optimized"
+    "annotations",
+    "annots",
+    "pdfkit",
+    "pdfium",
+    "catiledlayer"
   ],
   "author": "Your Name",
   "license": "MIT",
@@ -38,16 +45,22 @@
   },
   "devDependencies": {
     "@react-native-community/eslint-config": "^3.2.0",
+    "@testing-library/react-native": "^13.3.1",
     "@types/crypto-js": "^4.2.2",
-    "@types/react": "^18.0.0",
-    "@types/react-native": "^0.72.0",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^18.2.6",
+    "@types/react-native": "^0.64.19",
     "@typescript-eslint/eslint-plugin": "^6.0.0",
     "@typescript-eslint/parser": "^6.0.0",
     "eslint": "^8.0.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-jest": "^29.11.0",
     "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
     "prettier": "2.8.8",
+    "react": "18.2.0",
+    "react-native": "0.73.11",
+    "react-test-renderer": "18.2.0",
     "typescript": "^5.0.0"
   },
   "repository": {
@@ -55,7 +68,7 @@
     "url": "https://github.com/Herbeth-LKS/react-native-optimized-pdf"
   },
   "dependencies": {
-    "crypto-js": "^4.2.0",
-    "react-native-fs": "^2.20.0"
+    "@dr.pogodin/react-native-fs": "^2.41.0",
+    "crypto-js": "^4.2.0"
   }
 }