react-native-optimized-pdf 1.0.1 → 1.2.0

package/ios/Core/PDFDocumentLoader.swift

@@ -0,0 +1,75 @@
+import Foundation
+import CoreGraphics
+
+/// Protocol for PDF document loading operations.
+protocol PDFDocumentLoading {
+    func loadDocument(from source: String, password: String?) -> Result<CGPDFDocument, PDFError>
+}
+
+/// Handles loading and unlocking PDF documents.
+final class PDFDocumentLoader: PDFDocumentLoading {
+
+    // MARK: - Singleton
+
+    static let shared = PDFDocumentLoader()
+
+    private init() {}
+
+    // MARK: - Public Methods
+
+    /// Loads a PDF document from the given source path.
+    /// - Parameters:
+    ///   - source: The file path to the PDF document.
+    ///   - password: Optional password for encrypted PDFs.
+    /// - Returns: A Result containing the loaded document or an error.
+    func loadDocument(from source: String, password: String?) -> Result<CGPDFDocument, PDFError> {
+        guard !source.isEmpty else {
+            return .failure(.emptySource)
+        }
+
+        let url = normalizedURL(from: source)
+
+        guard let document = CGPDFDocument(url as CFURL) else {
+            return .failure(.documentLoadFailed(source))
+        }
+
+        return unlockIfNeeded(document: document, password: password)
+    }
+
+    // MARK: - Private Methods
+
+    /// Normalizes the source path to a file URL.
+    private func normalizedURL(from source: String) -> URL {
+        let path = source.hasPrefix("file://")
+            ? String(source.dropFirst(7))
+            : source
+        return URL(fileURLWithPath: path)
+    }
+
+    /// Attempts to unlock an encrypted PDF document.
+    private func unlockIfNeeded(
+        document: CGPDFDocument,
+        password: String?
+    ) -> Result<CGPDFDocument, PDFError> {
+        guard document.isEncrypted else {
+            return .success(document)
+        }
+
+        // Try empty password first (some PDFs use empty password for user access)
+        if document.unlockWithPassword("") {
+            return .success(document)
+        }
+
+        // Check if password was provided
+        guard let password = password, !password.isEmpty else {
+            return .failure(.passwordRequired)
+        }
+
+        // Try provided password
+        guard document.unlockWithPassword(password) else {
+            return .failure(.invalidPassword)
+        }
+
+        return .success(document)
+    }
+}

package/ios/Core/PDFError.swift

@@ -0,0 +1,36 @@
+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"
+        }
+    }
+
+    /// Dictionary representation for React Native events.
+    var eventPayload: [String: Any] {
+        ["message": errorDescription ?? "Unknown error"]
+    }
+}

package/ios/ReactNative/OptimizedPDFViewManager.swift

@@ -0,0 +1,48 @@
+import Foundation
+import React
+
+/// React Native View Manager for OptimizedPDFView.
+///
+/// This class bridges the native OptimizedPDFView with React Native,
+/// exposing properties and methods to the JavaScript layer.
+@objc(OptimizedPdfViewManager)
+final class OptimizedPDFViewManager: RCTViewManager {
+
+    // MARK: - RCTViewManager
+
+    override func view() -> UIView! {
+        OptimizedPDFView()
+    }
+
+    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

@@ -0,0 +1,54 @@
+/**
+ * React Native bridge for OptimizedPDFViewManager.
+ *
+ * This file exposes the Swift view manager and its properties/methods
+ * to the React Native JavaScript layer using the RCT_EXTERN macros.
+ */
+
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(OptimizedPdfViewManager, RCTViewManager)
+
+#pragma mark - View Properties
+
+/// Path to the PDF file to display.
+RCT_EXPORT_VIEW_PROPERTY(source, NSString)
+
+/// Current page index (0-based).
+RCT_EXPORT_VIEW_PROPERTY(page, NSNumber)
+
+/// Maximum zoom scale allowed.
+RCT_EXPORT_VIEW_PROPERTY(maximumZoom, NSNumber)
+
+/// Whether antialiasing is enabled for smoother rendering.
+RCT_EXPORT_VIEW_PROPERTY(enableAntialiasing, BOOL)
+
+/// Password for encrypted PDFs.
+RCT_EXPORT_VIEW_PROPERTY(password, NSString)
+
+#pragma mark - Event Callbacks
+
+/// Called when an error occurs during PDF loading or rendering.
+RCT_EXPORT_VIEW_PROPERTY(onError, RCTDirectEventBlock)
+
+/// Called when a page is fully loaded and displayed.
+RCT_EXPORT_VIEW_PROPERTY(onLoadComplete, RCTDirectEventBlock)
+
+/// Called when the document is loaded with the total page count.
+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

@@ -0,0 +1,401 @@
+import UIKit
+import React
+import PDFKit
+
+/// 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)
+}
+
+/// 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.
+@objc(OptimizedPdfView)
+final class OptimizedPDFView: UIScrollView {
+
+    // MARK: - React Native Properties
+
+    /// Path to the PDF file to display.
+    @objc var source: String = "" {
+        didSet {
+            handleSourceChange()
+        }
+    }
+
+    /// Current page index (0-based).
+    @objc var page: NSNumber = 0 {
+        didSet {
+            handlePageChange(to: page.intValue)
+        }
+    }
+
+    /// Maximum zoom scale.
+    @objc var maximumZoom: NSNumber = 5.0 {
+        didSet {
+            configuration.maximumZoom = CGFloat(truncating: maximumZoom)
+            applyZoomConfiguration()
+        }
+    }
+
+    /// Whether antialiasing is enabled.
+    @objc var enableAntialiasing: Bool = true {
+        didSet {
+            configuration.enableAntialiasing = enableAntialiasing
+            tiledPageView?.enableAntialiasing = enableAntialiasing
+        }
+    }
+
+    /// Password for encrypted PDFs.
+    @objc var password: String = "" {
+        didSet {
+            configuration.password = password.isEmpty ? nil : password
+            retryLoadIfNeeded()
+        }
+    }
+
+    // MARK: - React Native Event Callbacks
+
+    @objc var onError: RCTDirectEventBlock?
+    @objc var onLoadComplete: RCTDirectEventBlock?
+    @objc var onPageCount: RCTDirectEventBlock?
+    @objc var onPasswordRequired: RCTDirectEventBlock?
+
+    // 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 var tiledPageView: TiledPDFPageView!
+    private var pdfURL: URL?
+    private var configuration = PDFConfiguration.default
+    private let documentLoader: PDFDocumentLoading
+
+    private var pendingPageIndex: Int?
+    private var needsLoad = false
+    private var lastBoundsSize: CGSize = .zero
+    private var currentPageRect: CGRect?
+    private var initialZoomScale: CGFloat = 1.0
+
+    // MARK: - Initialization
+
+    override init(frame: CGRect) {
+        self.tiledPageView = TiledPDFPageView(frame: frame)
+        self.documentLoader = PDFDocumentLoader.shared
+        super.init(frame: frame)
+        setupView()
+    }
+
+    required init?(coder: NSCoder) {
+        self.tiledPageView = TiledPDFPageView(frame: .zero)
+        self.documentLoader = PDFDocumentLoader.shared
+        super.init(coder: coder)
+        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() {
+        setupScrollView()
+        setupTiledPageView()
+    }
+
+    private func setupScrollView() {
+        delegate = self
+        showsHorizontalScrollIndicator = false
+        showsVerticalScrollIndicator = false
+        bouncesZoom = true
+        applyZoomConfiguration()
+    }
+
+    private func setupTiledPageView() {
+        tiledPageView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        tiledPageView.configuration = configuration
+        addSubview(tiledPageView)
+    }
+
+    private func applyZoomConfiguration() {
+        maximumZoomScale = configuration.maximumZoom
+
+        guard let pageRect = currentPageRect else { return }
+
+        let fitScale = calculateFitScale(for: pageRect)
+        minimumZoomScale = fitScale
+        initialZoomScale = fitScale
+    }
+}
+
+// MARK: - Document Loading
+
+private extension OptimizedPDFView {
+
+    func handleSourceChange() {
+        resetDocument()
+        pdfURL = nil
+        FlattenedPageCache.shared.removeAll()
+        pendingPageIndex = page.intValue
+        needsLoad = true
+        setNeedsLayout()
+    }
+
+    func handlePageChange(to index: Int) {
+        guard let document = pdfDocument else {
+            pendingPageIndex = index
+            return
+        }
+
+        let validIndex = clampPageIndex(index, for: document)
+        displayPage(at: validIndex)
+    }
+
+    func retryLoadIfNeeded() {
+        guard !password.isEmpty, pdfDocument == nil, needsLoad else { return }
+        setNeedsLayout()
+    }
+
+    func resetDocument() {
+        pdfDocument = nil
+        pageCount = 0
+    }
+
+    func loadDocument() {
+        guard !source.isEmpty else { return }
+
+        let path = source.hasPrefix("file://") ? String(source.dropFirst(7)) : source
+        pdfURL = URL(fileURLWithPath: path)
+
+        let result = documentLoader.loadDocument(from: source, password: configuration.password)
+
+        switch result {
+        case .success(let document):
+            handleLoadSuccess(document: document)
+
+        case .failure(let error):
+            handleLoadFailure(error: error)
+        }
+    }
+
+    func handleLoadSuccess(document: CGPDFDocument) {
+        pdfDocument = document
+        pageCount = document.numberOfPages
+
+        // Emit page count event on next run loop to ensure listeners are connected
+        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
+        let targetIndex = pendingPageIndex ?? 0
+        pendingPageIndex = nil
+        let validIndex = clampPageIndex(targetIndex, for: document)
+        displayPage(at: validIndex)
+    }
+
+    func handleLoadFailure(error: PDFError) {
+        if case .passwordRequired = error {
+            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 {
+        max(0, min(index, document.numberOfPages - 1))
+    }
+}
+
+// MARK: - Page Display
+
+private extension OptimizedPDFView {
+
+    func displayPage(at index: Int) {
+        guard let document = pdfDocument,
+              let page = document.page(at: index + 1) else {
+            return
+        }
+
+        let pageRect = page.getBoxRect(.cropBox)
+        currentPageRect = pageRect
+
+        prepareForPageDisplay()
+
+        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)
+    }
+
+    func prepareForPageDisplay() {
+        zoomScale = 1.0
+        contentOffset = .zero
+    }
+
+    func applyFitScale(for pageRect: CGRect) {
+        let fitScale = calculateFitScale(for: pageRect)
+        minimumZoomScale = fitScale
+        initialZoomScale = fitScale
+        setZoomScale(fitScale, animated: false)
+    }
+
+    func notifyPageDisplayed(index: Int, size: CGSize) {
+        let payload: [String: Any] = [
+            "currentPage": index + 1,
+            "width": size.width,
+            "height": size.height
+        ]
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.onLoadComplete?(payload)
+            self.pdfDelegate?.pdfView?(self, didDisplayPage: index + 1, size: size)
+        }
+    }
+}
+
+// MARK: - Layout & Scaling
+
+private extension OptimizedPDFView {
+
+    func calculateFitScale(for pageRect: CGRect) -> CGFloat {
+        guard bounds.width > 0,
+              bounds.height > 0,
+              pageRect.width > 0,
+              pageRect.height > 0 else {
+            return 1.0
+        }
+
+        let scaleX = bounds.width / pageRect.width
+        let scaleY = bounds.height / pageRect.height
+        let scale = min(scaleX, scaleY)
+
+        guard scale.isFinite, scale > 0 else {
+            return 1.0
+        }
+
+        return scale
+    }
+
+    func centerContent() {
+        let boundsSize = bounds.size
+        var frame = tiledPageView.frame
+
+        frame.origin.x = frame.width < boundsSize.width
+            ? (boundsSize.width - frame.width) * 0.5
+            : 0
+
+        frame.origin.y = frame.height < boundsSize.height
+            ? (boundsSize.height - frame.height) * 0.5
+            : 0
+
+        tiledPageView.frame = frame
+    }
+}
+
+// MARK: - UIScrollViewDelegate
+
+extension OptimizedPDFView: UIScrollViewDelegate {
+
+    func viewForZooming(in scrollView: UIScrollView) -> UIView? {
+        tiledPageView
+    }
+
+    func scrollViewDidZoom(_ scrollView: UIScrollView) {
+        centerContent()
+    }
+}
+
+// MARK: - Lifecycle
+
+extension OptimizedPDFView {
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window != nil {
+            setNeedsLayout()
+        }
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+
+        guard bounds.width > 0, bounds.height > 0 else { return }
+
+        if needsLoad {
+            needsLoad = false
+            loadDocument()
+            lastBoundsSize = bounds.size
+            return
+        }
+
+        handleBoundsChange()
+    }
+
+    private func handleBoundsChange() {
+        guard lastBoundsSize != bounds.size,
+              let pageRect = currentPageRect else {
+            centerContent()
+            return
+        }
+
+        lastBoundsSize = bounds.size
+        applyFitScale(for: pageRect)
+        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)
+    }
+}