@webority-technologies/mobile-ui 0.0.7 → 0.0.8

package/RNMobileUiPdfRasterizer.podspec

@@ -0,0 +1,25 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name             = "RNMobileUiPdfRasterizer"
+  s.version          = package["version"]
+  s.license          = package["license"]
+  s.summary          = "Native PDF rasterizer for @webority-technologies/mobile-ui's DocumentViewer (PDFKit-backed)."
+  s.author           = package["author"]
+  s.homepage         = package["homepage"]
+
+  s.platforms        = { :ios => "15.1" }
+  s.requires_arc     = true
+  s.swift_version    = "5.9"
+
+  s.source           = { :git => "https://www.webority.com", :tag => s.version }
+  s.source_files     = "ios/*.{h,m,mm,swift}"
+
+  if ENV['RCT_NEW_ARCH_ENABLED'] == "1" then
+    install_modules_dependencies(s)
+  else
+    s.dependency   "React-Core"
+  end
+end

package/android/build.gradle

@@ -0,0 +1,64 @@
+buildscript {
+    ext.safeExtGet = { prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        gradlePluginPortal()
+    }
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet("kotlinVersion", "2.1.20")}")
+    }
+}
+
+def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: "com.facebook.react"
+}
+
+android {
+    namespace "com.webority.mobileui.pdfrasterizer"
+
+    buildToolsVersion safeExtGet("buildToolsVersion", "36.0.0")
+    compileSdkVersion safeExtGet("compileSdkVersion", 36)
+
+    buildFeatures {
+        buildConfig true
+    }
+    defaultConfig {
+        buildConfigField("boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString())
+        minSdkVersion safeExtGet("minSdkVersion", 24)
+        targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    }
+    lintOptions {
+        abortOnError false
+    }
+    sourceSets {
+        main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ["src/newarch"]
+            } else {
+                java.srcDirs += ["src/oldarch"]
+            }
+        }
+    }
+}
+
+repositories {
+    maven {
+        url("$rootDir/../node_modules/react-native/android")
+    }
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation "com.facebook.react:react-native:+"
+}

package/android/src/newarch/java/com/webority/mobileui/pdfrasterizer/PdfRasterizerModule.kt

@@ -0,0 +1,211 @@
+package com.webority.mobileui.pdfrasterizer
+
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.graphics.pdf.PdfRenderer
+import android.os.ParcelFileDescriptor
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.Arguments
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import kotlin.math.roundToInt
+
+/**
+ * Android implementation of the PdfRasterizer TurboModule, backed by the platform
+ * `android.graphics.pdf.PdfRenderer` (API 21+) — no third-party PDF library.
+ *
+ * `PdfRenderer` allows only ONE open page per document at a time, so every
+ * getPageInfo/renderPage call for a given handle is serialized on that handle's
+ * renderer instance via `synchronized`.
+ */
+class PdfRasterizerModule(reactContext: ReactApplicationContext) :
+    NativePdfRasterizerSpec(reactContext) {
+
+  private class OpenDocument(val renderer: PdfRenderer, val fd: ParcelFileDescriptor)
+
+  private val openDocuments = ConcurrentHashMap<String, OpenDocument>()
+  private val executor: ExecutorService = Executors.newCachedThreadPool()
+
+  companion object {
+    const val NAME = "PdfRasterizer"
+
+    private const val ERR_FILE_NOT_FOUND = "E_FILE_NOT_FOUND"
+    private const val ERR_INVALID_PDF = "E_INVALID_PDF"
+    private const val ERR_PASSWORD_PROTECTED = "E_PASSWORD_PROTECTED"
+    private const val ERR_UNKNOWN_HANDLE = "E_UNKNOWN_HANDLE"
+    private const val ERR_PAGE_OUT_OF_RANGE = "E_PAGE_OUT_OF_RANGE"
+
+    // Clamp the larger render dimension to avoid an OOM on a pathological scale value.
+    private const val MAX_RENDER_DIMENSION_PX = 4096
+  }
+
+  override fun getName(): String = NAME
+
+  override fun open(path: String, promise: Promise) {
+    executor.execute {
+      var fd: ParcelFileDescriptor? = null
+      try {
+        val barePath = normalizePath(path)
+        val file = File(barePath)
+        if (!file.exists()) {
+          promise.reject(ERR_FILE_NOT_FOUND, "PDF file not found at path: $path")
+          return@execute
+        }
+
+        fd = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
+        val renderer = PdfRenderer(fd)
+
+        val handle = UUID.randomUUID().toString()
+        openDocuments[handle] = OpenDocument(renderer, fd)
+
+        val page = renderer.openPage(0)
+        val result: WritableMap = Arguments.createMap()
+        result.putString("handle", handle)
+        result.putInt("pageCount", renderer.pageCount)
+        // PdfRenderer reports page size in points (1/72 in) — return as-is.
+        result.putDouble("pageWidth", page.width.toDouble())
+        result.putDouble("pageHeight", page.height.toDouble())
+        page.close()
+
+        promise.resolve(result)
+      } catch (e: SecurityException) {
+        // PdfRenderer throws SecurityException specifically for password-protected PDFs.
+        fd?.close()
+        promise.reject(ERR_PASSWORD_PROTECTED, "PDF is password-protected: $path", e)
+      } catch (e: IOException) {
+        fd?.close()
+        promise.reject(ERR_INVALID_PDF, "PDF file is missing or corrupt: $path", e)
+      } catch (e: Exception) {
+        fd?.close()
+        promise.reject(ERR_INVALID_PDF, "Failed to open PDF: ${e.message}", e)
+      }
+    }
+  }
+
+  override fun getPageInfo(handle: String, pageIndex: Double, promise: Promise) {
+    executor.execute {
+      val doc = openDocuments[handle]
+      if (doc == null) {
+        promise.reject(ERR_UNKNOWN_HANDLE, "Unknown PDF handle: $handle")
+        return@execute
+      }
+
+      val index = pageIndex.toInt()
+      synchronized(doc.renderer) {
+        if (index < 0 || index >= doc.renderer.pageCount) {
+          promise.reject(
+              ERR_PAGE_OUT_OF_RANGE,
+              "Page index $index out of range [0, ${doc.renderer.pageCount})")
+          return@synchronized
+        }
+
+        try {
+          val page = doc.renderer.openPage(index)
+          val result: WritableMap = Arguments.createMap()
+          result.putDouble("width", page.width.toDouble())
+          result.putDouble("height", page.height.toDouble())
+          page.close()
+          promise.resolve(result)
+        } catch (e: Exception) {
+          promise.reject(ERR_INVALID_PDF, "Failed to read page $index: ${e.message}", e)
+        }
+      }
+    }
+  }
+
+  override fun renderPage(handle: String, pageIndex: Double, scale: Double, promise: Promise) {
+    executor.execute {
+      val doc = openDocuments[handle]
+      if (doc == null) {
+        promise.reject(ERR_UNKNOWN_HANDLE, "Unknown PDF handle: $handle")
+        return@execute
+      }
+
+      val index = pageIndex.toInt()
+
+      synchronized(doc.renderer) {
+        if (index < 0 || index >= doc.renderer.pageCount) {
+          promise.reject(
+              ERR_PAGE_OUT_OF_RANGE,
+              "Page index $index out of range [0, ${doc.renderer.pageCount})")
+          return@synchronized
+        }
+
+        try {
+          val cacheDir = File(reactApplicationContext.cacheDir, "pdf-rasterizer-cache/$handle")
+          if (!cacheDir.exists()) {
+            cacheDir.mkdirs()
+          }
+          val outputFile = File(cacheDir, "$index-$scale.png")
+
+          if (outputFile.exists()) {
+            promise.resolve("file://${outputFile.absolutePath}")
+            return@synchronized
+          }
+
+          val page = doc.renderer.openPage(index)
+          val targetWidth = clampDimension((page.width * scale).roundToInt())
+          val targetHeight = clampDimension((page.height * scale).roundToInt())
+
+          val bitmap = Bitmap.createBitmap(targetWidth, targetHeight, Bitmap.Config.ARGB_8888)
+          // Fill white first — PDF transparency renders as black on some devices otherwise.
+          bitmap.eraseColor(Color.WHITE)
+          page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
+          page.close()
+
+          FileOutputStream(outputFile).use { out ->
+            bitmap.compress(Bitmap.CompressFormat.PNG, 100, out)
+          }
+          bitmap.recycle()
+
+          promise.resolve("file://${outputFile.absolutePath}")
+        } catch (e: Exception) {
+          promise.reject(ERR_INVALID_PDF, "Failed to render page $index: ${e.message}", e)
+        }
+      }
+    }
+  }
+
+  override fun close(handle: String, promise: Promise) {
+    executor.execute {
+      val doc = openDocuments.remove(handle)
+      if (doc != null) {
+        try {
+          doc.renderer.close()
+        } catch (_: Exception) {
+          // Best-effort.
+        }
+        try {
+          doc.fd.close()
+        } catch (_: Exception) {
+          // Best-effort.
+        }
+      }
+
+      try {
+        File(reactApplicationContext.cacheDir, "pdf-rasterizer-cache/$handle").deleteRecursively()
+      } catch (_: Exception) {
+        // Best-effort — cache eviction failure must not fail an otherwise-idempotent close.
+      }
+
+      // Idempotent: resolve even if the handle was already unknown or already closed.
+      promise.resolve(null)
+    }
+  }
+
+  private fun clampDimension(dimension: Int): Int {
+    val positive = if (dimension < 1) 1 else dimension
+    return if (positive > MAX_RENDER_DIMENSION_PX) MAX_RENDER_DIMENSION_PX else positive
+  }
+
+  private fun normalizePath(path: String): String {
+    return if (path.startsWith("file://")) path.removePrefix("file://") else path
+  }
+}

package/android/src/newarch/java/com/webority/mobileui/pdfrasterizer/PdfRasterizerPackage.kt

@@ -0,0 +1,33 @@
+package com.webority.mobileui.pdfrasterizer
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class PdfRasterizerPackage : TurboReactPackage() {
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == PdfRasterizerModule.NAME) {
+      PdfRasterizerModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      mapOf(
+          PdfRasterizerModule.NAME to
+              ReactModuleInfo(
+                  PdfRasterizerModule.NAME,
+                  PdfRasterizerModule.NAME,
+                  false, // canOverrideExistingModule
+                  false, // needsEagerInit
+                  false, // isCxxModule
+                  true // isTurboModule
+                  ))
+    }
+  }
+}

package/ios/PdfRasterizer.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNMobileUiPdfRasterizerSpec/RNMobileUiPdfRasterizerSpec.h>
+
+@interface PdfRasterizer : NSObject <NativePdfRasterizerSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface PdfRasterizer : NSObject <RCTBridgeModule>
+#endif
+
+@end

package/ios/PdfRasterizer.mm

@@ -0,0 +1,292 @@
+#import "PdfRasterizer.h"
+
+#import <CoreGraphics/CoreGraphics.h>
+#import <UIKit/UIKit.h>
+
+static NSString *const kCacheDirName = @"pdf-rasterizer-cache";
+
+// Wraps a CGPDFDocumentRef so ARC can own its lifetime inside an NSMutableDictionary —
+// CGPDFDocumentRef is a plain CF type with no toll-free-bridged Foundation counterpart.
+@interface PdfRasterizerDocumentBox : NSObject
+@property (nonatomic, assign, readonly) CGPDFDocumentRef document;
+- (instancetype)initWithDocument:(CGPDFDocumentRef)document;
+@end
+
+@implementation PdfRasterizerDocumentBox
+- (instancetype)initWithDocument:(CGPDFDocumentRef)document {
+  if (self = [super init]) {
+    _document = CGPDFDocumentRetain(document);
+  }
+  return self;
+}
+- (void)dealloc {
+  if (_document != NULL) {
+    CGPDFDocumentRelease(_document);
+    _document = NULL;
+  }
+}
+@end
+
+@interface PdfRasterizer ()
+@property (nonatomic, strong) NSMutableDictionary<NSString *, PdfRasterizerDocumentBox *> *documents;
+@property (nonatomic, strong) dispatch_queue_t queue;
+@end
+
+@implementation PdfRasterizer
+
+RCT_EXPORT_MODULE(PdfRasterizer)
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _documents = [NSMutableDictionary new];
+    // Serial: guards the handle->document dictionary AND serializes renders,
+    // since CGPDFDocument/CGPDFPage are not safe under concurrent access.
+    _queue = dispatch_queue_create("com.webority.mobileui.pdfrasterizer", DISPATCH_QUEUE_SERIAL);
+  }
+  return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+#pragma mark - Helpers
+
++ (NSString *)normalizedPathFromPath:(NSString *)path {
+  NSString *scheme = @"file://";
+  if ([path hasPrefix:scheme]) {
+    return [path substringFromIndex:scheme.length];
+  }
+  return path;
+}
+
+// Page size in points, respecting rotation (90/270 swap width & height) — same
+// logic used both for open()'s page-0 read and getPageInfo()'s arbitrary page.
++ (CGSize)pageSizeForPage:(CGPDFPageRef)page {
+  CGRect box = CGPDFPageGetBoxRect(page, kCGPDFMediaBox);
+  int rotation = CGPDFPageGetRotationAngle(page);
+  CGFloat width = box.size.width;
+  CGFloat height = box.size.height;
+  if (rotation == 90 || rotation == 270) {
+    CGFloat tmp = width;
+    width = height;
+    height = tmp;
+  }
+  return CGSizeMake(width, height);
+}
+
+- (NSString *)cacheDirectoryForHandle:(NSString *)handle {
+  return [[NSTemporaryDirectory() stringByAppendingPathComponent:kCacheDirName]
+      stringByAppendingPathComponent:handle];
+}
+
+#pragma mark - Spec methods
+
+- (void)open:(NSString *)path
+     resolve:(RCTPromiseResolveBlock)resolve
+      reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(self.queue, ^{
+    NSString *normalizedPath = [PdfRasterizer normalizedPathFromPath:path];
+
+    if (![[NSFileManager defaultManager] fileExistsAtPath:normalizedPath]) {
+      reject(@"E_FILE_NOT_FOUND", [NSString stringWithFormat:@"No file at path: %@", path], nil);
+      return;
+    }
+
+    NSURL *url = [NSURL fileURLWithPath:normalizedPath];
+    CGPDFDocumentRef document = CGPDFDocumentCreateWithURL((__bridge CFURLRef)url);
+    if (document == NULL) {
+      reject(@"E_INVALID_PDF", @"The file is not a valid PDF document.", nil);
+      return;
+    }
+
+    if (CGPDFDocumentIsEncrypted(document)) {
+      // Only ever try the empty password — a real password prompt is a UI
+      // concern the caller owns, not this module's job to solve.
+      CGPDFDocumentUnlockWithPassword(document, "");
+      if (!CGPDFDocumentIsUnlocked(document)) {
+        CGPDFDocumentRelease(document);
+        reject(@"E_PASSWORD_PROTECTED", @"The PDF is password-protected.", nil);
+        return;
+      }
+    }
+
+    size_t pageCount = CGPDFDocumentGetNumberOfPages(document);
+    if (pageCount == 0) {
+      CGPDFDocumentRelease(document);
+      reject(@"E_INVALID_PDF", @"The PDF document has no pages.", nil);
+      return;
+    }
+
+    CGPDFPageRef firstPage = CGPDFDocumentGetPage(document, 1);
+    if (firstPage == NULL) {
+      CGPDFDocumentRelease(document);
+      reject(@"E_INVALID_PDF", @"Unable to read the PDF's first page.", nil);
+      return;
+    }
+
+    CGSize size = [PdfRasterizer pageSizeForPage:firstPage];
+
+    NSString *handle = [[NSUUID UUID] UUIDString];
+    PdfRasterizerDocumentBox *box = [[PdfRasterizerDocumentBox alloc] initWithDocument:document];
+    CGPDFDocumentRelease(document); // box retained its own reference above
+    self.documents[handle] = box;
+
+    resolve(@{
+      @"handle" : handle,
+      @"pageCount" : @(pageCount),
+      @"pageWidth" : @(size.width),
+      @"pageHeight" : @(size.height),
+    });
+  });
+}
+
+- (void)getPageInfo:(NSString *)handle
+          pageIndex:(double)pageIndex
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(self.queue, ^{
+    PdfRasterizerDocumentBox *box = self.documents[handle];
+    if (box == nil) {
+      reject(@"E_UNKNOWN_HANDLE", [NSString stringWithFormat:@"No open document for handle: %@", handle], nil);
+      return;
+    }
+
+    NSInteger index = (NSInteger)pageIndex;
+    size_t pageCount = CGPDFDocumentGetNumberOfPages(box.document);
+    if (index < 0 || (size_t)index >= pageCount) {
+      reject(@"E_PAGE_OUT_OF_RANGE",
+             [NSString stringWithFormat:@"Page index %ld out of range (0..%zu).", (long)index, pageCount - 1],
+             nil);
+      return;
+    }
+
+    CGPDFPageRef page = CGPDFDocumentGetPage(box.document, (size_t)index + 1);
+    if (page == NULL) {
+      reject(@"E_PAGE_OUT_OF_RANGE", [NSString stringWithFormat:@"Unable to read page %ld.", (long)index], nil);
+      return;
+    }
+
+    CGSize size = [PdfRasterizer pageSizeForPage:page];
+    resolve(@{
+      @"width" : @(size.width),
+      @"height" : @(size.height),
+    });
+  });
+}
+
+- (void)renderPage:(NSString *)handle
+         pageIndex:(double)pageIndex
+             scale:(double)scale
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(self.queue, ^{
+    PdfRasterizerDocumentBox *box = self.documents[handle];
+    if (box == nil) {
+      reject(@"E_UNKNOWN_HANDLE", [NSString stringWithFormat:@"No open document for handle: %@", handle], nil);
+      return;
+    }
+
+    NSInteger index = (NSInteger)pageIndex;
+    size_t pageCount = CGPDFDocumentGetNumberOfPages(box.document);
+    if (index < 0 || (size_t)index >= pageCount) {
+      reject(@"E_PAGE_OUT_OF_RANGE",
+             [NSString stringWithFormat:@"Page index %ld out of range (0..%zu).", (long)index, pageCount - 1],
+             nil);
+      return;
+    }
+
+    CGPDFPageRef page = CGPDFDocumentGetPage(box.document, (size_t)index + 1);
+    if (page == NULL) {
+      reject(@"E_PAGE_OUT_OF_RANGE", [NSString stringWithFormat:@"Unable to read page %ld.", (long)index], nil);
+      return;
+    }
+
+    NSString *cacheDir = [self cacheDirectoryForHandle:handle];
+    NSError *dirError = nil;
+    if (![[NSFileManager defaultManager] createDirectoryAtPath:cacheDir
+                                    withIntermediateDirectories:YES
+                                                     attributes:nil
+                                                          error:&dirError]) {
+      reject(@"E_WRITE_FAILED",
+             [NSString stringWithFormat:@"Could not create cache directory: %@", dirError.localizedDescription],
+             dirError);
+      return;
+    }
+
+    NSString *fileName = [NSString stringWithFormat:@"%ld-%g.png", (long)index, scale];
+    NSString *filePath = [cacheDir stringByAppendingPathComponent:fileName];
+
+    if ([[NSFileManager defaultManager] fileExistsAtPath:filePath]) {
+      resolve([[NSURL fileURLWithPath:filePath] absoluteString]);
+      return;
+    }
+
+    CGSize pageSize = [PdfRasterizer pageSizeForPage:page];
+    CGSize renderSize = CGSizeMake(pageSize.width * scale, pageSize.height * scale);
+    if (renderSize.width <= 0 || renderSize.height <= 0) {
+      reject(@"E_RENDER_FAILED", @"Computed render size is empty.", nil);
+      return;
+    }
+
+    UIGraphicsImageRendererFormat *format = [UIGraphicsImageRendererFormat preferredFormat];
+    format.opaque = YES;
+    format.scale = 1.0; // renderSize already carries the caller's scale factor
+    UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc] initWithSize:renderSize format:format];
+
+    UIImage *image = [renderer imageWithActions:^(UIGraphicsImageRendererContext * _Nonnull rendererContext) {
+      CGContextRef ctx = rendererContext.CGContext;
+
+      CGContextSetFillColorWithColor(ctx, [UIColor whiteColor].CGColor);
+      CGContextFillRect(ctx, CGRectMake(0, 0, renderSize.width, renderSize.height));
+
+      CGContextSaveGState(ctx);
+      // Flip into PDF's bottom-left-origin space, then let CGPDFPageGetDrawingTransform
+      // account for the page's own rotation/media box when mapping into renderSize.
+      CGContextTranslateCTM(ctx, 0, renderSize.height);
+      CGContextScaleCTM(ctx, 1, -1);
+      CGAffineTransform transform = CGPDFPageGetDrawingTransform(
+          page, kCGPDFMediaBox, CGRectMake(0, 0, renderSize.width, renderSize.height), 0, true);
+      CGContextConcatCTM(ctx, transform);
+      CGContextDrawPDFPage(ctx, page);
+      CGContextRestoreGState(ctx);
+    }];
+
+    NSData *pngData = UIImagePNGRepresentation(image);
+    if (pngData == nil) {
+      reject(@"E_RENDER_FAILED", @"Failed to encode the rendered page as PNG.", nil);
+      return;
+    }
+
+    NSError *writeError = nil;
+    if (![pngData writeToFile:filePath options:NSDataWritingAtomic error:&writeError]) {
+      reject(@"E_WRITE_FAILED",
+             [NSString stringWithFormat:@"Could not write rendered page: %@", writeError.localizedDescription],
+             writeError);
+      return;
+    }
+
+    resolve([[NSURL fileURLWithPath:filePath] absoluteString]);
+  });
+}
+
+- (void)close:(NSString *)handle resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(self.queue, ^{
+    [self.documents removeObjectForKey:handle];
+
+    NSString *cacheDir = [self cacheDirectoryForHandle:handle];
+    // Best-effort cleanup — a stale cache dir on delete failure is not worth
+    // failing an otherwise-successful close over.
+    [[NSFileManager defaultManager] removeItemAtPath:cacheDir error:nil];
+
+    resolve(nil);
+  });
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativePdfRasterizerSpecJSI>(params);
+}
+#endif
+
+@end

package/lib/commonjs/components/DocumentViewer/DocumentViewer.js

@@ -5,21 +5,47 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.DocumentViewer = void 0;
 var _mobileCore = require("@webority-technologies/mobile-core");
+var _download = require("@webority-technologies/mobile-core/download");
 var _react = require("react");
 var _reactNative = require("react-native");
-var _reactNativePdf = _interopRequireDefault(require("react-native-pdf"));
+var _NativePdfRasterizer = _interopRequireDefault(require("../../specs/NativePdfRasterizer.js"));
 var _index = require("../Spinner/index.js");
 var _jsxRuntime = require("react/jsx-runtime");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+const MAX_RENDER_SCALE = 3;
 const toError = value => value instanceof Error ? value : new Error(String(value));
 
+/** The renderPage scale is capped so a very wide view never asks the native
+ * rasterizer for an unbounded bitmap (see react-native.md's ARGB_8888 4-bytes/px
+ * guidance) — both native sides additionally clamp their own pixel ceiling. */
+const scaleForWidth = (viewWidthPx, pageWidthPt) => {
+  if (pageWidthPt <= 0) {
+    return 1;
+  }
+  const raw = viewWidthPx / pageWidthPt * _reactNative.PixelRatio.get();
+  return Math.min(Math.max(raw, 1), MAX_RENDER_SCALE);
+};
+const localPathFromSource = async source => {
+  if (!HAS_SCHEME.test(source.uri) || source.uri.startsWith('file://')) {
+    return source.uri.replace(/^file:\/\//, '');
+  }
+  const result = await (0, _download.downloadFile)({
+    url: source.uri,
+    headers: source.headers,
+    authenticated: false,
+    overwrite: source.cache === false
+  });
+  return result.path;
+};
 /**
- * Renders a PDF only — the WebView fallback consumer apps use for non-PDF
- * office documents is a distinct rendering strategy and stays app-side.
+ * Renders a PDF via our own native rasterizer (PDFKit on iOS, PdfRenderer on
+ * Android) — no third-party PDF dependency. The WebView fallback consumer
+ * apps use for non-PDF office documents is a distinct rendering strategy and
+ * stays app-side.
  */
 const DocumentViewer = ({
   source,
-  trustAllCerts = false,
   onLoadComplete,
   onPageChanged,
   onError,
@@ -28,29 +54,158 @@ const DocumentViewer = ({
   testID,
   accessibilityLabel
 }) => {
-  const renderActivityIndicator = (0, _react.useCallback)(() => loadingIndicator ? loadingIndicator() : /*#__PURE__*/(0, _jsxRuntime.jsx)(_index.Spinner, {
-    size: "lg"
-  }), [loadingIndicator]);
-  const handleError = (0, _react.useCallback)(error => {
-    const err = toError(error);
-    _mobileCore.Logger.error('[@webority-technologies/mobile-ui] DocumentViewer failed to load.', err);
-    onError?.(err);
-  }, [onError]);
-  const handleLoadComplete = (0, _react.useCallback)(numberOfPages => onLoadComplete?.(numberOfPages), [onLoadComplete]);
+  const {
+    width: windowWidth
+  } = (0, _reactNative.useWindowDimensions)();
+  const [pageCount, setPageCount] = (0, _react.useState)(0);
+  const [pageSizePt, setPageSizePt] = (0, _react.useState)({
+    width: 612,
+    height: 792
+  }); // US Letter fallback
+  const pageAspect = pageSizePt.height / pageSizePt.width;
+  const [renderedPages, setRenderedPages] = (0, _react.useState)({});
+  const handleRef = (0, _react.useRef)(null);
+  const onErrorRef = (0, _react.useRef)(onError);
+  onErrorRef.current = onError;
+  const onLoadCompleteRef = (0, _react.useRef)(onLoadComplete);
+  onLoadCompleteRef.current = onLoadComplete;
+  const documentSource = (0, _react.useMemo)(() => ({
+    uri: source.uri,
+    headers: source.headers,
+    cache: source.cache
+  }), [source.uri, source.headers, source.cache]);
+  (0, _react.useEffect)(() => {
+    let cancelled = false;
+    const load = async () => {
+      if (!_NativePdfRasterizer.default) {
+        onErrorRef.current?.(new Error('[@webority-technologies/mobile-ui] PdfRasterizer native module is not linked. ' + 'Run pod install / rebuild the app after adding @webority-technologies/mobile-ui.'));
+        return;
+      }
+      try {
+        const path = await localPathFromSource(documentSource);
+        if (cancelled) {
+          return;
+        }
+        const opened = await _NativePdfRasterizer.default.open(path);
+        if (cancelled) {
+          await _NativePdfRasterizer.default.close(opened.handle).catch(() => undefined);
+          return;
+        }
+        handleRef.current = opened.handle;
+        setPageCount(opened.pageCount);
+        if (opened.pageWidth > 0 && opened.pageHeight > 0) {
+          setPageSizePt({
+            width: opened.pageWidth,
+            height: opened.pageHeight
+          });
+        }
+        onLoadCompleteRef.current?.(opened.pageCount);
+      } catch (error) {
+        if (!cancelled) {
+          const err = toError(error);
+          _mobileCore.Logger.error('[@webority-technologies/mobile-ui] DocumentViewer failed to load.', err);
+          onErrorRef.current?.(err);
+        }
+      }
+    };
+    void load();
+    return () => {
+      cancelled = true;
+    };
+  }, [documentSource]);
+  (0, _react.useEffect)(() => () => {
+    const openHandle = handleRef.current;
+    if (openHandle) {
+      _NativePdfRasterizer.default?.close(openHandle).catch(() => undefined);
+    }
+  }, []);
+  const renderPageImage = (0, _react.useCallback)(async pageIndex => {
+    const openHandle = handleRef.current;
+    if (!openHandle || !_NativePdfRasterizer.default) {
+      return;
+    }
+    try {
+      const scale = scaleForWidth(windowWidth, pageSizePt.width);
+      const uri = await _NativePdfRasterizer.default.renderPage(openHandle, pageIndex, scale);
+      setRenderedPages(prev => prev[pageIndex] ? prev : {
+        ...prev,
+        [pageIndex]: uri
+      });
+    } catch (error) {
+      _mobileCore.Logger.error(`[@webority-technologies/mobile-ui] DocumentViewer failed to render page ${pageIndex}.`, toError(error));
+    }
+  }, [pageSizePt.width, windowWidth]);
+  const data = (0, _react.useMemo)(() => Array.from({
+    length: pageCount
+  }, (_unused, index) => ({
+    index
+  })), [pageCount]);
+  const onPageChangedRef = (0, _react.useRef)(onPageChanged);
+  onPageChangedRef.current = onPageChanged;
+  const pageCountRef = (0, _react.useRef)(pageCount);
+  pageCountRef.current = pageCount;
+  const renderPageImageRef = (0, _react.useRef)(renderPageImage);
+  renderPageImageRef.current = renderPageImage;
+
+  // A stable function identity: FlatList warns if onViewableItemsChanged changes
+  // identity across renders, so the current values it needs are read from refs
+  // kept up to date every render instead of being closed over here.
+  const onViewableItemsChanged = (0, _react.useRef)(({
+    viewableItems
+  }) => {
+    const first = viewableItems[0]?.item;
+    if (first) {
+      onPageChangedRef.current?.(first.index + 1, pageCountRef.current);
+      viewableItems.forEach(v => void renderPageImageRef.current(v.item.index));
+    }
+  });
+  const renderItem = (0, _react.useCallback)(({
+    item
+  }) => {
+    const uri = renderedPages[item.index];
+    const pageWidth = windowWidth;
+    const pageHeight = pageWidth * pageAspect;
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+      style: [styles.page, {
+        width: pageWidth,
+        height: pageHeight
+      }],
+      children: uri ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.Image, {
+        source: {
+          uri
+        },
+        style: styles.pageImage,
+        resizeMode: "contain",
+        accessible: false
+      }) : /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+        style: styles.pagePlaceholder,
+        children: loadingIndicator ? loadingIndicator() : /*#__PURE__*/(0, _jsxRuntime.jsx)(_index.Spinner, {
+          size: "lg"
+        })
+      })
+    });
+  }, [loadingIndicator, pageAspect, renderedPages, windowWidth]);
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
     style: [styles.root, style],
     testID: testID,
     accessible: accessibilityLabel !== undefined,
     accessibilityLabel: accessibilityLabel,
     accessibilityRole: "none",
-    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNativePdf.default, {
-      source: source,
-      trustAllCerts: trustAllCerts,
-      style: styles.pdf,
-      renderActivityIndicator: renderActivityIndicator,
-      onLoadComplete: handleLoadComplete,
-      onPageChanged: onPageChanged,
-      onError: handleError
+    children: pageCount === 0 ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.View, {
+      style: styles.pagePlaceholder,
+      children: loadingIndicator ? loadingIndicator() : /*#__PURE__*/(0, _jsxRuntime.jsx)(_index.Spinner, {
+        size: "lg"
+      })
+    }) : /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactNative.FlatList, {
+      data: data,
+      keyExtractor: item => String(item.index),
+      renderItem: renderItem,
+      onViewableItemsChanged: onViewableItemsChanged.current,
+      viewabilityConfig: {
+        itemVisiblePercentThreshold: 50
+      },
+      initialNumToRender: 2,
+      windowSize: 3
     })
   });
 };
@@ -60,10 +215,16 @@ const styles = _reactNative.StyleSheet.create({
   root: {
     flex: 1
   },
-  pdf: {
+  page: {
+    alignSelf: 'center'
+  },
+  pageImage: {
+    flex: 1
+  },
+  pagePlaceholder: {
     flex: 1,
-    width: '100%',
-    height: '100%'
+    alignItems: 'center',
+    justifyContent: 'center'
   }
 });
 var _default = exports.default = DocumentViewer;

package/lib/commonjs/specs/NativePdfRasterizer.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _default = exports.default = _reactNative.TurboModuleRegistry.get('PdfRasterizer');
+//# sourceMappingURL=NativePdfRasterizer.js.map

package/lib/module/components/DocumentViewer/DocumentViewer.js

@@ -1,20 +1,46 @@
 "use strict";
 
 import { Logger } from '@webority-technologies/mobile-core';
-import { useCallback } from 'react';
-import { StyleSheet, View } from 'react-native';
-import Pdf from 'react-native-pdf';
+import { downloadFile } from '@webority-technologies/mobile-core/download';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { FlatList, Image, PixelRatio, StyleSheet, useWindowDimensions, View } from 'react-native';
+import PdfRasterizer from "../../specs/NativePdfRasterizer.js";
 import { Spinner } from "../Spinner/index.js";
 import { jsx as _jsx } from "react/jsx-runtime";
+const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+const MAX_RENDER_SCALE = 3;
 const toError = value => value instanceof Error ? value : new Error(String(value));
 
+/** The renderPage scale is capped so a very wide view never asks the native
+ * rasterizer for an unbounded bitmap (see react-native.md's ARGB_8888 4-bytes/px
+ * guidance) — both native sides additionally clamp their own pixel ceiling. */
+const scaleForWidth = (viewWidthPx, pageWidthPt) => {
+  if (pageWidthPt <= 0) {
+    return 1;
+  }
+  const raw = viewWidthPx / pageWidthPt * PixelRatio.get();
+  return Math.min(Math.max(raw, 1), MAX_RENDER_SCALE);
+};
+const localPathFromSource = async source => {
+  if (!HAS_SCHEME.test(source.uri) || source.uri.startsWith('file://')) {
+    return source.uri.replace(/^file:\/\//, '');
+  }
+  const result = await downloadFile({
+    url: source.uri,
+    headers: source.headers,
+    authenticated: false,
+    overwrite: source.cache === false
+  });
+  return result.path;
+};
 /**
- * Renders a PDF only — the WebView fallback consumer apps use for non-PDF
- * office documents is a distinct rendering strategy and stays app-side.
+ * Renders a PDF via our own native rasterizer (PDFKit on iOS, PdfRenderer on
+ * Android) — no third-party PDF dependency. The WebView fallback consumer
+ * apps use for non-PDF office documents is a distinct rendering strategy and
+ * stays app-side.
  */
 export const DocumentViewer = ({
   source,
-  trustAllCerts = false,
   onLoadComplete,
   onPageChanged,
   onError,
@@ -23,29 +49,158 @@ export const DocumentViewer = ({
   testID,
   accessibilityLabel
 }) => {
-  const renderActivityIndicator = useCallback(() => loadingIndicator ? loadingIndicator() : /*#__PURE__*/_jsx(Spinner, {
-    size: "lg"
-  }), [loadingIndicator]);
-  const handleError = useCallback(error => {
-    const err = toError(error);
-    Logger.error('[@webority-technologies/mobile-ui] DocumentViewer failed to load.', err);
-    onError?.(err);
-  }, [onError]);
-  const handleLoadComplete = useCallback(numberOfPages => onLoadComplete?.(numberOfPages), [onLoadComplete]);
+  const {
+    width: windowWidth
+  } = useWindowDimensions();
+  const [pageCount, setPageCount] = useState(0);
+  const [pageSizePt, setPageSizePt] = useState({
+    width: 612,
+    height: 792
+  }); // US Letter fallback
+  const pageAspect = pageSizePt.height / pageSizePt.width;
+  const [renderedPages, setRenderedPages] = useState({});
+  const handleRef = useRef(null);
+  const onErrorRef = useRef(onError);
+  onErrorRef.current = onError;
+  const onLoadCompleteRef = useRef(onLoadComplete);
+  onLoadCompleteRef.current = onLoadComplete;
+  const documentSource = useMemo(() => ({
+    uri: source.uri,
+    headers: source.headers,
+    cache: source.cache
+  }), [source.uri, source.headers, source.cache]);
+  useEffect(() => {
+    let cancelled = false;
+    const load = async () => {
+      if (!PdfRasterizer) {
+        onErrorRef.current?.(new Error('[@webority-technologies/mobile-ui] PdfRasterizer native module is not linked. ' + 'Run pod install / rebuild the app after adding @webority-technologies/mobile-ui.'));
+        return;
+      }
+      try {
+        const path = await localPathFromSource(documentSource);
+        if (cancelled) {
+          return;
+        }
+        const opened = await PdfRasterizer.open(path);
+        if (cancelled) {
+          await PdfRasterizer.close(opened.handle).catch(() => undefined);
+          return;
+        }
+        handleRef.current = opened.handle;
+        setPageCount(opened.pageCount);
+        if (opened.pageWidth > 0 && opened.pageHeight > 0) {
+          setPageSizePt({
+            width: opened.pageWidth,
+            height: opened.pageHeight
+          });
+        }
+        onLoadCompleteRef.current?.(opened.pageCount);
+      } catch (error) {
+        if (!cancelled) {
+          const err = toError(error);
+          Logger.error('[@webority-technologies/mobile-ui] DocumentViewer failed to load.', err);
+          onErrorRef.current?.(err);
+        }
+      }
+    };
+    void load();
+    return () => {
+      cancelled = true;
+    };
+  }, [documentSource]);
+  useEffect(() => () => {
+    const openHandle = handleRef.current;
+    if (openHandle) {
+      PdfRasterizer?.close(openHandle).catch(() => undefined);
+    }
+  }, []);
+  const renderPageImage = useCallback(async pageIndex => {
+    const openHandle = handleRef.current;
+    if (!openHandle || !PdfRasterizer) {
+      return;
+    }
+    try {
+      const scale = scaleForWidth(windowWidth, pageSizePt.width);
+      const uri = await PdfRasterizer.renderPage(openHandle, pageIndex, scale);
+      setRenderedPages(prev => prev[pageIndex] ? prev : {
+        ...prev,
+        [pageIndex]: uri
+      });
+    } catch (error) {
+      Logger.error(`[@webority-technologies/mobile-ui] DocumentViewer failed to render page ${pageIndex}.`, toError(error));
+    }
+  }, [pageSizePt.width, windowWidth]);
+  const data = useMemo(() => Array.from({
+    length: pageCount
+  }, (_unused, index) => ({
+    index
+  })), [pageCount]);
+  const onPageChangedRef = useRef(onPageChanged);
+  onPageChangedRef.current = onPageChanged;
+  const pageCountRef = useRef(pageCount);
+  pageCountRef.current = pageCount;
+  const renderPageImageRef = useRef(renderPageImage);
+  renderPageImageRef.current = renderPageImage;
+
+  // A stable function identity: FlatList warns if onViewableItemsChanged changes
+  // identity across renders, so the current values it needs are read from refs
+  // kept up to date every render instead of being closed over here.
+  const onViewableItemsChanged = useRef(({
+    viewableItems
+  }) => {
+    const first = viewableItems[0]?.item;
+    if (first) {
+      onPageChangedRef.current?.(first.index + 1, pageCountRef.current);
+      viewableItems.forEach(v => void renderPageImageRef.current(v.item.index));
+    }
+  });
+  const renderItem = useCallback(({
+    item
+  }) => {
+    const uri = renderedPages[item.index];
+    const pageWidth = windowWidth;
+    const pageHeight = pageWidth * pageAspect;
+    return /*#__PURE__*/_jsx(View, {
+      style: [styles.page, {
+        width: pageWidth,
+        height: pageHeight
+      }],
+      children: uri ? /*#__PURE__*/_jsx(Image, {
+        source: {
+          uri
+        },
+        style: styles.pageImage,
+        resizeMode: "contain",
+        accessible: false
+      }) : /*#__PURE__*/_jsx(View, {
+        style: styles.pagePlaceholder,
+        children: loadingIndicator ? loadingIndicator() : /*#__PURE__*/_jsx(Spinner, {
+          size: "lg"
+        })
+      })
+    });
+  }, [loadingIndicator, pageAspect, renderedPages, windowWidth]);
   return /*#__PURE__*/_jsx(View, {
     style: [styles.root, style],
     testID: testID,
     accessible: accessibilityLabel !== undefined,
     accessibilityLabel: accessibilityLabel,
     accessibilityRole: "none",
-    children: /*#__PURE__*/_jsx(Pdf, {
-      source: source,
-      trustAllCerts: trustAllCerts,
-      style: styles.pdf,
-      renderActivityIndicator: renderActivityIndicator,
-      onLoadComplete: handleLoadComplete,
-      onPageChanged: onPageChanged,
-      onError: handleError
+    children: pageCount === 0 ? /*#__PURE__*/_jsx(View, {
+      style: styles.pagePlaceholder,
+      children: loadingIndicator ? loadingIndicator() : /*#__PURE__*/_jsx(Spinner, {
+        size: "lg"
+      })
+    }) : /*#__PURE__*/_jsx(FlatList, {
+      data: data,
+      keyExtractor: item => String(item.index),
+      renderItem: renderItem,
+      onViewableItemsChanged: onViewableItemsChanged.current,
+      viewabilityConfig: {
+        itemVisiblePercentThreshold: 50
+      },
+      initialNumToRender: 2,
+      windowSize: 3
     })
   });
 };
@@ -54,10 +209,16 @@ const styles = StyleSheet.create({
   root: {
     flex: 1
   },
-  pdf: {
+  page: {
+    alignSelf: 'center'
+  },
+  pageImage: {
+    flex: 1
+  },
+  pagePlaceholder: {
     flex: 1,
-    width: '100%',
-    height: '100%'
+    alignItems: 'center',
+    justifyContent: 'center'
   }
 });
 export default DocumentViewer;

package/lib/module/specs/NativePdfRasterizer.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('PdfRasterizer');
+//# sourceMappingURL=NativePdfRasterizer.js.map

package/lib/typescript/commonjs/components/DocumentViewer/DocumentViewer.d.ts

@@ -3,12 +3,11 @@ import type { StyleProp, ViewStyle } from 'react-native';
 export interface DocumentViewerSource {
     uri: string;
     headers?: Record<string, string>;
+    /** Reuse a previously downloaded copy of this URL instead of re-fetching. Default true. */
     cache?: boolean;
 }
 export interface DocumentViewerProps {
     source: DocumentViewerSource;
-    /** Trust self-signed / invalid certs on the document request. Default false. */
-    trustAllCerts?: boolean;
     onLoadComplete?: (numberOfPages: number) => void;
     onPageChanged?: (page: number, numberOfPages: number) => void;
     onError?: (error: Error) => void;
@@ -19,8 +18,10 @@ export interface DocumentViewerProps {
     accessibilityLabel?: string;
 }
 /**
- * Renders a PDF only — the WebView fallback consumer apps use for non-PDF
- * office documents is a distinct rendering strategy and stays app-side.
+ * Renders a PDF via our own native rasterizer (PDFKit on iOS, PdfRenderer on
+ * Android) — no third-party PDF dependency. The WebView fallback consumer
+ * apps use for non-PDF office documents is a distinct rendering strategy and
+ * stays app-side.
  */
 export declare const DocumentViewer: React.FC<DocumentViewerProps>;
 export default DocumentViewer;

package/lib/typescript/commonjs/specs/NativePdfRasterizer.d.ts

@@ -0,0 +1,40 @@
+import type { TurboModule } from 'react-native';
+export interface PdfDocumentInfo {
+    /** Opaque handle for every subsequent call (getPageInfo/renderPage/close) — NOT the file path. */
+    handle: string;
+    pageCount: number;
+    /** Points (1/72 in), the unrotated page size of page 0 — a per-page size read happens in renderPage. */
+    pageWidth: number;
+    pageHeight: number;
+}
+export interface PdfPageInfo {
+    width: number;
+    height: number;
+}
+export interface Spec extends TurboModule {
+    /**
+     * Opens a LOCAL pdf file (a file:// path or bare absolute path — no http(s), no
+     * headers, no auth: callers download remote documents with mobile-core's
+     * `downloadFile` first). Returns a handle used by every other call. Throws
+     * (rejects) on a missing file, a corrupt PDF, or a password-protected PDF.
+     */
+    open(path: string): Promise<PdfDocumentInfo>;
+    /**
+     * Reads one page's own size without rasterizing it (pages in a PDF can each
+     * have a different size/rotation).
+     */
+    getPageInfo(handle: string, pageIndex: number): Promise<PdfPageInfo>;
+    /**
+     * Rasterizes one page to a PNG file in the cache directory and returns its
+     * absolute path. `scale` is a multiplier on the page's own point size (pass
+     * the view width / page width ratio, capped by the caller — see
+     * react-native.md's "RGBA_8888 is 4 bytes/px" guidance). Renders are
+     * serialized per handle on both platforms; call sequentially per document.
+     */
+    renderPage(handle: string, pageIndex: number, scale: number): Promise<string>;
+    /** Releases the native document and evicts any cached page renders for it. */
+    close(handle: string): Promise<void>;
+}
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativePdfRasterizer.d.ts.map

package/lib/typescript/module/components/DocumentViewer/DocumentViewer.d.ts

@@ -3,12 +3,11 @@ import type { StyleProp, ViewStyle } from 'react-native';
 export interface DocumentViewerSource {
     uri: string;
     headers?: Record<string, string>;
+    /** Reuse a previously downloaded copy of this URL instead of re-fetching. Default true. */
     cache?: boolean;
 }
 export interface DocumentViewerProps {
     source: DocumentViewerSource;
-    /** Trust self-signed / invalid certs on the document request. Default false. */
-    trustAllCerts?: boolean;
     onLoadComplete?: (numberOfPages: number) => void;
     onPageChanged?: (page: number, numberOfPages: number) => void;
     onError?: (error: Error) => void;
@@ -19,8 +18,10 @@ export interface DocumentViewerProps {
     accessibilityLabel?: string;
 }
 /**
- * Renders a PDF only — the WebView fallback consumer apps use for non-PDF
- * office documents is a distinct rendering strategy and stays app-side.
+ * Renders a PDF via our own native rasterizer (PDFKit on iOS, PdfRenderer on
+ * Android) — no third-party PDF dependency. The WebView fallback consumer
+ * apps use for non-PDF office documents is a distinct rendering strategy and
+ * stays app-side.
  */
 export declare const DocumentViewer: React.FC<DocumentViewerProps>;
 export default DocumentViewer;

package/lib/typescript/module/specs/NativePdfRasterizer.d.ts

@@ -0,0 +1,40 @@
+import type { TurboModule } from 'react-native';
+export interface PdfDocumentInfo {
+    /** Opaque handle for every subsequent call (getPageInfo/renderPage/close) — NOT the file path. */
+    handle: string;
+    pageCount: number;
+    /** Points (1/72 in), the unrotated page size of page 0 — a per-page size read happens in renderPage. */
+    pageWidth: number;
+    pageHeight: number;
+}
+export interface PdfPageInfo {
+    width: number;
+    height: number;
+}
+export interface Spec extends TurboModule {
+    /**
+     * Opens a LOCAL pdf file (a file:// path or bare absolute path — no http(s), no
+     * headers, no auth: callers download remote documents with mobile-core's
+     * `downloadFile` first). Returns a handle used by every other call. Throws
+     * (rejects) on a missing file, a corrupt PDF, or a password-protected PDF.
+     */
+    open(path: string): Promise<PdfDocumentInfo>;
+    /**
+     * Reads one page's own size without rasterizing it (pages in a PDF can each
+     * have a different size/rotation).
+     */
+    getPageInfo(handle: string, pageIndex: number): Promise<PdfPageInfo>;
+    /**
+     * Rasterizes one page to a PNG file in the cache directory and returns its
+     * absolute path. `scale` is a multiplier on the page's own point size (pass
+     * the view width / page width ratio, capped by the caller — see
+     * react-native.md's "RGBA_8888 is 4 bytes/px" guidance). Renders are
+     * serialized per handle on both platforms; call sequentially per document.
+     */
+    renderPage(handle: string, pageIndex: number, scale: number): Promise<string>;
+    /** Releases the native document and evicts any cached page renders for it. */
+    close(handle: string): Promise<void>;
+}
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativePdfRasterizer.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webority-technologies/mobile-ui",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Beautiful, animated, accessible React Native components, theme and form engine for Webority projects.",
   "keywords": [
     "react-native",
@@ -47,11 +47,22 @@
   "types": "./lib/typescript/commonjs/index.d.ts",
   "files": [
     "lib",
+    "ios",
+    "android",
+    "RNMobileUiPdfRasterizer.podspec",
     "!**/__tests__",
     "!**/*.test.*",
     "!**/*.spec.*",
     "!**/*.map"
   ],
+  "codegenConfig": {
+    "name": "RNMobileUiPdfRasterizerSpec",
+    "type": "modules",
+    "jsSrcsDir": "./src/specs",
+    "android": {
+      "javaPackageName": "com.webority.mobileui.pdfrasterizer"
+    }
+  },
   "scripts": {
     "build": "bob build",
     "clean": "rimraf lib",
@@ -69,7 +80,6 @@
     "react": "^19.1.0",
     "react-native": ">=0.81.0",
     "react-native-gesture-handler": "^2.21.0 || ^3.0.0",
-    "react-native-pdf": ">=7.0.4",
     "react-native-reanimated": "^4.0.0",
     "react-native-safe-area-context": ">=5.4.0",
     "react-native-worklets": ">=0.10.0"
@@ -104,7 +114,6 @@
     ]
   },
   "devDependencies": {
-    "expo-haptics": "^57.0.2",
-    "react-native-pdf": "^7.0.4"
+    "expo-haptics": "^57.0.2"
   }
 }