@kishannareshpal/expo-pdf 0.1.0

package/eslint.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['universe/native', 'universe/web'],
+  ignorePatterns: ['build'],
+};

package/expo-module.config.json

@@ -0,0 +1,16 @@
+{
+  "platforms": [
+    "apple",
+    "android"
+  ],
+  "apple": {
+    "modules": [
+      "KJExpoPdfModule"
+    ]
+  },
+  "android": {
+    "modules": [
+      "com.kishannareshpal.expopdf.KJExpoPdfModule"
+    ]
+  }
+}

package/ios/KJExpoPdf.podspec

@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'KJExpoPdf'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/kishannareshpal/expo-pdf' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/KJExpoPdfModule.swift

@@ -0,0 +1,51 @@
+import ExpoModulesCore
+
+public class KJExpoPdfModule: Module {
+  // Each module class must implement the definition function. The definition consists of components
+  // that describes the module's functionality and behavior.
+  // See https://docs.expo.dev/modules/module-api for more details about available components.
+  public func definition() -> ModuleDefinition {
+    // Sets the name of the module that JavaScript code will use to refer to the module. Takes a string as an argument.
+    // Can be inferred from module's class name, but it's recommended to set it explicitly for clarity.
+    // The module will be accessible from `requireNativeModule('ExpoPdf')` in JavaScript.
+    Name("KJExpoPdf")
+
+    // Enables the module to be used as a native view. Definition components that are accepted as part of the
+    // view definition: Prop, Events.
+    View(KJExpoPdfView.self) {
+      Events("onLoadComplete", "onPageChanged", "onError")
+
+      Prop("uri") { (view: KJExpoPdfView, uri: String) in
+        view.setUri(uri)
+      }
+
+      Prop("password") { (view: KJExpoPdfView, password: String?) in
+        view.setPassword(password)
+      }
+
+      Prop("pagingEnabled") { (view: KJExpoPdfView, enabled: Bool?) in
+        view.setPagingEnabled(enabled)
+      }
+
+      Prop("disableDoubleTapToZoom") { (view: KJExpoPdfView, disabled: Bool?) in
+        view.setDoubleTapZoomEnabled(disabled != true)
+      }
+
+      Prop("horizontal") { (view: KJExpoPdfView, enabled: Bool?) in
+        view.setHorizontalModeEnabled(enabled)
+      }
+
+      Prop("pageGap") { (view: KJExpoPdfView, gapPx: Int?) in
+        view.setPageGap(gapPx)
+      }
+
+      Prop("contentPadding") { (view: KJExpoPdfView, contentPadding: ContentPadding?) in
+        view.setContentPadding(contentPadding?.toEdgeInset())
+      }
+
+      Prop("fitMode") { (view: KJExpoPdfView, fitMode: FitMode?) in
+        view.setFitMode(fitMode)
+      }
+    }
+  }
+}

package/ios/KJExpoPdfView.swift

@@ -0,0 +1,242 @@
+import ExpoModulesCore
+import PDFKit
+import SwiftUI
+
+class KJExpoPdfView: ExpoView {
+  // MARK: - Defaults
+  static let DEFAULT_PAGING_ENABLED = false
+  static let DEFAULT_DOUBLE_TAP_ZOOM_ENABLED = true
+  static let DEFAULT_HORIZONTAL_MODE_ENABLED = false
+  static let DEFAULT_PAGE_GAP = 0
+  static let DEFAULT_CONTENT_PADDING = UIEdgeInsets.zero
+  static let DEFAULT_FIT_MODE = FitMode.both
+
+  let onLoadComplete = EventDispatcher()
+  let onPageChanged = EventDispatcher()
+  let onError = EventDispatcher()
+
+  enum ErrorCode: String, Codable {
+    case invalidUri = "invalid_uri"
+    case invalidDocument = "invalid_document"
+    case passwordRequired = "password_required"
+    case passwordIncorrect = "password_incorrect"
+  }
+
+  private let pdfView = PDFView()
+
+  private var documentURL: URL? = nil
+  private var password: String? = nil
+  private var isPagingEnabled: Bool = DEFAULT_PAGING_ENABLED
+  private var isDoubleTapZoomEnabled: Bool = DEFAULT_DOUBLE_TAP_ZOOM_ENABLED
+  private var isHorizontalModeEnabled: Bool = DEFAULT_HORIZONTAL_MODE_ENABLED
+  private var pageGap: Int = DEFAULT_PAGE_GAP
+  private var contentPadding: UIEdgeInsets = DEFAULT_CONTENT_PADDING
+  private var fitMode: FitMode = DEFAULT_FIT_MODE
+
+  required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+
+    clipsToBounds = true
+
+    // Set the primitive PdfView's content background to transparent so that it inherits
+    // the color from the React Native view (ExpoView), as defined by the
+    // style prop in the component (`style={{ backgroundColor: '#eee' }}`).
+    self.pdfView.backgroundColor = .clear
+
+    // We calculate the scaling manually via PDFView.scaleToFit(contentPadding:)
+    self.pdfView.autoScales = false
+
+    addSubview(pdfView)
+
+    setupListeners()
+  }
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    pdfView.frame = bounds
+
+    // Maintain insets on rotation, but don't reset reading position
+    self.pdfView.scaleToFit(
+      contentPadding: self.contentPadding, fitMode: self.fitMode, resetOffset: false)
+  }
+
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+
+  func setUri(_ uri: String) {
+    guard let parsedURL = URL(string: uri) else {
+      reportError(.invalidUri, "Invalid URI provided: \(uri)")
+      return
+    }
+
+    self.documentURL = parsedURL
+    self.reloadPdf()
+  }
+
+  func setPassword(_ password: String?) {
+    self.password = password
+
+    // Reload the PDF as it needs to perform the unlock attempt
+    // if password has been set, or lock if password's been removed
+    if self.pdfView.document?.isLocked == true {
+      self.reloadPdf()
+    }
+  }
+
+  func setPagingEnabled(_ enabled: Bool?) {
+    self.isPagingEnabled = enabled ?? Self.DEFAULT_PAGING_ENABLED
+    self.pdfView.displayMode = self.isPagingEnabled ? .singlePage : .singlePageContinuous
+  }
+
+  func setDoubleTapZoomEnabled(_ enabled: Bool?) {
+    self.isDoubleTapZoomEnabled = enabled ?? Self.DEFAULT_DOUBLE_TAP_ZOOM_ENABLED
+    self.pdfView.toggleDoubleTapToZoom(self.isDoubleTapZoomEnabled)
+  }
+
+  func setHorizontalModeEnabled(_ enabled: Bool?) {
+    self.isHorizontalModeEnabled = enabled ?? Self.DEFAULT_HORIZONTAL_MODE_ENABLED
+    self.pdfView.displayDirection = self.isHorizontalModeEnabled ? .horizontal : .vertical
+  }
+
+  func setPageGap(_ gap: Int?) {
+    self.pageGap = gap ?? Self.DEFAULT_PAGE_GAP
+    self.pdfView.pageBreakMargins = UIEdgeInsets(
+      top: 0,
+      left: 0,
+      bottom: isHorizontalModeEnabled ? 0 : CGFloat(pageGap),
+      right: isHorizontalModeEnabled ? CGFloat(pageGap) : 0
+    )
+
+    // PDFView pageBreakMargins not only apply insets between the pages, but also around the pages
+    // which is not what we always want - expo-pdf only uses pageBreakMargins for inter page spacing
+    // and we use our contentPadding for the spacing around the document.
+    // - Subtract the PDFView pageBreakMargins to prevent double spacing
+    var padding = self.contentPadding
+    let margins = self.pdfView.pageBreakMargins
+
+    padding = UIEdgeInsets(
+      top: padding.top - margins.top,
+      left: padding.left - margins.left,
+      bottom: padding.bottom - margins.bottom,
+      right: padding.right - margins.right
+    )
+    self.pdfView.scaleToFit(
+      contentPadding: self.contentPadding, fitMode: self.fitMode, resetOffset: false)
+  }
+
+  func setContentPadding(_ padding: UIEdgeInsets?) {
+    self.contentPadding = padding ?? Self.DEFAULT_CONTENT_PADDING
+
+    // PDFView pageBreakMargins not only apply insets between the pages, but also around the pages
+    // which is not what we always want - expo-pdf only uses pageBreakMargins for inter page spacing
+    // and we use our contentPadding for the spacing around the document.
+    // - Subtract the PDFView pageBreakMargins to prevent double spacing
+    var padding = self.contentPadding
+    let margins = self.pdfView.pageBreakMargins
+
+    padding = UIEdgeInsets(
+      top: padding.top - margins.top,
+      left: padding.left - margins.left,
+      bottom: padding.bottom - margins.bottom,
+      right: padding.right - margins.right
+    )
+    self.pdfView.scaleToFit(
+      contentPadding: self.contentPadding, fitMode: self.fitMode, resetOffset: false)
+  }
+
+  func setFitMode(_ mode: FitMode?) {
+    self.fitMode = mode ?? Self.DEFAULT_FIT_MODE
+
+    self.pdfView.scaleToFit(
+      contentPadding: self.contentPadding, fitMode: self.fitMode, resetOffset: false)
+  }
+
+  @objc private func handlePageChange() {
+    guard
+      let page = pdfView.currentPage,
+      let document = pdfView.document
+    else { return }
+
+    onPageChanged([
+      "pageIndex": document.index(for: page),
+      "pageCount": document.pageCount,
+    ])
+  }
+
+  private func reloadPdf() {
+    guard let document = self.loadDocument() else {
+      return
+    }
+
+    if document.isLocked {
+      if let password = self.password {
+        let unlocked = document.unlock(withPassword: password)
+        if !unlocked {
+          reportError(
+            .passwordIncorrect,
+            "The provided password was incorrect"
+          )
+        }
+      } else {
+        reportError(
+          .passwordRequired,
+          "PDF requires a password, but no password was provided"
+        )
+      }
+    }
+
+    self.pdfView.document = document
+
+    // Dispatch async to allow PDFView to finish its initial layout
+    DispatchQueue.main.async {
+      self.pdfView.scaleToFit(
+        contentPadding: self.contentPadding, fitMode: self.fitMode, resetOffset: true)
+    }
+
+    self.onLoadComplete([
+      "pageCount": document.pageCount
+    ])
+  }
+
+  private func loadDocument() -> PDFDocument? {
+    guard let documentURL else {
+      return nil
+    }
+
+    // TODO: Apple PDFView supports "http", "https" - but I've not implemented it on Android so for consistency I'm explicitly not allowing it here until then.
+    guard ["file"].contains(self.documentURL?.scheme?.lowercased()) else {
+      reportError(
+        .invalidUri,
+        "URL scheme '\(self.documentURL?.scheme ?? "unknown")' is not supported"
+      )
+      return nil
+    }
+
+    guard let document: PDFDocument = PDFDocument(url: documentURL) else {
+      self.reportError(
+        .invalidDocument,
+        "Failed to load the PDF document"
+      )
+      return nil
+    }
+
+    return document
+  }
+
+  private func setupListeners() {
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(handlePageChange),
+      name: .PDFViewPageChanged,
+      object: pdfView
+    )
+  }
+
+  private func reportError(_ code: ErrorCode, _ message: String) {
+    onError([
+      "code": code.rawValue,
+      "message": message,
+    ])
+  }
+}

package/ios/extensions/PdfViewExtensions.swift

@@ -0,0 +1,94 @@
+//
+//  PdfViewExtensions.swift
+//  Pods
+//
+//  Created by Kishan Jadav on 05/01/2026.
+//
+
+import PDFKit
+
+extension PDFView {
+  func scaleToFit(contentPadding: UIEdgeInsets, fitMode: FitMode, resetOffset: Bool = false) {
+    guard let page = self.currentPage else {
+      return
+    }
+    
+    let viewSize = self.bounds.size
+    let pageSize = page.bounds(for: self.displayBox).size
+    
+    // Ensure we have valid dimensions to avoid division by zero
+    guard viewSize.width > 0, pageSize.width > 0, pageSize.height > 0 else {
+      return
+    }
+    
+    // Calculate the available space (View size minus Padding)
+    let availableWidth = viewSize.width - contentPadding.left - contentPadding.right
+    let availableHeight = viewSize.height - contentPadding.top - contentPadding.bottom
+    
+    // Calculate potential scale factors
+    let widthScale = availableWidth / pageSize.width
+    let heightScale = availableHeight / pageSize.height
+    
+    // Determine the target scale based on the requested FitMode
+    let targetScale: CGFloat
+    switch fitMode {
+    case .width:
+      targetScale = widthScale
+    case .height:
+      targetScale = heightScale
+    case .both:
+      // "Aspect Fit": Choose the smaller scale to ensure the whole page is visible
+      targetScale = min(widthScale, heightScale)
+    }
+    
+    // Apply new scale factor
+    if abs(self.scaleFactor - targetScale) > 0.001 {
+      self.minScaleFactor = targetScale // Prevent zooming out further than the fit
+      self.scaleFactor = targetScale
+    }
+    
+    self.applyContentPadding(contentPadding, resetOffset: resetOffset)
+  }
+  
+  func applyContentPadding(_ contentPadding: UIEdgeInsets, resetOffset: Bool = false) {
+    // Iterate through the PDFView's subviews to find the scroll view
+    if let scrollView = self.subviews.first(where: { $0 is UIScrollView }) as? UIScrollView {
+      scrollView.contentInset = contentPadding
+
+      if resetOffset {
+        var offset = scrollView.contentOffset
+        if self.displayDirection == .horizontal {
+          offset.x = -contentPadding.left
+        } else {
+          offset.y = -contentPadding.top
+        }
+        scrollView.contentOffset = offset
+      }
+    }
+  }
+  
+  func toggleDoubleTapToZoom(_ enabled: Bool) {
+    // Iterate through the PDFView's subviews to find the scroll view
+    for subview in self.subviews {
+      if let gestureRecognizers = subview.gestureRecognizers {
+        for gesture in gestureRecognizers {
+          if let tapGesture = gesture as? UITapGestureRecognizer, tapGesture.numberOfTapsRequired == 2 {
+            // Disable the double-tap recognizer
+            tapGesture.isEnabled = enabled
+          }
+        }
+      }
+      
+      // Sometimes the gesture is deeper, so we check sub-subviews (like the document view)
+      for internalSubview in subview.subviews {
+        if let gestureRecognizers = internalSubview.gestureRecognizers {
+          for gesture in gestureRecognizers {
+            if let tapGesture = gesture as? UITapGestureRecognizer, tapGesture.numberOfTapsRequired == 2 {
+              tapGesture.isEnabled = enabled
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/ios/lib/ContentPadding.swift

@@ -0,0 +1,26 @@
+//
+//  ContentPadding.swift
+//  Pods
+//
+//  Created by Kishan Jadav on 05/01/2026.
+//
+
+import ExpoModulesCore
+
+struct ContentPadding: Record {
+  @Field
+  var left: Int = 0
+  
+  @Field
+  var top: Int = 0
+  
+  @Field
+  var right: Int = 0
+  
+  @Field
+  var bottom: Int = 0
+  
+  func toEdgeInset() -> UIEdgeInsets {
+    UIEdgeInsets(top: CGFloat(self.top), left: CGFloat(self.left), bottom: CGFloat(self.bottom), right: CGFloat(self.right))
+  }
+}

package/ios/lib/FitMode.swift

@@ -0,0 +1,14 @@
+//
+//  FitMode.swift
+//  Pods
+//
+//  Created by Kishan Jadav on 05/01/2026.
+//
+
+import ExpoModulesCore
+
+enum FitMode: String, Enumerable {
+  case width
+  case height
+  case both
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@kishannareshpal/expo-pdf",
+  "version": "0.1.0",
+  "description": "A cross-platform, performant PDF viewer component for React Native and Expo",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepare": "husky; expo-module prepare"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "@kishannareshpal/expo-pdf",
+    "rn-pdf",
+    "react-native-pdf",
+    "expo-pdf",
+    "pdf",
+    "expopdf"
+  ],
+  "repository": "https://github.com/kishannareshpal/expo-pdf",
+  "bugs": {
+    "url": "https://github.com/kishannareshpal/expo-pdf/issues"
+  },
+  "author": "Kishan Jadav <kishan_jadav@hotmail.com> (https://github.com/kishannareshpal)",
+  "license": "MIT",
+  "homepage": "https://github.com/kishannareshpal/expo-pdf#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "~19.1.0",
+    "expo": "^54.0.27",
+    "expo-module-scripts": "^5.0.8",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.7.4",
+    "react-native": "0.81.5"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx,json,css,md,yml,yaml}": [
+      "prettier --write"
+    ],
+    "*.{java,kt,swift,h,m,mm}": [
+      "prettier --write"
+    ]
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+// Reexport the native module
+export { default } from './pdf-module';
+export { PdfView } from './pdf-view';
+export * from './types';

package/src/pdf-module.ts

@@ -0,0 +1,8 @@
+import { NativeModule, requireNativeModule } from 'expo';
+
+type PdfModuleEvents = {}
+
+declare class PdfModule extends NativeModule<PdfModuleEvents> { }
+
+// This call loads the native module object from the JSI.
+export default requireNativeModule<PdfModule>('KJExpoPdf');

package/src/pdf-view.tsx

@@ -0,0 +1,68 @@
+import { requireNativeView } from 'expo';
+import * as React from 'react';
+
+import { ContentPadding, FitMode, OnErrorEventPayload, OnLoadCompleteEventPayload, OnPageChangedEventPayload } from './types';
+import { NativeSyntheticEvent, StyleProp, StyleSheet, ViewStyle } from 'react-native';
+import { forwardNativeEventTo } from './utils';
+
+type BaseProps = {
+  style?: StyleProp<ViewStyle>;
+  /**
+   * The file URI. Accepts a remote resource (e.g. via HTTPs) or a local file path (e.g. file:///)
+   */
+  uri: string;
+  password?: string;
+  pagingEnabled?: boolean
+  disableDoubleTapToZoom?: boolean
+  horizontal?: boolean
+  pageGap?: number
+  contentPadding?: ContentPadding
+  fitMode?: FitMode
+}
+
+type NativePdfViewProps = BaseProps & {
+  onLoadComplete?: (event: NativeSyntheticEvent<OnLoadCompleteEventPayload>) => void;
+  onPageChanged?: (event: NativeSyntheticEvent<OnPageChangedEventPayload>) => void;
+  onError?: (event: NativeSyntheticEvent<OnErrorEventPayload>) => void;
+};
+
+const NativePdfView: React.ComponentType<NativePdfViewProps> = requireNativeView('KJExpoPdf');
+
+// -----------
+
+export type PdfViewProps = BaseProps & {
+  onLoadComplete?: (params: OnLoadCompleteEventPayload) => void,
+  onPageChanged?: (params: OnPageChangedEventPayload) => void,
+  onError?: (params: OnErrorEventPayload) => void
+};
+
+export const PdfView = ({
+  style,
+  onLoadComplete,
+  onError,
+  onPageChanged,
+  ...props
+}: PdfViewProps) => {
+  return (
+    <NativePdfView
+      style={[styles.container, style]}
+      uri={props.uri}
+      disableDoubleTapToZoom={props.disableDoubleTapToZoom}
+      horizontal={props.horizontal}
+      pageGap={props.pageGap}
+      pagingEnabled={props.pagingEnabled}
+      password={props.password}
+      contentPadding={props.contentPadding}
+      fitMode={props.fitMode}
+      onLoadComplete={forwardNativeEventTo(onLoadComplete)}
+      onPageChanged={forwardNativeEventTo(onPageChanged)}
+      onError={forwardNativeEventTo(onError)}
+    />
+  )
+}
+
+const styles = StyleSheet.create({
+  container: {
+    backgroundColor: '#eeeeee'
+  }
+})

package/src/types.ts

@@ -0,0 +1,16 @@
+export type OnLoadCompleteEventPayload = { pageCount: number }
+
+export type OnPageChangedEventPayload = { pageIndex: number, pageCount: number }
+
+export type ErrorCode = 'no_url' | 'invalid_url' | 'invalid_document'
+
+export type OnErrorEventPayload = { code: ErrorCode, message: string }
+
+export type ContentPadding = {
+  top?: number;
+  right?: number;
+  bottom?: number;
+  left?: number;
+}
+
+export type FitMode = 'width' | 'height' | 'both';

package/src/utils.ts

@@ -0,0 +1,12 @@
+import { NativeSyntheticEvent } from 'react-native';
+
+export const forwardNativeEventTo = <T,>(handler?: (payload: T) => void) => {
+    if (!handler) return undefined;
+
+    return (event: NativeSyntheticEvent<T>) => {
+        // Native event includes a "target" property that I think corresponds to the view tag, but this is not needed in my lib
+        delete (event.nativeEvent as any).target;
+
+        handler(event.nativeEvent);
+    };
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @generated by expo-module-scripts
+{
+  "extends": "expo-module-scripts/tsconfig.base",
+  "compilerOptions": {
+    "outDir": "./build"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*", "**/__rsc_tests__/*"]
+}