react-native-tvos 0.73.7-1 → 0.74.0-0

package/Libraries/AppDelegate/RCTAppDelegate.mm

@@ -7,19 +7,22 @@
 
 #import "RCTAppDelegate.h"
 #import <React/RCTCxxBridgeDelegate.h>
+#import <React/RCTLog.h>
 #import <React/RCTRootView.h>
 #import <React/RCTSurfacePresenterBridgeAdapter.h>
+#import <React/RCTUtils.h>
 #import <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #import "RCTAppSetupUtils.h"
-#import "RCTLegacyInteropComponents.h"
 
-#if RCT_NEW_ARCH_ENABLED
+#if RN_DISABLE_OSS_PLUGIN_HEADER
+#import <RCTTurboModulePlugin/RCTTurboModulePlugin.h>
+#else
 #import <React/CoreModulesPlugins.h>
+#endif
 #import <React/RCTBundleURLProvider.h>
 #import <React/RCTComponentViewFactory.h>
 #import <React/RCTComponentViewProtocol.h>
 #import <React/RCTFabricSurface.h>
-#import <React/RCTLegacyViewManagerInteropComponentView.h>
 #import <React/RCTSurfaceHostingProxyRootView.h>
 #import <React/RCTSurfacePresenter.h>
 #import <ReactCommon/RCTContextContainerHandling.h>
@@ -34,118 +37,53 @@
 #import <react/config/ReactNativeConfig.h>
 #import <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #import <react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.h>
-#import <react/runtime/JSEngineInstance.h>
-
-static NSString *const kRNConcurrentRoot = @"concurrentRoot";
+#import <react/runtime/JSRuntimeFactory.h>
 
-@interface RCTAppDelegate () <
-    RCTTurboModuleManagerDelegate,
-    RCTComponentViewFactoryComponentProvider,
-    RCTContextContainerHandling> {
-  std::shared_ptr<const facebook::react::ReactNativeConfig> _reactNativeConfig;
-  facebook::react::ContextContainer::Shared _contextContainer;
-}
+@interface RCTAppDelegate () <RCTComponentViewFactoryComponentProvider, RCTTurboModuleManagerDelegate>
 @end
 
-#endif
-
-static NSDictionary *updateInitialProps(NSDictionary *initialProps, BOOL isFabricEnabled)
-{
-#ifdef RCT_NEW_ARCH_ENABLED
-  NSMutableDictionary *mutableProps = [initialProps mutableCopy] ?: [NSMutableDictionary new];
-  // Hardcoding the Concurrent Root as it it not recommended to
-  // have the concurrentRoot turned off when Fabric is enabled.
-  mutableProps[kRNConcurrentRoot] = @(isFabricEnabled);
-  return mutableProps;
-#else
-  return initialProps;
-#endif
-}
-
-@interface RCTAppDelegate () <RCTCxxBridgeDelegate> {
-  std::shared_ptr<facebook::react::RuntimeScheduler> _runtimeScheduler;
-}
-@end
-
-@implementation RCTAppDelegate {
-#if RCT_NEW_ARCH_ENABLED
-  RCTHost *_reactHost;
-#endif
-}
-
-#if RCT_NEW_ARCH_ENABLED
-- (instancetype)init
-{
-  if (self = [super init]) {
-    _contextContainer = std::make_shared<facebook::react::ContextContainer const>();
-    _reactNativeConfig = std::make_shared<facebook::react::EmptyReactNativeConfig const>();
-    _contextContainer->insert("ReactNativeConfig", _reactNativeConfig);
-  }
-  return self;
-}
-#endif
+@implementation RCTAppDelegate
 
 - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
 {
-  BOOL enableTM = NO;
-  BOOL enableBridgeless = NO;
-  BOOL fabricEnabled = NO;
-#if RCT_NEW_ARCH_ENABLED
-  enableTM = self.turboModuleEnabled;
-  enableBridgeless = self.bridgelessEnabled;
-  fabricEnabled = [self fabricEnabled];
-#endif
-  NSDictionary *initProps = updateInitialProps([self prepareInitialProps], fabricEnabled);
-
-  RCTAppSetupPrepareApp(application, enableTM);
-
-  UIView *rootView;
-
-  if (enableBridgeless) {
-#if RCT_NEW_ARCH_ENABLED
-    // Enable native view config interop only if both bridgeless mode and Fabric is enabled.
-    RCTSetUseNativeViewConfigsInBridgelessMode(fabricEnabled);
-
-    // Enable TurboModule interop by default in Bridgeless mode
-    RCTEnableTurboModuleInterop(YES);
-    RCTEnableTurboModuleInteropBridgeProxy(YES);
+  RCTSetNewArchEnabled([self newArchEnabled]);
+  RCTAppSetupPrepareApp(application, self.turboModuleEnabled);
 
-    [self createReactHost];
-    [self unstable_registerLegacyComponents];
-    [RCTComponentViewFactory currentComponentViewFactory].thirdPartyFabricComponentsProvider = self;
-    RCTFabricSurface *surface = [_reactHost createSurfaceWithModuleName:self.moduleName initialProperties:initProps];
-
-    RCTSurfaceHostingProxyRootView *surfaceHostingProxyRootView = [[RCTSurfaceHostingProxyRootView alloc]
-        initWithSurface:surface
-        sizeMeasureMode:RCTSurfaceSizeMeasureModeWidthExact | RCTSurfaceSizeMeasureModeHeightExact];
+  self.rootViewFactory = [self createRCTRootViewFactory];
 
-    rootView = (RCTRootView *)surfaceHostingProxyRootView;
-#endif
-  } else {
-    if (!self.bridge) {
-      self.bridge = [self createBridgeWithDelegate:self launchOptions:launchOptions];
-    }
-#if RCT_NEW_ARCH_ENABLED
-    self.bridgeAdapter = [[RCTSurfacePresenterBridgeAdapter alloc] initWithBridge:self.bridge
-                                                                 contextContainer:_contextContainer];
-    self.bridge.surfacePresenter = self.bridgeAdapter.surfacePresenter;
+  UIView *rootView = [self.rootViewFactory viewWithModuleName:self.moduleName
+                                            initialProperties:self.initialProps
+                                                launchOptions:launchOptions];
 
-    [self unstable_registerLegacyComponents];
+  if (self.newArchEnabled || self.fabricEnabled) {
     [RCTComponentViewFactory currentComponentViewFactory].thirdPartyFabricComponentsProvider = self;
-#endif
-
-    rootView = [self createRootViewWithBridge:self.bridge moduleName:self.moduleName initProps:initProps];
   }
+  [self _logWarnIfCreateRootViewWithBridgeIsOverridden];
+  [self customizeRootView:(RCTRootView *)rootView];
+
   self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
   UIViewController *rootViewController = [self createRootViewController];
   [self setRootView:rootView toRootViewController:rootViewController];
   self.window.rootViewController = rootViewController;
+#if TARGET_OS_TV
+  UIUserInterfaceStyle style = rootViewController.traitCollection.userInterfaceStyle;
+  if (style == UIUserInterfaceStyleDark) {
+    rootView.backgroundColor = [UIColor colorWithRed:0.0 green:0.0 blue:0.0 alpha:1.0];
+  } else {
+    rootView.backgroundColor = [UIColor colorWithRed:1.0 green:1.0 blue:1.0 alpha:1.0];
+  }
+#endif
   self.window.windowScene.delegate = self;
   [self.window makeKeyAndVisible];
 
   return YES;
 }
 
+- (void)applicationDidEnterBackground:(UIApplication *)application
+{
+  // Noop
+}
+
 - (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
 {
   [NSException raise:@"RCTBridgeDelegate::sourceURLForBridge not implemented"
@@ -153,11 +91,6 @@ static NSDictionary *updateInitialProps(NSDictionary *initialProps, BOOL isFabri
   return nil;
 }
 
-- (NSDictionary *)prepareInitialProps
-{
-  return self.initialProps;
-}
-
 - (RCTBridge *)createBridgeWithDelegate:(id<RCTBridgeDelegate>)delegate launchOptions:(NSDictionary *)launchOptions
 {
   return [[RCTBridge alloc] initWithDelegate:delegate launchOptions:launchOptions];
@@ -167,19 +100,29 @@ static NSDictionary *updateInitialProps(NSDictionary *initialProps, BOOL isFabri
                           moduleName:(NSString *)moduleName
                            initProps:(NSDictionary *)initProps
 {
-  BOOL enableFabric = NO;
-#if RCT_NEW_ARCH_ENABLED
-  enableFabric = self.fabricEnabled;
-#endif
+  BOOL enableFabric = self.fabricEnabled;
   UIView *rootView = RCTAppSetupDefaultRootView(bridge, moduleName, initProps, enableFabric);
-#if TARGET_OS_TV
-  rootView.backgroundColor = [UIColor whiteColor];
-#else
+#if !TARGET_OS_TV
   rootView.backgroundColor = [UIColor systemBackgroundColor];
 #endif
   return rootView;
 }
 
+// TODO T173939093 - Remove _logWarnIfCreateRootViewWithBridgeIsOverridden after 0.74 is cut
+- (void)_logWarnIfCreateRootViewWithBridgeIsOverridden
+{
+  SEL selector = @selector(createRootViewWithBridge:moduleName:initProps:);
+  IMP baseClassImp = method_getImplementation(class_getInstanceMethod([RCTAppDelegate class], selector));
+  IMP currentClassImp = method_getImplementation(class_getInstanceMethod([self class], selector));
+  if (currentClassImp != baseClassImp) {
+    NSString *warnMessage =
+        @"If you are using the `createRootViewWithBridge` to customize the root view appearence,"
+         "for example to set the backgroundColor, please migrate to `customiseView` method.\n"
+         "The `createRootViewWithBridge` method is not invoked in bridgeless.";
+    RCTLogWarn(@"%@", warnMessage);
+  }
+}
+
 - (UIViewController *)createRootViewController
 {
   return [UIViewController new];
@@ -190,12 +133,13 @@ static NSDictionary *updateInitialProps(NSDictionary *initialProps, BOOL isFabri
   rootViewController.view = rootView;
 }
 
-- (BOOL)runtimeSchedulerEnabled
+- (void)customizeRootView:(RCTRootView *)rootView
 {
-  return YES;
+  // Override point for customization after application launch.
 }
 
 #pragma mark - UISceneDelegate
+
 #if !TARGET_OS_TV
 - (void)windowScene:(UIWindowScene *)windowScene
     didUpdateCoordinateSpace:(id<UICoordinateSpace>)previousCoordinateSpace
@@ -206,121 +150,122 @@ static NSDictionary *updateInitialProps(NSDictionary *initialProps, BOOL isFabri
 }
 #endif
 
-#pragma mark - RCTCxxBridgeDelegate
-- (std::unique_ptr<facebook::react::JSExecutorFactory>)jsExecutorFactoryForBridge:(RCTBridge *)bridge
+#pragma mark - New Arch Enabled settings
+
+- (BOOL)newArchEnabled
 {
-  _runtimeScheduler = std::make_shared<facebook::react::RuntimeScheduler>(RCTRuntimeExecutorFromBridge(bridge));
 #if RCT_NEW_ARCH_ENABLED
-  std::shared_ptr<facebook::react::CallInvoker> callInvoker =
-      std::make_shared<facebook::react::RuntimeSchedulerCallInvoker>(_runtimeScheduler);
-  RCTTurboModuleManager *turboModuleManager = [[RCTTurboModuleManager alloc] initWithBridge:bridge
-                                                                                   delegate:self
-                                                                                  jsInvoker:callInvoker];
-  _contextContainer->erase("RuntimeScheduler");
-  _contextContainer->insert("RuntimeScheduler", _runtimeScheduler);
-  return RCTAppSetupDefaultJsExecutorFactory(bridge, turboModuleManager, _runtimeScheduler);
+  return YES;
 #else
-  return RCTAppSetupJsExecutorFactoryForOldArch(bridge, _runtimeScheduler);
+  return NO;
 #endif
 }
 
-#if RCT_NEW_ARCH_ENABLED
-
-#pragma mark - RCTTurboModuleManagerDelegate
-
-- (Class)getModuleClassFromName:(const char *)name
+- (BOOL)turboModuleEnabled
 {
-  return RCTCoreModulesClassProvider(name);
+  return [self newArchEnabled];
 }
 
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
-                                                      jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+- (BOOL)fabricEnabled
 {
-  return nullptr;
+  return [self newArchEnabled];
 }
 
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
-                                                     initParams:
-                                                         (const facebook::react::ObjCTurboModule::InitParams &)params
+- (BOOL)bridgelessEnabled
 {
-  return nullptr;
+  return [self newArchEnabled];
 }
 
-- (id<RCTTurboModule>)getModuleInstanceFromClass:(Class)moduleClass
+- (NSURL *)bundleURL
 {
-  return RCTAppSetupDefaultModuleFromClass(moduleClass);
+  [NSException raise:@"RCTAppDelegate::bundleURL not implemented"
+              format:@"Subclasses must implement a valid getBundleURL method"];
+  return nullptr;
 }
 
-#pragma mark - RCTComponentViewFactoryComponentProvider
+#pragma mark - Bridge and Bridge Adapter properties
 
-- (NSDictionary<NSString *, Class<RCTComponentViewProtocol>> *)thirdPartyFabricComponents
+- (RCTBridge *)bridge
 {
-  return @{};
+  return self.rootViewFactory.bridge;
 }
 
-#pragma mark - New Arch Enabled settings
-
-- (BOOL)turboModuleEnabled
+- (RCTSurfacePresenterBridgeAdapter *)bridgeAdapter
 {
-  return YES;
+  return self.rootViewFactory.bridgeAdapter;
 }
 
-- (BOOL)fabricEnabled
+- (void)setBridge:(RCTBridge *)bridge
 {
-  return YES;
+  self.rootViewFactory.bridge = bridge;
 }
 
-- (BOOL)bridgelessEnabled
+- (void)setBridgeAdapter:(RCTSurfacePresenterBridgeAdapter *)bridgeAdapter
 {
-  return NO;
+  self.rootViewFactory.bridgeAdapter = bridgeAdapter;
 }
 
-#pragma mark - New Arch Utilities
+#pragma mark - RCTTurboModuleManagerDelegate
 
-- (void)unstable_registerLegacyComponents
+- (Class)getModuleClassFromName:(const char *)name
 {
-  for (NSString *legacyComponent in [RCTLegacyInteropComponents legacyInteropComponents]) {
-    [RCTLegacyViewManagerInteropComponentView supportLegacyViewManagerWithName:legacyComponent];
-  }
+#if RN_DISABLE_OSS_PLUGIN_HEADER
+  return RCTTurboModulePluginClassProvider(name);
+#else
+  return RCTCoreModulesClassProvider(name);
+#endif
 }
 
-- (void)createReactHost
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
+                                                      jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
 {
-  __weak __typeof(self) weakSelf = self;
-  _reactHost = [[RCTHost alloc] initWithBundleURL:[self getBundleURL]
-                                     hostDelegate:nil
-                       turboModuleManagerDelegate:self
-                                 jsEngineProvider:^std::shared_ptr<facebook::react::JSEngineInstance>() {
-                                   return [weakSelf createJSEngineInstance];
-                                 }];
-  [_reactHost setBundleURLProvider:^NSURL *() {
-    return [weakSelf getBundleURL];
-  }];
-  [_reactHost setContextContainerHandler:self];
-  [_reactHost start];
+  return nullptr;
 }
 
-- (std::shared_ptr<facebook::react::JSEngineInstance>)createJSEngineInstance
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
+                                                     initParams:
+                                                         (const facebook::react::ObjCTurboModule::InitParams &)params
 {
-#if USE_HERMES
-  return std::make_shared<facebook::react::RCTHermesInstance>(_reactNativeConfig, nullptr);
-#else
-  return std::make_shared<facebook::react::RCTJscInstance>();
-#endif
+  return nullptr;
 }
 
-- (void)didCreateContextContainer:(std::shared_ptr<facebook::react::ContextContainer>)contextContainer
+- (id<RCTTurboModule>)getModuleInstanceFromClass:(Class)moduleClass
 {
-  contextContainer->insert("ReactNativeConfig", _reactNativeConfig);
+  return RCTAppSetupDefaultModuleFromClass(moduleClass);
 }
 
-- (NSURL *)getBundleURL
+#pragma mark - RCTComponentViewFactoryComponentProvider
+
+- (NSDictionary<NSString *, Class<RCTComponentViewProtocol>> *)thirdPartyFabricComponents
 {
-  [NSException raise:@"RCTAppDelegate::getBundleURL not implemented"
-              format:@"Subclasses must implement a valid getBundleURL method"];
-  return nullptr;
+  return @{};
 }
 
-#endif
+- (RCTRootViewFactory *)createRCTRootViewFactory
+{
+  __weak __typeof(self) weakSelf = self;
+  RCTBundleURLBlock bundleUrlBlock = ^{
+    RCTAppDelegate *strongSelf = weakSelf;
+    return strongSelf.bundleURL;
+  };
+
+  RCTRootViewFactoryConfiguration *configuration =
+      [[RCTRootViewFactoryConfiguration alloc] initWithBundleURLBlock:bundleUrlBlock
+                                                       newArchEnabled:self.fabricEnabled
+                                                   turboModuleEnabled:self.turboModuleEnabled
+                                                    bridgelessEnabled:self.bridgelessEnabled];
+
+  configuration.createRootViewWithBridge = ^UIView *(RCTBridge *bridge, NSString *moduleName, NSDictionary *initProps)
+  {
+    return [weakSelf createRootViewWithBridge:bridge moduleName:moduleName initProps:initProps];
+  };
+
+  configuration.createBridgeWithDelegate = ^RCTBridge *(id<RCTBridgeDelegate> delegate, NSDictionary *launchOptions)
+  {
+    return [weakSelf createBridgeWithDelegate:delegate launchOptions:launchOptions];
+  };
+
+  return [[RCTRootViewFactory alloc] initWithConfiguration:configuration andTurboModuleManagerDelegate:self];
+}
 
 @end

package/Libraries/AppDelegate/RCTAppSetupUtils.h

@@ -13,42 +13,33 @@
 
 #import <memory>
 
-#ifndef RCT_USE_HERMES
-#if __has_include(<reacthermes/HermesExecutorFactory.h>)
-#define RCT_USE_HERMES 1
-#else
-#define RCT_USE_HERMES 0
-#endif
-#endif
-
-#if RCT_USE_HERMES
+#if USE_HERMES
+#if __has_include(<jsireact/HermesExecutorFactory.h>)
+#import <jsireact/HermesExecutorFactory.h>
+#elif __has_include(<reacthermes/HermesExecutorFactory.h>)
 #import <reacthermes/HermesExecutorFactory.h>
-#else
-#import <React/JSCExecutorFactory.h>
 #endif
+#else // USE_HERMES
+#import <React/JSCExecutorFactory.h>
+#endif // USE_HERMES
 
-#if RCT_NEW_ARCH_ENABLED
 #import <ReactCommon/RCTTurboModuleManager.h>
-#endif
 
 // Forward declaration to decrease compilation coupling
 namespace facebook::react {
 class RuntimeScheduler;
 }
 
-#if RCT_NEW_ARCH_ENABLED
-
 RCT_EXTERN id<RCTTurboModule> RCTAppSetupDefaultModuleFromClass(Class moduleClass);
 
 std::unique_ptr<facebook::react::JSExecutorFactory> RCTAppSetupDefaultJsExecutorFactory(
     RCTBridge *bridge,
     RCTTurboModuleManager *turboModuleManager,
     const std::shared_ptr<facebook::react::RuntimeScheduler> &runtimeScheduler);
-#else
+
 std::unique_ptr<facebook::react::JSExecutorFactory> RCTAppSetupJsExecutorFactoryForOldArch(
     RCTBridge *bridge,
     const std::shared_ptr<facebook::react::RuntimeScheduler> &runtimeScheduler);
-#endif
 
 #endif // __cplusplus
 

package/Libraries/AppDelegate/RCTAppSetupUtils.mm

@@ -11,9 +11,7 @@
 #import <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #import <react/renderer/runtimescheduler/RuntimeSchedulerBinding.h>
 
-#if RCT_NEW_ARCH_ENABLED
 // Turbo Module
-#import <React/CoreModulesPlugins.h>
 #import <React/RCTBundleAssetImageLoader.h>
 #import <React/RCTDataRequestHandler.h>
 #import <React/RCTFileRequestHandler.h>
@@ -25,38 +23,24 @@
 // Fabric
 #import <React/RCTFabricSurface.h>
 #import <React/RCTSurfaceHostingProxyRootView.h>
-#endif
 
-#ifdef FB_SONARKIT_ENABLED
-#import <FlipperKit/FlipperClient.h>
-#import <FlipperKitLayoutPlugin/FlipperKitLayoutPlugin.h>
-#import <FlipperKitNetworkPlugin/FlipperKitNetworkPlugin.h>
-#import <FlipperKitReactPlugin/FlipperKitReactPlugin.h>
-#import <FlipperKitUserDefaultsPlugin/FKUserDefaultsPlugin.h>
-#import <SKIOSNetworkPlugin/SKIOSNetworkAdapter.h>
+// jsinspector-modern
+#import <jsinspector-modern/InspectorFlags.h>
 
-static void InitializeFlipper(UIApplication *application)
-{
-  FlipperClient *client = [FlipperClient sharedClient];
-  SKDescriptorMapper *layoutDescriptorMapper = [[SKDescriptorMapper alloc] initWithDefaults];
-  [client addPlugin:[[FlipperKitLayoutPlugin alloc] initWithRootNode:application
-                                                withDescriptorMapper:layoutDescriptorMapper]];
-  [client addPlugin:[[FKUserDefaultsPlugin alloc] initWithSuiteName:nil]];
-  [client addPlugin:[FlipperKitReactPlugin new]];
-  [client addPlugin:[[FlipperKitNetworkPlugin alloc] initWithNetworkAdapter:[SKIOSNetworkAdapter new]]];
-  [client start];
-}
+#if __has_include(<React-Codegen/RCTModulesConformingToProtocolsProvider.h>)
+#define USE_OSS_CODEGEN 1
+#import <React-Codegen/RCTModulesConformingToProtocolsProvider.h>
+#elif __has_include(<React_Codegen/RCTModulesConformingToProtocolsProvider.h>)
+#define USE_OSS_CODEGEN 1
+#import <React_Codegen/RCTModulesConformingToProtocolsProvider.h>
+#else
+// Meta internal system do not generate the RCTModulesConformingToProtocolsProvider.h file
+#define USE_OSS_CODEGEN 0
 #endif
 
 void RCTAppSetupPrepareApp(UIApplication *application, BOOL turboModuleEnabled)
 {
-#ifdef FB_SONARKIT_ENABLED
-  InitializeFlipper(application);
-#endif
-
-#if RCT_NEW_ARCH_ENABLED
   RCTEnableTurboModule(turboModuleEnabled);
-#endif
 
 #if DEBUG
   // Disable idle timer in dev builds to avoid putting application in background and complicating
@@ -68,37 +52,70 @@ void RCTAppSetupPrepareApp(UIApplication *application, BOOL turboModuleEnabled)
 UIView *
 RCTAppSetupDefaultRootView(RCTBridge *bridge, NSString *moduleName, NSDictionary *initialProperties, BOOL fabricEnabled)
 {
-#if RCT_NEW_ARCH_ENABLED
   if (fabricEnabled) {
     id<RCTSurfaceProtocol> surface = [[RCTFabricSurface alloc] initWithBridge:bridge
                                                                    moduleName:moduleName
                                                             initialProperties:initialProperties];
     return [[RCTSurfaceHostingProxyRootView alloc] initWithSurface:surface];
   }
-#endif
   return [[RCTRootView alloc] initWithBridge:bridge moduleName:moduleName initialProperties:initialProperties];
 }
 
-#if RCT_NEW_ARCH_ENABLED
 id<RCTTurboModule> RCTAppSetupDefaultModuleFromClass(Class moduleClass)
 {
+  // private block used to filter out modules depending on protocol conformance
+  NSArray * (^extractModuleConformingToProtocol)(RCTModuleRegistry *, Protocol *) =
+      ^NSArray *(RCTModuleRegistry *moduleRegistry, Protocol *protocol)
+  {
+    NSArray<NSString *> *classNames = @[];
+
+#if USE_OSS_CODEGEN
+    if (protocol == @protocol(RCTImageURLLoader)) {
+      classNames = [RCTModulesConformingToProtocolsProvider imageURLLoaderClassNames];
+    } else if (protocol == @protocol(RCTImageDataDecoder)) {
+      classNames = [RCTModulesConformingToProtocolsProvider imageDataDecoderClassNames];
+    } else if (protocol == @protocol(RCTURLRequestHandler)) {
+      classNames = [RCTModulesConformingToProtocolsProvider URLRequestHandlerClassNames];
+    }
+#endif
+
+    NSMutableArray *modules = [NSMutableArray new];
+
+    for (NSString *className in classNames) {
+      const char *cModuleName = [className cStringUsingEncoding:NSUTF8StringEncoding];
+      id moduleFromLibrary = [moduleRegistry moduleForName:cModuleName];
+      if (![moduleFromLibrary conformsToProtocol:protocol]) {
+        continue;
+      }
+      [modules addObject:moduleFromLibrary];
+    }
+    return modules;
+  };
+
   // Set up the default RCTImageLoader and RCTNetworking modules.
   if (moduleClass == RCTImageLoader.class) {
     return [[moduleClass alloc] initWithRedirectDelegate:nil
         loadersProvider:^NSArray<id<RCTImageURLLoader>> *(RCTModuleRegistry *moduleRegistry) {
-          return @[ [RCTBundleAssetImageLoader new] ];
+          NSArray *imageURLLoaderModules =
+              extractModuleConformingToProtocol(moduleRegistry, @protocol(RCTImageURLLoader));
+
+          return [@[ [RCTBundleAssetImageLoader new] ] arrayByAddingObjectsFromArray:imageURLLoaderModules];
         }
         decodersProvider:^NSArray<id<RCTImageDataDecoder>> *(RCTModuleRegistry *moduleRegistry) {
-          return @[ [RCTGIFImageDecoder new] ];
+          NSArray *imageDataDecoder = extractModuleConformingToProtocol(moduleRegistry, @protocol(RCTImageDataDecoder));
+          return [@[ [RCTGIFImageDecoder new] ] arrayByAddingObjectsFromArray:imageDataDecoder];
         }];
   } else if (moduleClass == RCTNetworking.class) {
     return [[moduleClass alloc]
         initWithHandlersProvider:^NSArray<id<RCTURLRequestHandler>> *(RCTModuleRegistry *moduleRegistry) {
-          return @[
+          NSArray *URLRequestHandlerModules =
+              extractModuleConformingToProtocol(moduleRegistry, @protocol(RCTURLRequestHandler));
+          return [@[
             [RCTHTTPRequestHandler new],
             [RCTDataRequestHandler new],
             [RCTFileRequestHandler new],
-          ];
+            [moduleRegistry moduleForName:"BlobModule"],
+          ] arrayByAddingObjectsFromArray:URLRequestHandlerModules];
         }];
   }
   // No custom initializer here.
@@ -123,11 +140,11 @@ std::unique_ptr<facebook::react::JSExecutorFactory> RCTAppSetupDefaultJsExecutor
   [turboModuleManager moduleForName:"RCTDevMenu"];
 #endif // end RCT_DEV
 
-#if RCT_USE_HERMES
+#if USE_HERMES
   return std::make_unique<facebook::react::HermesExecutorFactory>(
 #else
   return std::make_unique<facebook::react::JSCExecutorFactory>(
-#endif // end RCT_USE_HERMES
+#endif // USE_HERMES
       facebook::react::RCTJSIExecutorRuntimeInstaller(
           [turboModuleManager, bridge, runtimeScheduler](facebook::jsi::Runtime &runtime) {
             if (!bridge || !turboModuleManager) {
@@ -140,17 +157,15 @@ std::unique_ptr<facebook::react::JSExecutorFactory> RCTAppSetupDefaultJsExecutor
           }));
 }
 
-#else // else !RCT_NEW_ARCH_ENABLED
-
 std::unique_ptr<facebook::react::JSExecutorFactory> RCTAppSetupJsExecutorFactoryForOldArch(
     RCTBridge *bridge,
     const std::shared_ptr<facebook::react::RuntimeScheduler> &runtimeScheduler)
 {
-#if RCT_USE_HERMES
+#if USE_HERMES
   return std::make_unique<facebook::react::HermesExecutorFactory>(
 #else
   return std::make_unique<facebook::react::JSCExecutorFactory>(
-#endif // end RCT_USE_HERMES
+#endif // USE_HERMES
       facebook::react::RCTJSIExecutorRuntimeInstaller([bridge, runtimeScheduler](facebook::jsi::Runtime &runtime) {
         if (!bridge) {
           return;
@@ -160,4 +175,3 @@ std::unique_ptr<facebook::react::JSExecutorFactory> RCTAppSetupJsExecutorFactory
         }
       }));
 }
-#endif // end RCT_NEW_ARCH_ENABLED