@webority-technologies/mobile-ui 0.0.7 → 0.0.9

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