@thatkid02/react-native-pdf-viewer 0.0.1 → 0.0.3

package/README.md

@@ -1,7 +1,12 @@
 # react-native-pdf-viewer
 
+[![npm version](https://badge.fury.io/js/@thatkid02%2Freact-native-pdf-viewer.svg)](https://www.npmjs.com/package/@thatkid02/react-native-pdf-viewer)
+[![npm downloads](https://img.shields.io/npm/dm/@thatkid02/react-native-pdf-viewer.svg)](https://www.npmjs.com/package/@thatkid02/react-native-pdf-viewer)
+
 High-performance PDF viewer for React Native, built with [Nitro Modules](https://nitro.margelo.com/) for native rendering performance.
 
+<video src="docs/pdf.mp4" controls></video>
+
 ## Features
 
 ✅ **High-performance PDF rendering** with native APIs (PDFKit on iOS, PdfRenderer on Android)  
@@ -28,7 +33,7 @@ High-performance PDF viewer for React Native, built with [Nitro Modules](https:/
 ## Installation
 
 ```sh
-npm install react-native-pdf-viewer react-native-nitro-modules
+npm install @thatkid02/react-native-pdf-viewer react-native-nitro-modules
 ```
 
 > `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
@@ -38,7 +43,7 @@ npm install react-native-pdf-viewer react-native-nitro-modules
 ### Basic Example
 
 ```tsx
-import { PdfViewerView } from 'react-native-pdf-viewer';
+import { PdfViewerView } from '@thatkid02/react-native-pdf-viewer';
 
 export default function App() {
   return (
@@ -58,10 +63,12 @@ export default function App() {
 
 ### Advanced Example with All Features
 
+  - callback is exposed by nitro modules to avoid re-renders [here](https://nitro.margelo.com/docs/view-components#callbacks-have-to-be-wrapped)
+
 ```tsx
 import React, { useRef } from 'react';
 import { View, Button, StyleSheet } from 'react-native';
-import { PdfViewerView, type PdfViewer } from 'react-native-pdf-viewer';
+import { PdfViewerView, type PdfViewer } from '@thatkid02/react-native-pdf-viewer';
 
 export default function AdvancedPdfViewer() {
   const pdfRef = useRef<PdfViewer>(null);
@@ -94,10 +101,11 @@ export default function AdvancedPdfViewer() {
     pdfRef.current?.setScale(2.0);
   };
   
+
   return (
     <View style={styles.container}>
       <PdfViewerView
-        ref={pdfRef}
+        hybridRef={callback((ref: PdfViewerRef | null) => {
         source="https://example.com/document.pdf"
         style={styles.pdf}
         // Layout options
@@ -111,12 +119,12 @@ export default function AdvancedPdfViewer() {
         // Loading indicator
         showsActivityIndicator={true}
         // Event handlers
-        onLoadComplete={handleLoadComplete}
-        onPageChange={handlePageChange}
-        onScaleChange={handleScaleChange}
-        onThumbnailGenerated={handleThumbnailGenerated}
-        onError={(event) => console.error(event.message)}
-        onLoadingChange={(event) => console.log('Loading:', event.isLoading)}
+        onLoadComplete={callback(handleLoadComplete)}
+        onPageChange={callback(handlePageChange)}
+        onScaleChange={callback(handleScaleChange)}
+        onError={callback(handleError)}
+        onThumbnailGenerated={callback(handleThumbnailGenerated)}
+        onLoadingChange={callback(handleLoadingChange)}
       />
       
       <View style={styles.controls}>
@@ -183,6 +191,10 @@ const styles = StyleSheet.create({
 | `showsActivityIndicator` | `boolean` | `true` | Show loading indicator |
 | `horizontal` | `boolean` | `false` | Horizontal scroll (iOS only) |
 | `enablePaging` | `boolean` | `false` | Enable paging mode (iOS only) |
+| `contentInsetTop` | `number` | `0` | Top content inset (for glass topbars) |
+| `contentInsetBottom` | `number` | `0` | Bottom content inset (for glass toolbars) |
+| `contentInsetLeft` | `number` | `0` | Left content inset |
+| `contentInsetRight` | `number` | `0` | Right content inset |
 | `onLoadComplete` | `(event) => void` | - | Called when PDF loads |
 | `onPageChange` | `(event) => void` | - | Called when page changes |
 | `onScaleChange` | `(event) => void` | - | Called when zoom changes |
@@ -190,6 +202,24 @@ const styles = StyleSheet.create({
 | `onThumbnailGenerated` | `(event) => void` | - | Called when thumbnail is ready |
 | `onLoadingChange` | `(event) => void` | - | Called when loading state changes |
 
+#### Glass UI / Transparent Bars
+
+Use `contentInset` props to make the PDF scroll behind transparent headers and toolbars:
+
+```tsx
+<PdfViewerView
+  source="https://example.com/document.pdf"
+  contentInsetTop={80}      // Height of your transparent top bar
+  contentInsetBottom={60}    // Height of your transparent bottom toolbar
+  style={{ flex: 1 }}
+/>
+```
+
+This creates a modern "glass" effect where:
+- PDF content starts below the top bar
+- Content scrolls behind transparent bars
+- Content ends above the bottom toolbar
+
 ### Methods
 
 Access methods via ref:

package/android/src/main/java/com/margelo/nitro/pdfviewer/HybridPdfViewer.kt

@@ -138,6 +138,30 @@ class HybridPdfViewer(private val reactContext: ThemedReactContext) : HybridPdfV
             value?.let { documentViewer.showsActivityIndicator = it }
         }
     
+    override var contentInsetTop: Double? = null
+        set(value) {
+            field = value
+            value?.let { documentViewer.contentInsetTop = it.toFloat() }
+        }
+    
+    override var contentInsetBottom: Double? = null
+        set(value) {
+            field = value
+            value?.let { documentViewer.contentInsetBottom = it.toFloat() }
+        }
+    
+    override var contentInsetLeft: Double? = null
+        set(value) {
+            field = value
+            value?.let { documentViewer.contentInsetLeft = it.toFloat() }
+        }
+    
+    override var contentInsetRight: Double? = null
+        set(value) {
+            field = value
+            value?.let { documentViewer.contentInsetRight = it.toFloat() }
+        }
+    
     // Event callbacks - these are set by Nitro
     override var onLoadComplete: ((event: LoadCompleteEvent) -> Unit)? = null
     override var onPageChange: ((event: PageChangeEvent) -> Unit)? = null

package/android/src/main/java/com/margelo/nitro/pdfviewer/PdfViewer.kt

@@ -102,6 +102,28 @@ class PdfViewer(context: Context) : FrameLayout(context) {
     var minScale: Float = 0.5f
     var maxScale: Float = 4.0f
     
+    // Content insets for glass UI / transparent bars
+    var contentInsetTop: Float = 0f
+        set(value) {
+            field = value
+            updateContentInsets()
+        }
+    var contentInsetBottom: Float = 0f
+        set(value) {
+            field = value
+            updateContentInsets()
+        }
+    var contentInsetLeft: Float = 0f
+        set(value) {
+            field = value
+            updateContentInsets()
+        }
+    var contentInsetRight: Float = 0f
+        set(value) {
+            field = value
+            updateContentInsets()
+        }
+    
     // Callbacks for HybridPdfViewer integration
     var onLoadCompleteCallback: ((pageCount: Int, pageWidth: Int, pageHeight: Int) -> Unit)? = null
     var onPageChangeCallback: ((page: Int, pageCount: Int) -> Unit)? = null
@@ -125,6 +147,9 @@ class PdfViewer(context: Context) : FrameLayout(context) {
             
             // Allow parent to intercept touch events for pinch-to-zoom
             requestDisallowInterceptTouchEvent(false)
+            
+            // Enable drawing content under padding (for glass UI effect)
+            clipToPadding = false
         }
         
         loadingIndicator = ProgressBar(context).apply {
@@ -191,6 +216,17 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         })
     }
     
+    private fun updateContentInsets() {
+        // Apply content insets as padding
+        // clipToPadding=false allows content to draw under padding (glass UI effect)
+        recyclerView.setPadding(
+            contentInsetLeft.toInt(),
+            contentInsetTop.toInt(),
+            contentInsetRight.toInt(),
+            contentInsetBottom.toInt()
+        )
+    }
+    
     private fun setupRecyclerView() {
         // Android always uses vertical scroll (horizontal is iOS-only)
         val layoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
@@ -329,12 +365,7 @@ class PdfViewer(context: Context) : FrameLayout(context) {
                     pendingThumbnails.clear()
                     lastReportedPage = -1
                     
-                    // Preload page dimensions in background
-                    componentScope.launch(Dispatchers.IO) {
-                        preloadPageDimensions(renderer)
-                    }
-                    
-                    // Get first page dimensions immediately
+                    // Get first page dimensions immediately for initial render
                     val firstDim = try {
                         renderMutex.withLock {
                             renderer.openPage(0).use { page ->
@@ -348,6 +379,12 @@ class PdfViewer(context: Context) : FrameLayout(context) {
                         Pair(612, 792)
                     }
                     
+                    // Preload a few more page dimensions in background (non-blocking)
+                    // This helps with initial scrolling but doesn't delay the initial render
+                    componentScope.launch(Dispatchers.IO) {
+                        preloadInitialPageDimensions(renderer)
+                    }
+                    
                     adapter = PdfPageAdapter()
                     recyclerView.adapter = adapter
                     
@@ -359,6 +396,13 @@ class PdfViewer(context: Context) : FrameLayout(context) {
                     }
                     emitLoadComplete(renderer.pageCount, firstDim.first, firstDim.second)
                     
+                    // Force initial layout and render by scrolling slightly
+                    // This ensures content appears without requiring user interaction
+                    post {
+                        recyclerView.scrollBy(0, 2)
+                        recyclerView.scrollBy(0, -2)
+                    }
+                    
                     schedulePreload()
                 }
             } catch (e: SecurityException) {
@@ -386,18 +430,67 @@ class PdfViewer(context: Context) : FrameLayout(context) {
         }
     }
     
-    private suspend fun preloadPageDimensions(renderer: PdfRenderer) {
-        for (i in 0 until renderer.pageCount) {
+    // Preload only first few pages (non-blocking) for better initial experience
+    private suspend fun preloadInitialPageDimensions(renderer: PdfRenderer) {
+        // Preload first 5-10 pages to improve initial scrolling
+        val pagesToPreload = minOf(10, renderer.pageCount)
+        for (i in 1 until pagesToPreload) { // Start from 1 since 0 is already loaded
             try {
+                kotlinx.coroutines.delay(50) // Small delay to not block other operations
                 renderMutex.withLock {
-                    renderer.openPage(i).use { page ->
-                        pageDimensions[i] = Pair(page.width, page.height)
+                    if (pageDimensions[i] == null) { // Only if not already loaded
+                        renderer.openPage(i).use { page ->
+                            pageDimensions[i] = Pair(page.width, page.height)
+                        }
                     }
                 }
             } catch (e: Exception) {
                 Log.e(TAG, "Error preloading page $i dimensions", e)
             }
         }
+        
+        // Lazily load remaining pages with lower priority
+        if (renderer.pageCount > pagesToPreload) {
+            for (i in pagesToPreload until renderer.pageCount) {
+                try {
+                    kotlinx.coroutines.delay(100) // Longer delay for non-critical pages
+                    renderMutex.withLock {
+                        if (pageDimensions[i] == null) {
+                            renderer.openPage(i).use { page ->
+                                pageDimensions[i] = Pair(page.width, page.height)
+                            }
+                        }
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error preloading page $i dimensions", e)
+                }
+            }
+        }
+    }
+    
+    // Get page dimensions on-demand if not already cached
+    private suspend fun getPageDimensions(pageIndex: Int): Pair<Int, Int> {
+        // Return cached if available
+        pageDimensions[pageIndex]?.let { return it }
+        
+        // Load on-demand
+        val renderer = pdfRenderer ?: return Pair(612, 792) // Standard page size fallback
+        
+        return try {
+            renderMutex.withLock {
+                // Check again inside lock in case another thread loaded it
+                pageDimensions[pageIndex] ?: run {
+                    renderer.openPage(pageIndex).use { page ->
+                        Pair(page.width, page.height).also {
+                            pageDimensions[pageIndex] = it
+                        }
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error loading page $pageIndex dimensions", e)
+            Pair(612, 792) // Fallback
+        }
     }
     
     private fun closePdfRenderer() {
@@ -445,18 +538,81 @@ class PdfViewer(context: Context) : FrameLayout(context) {
             uri.startsWith("http://") || uri.startsWith("https://") -> {
                 val hash = uri.hashCode().toString()
                 val file = File(context.cacheDir, "pdf_$hash.pdf")
+                val tempFile = File(context.cacheDir, "pdf_${hash}_temp.pdf")
+                
+                // Check if cached file exists and is reasonably fresh (< 1 hour)
+                if (file.exists() && (System.currentTimeMillis() - file.lastModified() < 3600_000)) {
+                    if (BuildConfig.DEBUG) {
+                        Log.d(TAG, "Using cached PDF file: ${file.absolutePath}")
+                    }
+                    return@withContext file
+                }
                 
-                if (!file.exists()) {
-                    val connection = URL(uri).openConnection().apply {
+                // Download with better error handling and progress
+                try {
+                    val url = URL(uri)
+                    val connection = url.openConnection().apply {
                         connectTimeout = 30_000 // 30 seconds
                         readTimeout = 60_000   // 60 seconds
+                        setRequestProperty("Accept", "application/pdf")
+                        
+                        // Add cache headers for better HTTP caching
+                        if (file.exists()) {
+                            setRequestProperty("If-Modified-Since", 
+                                java.text.SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", java.util.Locale.US)
+                                    .apply { timeZone = java.util.TimeZone.getTimeZone("GMT") }
+                                    .format(java.util.Date(file.lastModified())))
+                        }
                     }
+                    
+                    val contentLength = connection.contentLength
+                    if (BuildConfig.DEBUG) {
+                        Log.d(TAG, "Downloading PDF: $uri, size: $contentLength bytes")
+                    }
+                    
                     connection.getInputStream().use { input ->
-                        FileOutputStream(file).use { output ->
-                            input.copyTo(output)
+                        FileOutputStream(tempFile).use { output ->
+                            val buffer = ByteArray(8192)
+                            var bytesRead: Int
+                            var totalRead = 0
+                            
+                            while (input.read(buffer).also { bytesRead = it } != -1) {
+                                output.write(buffer, 0, bytesRead)
+                                totalRead += bytesRead
+                                
+                                // Log progress for large files
+                                if (BuildConfig.DEBUG && contentLength > 0 && totalRead % (contentLength / 10 + 1) == 0) {
+                                    val progress = (totalRead * 100) / contentLength
+                                    Log.d(TAG, "Download progress: $progress%")
+                                }
+                            }
+                            
+                            output.flush()
                         }
                     }
+                    
+                    // Move temp file to final location
+                    if (tempFile.exists()) {
+                        file.delete() // Remove old cached file
+                        tempFile.renameTo(file)
+                    }
+                    
+                    if (BuildConfig.DEBUG) {
+                        Log.d(TAG, "Download completed: ${file.absolutePath}")
+                    }
+                } catch (e: Exception) {
+                    // Clean up temp file on error
+                    tempFile.delete()
+                    
+                    // If download failed but we have an old cached version, use it
+                    if (file.exists()) {
+                        Log.w(TAG, "Download failed, using cached version: ${e.message}")
+                        return@withContext file
+                    }
+                    
+                    throw e
                 }
+                
                 file
             }
             else -> File(uri)
@@ -850,6 +1006,23 @@ class PdfViewer(context: Context) : FrameLayout(context) {
                 val scale = (viewWidth.toFloat() / dimensions.first) * currentScale
                 val targetHeight = (dimensions.second * scale).toInt().coerceAtLeast(100)
                 holder.imageView.layoutParams.height = targetHeight
+            } else {
+                // Dimensions not loaded yet, use default height and trigger lazy load
+                holder.imageView.layoutParams.height = (viewWidth * 1.414f).toInt().coerceAtLeast(100)
+                
+                // Trigger lazy loading of dimensions in background
+                componentScope.launch(Dispatchers.IO) {
+                    val dims = getPageDimensions(position)
+                    withContext(Dispatchers.Main) {
+                        // Update the view if it's still showing this position
+                        if (holder.bindingAdapterPosition == position) {
+                            val scale = (viewWidth.toFloat() / dims.first) * currentScale
+                            val targetHeight = (dims.second * scale).toInt().coerceAtLeast(100)
+                            holder.imageView.layoutParams.height = targetHeight
+                            holder.imageView.requestLayout()
+                        }
+                    }
+                }
             }
             
             // Check cache for valid bitmap at current scale

package/ios/PdfViewer.swift

@@ -127,6 +127,8 @@ class HybridPdfViewer: HybridPdfViewerSpec {
       ensureMainThread {
         self.pdfView.displayMode = enablePaging ? .singlePage : .singlePageContinuous
         self.pdfView.usePageViewController(enablePaging, withViewOptions: nil)
+        // Ensure autoScales is enabled for proper width fitting in both modes
+        self.pdfView.autoScales = true
       }
     }
   }
@@ -145,6 +147,61 @@ class HybridPdfViewer: HybridPdfViewerSpec {
     }
   }
   
+  // Content insets for glass UI / transparent bars
+  var contentInsetTop: Double? {
+    didSet {
+      updateContentInsets()
+    }
+  }
+  
+  var contentInsetBottom: Double? {
+    didSet {
+      updateContentInsets()
+    }
+  }
+  
+  var contentInsetLeft: Double? {
+    didSet {
+      updateContentInsets()
+    }
+  }
+  
+  var contentInsetRight: Double? {
+    didSet {
+      updateContentInsets()
+    }
+  }
+  
+  private func updateContentInsets() {
+    ensureMainThread {
+      // Get scroll view from PDFView's view hierarchy
+      // PDFView uses PDFDocumentView which contains a scroll view
+      if let scrollView = self.findScrollView(in: self.pdfView) {
+        let insets = UIEdgeInsets(
+          top: CGFloat(self.contentInsetTop ?? 0),
+          left: CGFloat(self.contentInsetLeft ?? 0),
+          bottom: CGFloat(self.contentInsetBottom ?? 0),
+          right: CGFloat(self.contentInsetRight ?? 0)
+        )
+        scrollView.contentInset = insets
+        // Adjust scroll indicator insets to match
+        scrollView.scrollIndicatorInsets = insets
+      }
+    }
+  }
+  
+  private func findScrollView(in view: UIView) -> UIScrollView? {
+    if let scrollView = view as? UIScrollView {
+      return scrollView
+    }
+    for subview in view.subviews {
+      if let scrollView = findScrollView(in: subview) {
+        return scrollView
+      }
+    }
+    return nil
+  }
+  
   var enableZoom: Bool? {
     didSet {
       guard let enableZoom = enableZoom else { return }
@@ -228,7 +285,7 @@ class HybridPdfViewer: HybridPdfViewerSpec {
     // Create PDF view
     pdfView = PDFView()
     pdfView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-    pdfView.autoScales = false
+    pdfView.autoScales = true  // Enable autoScales to fit width by default
     pdfView.displayDirection = .vertical
     pdfView.displayMode = .singlePageContinuous
     pdfView.usePageViewController(false, withViewOptions: nil)
@@ -257,8 +314,11 @@ class HybridPdfViewer: HybridPdfViewerSpec {
       activityIndicator.centerYAnchor.constraint(equalTo: containerView.centerYAnchor)
     ])
     
-    let config = URLSessionConfiguration.ephemeral
+    // Use default configuration with caching enabled for better performance
+    let config = URLSessionConfiguration.default
     config.timeoutIntervalForRequest = 30.0
+    config.requestCachePolicy = .returnCacheDataElseLoad
+    config.urlCache = URLCache.shared
     urlSession = URLSession(configuration: config)
     
     super.init()
@@ -287,7 +347,13 @@ class HybridPdfViewer: HybridPdfViewerSpec {
     
     // Observe bounds changes to update scale factor when view is resized
     boundsObservation = pdfView.observe(\.bounds, options: [.new]) { [weak self] _, _ in
-      self?.updateScaleToFitWidthIfNeeded()
+      guard let self = self else { return }
+      // Only re-enable autoScales during bounds change if we're at default scale
+      // This allows manual zoom to persist through view lifecycle changes
+      if self.pdfView.displayMode == .singlePageContinuous && self.pdfView.scaleFactor == 1.0 {
+        self.pdfView.autoScales = true
+      }
+      self.updateScaleToFitWidthIfNeeded()
     }
   }
   
@@ -434,9 +500,19 @@ class HybridPdfViewer: HybridPdfViewerSpec {
     pdfView.document = document
     thumbnailCache.removeAllObjects()
     
+    // Ensure autoScales is enabled for proper width fitting
+    pdfView.autoScales = true
+    
     // Update scale after document is loaded
     updateScaleToFitWidthIfNeeded()
     
+    // If bounds were zero, schedule a delayed update
+    if pdfView.bounds.width == 0 {
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+        self?.updateScaleToFitWidthIfNeeded()
+      }
+    }
+    
     if let firstPage = document.page(at: 0) {
       let pageRect = firstPage.bounds(for: .mediaBox)
       onLoadComplete?(LoadCompleteEvent(
@@ -454,16 +530,31 @@ class HybridPdfViewer: HybridPdfViewerSpec {
     let pageRect = firstPage.bounds(for: .mediaBox)
     let viewWidth = pdfView.bounds.width
     
-    // Only update scale if view has been laid out (width > 0) and zoom is enabled
+    // Only update scale if view has been laid out (width > 0)
     guard viewWidth > 0 && pageRect.width > 0 else { return }
     
-    let scale = viewWidth / pageRect.width
-    let minScale = CGFloat(self.minScale ?? 0.5)
-    let maxScale = CGFloat(self.maxScale ?? 4.0)
-    
-    // Clamp the scale between min and max
-    let clampedScale = max(minScale, min(maxScale, scale))
-    pdfView.scaleFactor = clampedScale
+    // In continuous scroll mode, check if we should enable autoScales
+    if pdfView.displayMode == .singlePageContinuous {
+      // Only enable autoScales if at default scale (hasn't been manually zoomed)
+      // This preserves user's manual zoom level through view lifecycle
+      let currentScale = pdfView.scaleFactor
+      let isDefaultScale = abs(currentScale - 1.0) < 0.01
+      
+      if isDefaultScale {
+        pdfView.autoScales = true
+        // Force PDFView to recalculate scale if needed
+        pdfView.layoutDocumentView()
+      }
+    } else {
+      // For paging mode, calculate and set the scale to fit width
+      let scale = viewWidth / pageRect.width
+      let minScale = CGFloat(self.minScale ?? 0.5)
+      let maxScale = CGFloat(self.maxScale ?? 4.0)
+      
+      // Clamp the scale between min and max
+      let clampedScale = max(minScale, min(maxScale, scale))
+      pdfView.scaleFactor = clampedScale
+    }
   }
   
   private func resolveURL(from source: String) -> URL? {
@@ -532,13 +623,11 @@ class HybridPdfViewer: HybridPdfViewerSpec {
     let maxScale = CGFloat(self.maxScale ?? 4.0)
     let clampedScale = max(minScale, min(maxScale, CGFloat(scale)))
     
-    // Ensure UI update happens on main thread
-    if Thread.isMainThread {
-      pdfView.scaleFactor = clampedScale
-    } else {
-      DispatchQueue.main.async { [weak self] in
-        self?.pdfView.scaleFactor = clampedScale
-      }
+    // Disable autoScales when manually setting scale
+    // This allows programmatic zoom control to work
+    ensureMainThread {
+      self.pdfView.autoScales = false
+      self.pdfView.scaleFactor = clampedScale
     }
   }
   

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["getHostComponent","callback","PdfViewerConfig","require","PdfViewerView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,gBAAgB,EAAEC,QAAQ,QAAQ,4BAA4B;AAEvE,MAAMC,eAAe,GAAGC,OAAO,CAAC,wDAAwD,CAAC;AAGzF,OAAO,MAAMC,aAAa,GAAGJ,gBAAgB,CAC3C,WAAW,EACX,MAAME,eACR,CAAC;;AAED;;AAGA;;AAYA;AACA,SAASD,QAAQ","ignoreList":[]}
+{"version":3,"names":["getHostComponent","callback","PdfViewerConfig","require","PdfViewerView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,gBAAgB,EAAEC,QAAQ,QAAQ,4BAA4B;AAIvE,MAAMC,eAAe,GAAGC,OAAO,CAAC,wDAAwD,CAAC;AAEzF,OAAO,MAAMC,aAAa,GAAGJ,gBAAgB,CAC3C,WAAW,EACX,MAAME,eACR,CAAC;;AAED;;AAGA;;AAYA;AACA,SAASD,QAAQ","ignoreList":[]}

package/lib/typescript/src/PdfViewer.nitro.d.ts

@@ -46,6 +46,25 @@ export interface PdfViewerProps extends HybridViewProps {
      */
     enablePaging?: boolean;
     spacing?: number;
+    /**
+     * Top content inset in pixels
+     * Useful for transparent/glass top bars - content starts below but scrolls behind
+     * @example 80 // Start content below 80px top bar
+     */
+    contentInsetTop?: number;
+    /**
+     * Bottom content inset in pixels
+     * Useful for transparent/glass bottom bars - content ends above but scrolls behind
+     */
+    contentInsetBottom?: number;
+    /**
+     * Left content inset in pixels
+     */
+    contentInsetLeft?: number;
+    /**
+     * Right content inset in pixels
+     */
+    contentInsetRight?: number;
     enableZoom?: boolean;
     minScale?: number;
     maxScale?: number;

package/lib/typescript/src/PdfViewer.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PdfViewer.nitro.d.ts","sourceRoot":"","sources":["../../../src/PdfViewer.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,OAAO,CAAC;CACpB;AAGD,MAAM,WAAW,iBAAiB;IAEhC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAGhB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IAGjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAGjC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACpD,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAChD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAClD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAChE,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IAEzD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAG7B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAG9B,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAGtC,qBAAqB,IAAI,IAAI,CAAC;CAC/B;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"PdfViewer.nitro.d.ts","sourceRoot":"","sources":["../../../src/PdfViewer.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,OAAO,CAAC;CACpB;AAGD,MAAM,WAAW,iBAAiB;IAEhC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,cAAe,SAAQ,eAAe;IACrD;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAGhB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IAGjB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAG3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAGjC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACpD,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAChD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAClD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAChE,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IAEzD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAG7B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAG9B,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAGtC,qBAAqB,IAAI,IAAI,CAAC;CAC/B;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC"}

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAoB,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE1E,eAAO,MAAM,aAAa,wFAGzB,CAAC;AAGF,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;AAGvE,YAAY,EACV,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,UAAU,EACV,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAoB,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAI1E,eAAO,MAAM,aAAa,wFAGzB,CAAC;AAGF,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;AAGvE,YAAY,EACV,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,UAAU,EACV,uBAAuB,EACvB,kBAAkB,EAClB,cAAc,EACd,gBAAgB,GACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,QAAQ,EAAE,CAAC"}

package/nitrogen/generated/android/c++/JHybridPdfViewerSpec.cpp

@@ -101,6 +101,42 @@ namespace margelo::nitro::pdfviewer {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* spacing */)>("setSpacing");
     method(_javaPart, spacing.has_value() ? jni::JDouble::valueOf(spacing.value()) : nullptr);
   }
+  std::optional<double> JHybridPdfViewerSpec::getContentInsetTop() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getContentInsetTop");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setContentInsetTop(std::optional<double> contentInsetTop) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* contentInsetTop */)>("setContentInsetTop");
+    method(_javaPart, contentInsetTop.has_value() ? jni::JDouble::valueOf(contentInsetTop.value()) : nullptr);
+  }
+  std::optional<double> JHybridPdfViewerSpec::getContentInsetBottom() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getContentInsetBottom");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setContentInsetBottom(std::optional<double> contentInsetBottom) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* contentInsetBottom */)>("setContentInsetBottom");
+    method(_javaPart, contentInsetBottom.has_value() ? jni::JDouble::valueOf(contentInsetBottom.value()) : nullptr);
+  }
+  std::optional<double> JHybridPdfViewerSpec::getContentInsetLeft() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getContentInsetLeft");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setContentInsetLeft(std::optional<double> contentInsetLeft) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* contentInsetLeft */)>("setContentInsetLeft");
+    method(_javaPart, contentInsetLeft.has_value() ? jni::JDouble::valueOf(contentInsetLeft.value()) : nullptr);
+  }
+  std::optional<double> JHybridPdfViewerSpec::getContentInsetRight() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getContentInsetRight");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridPdfViewerSpec::setContentInsetRight(std::optional<double> contentInsetRight) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* contentInsetRight */)>("setContentInsetRight");
+    method(_javaPart, contentInsetRight.has_value() ? jni::JDouble::valueOf(contentInsetRight.value()) : nullptr);
+  }
   std::optional<bool> JHybridPdfViewerSpec::getEnableZoom() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getEnableZoom");
     auto __result = method(_javaPart);

package/nitrogen/generated/android/c++/JHybridPdfViewerSpec.hpp

@@ -57,6 +57,14 @@ namespace margelo::nitro::pdfviewer {
     void setEnablePaging(std::optional<bool> enablePaging) override;
     std::optional<double> getSpacing() override;
     void setSpacing(std::optional<double> spacing) override;
+    std::optional<double> getContentInsetTop() override;
+    void setContentInsetTop(std::optional<double> contentInsetTop) override;
+    std::optional<double> getContentInsetBottom() override;
+    void setContentInsetBottom(std::optional<double> contentInsetBottom) override;
+    std::optional<double> getContentInsetLeft() override;
+    void setContentInsetLeft(std::optional<double> contentInsetLeft) override;
+    std::optional<double> getContentInsetRight() override;
+    void setContentInsetRight(std::optional<double> contentInsetRight) override;
     std::optional<bool> getEnableZoom() override;
     void setEnableZoom(std::optional<bool> enableZoom) override;
     std::optional<double> getMinScale() override;

package/nitrogen/generated/android/c++/views/JHybridPdfViewerStateUpdater.cpp

@@ -52,6 +52,22 @@ void JHybridPdfViewerStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /
     view->setSpacing(props.spacing.value);
     // TODO: Set isDirty = false
   }
+  if (props.contentInsetTop.isDirty) {
+    view->setContentInsetTop(props.contentInsetTop.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.contentInsetBottom.isDirty) {
+    view->setContentInsetBottom(props.contentInsetBottom.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.contentInsetLeft.isDirty) {
+    view->setContentInsetLeft(props.contentInsetLeft.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.contentInsetRight.isDirty) {
+    view->setContentInsetRight(props.contentInsetRight.value);
+    // TODO: Set isDirty = false
+  }
   if (props.enableZoom.isDirty) {
     view->setEnableZoom(props.enableZoom.value);
     // TODO: Set isDirty = false

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfviewer/HybridPdfViewerSpec.kt

@@ -62,6 +62,30 @@ abstract class HybridPdfViewerSpec: HybridView() {
   @set:Keep
   abstract var spacing: Double?
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var contentInsetTop: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var contentInsetBottom: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var contentInsetLeft: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var contentInsetRight: Double?
+  
   @get:DoNotStrip
   @get:Keep
   @set:DoNotStrip

package/nitrogen/generated/ios/c++/HybridPdfViewerSpecSwift.hpp

@@ -100,6 +100,34 @@ namespace margelo::nitro::pdfviewer {
     inline void setSpacing(std::optional<double> spacing) noexcept override {
       _swiftPart.setSpacing(spacing);
     }
+    inline std::optional<double> getContentInsetTop() noexcept override {
+      auto __result = _swiftPart.getContentInsetTop();
+      return __result;
+    }
+    inline void setContentInsetTop(std::optional<double> contentInsetTop) noexcept override {
+      _swiftPart.setContentInsetTop(contentInsetTop);
+    }
+    inline std::optional<double> getContentInsetBottom() noexcept override {
+      auto __result = _swiftPart.getContentInsetBottom();
+      return __result;
+    }
+    inline void setContentInsetBottom(std::optional<double> contentInsetBottom) noexcept override {
+      _swiftPart.setContentInsetBottom(contentInsetBottom);
+    }
+    inline std::optional<double> getContentInsetLeft() noexcept override {
+      auto __result = _swiftPart.getContentInsetLeft();
+      return __result;
+    }
+    inline void setContentInsetLeft(std::optional<double> contentInsetLeft) noexcept override {
+      _swiftPart.setContentInsetLeft(contentInsetLeft);
+    }
+    inline std::optional<double> getContentInsetRight() noexcept override {
+      auto __result = _swiftPart.getContentInsetRight();
+      return __result;
+    }
+    inline void setContentInsetRight(std::optional<double> contentInsetRight) noexcept override {
+      _swiftPart.setContentInsetRight(contentInsetRight);
+    }
     inline std::optional<bool> getEnableZoom() noexcept override {
       auto __result = _swiftPart.getEnableZoom();
       return __result;

package/nitrogen/generated/ios/c++/views/HybridPdfViewerComponent.mm

@@ -91,6 +91,26 @@ using namespace margelo::nitro::pdfviewer::views;
     swiftPart.setSpacing(newViewProps.spacing.value);
     newViewProps.spacing.isDirty = false;
   }
+  // contentInsetTop: optional
+  if (newViewProps.contentInsetTop.isDirty) {
+    swiftPart.setContentInsetTop(newViewProps.contentInsetTop.value);
+    newViewProps.contentInsetTop.isDirty = false;
+  }
+  // contentInsetBottom: optional
+  if (newViewProps.contentInsetBottom.isDirty) {
+    swiftPart.setContentInsetBottom(newViewProps.contentInsetBottom.value);
+    newViewProps.contentInsetBottom.isDirty = false;
+  }
+  // contentInsetLeft: optional
+  if (newViewProps.contentInsetLeft.isDirty) {
+    swiftPart.setContentInsetLeft(newViewProps.contentInsetLeft.value);
+    newViewProps.contentInsetLeft.isDirty = false;
+  }
+  // contentInsetRight: optional
+  if (newViewProps.contentInsetRight.isDirty) {
+    swiftPart.setContentInsetRight(newViewProps.contentInsetRight.value);
+    newViewProps.contentInsetRight.isDirty = false;
+  }
   // enableZoom: optional
   if (newViewProps.enableZoom.isDirty) {
     swiftPart.setEnableZoom(newViewProps.enableZoom.value);

package/nitrogen/generated/ios/swift/HybridPdfViewerSpec.swift

@@ -15,6 +15,10 @@ public protocol HybridPdfViewerSpec_protocol: HybridObject, HybridView {
   var horizontal: Bool? { get set }
   var enablePaging: Bool? { get set }
   var spacing: Double? { get set }
+  var contentInsetTop: Double? { get set }
+  var contentInsetBottom: Double? { get set }
+  var contentInsetLeft: Double? { get set }
+  var contentInsetRight: Double? { get set }
   var enableZoom: Bool? { get set }
   var minScale: Double? { get set }
   var maxScale: Double? { get set }

package/nitrogen/generated/ios/swift/HybridPdfViewerSpec_cxx.swift

@@ -181,6 +181,74 @@ open class HybridPdfViewerSpec_cxx {
     }
   }
   
+  public final var contentInsetTop: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.contentInsetTop {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.contentInsetTop = newValue.value
+    }
+  }
+  
+  public final var contentInsetBottom: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.contentInsetBottom {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.contentInsetBottom = newValue.value
+    }
+  }
+  
+  public final var contentInsetLeft: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.contentInsetLeft {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.contentInsetLeft = newValue.value
+    }
+  }
+  
+  public final var contentInsetRight: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.contentInsetRight {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.contentInsetRight = newValue.value
+    }
+  }
+  
   public final var enableZoom: bridge.std__optional_bool_ {
     @inline(__always)
     get {

package/nitrogen/generated/shared/c++/HybridPdfViewerSpec.cpp

@@ -22,6 +22,14 @@ namespace margelo::nitro::pdfviewer {
       prototype.registerHybridSetter("enablePaging", &HybridPdfViewerSpec::setEnablePaging);
       prototype.registerHybridGetter("spacing", &HybridPdfViewerSpec::getSpacing);
       prototype.registerHybridSetter("spacing", &HybridPdfViewerSpec::setSpacing);
+      prototype.registerHybridGetter("contentInsetTop", &HybridPdfViewerSpec::getContentInsetTop);
+      prototype.registerHybridSetter("contentInsetTop", &HybridPdfViewerSpec::setContentInsetTop);
+      prototype.registerHybridGetter("contentInsetBottom", &HybridPdfViewerSpec::getContentInsetBottom);
+      prototype.registerHybridSetter("contentInsetBottom", &HybridPdfViewerSpec::setContentInsetBottom);
+      prototype.registerHybridGetter("contentInsetLeft", &HybridPdfViewerSpec::getContentInsetLeft);
+      prototype.registerHybridSetter("contentInsetLeft", &HybridPdfViewerSpec::setContentInsetLeft);
+      prototype.registerHybridGetter("contentInsetRight", &HybridPdfViewerSpec::getContentInsetRight);
+      prototype.registerHybridSetter("contentInsetRight", &HybridPdfViewerSpec::setContentInsetRight);
       prototype.registerHybridGetter("enableZoom", &HybridPdfViewerSpec::getEnableZoom);
       prototype.registerHybridSetter("enableZoom", &HybridPdfViewerSpec::setEnableZoom);
       prototype.registerHybridGetter("minScale", &HybridPdfViewerSpec::getMinScale);

package/nitrogen/generated/shared/c++/HybridPdfViewerSpec.hpp

@@ -71,6 +71,14 @@ namespace margelo::nitro::pdfviewer {
       virtual void setEnablePaging(std::optional<bool> enablePaging) = 0;
       virtual std::optional<double> getSpacing() = 0;
       virtual void setSpacing(std::optional<double> spacing) = 0;
+      virtual std::optional<double> getContentInsetTop() = 0;
+      virtual void setContentInsetTop(std::optional<double> contentInsetTop) = 0;
+      virtual std::optional<double> getContentInsetBottom() = 0;
+      virtual void setContentInsetBottom(std::optional<double> contentInsetBottom) = 0;
+      virtual std::optional<double> getContentInsetLeft() = 0;
+      virtual void setContentInsetLeft(std::optional<double> contentInsetLeft) = 0;
+      virtual std::optional<double> getContentInsetRight() = 0;
+      virtual void setContentInsetRight(std::optional<double> contentInsetRight) = 0;
       virtual std::optional<bool> getEnableZoom() = 0;
       virtual void setEnableZoom(std::optional<bool> enableZoom) = 0;
       virtual std::optional<double> getMinScale() = 0;

package/nitrogen/generated/shared/c++/views/HybridPdfViewerComponent.cpp

@@ -65,6 +65,46 @@ namespace margelo::nitro::pdfviewer::views {
         throw std::runtime_error(std::string("PdfViewer.spacing: ") + exc.what());
       }
     }()),
+    contentInsetTop([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("contentInsetTop", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.contentInsetTop;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.contentInsetTop);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PdfViewer.contentInsetTop: ") + exc.what());
+      }
+    }()),
+    contentInsetBottom([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("contentInsetBottom", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.contentInsetBottom;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.contentInsetBottom);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PdfViewer.contentInsetBottom: ") + exc.what());
+      }
+    }()),
+    contentInsetLeft([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("contentInsetLeft", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.contentInsetLeft;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.contentInsetLeft);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PdfViewer.contentInsetLeft: ") + exc.what());
+      }
+    }()),
+    contentInsetRight([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("contentInsetRight", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.contentInsetRight;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.contentInsetRight);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PdfViewer.contentInsetRight: ") + exc.what());
+      }
+    }()),
     enableZoom([&]() -> CachedProp<std::optional<bool>> {
       try {
         const react::RawValue* rawValue = rawProps.at("enableZoom", nullptr, nullptr);
@@ -182,6 +222,10 @@ namespace margelo::nitro::pdfviewer::views {
     horizontal(other.horizontal),
     enablePaging(other.enablePaging),
     spacing(other.spacing),
+    contentInsetTop(other.contentInsetTop),
+    contentInsetBottom(other.contentInsetBottom),
+    contentInsetLeft(other.contentInsetLeft),
+    contentInsetRight(other.contentInsetRight),
     enableZoom(other.enableZoom),
     minScale(other.minScale),
     maxScale(other.maxScale),
@@ -200,6 +244,10 @@ namespace margelo::nitro::pdfviewer::views {
       case hashString("horizontal"): return true;
       case hashString("enablePaging"): return true;
       case hashString("spacing"): return true;
+      case hashString("contentInsetTop"): return true;
+      case hashString("contentInsetBottom"): return true;
+      case hashString("contentInsetLeft"): return true;
+      case hashString("contentInsetRight"): return true;
       case hashString("enableZoom"): return true;
       case hashString("minScale"): return true;
       case hashString("maxScale"): return true;

package/nitrogen/generated/shared/c++/views/HybridPdfViewerComponent.hpp

@@ -53,6 +53,10 @@ namespace margelo::nitro::pdfviewer::views {
     CachedProp<std::optional<bool>> horizontal;
     CachedProp<std::optional<bool>> enablePaging;
     CachedProp<std::optional<double>> spacing;
+    CachedProp<std::optional<double>> contentInsetTop;
+    CachedProp<std::optional<double>> contentInsetBottom;
+    CachedProp<std::optional<double>> contentInsetLeft;
+    CachedProp<std::optional<double>> contentInsetRight;
     CachedProp<std::optional<bool>> enableZoom;
     CachedProp<std::optional<double>> minScale;
     CachedProp<std::optional<double>> maxScale;

package/nitrogen/generated/shared/json/PdfViewerConfig.json

@@ -8,6 +8,10 @@
     "horizontal": true,
     "enablePaging": true,
     "spacing": true,
+    "contentInsetTop": true,
+    "contentInsetBottom": true,
+    "contentInsetLeft": true,
+    "contentInsetRight": true,
     "enableZoom": true,
     "minScale": true,
     "maxScale": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thatkid02/react-native-pdf-viewer",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Pdf viewer with page thumbnailsthumbnails",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/PdfViewer.nitro.ts

@@ -63,6 +63,27 @@ export interface PdfViewerProps extends HybridViewProps {
   enablePaging?: boolean;
   spacing?: number;
 
+  // Content insets - allows content to start below transparent headers/toolbars
+  /**
+   * Top content inset in pixels
+   * Useful for transparent/glass top bars - content starts below but scrolls behind
+   * @example 80 // Start content below 80px top bar
+   */
+  contentInsetTop?: number;
+  /**
+   * Bottom content inset in pixels
+   * Useful for transparent/glass bottom bars - content ends above but scrolls behind
+   */
+  contentInsetBottom?: number;
+  /**
+   * Left content inset in pixels
+   */
+  contentInsetLeft?: number;
+  /**
+   * Right content inset in pixels
+   */
+  contentInsetRight?: number;
+
   // Zoom controls
   enableZoom?: boolean;
   minScale?: number;

package/src/index.tsx

@@ -1,8 +1,9 @@
 import { getHostComponent, callback } from 'react-native-nitro-modules';
 import type { HybridRef } from 'react-native-nitro-modules';
-const PdfViewerConfig = require('../nitrogen/generated/shared/json/PdfViewerConfig.json');
 import type { PdfViewerMethods, PdfViewerProps } from './PdfViewer.nitro';
 
+const PdfViewerConfig = require('../nitrogen/generated/shared/json/PdfViewerConfig.json');
+
 export const PdfViewerView = getHostComponent<PdfViewerProps, PdfViewerMethods>(
   'PdfViewer',
   () => PdfViewerConfig