@rnx-kit/react-native-host 0.4.1 → 0.4.3

package/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|

package/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

package/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

package/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 @@ NSObject *RNXInstallSurfacePresenterBridgeAdapter(RCTBridge *bridge)
     return bridgeAdapter;
 #else
     return nil;
-#endif  // USE_FABRIC
+#endif  // USE_FABRIC && !USE_BRIDGELESS
 }

package/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;
 

package/cocoa/RNXTurboModuleAdapter.mm

@@ -67,13 +67,13 @@
 
 // MARK: - RCTTurboModuleManagerDelegate details
 
-- (Class)getModuleClassFromName:(const char *)name
+- (Class)getModuleClassFromName:(char const *)name
 {
     return RCTCoreModulesClassProvider(name);
 }
 
 - (std::shared_ptr<facebook::react::TurboModule>)
-    getTurboModule:(const std::string &)name
+    getTurboModule:(std::string const &)name
          jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
 {
     return nullptr;

package/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

package/cocoa/ReactNativeHost+View.mm

@@ -1,4 +1,4 @@
-#import "ReactNativeHost.h"
+#import "ReactNativeHost+Private.h"
 
 #ifdef USE_FABRIC
 #if __has_include(<React/RCTFabricSurfaceHostingProxyRootView.h>)
@@ -7,6 +7,7 @@
 #import <React/RCTFabricSurface.h>
 #import <React/RCTSurfaceHostingProxyRootView.h>
 #endif  // __has_include(<React/RCTFabricSurfaceHostingProxyRootView.h>)
+static NSString *const kReactConcurrentRoot = @"concurrentRoot";
 #else
 #import <React/RCTRootView.h>
 #endif  // USE_FABRIC
@@ -36,14 +37,27 @@
               initialProperties:(NSDictionary *)initialProperties;
 {
 #ifdef USE_FABRIC
+    // Having `concurrentRoot` disabled when Fabric is enabled is not recommended:
+    // https://github.com/facebook/react-native/commit/7eaabfb174b14a30c30c7017195e8110348e5f44
+    // As of 0.74, it won't be possible to opt-out:
+    // https://github.com/facebook/react-native/commit/30d186c3683228d4fb7a42f804eb2fdfa7c8ac03
+    NSMutableDictionary *initialProps =
+        initialProperties == nil
+            ? [NSMutableDictionary dictionaryWithObjectsAndKeys:@YES, kReactConcurrentRoot, nil]
+            : [initialProperties mutableCopy];
+    if (initialProps[kReactConcurrentRoot] == nil) {
+        initialProps[kReactConcurrentRoot] = @YES;
+    }
+
 #if __has_include(<React/RCTFabricSurfaceHostingProxyRootView.h>)
     return [[RCTFabricSurfaceHostingProxyRootView alloc] initWithBridge:self.bridge
                                                              moduleName:moduleName
-                                                      initialProperties:initialProperties];
+                                                      initialProperties:initialProps];
 #else
-    RCTFabricSurface *surface = [[RCTFabricSurface alloc] initWithBridge:self.bridge
-                                                              moduleName:moduleName
-                                                       initialProperties:initialProperties];
+    RCTFabricSurface *surface =
+        [[RCTFabricSurface alloc] initWithSurfacePresenter:self.surfacePresenter
+                                                moduleName:moduleName
+                                         initialProperties:initialProps];
     return [[RCTSurfaceHostingProxyRootView alloc] initWithSurface:surface];
 #endif  // __has_include(<React/RCTFabricSurfaceHostingProxyRootView.h>)
 #else

package/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;

package/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,9 +64,7 @@
         }
 
         _config = config;
-#if USE_FABRIC
-        _turboModuleAdapter = [[RNXTurboModuleAdapter alloc] init];
-#endif
+        [self enableTurboModule];
         _isShuttingDown = [[NSLock alloc] init];
 
         if ([config respondsToSelector:@selector(shouldReleaseBridgeWhenBackgrounded)] &&
@@ -63,13 +72,16 @@
             _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 @@
     } @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
@@ -102,11 +126,11 @@
 
 - (void)usingModule:(Class)moduleClass block:(void (^)(id<RCTBridgeModule> _Nullable))block
 {
-    const BOOL requiresMainQueueSetup =
+    BOOL const requiresMainQueueSetup =
         [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 @@
                : @[];
 }
 
+#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 @@
 #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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rnx-kit/react-native-host",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Simplify React Native initialization",
   "homepage": "https://github.com/microsoft/rnx-kit/tree/main/packages/react-native-host#readme",
   "license": "MIT",