react-native-optimized-pdf 1.0.0 → 1.1.0

package/ReactNativeOptimizedPdf.podspec

@@ -9,12 +9,12 @@ Pod::Spec.new do |s|
   s.description  = <<-DESC
                   High-performance PDF viewer for React Native
                    DESC
-  s.homepage     = "https://github.com/your-username/react-native-optimized-pdf"
+  s.homepage     = "https://github.com/Herbeth-LKS/react-native-optimized-pdf"
   s.license      = "MIT"
-  s.author       = { "Your Name" => "your-email@example.com" }
+  s.author       = { "Herbeth Lucas" => "herbethlucas007@gmail.com" }
   s.platform     = :ios, "12.0"
-  s.source       = { :git => "https://github.com/your-username/react-native-optimized-pdf.git", :tag => "#{s.version}" }
-  s.source_files = "ios/*.{swift,h,m}"
+  s.source       = { :git => "https://github.com/Herbeth-LKS/react-native-optimized-pdf.git", :tag => "#{s.version}" }
+  s.source_files = "ios/**/*.{swift,h,m}"
   s.requires_arc = true
   s.swift_version = "5.0"
   s.dependency "React-Core"

package/ios/Core/PDFConfiguration.swift

@@ -0,0 +1,28 @@
+import UIKit
+
+/// Configuration options for PDF rendering.
+struct PDFConfiguration {
+    /// Maximum zoom scale allowed.
+    var maximumZoom: CGFloat = 5.0
+
+    /// Whether to enable antialiasing for smoother rendering.
+    var enableAntialiasing: Bool = true
+
+    /// Password for encrypted PDFs.
+    var password: String?
+
+    /// Size of each tile for CATiledLayer rendering.
+    var tileSize: CGSize = CGSize(width: 512, height: 512)
+
+    /// Number of detail levels for zoom.
+    var levelsOfDetail: Int = 2
+
+    /// Bias for levels of detail (allows zoom up to 2^bias resolution).
+    var levelsOfDetailBias: Int = 8
+
+    /// Animation duration for zoom reset.
+    var zoomResetAnimationDuration: TimeInterval = 0.25
+
+    /// Default configuration.
+    static let `default` = PDFConfiguration()
+}

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,384 @@
+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)
+}
+
+/// 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 let tiledPageView: TiledPDFPageView
+    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()
+        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 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()
+        configureTiledView(for: page, rect: pageRect)
+        applyFitScale(for: pageRect)
+        centerContent()
+        notifyPageDisplayed(index: index, size: pageRect.size)
+    }
+
+    func prepareForPageDisplay() {
+        zoomScale = 1.0
+        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)
+    }
+
+    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)
+    }
+}

package/ios/Views/TiledPDFPageView.swift

@@ -0,0 +1,140 @@
+import UIKit
+import CoreGraphics
+
+/// 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.
+final class TiledPDFPageView: UIView {
+
+    // MARK: - Properties
+
+    /// The PDF page to render.
+    var pdfPage: CGPDFPage? {
+        didSet {
+            setNeedsDisplay()
+        }
+    }
+
+    /// Whether antialiasing is enabled for rendering.
+    var enableAntialiasing: Bool = true {
+        didSet {
+            setNeedsDisplay()
+        }
+    }
+
+    /// The configuration for tiled rendering.
+    var configuration: PDFConfiguration = .default {
+        didSet {
+            applyConfiguration()
+        }
+    }
+
+    /// Returns CATiledLayer as the backing layer.
+    override class var layerClass: AnyClass {
+        CATiledLayer.self
+    }
+
+    /// Typed accessor for the tiled layer.
+    private var tiledLayer: CATiledLayer {
+        layer as! CATiledLayer
+    }
+
+    // MARK: - Initialization
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        commonInit()
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        commonInit()
+    }
+
+    /// Initializes with a specific configuration.
+    convenience init(frame: CGRect, configuration: PDFConfiguration) {
+        self.init(frame: frame)
+        self.configuration = configuration
+        applyConfiguration()
+    }
+
+    private func commonInit() {
+        applyConfiguration()
+        contentScaleFactor = UIScreen.main.scale
+        backgroundColor = .white
+    }
+
+    // MARK: - Configuration
+
+    private func applyConfiguration() {
+        tiledLayer.tileSize = configuration.tileSize
+        tiledLayer.levelsOfDetail = configuration.levelsOfDetail
+        tiledLayer.levelsOfDetailBias = configuration.levelsOfDetailBias
+        enableAntialiasing = configuration.enableAntialiasing
+    }
+
+    // MARK: - Rendering
+
+    override func draw(_ rect: CGRect) {
+        guard let context = UIGraphicsGetCurrentContext(),
+              let page = pdfPage 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,
+            rotate: 0,
+            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,6 +1,6 @@
 {
   "name": "react-native-optimized-pdf",
-  "version": "1.0.0",
+  "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.",
   "main": "index.ts",
   "types": "index.d.ts",

package/ios/OptimizedPdfView.swift

@@ -1,256 +0,0 @@
-import UIKit
-import PDFKit
-import React
-
-// Classe que representa a View personalizada do PDF otimizado.
-// É baseada em UIScrollView para permitir zoom e scroll sem travar,
-@objc(OptimizedPdfView)
-class OptimizedPdfView: UIScrollView, UIScrollViewDelegate {
-
-    // Caminho do arquivo PDF a ser carregado
-    @objc var source: String = "" {
-        didSet {
-            needsLoad = true
-            pdfDocument = nil
-            pendingPageIndex = Int(truncating: page)
-            setNeedsLayout()
-        }
-    }
-
-    @objc var page: NSNumber = 0 {
-        didSet {
-            let idx = page.intValue
-            if let doc = pdfDocument {
-                if idx >= 0, idx < doc.numberOfPages {
-                    displayPage(index: idx)
-                }
-            } else {
-                pendingPageIndex = idx
-            }
-        }
-    }
-
-    @objc var maximumZoom: NSNumber = 5.0 {
-        didSet {
-            self.maximumZoomScale = CGFloat(truncating: maximumZoom)
-            if let lastRect = currentPageRect {
-                let fit = fitScale(for: lastRect)
-                self.minimumZoomScale = fit
-                self.initialZoomScale = fit
-            }
-        }
-    }
-
-    @objc var enableAntialiasing: Bool = true {
-        didSet {
-            tiledView?.enableAntialiasing = enableAntialiasing
-            tiledView?.setNeedsDisplay()
-        }
-    }
-
-    @objc var password: String = "" {
-        didSet {
-            if !password.isEmpty && pdfDocument == nil && needsLoad {
-                setNeedsLayout()
-            }
-        }
-    }
-
-    // Eventos enviados para o React Native
-    @objc var onError: RCTDirectEventBlock?
-    @objc var onLoadComplete: RCTDirectEventBlock?
-    @objc var onPageCount: RCTDirectEventBlock?
-    @objc var onPasswordRequired: RCTDirectEventBlock?
-
-    // Documento PDF em memória (usando Core Graphics, mais leve que PDFKit para esse caso)
-    private var pdfDocument: CGPDFDocument?
-
-    // View responsável por desenhar a página atual usando CATiledLayer
-    private var tiledView: TiledPdfPageView!
-    private var initialZoomScale: CGFloat = 1.0
-    private var needsLoad = false
-    private var pendingPageIndex: Int?
-    private var lastBoundsSize: CGSize = .zero
-    private var currentPageRect: CGRect?
-
-    // Inicializadores
-    override init(frame: CGRect) {
-        super.init(frame: frame)
-        setupScrollView()
-    }
-
-    required init?(coder: NSCoder) {
-        super.init(coder: coder)
-        setupScrollView()
-    }
-
-    // Configura a ScrollView para suportar zoom suave e sem travamentos
-    private func setupScrollView() {
-        delegate = self
-        minimumZoomScale = 1.0
-        maximumZoomScale = CGFloat(truncating: maximumZoom)
-        showsHorizontalScrollIndicator = false
-        showsVerticalScrollIndicator = false
-        bouncesZoom = true // "efeito mola" ao dar zoom
-
-        // Inicializa o tiledView que renderiza as páginas em blocos (tiles)
-        tiledView = TiledPdfPageView(frame: bounds)
-        tiledView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-        tiledView.enableAntialiasing = enableAntialiasing
-        addSubview(tiledView)
-    }
-
-    // Carrega o PDF a partir de um caminho local
-    private func loadPdf() {
-        guard !source.isEmpty else { return }
-
-        // Remove prefixo "file://" se existir
-        let path = source.hasPrefix("file://") ? String(source.dropFirst(7)) : source
-        let url = URL(fileURLWithPath: path)
-
-        // Tenta abrir o documento PDF
-        guard let doc = CGPDFDocument(url as CFURL) else {
-            onError?(["message": "Failed to open PDF at \(source)"])
-            return
-        }
-
-        if doc.isEncrypted {
-            if !doc.unlockWithPassword("") {
-                if password.isEmpty {
-                    DispatchQueue.main.async { [weak self] in
-                        self?.onPasswordRequired?([:])  
-                    }
-                    onError?(["message": "PDF is password protected"])
-                    return
-                }
-                
-                if !doc.unlockWithPassword(password) {
-                    onError?(["message": "Invalid password for PDF"])
-                    return
-                }
-            }
-        }
-
-        pdfDocument = doc
-
-        // Emite evento na próxima iteração do runloop p/ garantir listeners conectados
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            self.onPageCount?(["numberOfPages": NSNumber(value: doc.numberOfPages)])
-        }
-
-        // Página desejada (ou 0 se não tiver)
-        let idx = (pendingPageIndex ?? 0)
-        pendingPageIndex = nil
-
-        displayPage(index: max(0, min(idx, doc.numberOfPages - 1)))
-    }
-
-    // MARK: Exibir página
-    private func displayPage(index: Int) {
-        guard let doc = pdfDocument,
-              let pageRef = doc.page(at: index + 1) else { return }
-
-        let pageRect = pageRef.getBoxRect(.cropBox)
-        currentPageRect = pageRect
-
-        // Prepara conteúdo
-        zoomScale = 1.0
-        contentOffset = .zero
-        tiledView.pdfPage = pageRef
-        tiledView.frame = CGRect(origin: .zero, size: pageRect.size)
-        tiledView.setNeedsDisplay()
-        contentSize = pageRect.size
-
-        // Fit seguro (só com bounds válidos)
-        let fit = fitScale(for: pageRect)
-        minimumZoomScale = fit
-        initialZoomScale = fit
-        setZoomScale(fit, animated: false)
-        centerContent()
-
-       // Evento enviado ao RN quando a página carrega
-        let w = pageRect.width, h = pageRect.height
-        DispatchQueue.main.async { [weak self] in
-            self?.onLoadComplete?([ "currentPage": index + 1, "width": w, "height": h])
-        }
-    }
-
-    // Cálculo de escala sempre com guarda
-    private func fitScale(for pageRect: CGRect) -> CGFloat {
-        guard bounds.width > 0, bounds.height > 0,
-              pageRect.width > 0, pageRect.height > 0 else {
-            return 1.0
-        }
-        let sW = bounds.width / pageRect.width
-        let sH = bounds.height / pageRect.height
-        let s = min(sW, sH)
-        // evita zero/NaN/inf
-        if s.isNaN || s.isInfinite || s <= 0 { return 1.0 }
-        return s
-    }
-
-    private func centerContent() {
-        let boundsSize = bounds.size
-        var frameToCenter = tiledView.frame
-
-        // Centro horizontal
-        frameToCenter.origin.x = (frameToCenter.size.width < boundsSize.width)
-            ? (boundsSize.width - frameToCenter.size.width) * 0.5
-            : 0
-
-        // Centro vertical
-        frameToCenter.origin.y = (frameToCenter.size.height < boundsSize.height)
-            ? (boundsSize.height - frameToCenter.size.height) * 0.5
-            : 0
-
-        tiledView.frame = frameToCenter
-    }
-
-    func viewForZooming(in scrollView: UIScrollView) -> UIView? {
-        return tiledView
-    }
-
-    func scrollViewDidZoom(_ scrollView: UIScrollView) {
-        centerContent()
-    }
-
-    func resetZoom() {
-        UIView.animate(withDuration: 0.25) {
-            self.setZoomScale(self.initialZoomScale, animated: false)
-            self.centerContent()
-        }
-    }
-
-    // MARK: Layout ciclo
-    override func didMoveToWindow() {
-        super.didMoveToWindow()
-        if window != nil { setNeedsLayout() }
-    }
-
-    override func layoutSubviews() {
-        super.layoutSubviews()
-
-        guard bounds.width > 0, bounds.height > 0 else { return }
-
-        // Carrega o PDF somente agora (props já setadas e bounds válidos)
-        if needsLoad {
-            needsLoad = false
-            loadPdf()
-            lastBoundsSize = bounds.size
-            return
-        }
-
-        // Se mudou o tamanho (ex.: rotação), refaz o fit na página atual
-        if lastBoundsSize != bounds.size, let rect = currentPageRect {
-            lastBoundsSize = bounds.size
-            let fit = fitScale(for: rect)
-            minimumZoomScale = fit
-            initialZoomScale = fit
-            setZoomScale(fit, animated: false)
-            centerContent()
-        } else {
-            centerContent()
-        }
-    }
-}

package/ios/OptimizedPdfViewManager.m

@@ -1,22 +0,0 @@
-#import <React/RCTViewManager.h>
-#import <React/RCTUIManager.h>
-#import <React/RCTBridgeModule.h>
-
-@interface RCT_EXTERN_MODULE(OptimizedPdfViewManager, RCTViewManager)
-
-// Propriedades
-RCT_EXPORT_VIEW_PROPERTY(source, NSString)
-RCT_EXPORT_VIEW_PROPERTY(page, NSNumber)
-RCT_EXPORT_VIEW_PROPERTY(maximumZoom, NSNumber)
-RCT_EXPORT_VIEW_PROPERTY(enableAntialiasing, BOOL)
-RCT_EXPORT_VIEW_PROPERTY(password, NSString)
-RCT_EXPORT_VIEW_PROPERTY(onError, RCTDirectEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onLoadComplete, RCTDirectEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onPageCount, RCTDirectEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onPasswordRequired, RCTDirectEventBlock)
-
-// Métodos nativos
-RCT_EXTERN_METHOD(goToPage:(nonnull NSNumber *)node
-                  page:(nonnull NSNumber *)page)
-
-@end

package/ios/OptimizedPdfViewManager.swift

@@ -1,24 +0,0 @@
-import Foundation
-import React
-
-@objc(OptimizedPdfViewManager)
-class OptimizedPdfViewManager: RCTViewManager {
-
-    override func view() -> UIView! {
-        return OptimizedPdfView()
-    }
-
-    override static func requiresMainQueueSetup() -> Bool {
-        return true
-    }
-
-    @objc func goToPage(_ node: NSNumber, page: NSNumber) {
-        DispatchQueue.main.async {
-            if let component = self.bridge.uiManager.view(
-                forReactTag: node
-            ) as? OptimizedPdfView {
-                component.page = page
-            }
-        }
-    }
-}

package/ios/TiledPdfPageView.swift

@@ -1,76 +0,0 @@
-import UIKit
-
-// View que desenha um PDF usando CATiledLayer.
-// CATiledLayer divide o PDF em blocos ("tiles"), permitindo zoom e rolagem
-// sem precisar renderizar o PDF inteiro de uma vez.
-class TiledPdfPageView: UIView {
-    var pdfPage: CGPDFPage?
-    var enableAntialiasing: Bool = true
-
-    // Define o layer como CATiledLayer em vez do CALayer padrão
-    override class var layerClass: AnyClass { CATiledLayer.self }
-    private var tiledLayer: CATiledLayer { return layer as! CATiledLayer }
-
-    override init(frame: CGRect) {
-        super.init(frame: frame)
-        setupTiledLayer()
-    }
-
-    required init?(coder: NSCoder) {
-        super.init(coder: coder)
-        setupTiledLayer()
-    }
-
-    // Configuração do CATiledLayer
-    private func setupTiledLayer() {
-        // Tamanho de cada tile (ajustado para balancear memória e performance)
-        tiledLayer.tileSize = CGSize(width: 512, height: 512)
-
-        // Número de níveis de detalhe (zoom in/out)
-        tiledLayer.levelsOfDetail = 2
-
-        // permite zoom até 256x acima da resolução base
-        tiledLayer.levelsOfDetailBias = 8
-
-        // Mantém qualidade de acordo com a tela
-        contentScaleFactor = UIScreen.main.scale
-
-        // Fundo branco atrás do PDF
-        backgroundColor = .white
-    }
-
-    // Renderiza o conteúdo do PDF
-    override func draw(_ rect: CGRect) {
-        guard let ctx = UIGraphicsGetCurrentContext(),
-              let page = pdfPage else { return }
-
-        ctx.saveGState()
-        
-        ctx.setShouldAntialias(enableAntialiasing)
-
-        // Fundo branco no pedaço atual
-        ctx.setFillColor(UIColor.white.cgColor)
-        ctx.fill(rect)
-
-        let pageRect = page.getBoxRect(.cropBox)
-
-        // Ajusta coordenadas (UIKit e PDF têm sistemas de coordenadas diferentes)
-        ctx.translateBy(x: 0, y: bounds.height)
-        ctx.scaleBy(x: 1.0, y: -1.0)
-
-        // Define a transformação para encaixar a página no espaço disponível
-        let pdfTransform = page.getDrawingTransform(.cropBox, rect: bounds, rotate: 0, preserveAspectRatio: true)
-        ctx.concatenate(pdfTransform)
-
-        // Qualidade da renderização (melhor em zoom, mais rápida em tiles distantes)
-        if tiledLayer.levelsOfDetail == 1 {
-            ctx.interpolationQuality = .low
-        } else {
-            ctx.interpolationQuality = .high
-        }
-
-        // Desenha a página PDF
-        ctx.drawPDFPage(page)
-        ctx.restoreGState()
-    }
-}