react-native-tvos 0.76.6-0 → 0.77.0-0

package/React/Fabric/Mounting/ComponentViews/View/RCTViewComponentView.mm

@@ -10,11 +10,13 @@
 #import <CoreGraphics/CoreGraphics.h>
 #import <QuartzCore/QuartzCore.h>
 #import <objc/runtime.h>
+#import <ranges>
 
 #import <React/RCTAssert.h>
 #import <React/RCTBorderDrawing.h>
 #import <React/RCTBoxShadow.h>
 #import <React/RCTConversions.h>
+#import <React/RCTLinearGradient.h>
 #import <React/RCTLocalizedString.h>
 #import <react/featureflags/ReactNativeFeatureFlags.h>
 #import <React/RCTDefines.h>
@@ -55,9 +57,10 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   UIColor *_backgroundColor;
   CALayer *_backgroundColorLayer;
   __weak CALayer *_borderLayer;
+  CALayer *_outlineLayer;
   CALayer *_boxShadowLayer;
   CALayer *_filterLayer;
-  NSMutableArray<CAGradientLayer *> *_gradientLayers;
+  NSMutableArray<CALayer *> *_backgroundImageLayers;
   BOOL _needsInvalidateLayer;
   BOOL _isJSResponder;
   BOOL _removeClippedSubviews;
@@ -778,9 +781,8 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
   // `shadowColor`
   if (oldViewProps.shadowColor != newViewProps.shadowColor) {
-    CGColorRef shadowColor = RCTCreateCGColorRefFromSharedColor(newViewProps.shadowColor);
-    self.layer.shadowColor = shadowColor;
-    CGColorRelease(shadowColor);
+    UIColor *shadowColor = RCTUIColorFromSharedColor(newViewProps.shadowColor);
+    self.layer.shadowColor = shadowColor.CGColor;
     needsInvalidateLayer = YES;
   }
 
@@ -856,6 +858,14 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     needsInvalidateLayer = YES;
   }
 
+  // `outline`
+  if (oldViewProps.outlineStyle != newViewProps.outlineStyle ||
+      oldViewProps.outlineColor != newViewProps.outlineColor ||
+      oldViewProps.outlineOffset != newViewProps.outlineOffset ||
+      oldViewProps.outlineWidth != newViewProps.outlineWidth) {
+    needsInvalidateLayer = YES;
+  }
+
   // `nativeId`
   if (oldViewProps.nativeId != newViewProps.nativeId) {
     self.nativeId = RCTNSStringFromStringNilIfEmpty(newViewProps.nativeId);
@@ -1304,21 +1314,61 @@ static RCTCornerRadii RCTCornerRadiiFromBorderRadii(BorderRadii borderRadii)
       .bottomRightVertical = (CGFloat)borderRadii.bottomRight.vertical};
 }
 
-static RCTBorderColors RCTCreateRCTBorderColorsFromBorderColors(BorderColors borderColors)
+static RCTCornerRadii RCTCreateOutlineCornerRadiiFromBorderRadii(const BorderRadii &borderRadii, CGFloat outlineWidth)
 {
-  return RCTBorderColors{
-      .top = RCTCreateCGColorRefFromSharedColor(borderColors.top),
-      .left = RCTCreateCGColorRefFromSharedColor(borderColors.left),
-      .bottom = RCTCreateCGColorRefFromSharedColor(borderColors.bottom),
-      .right = RCTCreateCGColorRefFromSharedColor(borderColors.right)};
+  return RCTCornerRadii{
+      borderRadii.topLeft.horizontal != 0 ? borderRadii.topLeft.horizontal + outlineWidth : 0,
+      borderRadii.topLeft.vertical != 0 ? borderRadii.topLeft.vertical + outlineWidth : 0,
+      borderRadii.topRight.horizontal != 0 ? borderRadii.topRight.horizontal + outlineWidth : 0,
+      borderRadii.topRight.vertical != 0 ? borderRadii.topRight.vertical + outlineWidth : 0,
+      borderRadii.bottomLeft.horizontal != 0 ? borderRadii.bottomLeft.horizontal + outlineWidth : 0,
+      borderRadii.bottomLeft.vertical != 0 ? borderRadii.bottomLeft.vertical + outlineWidth : 0,
+      borderRadii.bottomRight.horizontal != 0 ? borderRadii.bottomRight.horizontal + outlineWidth : 0,
+      borderRadii.bottomRight.vertical != 0 ? borderRadii.bottomRight.vertical + outlineWidth : 0};
+}
+
+// To be used for CSS properties like `border` and `outline`.
+static void RCTAddContourEffectToLayer(
+    CALayer *layer,
+    const RCTCornerRadii &cornerRadii,
+    const RCTBorderColors &contourColors,
+    const UIEdgeInsets &contourInsets,
+    const RCTBorderStyle &contourStyle)
+{
+  UIImage *image = RCTGetBorderImage(
+      contourStyle, layer.bounds.size, cornerRadii, contourInsets, contourColors, [UIColor clearColor], NO);
+
+  if (image == nil) {
+    layer.contents = nil;
+  } else {
+    CGSize imageSize = image.size;
+    UIEdgeInsets imageCapInsets = image.capInsets;
+    CGRect contentsCenter = CGRect{
+        CGPoint{imageCapInsets.left / imageSize.width, imageCapInsets.top / imageSize.height},
+        CGSize{(CGFloat)1.0 / imageSize.width, (CGFloat)1.0 / imageSize.height}};
+    layer.contents = (id)image.CGImage;
+    layer.contentsScale = image.scale;
+
+    BOOL isResizable = !UIEdgeInsetsEqualToEdgeInsets(image.capInsets, UIEdgeInsetsZero);
+    if (isResizable) {
+      layer.contentsCenter = contentsCenter;
+    } else {
+      layer.contentsCenter = CGRect{CGPoint{0.0, 0.0}, CGSize{1.0, 1.0}};
+    }
+  }
+
+  // If mutations are applied inside of Animation block, it may cause layer to be animated.
+  // To stop that, imperatively remove all animations from layer.
+  [layer removeAllAnimations];
 }
 
-static void RCTReleaseRCTBorderColors(RCTBorderColors borderColors)
+static RCTBorderColors RCTCreateRCTBorderColorsFromBorderColors(BorderColors borderColors)
 {
-  CGColorRelease(borderColors.top);
-  CGColorRelease(borderColors.left);
-  CGColorRelease(borderColors.bottom);
-  CGColorRelease(borderColors.right);
+  return RCTBorderColors{
+      .top = RCTUIColorFromSharedColor(borderColors.top),
+      .left = RCTUIColorFromSharedColor(borderColors.left),
+      .bottom = RCTUIColorFromSharedColor(borderColors.bottom),
+      .right = RCTUIColorFromSharedColor(borderColors.right)};
 }
 
 static CALayerCornerCurve CornerCurveFromBorderCurve(BorderCurve borderCurve)
@@ -1345,12 +1395,25 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
   }
 }
 
+static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
+{
+  switch (outlineStyle) {
+    case OutlineStyle::Solid:
+      return RCTBorderStyleSolid;
+    case OutlineStyle::Dotted:
+      return RCTBorderStyleDotted;
+    case OutlineStyle::Dashed:
+      return RCTBorderStyleDashed;
+  }
+}
+
 - (BOOL)styleWouldClipOverflowInk
 {
   const auto borderMetrics = _props->resolveBorderMetrics(_layoutMetrics);
   BOOL nonZeroBorderWidth = !(borderMetrics.borderWidths.isUniform() && borderMetrics.borderWidths.left == 0);
   BOOL clipToPaddingBox = ReactNativeFeatureFlags::enableIOSViewClipToPaddingBox();
-  return _props->getClipsContentToBounds() && (!_props->boxShadow.empty() || (clipToPaddingBox && nonZeroBorderWidth));
+  return _props->getClipsContentToBounds() &&
+      ((!_props->boxShadow.empty() || (clipToPaddingBox && nonZeroBorderWidth)) || _props->outlineWidth != 0);
 }
 
 // This UIView is the UIView that holds all subviews. It is sometimes not self
@@ -1453,7 +1516,7 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
            (*borderMetrics.borderColors.left).getUIColor() != nullptr));
 
   // background color
-  CGColorRef backgroundColor = [_backgroundColor resolvedColorWithTraitCollection:self.traitCollection].CGColor;
+  UIColor *backgroundColor = [_backgroundColor resolvedColorWithTraitCollection:self.traitCollection];
   // The reason we sometimes do not set self.layer's backgroundColor is because
   // we want to support non-uniform border radii, which apple does not natively
   // support. To get this behavior we need to create a CGPath in the shape that
@@ -1463,7 +1526,7 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
   if (useCoreAnimationBorderRendering) {
     [_backgroundColorLayer removeFromSuperlayer];
     _backgroundColorLayer = nil;
-    layer.backgroundColor = backgroundColor;
+    layer.backgroundColor = backgroundColor.CGColor;
   } else {
     layer.backgroundColor = nil;
     if (!_backgroundColorLayer) {
@@ -1473,7 +1536,7 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
       [self.layer addSublayer:_backgroundColorLayer];
     }
 
-    _backgroundColorLayer.backgroundColor = backgroundColor;
+    _backgroundColorLayer.backgroundColor = backgroundColor.CGColor;
     if (borderMetrics.borderRadii.isUniform()) {
       _backgroundColorLayer.mask = nil;
       _backgroundColorLayer.cornerRadius = borderMetrics.borderRadii.topLeft.horizontal;
@@ -1496,9 +1559,8 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
     _borderLayer = nil;
 
     layer.borderWidth = (CGFloat)borderMetrics.borderWidths.left;
-    CGColorRef borderColor = RCTCreateCGColorRefFromSharedColor(borderMetrics.borderColors.left);
-    layer.borderColor = borderColor;
-    CGColorRelease(borderColor);
+    UIColor *borderColor = RCTUIColorFromSharedColor(borderMetrics.borderColors.left);
+    layer.borderColor = borderColor.CGColor;
     layer.cornerRadius = (CGFloat)borderMetrics.borderRadii.topLeft.horizontal;
     layer.cornerCurve = CornerCurveFromBorderCurve(borderMetrics.borderCurves.topLeft);
   } else {
@@ -1516,40 +1578,44 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
     layer.cornerRadius = 0;
 
     RCTBorderColors borderColors = RCTCreateRCTBorderColorsFromBorderColors(borderMetrics.borderColors);
-    UIImage *image = RCTGetBorderImage(
-        RCTBorderStyleFromBorderStyle(borderMetrics.borderStyles.left),
-        layer.bounds.size,
+
+    RCTAddContourEffectToLayer(
+        _borderLayer,
         RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii),
-        RCTUIEdgeInsetsFromEdgeInsets(borderMetrics.borderWidths),
         borderColors,
-        [UIColor clearColor].CGColor,
-        NO);
+        RCTUIEdgeInsetsFromEdgeInsets(borderMetrics.borderWidths),
+        RCTBorderStyleFromBorderStyle(borderMetrics.borderStyles.left));
+  }
 
-    RCTReleaseRCTBorderColors(borderColors);
+  // outline
+  [_outlineLayer removeFromSuperlayer];
+  _outlineLayer = nil;
+  if (_props->outlineWidth != 0) {
+    if (!_outlineLayer) {
+      CALayer *outlineLayer = [CALayer new];
+      outlineLayer.magnificationFilter = kCAFilterNearest;
+      outlineLayer.zPosition = BACKGROUND_COLOR_ZPOSITION + 2;
 
-    if (image == nil) {
-      _borderLayer.contents = nil;
-    } else {
-      CGSize imageSize = image.size;
-      UIEdgeInsets imageCapInsets = image.capInsets;
-      CGRect contentsCenter = CGRect{
-          CGPoint{imageCapInsets.left / imageSize.width, imageCapInsets.top / imageSize.height},
-          CGSize{(CGFloat)1.0 / imageSize.width, (CGFloat)1.0 / imageSize.height}};
-
-      _borderLayer.contents = (id)image.CGImage;
-      _borderLayer.contentsScale = image.scale;
-
-      BOOL isResizable = !UIEdgeInsetsEqualToEdgeInsets(image.capInsets, UIEdgeInsetsZero);
-      if (isResizable) {
-        _borderLayer.contentsCenter = contentsCenter;
-      } else {
-        _borderLayer.contentsCenter = CGRect{CGPoint{0.0, 0.0}, CGSize{1.0, 1.0}};
-      }
+      [layer addSublayer:outlineLayer];
+      _outlineLayer = outlineLayer;
     }
+    _outlineLayer.frame = CGRectInset(
+        layer.bounds, -_props->outlineOffset - _props->outlineWidth, -_props->outlineOffset - _props->outlineWidth);
 
-    // If mutations are applied inside of Animation block, it may cause _borderLayer to be animated.
-    // To stop that, imperatively remove all animations from _borderLayer.
-    [_borderLayer removeAllAnimations];
+    if (borderMetrics.borderRadii.isUniform() && borderMetrics.borderRadii.topLeft.horizontal == 0) {
+      UIColor *outlineColor = RCTUIColorFromSharedColor(_props->outlineColor);
+      _outlineLayer.borderWidth = _props->outlineWidth;
+      _outlineLayer.borderColor = outlineColor.CGColor;
+    } else {
+      UIColor *outlineColor = RCTUIColorFromSharedColor(_props->outlineColor);
+
+      RCTAddContourEffectToLayer(
+          _outlineLayer,
+          RCTCreateOutlineCornerRadiiFromBorderRadii(borderMetrics.borderRadii, _props->outlineWidth),
+          RCTBorderColors{outlineColor, outlineColor, outlineColor, outlineColor},
+          UIEdgeInsets{_props->outlineWidth, _props->outlineWidth, _props->outlineWidth, _props->outlineWidth},
+          RCTBorderStyleFromOutlineStyle(_props->outlineStyle));
+    }
   }
 
   // filter
@@ -1590,50 +1656,35 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
   }
 
   // background image
-  [self clearExistingGradientLayers];
+  [self clearExistingBackgroundImageLayers];
   if (!_props->backgroundImage.empty()) {
-    for (const auto &gradient : _props->backgroundImage) {
-      CAGradientLayer *gradientLayer = [CAGradientLayer layer];
-      NSMutableArray *colors = [NSMutableArray array];
-      NSMutableArray *locations = [NSMutableArray array];
-      for (const auto &colorStop : gradient.colorStops) {
-        if (colorStop.position.has_value()) {
-          auto location = @(colorStop.position.value());
-          UIColor *color = RCTUIColorFromSharedColor(colorStop.color);
-          [colors addObject:(id)color.CGColor];
-          [locations addObject:location];
+    // iterate in reverse to match CSS specification
+    for (const auto &backgroundImage : std::ranges::reverse_view(_props->backgroundImage)) {
+      if (std::holds_alternative<LinearGradient>(backgroundImage)) {
+        const auto &linearGradient = std::get<LinearGradient>(backgroundImage);
+        CALayer *backgroundImageLayer = [RCTLinearGradient gradientLayerWithSize:self.layer.bounds.size
+                                                                        gradient:linearGradient];
+        backgroundImageLayer.frame = layer.bounds;
+        backgroundImageLayer.masksToBounds = YES;
+        // To make border radius work with gradient layers
+        if (borderMetrics.borderRadii.isUniform()) {
+          backgroundImageLayer.cornerRadius = layer.cornerRadius;
+          backgroundImageLayer.cornerCurve = layer.cornerCurve;
+          backgroundImageLayer.mask = nil;
+        } else {
+          CAShapeLayer *maskLayer =
+              [self createMaskLayer:self.bounds
+                       cornerInsets:RCTGetCornerInsets(
+                                        RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii), UIEdgeInsetsZero)];
+          backgroundImageLayer.mask = maskLayer;
+          backgroundImageLayer.cornerRadius = 0;
         }
-      }
-      gradientLayer.startPoint = CGPointMake(gradient.startX, gradient.startY);
-      gradientLayer.endPoint = CGPointMake(gradient.endX, gradient.endY);
-
-      if (locations.count > 0) {
-        gradientLayer.locations = locations;
-      }
-      gradientLayer.colors = colors;
-      gradientLayer.frame = layer.bounds;
-
-      // border styling to work with gradient layers
-      if (useCoreAnimationBorderRendering) {
-        gradientLayer.borderWidth = layer.borderWidth;
-        gradientLayer.borderColor = layer.borderColor;
-        gradientLayer.cornerRadius = layer.cornerRadius;
-        gradientLayer.cornerCurve = layer.cornerCurve;
-      } else {
-        CAShapeLayer *maskLayer = [CAShapeLayer layer];
-        CGPathRef path = RCTPathCreateWithRoundedRect(
-            self.bounds,
-            RCTGetCornerInsets(RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii), UIEdgeInsetsZero),
-            nil);
-        maskLayer.path = path;
-        CGPathRelease(path);
-        gradientLayer.mask = maskLayer;
-      }
 
-      gradientLayer.zPosition = BACKGROUND_COLOR_ZPOSITION;
+        backgroundImageLayer.zPosition = BACKGROUND_COLOR_ZPOSITION;
 
-      [self.layer addSublayer:gradientLayer];
-      [_gradientLayers addObject:gradientLayer];
+        [self.layer addSublayer:backgroundImageLayer];
+        [_backgroundImageLayers addObject:backgroundImageLayer];
+      }
     }
   }
 
@@ -1704,16 +1755,16 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
   return maskLayer;
 }
 
-- (void)clearExistingGradientLayers
+- (void)clearExistingBackgroundImageLayers
 {
-  if (_gradientLayers == nil) {
-    _gradientLayers = [NSMutableArray new];
+  if (_backgroundImageLayers == nil) {
+    _backgroundImageLayers = [NSMutableArray new];
     return;
   }
-  for (CAGradientLayer *gradientLayer in _gradientLayers) {
-    [gradientLayer removeFromSuperlayer];
+  for (CALayer *backgroundImageLayer in _backgroundImageLayers) {
+    [backgroundImageLayer removeFromSuperlayer];
   }
-  [_gradientLayers removeAllObjects];
+  [_backgroundImageLayers removeAllObjects];
 }
 
 #pragma mark - Accessibility
@@ -1887,6 +1938,20 @@ static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
   }
 }
 
+- (void)accessibilityIncrement
+{
+  if (_eventEmitter && _props->onAccessibilityAction) {
+    _eventEmitter->onAccessibilityAction("increment");
+  }
+}
+
+- (void)accessibilityDecrement
+{
+  if (_eventEmitter && _props->onAccessibilityAction) {
+    _eventEmitter->onAccessibilityAction("decrement");
+  }
+}
+
 - (BOOL)didActivateAccessibilityCustomAction:(UIAccessibilityCustomAction *)action
 {
   if (_eventEmitter && _props->onAccessibilityAction) {

package/React/Fabric/Mounting/RCTMountingManager.h

@@ -48,7 +48,7 @@ NS_ASSUME_NONNULL_BEGIN
  * Schedule a mounting transaction to be performed on the main thread.
  * Can be called from any thread.
  */
-- (void)scheduleTransaction:(facebook::react::MountingCoordinator::Shared)mountingCoordinator;
+- (void)scheduleTransaction:(std::shared_ptr<const facebook::react::MountingCoordinator>)mountingCoordinator;
 
 /**
  * Dispatch a command to be performed on the main thread.

package/React/Fabric/Mounting/RCTMountingManager.mm

@@ -20,7 +20,6 @@
 #import <react/renderer/core/LayoutableShadowNode.h>
 #import <react/renderer/core/RawProps.h>
 #import <react/renderer/mounting/TelemetryController.h>
-#import <react/utils/CoreFeatures.h>
 
 #import <React/RCTComponentViewProtocol.h>
 #import <React/RCTComponentViewRegistry.h>
@@ -187,7 +186,7 @@ static void RCTPerformMountInstructions(
                                           componentViewDescriptor:rootViewDescriptor];
 }
 
-- (void)scheduleTransaction:(MountingCoordinator::Shared)mountingCoordinator
+- (void)scheduleTransaction:(std::shared_ptr<const MountingCoordinator>)mountingCoordinator
 {
   if (RCTIsMainQueue()) {
     // Already on the proper thread, so:

package/React/Fabric/RCTScheduler.h

@@ -26,9 +26,10 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @protocol RCTSchedulerDelegate
 
-- (void)schedulerDidFinishTransaction:(facebook::react::MountingCoordinator::Shared)mountingCoordinator;
+- (void)schedulerDidFinishTransaction:(std::shared_ptr<const facebook::react::MountingCoordinator>)mountingCoordinator;
 
-- (void)schedulerShouldRenderTransactions:(facebook::react::MountingCoordinator::Shared)mountingCoordinator;
+- (void)schedulerShouldRenderTransactions:
+    (std::shared_ptr<const facebook::react::MountingCoordinator>)mountingCoordinator;
 
 - (void)schedulerDidDispatchCommand:(const facebook::react::ShadowView &)shadowView
                         commandName:(const std::string &)commandName

package/React/Fabric/RCTScheduler.mm

@@ -26,13 +26,13 @@ class SchedulerDelegateProxy : public SchedulerDelegate {
  public:
   SchedulerDelegateProxy(void *scheduler) : scheduler_(scheduler) {}
 
-  void schedulerDidFinishTransaction(const MountingCoordinator::Shared &mountingCoordinator) override
+  void schedulerDidFinishTransaction(const std::shared_ptr<const MountingCoordinator> &mountingCoordinator) override
   {
     RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
     [scheduler.delegate schedulerDidFinishTransaction:mountingCoordinator];
   }
 
-  void schedulerShouldRenderTransactions(const MountingCoordinator::Shared &mountingCoordinator) override
+  void schedulerShouldRenderTransactions(const std::shared_ptr<const MountingCoordinator> &mountingCoordinator) override
   {
     RCTScheduler *scheduler = (__bridge RCTScheduler *)scheduler_;
     [scheduler.delegate schedulerShouldRenderTransactions:mountingCoordinator];
@@ -106,18 +106,15 @@ class LayoutAnimationDelegateProxy : public LayoutAnimationStatusDelegate, publi
 @implementation RCTScheduler {
   std::unique_ptr<Scheduler> _scheduler;
   std::shared_ptr<LayoutAnimationDriver> _animationDriver;
-  std::shared_ptr<SchedulerDelegateProxy> _delegateProxy;
+  std::unique_ptr<SchedulerDelegateProxy> _delegateProxy;
   std::shared_ptr<LayoutAnimationDelegateProxy> _layoutAnimationDelegateProxy;
-  RunLoopObserver::Unique _uiRunLoopObserver;
+  std::unique_ptr<const PlatformRunLoopObserver> _uiRunLoopObserver;
 }
 
 - (instancetype)initWithToolbox:(SchedulerToolbox)toolbox
 {
   if (self = [super init]) {
-    auto reactNativeConfig =
-        toolbox.contextContainer->at<std::shared_ptr<const ReactNativeConfig>>("ReactNativeConfig");
-
-    _delegateProxy = std::make_shared<SchedulerDelegateProxy>((__bridge void *)self);
+    _delegateProxy = std::make_unique<SchedulerDelegateProxy>((__bridge void *)self);
 
     if (ReactNativeFeatureFlags::enableLayoutAnimationsOnIOS()) {
       _layoutAnimationDelegateProxy = std::make_shared<LayoutAnimationDelegateProxy>((__bridge void *)self);

package/React/Fabric/RCTSurfacePointerHandler.mm

@@ -640,22 +640,22 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
     if (eventEmitter != nil) {
       switch (eventType) {
         case RCTPointerEventTypeStart: {
-          eventEmitter->onPointerDown(pointerEvent);
+          eventEmitter->onPointerDown(std::move(pointerEvent));
           break;
         }
         case RCTPointerEventTypeMove: {
-          eventEmitter->onPointerMove(pointerEvent);
+          eventEmitter->onPointerMove(std::move(pointerEvent));
           break;
         }
         case RCTPointerEventTypeEnd: {
           eventEmitter->onPointerUp(pointerEvent);
           if (pointerEvent.isPrimary && pointerEvent.button == 0 && IsPointerWithinInitialTree(activePointer)) {
-            eventEmitter->onClick(pointerEvent);
+            eventEmitter->onClick(std::move(pointerEvent));
           }
           break;
         }
         case RCTPointerEventTypeCancel: {
-          eventEmitter->onPointerCancel(pointerEvent);
+          eventEmitter->onPointerCancel(std::move(pointerEvent));
           break;
         }
       }
@@ -782,9 +782,11 @@ RCT_NOT_IMPLEMENTED(-(instancetype)initWithTarget : (id)target action : (SEL)act
   if (eventEmitter != nil) {
     switch (recognizer.state) {
       case UIGestureRecognizerStateEnded:
-        eventEmitter->onPointerLeave(event);
+        eventEmitter->onPointerLeave(std::move(event));
+        break;
       default:
-        eventEmitter->onPointerMove(event);
+        eventEmitter->onPointerMove(std::move(event));
+        break;
     }
   }
 }

package/React/Fabric/RCTSurfacePresenter.mm

@@ -26,16 +26,14 @@
 #import <React/RCTSurfaceView.h>
 #import <React/RCTUtils.h>
 
-#import <react/config/ReactNativeConfig.h>
 #import <react/featureflags/ReactNativeFeatureFlags.h>
 #import <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #import <react/renderer/components/text/BaseTextProps.h>
 #import <react/renderer/runtimescheduler/RuntimeScheduler.h>
-#import <react/renderer/scheduler/AsynchronousEventBeat.h>
 #import <react/renderer/scheduler/SchedulerToolbox.h>
 #import <react/utils/ContextContainer.h>
-#import <react/utils/CoreFeatures.h>
 #import <react/utils/ManagedObjectWrapper.h>
+#import "AppleEventBeat.h"
 
 #import "PlatformRunLoopObserver.h"
 #import "RCTConversions.h"
@@ -227,16 +225,6 @@ using namespace facebook::react;
 
 - (RCTScheduler *)_createScheduler
 {
-  auto reactNativeConfig = _contextContainer->at<std::shared_ptr<const ReactNativeConfig>>("ReactNativeConfig");
-
-  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_cpp_props_iterator_setter_ios")) {
-    CoreFeatures::enablePropIteratorSetter = true;
-  }
-
-  if (reactNativeConfig && reactNativeConfig->getBool("react_fabric:enable_granular_scroll_view_state_updates_ios")) {
-    CoreFeatures::enableGranularScrollViewStateUpdatesIOS = true;
-  }
-
   auto componentRegistryFactory =
       [factory = wrapManagedObject(_mountingManager.componentViewRegistry.componentViewFactory)](
           const EventDispatcher::Weak &eventDispatcher, const ContextContainer::Shared &contextContainer) {
@@ -261,11 +249,11 @@ using namespace facebook::react;
   toolbox.runtimeExecutor = runtimeExecutor;
   toolbox.bridgelessBindingsExecutor = _bridgelessBindingsExecutor;
 
-  toolbox.asynchronousEventBeatFactory =
-      [runtimeExecutor](const EventBeat::SharedOwnerBox &ownerBox) -> std::unique_ptr<EventBeat> {
+  toolbox.eventBeatFactory =
+      [runtimeScheduler](std::shared_ptr<EventBeat::OwnerBox> ownerBox) -> std::unique_ptr<EventBeat> {
     auto runLoopObserver =
         std::make_unique<const MainRunLoopObserver>(RunLoopObserver::Activity::BeforeWaiting, ownerBox->owner);
-    return std::make_unique<AsynchronousEventBeat>(std::move(runLoopObserver), runtimeExecutor);
+    return std::make_unique<AppleEventBeat>(std::move(ownerBox), std::move(runLoopObserver), *runtimeScheduler);
   };
 
   RCTScheduler *scheduler = [[RCTScheduler alloc] initWithToolbox:toolbox];
@@ -301,12 +289,12 @@ using namespace facebook::react;
 
 #pragma mark - RCTSchedulerDelegate
 
-- (void)schedulerDidFinishTransaction:(MountingCoordinator::Shared)mountingCoordinator
+- (void)schedulerDidFinishTransaction:(std::shared_ptr<const MountingCoordinator>)mountingCoordinator
 {
   // no-op, we will flush the transaction from schedulerShouldRenderTransactions
 }
 
-- (void)schedulerShouldRenderTransactions:(MountingCoordinator::Shared)mountingCoordinator
+- (void)schedulerShouldRenderTransactions:(std::shared_ptr<const MountingCoordinator>)mountingCoordinator
 {
   [_mountingManager scheduleTransaction:mountingCoordinator];
 }

package/React/Fabric/Surface/RCTFabricSurface.mm

@@ -99,15 +99,16 @@ using namespace facebook::react;
 
   // We need to register a root view component here synchronously because right after
   // we start a surface, it can initiate an update that can query the root component.
-  RCTUnsafeExecuteOnMainQueueSync(^{
+  RCTExecuteOnMainQueue(^{
     [self->_surfacePresenter.mountingManager attachSurfaceToView:self.view
                                                        surfaceId:self->_surfaceHandler->getSurfaceId()];
-  });
+    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
+      self->_surfaceHandler->start();
+      [self _propagateStageChange];
 
-  _surfaceHandler->start();
-  [self _propagateStageChange];
-
-  [_surfacePresenter setupAnimationDriverWithSurfaceHandler:*_surfaceHandler];
+      [self->_surfacePresenter setupAnimationDriverWithSurfaceHandler:*self->_surfaceHandler];
+    });
+  });
 }
 
 - (void)stop

package/React/Fabric/Utils/PlatformRunLoopObserver.h

@@ -22,7 +22,7 @@ class PlatformRunLoopObserver : public RunLoopObserver {
  public:
   PlatformRunLoopObserver(
       RunLoopObserver::Activity activities,
-      const RunLoopObserver::WeakOwner& owner,
+      RunLoopObserver::WeakOwner owner,
       CFRunLoopRef runLoop);
 
   ~PlatformRunLoopObserver();
@@ -45,8 +45,11 @@ class MainRunLoopObserver final : public PlatformRunLoopObserver {
  public:
   MainRunLoopObserver(
       RunLoopObserver::Activity activities,
-      const RunLoopObserver::WeakOwner& owner)
-      : PlatformRunLoopObserver(activities, owner, CFRunLoopGetMain()) {}
+      RunLoopObserver::WeakOwner owner)
+      : PlatformRunLoopObserver(
+            activities,
+            std::move(owner),
+            CFRunLoopGetMain()) {}
 };
 
 } // namespace facebook::react

package/React/Fabric/Utils/PlatformRunLoopObserver.mm

@@ -45,13 +45,10 @@ static RunLoopObserver::Activity toRunLoopActivity(CFRunLoopActivity activity)
 
 PlatformRunLoopObserver::PlatformRunLoopObserver(
     RunLoopObserver::Activity activities,
-    const RunLoopObserver::WeakOwner &owner,
+    RunLoopObserver::WeakOwner owner,
     CFRunLoopRef runLoop)
     : RunLoopObserver(activities, owner), runLoop_(runLoop)
 {
-  // A value (not a reference) to be captured by the block.
-  auto weakOwner = owner;
-
   // The documentation for `CFRunLoop` family API states that all of the methods are thread-safe.
   // See "Thread Safety and Run Loop Objects" section of the "Threading Programming Guide" for more details.
   mainRunLoopObserver_ = CFRunLoopObserverCreateWithHandler(
@@ -60,7 +57,7 @@ PlatformRunLoopObserver::PlatformRunLoopObserver(
       true /* repeats */,
       0 /* order */,
       ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
-        auto strongOwner = weakOwner.lock();
+        auto strongOwner = owner.lock();
         if (!strongOwner) {
           return;
         }

package/React/Fabric/Utils/RCTLinearGradient.h

@@ -0,0 +1,19 @@
+/*
+ * 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/renderer/components/view/ViewProps.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTLinearGradient : NSObject
+
++ (CALayer *)gradientLayerWithSize:(CGSize)size gradient:(const facebook::react::LinearGradient &)gradient;
+
+@end
+
+NS_ASSUME_NONNULL_END