@june24/expo-pdf-reader 0.1.0

package/ios/ExpoPdfReaderView.swift

@@ -0,0 +1,675 @@
+import ExpoModulesCore
+import PDFKit
+
+class ExpoPdfReaderView: ExpoView {
+  let pdfView = PDFView()
+  var currentTool: String = "none"
+  var currentColor: UIColor = .black
+  var currentFontSize: CGFloat = 16.0
+  var currentText: String = "Text"
+  var currentStrokeWidth: CGFloat = 2.0
+  var initialPage: Int = 0
+  var minZoom: CGFloat = 1.0
+  var maxZoom: CGFloat = 4.0
+  
+  // Events
+  let onAnnotationChange = EventDispatcher()
+  let onPageChange = EventDispatcher()
+  let onScroll = EventDispatcher()
+  
+  // Gesture recognizers for drawing
+  private var panGesture: UIPanGestureRecognizer?
+  private var tapGesture: UITapGestureRecognizer?
+  private var currentAnnotation: PDFAnnotation?
+  private var currentPath: UIBezierPath?
+  
+  // Undo/Redo stacks
+  private var undoStack: [PDFAnnotation] = []
+  private var redoStack: [PDFAnnotation] = []
+
+  required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+    clipsToBounds = true
+    addSubview(pdfView)
+    
+    pdfView.autoScales = true
+    pdfView.displayMode = .singlePageContinuous
+    pdfView.displayDirection = .vertical
+    pdfView.minScaleFactor = minZoom
+    pdfView.maxScaleFactor = maxZoom
+    
+    // Setup gestures
+    panGesture = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))
+    tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap(_:)))
+    
+    // Initially disabled
+    panGesture?.isEnabled = false
+    tapGesture?.isEnabled = false
+    
+    pdfView.addGestureRecognizer(panGesture!)
+    pdfView.addGestureRecognizer(tapGesture!)
+    
+    // Listen for page changes
+    NotificationCenter.default.addObserver(self, selector: #selector(handlePageChange), name: .PDFViewPageChanged, object: pdfView)
+    
+    // Setup scroll observer
+    setupScrollObserver()
+  }
+  
+  private func setupScrollObserver() {
+    // Use KVO to observe scroll position changes
+    pdfView.addObserver(self, forKeyPath: "bounds", options: [.new, .old], context: nil)
+    
+    // Also observe content offset if available
+    if let scrollView = pdfView.subviews.first(where: { $0 is UIScrollView }) as? UIScrollView {
+      scrollView.addObserver(self, forKeyPath: "contentOffset", options: [.new], context: nil)
+    }
+  }
+  
+  override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
+    if keyPath == "bounds" || keyPath == "contentOffset" {
+      notifyScroll()
+    } else {
+      super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
+    }
+  }
+  
+  private func notifyScroll() {
+    let bounds = pdfView.bounds
+    let contentSize = pdfView.document?.bounds(for: .mediaBox).size ?? .zero
+    
+    // Get scroll position from PDFView
+    let visibleRect = pdfView.visiblePageRect
+    let scrollX = visibleRect.origin.x
+    let scrollY = visibleRect.origin.y
+    
+    onScroll([
+      "x": scrollX,
+      "y": scrollY,
+      "contentWidth": contentSize.width,
+      "contentHeight": contentSize.height,
+      "layoutWidth": bounds.width,
+      "layoutHeight": bounds.height
+    ])
+  }
+  
+  deinit {
+      NotificationCenter.default.removeObserver(self)
+      
+      // Remove KVO observers
+      pdfView.removeObserver(self, forKeyPath: "bounds")
+      if let scrollView = pdfView.subviews.first(where: { $0 is UIScrollView }) as? UIScrollView {
+        scrollView.removeObserver(self, forKeyPath: "contentOffset")
+      }
+  }
+
+  override func layoutSubviews() {
+    pdfView.frame = bounds
+  }
+
+  func load(url: URL) {
+    if url.scheme == "http" || url.scheme == "https" {
+      DispatchQueue.global().async {
+        if let data = try? Data(contentsOf: url), let document = PDFDocument(data: data) {
+          DispatchQueue.main.async {
+            self.pdfView.document = document
+            self.applyInitialPageIfNeeded()
+            self.notifyPageChange()
+          }
+        }
+      }
+    } else {
+      if let document = PDFDocument(url: url) {
+        pdfView.document = document
+        applyInitialPageIfNeeded()
+        notifyPageChange()
+      }
+    }
+  }
+  
+  @objc func handlePageChange() {
+      notifyPageChange()
+  }
+  
+  func notifyPageChange() {
+      guard let document = pdfView.document, let currentPage = pdfView.currentPage else { return }
+      let pageIndex = document.index(for: currentPage)
+      
+      onPageChange([
+          "page": pageIndex,
+          "total": document.pageCount
+      ])
+  }
+  
+  func setDisplayMode(_ mode: String) {
+    switch mode {
+    case "single":
+      pdfView.displayMode = .singlePage
+    case "continuous":
+      pdfView.displayMode = .singlePageContinuous
+    case "twoUp":
+      pdfView.displayMode = .twoUp
+    case "twoUpContinuous":
+      pdfView.displayMode = .twoUpContinuous
+    default:
+      pdfView.displayMode = .singlePageContinuous
+    }
+  }
+  
+  func setInitialPage(_ page: Int) {
+    self.initialPage = max(0, page)
+    applyInitialPageIfNeeded()
+  }
+  
+  private func applyInitialPageIfNeeded() {
+    guard let document = pdfView.document else { return }
+    let index = max(0, min(initialPage, document.pageCount - 1))
+    if let page = document.page(at: index) {
+      pdfView.go(to: page)
+    }
+  }
+  
+  func zoomIn() -> Bool {
+    guard pdfView.document != nil else { return false }
+    let newFactor = min(pdfView.scaleFactor * 1.25, maxZoom)
+    if newFactor == pdfView.scaleFactor { return false }
+    pdfView.scaleFactor = newFactor
+    return true
+  }
+  
+  func zoomOut() -> Bool {
+    guard pdfView.document != nil else { return false }
+    let newFactor = max(pdfView.scaleFactor / 1.25, minZoom)
+    if newFactor == pdfView.scaleFactor { return false }
+    pdfView.scaleFactor = newFactor
+    return true
+  }
+  
+  func setAnnotationTool(_ tool: String) {
+    self.currentTool = tool
+    
+    // Enable/disable gestures based on tool
+    let isDrawing = tool == "pen" || tool == "highlighter"
+    let isEraser = tool == "eraser"
+    panGesture?.isEnabled = isDrawing || isEraser
+    pdfView.isUserInteractionEnabled = !isDrawing && !isEraser // Disable PDF interaction when drawing/erasing to prevent scrolling
+    
+    // Re-enable scrolling if not drawing or erasing
+    if !isDrawing && !isEraser {
+        pdfView.isUserInteractionEnabled = true
+    }
+    
+    if tool == "text" || tool == "note" {
+        tapGesture?.isEnabled = true
+    } else {
+        tapGesture?.isEnabled = false
+    }
+  }
+
+  func setAnnotationColor(_ colorHex: String?) {
+      if let hex = colorHex {
+          self.currentColor = UIColor(hex: hex) ?? .black
+      }
+  }
+  
+  func setAnnotationFontSize(_ size: Double) {
+      self.currentFontSize = CGFloat(size)
+  }
+  
+  func setAnnotationText(_ text: String) {
+      self.currentText = text
+  }
+  
+  func setAnnotationStrokeWidth(_ width: Double) {
+      // Avoid zero / negative
+      let w = CGFloat(width)
+      self.currentStrokeWidth = w > 0 ? w : 1.0
+  }
+  
+  func setMinZoom(_ value: Double) {
+      let v = CGFloat(value)
+      minZoom = v > 0 ? v : 0.5
+      pdfView.minScaleFactor = minZoom
+      if pdfView.scaleFactor < minZoom {
+          pdfView.scaleFactor = minZoom
+      }
+  }
+  
+  func setMaxZoom(_ value: Double) {
+      let v = CGFloat(value)
+      maxZoom = v > minZoom ? v : minZoom
+      pdfView.maxScaleFactor = maxZoom
+      if pdfView.scaleFactor > maxZoom {
+          pdfView.scaleFactor = maxZoom
+      }
+  }
+  
+  func searchText(_ text: String) -> [[String: Any]] {
+      guard let document = pdfView.document else { return [] }
+      
+      let selections = document.findString(text, withOptions: .caseInsensitive)
+      var results: [[String: Any]] = []
+      
+      for selection in selections {
+          guard let page = selection.pages.first else { continue }
+          let pageIndex = document.index(for: page)
+          let bounds = selection.bounds(for: page)
+          
+          let highlight = PDFAnnotation(bounds: bounds, forType: .highlight, withProperties: nil)
+          highlight.color = .yellow.withAlphaComponent(0.5)
+          page.addAnnotation(highlight)
+          
+          results.append([
+              "page": pageIndex,
+              "x": bounds.origin.x,
+              "y": bounds.origin.y,
+              "width": bounds.size.width,
+              "height": bounds.size.height,
+              "textSnippet": selection.string ?? ""
+          ])
+      }
+      
+      return results
+  }
+  
+  func goToPage(_ pageIndex: Int) {
+      if let document = pdfView.document,
+         let page = document.page(at: pageIndex) {
+          pdfView.go(to: page)
+      }
+  }
+  
+  func undo() -> Bool {
+      guard let document = pdfView.document else { return false }
+      
+      // Find the last annotation across all pages
+      var lastAnnotation: PDFAnnotation?
+      var lastPage: PDFPage?
+      
+      for i in (0..<document.pageCount).reversed() {
+          guard let page = document.page(at: i) else { continue }
+          if let annotation = page.annotations.last {
+              lastAnnotation = annotation
+              lastPage = page
+              break
+          }
+      }
+      
+      guard let annotation = lastAnnotation, let page = lastPage else { return false }
+      
+      // Remove from page and add to undo stack
+      page.removeAnnotation(annotation)
+      undoStack.append(annotation)
+      redoStack.removeAll() // Clear redo when new undo is performed
+      
+      // Emit event
+      onAnnotationChange([
+        "annotations": getAnnotations()
+      ])
+      
+      return true
+  }
+  
+  func redo() -> Bool {
+      guard undoStack.isEmpty == false else { return false }
+      guard let document = pdfView.document else { return false }
+      
+      // Get the last undone annotation
+      let annotation = undoStack.removeLast()
+      
+      // Find which page it belongs to (we'll need to track this better in a real implementation)
+      // For now, try to add it to the current page
+      if let currentPage = pdfView.currentPage {
+          currentPage.addAnnotation(annotation)
+      } else if let firstPage = document.page(at: 0) {
+          firstPage.addAnnotation(annotation)
+      }
+      
+      // Emit event
+      onAnnotationChange([
+        "annotations": getAnnotations()
+      ])
+      
+      return true
+  }
+  
+  func renderThumbnail(pageIndex: Int, width: Double) throws -> String {
+      guard let document = pdfView.document else {
+          throw NSError(domain: "ExpoPdfReader", code: 3, userInfo: [NSLocalizedDescriptionKey: "No document loaded"])
+      }
+      guard let page = document.page(at: pageIndex) else {
+          throw NSError(domain: "ExpoPdfReader", code: 4, userInfo: [NSLocalizedDescriptionKey: "Invalid page index"])
+      }
+      
+      let pageRect = page.bounds(for: .mediaBox)
+      let targetWidth = CGFloat(width)
+      let scale = targetWidth / pageRect.width
+      let size = CGSize(width: targetWidth, height: pageRect.height * scale)
+      
+      let image = page.thumbnail(of: size, for: .mediaBox)
+      guard let data = image.pngData() else {
+          throw NSError(domain: "ExpoPdfReader", code: 5, userInfo: [NSLocalizedDescriptionKey: "Failed to create PNG data"])
+      }
+      
+      let fileName = "thumb_\(pageIndex)_\(Int(Date().timeIntervalSince1970)).png"
+      let url = FileManager.default.temporaryDirectory.appendingPathComponent(fileName)
+      try data.write(to: url)
+      return url.absoluteString
+  }
+  
+  func savePdf() throws -> String {
+      guard let document = pdfView.document else {
+          throw NSError(domain: "ExpoPdfReader", code: 1, userInfo: [NSLocalizedDescriptionKey: "No document loaded"])
+      }
+      
+      let fileName = "saved_pdf_\(Int(Date().timeIntervalSince1970)).pdf"
+      let fileManager = FileManager.default
+      let tempDir = fileManager.temporaryDirectory
+      let fileURL = tempDir.appendingPathComponent(fileName)
+      
+      if document.write(to: fileURL) {
+          return fileURL.absoluteString
+      } else {
+          throw NSError(domain: "ExpoPdfReader", code: 2, userInfo: [NSLocalizedDescriptionKey: "Failed to write PDF to file"])
+      }
+  }
+  
+  func getAnnotations() -> [[String: Any]] {
+      guard let document = pdfView.document else { return [] }
+      var annotationsData: [[String: Any]] = []
+      
+      for i in 0..<document.pageCount {
+          guard let page = document.page(at: i) else { continue }
+          for annotation in page.annotations {
+              if annotation.type == "Ink" {
+                  var points: [[String: Double]] = []
+                  
+                  // Simplified extraction logic
+                  
+                  var colorHex = "#000000"
+                  if let color = annotation.color {
+                      colorHex = color.toHex() ?? "#000000"
+                  }
+                  
+                  var type = "pen"
+                  if let color = annotation.color {
+                      var a: CGFloat = 0
+                      color.getWhite(nil, alpha: &a)
+                      if a < 0.5 {
+                          type = "highlighter"
+                      }
+                  }
+                  
+                  annotationsData.append([
+                      "type": type,
+                      "color": colorHex,
+                      "page": i,
+                      "points": [points], 
+                      "width": annotation.border?.lineWidth ?? 10.0
+                  ])
+              } else if annotation.type == "FreeText" {
+                  var colorHex = "#000000"
+                  if let color = annotation.fontColor {
+                      colorHex = color.toHex() ?? "#000000"
+                  }
+                  
+                  annotationsData.append([
+                      "type": "text",
+                      "color": colorHex,
+                      "page": i,
+                      "text": annotation.contents ?? "",
+                      "fontSize": annotation.font?.pointSize ?? 16.0,
+                      "x": annotation.bounds.origin.x,
+                      "y": annotation.bounds.origin.y
+                  ])
+              }
+          }
+      }
+      return annotationsData
+  }
+  
+  func setAnnotations(_ annotations: [[String: Any]]) {
+      guard let document = pdfView.document else { return }
+      
+      // Clear undo/redo stacks when setting annotations
+      undoStack.removeAll()
+      redoStack.removeAll()
+      
+      for data in annotations {
+          guard let pageIndex = data["page"] as? Int,
+                let page = document.page(at: pageIndex),
+                let type = data["type"] as? String,
+                let colorHex = data["color"] as? String else { continue }
+          
+          let color = UIColor(hex: colorHex) ?? .black
+          
+          if type == "text" {
+              guard let text = data["text"] as? String,
+                    let fontSize = data["fontSize"] as? Double,
+                    let x = data["x"] as? Double,
+                    let y = data["y"] as? Double else { continue }
+              
+              let annotation = PDFAnnotation(bounds: CGRect(x: x, y: y, width: 200, height: 50), forType: .freeText, withProperties: nil)
+              annotation.contents = text
+              annotation.font = UIFont.systemFont(ofSize: CGFloat(fontSize))
+              annotation.fontColor = color
+              annotation.color = .clear
+              page.addAnnotation(annotation)
+              
+          } else {
+              guard let pointsArray = data["points"] as? [[[String: Double]]] else { continue }
+              
+              for stroke in pointsArray {
+                  if stroke.isEmpty { continue }
+                  
+                  let path = UIBezierPath()
+                  let start = stroke[0]
+                  path.move(to: CGPoint(x: start["x"]!, y: start["y"]!))
+                  
+                  for i in 1..<stroke.count {
+                      let pt = stroke[i]
+                      path.addLine(to: CGPoint(x: pt["x"]!, y: pt["y"]!))
+                  }
+                  
+                  let bounds = page.bounds(for: pdfView.displayBox)
+                  
+                  let annotation = PDFAnnotation(bounds: bounds, forType: .ink, withProperties: nil)
+                  annotation.add(path)
+                  
+                  if type == "highlighter" {
+                      annotation.color = color.withAlphaComponent(0.3)
+                  } else {
+                      annotation.color = color
+                  }
+                  
+                  page.addAnnotation(annotation)
+              }
+          }
+      }
+  }
+
+  @objc func handlePan(_ gesture: UIPanGestureRecognizer) {
+    guard let page = pdfView.currentPage else { return }
+    let location = gesture.location(in: pdfView)
+    let convertedPoint = pdfView.convert(location, to: page)
+    
+    // Handle eraser
+    if currentTool == "eraser" {
+        switch gesture.state {
+        case .began, .changed:
+            // Find annotation at touch point
+            let tolerance: CGFloat = 20.0
+            for annotation in page.annotations {
+                let bounds = annotation.bounds
+                let expandedBounds = bounds.insetBy(dx: -tolerance, dy: -tolerance)
+                
+                if expandedBounds.contains(convertedPoint) {
+                    // Check if point is actually on the annotation path
+                    if let paths = annotation.paths {
+                        for path in paths {
+                            let cgPath = path.cgPath
+                            if cgPath.contains(convertedPoint) || cgPath.boundingBox.contains(convertedPoint) {
+                                page.removeAnnotation(annotation)
+                                undoStack.append(annotation)
+                                redoStack.removeAll()
+                                
+                                // Emit event
+                                onAnnotationChange([
+                                  "annotations": getAnnotations()
+                                ])
+                                return
+                            }
+                        }
+                    } else {
+                        // For non-path annotations (like text), just check bounds
+                        page.removeAnnotation(annotation)
+                        undoStack.append(annotation)
+                        redoStack.removeAll()
+                        
+                        // Emit event
+                        onAnnotationChange([
+                          "annotations": getAnnotations()
+                        ])
+                        return
+                    }
+                }
+            }
+        default:
+            break
+        }
+        return
+    }
+    
+    switch gesture.state {
+    case .began:
+      currentPath = UIBezierPath()
+      currentPath?.move(to: convertedPoint)
+      
+      // Create annotation
+      let bounds = page.bounds(for: pdfView.displayBox)
+      
+      if currentTool == "pen" {
+          let annotation = PDFAnnotation(bounds: bounds, forType: .ink, withProperties: nil)
+          annotation.color = currentColor
+          let border = PDFBorder()
+          border.lineWidth = currentStrokeWidth
+          annotation.border = border
+          annotation.add(currentPath!)
+          page.addAnnotation(annotation)
+          currentAnnotation = annotation
+      }
+      else if currentTool == "highlighter" {
+           let annotation = PDFAnnotation(bounds: bounds, forType: .ink, withProperties: nil)
+           annotation.color = currentColor.withAlphaComponent(0.3)
+          let border = PDFBorder()
+          border.lineWidth = currentStrokeWidth * 3.0
+          annotation.border = border
+           annotation.add(currentPath!)
+           page.addAnnotation(annotation)
+           currentAnnotation = annotation
+      }
+      
+    case .changed:
+      guard let path = currentPath, let annotation = currentAnnotation else { return }
+      path.addLine(to: convertedPoint)
+      annotation.add(path) // Update path
+      
+    case .ended, .cancelled:
+      // Clear redo stack when new annotation is added
+      redoStack.removeAll()
+      
+      currentPath = nil
+      currentAnnotation = nil
+      
+      // Emit event
+      onAnnotationChange([
+        "annotations": getAnnotations()
+      ])
+      
+    default:
+      break
+    }
+  }
+  
+  @objc func handleTap(_ gesture: UITapGestureRecognizer) {
+      guard let page = pdfView.currentPage else { return }
+      let location = gesture.location(in: pdfView)
+      let convertedPoint = pdfView.convert(location, to: page)
+      
+      if currentTool == "text" {
+          let annotation = PDFAnnotation(bounds: CGRect(x: convertedPoint.x, y: convertedPoint.y, width: 200, height: 50), forType: .freeText, withProperties: nil)
+          annotation.contents = currentText
+          annotation.font = UIFont.systemFont(ofSize: currentFontSize)
+          annotation.fontColor = currentColor
+          annotation.color = .clear // Background
+          page.addAnnotation(annotation)
+          
+          // Clear redo stack when new annotation is added
+          redoStack.removeAll()
+          
+          onAnnotationChange([
+            "annotations": getAnnotations()
+          ])
+          
+      } else if currentTool == "note" {
+          let annotation = PDFAnnotation(bounds: CGRect(x: convertedPoint.x, y: convertedPoint.y, width: 20, height: 20), forType: .text, withProperties: nil)
+          annotation.iconType = .comment
+          annotation.color = currentColor
+          page.addAnnotation(annotation)
+          
+          // Clear redo stack when new annotation is added
+          redoStack.removeAll()
+          
+          onAnnotationChange([
+            "annotations": getAnnotations()
+          ])
+      }
+  }
+}
+
+extension UIColor {
+    convenience init?(hex: String) {
+        var hexSanitized = hex.trimmingCharacters(in: .whitespacesAndNewlines)
+        hexSanitized = hexSanitized.replacingOccurrences(of: "#", with: "")
+
+        var rgb: UInt64 = 0
+
+        var r: CGFloat = 0.0
+        var g: CGFloat = 0.0
+        var b: CGFloat = 0.0
+        var a: CGFloat = 1.0
+
+        let length = hexSanitized.count
+
+        guard Scanner(string: hexSanitized).scanHexInt64(&rgb) else { return nil }
+
+        if length == 6 {
+            r = CGFloat((rgb & 0xFF0000) >> 16) / 255.0
+            g = CGFloat((rgb & 0x00FF00) >> 8) / 255.0
+            b = CGFloat(rgb & 0x0000FF) / 255.0
+
+        } else if length == 8 {
+            r = CGFloat((rgb & 0xFF000000) >> 24) / 255.0
+            g = CGFloat((rgb & 0x00FF0000) >> 16) / 255.0
+            b = CGFloat((rgb & 0x0000FF00) >> 8) / 255.0
+            a = CGFloat(rgb & 0x000000FF) / 255.0
+
+        } else {
+            return nil
+        }
+
+        self.init(red: r, green: g, blue: b, alpha: a)
+    }
+    
+    func toHex() -> String? {
+        var r: CGFloat = 0
+        var g: CGFloat = 0
+        var b: CGFloat = 0
+        var a: CGFloat = 0
+        
+        guard getRed(&r, green: &g, blue: &b, alpha: &a) else { return nil }
+        
+        let rgb: Int = (Int)(r*255)<<16 | (Int)(g*255)<<8 | (Int)(b*255)<<0
+        return String(format: "#%06x", rgb)
+    }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@june24/expo-pdf-reader",
+  "version": "0.1.0",
+  "description": "A PDF reader for 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"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-module",
+    "pdf"
+  ],
+  "author": "User",
+  "license": "MIT",
+  "dependencies": {
+    "expo-modules-core": "^3.0.29"
+  },
+  "devDependencies": {
+    "expo-module-scripts": "^5.0.8",
+    "typescript": "^5.9.3",
+    "@types/react": "^19.2.9",
+    "react": "19.2.3",
+    "react-native": "0.83.1"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}