react-native-pdfrender 0.1.0

package/ios/PdfConstants.swift

@@ -0,0 +1,38 @@
+import UIKit
+
+// MARK: - Scroll direction
+
+enum PdfScrollDirection: String {
+    case vertical
+    case horizontal
+}
+
+// MARK: - Shared constants
+
+enum PdfConstants {
+    /// Minimum allowed zoom scale (50%)
+    static let minZoom: CGFloat = 0.5
+    /// Maximum allowed zoom scale (500%)
+    static let maxZoom: CGFloat = 5.0
+    /// Default initial zoom (150%)
+    static let defaultZoom: CGFloat = 1.5
+    /// Vertical gap between consecutive pages
+    static let pageSpacing: CGFloat = 12.0
+    /// Horizontal padding around each page
+    static let pageHorizontalPadding: CGFloat = 16.0
+    /// Multiplier applied to target width before rendering.
+    /// Retina screen (2×) × 1.5 = 3× physical pixels → crisp at maximum zoom.
+    static let renderScale: CGFloat = UIScreen.main.scale * 1.5
+    /// Max number of page images kept in NSCache
+    static let cacheCountLimit = 20
+    /// Max total bytes in NSCache (50 MB)
+    static let cacheTotalCostLimit = 50 * 1024 * 1024
+    /// Fixed height of the toolbar
+    static let toolbarHeight: CGFloat = 52.0
+    /// Corner radius applied to each page card
+    static let cornerRadius: CGFloat = 4.0
+    /// Drop-shadow opacity on each page card
+    static let pageShadowOpacity: Float = 0.15
+    /// Step factor for each tap of + / – zoom button
+    static let zoomStep: CGFloat = 1.25
+}

package/ios/PdfPageView.swift

@@ -0,0 +1,121 @@
+import UIKit
+
+/// UIView that displays a single rendered PDF page.
+///
+/// Rendering is always performed on a background queue; the result is
+/// cached in PdfCacheManager and applied on the main thread.
+/// Cancelling an in-flight render is safe — the DispatchWorkItem is
+/// checked for cancellation before the result is applied.
+final class PdfPageView: UIView {
+
+    // MARK: - Public
+
+    /// 0-based index of the page this view represents.
+    var pageIndex: Int = 0
+
+    // MARK: - Private
+
+    private let imageView    = UIImageView()
+    private let spinner      = UIActivityIndicatorView(style: .medium)
+    private var renderTask: DispatchWorkItem?
+
+    // MARK: - Init
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setup()
+    }
+
+    required init?(coder: NSCoder) { fatalError("Use init(frame:)") }
+
+    // MARK: - Setup
+
+    private func setup() {
+        backgroundColor = .white
+        clipsToBounds = true
+
+        imageView.contentMode = .scaleAspectFit
+        imageView.backgroundColor = .white
+        imageView.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(imageView)
+
+        spinner.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(spinner)
+
+        NSLayoutConstraint.activate([
+            imageView.leadingAnchor.constraint(equalTo: leadingAnchor),
+            imageView.trailingAnchor.constraint(equalTo: trailingAnchor),
+            imageView.topAnchor.constraint(equalTo: topAnchor),
+            imageView.bottomAnchor.constraint(equalTo: bottomAnchor),
+
+            spinner.centerXAnchor.constraint(equalTo: centerXAnchor),
+            spinner.centerYAnchor.constraint(equalTo: centerYAnchor),
+        ])
+        spinner.startAnimating()
+    }
+
+    // MARK: - Loading
+
+    /// Loads and renders the page at `pageIndex` using `document`.
+    ///
+    /// - Parameters:
+    ///   - document:    An open CGPDFDocument (kept alive by the caller).
+    ///   - targetWidth: Logical width of the container; rendering happens
+    ///                  at `targetWidth × PdfConstants.renderScale` for retina.
+    func load(document: CGPDFDocument, targetWidth: CGFloat) {
+        let cacheKey = PdfCacheManager.key(pageIndex: pageIndex, targetWidth: targetWidth)
+
+        // Serve from cache immediately if available
+        if let cached = PdfCacheManager.shared.image(forKey: cacheKey) {
+            imageView.image = cached
+            spinner.stopAnimating()
+            return
+        }
+
+        // Cancel any previous render for this view
+        renderTask?.cancel()
+        renderTask = nil
+
+        // Capture locals so the closure doesn't hold self strongly during rendering
+        let idx          = pageIndex
+        let renderWidth  = targetWidth * PdfConstants.renderScale
+
+        var item: DispatchWorkItem!
+        item = DispatchWorkItem { [weak self] in
+            guard !item.isCancelled else { return }
+
+            let image = PdfRenderingLogic.renderPage(
+                document: document,
+                pageIndex: idx,
+                targetWidth: renderWidth
+            )
+
+            if let image {
+                PdfCacheManager.shared.setImage(image, forKey: cacheKey)
+            }
+
+            DispatchQueue.main.async { [weak self] in
+                guard let self, !item.isCancelled else { return }
+                self.imageView.image = image
+                self.spinner.stopAnimating()
+            }
+        }
+
+        renderTask = item
+        DispatchQueue.global(qos: .userInitiated).async(execute: item)
+    }
+
+    /// Cancels any in-flight render task.
+    func cancelLoad() {
+        renderTask?.cancel()
+        renderTask = nil
+    }
+
+    // MARK: - Reuse
+
+    func prepareForReuse() {
+        cancelLoad()
+        imageView.image = nil
+        spinner.startAnimating()
+    }
+}

package/ios/PdfRenderingLogic.swift

@@ -0,0 +1,107 @@
+import UIKit
+import CoreGraphics
+
+/// Stateless PDF rendering utilities using CoreGraphics (CGPDFDocument).
+///
+/// All rendering methods are safe to call from a background thread.
+/// CGPDFDocument is thread-safe for concurrent reads once opened.
+///
+/// Why CoreGraphics instead of PDFKit?
+///   CGPDFDocument gives direct access to the page bitmap, letting us
+///   control output resolution (PdfConstants.renderScale) and feed the
+///   result into a custom UIScrollView.  PDFKit's PDFView is great for
+///   simple embed cases but harder to customise for split-view or
+///   controlled-zoom layouts.
+enum PdfRenderingLogic {
+
+    // MARK: - Document opening
+
+    /// Opens a CGPDFDocument from a file URL.
+    /// Returns nil if the URL is unreachable or the file is not a valid PDF.
+    static func openDocument(url: URL) -> CGPDFDocument? {
+        CGPDFDocument(url as CFURL)
+    }
+
+    /// Convenience: opens a document from a string that may be either a
+    /// file:// URI or a plain filesystem path.
+    static func openDocument(uri: String) -> CGPDFDocument? {
+        openDocument(url: fileURL(from: uri))
+    }
+
+    // MARK: - Page count
+
+    /// Synchronously returns total page count without rendering any content.
+    /// Safe to call from any thread.
+    static func pageCount(url: URL) -> Int {
+        CGPDFDocument(url as CFURL)?.numberOfPages ?? 0
+    }
+
+    static func pageCount(uri: String) -> Int {
+        pageCount(url: fileURL(from: uri))
+    }
+
+    // MARK: - Page rendering
+
+    /// Renders a single PDF page to a UIImage.
+    ///
+    /// - Parameters:
+    ///   - document:    Open CGPDFDocument.
+    ///   - pageIndex:   0-based page index.
+    ///   - targetWidth: Desired pixel width of the output image.
+    ///                  Pass `view.bounds.width * PdfConstants.renderScale`
+    ///                  for retina-quality output.
+    /// - Returns: Rendered UIImage, or nil if pageIndex is out of range.
+    static func renderPage(
+        document: CGPDFDocument,
+        pageIndex: Int,
+        targetWidth: CGFloat
+    ) -> UIImage? {
+        // CGPDFDocument is 1-based
+        guard
+            pageIndex >= 0,
+            pageIndex < document.numberOfPages,
+            let page = document.page(at: pageIndex + 1)
+        else { return nil }
+
+        let mediaBox = page.getBoxRect(.mediaBox)
+        guard mediaBox.width > 0 else { return nil }
+
+        let scale  = targetWidth / mediaBox.width
+        let size   = CGSize(width: targetWidth, height: mediaBox.height * scale)
+
+        let renderer = UIGraphicsImageRenderer(size: size)
+        return renderer.image { ctx in
+            let cgCtx = ctx.cgContext
+
+            // White background — PDFs may have transparent backgrounds
+            cgCtx.setFillColor(UIColor.white.cgColor)
+            cgCtx.fill(CGRect(origin: .zero, size: size))
+
+            // CGPDFPage origin is bottom-left; UIKit origin is top-left.
+            // Flip the coordinate system vertically before drawing.
+            cgCtx.translateBy(x: 0, y: size.height)
+            cgCtx.scaleBy(x: scale, y: -scale)
+            cgCtx.drawPDFPage(page)
+        }
+    }
+
+    // MARK: - Aspect ratio
+
+    /// Returns width/height aspect ratio for a given page (for layout).
+    /// Falls back to A4 ratio (0.707) if the page cannot be opened.
+    static func pageAspectRatio(document: CGPDFDocument, pageIndex: Int) -> CGFloat {
+        guard let page = document.page(at: pageIndex + 1) else { return 0.707 }
+        let box = page.getBoxRect(.mediaBox)
+        return box.height > 0 ? box.width / box.height : 0.707
+    }
+
+    // MARK: - URI helpers
+
+    /// Converts a string that is either a file:// URI or a plain path to URL.
+    static func fileURL(from uri: String) -> URL {
+        if uri.hasPrefix("file://") {
+            return URL(string: uri) ?? URL(fileURLWithPath: uri)
+        }
+        return URL(fileURLWithPath: uri)
+    }
+}

package/ios/PdfToolbarView.swift

@@ -0,0 +1,158 @@
+import UIKit
+
+// MARK: - Delegate
+
+protocol PdfToolbarViewDelegate: AnyObject {
+    func toolbarDidTapBack(_ toolbar: PdfToolbarView)
+    func toolbarDidTapZoomIn(_ toolbar: PdfToolbarView)
+    func toolbarDidTapZoomOut(_ toolbar: PdfToolbarView)
+    func toolbarDidTapFullScreen(_ toolbar: PdfToolbarView)
+}
+
+// MARK: - PdfToolbarView
+
+/// A fixed-height toolbar that mirrors the Android PdfViewerToolbar behaviour.
+///
+/// Layout (left → right):
+///   [← Back]  [spacer]  [Title]  [spacer]  [−] [+] [⛶]
+final class PdfToolbarView: UIView {
+
+    // MARK: Public
+
+    weak var delegate: PdfToolbarViewDelegate?
+
+    var isFullScreen: Bool = false {
+        didSet {
+            fullScreenButton.setTitle(isFullScreen ? "⊡" : "⛶", for: .normal)
+            fullScreenButton.backgroundColor = isFullScreen
+                ? UIColor(red: 1.0, green: 0.93, blue: 0.93, alpha: 1.0)
+                : UIColor(red: 0.93, green: 0.96, blue: 1.0, alpha: 1.0)
+        }
+    }
+
+    var headerText: String? {
+        didSet { titleLabel.text = headerText }
+    }
+
+    var backButtonText: String? {
+        didSet { backButton.setTitle(backButtonText ?? "Back", for: .normal) }
+    }
+
+    // Custom icon images (optional — falls back to text glyphs when nil)
+    var zoomInImage: UIImage?   { didSet { applyIcon(zoomInImage,   to: zoomInButton,   fallback: "+") } }
+    var zoomOutImage: UIImage?  { didSet { applyIcon(zoomOutImage,  to: zoomOutButton,  fallback: "−") } }
+    var fullScreenImage: UIImage? { didSet { applyIcon(fullScreenImage, to: fullScreenButton, fallback: "⛶") } }
+
+    // MARK: - Private UI
+
+    private let backButton       = UIButton(type: .system)
+    private let titleLabel       = UILabel()
+    private let zoomOutButton    = UIButton(type: .system)
+    private let zoomInButton     = UIButton(type: .system)
+    private let fullScreenButton = UIButton(type: .system)
+
+    // MARK: - Init
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setup()
+    }
+
+    required init?(coder: NSCoder) { fatalError("Use init(frame:)") }
+
+    // MARK: - Setup
+
+    private func setup() {
+        backgroundColor = .white
+
+        // Top border line instead of shadow
+        let separator = UIView()
+        separator.backgroundColor = UIColor(white: 0.88, alpha: 1)
+        separator.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(separator)
+        NSLayoutConstraint.activate([
+            separator.topAnchor.constraint(equalTo: topAnchor),
+            separator.leadingAnchor.constraint(equalTo: leadingAnchor),
+            separator.trailingAnchor.constraint(equalTo: trailingAnchor),
+            separator.heightAnchor.constraint(equalToConstant: 0.5),
+        ])
+
+        // Back button
+        backButton.setTitle("Back", for: .normal)
+        backButton.titleLabel?.font = .systemFont(ofSize: 15, weight: .medium)
+        backButton.setTitleColor(UIColor.systemBlue, for: .normal)
+        backButton.addTarget(self, action: #selector(backTapped), for: .touchUpInside)
+        backButton.setContentHuggingPriority(.required, for: .horizontal)
+
+        // Title
+        titleLabel.text          = ""
+        titleLabel.font          = .systemFont(ofSize: 17, weight: .semibold)
+        titleLabel.textColor     = UIColor(red: 0.10, green: 0.10, blue: 0.18, alpha: 1)
+        titleLabel.textAlignment = .center
+        titleLabel.setContentHuggingPriority(.defaultLow, for: .horizontal)
+
+        // Zoom out — styled icon button
+        styleIconButton(zoomOutButton, symbol: "−", fontSize: 26)
+        zoomOutButton.addTarget(self, action: #selector(zoomOutTapped), for: .touchUpInside)
+
+        // Zoom in — styled icon button
+        styleIconButton(zoomInButton, symbol: "+", fontSize: 26)
+        zoomInButton.addTarget(self, action: #selector(zoomInTapped), for: .touchUpInside)
+
+        // Full-screen toggle — styled icon button
+        styleIconButton(fullScreenButton, symbol: "⛶", fontSize: 22)
+        fullScreenButton.addTarget(self, action: #selector(fullScreenTapped), for: .touchUpInside)
+
+        let stack = UIStackView(arrangedSubviews: [
+            backButton,
+            UIView(),   // flexible spacer
+            titleLabel,
+            UIView(),   // flexible spacer
+            zoomOutButton,
+            zoomInButton,
+            fullScreenButton,
+        ])
+        stack.axis      = .horizontal
+        stack.spacing   = 12
+        stack.alignment = .center
+        stack.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(stack)
+
+        NSLayoutConstraint.activate([
+            stack.leadingAnchor.constraint(equalTo: leadingAnchor, constant: 16),
+            stack.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -16),
+            stack.topAnchor.constraint(equalTo: topAnchor, constant: 4),
+            stack.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -4),
+        ])
+    }
+
+    private func styleIconButton(_ button: UIButton, symbol: String, fontSize: CGFloat) {
+        button.setTitle(symbol, for: .normal)
+        button.titleLabel?.font = .systemFont(ofSize: fontSize, weight: .medium)
+        button.setTitleColor(.systemBlue, for: .normal)
+        button.setTitleColor(UIColor.systemBlue.withAlphaComponent(0.4), for: .disabled)
+        button.backgroundColor = UIColor(red: 0.93, green: 0.96, blue: 1.0, alpha: 1.0)
+        button.layer.cornerRadius = 8
+        button.contentEdgeInsets = UIEdgeInsets(top: 6, left: 10, bottom: 6, right: 10)
+        button.setContentHuggingPriority(.required, for: .horizontal)
+    }
+
+    // MARK: - Icon helpers
+
+    private func applyIcon(_ image: UIImage?, to button: UIButton, fallback: String) {
+        if let image {
+            button.setImage(image.withRenderingMode(.alwaysTemplate), for: .normal)
+            button.setTitle(nil, for: .normal)
+        } else {
+            button.setImage(nil, for: .normal)
+            button.setTitle(fallback, for: .normal)
+        }
+    }
+
+    // MARK: - Actions
+
+    @objc private func backTapped()       { delegate?.toolbarDidTapBack(self) }
+    @objc private func zoomInTapped()    { delegate?.toolbarDidTapZoomIn(self) }
+    @objc private func zoomOutTapped()   { delegate?.toolbarDidTapZoomOut(self) }
+    @objc private func fullScreenTapped() { delegate?.toolbarDidTapFullScreen(self) }
+}

package/ios/PdfViewerComponentView.mm

@@ -0,0 +1,194 @@
+/**
+ * PdfViewerComponentView.mm — Fabric ViewManager for PdfViewerView.
+ *
+ * Architecture
+ * ────────────
+ *  Swift class  (PdfViewerView.swift)  ← all rendering logic
+ *  This ObjC++ file  ← Fabric integration layer
+ *    ├─ Hosts Swift PdfViewerView as contentView
+ *    ├─ Receives props from codegen-generated PdfViewerViewProps C++ struct
+ *    └─ Dispatches events via codegen-generated PdfViewerViewEventEmitter
+ *
+ * Codegen source: src/specs/NativePdfViewerComponent.ts
+ * Codegen output: build/generated/ios/PdfViewerSpecs/
+ *   ├─ ComponentDescriptors.h  (PdfViewerViewComponentDescriptor)
+ *   ├─ Props.h                 (PdfViewerViewProps)
+ *   ├─ EventEmitters.h         (PdfViewerViewEventEmitter)
+ *   └─ RCTComponentViewHelpers.h (RCTPdfViewerViewViewProtocol)
+ *
+ * Why RCTViewComponentView instead of RCTViewManager?
+ *   RCTViewManager is the old-arch pattern.  In Fabric, each component is a
+ *   self-contained RCTViewComponentView that receives C++ props directly via
+ *   JSI — no bridge serialization, no main-queue hopping for prop delivery.
+ *
+ * Guard: compiled only when New Architecture is enabled.
+ */
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+// ── Forward-declare Swift PdfViewerView ───────────────────────────────────────
+// Declare only the properties and block callbacks used in this translation unit.
+// The actual UIView subclass is resolved by the linker from PdfViewerView.swift.
+
+@interface PdfViewerView : UIView
+
+// Props
+@property (nonatomic, copy, nullable)   NSString *pdfUri;
+@property (nonatomic)                   NSInteger  initialPageIndex;
+@property (nonatomic)                   CGFloat    defaultZoom;
+@property (nonatomic)                   BOOL       isFullScreen;
+@property (nonatomic, copy, nullable)   NSString  *headerText;
+@property (nonatomic, copy, nullable)   NSString  *backButtonText;
+
+// Event callbacks (set by this manager; called by PdfViewerView when events fire)
+@property (nonatomic, copy, nullable) void (^onFullScreenChangeBlock)(BOOL);
+@property (nonatomic, copy, nullable) void (^onZoomChangeBlock)(float);
+@property (nonatomic, copy, nullable) void (^onLeftScreenChangeBlock)(BOOL);
+@property (nonatomic, copy, nullable) void (^onRightScreenChangeBlock)(BOOL);
+
+@end
+
+// ── Codegen-generated headers ─────────────────────────────────────────────────
+// Generated by `yarn ios` / `pod install` from src/specs/NativePdfViewerComponent.ts
+// The correct include path mirrors the ReactCodegen pod's directory layout:
+//   <react/renderer/components/<spec-name>/<header>.h>
+// This matches how react-native-safe-area-context and other Fabric components import them.
+
+#import <react/renderer/components/PdfViewerSpecs/ComponentDescriptors.h>
+#import <react/renderer/components/PdfViewerSpecs/EventEmitters.h>
+#import <react/renderer/components/PdfViewerSpecs/Props.h>
+#import <react/renderer/components/PdfViewerSpecs/RCTComponentViewHelpers.h>
+
+#import <React/RCTFabricComponentsPlugins.h>
+
+using namespace facebook::react;
+
+// ── PdfViewerComponentView ────────────────────────────────────────────────────
+
+@interface PdfViewerComponentView : RCTViewComponentView <RCTPdfViewerViewViewProtocol>
+@end
+
+@implementation PdfViewerComponentView {
+    PdfViewerView *_pdfView;
+}
+
+// ── Fabric registration ───────────────────────────────────────────────────────
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+    return concreteComponentDescriptorProvider<PdfViewerViewComponentDescriptor>();
+}
+
+// ── Initialisation ────────────────────────────────────────────────────────────
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    if (self = [super initWithFrame:frame]) {
+        _pdfView = [[PdfViewerView alloc] initWithFrame:frame];
+
+        __weak PdfViewerComponentView *weakSelf = self;
+
+        // Wire each Swift block to the Fabric event emitter.
+        // The event payload field names must match the TS spec interfaces.
+
+        _pdfView.onFullScreenChangeBlock = ^(BOOL isFS) {
+            auto strongSelf = weakSelf;
+            if (!strongSelf || !strongSelf->_eventEmitter) return;
+            auto emitter = std::dynamic_pointer_cast<const PdfViewerViewEventEmitter>(
+                strongSelf->_eventEmitter
+            );
+            if (emitter) {
+                emitter->onFullScreenChange(
+                    PdfViewerViewEventEmitter::OnFullScreenChange{.isFullScreen = (bool)isFS}
+                );
+            }
+        };
+
+        _pdfView.onZoomChangeBlock = ^(float zoom) {
+            auto strongSelf = weakSelf;
+            if (!strongSelf || !strongSelf->_eventEmitter) return;
+            auto emitter = std::dynamic_pointer_cast<const PdfViewerViewEventEmitter>(
+                strongSelf->_eventEmitter
+            );
+            if (emitter) {
+                emitter->onZoomChange(
+                    PdfViewerViewEventEmitter::OnZoomChange{.zoomPercentage = zoom}
+                );
+            }
+        };
+
+        _pdfView.onLeftScreenChangeBlock = ^(BOOL isLeft) {
+            auto strongSelf = weakSelf;
+            if (!strongSelf || !strongSelf->_eventEmitter) return;
+            auto emitter = std::dynamic_pointer_cast<const PdfViewerViewEventEmitter>(
+                strongSelf->_eventEmitter
+            );
+            if (emitter) {
+                emitter->onLeftScreenChange(
+                    PdfViewerViewEventEmitter::OnLeftScreenChange{.isLeftScreen = (bool)isLeft}
+                );
+            }
+        };
+
+        _pdfView.onRightScreenChangeBlock = ^(BOOL isRight) {
+            auto strongSelf = weakSelf;
+            if (!strongSelf || !strongSelf->_eventEmitter) return;
+            auto emitter = std::dynamic_pointer_cast<const PdfViewerViewEventEmitter>(
+                strongSelf->_eventEmitter
+            );
+            if (emitter) {
+                emitter->onRightScreenChange(
+                    PdfViewerViewEventEmitter::OnRightScreenChange{.isRightScreen = (bool)isRight}
+                );
+            }
+        };
+
+        self.contentView = _pdfView;
+    }
+    return self;
+}
+
+// ── Prop delivery (called by Fabric on every JS prop update) ──────────────────
+
+- (void)updateProps:(const Props::Shared &)props
+           oldProps:(const Props::Shared &)oldProps
+{
+    const auto &p = *std::static_pointer_cast<const PdfViewerViewProps>(props);
+
+    // pdfUri
+    if (!p.pdfUri.empty()) {
+        NSString *uri = [NSString stringWithUTF8String:p.pdfUri.c_str()];
+        if (![_pdfView.pdfUri isEqualToString:uri]) {
+            _pdfView.pdfUri = uri;
+        }
+    }
+
+    // Numeric / bool props
+    _pdfView.initialPageIndex = p.initialPageIndex;
+    _pdfView.defaultZoom      = (CGFloat)p.defaultZoom;
+    _pdfView.isFullScreen     = p.isFullScreen;
+
+    // Optional string props
+    if (!p.headerText.empty()) {
+        _pdfView.headerText = [NSString stringWithUTF8String:p.headerText.c_str()];
+    }
+    if (!p.backButtonText.empty()) {
+        _pdfView.backButtonText = [NSString stringWithUTF8String:p.backButtonText.c_str()];
+    }
+
+    [super updateProps:props oldProps:oldProps];
+}
+
+@end
+
+// ── Plugin registration ───────────────────────────────────────────────────────
+// Fabric uses this C function to look up the component view class by name.
+// The name "PdfViewerView" must match codegenNativeComponent('PdfViewerView')
+// in NativePdfViewerComponent.ts AND VIEW_NAME returned by the Android manager.
+
+Class<RCTComponentViewProtocol> PdfViewerViewCls(void) {
+    return PdfViewerComponentView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED