@react-native-firebase/storage 26.3.3 → 27.0.0

package/ios/RNFBStorage/RNFBStorageErrorCodeMapper.swift

@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+/**
+ * `FIRStorageErrorCode` raw value → JS error-code / message mapping previously
+ * inline in `+[RNFBStorageCommon getErrorCodeMessage:]`.
+ *
+ * Raw ints from Firebase Storage `StorageErrorCode`
+ * (`@objc(FIRStorageErrorCode)` in `StorageError.swift`):
+ * - unknown = -13000, objectNotFound = -13010, …
+ *
+ * Hardcoded so the Storage unit target does not need FirebaseStorage.
+ */
+@objc(RNFBStorageErrorCodeMapper)
+public final class RNFBStorageErrorCodeMapper: NSObject {
+  /// `FIRStorageErrorCodeUnknown`
+  private static let codeUnknown = -13000
+  /// `FIRStorageErrorCodeObjectNotFound`
+  private static let codeObjectNotFound = -13010
+  /// `FIRStorageErrorCodeBucketNotFound`
+  private static let codeBucketNotFound = -13011
+  /// `FIRStorageErrorCodeProjectNotFound`
+  private static let codeProjectNotFound = -13012
+  /// `FIRStorageErrorCodeQuotaExceeded`
+  private static let codeQuotaExceeded = -13013
+  /// `FIRStorageErrorCodeUnauthenticated`
+  private static let codeUnauthenticated = -13020
+  /// `FIRStorageErrorCodeUnauthorized`
+  private static let codeUnauthorized = -13021
+  /// `FIRStorageErrorCodeRetryLimitExceeded`
+  private static let codeRetryLimitExceeded = -13030
+  /// `FIRStorageErrorCodeNonMatchingChecksum`
+  private static let codeNonMatchingChecksum = -13031
+  /// `FIRStorageErrorCodeDownloadSizeExceeded`
+  private static let codeDownloadSizeExceeded = -13032
+  /// `FIRStorageErrorCodeCancelled`
+  private static let codeCancelled = -13040
+
+  /// Exact pre-port string (U+2019 apostrophe in "couldn't").
+  private static let permissionDeniedUnderlying =
+    "The operation couldn’t be completed. Permission denied"
+
+  @objc(codeAndMessageForError:)
+  public static func codeAndMessage(for error: NSError?) -> [String] {
+    var code = "unknown"
+
+    guard let error else {
+      return [code, "An unknown error has occurred."]
+    }
+
+    var message = error.localizedDescription
+    let userInfo = error.userInfo
+    let underlyingError = userInfo[NSUnderlyingErrorKey] as? NSError
+    let underlyingErrorDescription = underlyingError?.localizedDescription
+
+    switch error.code {
+    case codeUnknown:
+      if underlyingErrorDescription == permissionDeniedUnderlying {
+        code = "invalid-device-file-path"
+        message = "The specified device file path is invalid or is restricted."
+      } else if let responseBody = userInfo["ResponseBody"] {
+        message =
+          "An unknown error has occurred. (underlying reason '\(responseBody)')"
+      } else {
+        message = "An unknown error has occurred."
+      }
+    case codeObjectNotFound:
+      code = "object-not-found"
+      message = "No object exists at the desired reference."
+    case codeBucketNotFound:
+      code = "bucket-not-found"
+      message = "No bucket is configured for Firebase Storage."
+    case codeProjectNotFound:
+      code = "project-not-found"
+      message = "No project is configured for Firebase Storage."
+    case codeQuotaExceeded:
+      code = "quota-exceeded"
+      message = "Quota on your Firebase Storage bucket has been exceeded."
+    case codeUnauthenticated:
+      code = "unauthenticated"
+      message = "User is unauthenticated. Authenticate and try again."
+    case codeUnauthorized:
+      code = "unauthorized"
+      message = "User is not authorized to perform the desired action."
+    case codeRetryLimitExceeded:
+      code = "retry-limit-exceeded"
+      message =
+        "The maximum time limit on an operation (upload, download, delete, etc.) has been "
+        + "exceeded."
+    case codeNonMatchingChecksum:
+      code = "non-matching-checksum"
+      message =
+        "File on the client does not match the checksum of the file received by the server."
+    case codeDownloadSizeExceeded:
+      code = "download-size-exceeded"
+      message =
+        "Size of the downloaded file exceeds the amount of memory allocated for the download."
+    case codeCancelled:
+      code = "cancelled"
+      message = "User cancelled the operation."
+    default:
+      break
+    }
+
+    return [code, message]
+  }
+}

package/ios/RNFBStorage/RNFBStorageErrorSnapshotDictBuilder.swift

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+/**
+ * Error payload attachment previously inline in
+ * `+[RNFBStorageCommon buildErrorSnapshotDict:taskSnapshotDict:]` and
+ * `+[RNFBStorageCommon buildErrorSnapshotDictFromCodeAndMessage:taskSnapshotDict:]`.
+ *
+ * Mutates `taskSnapshotDict` in place and returns the same instance (or nil when
+ * the snapshot dict is nil — matching ObjC nil-messaging).
+ */
+@objc(RNFBStorageErrorSnapshotDictBuilder)
+public final class RNFBStorageErrorSnapshotDictBuilder: NSObject {
+  @objc(buildErrorSnapshotDict:taskSnapshotDict:)
+  public static func buildErrorSnapshotDict(
+    _ error: NSError?,
+    taskSnapshotDict: NSMutableDictionary?
+  ) -> NSDictionary? {
+    guard let taskSnapshotDict else {
+      return nil
+    }
+
+    let codeAndMessage = RNFBStorageErrorCodeMapper.codeAndMessage(for: error)
+    var errorPayload: [String: Any] = [
+      "code": codeAndMessage[0],
+      "message": codeAndMessage[1],
+    ]
+    // Pre-port ObjC always set this key from `[error localizedDescription]`.
+    if let error {
+      errorPayload["nativeErrorMessage"] = error.localizedDescription
+    } else {
+      errorPayload["nativeErrorMessage"] = NSNull()
+    }
+    taskSnapshotDict["error"] = errorPayload
+    return taskSnapshotDict
+  }
+
+  @objc(buildErrorSnapshotDictFromCodeAndMessage:taskSnapshotDict:)
+  public static func buildErrorSnapshotDictFromCodeAndMessage(
+    _ codeAndMessage: [Any]?,
+    taskSnapshotDict: NSMutableDictionary?
+  ) -> NSDictionary? {
+    guard let taskSnapshotDict else {
+      return nil
+    }
+
+    // Pre-port ObjC indexed without bounds checks; callers always pass [code, message].
+    let pair = codeAndMessage!
+    taskSnapshotDict["error"] = [
+      "code": pair[0],
+      "message": pair[1],
+    ]
+    return taskSnapshotDict
+  }
+}

package/ios/RNFBStorage/RNFBStorageHelper.m

@@ -28,6 +28,7 @@
 #import "RNFBRCTEventEmitter.h"
 #import "RNFBStorageCommon.h"
 #import "RNFBStorageHelper.h"
+#import "RNFBStorageTaskRegistry.h"
 
 static NSString *const RNFB_STORAGE_EVENT = @"storage_event";
 static NSString *const RNFB_STORAGE_STATE_CHANGED = @"state_changed";
@@ -36,7 +37,7 @@ static NSString *const RNFB_STORAGE_UPLOAD_FAILURE = @"upload_failure";
 static NSString *const RNFB_STORAGE_DOWNLOAD_SUCCESS = @"download_success";
 static NSString *const RNFB_STORAGE_DOWNLOAD_FAILURE = @"download_failure";
 
-static NSMutableDictionary *PENDING_TASKS;
+static RNFBStorageTaskRegistry *pendingTasks;
 
 // The iOS SDK has a short memory on settings, store these globally and set them in each time
 static NSString *emulatorHost = nil;
@@ -54,16 +55,14 @@ static NSTimeInterval maxOperationRetryTime = 120;
 + (void)initializeSharedStateOnce {
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
-    PENDING_TASKS = [[NSMutableDictionary alloc] init];
+    pendingTasks = [[RNFBStorageTaskRegistry alloc] init];
     emulatorConfigs = [[NSMutableDictionary alloc] init];
   });
 }
 
 + (void)invalidate {
   [self initializeSharedStateOnce];
-  for (NSString *key in [PENDING_TASKS allKeys]) {
-    [PENDING_TASKS removeObjectForKey:key];
-  }
+  [pendingTasks cancelAll];
 }
 
 #pragma mark -
@@ -283,7 +282,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
     downloadTask = [storageReference writeToFile:localFile];
   });
 
-  PENDING_TASKS[taskIdNumber] = downloadTask;
+  if (![pendingTasks putOrDiscard:taskIdNumber value:downloadTask]) {
+    reject(@"internal", @"Handle id already registered", nil);
+    return;
+  }
 
   [downloadTask
       observeStatus:FIRStorageTaskStatusResume
@@ -324,7 +326,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
   [downloadTask
       observeStatus:FIRStorageTaskStatusSuccess
             handler:^(FIRStorageTaskSnapshot *snapshot) {
-              [PENDING_TASKS removeObjectForKey:taskIdNumber];
+              [pendingTasks takeIf:taskIdNumber
+                              when:^BOOL(id value) {
+                                return value == downloadTask;
+                              }];
 
               NSDictionary *stateChangedEventBody =
                   [RNFBStorageCommon getDownloadTaskAsDictionary:snapshot];
@@ -349,7 +354,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
   [downloadTask
       observeStatus:FIRStorageTaskStatusFailure
             handler:^(FIRStorageTaskSnapshot *snapshot) {
-              [PENDING_TASKS removeObjectForKey:taskIdNumber];
+              [pendingTasks takeIf:taskIdNumber
+                              when:^BOOL(id value) {
+                                return value == downloadTask;
+                              }];
 
               NSDictionary *stateChangedEventBody =
                   [RNFBStorageCommon getDownloadTaskAsDictionary:snapshot];
@@ -501,7 +509,7 @@ static NSTimeInterval maxOperationRetryTime = 120;
 + (NSNumber *)setTaskStatus:(NSString *)appName taskId:(double)taskId status:(double)status {
   [self initializeSharedStateOnce];
   NSNumber *taskIdNumber = @(taskId);
-  id task = PENDING_TASKS[taskIdNumber];
+  id task = [pendingTasks get:taskIdNumber];
   if (task == nil) {
     return @NO;
   }
@@ -546,7 +554,15 @@ static NSTimeInterval maxOperationRetryTime = 120;
           (currentStatus == FIRStorageTaskStatusResume ||
            currentStatus == FIRStorageTaskStatusProgress ||
            currentStatus == FIRStorageTaskStatusPause)) {
-        [PENDING_TASKS removeObjectForKey:taskIdNumber];
+        // Identity take then cancel so a replacement at taskId is not stolen.
+        // Ordering differs from registry takeAndCancel: (takeIf → cancel) vs Android
+        // (get → cancel → takeIf). Both are identity-safe; FIRStorage cancel is void.
+        if ([pendingTasks takeIf:taskIdNumber
+                            when:^BOOL(id value) {
+                              return value == task;
+                            }] == nil) {
+          return @NO;
+        }
         if ([task isKindOfClass:[FIRStorageDownloadTask class]]) {
           [(FIRStorageDownloadTask *)task cancel];
         } else {
@@ -595,7 +611,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
                       resolver:(RCTPromiseResolveBlock)resolve
                       rejecter:(RCTPromiseRejectBlock)reject {
   [self initializeSharedStateOnce];
-  PENDING_TASKS[taskId] = uploadTask;
+  if (![pendingTasks putOrDiscard:taskId value:uploadTask]) {
+    reject(@"internal", @"Handle id already registered", nil);
+    return;
+  }
 
   [uploadTask
       observeStatus:FIRStorageTaskStatusResume
@@ -635,7 +654,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
 
   [uploadTask observeStatus:FIRStorageTaskStatusSuccess
                     handler:^(FIRStorageTaskSnapshot *snapshot) {
-                      [PENDING_TASKS removeObjectForKey:taskId];
+                      [pendingTasks takeIf:taskId
+                                      when:^BOOL(id value) {
+                                        return value == uploadTask;
+                                      }];
 
                       NSDictionary *eventBody =
                           [RNFBStorageCommon getUploadTaskAsDictionary:snapshot];
@@ -661,7 +683,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
   [uploadTask
       observeStatus:FIRStorageTaskStatusFailure
             handler:^(FIRStorageTaskSnapshot *snapshot) {
-              [PENDING_TASKS removeObjectForKey:taskId];
+              [pendingTasks takeIf:taskId
+                              when:^BOOL(id value) {
+                                return value == uploadTask;
+                              }];
 
               NSMutableDictionary *taskSnapshotDict =
                   [RNFBStorageCommon getUploadTaskAsDictionary:snapshot];

package/ios/RNFBStorage/RNFBStorageTaskRegistry.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Pending upload/download task map. Unique `put`; callers `take` or `cancelAll` then cancel
+ * outside the HandleMap lock. Stored values are expected to respond to `cancel`.
+ */
+@interface RNFBStorageTaskRegistry : NSObject
+
+- (BOOL)put:(id)key value:(id)value error:(NSError *_Nullable *_Nullable)error;
+/// Unique put. On collision, `cancel`s the incoming value and leaves the existing mapping.
+- (BOOL)putOrDiscard:(id)key value:(id)value;
+- (nullable id)get:(id)key;
+- (nullable id)take:(id)key;
+/// Identity-gated take; see RNFBHandleMap `takeIf:when:`.
+- (nullable id)takeIf:(id)key when:(BOOL (^)(id value))condition;
+/// get → cancel → identity take (Android shape). FIRStorage cancel is void (no keep-on-false).
+/// Production setTaskStatus cancel uses takeIf then cancel; see RNFBStorageHelper.
+- (BOOL)takeAndCancel:(id)key;
+- (void)cancelAll;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNFBStorage/RNFBStorageTaskRegistry.m

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import "RNFBStorageTaskRegistry.h"
+
+#if __has_include("RNFBHandleMap.h")
+#import "RNFBHandleMap.h"
+#else
+#import "RNFBApp/RNFBHandleMap.h"
+#endif
+
+#if __has_include(<RNFBStorage/RNFBStorage-Swift.h>)
+#import <RNFBStorage/RNFBStorage-Swift.h>
+#elif __has_include("RNFBStorage-Swift.h")
+#import "RNFBStorage-Swift.h"
+#elif __has_include("RNFBHandleMapStorage-Swift.inc")
+#import "RNFBHandleMapStorage-Swift.inc"
+#else
+#error "RNFBStorageTaskRegistryStorage Swift interface not found"
+#endif
+
+@interface RNFBStorageTaskRegistry ()
+@property(nonatomic, strong) RNFBStorageTaskRegistryStorage *storage;
+@end
+
+@implementation RNFBStorageTaskRegistry
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _storage = [[RNFBStorageTaskRegistryStorage alloc] init];
+  }
+  return self;
+}
+
+- (BOOL)put:(id)key value:(id)value error:(NSError **)error {
+  if (![self.storage putIfAbsent:key value:value]) {
+    if (error != nil) {
+      NSString *message = [NSString stringWithFormat:@"Handle id already registered: %@", key];
+      *error = [NSError errorWithDomain:RNFBHandleMapErrorDomain
+                                   code:RNFBHandleMapErrorCollision
+                               userInfo:@{NSLocalizedDescriptionKey : message}];
+    }
+    return NO;
+  }
+  return YES;
+}
+
+- (BOOL)putOrDiscard:(id)key value:(id)value {
+  return [self.storage putOrDiscard:key value:value];
+}
+
+- (id)get:(id)key {
+  return [self.storage get:key];
+}
+
+- (id)take:(id)key {
+  return [self.storage take:key];
+}
+
+- (id)takeIf:(id)key when:(BOOL (^)(id))condition {
+  return [self.storage takeIf:key when:condition];
+}
+
+- (BOOL)takeAndCancel:(id)key {
+  return [self.storage takeAndCancel:key];
+}
+
+- (void)cancelAll {
+  [self.storage cancelAll];
+}
+
+@end

package/ios/RNFBStorage/RNFBStorageTaskRegistryStorage.swift

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+#if canImport(RNFBApp)
+import RNFBApp
+#endif
+
+/// Pending upload/download task map storage. Composes `RNFBHandleMapStorage`.
+/// `putOrDiscard` is first-wins and calls `cancel` on the incoming value on collision.
+/// Unique `put` collision errors stay on the ObjC façade.
+@objc(RNFBStorageTaskRegistryStorage)
+public final class RNFBStorageTaskRegistryStorage: NSObject {
+  private static let cancelSelector = Selector(("cancel"))
+
+  private let storage = RNFBHandleMapStorage()
+
+  private func cancelHandle(_ handle: AnyObject?) {
+    guard let handle = handle, handle.responds(to: Self.cancelSelector) else {
+      return
+    }
+    _ = handle.perform(Self.cancelSelector)
+  }
+
+  /// First-wins store without discarding the incoming value. Used by façade `put`.
+  @objc(putIfAbsent:value:)
+  public func putIfAbsent(_ key: AnyObject, value: AnyObject) -> Bool {
+    storage.putIfAbsent(key, value: value)
+  }
+
+  /// Unique put. On collision, `cancel`s the incoming value and leaves the existing mapping.
+  @objc(putOrDiscard:value:)
+  public func putOrDiscard(_ key: AnyObject, value: AnyObject) -> Bool {
+    if storage.putIfAbsent(key, value: value) {
+      return true
+    }
+    cancelHandle(value)
+    return false
+  }
+
+  @objc(get:)
+  public func get(_ key: AnyObject) -> AnyObject? {
+    storage.get(key)
+  }
+
+  @objc(take:)
+  public func take(_ key: AnyObject) -> AnyObject? {
+    storage.take(key)
+  }
+
+  @objc(takeIf:when:)
+  public func takeIf(_ key: AnyObject, when condition: (AnyObject) -> Bool) -> AnyObject? {
+    storage.takeIf(key, when: condition)
+  }
+
+  /// get → cancel → identity take (Android shape). FIRStorage cancel is void (no keep-on-false).
+  @objc(takeAndCancel:)
+  public func takeAndCancel(_ key: AnyObject) -> Bool {
+    guard let handle = storage.get(key) else {
+      return false
+    }
+    cancelHandle(handle)
+    _ = storage.takeIf(key, when: { $0 === handle })
+    return true
+  }
+
+  @objc
+  public func cancelAll() {
+    for handle in storage.takeAll() {
+      cancelHandle(handle)
+    }
+  }
+}

package/ios/RNFBStorage/RNFBStorageTaskStatusMapper.swift

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+/**
+ * `FIRStorageTaskStatus` raw value → JS task-state string mapping previously
+ * inline in `+[RNFBStorageCommon getTaskStatus:]`.
+ *
+ * Raw ints from Firebase Storage `StorageTaskStatus`
+ * (`@objc(FIRStorageTaskStatus)` in `StorageConstants.swift`):
+ * - unknown = 0, resume = 1, progress = 2, pause = 3, success = 4, failure = 5
+ *
+ * Hardcoded so the Storage unit target does not need FirebaseStorage.
+ */
+@objc(RNFBStorageTaskStatusMapper)
+public final class RNFBStorageTaskStatusMapper: NSObject {
+  /// `FIRStorageTaskStatusResume`
+  private static let statusResume = 1
+  /// `FIRStorageTaskStatusProgress`
+  private static let statusProgress = 2
+  /// `FIRStorageTaskStatusPause`
+  private static let statusPause = 3
+  /// `FIRStorageTaskStatusSuccess`
+  private static let statusSuccess = 4
+  /// `FIRStorageTaskStatusFailure`
+  private static let statusFailure = 5
+
+  @objc(stringForTaskStatus:)
+  public static func string(forTaskStatus status: Int) -> String {
+    if status == statusResume || status == statusProgress {
+      return "running"
+    } else if status == statusPause {
+      return "paused"
+    } else if status == statusSuccess {
+      return "success"
+    } else if status == statusFailure {
+      return "error"
+    } else {
+      // `FIRStorageTaskStatusUnknown` (0) and any other raw value
+      return "unknown"
+    }
+  }
+}

package/ios/RNFBStorage.xcodeproj/project.pbxproj

@@ -12,6 +12,11 @@
 		27A35B652268E118005BE5A8 /* RNFBStorageDownloadTask.m in Sources */ = {isa = PBXBuildFile; fileRef = 27A35B642268E118005BE5A8 /* RNFBStorageDownloadTask.m */; };
 		27A35B682268E138005BE5A8 /* RNFBStorageUploadTask.m in Sources */ = {isa = PBXBuildFile; fileRef = 27A35B672268E138005BE5A8 /* RNFBStorageUploadTask.m */; };
 		27A35B6B2268E1BE005BE5A8 /* RNFBStorageCommon.m in Sources */ = {isa = PBXBuildFile; fileRef = 27A35B6A2268E1BE005BE5A8 /* RNFBStorageCommon.m */; };
+		RNFBSTOR0000000000000001 /* RNFBStorageTaskRegistry.m in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR0000000000000002 /* RNFBStorageTaskRegistry.m */; };
+		RNFBSTOR0000000000000003 /* RNFBStorageTaskRegistryStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR0000000000000004 /* RNFBStorageTaskRegistryStorage.swift */; };
+		RNFBSTOR0000000000000006 /* RNFBStorageTaskStatusMapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR0000000000000007 /* RNFBStorageTaskStatusMapper.swift */; };
+		RNFBSTOR0000000000000008 /* RNFBStorageErrorCodeMapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR0000000000000009 /* RNFBStorageErrorCodeMapper.swift */; };
+		RNFBSTOR000000000000000A /* RNFBStorageErrorSnapshotDictBuilder.swift in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR000000000000000B /* RNFBStorageErrorSnapshotDictBuilder.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -38,6 +43,12 @@
 		27A35B692268E143005BE5A8 /* RNFBStorageUploadTask.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFBStorageUploadTask.h; sourceTree = "<group>"; };
 		27A35B6A2268E1BE005BE5A8 /* RNFBStorageCommon.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBStorageCommon.m; sourceTree = "<group>"; };
 		27A35B6C2268E1C8005BE5A8 /* RNFBStorageCommon.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFBStorageCommon.h; sourceTree = "<group>"; };
+		RNFBSTOR0000000000000005 /* RNFBStorageTaskRegistry.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBStorageTaskRegistry.h; path = RNFBStorage/RNFBStorageTaskRegistry.h; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR0000000000000002 /* RNFBStorageTaskRegistry.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBStorageTaskRegistry.m; path = RNFBStorage/RNFBStorageTaskRegistry.m; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR0000000000000004 /* RNFBStorageTaskRegistryStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBStorageTaskRegistryStorage.swift; path = RNFBStorage/RNFBStorageTaskRegistryStorage.swift; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR0000000000000007 /* RNFBStorageTaskStatusMapper.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBStorageTaskStatusMapper.swift; path = RNFBStorage/RNFBStorageTaskStatusMapper.swift; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR0000000000000009 /* RNFBStorageErrorCodeMapper.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBStorageErrorCodeMapper.swift; path = RNFBStorage/RNFBStorageErrorCodeMapper.swift; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR000000000000000B /* RNFBStorageErrorSnapshotDictBuilder.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBStorageErrorSnapshotDictBuilder.swift; path = RNFBStorage/RNFBStorageErrorSnapshotDictBuilder.swift; sourceTree = SOURCE_ROOT; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -64,6 +75,12 @@
 			children = (
 				2744B98421F45429004F8E3F /* RNFBStorageModule.h */,
 				2744B98521F45429004F8E3F /* RNFBStorageModule.mm */,
+				RNFBSTOR0000000000000005 /* RNFBStorageTaskRegistry.h */,
+				RNFBSTOR0000000000000002 /* RNFBStorageTaskRegistry.m */,
+				RNFBSTOR0000000000000004 /* RNFBStorageTaskRegistryStorage.swift */,
+				RNFBSTOR0000000000000007 /* RNFBStorageTaskStatusMapper.swift */,
+				RNFBSTOR0000000000000009 /* RNFBStorageErrorCodeMapper.swift */,
+				RNFBSTOR000000000000000B /* RNFBStorageErrorSnapshotDictBuilder.swift */,
 				27A35B612268E0AB005BE5A8 /* RNFBStorageTask.m */,
 				27A35B632268E0CD005BE5A8 /* RNFBStorageTask.h */,
 				27A35B642268E118005BE5A8 /* RNFBStorageDownloadTask.m */,
@@ -142,6 +159,11 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				RNFBSTOR0000000000000003 /* RNFBStorageTaskRegistryStorage.swift in Sources */,
+				RNFBSTOR0000000000000006 /* RNFBStorageTaskStatusMapper.swift in Sources */,
+				RNFBSTOR0000000000000008 /* RNFBStorageErrorCodeMapper.swift in Sources */,
+				RNFBSTOR000000000000000A /* RNFBStorageErrorSnapshotDictBuilder.swift in Sources */,
+				RNFBSTOR0000000000000001 /* RNFBStorageTaskRegistry.m in Sources */,
 				27A35B622268E0AB005BE5A8 /* RNFBStorageTask.m in Sources */,
 				27A35B6B2268E1BE005BE5A8 /* RNFBStorageCommon.m in Sources */,
 				2744B98621F45429004F8E3F /* RNFBStorageModule.mm in Sources */,
@@ -172,6 +194,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = dwarf;
+				DEFINES_MODULE = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_OPTIMIZATION_LEVEL = 0;
@@ -188,6 +211,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = iphoneos;
 				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 5.10;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Debug;
@@ -211,6 +235,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				DEFINES_MODULE = YES;
 				ENABLE_NS_ASSERTIONS = NO;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
@@ -222,6 +247,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = iphoneos;
 				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 5.10;
 				TARGETED_DEVICE_FAMILY = "1,2";
 				VALIDATE_PRODUCT = YES;
 			};