react-native-buffered-blob 1.0.0

package/ios/BufferedBlobModule.m

@@ -0,0 +1,433 @@
+#import "BufferedBlobModule.h"
+#import "HandleRegistry.h"
+#import "HandleTypes.h"
+#import <CommonCrypto/CommonDigest.h>
+
+@implementation BufferedBlobModule
+
++ (NSString *)moduleName {
+  return @"BufferedBlob";
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (NSDictionary *)constantsToExport {
+  NSArray<NSString *> *docPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+  NSString *docDir = docPaths.firstObject ?: @"";
+
+  NSArray<NSString *> *cachePaths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
+  NSString *cacheDir = cachePaths.firstObject ?: @"";
+
+  NSString *tempDir = NSTemporaryDirectory();
+
+  NSString *downloadDir = docDir;
+  if (@available(iOS 16.0, *)) {
+    NSArray<NSString *> *dlPaths = NSSearchPathForDirectoriesInDomains(NSDownloadsDirectory, NSUserDomainMask, YES);
+    if (dlPaths.firstObject) {
+      downloadDir = dlPaths.firstObject;
+    }
+  }
+
+  return @{
+    @"documentDir": docDir,
+    @"cacheDir": cacheDir,
+    @"tempDir": tempDir,
+    @"downloadDir": downloadDir,
+  };
+}
+
+// ──────────────────────────────────────────────────────────────────────
+#pragma mark - Handle Factories
+// ──────────────────────────────────────────────────────────────────────
+
+static const NSInteger kMinBufferSize = 4096;
+static const NSInteger kMaxBufferSize = 4194304; // 4MB
+
+- (NSNumber *)openRead:(NSString *)path bufferSize:(double)bufferSize {
+  NSInteger size = (NSInteger)bufferSize;
+  if (size < kMinBufferSize || size > kMaxBufferSize) {
+    NSLog(@"[BufferedBlob] openRead: buffer size out of range (%ld). Must be %ld-%ld.",
+          (long)size, (long)kMinBufferSize, (long)kMaxBufferSize);
+    return @(-1);
+  }
+
+  NSError *error = nil;
+  ReaderHandleIOS *reader = [[ReaderHandleIOS alloc] initWithPath:path
+                                                       bufferSize:size
+                                                            error:&error];
+  if (!reader) {
+    return @(-1);
+  }
+
+  NSInteger handleId = [[HandleRegistry shared] registerObject:reader];
+  return @(handleId);
+}
+
+- (NSNumber *)openWrite:(NSString *)path append:(BOOL)append {
+  NSFileManager *fm = [NSFileManager defaultManager];
+  NSString *parentDir = [path stringByDeletingLastPathComponent];
+  if (![fm fileExistsAtPath:parentDir]) {
+    [fm createDirectoryAtPath:parentDir withIntermediateDirectories:YES attributes:nil error:nil];
+  }
+
+  NSError *error = nil;
+  WriterHandleIOS *writer = [[WriterHandleIOS alloc] initWithPath:path
+                                                           append:append
+                                                            error:&error];
+  if (!writer) {
+    return @(-1);
+  }
+
+  NSInteger handleId = [[HandleRegistry shared] registerObject:writer];
+  return @(handleId);
+}
+
+- (NSNumber *)createDownload:(NSString *)url destPath:(NSString *)destPath headers:(NSDictionary *)headers {
+  NSFileManager *fm = [NSFileManager defaultManager];
+  NSString *parentDir = [destPath stringByDeletingLastPathComponent];
+  if (![fm fileExistsAtPath:parentDir]) {
+    [fm createDirectoryAtPath:parentDir withIntermediateDirectories:YES attributes:nil error:nil];
+  }
+
+  NSMutableDictionary<NSString *, NSString *> *headerMap = [NSMutableDictionary new];
+  [headers enumerateKeysAndObjectsUsingBlock:^(id key, id value, BOOL *stop) {
+    if ([key isKindOfClass:[NSString class]] && [value isKindOfClass:[NSString class]]) {
+      headerMap[key] = value;
+    }
+  }];
+
+  DownloaderHandleIOS *handle = [[DownloaderHandleIOS alloc] initWithURL:url
+                                                                destPath:destPath
+                                                                 headers:headerMap];
+  NSInteger handleId = [[HandleRegistry shared] registerObject:handle];
+  return @(handleId);
+}
+
+- (void)closeHandle:(double)handleId {
+  [[HandleRegistry shared] removeObjectForId:(NSInteger)handleId];
+}
+
+// ──────────────────────────────────────────────────────────────────────
+#pragma mark - FS Operations
+// ──────────────────────────────────────────────────────────────────────
+
+- (void)exists:(NSString *)path
+       resolve:(RCTPromiseResolveBlock)resolve
+        reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    BOOL exists = [[NSFileManager defaultManager] fileExistsAtPath:path];
+    resolve(@(exists));
+  });
+}
+
+- (void)stat:(NSString *)path
+     resolve:(RCTPromiseResolveBlock)resolve
+      reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSFileManager *fm = [NSFileManager defaultManager];
+    NSError *error = nil;
+    NSDictionary *attrs = [fm attributesOfItemAtPath:path error:&error];
+    if (!attrs) {
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[FILE_NOT_FOUND] File does not exist: %@", path],
+             error);
+      return;
+    }
+
+    int64_t size = [attrs[NSFileSize] longLongValue];
+    NSDate *modDate = attrs[NSFileModificationDate] ?: [NSDate date];
+    NSString *fileType = attrs[NSFileType];
+
+    NSString *type;
+    if ([fileType isEqualToString:NSFileTypeDirectory]) {
+      type = @"directory";
+    } else if ([fileType isEqualToString:NSFileTypeRegular]) {
+      type = @"file";
+    } else {
+      type = @"unknown";
+    }
+
+    NSString *name = [path lastPathComponent];
+    resolve(@{
+      @"path": path,
+      @"name": name,
+      @"size": @(size),
+      @"type": type,
+      @"lastModified": @(modDate.timeIntervalSince1970 * 1000),
+    });
+  });
+}
+
+- (void)unlink:(NSString *)path
+       resolve:(RCTPromiseResolveBlock)resolve
+        reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSFileManager *fm = [NSFileManager defaultManager];
+    NSError *error = nil;
+    if (![fm removeItemAtPath:path error:&error]) {
+      // Map "file not found" NSCocoa errors to the same ERR_FS format
+      if (error.code == NSFileNoSuchFileError || error.code == NSFileReadNoSuchFileError) {
+        reject(@"ERR_FS",
+               [NSString stringWithFormat:@"[FILE_NOT_FOUND] File does not exist: %@", path],
+               error);
+      } else {
+        reject(@"ERR_FS", error.localizedDescription, error);
+      }
+      return;
+    }
+    resolve(nil);
+  });
+}
+
+- (void)mkdir:(NSString *)path
+      resolve:(RCTPromiseResolveBlock)resolve
+       reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSFileManager *fm = [NSFileManager defaultManager];
+    BOOL isDir = NO;
+    if ([fm fileExistsAtPath:path isDirectory:&isDir]) {
+      if (isDir) {
+        resolve(nil);
+        return;
+      }
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[INVALID_ARGUMENT] Path exists and is not a directory: %@", path],
+             nil);
+      return;
+    }
+
+    NSError *error = nil;
+    if (![fm createDirectoryAtPath:path withIntermediateDirectories:YES attributes:nil error:&error]) {
+      reject(@"ERR_FS", error.localizedDescription, error);
+      return;
+    }
+    resolve(nil);
+  });
+}
+
+- (void)ls:(NSString *)path
+   resolve:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSFileManager *fm = [NSFileManager defaultManager];
+    BOOL isDir = NO;
+    if (![fm fileExistsAtPath:path isDirectory:&isDir]) {
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[FILE_NOT_FOUND] Directory does not exist: %@", path],
+             nil);
+      return;
+    }
+    if (!isDir) {
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[NOT_A_DIRECTORY] Path is not a directory: %@", path],
+             nil);
+      return;
+    }
+
+    NSError *error = nil;
+    NSArray<NSString *> *contents = [fm contentsOfDirectoryAtPath:path error:&error];
+    if (!contents) {
+      reject(@"ERR_FS", error.localizedDescription, error);
+      return;
+    }
+
+    NSMutableArray *results = [NSMutableArray new];
+    for (NSString *item in contents) {
+      NSString *fullPath = [path stringByAppendingPathComponent:item];
+      NSDictionary *attrs = [fm attributesOfItemAtPath:fullPath error:nil];
+      if (!attrs) continue;
+
+      int64_t size = [attrs[NSFileSize] longLongValue];
+      NSDate *modDate = attrs[NSFileModificationDate] ?: [NSDate date];
+      NSString *fileType = attrs[NSFileType];
+
+      NSString *type;
+      if ([fileType isEqualToString:NSFileTypeDirectory]) {
+        type = @"directory";
+      } else if ([fileType isEqualToString:NSFileTypeRegular]) {
+        type = @"file";
+      } else {
+        type = @"unknown";
+      }
+
+      [results addObject:@{
+        @"path": fullPath,
+        @"name": item,
+        @"size": @(size),
+        @"type": type,
+        @"lastModified": @(modDate.timeIntervalSince1970 * 1000),
+      }];
+    }
+    resolve(results);
+  });
+}
+
+- (void)cp:(NSString *)srcPath
+  destPath:(NSString *)destPath
+   resolve:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSFileManager *fm = [NSFileManager defaultManager];
+    if (![fm fileExistsAtPath:srcPath]) {
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[FILE_NOT_FOUND] Source does not exist: %@", srcPath],
+             nil);
+      return;
+    }
+
+    NSString *parentDir = [destPath stringByDeletingLastPathComponent];
+    if (![fm fileExistsAtPath:parentDir]) {
+      [fm createDirectoryAtPath:parentDir withIntermediateDirectories:YES attributes:nil error:nil];
+    }
+
+    if ([fm fileExistsAtPath:destPath]) {
+      [fm removeItemAtPath:destPath error:nil];
+    }
+
+    NSError *error = nil;
+    if (![fm copyItemAtPath:srcPath toPath:destPath error:&error]) {
+      reject(@"ERR_FS", error.localizedDescription, error);
+      return;
+    }
+    resolve(nil);
+  });
+}
+
+- (void)mv:(NSString *)srcPath
+  destPath:(NSString *)destPath
+   resolve:(RCTPromiseResolveBlock)resolve
+    reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSFileManager *fm = [NSFileManager defaultManager];
+    if (![fm fileExistsAtPath:srcPath]) {
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[FILE_NOT_FOUND] Source does not exist: %@", srcPath],
+             nil);
+      return;
+    }
+
+    NSString *parentDir = [destPath stringByDeletingLastPathComponent];
+    if (![fm fileExistsAtPath:parentDir]) {
+      [fm createDirectoryAtPath:parentDir withIntermediateDirectories:YES attributes:nil error:nil];
+    }
+
+    if ([fm fileExistsAtPath:destPath]) {
+      [fm removeItemAtPath:destPath error:nil];
+    }
+
+    NSError *error = nil;
+    if (![fm moveItemAtPath:srcPath toPath:destPath error:&error]) {
+      reject(@"ERR_FS", error.localizedDescription, error);
+      return;
+    }
+    resolve(nil);
+  });
+}
+
+- (void)hashFile:(NSString *)path
+       algorithm:(NSString *)algorithm
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSFileManager *fm = [NSFileManager defaultManager];
+    BOOL isDir = NO;
+    if ([fm fileExistsAtPath:path isDirectory:&isDir] && isDir) {
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[INVALID_ARGUMENT] Cannot hash a directory: %@", path],
+             nil);
+      return;
+    }
+
+    NSInputStream *inputStream = [NSInputStream inputStreamWithFileAtPath:path];
+    if (!inputStream) {
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[FILE_NOT_FOUND] File does not exist: %@", path],
+             nil);
+      return;
+    }
+    [inputStream open];
+    if (inputStream.streamStatus == NSStreamStatusError) {
+      [inputStream close];
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[FILE_NOT_FOUND] File does not exist: %@", path],
+             nil);
+      return;
+    }
+
+    const NSUInteger kBufferSize = 8192;
+    uint8_t *buffer = malloc(kBufferSize);
+    if (!buffer) {
+      [inputStream close];
+      reject(@"ERR_FS", @"[READ_ERROR] Failed to allocate buffer", nil);
+      return;
+    }
+
+    if ([algorithm isEqualToString:@"sha256"]) {
+      CC_SHA256_CTX ctx;
+      CC_SHA256_Init(&ctx);
+
+      while ([inputStream hasBytesAvailable]) {
+        NSInteger bytesRead = [inputStream read:buffer maxLength:kBufferSize];
+        if (bytesRead < 0) {
+          free(buffer);
+          [inputStream close];
+          reject(@"ERR_FS", @"[READ_ERROR] Error reading file", nil);
+          return;
+        }
+        if (bytesRead == 0) break;
+        CC_SHA256_Update(&ctx, buffer, (CC_LONG)bytesRead);
+      }
+
+      unsigned char digest[CC_SHA256_DIGEST_LENGTH];
+      CC_SHA256_Final(digest, &ctx);
+
+      free(buffer);
+      [inputStream close];
+
+      NSMutableString *hex = [NSMutableString stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
+      for (int i = 0; i < CC_SHA256_DIGEST_LENGTH; i++) {
+        [hex appendFormat:@"%02x", digest[i]];
+      }
+      resolve(hex);
+
+    } else if ([algorithm isEqualToString:@"md5"]) {
+      CC_MD5_CTX ctx;
+      CC_MD5_Init(&ctx);
+
+      while ([inputStream hasBytesAvailable]) {
+        NSInteger bytesRead = [inputStream read:buffer maxLength:kBufferSize];
+        if (bytesRead < 0) {
+          free(buffer);
+          [inputStream close];
+          reject(@"ERR_FS", @"[READ_ERROR] Error reading file", nil);
+          return;
+        }
+        if (bytesRead == 0) break;
+        CC_MD5_Update(&ctx, buffer, (CC_LONG)bytesRead);
+      }
+
+      unsigned char digest[CC_MD5_DIGEST_LENGTH];
+      CC_MD5_Final(digest, &ctx);
+
+      free(buffer);
+      [inputStream close];
+
+      NSMutableString *hex = [NSMutableString stringWithCapacity:CC_MD5_DIGEST_LENGTH * 2];
+      for (int i = 0; i < CC_MD5_DIGEST_LENGTH; i++) {
+        [hex appendFormat:@"%02x", digest[i]];
+      }
+      resolve(hex);
+
+    } else {
+      free(buffer);
+      [inputStream close];
+      reject(@"ERR_FS",
+             [NSString stringWithFormat:@"[INVALID_ARGUMENT] Unknown algorithm: %@", algorithm],
+             nil);
+    }
+  });
+}
+
+@end

package/ios/BufferedBlobModule.mm

@@ -0,0 +1,192 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTBridge+Private.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <ReactCommon/CallInvoker.h>
+#import <jsi/jsi.h>
+#import "BufferedBlobStreamingBridge.h"
+#import "BufferedBlobModule.h"
+#import "HandleRegistry.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <BufferedBlobSpec/BufferedBlobSpec.h>
+#endif
+
+@interface BufferedBlobModuleBridge : NSObject <
+#ifdef RCT_NEW_ARCH_ENABLED
+  NativeBufferedBlobSpec
+#else
+  RCTBridgeModule
+#endif
+>
+@property (nonatomic, strong) BufferedBlobModule *module;
+- (void)setRuntimePointer:(facebook::jsi::Runtime *)runtime;
+@end
+
+#ifdef RCT_NEW_ARCH_ENABLED
+namespace facebook::react {
+
+/**
+ * Subclass the codegen JSI wrapper to intercept install() and capture
+ * the jsi::Runtime reference, which is only available inside JSI host functions.
+ */
+class BufferedBlobSpecJSI : public NativeBufferedBlobSpecJSI {
+public:
+  BufferedBlobSpecJSI(const ObjCTurboModule::InitParams &params)
+    : NativeBufferedBlobSpecJSI(params) {
+    // Override install to capture runtime before delegating to ObjC
+    methodMap_["install"] = MethodMetadata {0,
+      [](jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t count) -> jsi::Value {
+        auto &self = static_cast<BufferedBlobSpecJSI &>(turboModule);
+        auto *module = static_cast<BufferedBlobModuleBridge *>(self.instance_);
+        [module setRuntimePointer:&rt];
+        return static_cast<ObjCTurboModule &>(turboModule).invokeObjCMethod(
+            rt, BooleanKind, "install", @selector(install), args, count);
+      }
+    };
+  }
+};
+
+} // namespace facebook::react
+#endif
+
+@implementation BufferedBlobModuleBridge {
+  facebook::jsi::Runtime *_runtime;
+  std::shared_ptr<facebook::react::CallInvoker> _callInvoker;
+}
+
+RCT_EXPORT_MODULE(BufferedBlob)
+
++ (BOOL)requiresMainQueueSetup {
+  return NO;
+}
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _module = [[BufferedBlobModule alloc] init];
+    _runtime = nullptr;
+  }
+  return self;
+}
+
+- (void)setRuntimePointer:(facebook::jsi::Runtime *)runtime {
+  _runtime = runtime;
+}
+
+- (NSDictionary *)constantsToExport {
+  return [_module constantsToExport];
+}
+
+- (NSDictionary *)getConstants {
+  return [self constantsToExport];
+}
+
+// --- install(): Wire JSI HostObject ---
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+  @try {
+    // New arch path: runtime and callInvoker are captured by
+    // getTurboModule: (callInvoker) and the JSI install() override (runtime).
+    if (_runtime && _callInvoker) {
+      installBufferedBlobStreaming(*_runtime, _callInvoker);
+      return @(YES);
+    }
+
+    // Old arch / bridge fallback
+    RCTBridge *bridge = self.bridge;
+    if (!bridge) {
+      bridge = [RCTBridge currentBridge];
+    }
+    if (!bridge) {
+      return @(NO);
+    }
+
+    RCTCxxBridge *target = (RCTCxxBridge *)(bridge.batchedBridge ?: bridge);
+
+    void *runtimePtr = target.runtime;
+    if (!runtimePtr) {
+      return @(NO);
+    }
+    facebook::jsi::Runtime *runtime = (facebook::jsi::Runtime *)runtimePtr;
+
+    auto callInvoker = [bridge jsCallInvoker];
+    if (!callInvoker) {
+      return @(NO);
+    }
+
+    _runtime = runtime;
+    _callInvoker = callInvoker;
+
+    installBufferedBlobStreaming(*_runtime, _callInvoker);
+    return @(YES);
+  } @catch (NSException *exception) {
+    NSLog(@"[BufferedBlob] install() failed: %@", exception.reason);
+    return @(NO);
+  }
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  _callInvoker = params.jsInvoker;
+  return std::make_shared<facebook::react::BufferedBlobSpecJSI>(params);
+}
+#endif
+
+// --- Handle Factories ---
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(openRead:(NSString *)path bufferSize:(double)bufferSize) {
+  return [_module openRead:path bufferSize:bufferSize];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(openWrite:(NSString *)path append:(BOOL)append) {
+  return [_module openWrite:path append:append];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(createDownload:(NSString *)url destPath:(NSString *)destPath headers:(NSDictionary *)headers) {
+  return [_module createDownload:url destPath:destPath headers:headers];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(closeHandle:(double)handleId) {
+  [_module closeHandle:handleId];
+  return nil;
+}
+
+// --- FS Operations ---
+RCT_EXPORT_METHOD(exists:(NSString *)path resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  [_module exists:path resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(stat:(NSString *)path resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  [_module stat:path resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(unlink:(NSString *)path resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  [_module unlink:path resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(mkdir:(NSString *)path resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  [_module mkdir:path resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(ls:(NSString *)path resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  [_module ls:path resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(cp:(NSString *)srcPath destPath:(NSString *)destPath resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  [_module cp:srcPath destPath:destPath resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(mv:(NSString *)srcPath destPath:(NSString *)destPath resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  [_module mv:srcPath destPath:destPath resolve:resolve reject:reject];
+}
+
+RCT_EXPORT_METHOD(hashFile:(NSString *)path algorithm:(NSString *)algorithm resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+  [_module hashFile:path algorithm:algorithm resolve:resolve reject:reject];
+}
+
+- (void)invalidate {
+  [[HandleRegistry shared] clear];
+  _runtime = nullptr;
+  _callInvoker = nullptr;
+}
+
+@end

package/ios/BufferedBlobStreamingBridge.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#import <React/RCTBridgeModule.h>
+#import <ReactCommon/CallInvoker.h>
+#import <jsi/jsi.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Install the BufferedBlobStreaming JSI HostObject on the given runtime.
+ * Called from BufferedBlobModule.mm during install().
+ */
+void installBufferedBlobStreaming(
+    facebook::jsi::Runtime& runtime,
+    std::shared_ptr<facebook::react::CallInvoker> callInvoker);
+
+#ifdef __cplusplus
+}
+#endif