@react-native-firebase/auth 26.4.0 → 27.0.0

package/ios/RNFBAuthUnitTests/RNFBAuthCacheRegistryStorageTests.swift

@@ -0,0 +1,72 @@
+/**
+ * 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 XCTest
+
+final class RNFBAuthCacheRegistryStorageTests: XCTestCase {
+  private var storage: RNFBAuthCacheRegistryStorage!
+
+  override func setUp() {
+    super.setUp()
+    storage = RNFBAuthCacheRegistryStorage()
+  }
+
+  func testPutOrDiscard_storesWhenFree() {
+    XCTAssertTrue(storage.putOrDiscard("k1" as NSString, value: "payload" as NSString))
+    XCTAssertEqual(storage.get("k1" as NSString) as? NSString, "payload")
+  }
+
+  func testPutOrDiscard_collision_keepsExisting() {
+    XCTAssertTrue(storage.putOrDiscard("k1" as NSString, value: "first" as NSString))
+    XCTAssertFalse(storage.putOrDiscard("k1" as NSString, value: "second" as NSString))
+    XCTAssertEqual(storage.get("k1" as NSString) as? NSString, "first")
+  }
+
+  func testPutReplacing_whenFree_returnsNil() {
+    XCTAssertNil(storage.putReplacing("k1" as NSString, value: "payload" as NSString))
+    XCTAssertEqual(storage.get("k1" as NSString) as? NSString, "payload")
+  }
+
+  func testPutReplacing_whenOccupied_returnsDisplaced() {
+    XCTAssertTrue(storage.putOrDiscard("k1" as NSString, value: "first" as NSString))
+    let displaced = storage.putReplacing("k1" as NSString, value: "second" as NSString)
+    XCTAssertEqual(displaced as? NSString, "first")
+    XCTAssertEqual(storage.get("k1" as NSString) as? NSString, "second")
+  }
+
+  func testGet_whenFree_isNil() {
+    XCTAssertNil(storage.get("missing" as NSString))
+  }
+
+  func testTake_removesAndReturns() {
+    XCTAssertTrue(storage.putOrDiscard("k1" as NSString, value: "payload" as NSString))
+    XCTAssertEqual(storage.take("k1" as NSString) as? NSString, "payload")
+    XCTAssertNil(storage.get("k1" as NSString))
+  }
+
+  func testTake_whenFree_isNil() {
+    XCTAssertNil(storage.take("missing" as NSString))
+  }
+
+  func testTakeAll_returnsSnapshotAndLeavesEmpty() {
+    XCTAssertTrue(storage.putOrDiscard("a" as NSString, value: "1" as NSString))
+    XCTAssertTrue(storage.putOrDiscard("b" as NSString, value: "2" as NSString))
+    let remaining = storage.takeAll()
+    XCTAssertEqual(remaining.count, 2)
+    XCTAssertNil(storage.get("a" as NSString))
+    XCTAssertNil(storage.get("b" as NSString))
+  }
+}

package/ios/RNFBAuthUnitTests/RNFBAuthErrorCodeMapperTests.swift

@@ -0,0 +1,250 @@
+/**
+ * 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 XCTest
+
+final class RNFBAuthErrorCodeMapperTests: XCTestCase {
+  /// Sample of known FIRAuthErrorCode raw values → JS codes.
+  func testSampleKnownCodes() {
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 17000),
+      "invalid-custom-token"
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 17008),
+      "invalid-email"
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 17020),
+      "network-request-failed"
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 17057),
+      "cancelled-popup-request"
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 17078),
+      "multi-factor-auth-required"
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 17999),
+      "internal-error"
+    )
+  }
+
+  /// Pre-port quirk: MissingEmail (17034) maps to invalid-email, not missing-email.
+  func testMissingEmailMapsToInvalidEmail() {
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 17034),
+      "invalid-email"
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 17008),
+      "invalid-email"
+    )
+  }
+
+  func testUnknownCodeReturnsNil() {
+    XCTAssertNil(RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 0))
+    XCTAssertNil(RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 17001))
+    XCTAssertNil(RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: 99999))
+    XCTAssertNil(RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: -1))
+  }
+
+  /// Sample of known FIRAuthErrorCode raw values → JS message overrides.
+  func testSampleKnownMessageOverrides() {
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 17000),
+      "The custom token format is incorrect. Please check the documentation."
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 17008),
+      "The email address is badly formatted."
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 17020),
+      "A network error has occurred, please try again."
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 17078),
+      "Please complete a second factor challenge to finish signing into this account."
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 17999),
+      "An internal error has occurred, please try again."
+    )
+    XCTAssertEqual(
+      RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 17042),
+      "The format of the phone number provided is incorrect. "
+        + "Please enter the phone number in a format that can be parsed into E.164 format. "
+        + "E.164 phone numbers are written in the format [+][country code][subscriber "
+        + "number including area code]."
+    )
+  }
+
+  func testUnknownMessageOverrideReturnsNil() {
+    XCTAssertNil(RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 0))
+    XCTAssertNil(RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 17001))
+    XCTAssertNil(RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 17034))
+    XCTAssertNil(RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: 99999))
+    XCTAssertNil(RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: -1))
+  }
+
+  /// Full table — every pre-port `getJSError:` message override (coverage of switch DA).
+  func testAllPrePortMessageOverrides() {
+    let expected: [(Int, String)] = [
+      (
+        17000,
+        "The custom token format is incorrect. Please check the documentation."
+      ),
+      (17002, "The custom token corresponds to a different audience."),
+      (17004, "The supplied auth credential is malformed or has expired."),
+      (17008, "The email address is badly formatted."),
+      (17009, "The password is invalid or the user does not have a password."),
+      (
+        17024,
+        "The supplied credentials do not correspond to the previously signed in user."
+      ),
+      (
+        17014,
+        "This operation is sensitive and requires recent authentication. Log in again "
+          + "before retrying this request."
+      ),
+      (
+        17078,
+        "Please complete a second factor challenge to finish signing into this account."
+      ),
+      (
+        17012,
+        "An account already exists with the same email address but different sign-in "
+          + "credentials. Sign in using a provider associated with this email address."
+      ),
+      (17007, "The email address is already in use by another account."),
+      (
+        17025,
+        "This credential is already associated with a different user account."
+      ),
+      (17005, "The user account has been disabled by an administrator."),
+      (
+        17021,
+        "The user's credential is no longer valid. The user must sign in again."
+      ),
+      (
+        17011,
+        "There is no user record corresponding to this identifier. The user may have been "
+          + "deleted."
+      ),
+      (
+        17017,
+        "The user's credential is no longer valid. The user must sign in again."
+      ),
+      (17026, "The given password is invalid."),
+      (
+        17006,
+        "This operation is not allowed. You must enable this service in the console."
+      ),
+      (17020, "A network error has occurred, please try again."),
+      (17999, "An internal error has occurred, please try again."),
+      (
+        17042,
+        "The format of the phone number provided is incorrect. "
+          + "Please enter the phone number in a format that can be parsed into E.164 format. "
+          + "E.164 phone numbers are written in the format [+][country code][subscriber "
+          + "number including area code]."
+      ),
+    ]
+
+    for (code, message) in expected {
+      XCTAssertEqual(
+        RNFBAuthErrorCodeMapper.jsErrorMessage(forAuthErrorCode: code),
+        message,
+        "FIRAuthErrorCode raw \(code) message override"
+      )
+    }
+  }
+
+  /// Full table — preserves every pre-port sparse-array entry (coverage of switch DA).
+  func testAllPrePortMappings() {
+    let expected: [(Int, String)] = [
+      (17000, "invalid-custom-token"),
+      (17002, "custom-token-mismatch"),
+      (17004, "invalid-credential"),
+      (17005, "user-disabled"),
+      (17006, "operation-not-allowed"),
+      (17007, "email-already-in-use"),
+      (17008, "invalid-email"),
+      (17009, "wrong-password"),
+      (17010, "too-many-requests"),
+      (17011, "user-not-found"),
+      (17012, "account-exists-with-different-credential"),
+      (17014, "requires-recent-login"),
+      (17015, "provider-already-linked"),
+      (17016, "no-such-provider"),
+      (17017, "invalid-user-token"),
+      (17020, "network-request-failed"),
+      (17021, "user-token-expired"),
+      (17023, "invalid-api-key"),
+      (17024, "user-mismatch"),
+      (17025, "credential-already-in-use"),
+      (17026, "weak-password"),
+      (17028, "app-not-authorized"),
+      (17029, "expired-action-code"),
+      (17030, "invalid-action-code"),
+      (17031, "invalid-message-payload"),
+      (17032, "invalid-sender"),
+      (17033, "invalid-recipient-email"),
+      (17034, "invalid-email"),
+      (17036, "missing-ios-bundle-id"),
+      (17037, "missing-android-pkg-name"),
+      (17038, "unauthorized-domain"),
+      (17039, "invalid-continue-uri"),
+      (17040, "missing-continue-uri"),
+      (17041, "missing-phone-number"),
+      (17042, "invalid-phone-number"),
+      (17043, "missing-verification-code"),
+      (17044, "invalid-verification-code"),
+      (17045, "missing-verification-id"),
+      (17046, "invalid-verification-id"),
+      (17047, "missing-app-credential"),
+      (17048, "invalid-app-credential"),
+      (17051, "code-expired"),
+      (17052, "quota-exceeded"),
+      (17053, "missing-apns-token"),
+      (17054, "notification-not-forwarded"),
+      (17055, "app-not-verified"),
+      (17056, "captcha-check-failed"),
+      (17057, "cancelled-popup-request"),
+      (17058, "popup-closed-by-user"),
+      (17059, "app-verification-user-interaction-failure"),
+      (17060, "invalid-oauth-client-id"),
+      (17061, "network-request-failed"),
+      (17062, "internal-error"),
+      (17067, "null-user"),
+      (17995, "keychain-error"),
+      (17999, "internal-error"),
+      (18000, "malformed-jwt"),
+      (17078, "multi-factor-auth-required"),
+    ]
+
+    for (code, js) in expected {
+      XCTAssertEqual(
+        RNFBAuthErrorCodeMapper.jsErrorCode(forAuthErrorCode: code),
+        js,
+        "FIRAuthErrorCode raw \(code)"
+      )
+    }
+  }
+}

package/ios/RNFBAuthUnitTests/RNFBAuthListenerRegistryStorageTests.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 XCTest
+
+private final class FakeRemovableHandle: NSObject {
+  private(set) var removeCount = 0
+
+  @objc func remove() {
+    removeCount += 1
+  }
+}
+
+final class RNFBAuthListenerRegistryStorageTests: XCTestCase {
+  private var storage: RNFBAuthListenerRegistryStorage!
+
+  override func setUp() {
+    super.setUp()
+    storage = RNFBAuthListenerRegistryStorage()
+  }
+
+  func testPutIfAbsent_storesWhenFree() {
+    let handle = FakeRemovableHandle()
+    XCTAssertTrue(storage.putIfAbsent("k1" as NSString, value: handle))
+    XCTAssertTrue(storage.get("k1" as NSString) === handle)
+    XCTAssertEqual(handle.removeCount, 0)
+  }
+
+  func testPutIfAbsent_collision_keepsExistingWithoutRemove() {
+    let first = FakeRemovableHandle()
+    let second = FakeRemovableHandle()
+    XCTAssertTrue(storage.putIfAbsent("k1" as NSString, value: first))
+    XCTAssertFalse(storage.putIfAbsent("k1" as NSString, value: second))
+    XCTAssertTrue(storage.get("k1" as NSString) === first)
+    XCTAssertEqual(first.removeCount, 0)
+    XCTAssertEqual(second.removeCount, 0)
+  }
+
+  func testPutOrDiscard_storesWhenFree() {
+    let handle = FakeRemovableHandle()
+    XCTAssertTrue(storage.putOrDiscard("k1" as NSString, value: handle))
+    XCTAssertTrue(storage.get("k1" as NSString) === handle)
+    XCTAssertEqual(handle.removeCount, 0)
+  }
+
+  func testPutOrDiscard_collision_removesIncoming() {
+    let first = FakeRemovableHandle()
+    let duplicate = FakeRemovableHandle()
+    XCTAssertTrue(storage.putOrDiscard("k1" as NSString, value: first))
+    XCTAssertFalse(storage.putOrDiscard("k1" as NSString, value: duplicate))
+    XCTAssertEqual(duplicate.removeCount, 1)
+    XCTAssertEqual(first.removeCount, 0)
+    XCTAssertTrue(storage.get("k1" as NSString) === first)
+  }
+
+  func testGet_whenFree_isNil() {
+    XCTAssertNil(storage.get("missing" as NSString))
+  }
+
+  func testTake_removesAndReturnsWithoutCallingRemove() {
+    let handle = FakeRemovableHandle()
+    XCTAssertTrue(storage.putIfAbsent("k1" as NSString, value: handle))
+    XCTAssertTrue(storage.take("k1" as NSString) === handle)
+    XCTAssertNil(storage.get("k1" as NSString))
+    XCTAssertEqual(handle.removeCount, 0)
+  }
+
+  func testTake_whenFree_isNil() {
+    XCTAssertNil(storage.take("missing" as NSString))
+  }
+
+  func testTakeAndRemove_removesAfterTake() {
+    let handle = FakeRemovableHandle()
+    XCTAssertTrue(storage.putIfAbsent("k1" as NSString, value: handle))
+    storage.takeAndRemove("k1" as NSString)
+    XCTAssertEqual(handle.removeCount, 1)
+    XCTAssertNil(storage.get("k1" as NSString))
+  }
+
+  func testTakeAndRemove_missingKey_isNoOp() {
+    storage.takeAndRemove("missing" as NSString)
+  }
+
+  func testTakeAndRemove_objectWithoutRemove_doesNotCrash() {
+    let plain = NSObject()
+    XCTAssertTrue(storage.putIfAbsent("plain" as NSString, value: plain))
+    storage.takeAndRemove("plain" as NSString)
+    XCTAssertNil(storage.get("plain" as NSString))
+  }
+
+  func testRemoveAll_removesSnapshotAndLeavesEmpty() {
+    let a = FakeRemovableHandle()
+    let b = FakeRemovableHandle()
+    XCTAssertTrue(storage.putIfAbsent("a" as NSString, value: a))
+    XCTAssertTrue(storage.putIfAbsent("b" as NSString, value: b))
+    storage.removeAll()
+    XCTAssertEqual(a.removeCount, 1)
+    XCTAssertEqual(b.removeCount, 1)
+    XCTAssertNil(storage.get("a" as NSString))
+    XCTAssertNil(storage.get("b" as NSString))
+  }
+
+  func testRemoveAll_objectWithoutRemove_doesNotCrash() {
+    let plain = NSObject()
+    XCTAssertTrue(storage.putIfAbsent("plain" as NSString, value: plain))
+    storage.removeAll()
+    XCTAssertNil(storage.get("plain" as NSString))
+  }
+}

package/ios/RNFBAuthUnitTests/RNFBAuthNullSentinelDecodeTests.m

@@ -0,0 +1,78 @@
+/**
+ * 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 <XCTest/XCTest.h>
+
+#import "RNFBAuthNullSentinelDecoder.h"
+
+@interface RNFBAuthNullSentinelDecodeTests : XCTestCase
+@end
+
+@implementation RNFBAuthNullSentinelDecodeTests
+
+- (NSDictionary *)nullSentinel {
+  return @{@"__rnfbNull" : @YES};
+}
+
+- (NSDictionary *)unrelatedOneKeyDictionary {
+  return @{@".sv" : @"timestamp"};
+}
+
+- (void)testUpdateProfile_displayNameNullSentinel_becomesNil {
+  NSDictionary *props = @{@"displayName" : [self nullSentinel]};
+  NSDictionary *decoded = [RNFBAuthNullSentinelDecoder decodedProfileProps:props];
+  XCTAssertNil(decoded[@"displayName"]);
+  XCTAssertFalse([decoded[@"displayName"] isKindOfClass:[NSDictionary class]]);
+}
+
+- (void)testUpdateProfile_photoURLNullSentinel_becomesNil {
+  NSDictionary *props = @{@"photoURL" : [self nullSentinel]};
+  NSDictionary *decoded = [RNFBAuthNullSentinelDecoder decodedProfileProps:props];
+  XCTAssertNil(decoded[@"photoURL"]);
+  XCTAssertFalse([decoded[@"photoURL"] isKindOfClass:[NSDictionary class]]);
+  // Same path updateProfile uses: seam omit → subscript nil → clear arm (nil, not URLWithString:).
+  XCTAssertNil([RNFBAuthNullSentinelDecoder photoURLFromDecodedValue:decoded[@"photoURL"]]);
+}
+
+- (void)testUpdateProfile_photoURLFromDecodedValue_nilClearsWithoutURLWithString {
+  XCTAssertNil([RNFBAuthNullSentinelDecoder photoURLFromDecodedValue:nil]);
+}
+
+- (void)testUpdateProfile_photoURLFromDecodedValue_stringBecomesNSURL {
+  NSURL *url = [RNFBAuthNullSentinelDecoder photoURLFromDecodedValue:@"https://example.com/a.jpg"];
+  XCTAssertEqualObjects(url.absoluteString, @"https://example.com/a.jpg");
+}
+
+- (void)testUpdateProfile_displayNameNSNull_becomesNil {
+  NSDictionary *props = @{@"displayName" : [NSNull null]};
+  NSDictionary *decoded = [RNFBAuthNullSentinelDecoder decodedProfileProps:props];
+  XCTAssertNil(decoded[@"displayName"]);
+}
+
+- (void)testUpdateProfile_photoURLNSNull_becomesNil {
+  NSDictionary *props = @{@"photoURL" : [NSNull null]};
+  NSDictionary *decoded = [RNFBAuthNullSentinelDecoder decodedProfileProps:props];
+  XCTAssertNil(decoded[@"photoURL"]);
+}
+
+- (void)testUpdateProfile_unrelatedOneKeyDictionary_unchanged {
+  NSDictionary *props = @{@"displayName" : [self unrelatedOneKeyDictionary]};
+  NSDictionary *decoded = [RNFBAuthNullSentinelDecoder decodedProfileProps:props];
+  XCTAssertEqualObjects(decoded[@"displayName"], [self unrelatedOneKeyDictionary]);
+}
+
+@end

package/ios/RNFBAuthUnitTests/RNFBAuthUnitTests.xcodeproj/project.pbxproj

@@ -12,7 +12,17 @@
 		A9000000000000000000000C /* RNFBAuthListenerRegistryTests.m in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000009 /* RNFBAuthListenerRegistryTests.m */; };
 		A9000000000000000000001E /* RNFBAuthCacheRegistry.m in Sources */ = {isa = PBXBuildFile; fileRef = A9000000000000000000001C /* RNFBAuthCacheRegistry.m */; };
 		A9000000000000000000001F /* RNFBAuthCacheRegistryTests.m in Sources */ = {isa = PBXBuildFile; fileRef = A9000000000000000000001D /* RNFBAuthCacheRegistryTests.m */; };
+		A90000000000000000000030 /* RNFBNullSentinelDecoding.swift in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000031 /* RNFBNullSentinelDecoding.swift */; };
+		A90000000000000000000032 /* RNFBAuthNullSentinelDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000033 /* RNFBAuthNullSentinelDecoder.m */; };
+		A90000000000000000000038 /* RNFBAuthNullSentinelDecodeTests.m in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000039 /* RNFBAuthNullSentinelDecodeTests.m */; };
 		A90000000000000000000015 /* XCTest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A90000000000000000000014 /* XCTest.framework */; };
+		A90000000000000000000020 /* RNFBHandleMapStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000021 /* RNFBHandleMapStorage.swift */; };
+		A90000000000000000000022 /* RNFBAuthCacheRegistryStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000023 /* RNFBAuthCacheRegistryStorage.swift */; };
+		A90000000000000000000024 /* RNFBAuthCacheRegistryStorageTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000025 /* RNFBAuthCacheRegistryStorageTests.swift */; };
+		A90000000000000000000026 /* RNFBAuthListenerRegistryStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000027 /* RNFBAuthListenerRegistryStorage.swift */; };
+		A90000000000000000000028 /* RNFBAuthListenerRegistryStorageTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000029 /* RNFBAuthListenerRegistryStorageTests.swift */; };
+		A9000000000000000000002A /* RNFBAuthErrorCodeMapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = A9000000000000000000002B /* RNFBAuthErrorCodeMapper.swift */; };
+		A9000000000000000000002C /* RNFBAuthErrorCodeMapperTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = A9000000000000000000002D /* RNFBAuthErrorCodeMapperTests.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
@@ -25,7 +35,18 @@
 		A90000000000000000000019 /* RNFBAuthCacheRegistry.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBAuthCacheRegistry.h; path = ../RNFBAuth/RNFBAuthCacheRegistry.h; sourceTree = SOURCE_ROOT; };
 		A9000000000000000000001C /* RNFBAuthCacheRegistry.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBAuthCacheRegistry.m; path = ../RNFBAuth/RNFBAuthCacheRegistry.m; sourceTree = SOURCE_ROOT; };
 		A9000000000000000000001D /* RNFBAuthCacheRegistryTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBAuthCacheRegistryTests.m; sourceTree = "<group>"; };
+		A90000000000000000000031 /* RNFBNullSentinelDecoding.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBNullSentinelDecoding.swift; path = ../../../app/ios/RNFBApp/RNFBNullSentinelDecoding.swift; sourceTree = SOURCE_ROOT; };
+		A90000000000000000000033 /* RNFBAuthNullSentinelDecoder.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBAuthNullSentinelDecoder.m; path = ../RNFBAuth/RNFBAuthNullSentinelDecoder.m; sourceTree = SOURCE_ROOT; };
+		A9000000000000000000003B /* RNFBAuthNullSentinelDecoder.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBAuthNullSentinelDecoder.h; path = ../RNFBAuth/RNFBAuthNullSentinelDecoder.h; sourceTree = SOURCE_ROOT; };
+		A90000000000000000000039 /* RNFBAuthNullSentinelDecodeTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBAuthNullSentinelDecodeTests.m; sourceTree = "<group>"; };
 		A90000000000000000000014 /* XCTest.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = XCTest.framework; path = Platforms/MacOSX.platform/Developer/Library/Frameworks/XCTest.framework; sourceTree = DEVELOPER_DIR; };
+		A90000000000000000000021 /* RNFBHandleMapStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBHandleMapStorage.swift; path = ../../../app/ios/RNFBApp/RNFBHandleMapStorage.swift; sourceTree = SOURCE_ROOT; };
+		A90000000000000000000023 /* RNFBAuthCacheRegistryStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBAuthCacheRegistryStorage.swift; path = ../RNFBAuth/RNFBAuthCacheRegistryStorage.swift; sourceTree = SOURCE_ROOT; };
+		A90000000000000000000025 /* RNFBAuthCacheRegistryStorageTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RNFBAuthCacheRegistryStorageTests.swift; sourceTree = "<group>"; };
+		A90000000000000000000027 /* RNFBAuthListenerRegistryStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBAuthListenerRegistryStorage.swift; path = ../RNFBAuth/RNFBAuthListenerRegistryStorage.swift; sourceTree = SOURCE_ROOT; };
+		A90000000000000000000029 /* RNFBAuthListenerRegistryStorageTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RNFBAuthListenerRegistryStorageTests.swift; sourceTree = "<group>"; };
+		A9000000000000000000002B /* RNFBAuthErrorCodeMapper.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBAuthErrorCodeMapper.swift; path = ../RNFBAuth/RNFBAuthErrorCodeMapper.swift; sourceTree = SOURCE_ROOT; };
+		A9000000000000000000002D /* RNFBAuthErrorCodeMapperTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RNFBAuthErrorCodeMapperTests.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -61,12 +82,23 @@
 			children = (
 				A90000000000000000000007 /* RNFBHandleMap.h */,
 				A90000000000000000000008 /* RNFBHandleMap.m */,
+				A90000000000000000000021 /* RNFBHandleMapStorage.swift */,
 				A90000000000000000000016 /* RNFBAuthListenerRegistry.h */,
 				A90000000000000000000018 /* RNFBAuthListenerRegistry.m */,
+				A90000000000000000000027 /* RNFBAuthListenerRegistryStorage.swift */,
 				A90000000000000000000009 /* RNFBAuthListenerRegistryTests.m */,
+				A90000000000000000000029 /* RNFBAuthListenerRegistryStorageTests.swift */,
 				A90000000000000000000019 /* RNFBAuthCacheRegistry.h */,
 				A9000000000000000000001C /* RNFBAuthCacheRegistry.m */,
+				A90000000000000000000023 /* RNFBAuthCacheRegistryStorage.swift */,
 				A9000000000000000000001D /* RNFBAuthCacheRegistryTests.m */,
+				A90000000000000000000031 /* RNFBNullSentinelDecoding.swift */,
+				A9000000000000000000003B /* RNFBAuthNullSentinelDecoder.h */,
+				A90000000000000000000033 /* RNFBAuthNullSentinelDecoder.m */,
+				A90000000000000000000039 /* RNFBAuthNullSentinelDecodeTests.m */,
+				A90000000000000000000025 /* RNFBAuthCacheRegistryStorageTests.swift */,
+				A9000000000000000000002B /* RNFBAuthErrorCodeMapper.swift */,
+				A9000000000000000000002D /* RNFBAuthErrorCodeMapperTests.swift */,
 			);
 			name = Sources;
 			sourceTree = "<group>";
@@ -129,10 +161,20 @@
 			buildActionMask = 2147483647;
 			files = (
 				A9000000000000000000000A /* RNFBHandleMap.m in Sources */,
+				A90000000000000000000020 /* RNFBHandleMapStorage.swift in Sources */,
 				A9000000000000000000000B /* RNFBAuthListenerRegistry.m in Sources */,
+				A90000000000000000000026 /* RNFBAuthListenerRegistryStorage.swift in Sources */,
 				A9000000000000000000000C /* RNFBAuthListenerRegistryTests.m in Sources */,
+				A90000000000000000000028 /* RNFBAuthListenerRegistryStorageTests.swift in Sources */,
 				A9000000000000000000001E /* RNFBAuthCacheRegistry.m in Sources */,
+				A90000000000000000000022 /* RNFBAuthCacheRegistryStorage.swift in Sources */,
 				A9000000000000000000001F /* RNFBAuthCacheRegistryTests.m in Sources */,
+				A90000000000000000000030 /* RNFBNullSentinelDecoding.swift in Sources */,
+				A90000000000000000000032 /* RNFBAuthNullSentinelDecoder.m in Sources */,
+				A90000000000000000000038 /* RNFBAuthNullSentinelDecodeTests.m in Sources */,
+				A90000000000000000000024 /* RNFBAuthCacheRegistryStorageTests.swift in Sources */,
+				A9000000000000000000002A /* RNFBAuthErrorCodeMapper.swift in Sources */,
+				A9000000000000000000002C /* RNFBAuthErrorCodeMapperTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -181,8 +223,10 @@
 				CODE_SIGNING_REQUIRED = NO;
 				CODE_SIGN_IDENTITY = "-";
 				COMBINE_HIDPI_IMAGES = YES;
+				DEFINES_MODULE = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				HEADER_SEARCH_PATHS = (
+					"$(SRCROOT)",
 					"$(SRCROOT)/../../../app/ios",
 					"$(SRCROOT)/../../../app/ios/RNFBApp",
 					"$(SRCROOT)/../RNFBAuth",
@@ -204,6 +248,8 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
 				SUPPORTED_PLATFORMS = macosx;
+				SWIFT_OBJC_INTERFACE_HEADER_NAME = "RNFBHandleMapStorage-Swift.inc";
+				SWIFT_VERSION = 5.10;
 			};
 			name = Debug;
 		};
@@ -215,8 +261,10 @@
 				CODE_SIGNING_REQUIRED = NO;
 				CODE_SIGN_IDENTITY = "-";
 				COMBINE_HIDPI_IMAGES = YES;
+				DEFINES_MODULE = YES;
 				GENERATE_INFOPLIST_FILE = YES;
 				HEADER_SEARCH_PATHS = (
+					"$(SRCROOT)",
 					"$(SRCROOT)/../../../app/ios",
 					"$(SRCROOT)/../../../app/ios/RNFBApp",
 					"$(SRCROOT)/../RNFBAuth",
@@ -231,6 +279,8 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = macosx;
 				SUPPORTED_PLATFORMS = macosx;
+				SWIFT_OBJC_INTERFACE_HEADER_NAME = "RNFBHandleMapStorage-Swift.inc";
+				SWIFT_VERSION = 5.10;
 			};
 			name = Release;
 		};

package/lib/index.ts

@@ -47,11 +47,11 @@ import {
   parseListenerOrObserver,
 } from '@react-native-firebase/app/dist/module/common';
 import type { ReactNativeFirebase } from '@react-native-firebase/app';
-import { setReactNativeModule } from '@react-native-firebase/app/dist/module/internal/nativeModule';
 import {
   FirebaseModule,
   getOrCreateModularInstance,
   type ModuleConfig,
+  setReactNativeModule,
 } from '@react-native-firebase/app/dist/module/internal';
 import ConfirmationResultClass from './ConfirmationResult';
 import { ActionCodeURL } from './ActionCodeURL';

package/lib/types/internal.ts

@@ -20,8 +20,8 @@ import type {} from '@react-native-firebase/app/dist/module/internal/NativeModul
 import type {
   ModuleConfig,
   NativeErrorUserInfo,
+  ReactNativeFirebaseEventEmitter,
 } from '@react-native-firebase/app/dist/module/types/internal';
-import type EventEmitter from 'react-native/Libraries/vendor/emitter/EventEmitter';
 import type {
   ActionCodeInfo,
   ActionCodeSettings,
@@ -411,7 +411,7 @@ export type AuthInternal = Auth & {
   verifyPasswordResetCode(code: string): Promise<string>;
   revokeToken(authorizationCode: string): Promise<void>;
   native: RNFBAuthModule;
-  emitter: EventEmitter;
+  emitter: ReactNativeFirebaseEventEmitter;
   eventNameForApp(...args: Array<string | number>): string;
   _config: ModuleConfig;
   _tenantId: string | null;