@react-native-firebase/app 26.4.0 → 27.0.0

package/ios/RNFBAppUnitTests/RNFBUtilsHelpersTests.swift

@@ -0,0 +1,144 @@
+/**
+ * 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
+import XCTest
+
+final class RNFBUtilsHelpersTests: XCTestCase {
+  func testPathForDirectoryReturnsSearchPathFirstObject() {
+    let caches = RNFBUtilsHelpers.path(
+      forDirectory: Int32(FileManager.SearchPathDirectory.cachesDirectory.rawValue)
+    )
+    let expected = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true)
+      .first
+    XCTAssertEqual(caches, expected)
+    XCTAssertNotNil(caches)
+  }
+
+  func testUtilsConstantsDictionaryIncludesRequiredKeys() {
+    let constants = RNFBUtilsHelpers.utilsConstantsDictionary(
+      bundlePath: "/App.app",
+      appVersion: "1.2.3",
+      pathProvider: { directory in "path-\(directory)" },
+      temporaryDirectory: "/tmp/rnfb"
+    )
+
+    XCTAssertEqual(constants["isRunningInTestLab"] as? Bool, false)
+    XCTAssertEqual(constants["MAIN_BUNDLE"] as? String, "/App.app")
+    XCTAssertEqual(
+      constants["CACHES_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.cachesDirectory.rawValue)"
+    )
+    XCTAssertEqual(
+      constants["DOCUMENT_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.documentDirectory.rawValue)"
+    )
+    XCTAssertEqual(
+      constants["PICTURES_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.picturesDirectory.rawValue)"
+    )
+    XCTAssertEqual(
+      constants["MOVIES_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.moviesDirectory.rawValue)"
+    )
+    XCTAssertEqual(constants["TEMP_DIRECTORY"] as? String, "/tmp/rnfb")
+    XCTAssertEqual(
+      constants["LIBRARY_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.libraryDirectory.rawValue)"
+    )
+    XCTAssertEqual(constants["appVersion"] as? String, "1.2.3")
+  }
+
+  func testUtilsConstantsDictionaryOmitsAppVersionWhenMissingEmptyOrNonString() {
+    let pathProvider: RNFBUtilsPathProvider = { _ in "/p" }
+
+    let missing = RNFBUtilsHelpers.utilsConstantsDictionary(
+      bundlePath: "/b",
+      appVersion: nil,
+      pathProvider: pathProvider,
+      temporaryDirectory: "/t"
+    )
+    XCTAssertNil(missing["appVersion"])
+
+    let empty = RNFBUtilsHelpers.utilsConstantsDictionary(
+      bundlePath: "/b",
+      appVersion: "",
+      pathProvider: pathProvider,
+      temporaryDirectory: "/t"
+    )
+    XCTAssertNil(empty["appVersion"])
+
+    let nonString = RNFBUtilsHelpers.utilsConstantsDictionary(
+      bundlePath: "/b",
+      appVersion: NSNumber(value: 42),
+      pathProvider: pathProvider,
+      temporaryDirectory: "/t"
+    )
+    XCTAssertNil(nonString["appVersion"])
+  }
+
+  func testUtilsConstantsDictionaryDefaultUsesMainBundle() {
+    let constants = RNFBUtilsHelpers.utilsConstantsDictionary()
+    XCTAssertEqual(constants["MAIN_BUNDLE"] as? String, Bundle.main.bundlePath)
+    XCTAssertEqual(constants["isRunningInTestLab"] as? Bool, false)
+    XCTAssertNotNil(constants["CACHES_DIRECTORY"])
+    XCTAssertNotNil(constants["TEMP_DIRECTORY"])
+  }
+
+  func testIsRemoteAssetPrefixChecks() {
+    XCTAssertTrue(RNFBUtilsHelpers.isRemoteAsset("assets-library://asset/foo"))
+    XCTAssertTrue(RNFBUtilsHelpers.isRemoteAsset("ph://LOCAL-ID"))
+    XCTAssertFalse(RNFBUtilsHelpers.isRemoteAsset("file:///tmp/x.jpg"))
+    XCTAssertFalse(RNFBUtilsHelpers.isRemoteAsset(""))
+    XCTAssertFalse(RNFBUtilsHelpers.isRemoteAsset(nil))
+  }
+
+  func testUnusedIsHeicCaseInsensitiveAndNilMessaging() {
+    XCTAssertTrue(RNFBUtilsHelpers.unusedIsHeic("photo.heic"))
+    XCTAssertTrue(RNFBUtilsHelpers.unusedIsHeic("photo.HEIC"))
+    XCTAssertTrue(RNFBUtilsHelpers.unusedIsHeic("photo.Heic"))
+    XCTAssertFalse(RNFBUtilsHelpers.unusedIsHeic("photo.jpg"))
+    XCTAssertFalse(RNFBUtilsHelpers.unusedIsHeic("heic"))
+    // Pre-port ObjC nil messaging → YES
+    XCTAssertTrue(RNFBUtilsHelpers.unusedIsHeic(nil))
+  }
+
+  func testValueForKeyFromQueryItemsUsesNamePredicateAndFirstObject() {
+    let items = [
+      URLQueryItem(name: "other", value: "a"),
+      URLQueryItem(name: "id", value: "first-id"),
+      URLQueryItem(name: "id", value: "second-id"),
+    ]
+
+    XCTAssertEqual(
+      RNFBUtilsHelpers.value(forKey: "id", fromQueryItems: items),
+      "first-id"
+    )
+    XCTAssertEqual(
+      RNFBUtilsHelpers.value(forKey: "other", fromQueryItems: items),
+      "a"
+    )
+    XCTAssertNil(RNFBUtilsHelpers.value(forKey: "missing", fromQueryItems: items))
+    XCTAssertNil(RNFBUtilsHelpers.value(forKey: "id", fromQueryItems: nil))
+    XCTAssertNil(RNFBUtilsHelpers.value(forKey: "id", fromQueryItems: []))
+    XCTAssertNil(
+      RNFBUtilsHelpers.value(
+        forKey: "id",
+        fromQueryItems: [URLQueryItem(name: "id", value: nil)]
+      )
+    )
+  }
+}

package/ios/RNFBAppUnitTests/RNFBUtilsModuleFacadeTests.m

@@ -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/XCTest.h>
+
+#import "RNFBHandleMapStorage-Swift.inc"
+#import "RNFBUtilsModule.h"
+
+@interface RNFBUtilsModuleFacadeTests : XCTestCase
+@end
+
+@implementation RNFBUtilsModuleFacadeTests
+
+- (void)testFacadePathForDirectoryMatchesSearchPath {
+  NSString *path = [RNFBUtilsHelpers pathForDirectory:(int)NSCachesDirectory];
+  NSString *expected =
+      [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
+  XCTAssertEqualObjects(path, expected);
+}
+
+- (void)testFacadeUtilsConstantsDictionaryKeys {
+  NSDictionary *constants = [RNFBUtilsHelpers
+      utilsConstantsDictionaryWithBundlePath:@"/Bundle.app"
+                                  appVersion:@"9.9.9"
+                                pathProvider:^NSString *(int directory) {
+                                  return [NSString stringWithFormat:@"dir-%d", directory];
+                                }
+                          temporaryDirectory:@"/tmp/facade"];
+
+  XCTAssertEqualObjects(constants[@"isRunningInTestLab"], @NO);
+  XCTAssertEqualObjects(constants[@"MAIN_BUNDLE"], @"/Bundle.app");
+  XCTAssertEqualObjects(constants[@"TEMP_DIRECTORY"], @"/tmp/facade");
+  XCTAssertEqualObjects(constants[@"appVersion"], @"9.9.9");
+  XCTAssertEqualObjects(constants[@"CACHES_DIRECTORY"],
+                        ([NSString stringWithFormat:@"dir-%d", (int)NSCachesDirectory]));
+}
+
+- (void)testFacadeIsRemoteAsset {
+  XCTAssertTrue([RNFBUtilsModule isRemoteAsset:@"assets-library://x"]);
+  XCTAssertTrue([RNFBUtilsModule isRemoteAsset:@"ph://y"]);
+  XCTAssertFalse([RNFBUtilsModule isRemoteAsset:@"/local/file.jpg"]);
+}
+
+- (void)testFacadeUnusedIsHeic {
+  XCTAssertTrue([RNFBUtilsModule unused_isHeic:@"a.HEIC"]);
+  XCTAssertFalse([RNFBUtilsModule unused_isHeic:@"a.png"]);
+}
+
+- (void)testFacadeValueForKeyFromQueryItems {
+  NSArray *items = @[
+    [NSURLQueryItem queryItemWithName:@"id" value:@"asset-1"],
+    [NSURLQueryItem queryItemWithName:@"w" value:@"100"],
+  ];
+  XCTAssertEqualObjects([RNFBUtilsModule valueForKey:@"id" fromQueryItems:items], @"asset-1");
+  XCTAssertEqualObjects([RNFBUtilsModule valueForKey:@"w" fromQueryItems:items], @"100");
+  XCTAssertNil([RNFBUtilsModule valueForKey:@"missing" fromQueryItems:items]);
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBUtilsModuleShellTests.mm

@@ -0,0 +1,282 @@
+/**
+ * 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 <Photos/Photos.h>
+#import <XCTest/XCTest.h>
+#import <objc/runtime.h>
+
+#import "RNFBAppTurboModules.h"
+#import "RNFBUtilsModule.h"
+#import "RNFBUtilsModuleImplementation.h"
+
+/**
+ * Exercises the shipped `RNFBUtilsModule.mm` shell, the Android-only stubs in
+ * `RNFBUtilsModuleImplementation.m` and the PhotoKit category in
+ * `RNFBUtilsModule+PhotoAssets.m`. All three are compiled into this target.
+ */
+@interface RNFBUtilsModule (ShellTesting)
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboUtils::Constants>)constantsToExport;
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboUtils::Constants>)getConstants;
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params;
++ (BOOL)requiresMainQueueSetup;
++ (NSString *)moduleName;
+- (void)androidGetPlayServicesStatus:(RCTPromiseResolveBlock)resolve
+                              reject:(RCTPromiseRejectBlock)reject;
+- (void)androidPromptForPlayServices:(RCTPromiseResolveBlock)resolve
+                              reject:(RCTPromiseRejectBlock)reject;
+- (void)androidResolutionForPlayServices:(RCTPromiseResolveBlock)resolve
+                                  reject:(RCTPromiseRejectBlock)reject;
+- (void)androidMakePlayServicesAvailable:(RCTPromiseResolveBlock)resolve
+                                  reject:(RCTPromiseRejectBlock)reject;
+@end
+
+/** `PHFetchResult` stand-in whose `firstObject` is controlled by the test. */
+@interface RNFBFakeFetchResult : PHFetchResult
+@property(nonatomic, strong, nullable) PHAsset *stubbedFirstObject;
+@end
+
+@implementation RNFBFakeFetchResult
+- (id)firstObject {
+  return self.stubbedFirstObject;
+}
+@end
+
+static SEL PHAssetFetchSelector(void) {
+  return @selector(fetchAssetsWithLocalIdentifiers:options:);
+}
+
+@interface RNFBUtilsModuleShellTests : XCTestCase
+@property(nonatomic, strong) PHAsset *fakeAsset;
+@property(nonatomic, strong) NSMutableArray<NSArray<NSString *> *> *fetchedIdentifiers;
+@property(nonatomic, strong) NSMutableArray<NSNumber *> *fetchedOptionsWereNil;
+@property(nonatomic, assign) IMP originalFetchImplementation;
+@end
+
+@implementation RNFBUtilsModuleShellTests
+
+#pragma mark - Module shell
+
+- (void)testExportedModuleNameAndMainQueueSetup {
+  XCTAssertEqualObjects([RNFBUtilsModule moduleName], @"NativeRNFBTurboUtils");
+  XCTAssertFalse([RNFBUtilsModule requiresMainQueueSetup]);
+}
+
+- (void)testGetTurboModuleCreatesTheUtilsSpecModule {
+  RNFBUtilsModule *module = [[RNFBUtilsModule alloc] init];
+  facebook::react::ObjCTurboModule::InitParams params;
+
+  auto turboModule = [module getTurboModule:params];
+
+  XCTAssertTrue(turboModule != nullptr);
+  XCTAssertTrue(std::dynamic_pointer_cast<facebook::react::NativeRNFBTurboUtilsSpecJSI>(
+                    turboModule) != nullptr);
+}
+
+- (void)testConstantsToExportAndGetConstantsReturnUtilsConstants {
+  RNFBUtilsModule *module = [[RNFBUtilsModule alloc] init];
+
+  auto exported = [module constantsToExport];
+  auto fetched = [module getConstants];
+
+  for (NSDictionary *constants in @[ exported.dictionary, fetched.dictionary ]) {
+    XCTAssertEqualObjects(constants[@"isRunningInTestLab"], @NO);
+    XCTAssertNotNil(constants[@"MAIN_BUNDLE"]);
+    XCTAssertNotNil(constants[@"TEMP_DIRECTORY"]);
+    XCTAssertNotNil(constants[@"CACHES_DIRECTORY"]);
+  }
+  XCTAssertEqualObjects(RNFBUtilsModuleConstantsDictionary()[@"isRunningInTestLab"], @NO);
+}
+
+#pragma mark - Android-only stubs
+
+- (void)testAndroidPlayServicesStatusReportsAvailableOnIOS {
+  RNFBUtilsModule *module = [[RNFBUtilsModule alloc] init];
+  __block NSDictionary *viaModule = nil;
+  __block NSDictionary *viaFunction = nil;
+
+  [module
+      androidGetPlayServicesStatus:^(id result) {
+        viaModule = result;
+      }
+      reject:^(NSString *code, NSString *message, NSError *error) {
+        XCTFail(@"unexpected reject %@", message);
+      }];
+  RNFBUtilsModuleAndroidGetPlayServicesStatus(
+      ^(id result) {
+        viaFunction = result;
+      },
+      ^(NSString *code, NSString *message, NSError *error) {
+        XCTFail(@"unexpected reject %@", message);
+      });
+
+  NSDictionary *expected = @{
+    @"isAvailable" : @YES,
+    @"status" : @0,
+    @"hasResolution" : @NO,
+    @"isUserResolvableError" : @NO,
+  };
+  XCTAssertEqualObjects(viaModule, expected);
+  XCTAssertEqualObjects(viaFunction, expected);
+}
+
+- (void)testAndroidPromptResolutionAndMakeAvailableResolveNil {
+  RNFBUtilsModule *module = [[RNFBUtilsModule alloc] init];
+  RCTPromiseRejectBlock failOnReject = ^(NSString *code, NSString *message, NSError *error) {
+    XCTFail(@"unexpected reject %@", message);
+  };
+  __block NSUInteger resolveCount = 0;
+  __block BOOL sawNonNil = NO;
+  RCTPromiseResolveBlock countNil = ^(id result) {
+    resolveCount += 1;
+    sawNonNil = sawNonNil || result != nil;
+  };
+
+  [module androidPromptForPlayServices:countNil reject:failOnReject];
+  [module androidResolutionForPlayServices:countNil reject:failOnReject];
+  [module androidMakePlayServicesAvailable:countNil reject:failOnReject];
+  RNFBUtilsModuleAndroidPromptForPlayServices(countNil, failOnReject);
+  RNFBUtilsModuleAndroidResolutionForPlayServices(countNil, failOnReject);
+  RNFBUtilsModuleAndroidMakePlayServicesAvailable(countNil, failOnReject);
+
+  XCTAssertEqual(resolveCount, 6);
+  XCTAssertFalse(sawNonNil);
+}
+
+#pragma mark - PhotoKit category
+
+- (void)testAssetsLibraryPathsAreUnsupportedAndNeverQueryPhotos {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:self.fakeAsset]];
+
+  // The one-time warning is suppressed on later calls; the result stays nil and PhotoKit is never
+  // consulted for the removed `assets-library://` scheme, even when an id is present.
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"assets-library://asset/asset.JPG?id=1"]);
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"assets-library://asset/asset.JPG?id=2"]);
+
+  XCTAssertEqual(self.fetchedIdentifiers.count, 0);
+}
+
+- (void)testPhotoLibraryPathPassesEverythingAfterTheSchemeToPhotoKit {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:self.fakeAsset]];
+
+  PHAsset *asset = [RNFBUtilsModule fetchAssetForPath:@"ph://ABC-123/L0/001"];
+
+  XCTAssertEqual(asset, self.fakeAsset);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"ABC-123/L0/001" ] ]);
+  XCTAssertEqual(self.fetchedOptionsWereNil.count, 1);
+  XCTAssertEqualObjects(self.fetchedOptionsWereNil.firstObject, @YES);
+}
+
+- (void)testPhotoLibraryPathWithNoMatchingAssetReturnsNil {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:nil]];
+
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"ph://missing-local-identifier"]);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"missing-local-identifier" ] ]);
+}
+
+- (void)testPhotoLibraryPathWithNoIdentifierLooksUpTheEmptyIdentifier {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:nil]];
+
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"ph://"]);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"" ] ]);
+}
+
+- (void)testOtherPathsLookUpTheIdQueryItem {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:self.fakeAsset]];
+
+  PHAsset *asset =
+      [RNFBUtilsModule fetchAssetForPath:@"file:///asset.jpg?w=100&id=local-identifier&h=50"];
+
+  XCTAssertEqual(asset, self.fakeAsset);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"local-identifier" ] ]);
+  XCTAssertEqualObjects(self.fetchedOptionsWereNil.firstObject, @YES);
+}
+
+- (void)testOtherPathsWithNoMatchingAssetReturnNil {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:nil]];
+
+  XCTAssertNil(
+      [RNFBUtilsModule fetchAssetForPath:@"file:///asset.jpg?id=missing-local-identifier"]);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, @[ @[ @"missing-local-identifier" ] ]);
+}
+
+- (void)testOtherPathsWithoutAnIdQueryItemRaiseBeforeQueryingPhotos {
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:self.fakeAsset]];
+
+  // Pre-port parity: a missing `id` yields a nil identifier and the `@[ assetId ]` literal
+  // raises. `RNFBStorageCommon` only reaches this method for `ph://` / `assets-library://`
+  // paths (`isRemoteAsset:`), so this is not reachable from the storage upload flow.
+  for (NSString *path in @[ @"file:///asset.jpg", @"file:///asset.jpg?other=1", @"" ]) {
+    XCTAssertThrowsSpecificNamed([RNFBUtilsModule fetchAssetForPath:path], NSException,
+                                 NSInvalidArgumentException, @"%@", path);
+  }
+  XCTAssertEqual(self.fetchedIdentifiers.count, 0);
+}
+
+- (void)testUnknownIdentifiersReturnNilWhenPhotoKitFindsNothing {
+  // Hostless macOS XCTest has no NSPhotoLibraryUsageDescription; never touch live PhotoKit.
+  // Stub an empty fetch for both lookup branches (`ph://` and `file://?id=`).
+  [self stubPhotoLibraryReturning:[self fetchResultContaining:nil]];
+
+  XCTAssertNil([RNFBUtilsModule fetchAssetForPath:@"ph://missing-local-identifier"]);
+  XCTAssertNil(
+      [RNFBUtilsModule fetchAssetForPath:@"file:///asset.jpg?id=missing-local-identifier"]);
+  XCTAssertEqualObjects(self.fetchedIdentifiers, (@[
+                          @[ @"missing-local-identifier" ],
+                          @[ @"missing-local-identifier" ],
+                        ]));
+}
+
+#pragma mark - PhotoKit stubbing
+
+- (void)setUp {
+  [super setUp];
+  self.fakeAsset = (PHAsset *)class_createInstance([PHAsset class], 0);
+  self.fetchedIdentifiers = [NSMutableArray array];
+  self.fetchedOptionsWereNil = [NSMutableArray array];
+}
+
+- (void)tearDown {
+  if (self.originalFetchImplementation != NULL) {
+    Method method = class_getClassMethod([PHAsset class], PHAssetFetchSelector());
+    method_setImplementation(method, self.originalFetchImplementation);
+    self.originalFetchImplementation = NULL;
+  }
+  [super tearDown];
+}
+
+- (id)fetchResultContaining:(PHAsset *)asset {
+  RNFBFakeFetchResult *result =
+      (RNFBFakeFetchResult *)class_createInstance([RNFBFakeFetchResult class], 0);
+  result.stubbedFirstObject = asset;
+  return result;
+}
+
+/** Replaces `+[PHAsset fetchAssetsWithLocalIdentifiers:options:]`, recording each call. */
+- (void)stubPhotoLibraryReturning:(id)fetchResult {
+  Method method = class_getClassMethod([PHAsset class], PHAssetFetchSelector());
+  self.originalFetchImplementation = method_getImplementation(method);
+  __weak RNFBUtilsModuleShellTests *weakSelf = self;
+  IMP stub = imp_implementationWithBlock(
+      ^id(id _self, NSArray<NSString *> *identifiers, PHFetchOptions *options) {
+        [weakSelf.fetchedIdentifiers addObject:identifiers];
+        [weakSelf.fetchedOptionsWereNil addObject:@(options == nil)];
+        return fetchResult;
+      });
+  method_setImplementation(method, stub);
+}
+
+@end

package/ios/RNFBFirebase/Package.swift

@@ -0,0 +1,53 @@
+// swift-tools-version: 5.9
+//
+// CI probe only (RNFB_TEST_RN_BARE_DYNAMIC_FIREBASE=1). Shipped podspecs keep
+// spm_dependency on firebase-ios-sdk. Exact pin tracks packages/app/package.json
+// sdkVersions.ios.firebase (checked by .github/workflows/scripts/check-ios-probe-sdk-pin.js).
+//
+// This package resolver rejects mixed Swift and Objective-C sources in one
+// target. SDK calls live in RNFBFirebaseBridge. The dynamic product links that
+// target beside the Swift target. The Swift target does not depend on it, so
+// the emitted module does not record FirebaseCore for clients.
+
+import PackageDescription
+
+let package = Package(
+  name: "RNFBFirebase",
+  platforms: [
+    .iOS(.v15),
+    .macOS(.v11),
+    .tvOS(.v15),
+  ],
+  products: [
+    .library(
+      name: "RNFBFirebase",
+      type: .dynamic,
+      targets: ["RNFBFirebase", "RNFBFirebaseBridge"]
+    ),
+  ],
+  dependencies: [
+    .package(
+      url: "https://github.com/firebase/firebase-ios-sdk.git",
+      exact: "13.0.0"
+    ),
+  ],
+  targets: [
+    .target(
+      name: "RNFBFirebaseBridge",
+      dependencies: [
+        .product(name: "FirebaseCore", package: "firebase-ios-sdk"),
+        .product(name: "FirebaseInstallations", package: "firebase-ios-sdk"),
+      ],
+      // Public headers stay empty so this clang target does not publish a
+      // module. The dynamic product still links the object file. The Swift
+      // target does not depend on it, so clients do not inherit FirebaseCore.
+      publicHeadersPath: "Public",
+      cSettings: [
+        .headerSearchPath("include"),
+      ]
+    ),
+    .target(
+      name: "RNFBFirebase"
+    ),
+  ]
+)