fix(react-native-host): add support for bridgeless mode

.changeset/old-bottles-clean.md

@@ -0,0 +1,12 @@
+---
+"@rnx-kit/react-native-host": patch
+---
+
+Added support for Bridgeless Mode
+
+Bridgeless mode can now be enabled by setting the environment variable
+`USE_BRIDGELESS=1`. This build flag will enable bridgeless bits, but you can
+still disable it at runtime by implementing `RNXHostConfig.isBridgelessEnabled`.
+
+See the full announcement here:
+https://reactnative.dev/blog/2023/12/06/0.73-debugging-improvements-stable-symlinks#new-architecture-updates

packages/react-native-host/ReactNativeHost.podspec

@@ -16,10 +16,12 @@ preprocessor_definitions = [
   'FOLLY_MOBILE=1',
   'FOLLY_NO_CONFIG=1',
   'FOLLY_USE_LIBCPP=1',
+  "USE_HERMES=#{ENV['USE_HERMES'] || '0'}",
 ]
 if new_arch_enabled
   preprocessor_definitions << 'RCT_NEW_ARCH_ENABLED=1'
   preprocessor_definitions << 'USE_FABRIC=1'
+  preprocessor_definitions << 'USE_BRIDGELESS=1' if ENV['USE_BRIDGELESS'] == '1'
 end
 
 Pod::Spec.new do |s|

packages/react-native-host/cocoa/RNXBridgelessHeaders.h

@@ -0,0 +1,40 @@
+#if USE_BRIDGELESS
+
+#import <React/RCTSurfacePresenterBridgeAdapter.h>
+#import <ReactCommon/RCTHost+Internal.h>
+#import <ReactCommon/RCTHost.h>
+
+#if USE_HERMES
+#import <ReactCommon/RCTHermesInstance.h>
+#else
+#import <ReactCommon/RCTJscInstance.h>
+#endif  // USE_HERMES
+
+#import <react/config/ReactNativeConfig.h>
+
+#if __has_include(<react/runtime/JSEngineInstance.h>)
+using SharedJSRuntimeFactory = std::shared_ptr<facebook::react::JSEngineInstance>;
+#else
+using SharedJSRuntimeFactory = std::shared_ptr<facebook::react::JSRuntimeFactory>;
+#endif  // __has_include(<react/runtime/JSEngineInstance.h>)
+
+#elif USE_FABRIC
+
+#import <React/RCTSurfacePresenterBridgeAdapter.h>
+#import <react/config/ReactNativeConfig.h>
+
+@class RCTHost;
+
+#else
+
+@class RCTHost;
+@class RCTSurfacePresenterBridgeAdapter;
+
+namespace facebook::react
+{
+    class EmptyReactNativeConfig
+    {
+    };
+}  // namespace facebook::react
+
+#endif  // USE_BRIDGELESS

packages/react-native-host/cocoa/RNXFabricAdapter.h

@@ -1,9 +1,11 @@
 #import <Foundation/Foundation.h>
 
 @class RCTBridge;
+@class RCTSurfacePresenterBridgeAdapter;
 
 NS_ASSUME_NONNULL_BEGIN
 
-NSObject *RNXInstallSurfacePresenterBridgeAdapter(RCTBridge *bridge);
+RCTSurfacePresenterBridgeAdapter *_Nullable RNXInstallSurfacePresenterBridgeAdapter(
+    RCTBridge *bridge);
 
 NS_ASSUME_NONNULL_END

packages/react-native-host/cocoa/RNXFabricAdapter.mm

@@ -1,6 +1,6 @@
 #import "RNXFabricAdapter.h"
 
-#ifdef USE_FABRIC
+#if USE_FABRIC && !USE_BRIDGELESS
 #include "FollyConfig.h"
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wcomma"
@@ -9,11 +9,11 @@
 #import <React/RCTSurfacePresenterBridgeAdapter.h>
 #import <react/config/ReactNativeConfig.h>
 #pragma clang diagnostic pop
-#endif  // USE_FABRIC
+#endif  // USE_FABRIC && !USE_BRIDGELESS
 
-NSObject *RNXInstallSurfacePresenterBridgeAdapter(RCTBridge *bridge)
+RCTSurfacePresenterBridgeAdapter *RNXInstallSurfacePresenterBridgeAdapter(RCTBridge *bridge)
 {
-#ifdef USE_FABRIC
+#if USE_FABRIC && !USE_BRIDGELESS
     auto contextContainer = std::make_shared<facebook::react::ContextContainer const>();
     auto reactNativeConfig = std::make_shared<facebook::react::EmptyReactNativeConfig const>();
     contextContainer->insert("ReactNativeConfig", reactNativeConfig);
@@ -24,5 +24,5 @@
     return bridgeAdapter;
 #else
     return nil;
-#endif  // USE_FABRIC
+#endif  // USE_FABRIC && !USE_BRIDGELESS
 }

packages/react-native-host/cocoa/RNXHostConfig.h

@@ -10,6 +10,9 @@ NS_ASSUME_NONNULL_BEGIN
 
 @optional
 
+/// Returns whether the new initialization layer is enabled.
+@property (nonatomic, readonly) BOOL isBridgelessEnabled;
+
 /// Returns whether the loading view should be visible while loading JavaScript.
 @property (nonatomic, readonly) BOOL isDevLoadingViewEnabled;
 

packages/react-native-host/cocoa/ReactNativeHost+Private.h

@@ -0,0 +1,16 @@
+#import "ReactNativeHost.h"
+
+@class RCTSurfacePresenter;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ReactNativeHost (Private)
+
+/// Returns the current ``RCTSurfacePresenter`` instance.
+///
+/// - Note: Returns `nil` if New Architecture is not enabled.
+@property (nonatomic, readonly, nullable) RCTSurfacePresenter *surfacePresenter;
+
+@end
+
+NS_ASSUME_NONNULL_END

packages/react-native-host/cocoa/ReactNativeHost+View.mm

@@ -1,4 +1,4 @@
-#import "ReactNativeHost.h"
+#import "ReactNativeHost+Private.h"
 
 #ifdef USE_FABRIC
 #if __has_include(<React/RCTFabricSurfaceHostingProxyRootView.h>)
@@ -41,9 +41,10 @@ - (RNXView *)viewWithModuleName:(NSString *)moduleName
                                                              moduleName:moduleName
                                                       initialProperties:initialProperties];
 #else
-    RCTFabricSurface *surface = [[RCTFabricSurface alloc] initWithBridge:self.bridge
-                                                              moduleName:moduleName
-                                                       initialProperties:initialProperties];
+    RCTFabricSurface *surface =
+        [[RCTFabricSurface alloc] initWithSurfacePresenter:self.surfacePresenter
+                                                moduleName:moduleName
+                                         initialProperties:initialProperties];
     return [[RCTSurfaceHostingProxyRootView alloc] initWithSurface:surface];
 #endif  // __has_include(<React/RCTFabricSurfaceHostingProxyRootView.h>)
 #else

packages/react-native-host/cocoa/ReactNativeHost.h

@@ -17,7 +17,7 @@ NS_ASSUME_NONNULL_BEGIN
 /// Hosts a React Native instance.
 @interface ReactNativeHost : NSObject <RCTBridgeDelegate>
 
-/// Returns the current `RCTBridge` instance.
+/// Returns the current ``RCTBridge`` instance.
 ///
 /// - Note: This is not forwards compatible and will be removed in the future.
 @property (nonatomic, readonly, nullable) RCTBridge *bridge;

packages/react-native-host/cocoa/ReactNativeHost.mm

@@ -12,21 +12,32 @@
 #import <React/RCTDevLoadingViewSetEnabled.h>
 #import <React/RCTUtils.h>
 
+#import "RNXBridgelessHeaders.h"
 #import "RNXFabricAdapter.h"
 #import "RNXHostConfig.h"
 #import "RNXHostReleaser.h"
 #import "RNXTurboModuleAdapter.h"
 
+@class RCTSurfacePresenter;
+
+using ReactNativeConfig = facebook::react::EmptyReactNativeConfig const;
+
+#if USE_BRIDGELESS
+@interface ReactNativeHost () <RCTContextContainerHandling>
+#else
 @interface ReactNativeHost () <RCTCxxBridgeDelegate>
+#endif  // USE_BRIDGELESS
 @end
 
 @implementation ReactNativeHost {
     __weak id<RNXHostConfig> _config;
     RNXTurboModuleAdapter *_turboModuleAdapter;
-    NSObject *_surfacePresenterBridgeAdapter;
+    RCTSurfacePresenterBridgeAdapter *_surfacePresenterBridgeAdapter;
     RCTBridge *_bridge;
+    RCTHost *_reactHost;
     NSLock *_isShuttingDown;
     RNXHostReleaser *_hostReleaser;
+    std::shared_ptr<ReactNativeConfig> _reactNativeConfig;
 }
 
 - (instancetype)initWithConfig:(id<RNXHostConfig>)config
@@ -53,23 +64,24 @@ - (instancetype)initWithConfig:(id<RNXHostConfig>)config
         }
 
         _config = config;
-#if USE_FABRIC
-        _turboModuleAdapter = [[RNXTurboModuleAdapter alloc] init];
-#endif
+        [self enableTurboModule];
         _isShuttingDown = [[NSLock alloc] init];
 
         if ([config respondsToSelector:@selector(shouldReleaseBridgeWhenBackgrounded)] &&
             [config shouldReleaseBridgeWhenBackgrounded]) {
             _hostReleaser = [[RNXHostReleaser alloc] initWithHost:self];
         }
 
-        (void)self.bridge;  // Initialize the bridge now
+        [self initializeReactHost];
     }
     return self;
 }
 
 - (RCTBridge *)bridge
 {
+#if USE_BRIDGELESS
+    return nil;
+#else
     if (![_isShuttingDown tryLock]) {
         NSAssert(NO, @"Tried to access the bridge while shutting down");
         return nil;
@@ -86,6 +98,18 @@ - (RCTBridge *)bridge
     } @finally {
         [_isShuttingDown unlock];
     }
+#endif  // USE_BRIDGELESS
+}
+
+- (RCTSurfacePresenter *)surfacePresenter
+{
+#if USE_BRIDGELESS
+    return [_reactHost getSurfacePresenter];
+#elif USE_FABRIC
+    return [_surfacePresenterBridgeAdapter surfacePresenter];
+#else
+    return nil;
+#endif
 }
 
 - (void)shutdown
@@ -106,7 +130,7 @@ - (void)usingModule:(Class)moduleClass block:(void (^)(id<RCTBridgeModule> _Null
         [moduleClass respondsToSelector:@selector(requiresMainQueueSetup)] &&
         [moduleClass requiresMainQueueSetup];
     if (requiresMainQueueSetup && !RCTIsMainQueue()) {
-        __weak id weakSelf = self;
+        __weak __typeof(self) weakSelf = self;
         dispatch_async(dispatch_get_main_queue(), ^{
           [weakSelf usingModule:moduleClass block:block];
         });
@@ -139,6 +163,18 @@ - (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
                : @[];
 }
 
+#if USE_BRIDGELESS
+
+// MARK: - RCTContextContainerHandling details
+
+- (void)didCreateContextContainer:
+    (std::shared_ptr<facebook::react::ContextContainer>)contextContainer
+{
+    contextContainer->insert("ReactNativeConfig", _reactNativeConfig);
+}
+
+#else  // USE_BRIDGELESS
+
 // MARK: - RCTCxxBridgeDelegate details
 
 - (std::unique_ptr<facebook::react::JSExecutorFactory>)jsExecutorFactoryForBridge:
@@ -153,6 +189,61 @@ - (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
 #endif  // USE_FABRIC
 }
 
+#endif  // USE_BRIDGELESS
+
 // MARK: - Private
 
+- (void)enableTurboModule
+{
+#if USE_FABRIC
+    _turboModuleAdapter = [[RNXTurboModuleAdapter alloc] init];
+    RCTEnableTurboModule(true);
+#endif
+}
+
+- (void)initializeReactHost
+{
+#if USE_BRIDGELESS
+    // Bridgeless mode is enabled if it was turned on with a build flag, unless
+    // `isBridgelessEnabled` is explicitly implemented and returns false.
+    if ([_config respondsToSelector:@selector(isBridgelessEnabled)] &&
+        ![_config isBridgelessEnabled]) {
+        (void)self.bridge;  // Initialize the bridge now
+        return;
+    }
+
+    RCTSetUseNativeViewConfigsInBridgelessMode(YES);
+    RCTEnableTurboModuleInterop(YES);
+    RCTEnableTurboModuleInteropBridgeProxy(YES);
+
+    _reactNativeConfig = std::make_shared<ReactNativeConfig>();
+    std::weak_ptr<ReactNativeConfig> reactNativeConfig{_reactNativeConfig};
+
+    SharedJSRuntimeFactory (^jsEngineProvider)() = ^SharedJSRuntimeFactory {
+#if USE_HERMES
+      auto config = reactNativeConfig.lock();
+      NSAssert(config, @"Expected nonnull ReactNativeConfig instance");
+      return std::make_shared<facebook::react::RCTHermesInstance>(config, nullptr);
+#else
+      return std::make_shared<facebook::react::RCTJscInstance>();
+#endif  // USE_HERMES
+    };
+
+    _reactHost = [[RCTHost alloc] initWithBundleURL:[self sourceURLForBridge:nil]
+                                       hostDelegate:nil
+                         turboModuleManagerDelegate:_turboModuleAdapter
+                                   jsEngineProvider:jsEngineProvider];
+
+    __weak __typeof(self) weakSelf = self;
+    [_reactHost setBundleURLProvider:^NSURL *() {
+      return [weakSelf sourceURLForBridge:nil];
+    }];
+
+    [_reactHost setContextContainerHandler:self];
+    [_reactHost start];
+#else
+    (void)self.bridge;
+#endif  // USE_BRIDGELESS
+}
+
 @end