react-native-tvos 0.81.4-0 → 0.82.0-0

package/React/Fabric/Mounting/ComponentViews/VirtualView/RCTVirtualViewComponentView.mm

@@ -21,23 +21,13 @@
 #import <react/renderer/components/virtualview/VirtualViewComponentDescriptor.h>
 #import <react/renderer/components/virtualview/VirtualViewShadowNode.h>
 
+#import "../VirtualViewExperimental/RCTVirtualViewMode.h"
+#import "../VirtualViewExperimental/RCTVirtualViewRenderState.h"
 #import "RCTFabricComponentsPlugins.h"
 
 using namespace facebook;
 using namespace facebook::react;
 
-typedef NS_ENUM(NSInteger, RCTVirtualViewMode) {
-  RCTVirtualViewModeVisible = 0,
-  RCTVirtualViewModePrerender = 1,
-  RCTVirtualViewModeHidden = 2,
-};
-
-typedef NS_ENUM(NSInteger, RCTVirtualViewRenderState) {
-  RCTVirtualViewRenderStateUnknown = 0,
-  RCTVirtualViewRenderStateRendered = 1,
-  RCTVirtualViewRenderStateNone = 2,
-};
-
 /**
  * Checks whether one CGRect overlaps with another CGRect.
  *
@@ -72,8 +62,8 @@ static BOOL CGRectOverlaps(CGRect rect1, CGRect rect2)
 
 @implementation RCTVirtualViewComponentView {
   RCTScrollViewComponentView *_lastParentScrollViewComponentView;
-  std::optional<enum RCTVirtualViewMode> _mode;
-  enum RCTVirtualViewRenderState _renderState;
+  std::optional<RCTVirtualViewMode> _mode;
+  RCTVirtualViewRenderState _renderState;
   std::optional<CGRect> _targetRect;
 }
 
@@ -234,27 +224,40 @@ static BOOL sIsAccessibilityUsed = NO;
     _targetRect = targetRect;
   }
 
-  enum RCTVirtualViewMode newMode;
+  RCTVirtualViewMode newMode;
   CGRect thresholdRect = CGRectMake(
       scrollView.contentOffset.x,
       scrollView.contentOffset.y,
       scrollView.frame.size.width,
       scrollView.frame.size.height);
+  const CGFloat visibleWidth = thresholdRect.size.width;
+  const CGFloat visibleHeight = thresholdRect.size.height;
+
   if (CGRectOverlaps(targetRect, thresholdRect)) {
     newMode = RCTVirtualViewModeVisible;
   } else {
     auto prerender = false;
     const CGFloat prerenderRatio = ReactNativeFeatureFlags::virtualViewPrerenderRatio();
     if (prerenderRatio > 0) {
-      thresholdRect = CGRectInset(
-          thresholdRect, -thresholdRect.size.width * prerenderRatio, -thresholdRect.size.height * prerenderRatio);
+      thresholdRect = CGRectInset(thresholdRect, -visibleWidth * prerenderRatio, -visibleHeight * prerenderRatio);
       prerender = CGRectOverlaps(targetRect, thresholdRect);
     }
     if (prerender) {
       newMode = RCTVirtualViewModePrerender;
     } else {
-      newMode = RCTVirtualViewModeHidden;
-      thresholdRect = CGRectZero;
+      const CGFloat hysteresisRatio = ReactNativeFeatureFlags::virtualViewHysteresisRatio();
+      if (_mode.has_value() && hysteresisRatio > 0) {
+        thresholdRect = CGRectInset(thresholdRect, -visibleWidth * hysteresisRatio, -visibleHeight * hysteresisRatio);
+        if (CGRectOverlaps(targetRect, thresholdRect)) {
+          newMode = _mode.value();
+        } else {
+          newMode = RCTVirtualViewModeHidden;
+          thresholdRect = CGRectZero;
+        }
+      } else {
+        newMode = RCTVirtualViewModeHidden;
+        thresholdRect = CGRectZero;
+      }
     }
   }
 
@@ -278,7 +281,7 @@ static BOOL sIsAccessibilityUsed = NO;
            .height = thresholdRect.size.height},
   };
 
-  const std::optional<enum RCTVirtualViewMode> oldMode = _mode;
+  const std::optional<RCTVirtualViewMode> oldMode = _mode;
   _mode = newMode;
 
   switch (newMode) {

package/React/Fabric/Mounting/ComponentViews/VirtualViewExperimental/RCTVirtualViewExperimentalComponentView.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTViewComponentView.h>
+#import <React/RCTVirtualViewProtocol.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTVirtualViewExperimentalComponentView : RCTViewComponentView <RCTVirtualViewProtocol>
+
++ (instancetype)new NS_UNAVAILABLE;
+- (instancetype)init NS_UNAVAILABLE;
+- (instancetype)initWithCoder:(NSCoder *)coder NS_UNAVAILABLE;
+
+- (instancetype)initWithFrame:(CGRect)frame NS_DESIGNATED_INITIALIZER;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/React/Fabric/Mounting/ComponentViews/VirtualViewExperimental/RCTVirtualViewExperimentalComponentView.mm

@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTVirtualViewExperimentalComponentView.h"
+
+#import <React/RCTAssert.h>
+#import <React/RCTConversions.h>
+#import <React/RCTScrollViewComponentView.h>
+#import <React/RCTScrollableProtocol.h>
+#import <React/RCTVirtualViewContainerProtocol.h>
+#import <React/RCTVirtualViewContainerState.h>
+#import <React/UIView+React.h>
+#import <jsi/jsi.h>
+
+#import <react/featureflags/ReactNativeFeatureFlags.h>
+#import <react/renderer/components/FBReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/FBReactNativeSpec/EventEmitters.h>
+#import <react/renderer/components/FBReactNativeSpec/Props.h>
+#import <react/renderer/components/virtualviewexperimental/VirtualViewExperimentalComponentDescriptor.h>
+#import <react/renderer/components/virtualviewexperimental/VirtualViewExperimentalShadowNode.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import "RCTVirtualViewMode.h"
+#import "RCTVirtualViewRenderState.h"
+
+using namespace facebook;
+using namespace facebook::react;
+
+@interface RCTVirtualViewExperimentalComponentView () {
+  NSString *_virtualViewID;
+}
+
+@end
+
+@implementation RCTVirtualViewExperimentalComponentView {
+  id<RCTVirtualViewContainerProtocol> _parentVirtualViewContainer;
+  std::optional<RCTVirtualViewMode> _mode;
+  RCTVirtualViewRenderState _renderState;
+  std::optional<CGRect> _targetRect;
+  NSString *_nativeId;
+  BOOL _didLayout;
+}
+
+#pragma mark - Public API
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if ((self = [super initWithFrame:frame]) != nil) {
+    _props = VirtualViewExperimentalShadowNode::defaultSharedProps();
+    _renderState = RCTVirtualViewRenderStateUnknown;
+    _virtualViewID = [[NSUUID UUID] UUIDString];
+    _didLayout = NO;
+  }
+
+  return self;
+}
+
+- (void)updateProps:(const Props::Shared &)props oldProps:(const Props::Shared &)oldProps
+{
+  const auto &newViewProps = static_cast<const VirtualViewExperimentalProps &>(*props);
+
+  if (!_mode.has_value()) {
+    _mode = newViewProps.initialHidden ? RCTVirtualViewModeHidden : RCTVirtualViewModeVisible;
+    if (ReactNativeFeatureFlags::hideOffscreenVirtualViewsOnIOS()) {
+      self.hidden = newViewProps.initialHidden && !sIsAccessibilityUsed;
+    }
+  }
+
+  // If disabled, `_renderState` will always be `RCTVirtualViewRenderStateUnknown`.
+  if (ReactNativeFeatureFlags::enableVirtualViewRenderState()) {
+    switch (newViewProps.renderState) {
+      case 1:
+        _renderState = RCTVirtualViewRenderStateRendered;
+        break;
+      case 2:
+        _renderState = RCTVirtualViewRenderStateNone;
+        break;
+      default:
+        _renderState = RCTVirtualViewRenderStateUnknown;
+        break;
+    }
+  }
+
+  const auto &newBaseViewProps = static_cast<const ViewProps &>(*props);
+  const auto nativeId = RCTNSStringFromStringNilIfEmpty(newBaseViewProps.nativeId);
+  _virtualViewID = nativeId == nil ? _virtualViewID : nativeId;
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+/**
+ * Static flag that tracks whether accessibility services are being used.
+ * When accessibility is detected, virtual views will remain visible even when
+ * they would normally be hidden when off-screen, ensuring that accessibility
+ * features will work correctly.
+ */
+static BOOL sIsAccessibilityUsed = NO;
+
+- (NSInteger)accessibilityElementCount
+{
+  // From empirical testing, method `accessibilityElementCount` is called lazily only
+  // when accessibility is used.
+  [self _unhideIfNeeded];
+  return [super accessibilityElementCount];
+}
+
+- (NSArray<id<UIFocusItem>> *)focusItemsInRect:(CGRect)rect
+{
+  // From empirical testing, method `focusItemsInRect:` is called lazily only
+  // when keyboard navigation is used.
+  [self _unhideIfNeeded];
+  return [super focusItemsInRect:rect];
+}
+
+- (NSString *)virtualViewID
+{
+  // Return a unique identifier for this virtual view
+  // Using the tag as a unique identifier since it's already unique per view
+  return _virtualViewID;
+}
+
+- (void)prepareForRecycle
+{
+  [super prepareForRecycle];
+
+  [[_parentVirtualViewContainer virtualViewContainerState] remove:self];
+  self.hidden = NO;
+  _didLayout = NO;
+  _mode.reset();
+  _targetRect.reset();
+  _parentVirtualViewContainer = nil;
+}
+
+// Handles case when sibling changes size.
+// TODO(T202601695): This doesn't yet handle the case of elements in the ScrollView outside a VirtualColumn changing
+// size.
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics
+{
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:_layoutMetrics];
+  _didLayout = YES;
+  [self updateState];
+}
+
+- (void)updateState
+{
+  [[_parentVirtualViewContainer virtualViewContainerState] onChange:self];
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  // here we will set the pointer to the virtualView container
+  // and if there was a layout, update
+
+  _parentVirtualViewContainer = [self _getParentVirtualViewContainer];
+  if (_parentVirtualViewContainer != nil && self.window != nil && _didLayout) {
+    [self updateState];
+  }
+}
+
+- (CGRect)containerRelativeRect:(UIView *)scrollView
+{
+  // Return the view's position relative to its container (the scroll view)
+  return [self convertRect:self.bounds toView:scrollView];
+}
+
+- (void)onModeChange:(RCTVirtualViewMode)newMode targetRect:(CGRect)targetRect thresholdRect:(CGRect)thresholdRect
+{
+  if (_mode.has_value() && newMode == _mode.value()) {
+    return;
+  }
+
+  // NOTE: Make sure to keep these props in sync with dispatchSyncModeChange below where we have to explicitly copy
+  // all props.
+  VirtualViewEventEmitter::OnModeChange event = {
+      .mode = (int)newMode,
+      .targetRect =
+          {.x = targetRect.origin.x,
+           .y = targetRect.origin.y,
+           .width = targetRect.size.width,
+           .height = targetRect.size.height},
+      .thresholdRect =
+          {.x = thresholdRect.origin.x,
+           .y = thresholdRect.origin.y,
+           .width = thresholdRect.size.width,
+           .height = thresholdRect.size.height},
+  };
+
+  const std::optional<RCTVirtualViewMode> oldMode = _mode;
+  _mode = newMode;
+
+  switch (newMode) {
+    case RCTVirtualViewModeVisible:
+      if (_renderState == RCTVirtualViewRenderStateUnknown) {
+        // Feature flag is disabled, so use the former logic.
+        [self _dispatchSyncModeChange:event];
+      } else {
+        // If the previous mode was prerender and the result of dispatching that event was committed, we do not need
+        // to dispatch an event for visible.
+        const auto wasPrerenderCommitted = oldMode.has_value() && oldMode == RCTVirtualViewModePrerender &&
+            _renderState == RCTVirtualViewRenderStateRendered;
+        if (!wasPrerenderCommitted) {
+          [self _dispatchSyncModeChange:event];
+        }
+      }
+      break;
+    case RCTVirtualViewModePrerender:
+      if (!oldMode.has_value() || oldMode != RCTVirtualViewModeVisible) {
+        [self _dispatchAsyncModeChange:event];
+      }
+      break;
+    case RCTVirtualViewModeHidden:
+      [self _dispatchAsyncModeChange:event];
+      break;
+  }
+
+  if (ReactNativeFeatureFlags::hideOffscreenVirtualViewsOnIOS()) {
+    switch (newMode) {
+      case RCTVirtualViewModeVisible:
+        self.hidden = NO;
+        break;
+      case RCTVirtualViewModePrerender:
+        self.hidden = !sIsAccessibilityUsed;
+        break;
+      case RCTVirtualViewModeHidden:
+        self.hidden = YES;
+        break;
+    }
+  }
+}
+
+#pragma mark - Private API
+
+- (void)_unhideIfNeeded
+{
+  if (!sIsAccessibilityUsed) {
+    // accessibility is detected for the first time. Make views visible.
+    sIsAccessibilityUsed = YES;
+  }
+
+  if (self.hidden) {
+    self.hidden = NO;
+  }
+}
+
+- (id<RCTVirtualViewContainerProtocol>)_getParentVirtualViewContainer
+{
+  UIView *view = self.superview;
+  while (view != nil) {
+    if ([view respondsToSelector:@selector(virtualViewContainerState)]) {
+      return (id<RCTVirtualViewContainerProtocol>)view;
+    }
+    view = view.superview;
+  }
+  return nil;
+}
+
+- (void)_dispatchAsyncModeChange:(VirtualViewEventEmitter::OnModeChange &)event
+{
+  if (!_eventEmitter) {
+    return;
+  }
+
+  std::shared_ptr<const VirtualViewEventEmitter> emitter =
+      std::static_pointer_cast<const VirtualViewEventEmitter>(_eventEmitter);
+  emitter->onModeChange(event);
+}
+
+- (void)_dispatchSyncModeChange:(VirtualViewEventEmitter::OnModeChange &)event
+{
+  if (!_eventEmitter) {
+    return;
+  }
+
+  std::shared_ptr<const VirtualViewEventEmitter> emitter =
+      std::static_pointer_cast<const VirtualViewEventEmitter>(_eventEmitter);
+
+  // TODO: Move this into a custom event emitter. We had to duplicate the codegen code here from onModeChange in order
+  // to dispatch synchronously and discrete.
+  emitter->experimental_flushSync([&emitter, &event]() {
+    emitter->dispatchEvent(
+        "modeChange",
+        [event](jsi::Runtime &runtime) {
+          auto payload = jsi::Object(runtime);
+          payload.setProperty(runtime, "mode", event.mode);
+          {
+            auto targetRect = jsi::Object(runtime);
+            targetRect.setProperty(runtime, "x", event.targetRect.x);
+            targetRect.setProperty(runtime, "y", event.targetRect.y);
+            targetRect.setProperty(runtime, "width", event.targetRect.width);
+            targetRect.setProperty(runtime, "height", event.targetRect.height);
+            payload.setProperty(runtime, "targetRect", targetRect);
+          }
+          {
+            auto thresholdRect = jsi::Object(runtime);
+            thresholdRect.setProperty(runtime, "x", event.thresholdRect.x);
+            thresholdRect.setProperty(runtime, "y", event.thresholdRect.y);
+            thresholdRect.setProperty(runtime, "width", event.thresholdRect.width);
+            thresholdRect.setProperty(runtime, "height", event.thresholdRect.height);
+            payload.setProperty(runtime, "thresholdRect", thresholdRect);
+          }
+          return payload;
+        },
+        RawEvent::Category::Discrete);
+  });
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<VirtualViewExperimentalComponentDescriptor>();
+}
+
+@end
+
+Class<RCTComponentViewProtocol> VirtualViewExperimentalCls(void)
+{
+  return RCTVirtualViewExperimentalComponentView.class;
+}

package/React/Fabric/Mounting/ComponentViews/VirtualViewExperimental/RCTVirtualViewMode.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+#ifndef RCTVirtualViewMode_h
+#define RCTVirtualViewMode_h
+
+// Enum for virtual view modes
+using RCTVirtualViewMode = NS_ENUM(NSInteger){
+    RCTVirtualViewModeVisible = 0,
+    RCTVirtualViewModePrerender = 1,
+    RCTVirtualViewModeHidden = 2,
+};
+#endif /* RCTVirtualViewMode_h */

package/React/Fabric/Mounting/ComponentViews/VirtualViewExperimental/RCTVirtualViewRenderState.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+#ifndef RCTVirtualViewRenderState_h
+#define RCTVirtualViewRenderState_h
+
+using RCTVirtualViewRenderState = NS_ENUM(NSInteger){
+    RCTVirtualViewRenderStateUnknown = 0,
+    RCTVirtualViewRenderStateRendered = 1,
+    RCTVirtualViewRenderStateNone = 2,
+};
+#endif /* RCTVirtualViewRenderState_h */

package/React/Fabric/Mounting/RCTComponentViewDescriptor.h

@@ -21,15 +21,15 @@ class RCTComponentViewDescriptor final {
   /*
    * Associated (and owned) native view instance.
    */
-  __strong UIView<RCTComponentViewProtocol> *view = nil;
+  __strong UIView<RCTComponentViewProtocol> *const view = nil;
 
   /*
    * Indicates a requirement to call on the view methods from
    * `RCTMountingTransactionObserving` protocol.
    */
-  bool observesMountingTransactionWillMount{false};
-  bool observesMountingTransactionDidMount{false};
-  bool shouldBeRecycled{true};
+  const bool observesMountingTransactionWillMount{false};
+  const bool observesMountingTransactionDidMount{false};
+  const bool shouldBeRecycled{true};
 };
 
 inline bool operator==(const RCTComponentViewDescriptor &lhs, const RCTComponentViewDescriptor &rhs)

package/React/Fabric/Mounting/RCTComponentViewFactory.mm

@@ -165,7 +165,8 @@ static Class<RCTComponentViewProtocol> RCTComponentViewClassWithName(const char
     auto componentHandle = reinterpret_cast<ComponentHandle>(componentName);
     auto constructor = [RCTLegacyViewManagerInteropComponentView componentDescriptorProvider].constructor;
 
-    auto provider = ComponentDescriptorProvider{componentHandle, componentName, flavor, constructor};
+    auto provider = ComponentDescriptorProvider{
+        .handle = componentHandle, .name = componentName, .flavor = flavor, .constructor = constructor};
 
     _providerRegistry.add(provider);
     _componentViewClasses[componentHandle] =
@@ -179,7 +180,8 @@ static Class<RCTComponentViewProtocol> RCTComponentViewClassWithName(const char
   auto componentName = ComponentName{flavor->c_str()};
   auto componentHandle = reinterpret_cast<ComponentHandle>(componentName);
   auto constructor = [RCTUnimplementedViewComponentView componentDescriptorProvider].constructor;
-  auto provider = ComponentDescriptorProvider{componentHandle, componentName, flavor, constructor};
+  auto provider = ComponentDescriptorProvider{
+      .handle = componentHandle, .name = componentName, .flavor = flavor, .constructor = constructor};
 
   _providerRegistry.add(provider);
   _componentViewClasses[componentHandle] =

package/React/Fabric/Mounting/RCTComponentViewProtocol.h

@@ -111,6 +111,12 @@ typedef NS_OPTIONS(NSInteger, RNComponentViewUpdateMask) {
  */
 - (void)prepareForRecycle;
 
+/*
+ * Called for unmounted components that won't be moved to a recycle pool.
+ * Useful for releasing any associated resources.
+ */
+- (void)invalidate;
+
 /*
  * Read the last props used to update the view.
  */

package/React/Fabric/Mounting/RCTComponentViewRegistry.mm

@@ -108,6 +108,7 @@ const NSInteger RCTComponentViewRegistryRecyclePoolMaxSize = 1024;
   auto &recycledViews = _recyclePool[componentHandle];
 
   if (recycledViews.size() > RCTComponentViewRegistryRecyclePoolMaxSize || !componentViewDescriptor.shouldBeRecycled) {
+    [componentViewDescriptor.view invalidate];
     return;
   }
 

package/React/Fabric/Mounting/RCTMountingManager.h

@@ -28,7 +28,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, weak) id<RCTMountingManagerDelegate> delegate;
 @property (nonatomic, strong) RCTComponentViewRegistry *componentViewRegistry;
 
-- (void)setContextContainer:(facebook::react::ContextContainer::Shared)contextContainer;
+- (void)setContextContainer:(std::shared_ptr<const facebook::react::ContextContainer>)contextContainer;
 
 /**
  * Designates the view as a rendering viewport of a React Native surface.

package/React/Fabric/Mounting/RCTMountingManager.mm

@@ -143,7 +143,7 @@ static void RCTPerformMountInstructions(
   RCTMountingTransactionObserverCoordinator _observerCoordinator;
   BOOL _transactionInFlight;
   BOOL _followUpTransactionRequired;
-  ContextContainer::Shared _contextContainer;
+  std::shared_ptr<const ContextContainer> _contextContainer;
 }
 
 - (instancetype)init
@@ -155,7 +155,7 @@ static void RCTPerformMountInstructions(
   return self;
 }
 
-- (void)setContextContainer:(ContextContainer::Shared)contextContainer
+- (void)setContextContainer:(std::shared_ptr<const ContextContainer>)contextContainer
 {
   _contextContainer = contextContainer;
 }

package/React/Fabric/Mounting/UIView+ComponentViewProtocol.h

@@ -37,6 +37,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)prepareForRecycle;
 
+- (void)invalidate;
+
 - (facebook::react::Props::Shared)props;
 
 - (void)setIsJSResponder:(BOOL)isJSResponder;

package/React/Fabric/Mounting/UIView+ComponentViewProtocol.mm

@@ -129,6 +129,11 @@ using namespace facebook::react;
   // Default implementation does nothing.
 }
 
+- (void)invalidate
+{
+  // Default implementation does nothing.
+}
+
 - (facebook::react::Props::Shared)props
 {
   RCTAssert(NO, @"props access should be implemented by RCTViewComponentView.");

package/React/Fabric/RCTConversions.h

@@ -153,7 +153,7 @@ inline CATransform3D RCTCATransform3DFromTransformMatrix(const facebook::react::
 
 inline facebook::react::Point RCTPointFromCGPoint(const CGPoint &point)
 {
-  return {point.x, point.y};
+  return {.x = point.x, .y = point.y};
 }
 
 inline facebook::react::Float RCTFloatFromCGFloat(CGFloat value)
@@ -166,12 +166,12 @@ inline facebook::react::Float RCTFloatFromCGFloat(CGFloat value)
 
 inline facebook::react::Size RCTSizeFromCGSize(const CGSize &size)
 {
-  return {RCTFloatFromCGFloat(size.width), RCTFloatFromCGFloat(size.height)};
+  return {.width = RCTFloatFromCGFloat(size.width), .height = RCTFloatFromCGFloat(size.height)};
 }
 
 inline facebook::react::Rect RCTRectFromCGRect(const CGRect &rect)
 {
-  return {RCTPointFromCGPoint(rect.origin), RCTSizeFromCGSize(rect.size)};
+  return {.origin = RCTPointFromCGPoint(rect.origin), .size = RCTSizeFromCGSize(rect.size)};
 }
 
 inline facebook::react::EdgeInsets RCTEdgeInsetsFromUIEdgeInsets(const UIEdgeInsets &edgeInsets)

package/React/Fabric/RCTPrimitives.h

@@ -7,4 +7,4 @@
 
 #import <Foundation/Foundation.h>
 
-typedef NSInteger ReactTag;
+using ReactTag = NSInteger;

package/React/Fabric/RCTSurfacePresenter.h

@@ -27,11 +27,11 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @interface RCTSurfacePresenter : NSObject
 
-- (instancetype)initWithContextContainer:(facebook::react::ContextContainer::Shared)contextContainer
+- (instancetype)initWithContextContainer:(std::shared_ptr<const facebook::react::ContextContainer>)contextContainer
                          runtimeExecutor:(facebook::react::RuntimeExecutor)runtimeExecutor
               bridgelessBindingsExecutor:(std::optional<facebook::react::RuntimeExecutor>)bridgelessBindingsExecutor;
 
-@property (nonatomic) facebook::react::ContextContainer::Shared contextContainer;
+@property (nonatomic) std::shared_ptr<const facebook::react::ContextContainer> contextContainer;
 @property (nonatomic) facebook::react::RuntimeExecutor runtimeExecutor;
 
 /*