react-native-pdfrender 0.1.0

package/ios/PdfViewerTurboModule.mm

@@ -0,0 +1,186 @@
+/**
+ * PdfViewerTurboModule.mm — ObjC++ bridge for the PDF viewer TurboModule.
+ *
+ * Architecture
+ * ────────────
+ *  Swift class  (PdfViewerTurboModuleImpl.swift)
+ *    └─ holds ALL business logic (present VC, render pages, create PDF)
+ *  This ObjC++ file
+ *    └─ bridges Swift ↔ React Native New Architecture (JSI / TurboModules)
+ *    └─ wraps promise-based methods (RCTPromiseResolveBlock / RejectBlock)
+ *    └─ emits native events to JS via RCTEventEmitter
+ *
+ * Why .mm (ObjC++)?
+ *   The New Architecture TurboModule system uses C++ (JSI) internally.
+ *   `getTurboModule:` returns a std::shared_ptr — a C++ type — which
+ *   cannot appear in a plain .m (ObjC) file.
+ *
+ * Why forward-declare instead of importing pdfRender-Swift.h?
+ *   The auto-generated Swift bridging header pulls in every @objc class,
+ *   including AppDelegate's ReactNativeDelegate which depends on
+ *   RCTDefaultReactNativeFactoryDelegate — a transitive header chain that
+ *   causes "file not found" errors in this translation unit.  A targeted
+ *   forward declaration breaks the dependency and the linker resolves the
+ *   Swift symbol at link time.
+ *
+ * Module name
+ *   RCT_EXPORT_MODULE(NativePdfViewerModule) must match the name returned by
+ *   TurboModuleRegistry.getEnforcing('NativePdfViewerModule') in the TS spec.
+ */
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+// ── Forward-declare Swift class ───────────────────────────────────────────────
+// Only declare the exact selectors used in this file; the linker resolves the
+// real Swift symbols at link time.  Adding new Swift methods requires adding
+// the corresponding declaration here.
+
+@interface PdfViewerTurboModuleImpl : NSObject
+
++ (BOOL)requiresMainQueueSetup;
+
+- (void)openViewerWithUri:(NSString *)uri
+                pageIndex:(double)pageIndex
+              defaultZoom:(double)defaultZoom
+       onFullScreenChange:(void (^)(BOOL))onFullScreenChange
+             onZoomChange:(void (^)(float))onZoomChange
+                onDismiss:(void (^)(void))onDismiss;
+
+- (void)dismissViewer;
+
+- (NSInteger)getPageCountWithUri:(NSString *)uri;
+
+- (NSDictionary * _Nullable)createPdfWithPages:(NSArray<NSDictionary *> *)pages
+                                        widthPx:(double)widthPx
+                                       heightPx:(double)heightPx;
+
+@end
+
+// ── RCT_NEW_ARCH_ENABLED guard ────────────────────────────────────────────────
+// Allows the same file to compile for both old and new architecture.
+// RN 0.74+ enables new arch by default; the guard keeps migration safe.
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <PdfViewerSpecs/PdfViewerSpecs.h>
+
+@interface PdfViewerTurboModule : RCTEventEmitter <NativePdfViewerModuleSpec>
+@end
+
+#else
+
+@interface PdfViewerTurboModule : RCTEventEmitter <RCTBridgeModule>
+@end
+
+#endif
+
+// ── Implementation ────────────────────────────────────────────────────────────
+
+@implementation PdfViewerTurboModule {
+    PdfViewerTurboModuleImpl *_impl;
+}
+
+RCT_EXPORT_MODULE(NativePdfViewerModule)
+
+- (instancetype)init {
+    if (self = [super init]) {
+        _impl = [[PdfViewerTurboModuleImpl alloc] init];
+    }
+    return self;
+}
+
++ (BOOL)requiresMainQueueSetup { return NO; }
+
+// Events emitted to JS (matches usePdfViewer.ts subscriptions)
+- (NSArray<NSString *> *)supportedEvents {
+    return @[
+        @"PdfFullScreenChanged",
+        @"PdfZoomChanged",
+        @"PdfViewerDismissed",
+        @"PdfViewerError",
+    ];
+}
+
+// ── openPdfViewer ─────────────────────────────────────────────────────────────
+// Dispatches to the main thread; Swift impl presents PdfViewerViewController.
+
+RCT_EXPORT_METHOD(openPdfViewer:(NSString *)uri
+                  pageIndex:(double)pageIndex
+                  defaultZoom:(double)defaultZoom)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self->_impl openViewerWithUri:uri
+                             pageIndex:pageIndex
+                           defaultZoom:defaultZoom
+                    onFullScreenChange:^(BOOL isFS) {
+            [self sendEventWithName:@"PdfFullScreenChanged"
+                              body:@{@"isFullScreen": @(isFS)}];
+        }
+                          onZoomChange:^(float zoom) {
+            [self sendEventWithName:@"PdfZoomChanged"
+                              body:@{@"zoomPercentage": @(zoom)}];
+        }
+                             onDismiss:^{
+            [self sendEventWithName:@"PdfViewerDismissed" body:@{}];
+        }];
+    });
+}
+
+// ── dismissPdfViewer ──────────────────────────────────────────────────────────
+
+RCT_EXPORT_METHOD(dismissPdfViewer)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [self->_impl dismissViewer];
+    });
+}
+
+// ── getPdfPageCount ───────────────────────────────────────────────────────────
+// File I/O happens on a background queue; promise is resolved/rejected there.
+
+RCT_EXPORT_METHOD(getPdfPageCount:(NSString *)uri
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+        NSInteger count = [self->_impl getPageCountWithUri:uri];
+        if (count > 0) {
+            resolve(@(count));
+        } else {
+            reject(@"PDF_ERROR", @"Could not open PDF or file has 0 pages", nil);
+        }
+    });
+}
+
+// ── createMultiPagePdfBase64 ──────────────────────────────────────────────────
+// PDF generation is CPU-bound; run on a background queue.
+
+RCT_EXPORT_METHOD(createMultiPagePdfBase64:(NSArray<NSDictionary *> *)pages
+                  widthPx:(double)widthPx
+                  heightPx:(double)heightPx
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+        NSDictionary *result = [self->_impl createPdfWithPages:pages
+                                                       widthPx:widthPx
+                                                      heightPx:heightPx];
+        if (result) {
+            resolve(result);
+        } else {
+            reject(@"PDF_CREATE_ERROR", @"Failed to generate PDF", nil);
+        }
+    });
+}
+
+// ── New Architecture JSI bridge ───────────────────────────────────────────────
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativePdfViewerModuleSpecJSI>(params);
+}
+#endif
+
+@end

package/ios/PdfViewerTurboModuleImpl.swift

@@ -0,0 +1,141 @@
+import UIKit
+
+/// Pure Swift business logic for the PDF viewer TurboModule.
+///
+/// The ObjC++ bridge (PdfViewerTurboModule.mm) forward-declares this class
+/// and calls into it.  All @objc annotations use explicit ObjC selector names
+/// to guarantee the bridge calls the correct method regardless of Swift's
+/// automatic ObjC name generation rules.
+///
+/// Threading contract:
+///   - openViewer / dismissViewer must be called on the MAIN thread by the bridge.
+///   - getPageCount / createPdf are synchronous and must be called on a
+///     BACKGROUND thread by the bridge, which wraps them in promise blocks.
+@objc(PdfViewerTurboModuleImpl)
+final class PdfViewerTurboModuleImpl: NSObject {
+
+    // Weak reference so ARC cleans up when the user dismisses
+    private weak var visibleVC: PdfViewerViewController?
+
+    @objc static func requiresMainQueueSetup() -> Bool { false }
+
+    // MARK: - openViewer (main thread)
+
+    /// Present PdfViewerViewController over the current key window root VC.
+    /// Selector: openViewerWithUri:pageIndex:defaultZoom:onFullScreenChange:onZoomChange:onDismiss:
+    @objc(openViewerWithUri:pageIndex:defaultZoom:onFullScreenChange:onZoomChange:onDismiss:)
+    func openViewer(
+        uri: String,
+        pageIndex: Double,
+        defaultZoom: Double,
+        onFullScreenChange: @escaping (Bool) -> Void,
+        onZoomChange: @escaping (Float) -> Void,
+        onDismiss: @escaping () -> Void
+    ) {
+        guard let presenter = topPresentedViewController() else { return }
+
+        let vc = PdfViewerViewController.make(
+            uri:         uri,
+            pageIndex:   Int(pageIndex),
+            defaultZoom: Float(defaultZoom)
+        )
+        vc.onFullScreenChange = { fs   in onFullScreenChange(fs) }
+        vc.onZoomChange       = { pct  in onZoomChange(pct) }
+        vc.onDismiss          = { onDismiss() }
+        vc.modalPresentationStyle = .overFullScreen
+
+        presenter.present(vc, animated: true)
+        visibleVC = vc
+    }
+
+    // MARK: - dismissViewer (main thread)
+
+    /// Selector: dismissViewer
+    @objc(dismissViewer)
+    func dismissViewer() {
+        visibleVC?.dismiss(animated: true)
+    }
+
+    // MARK: - getPageCount (background thread, synchronous)
+
+    /// Returns page count for the given URI.
+    /// Selector: getPageCountWithUri:
+    @objc(getPageCountWithUri:)
+    func getPageCount(uri: String) -> Int {
+        PdfRenderingLogic.pageCount(uri: uri)
+    }
+
+    // MARK: - createPdf (background thread, synchronous)
+
+    /// Renders structured pages into a PDF and returns base64 + temp file path.
+    /// Returns nil on failure (caller should reject the promise).
+    /// Selector: createPdfWithPages:widthPx:heightPx:
+    @objc(createPdfWithPages:widthPx:heightPx:)
+    func createPdf(
+        pages: [[String: Any]],
+        widthPx: Double,
+        heightPx: Double
+    ) -> [String: Any]? {
+        let pageSize = CGSize(width: widthPx, height: heightPx)
+        let data     = NSMutableData()
+
+        UIGraphicsBeginPDFContextToData(data, CGRect(origin: .zero, size: pageSize), nil)
+
+        for page in pages {
+            let title = page["title"] as? String ?? ""
+            let body  = page["body"]  as? String ?? ""
+
+            UIGraphicsBeginPDFPage()
+            guard let ctx = UIGraphicsGetCurrentContext() else { continue }
+
+            // White background
+            ctx.setFillColor(UIColor.white.cgColor)
+            ctx.fill(CGRect(origin: .zero, size: pageSize))
+
+            // Title
+            let titleAttrs: [NSAttributedString.Key: Any] = [
+                .font:            UIFont.boldSystemFont(ofSize: 24),
+                .foregroundColor: UIColor.black,
+            ]
+            title.draw(at: CGPoint(x: 40, y: 40), withAttributes: titleAttrs)
+
+            // Body
+            let bodyAttrs: [NSAttributedString.Key: Any] = [
+                .font:            UIFont.systemFont(ofSize: 16),
+                .foregroundColor: UIColor.darkGray,
+            ]
+            let bodyRect = CGRect(x: 40, y: 90, width: pageSize.width - 80, height: pageSize.height - 130)
+            body.draw(in: bodyRect, withAttributes: bodyAttrs)
+        }
+
+        UIGraphicsEndPDFContext()
+
+        let base64   = data.base64EncodedString(options: [])
+        let filename = "generated_\(Int(Date().timeIntervalSince1970)).pdf"
+        let tempURL  = FileManager.default.temporaryDirectory.appendingPathComponent(filename)
+
+        do {
+            try data.write(to: tempURL, options: .atomic)
+            return ["base64": base64, "path": tempURL.path]
+        } catch {
+            return nil
+        }
+    }
+
+    // MARK: - Helpers
+
+    /// Walks the presentation chain to find the topmost presented VC.
+    private func topPresentedViewController() -> UIViewController? {
+        guard let scene = UIApplication.shared.connectedScenes
+            .compactMap({ $0 as? UIWindowScene })
+            .first,
+              let root = scene.windows.first(where: \.isKeyWindow)?.rootViewController
+        else { return nil }
+
+        var top = root
+        while let presented = top.presentedViewController {
+            top = presented
+        }
+        return top
+    }
+}

package/ios/PdfViewerView.swift

@@ -0,0 +1,268 @@
+import UIKit
+
+// MARK: - Delegate (used by PdfViewerViewController)
+
+@objc protocol PdfViewerViewDelegate: AnyObject {
+    @objc optional func pdfViewerView(_ view: PdfViewerView, didChangeFullScreen isFullScreen: Bool)
+    @objc optional func pdfViewerView(_ view: PdfViewerView, didChangeZoom zoomPercentage: Float)
+    @objc optional func pdfViewerViewDidRequestDismiss(_ view: PdfViewerView)
+    @objc optional func pdfViewerView(_ view: PdfViewerView, didChangeToRightScreen isRight: Bool)
+}
+
+// MARK: - PdfViewerView
+
+/// Main PDF rendering view.
+///
+/// Equivalent to ComposeRenderer.kt on Android.
+/// Hosts a UIScrollView with pinch-to-zoom, a vertical stack of PdfPageViews,
+/// and a PdfToolbarView.  All page rendering is performed on background threads.
+///
+/// The @objc block callbacks (`onFullScreenChangeBlock`, etc.) are used by the
+/// Fabric ViewManager (PdfViewerComponentView.mm) to dispatch events to JS.
+/// The delegate protocol is used by PdfViewerViewController for VC-level handling.
+@objc(PdfViewerView)
+final class PdfViewerView: UIView {
+
+    // MARK: - @objc props (read by Fabric ObjC++ bridge via forward declaration)
+
+    @objc var pdfUri: String? {
+        didSet { guard pdfUri != oldValue else { return }; reloadDocument() }
+    }
+
+    @objc var initialPageIndex: Int = 0 {
+        didSet { if document != nil { scrollToPage(initialPageIndex) } }
+    }
+
+    @objc var defaultZoom: CGFloat = PdfConstants.defaultZoom {
+        didSet { scrollView.zoomScale = defaultZoom }
+    }
+
+    @objc var isFullScreen: Bool = false {
+        didSet {
+            toolbar.isHidden = isFullScreen
+            toolbarHeightConstraint?.constant = isFullScreen ? 0 : PdfConstants.toolbarHeight
+            UIView.animate(withDuration: 0.2) { self.layoutIfNeeded() }
+        }
+    }
+
+    @objc var headerText: String? {
+        didSet { toolbar.headerText = headerText }
+    }
+
+    @objc var backButtonText: String? {
+        didSet { toolbar.backButtonText = backButtonText }
+    }
+
+    // MARK: - @objc block callbacks (wired by Fabric manager and ViewController)
+
+    @objc var onFullScreenChangeBlock: ((Bool) -> Void)?
+    @objc var onZoomChangeBlock: ((Float) -> Void)?
+    @objc var onLeftScreenChangeBlock: ((Bool) -> Void)?
+    @objc var onRightScreenChangeBlock: ((Bool) -> Void)?
+
+    // MARK: - Delegate (optional, for ViewController usage)
+
+    @objc weak var delegate: PdfViewerViewDelegate?
+
+    // MARK: - Private state
+
+    private var document:   CGPDFDocument?
+    private var pageViews:  [PdfPageView] = []
+
+    private let scrollView   = UIScrollView()
+    private let pageStack    = UIStackView()
+    private let toolbar      = PdfToolbarView()
+    private var toolbarHeightConstraint: NSLayoutConstraint?
+
+    // MARK: - Init
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupUI()
+    }
+
+    required init?(coder: NSCoder) { fatalError("Use init(frame:)") }
+
+    // MARK: - Layout
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        // Rebuild pages when first laid out with a real size
+        if !pageViews.isEmpty { return }
+        if document != nil { buildPageViews() }
+    }
+
+    // MARK: - UI Setup
+
+    private func setupUI() {
+        backgroundColor = .white
+
+        // ── Toolbar ──────────────────────────────────────────────────────
+        toolbar.delegate = self
+        toolbar.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(toolbar)
+
+        let toolbarH = toolbar.heightAnchor.constraint(equalToConstant: PdfConstants.toolbarHeight)
+        toolbarHeightConstraint = toolbarH
+
+        // ── ScrollView ───────────────────────────────────────────────────
+        scrollView.delegate                           = self
+        scrollView.minimumZoomScale                   = PdfConstants.minZoom
+        scrollView.maximumZoomScale                   = PdfConstants.maxZoom
+        scrollView.showsVerticalScrollIndicator       = true
+        scrollView.showsHorizontalScrollIndicator     = false
+        scrollView.contentInsetAdjustmentBehavior     = .never
+        scrollView.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(scrollView)
+
+        // ── Page stack ───────────────────────────────────────────────────
+        pageStack.axis      = .vertical
+        pageStack.spacing   = PdfConstants.pageSpacing
+        pageStack.alignment = .center
+        pageStack.translatesAutoresizingMaskIntoConstraints = false
+        scrollView.addSubview(pageStack)
+
+        // ── Constraints ──────────────────────────────────────────────────
+        NSLayoutConstraint.activate([
+            scrollView.topAnchor.constraint(equalTo: topAnchor),
+            scrollView.leadingAnchor.constraint(equalTo: leadingAnchor),
+            scrollView.trailingAnchor.constraint(equalTo: trailingAnchor),
+            scrollView.bottomAnchor.constraint(equalTo: toolbar.topAnchor),
+
+            toolbar.leadingAnchor.constraint(equalTo: leadingAnchor),
+            toolbar.trailingAnchor.constraint(equalTo: trailingAnchor),
+            toolbar.bottomAnchor.constraint(equalTo: safeAreaLayoutGuide.bottomAnchor),
+            toolbarH,
+
+            pageStack.topAnchor.constraint(equalTo: scrollView.contentLayoutGuide.topAnchor, constant: 16),
+            pageStack.leadingAnchor.constraint(equalTo: scrollView.contentLayoutGuide.leadingAnchor),
+            pageStack.trailingAnchor.constraint(equalTo: scrollView.contentLayoutGuide.trailingAnchor),
+            pageStack.bottomAnchor.constraint(equalTo: scrollView.contentLayoutGuide.bottomAnchor, constant: -16),
+            // The stack width is pinned to the scroll view's frame (not content) width,
+            // so horizontal overflow is impossible — only vertical scrolling occurs.
+            pageStack.widthAnchor.constraint(equalTo: scrollView.frameLayoutGuide.widthAnchor),
+        ])
+    }
+
+    // MARK: - Document loading
+
+    private func reloadDocument() {
+        cancelAllPageLoads()
+        pageViews.removeAll()
+        pageStack.arrangedSubviews.forEach { $0.removeFromSuperview() }
+        document = nil
+
+        guard let uri = pdfUri, !uri.isEmpty else { return }
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            let doc = PdfRenderingLogic.openDocument(uri: uri)
+            DispatchQueue.main.async { [weak self] in
+                guard let self, let doc else { return }
+                self.document = doc
+                // Only build page views once we have a real layout size.
+                // layoutSubviews will trigger buildPageViews if bounds == .zero here.
+                if self.bounds.width > 0 {
+                    self.buildPageViews()
+                }
+            }
+        }
+    }
+
+    private func buildPageViews() {
+        guard let document else { return }
+
+        let containerWidth = bounds.width > 0 ? bounds.width : UIScreen.main.bounds.width
+        let pageWidth      = containerWidth - PdfConstants.pageHorizontalPadding * 2
+
+        for i in 0..<document.numberOfPages {
+            let pageView     = PdfPageView()
+            pageView.pageIndex = i
+            let ratio        = PdfRenderingLogic.pageAspectRatio(document: document, pageIndex: i)
+            let pageHeight   = ratio > 0 ? pageWidth / ratio : pageWidth * 1.414
+
+            pageView.translatesAutoresizingMaskIntoConstraints = false
+            pageStack.addArrangedSubview(pageView)
+            NSLayoutConstraint.activate([
+                pageView.widthAnchor.constraint(equalToConstant: pageWidth),
+                pageView.heightAnchor.constraint(equalToConstant: pageHeight),
+            ])
+            pageViews.append(pageView)
+        }
+
+        renderVisiblePages()
+        scrollToPage(initialPageIndex)
+        scrollView.zoomScale = defaultZoom
+    }
+
+    // MARK: - Rendering
+
+    private func renderVisiblePages() {
+        guard let document else { return }
+        let targetWidth = bounds.width > 0 ? bounds.width : UIScreen.main.bounds.width
+        pageViews.forEach { $0.load(document: document, targetWidth: targetWidth) }
+    }
+
+    private func cancelAllPageLoads() {
+        pageViews.forEach { $0.cancelLoad() }
+    }
+
+    // MARK: - Scroll
+
+    func scrollToPage(_ index: Int) {
+        guard index >= 0, index < pageViews.count else { return }
+        let pv    = pageViews[index]
+        let frame = pv.convert(pv.bounds, to: scrollView)
+        scrollView.scrollRectToVisible(frame, animated: false)
+    }
+}
+
+// MARK: - UIScrollViewDelegate
+
+extension PdfViewerView: UIScrollViewDelegate {
+
+    func viewForZooming(in scrollView: UIScrollView) -> UIView? {
+        pageStack
+    }
+
+    func scrollViewDidZoom(_ scrollView: UIScrollView) {
+        let pct = Float(scrollView.zoomScale * 100)
+        onZoomChangeBlock?(pct)
+        delegate?.pdfViewerView?(self, didChangeZoom: pct)
+    }
+
+    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
+        renderVisiblePages()
+    }
+
+    func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
+        if !decelerate { renderVisiblePages() }
+    }
+}
+
+// MARK: - PdfToolbarViewDelegate
+
+extension PdfViewerView: PdfToolbarViewDelegate {
+
+    func toolbarDidTapBack(_ toolbar: PdfToolbarView) {
+        onLeftScreenChangeBlock?(true)
+        delegate?.pdfViewerViewDidRequestDismiss?(self)
+    }
+
+    func toolbarDidTapZoomIn(_ toolbar: PdfToolbarView) {
+        let next = min(scrollView.zoomScale * PdfConstants.zoomStep, PdfConstants.maxZoom)
+        scrollView.setZoomScale(next, animated: true)
+    }
+
+    func toolbarDidTapZoomOut(_ toolbar: PdfToolbarView) {
+        let next = max(scrollView.zoomScale / PdfConstants.zoomStep, PdfConstants.minZoom)
+        scrollView.setZoomScale(next, animated: true)
+    }
+
+    func toolbarDidTapFullScreen(_ toolbar: PdfToolbarView) {
+        let next = !isFullScreen
+        isFullScreen = next
+        toolbar.isFullScreen = next
+        onFullScreenChangeBlock?(next)
+        delegate?.pdfViewerView?(self, didChangeFullScreen: next)
+    }
+}