not-react-native-macos 0.83.0-rc.1 → 0.87.1-rc.2

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

@@ -6,14 +6,12 @@
  */
 
 #import "RCTViewComponentView.h"
+#import <React/RCTSurfaceHostingProxyRootView.h>
 
 #import <CoreGraphics/CoreGraphics.h>
 #import <QuartzCore/QuartzCore.h>
 #import <objc/runtime.h>
 #import <ranges>
-#if TARGET_OS_OSX // [macOS
-#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
-#endif // macOS]
 
 #import <RCTSwiftUIWrapper/RCTSwiftUIContainerViewWrapper.h>
 #import <React/RCTAssert.h>
@@ -35,18 +33,12 @@
 #import <React/RCTComponentViewFactory.h>
 #endif
 
-#if TARGET_OS_OSX // [macOS
-#import <React/RCTCursor.h>
-#import <React/RCTViewKeyboardEvent.h>
-#import <React/RCTUtils.h>
-#endif // macOS]
-
 using namespace facebook::react;
 
 const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
 @implementation RCTViewComponentView {
-  RCTUIColor *_backgroundColor; // [macOS]
+  UIColor *_backgroundColor;
   CALayer *_backgroundColorLayer;
   __weak CALayer *_borderLayer;
   CALayer *_outlineLayer;
@@ -56,18 +48,13 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   BOOL _needsInvalidateLayer;
   BOOL _isJSResponder;
   BOOL _removeClippedSubviews;
-#if TARGET_OS_OSX // [macOS
-  BOOL _hasMouseOver;
-  BOOL _hasClipViewBoundsObserver;
-  NSTrackingArea *_trackingArea;
-  BOOL _allowsVibrancy;
-#endif // macOS]
-  NSMutableArray<RCTUIView *> *_reactSubviews; // [macOS]
+  NSMutableArray<UIView *> *_reactSubviews;
   NSSet<NSString *> *_Nullable _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
-  RCTPlatformView *_containerView; // [macOS]
+  UIView *_containerView;
   BOOL _useCustomContainerView;
   NSMutableSet<NSString *> *_accessibilityOrderNativeIDs;
   RCTSwiftUIContainerViewWrapper *_swiftUIWrapper;
+  BOOL _focusable;
 }
 
 #ifdef RCT_DYNAMIC_FRAMEWORKS
@@ -82,15 +69,11 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   if (self = [super initWithFrame:frame]) {
     _props = ViewShadowNode::defaultSharedProps();
     _reactSubviews = [NSMutableArray new];
-#if !TARGET_OS_OSX // [macOS]
+#if !TARGET_OS_TV
     self.multipleTouchEnabled = YES;
-#endif // [macOS]
+#endif
     _useCustomContainerView = NO;
     _removeClippedSubviews = NO;
-#if TARGET_OS_OSX // [macOS
-    _allowsVibrancy = NO;
-    self.mouseDownCanMoveWindow = YES;
-#endif // macOS]
   }
   return self;
 }
@@ -100,11 +83,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   return _props;
 }
 
-#if !TARGET_OS_OSX // [macOS]
-- (void)setContentView:(RCTUIView *)contentView // [macOS]
-#else // [macOS
-- (void)setContentView:(RCTPlatformView *)contentView // [macOS]
-#endif // macOS]
+- (void)setContentView:(UIView *)contentView
 {
   if (_contentView) {
     [_contentView removeFromSuperview];
@@ -115,15 +94,28 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   if (_contentView) {
     [self.currentContainerView addSubview:_contentView];
     _contentView.frame = RCTCGRectFromRect(_layoutMetrics.getContentFrame());
-#if TARGET_OS_OSX // [macOS
-    _contentView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-#endif // macOS]
-    [self addSubview:_contentView];
   }
 }
 
+// Rejects hits against views whose 2D transform collapses an axis (e.g. `scaleX: 0`,
+// `scaleY: 0`, or any other non-invertible affine). Such views are visually degenerate, and
+// UIKit's `-convertPoint:fromView:` falls back to the original matrix when
+// `CGAffineTransformInvert` can't invert, so without this check the degenerate transform is
+// applied to the touch point and the view can still register hits along the collapsed axis.
+static BOOL RCTLayerTransformCollapsesAxis(CALayer *layer)
+{
+  CATransform3D t = layer.transform;
+  // Determinant of the 2x2 projection onto the XY plane. Anything non-zero is invertible; we
+  // treat values within float epsilon as zero to avoid numerical issues near machine precision.
+  CGFloat det = t.m11 * t.m22 - t.m12 * t.m21;
+  return fabs(det) < (CGFloat)1e-6;
+}
+
 - (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event
 {
+  if (RCTLayerTransformCollapsesAxis(self.layer)) {
+    return NO;
+  }
   if (UIEdgeInsetsEqualToEdgeInsets(self.hitTestEdgeInsets, UIEdgeInsetsZero)) {
     return [super pointInside:point withEvent:event];
   }
@@ -131,34 +123,16 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   return CGRectContainsPoint(hitFrame, point);
 }
 
-- (RCTUIColor *)backgroundColor // [macOS]
+- (UIColor *)backgroundColor
 {
   return _backgroundColor;
 }
 
-- (void)setBackgroundColor:(RCTUIColor *)backgroundColor // [macOS]
+- (void)setBackgroundColor:(UIColor *)backgroundColor
 {
   _backgroundColor = backgroundColor;
 }
 
-#if TARGET_OS_OSX // [macOS
-- (void)resetCursorRects
-{
-  [self discardCursorRects];
-  if (_props->cursor != Cursor::Auto)
-  {
-    NSCursor *cursor = NSCursorFromRCTCursor(RCTCursorFromCursor(_props->cursor));
-    [self addCursorRect:self.bounds cursor:cursor];
-  }
-}
-
-- (BOOL)allowsVibrancy
-{
-  return _allowsVibrancy;
-}
-#endif // macOS]
-
-#if !TARGET_OS_OSX
 - (void)traitCollectionDidChange:(UITraitCollection *)previousTraitCollection
 {
   [super traitCollectionDidChange:previousTraitCollection];
@@ -167,14 +141,6 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     [self invalidateLayer];
   }
 }
-#else // [macOS SAAD
-- (void)viewDidChangeEffectiveAppearance
-{
-  [super viewDidChangeEffectiveAppearance];
-
-  [self invalidateLayer];
-}
-#endif // macOS]
 
 #pragma mark - RCTComponentViewProtocol
 
@@ -187,7 +153,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   return concreteComponentDescriptorProvider<ViewComponentDescriptor>();
 }
 
-- (void)mountChildComponentView:(RCTUIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index // [macOS]
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
 {
   RCTAssert(
       childComponentView.superview == nil,
@@ -204,17 +170,24 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   }
 }
 
-- (void)unmountChildComponentView:(RCTUIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index // [macOS]
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
 {
   if (_removeClippedSubviews) {
     [_reactSubviews removeObjectAtIndex:index];
   } else {
     RCTAssert(
-        childComponentView.superview == self.currentContainerView,
-        @"Attempt to unmount a view which is mounted inside different view. (parent: %@, child: %@, index: %@)",
+        childComponentView.superview != nil,
+        @"Attempt to unmount a view which is not mounted. (parent: %@, child: %@, index: %@)",
         self,
         childComponentView,
         @(index));
+    RCTAssert(
+        childComponentView.superview == self.currentContainerView,
+        @"Attempt to unmount a view which is mounted inside a different view. (parent: %@, child: %@, index: %@, existing parent: %@)",
+        self,
+        childComponentView,
+        @(index),
+        @([childComponentView.superview tag]));
     RCTAssert(
         (self.currentContainerView.subviews.count > index) &&
             [self.currentContainerView.subviews objectAtIndex:index] == childComponentView,
@@ -229,7 +202,31 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   [childComponentView removeFromSuperview];
 }
 
-- (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(RCTUIView *)clipView // [macOS]
+- (void)_updateRemoveClippedSubviewsState
+{
+  if (_removeClippedSubviews) {
+    // Toggled ON: populate _reactSubviews from the current view hierarchy.
+    // Actual clipping will happen on the next scroll event.
+    RCTAssert(
+        _reactSubviews.count == 0,
+        @"_reactSubviews should be empty when toggling removeClippedSubviews on. (view: %@, count: %@)",
+        self,
+        @(_reactSubviews.count));
+    if (self.currentContainerView.subviews.count > 0) {
+      _reactSubviews = [NSMutableArray arrayWithArray:self.currentContainerView.subviews];
+    }
+  } else {
+    // Toggled OFF: re-mount all children in the correct order, then clear the tracking array.
+    // addSubview: on an already-present child moves it to the front, so iterating in order
+    // produces the correct subview ordering.
+    for (UIView *view in _reactSubviews) {
+      [self.currentContainerView addSubview:view];
+    }
+    [_reactSubviews removeAllObjects];
+  }
+}
+
+- (void)updateClippedSubviewsWithClipRect:(CGRect)clipRect relativeToView:(UIView *)clipView
 {
   if (!_removeClippedSubviews) {
     // Use default behavior if unmounting is disabled
@@ -250,7 +247,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   clipRect = [clipView convertRect:clipRect toView:self];
 
   // Mount / unmount views
-  for (RCTUIView *view in _reactSubviews) { // [macOS]
+  for (UIView *view in _reactSubviews) {
     if (CGRectIntersectsRect(clipRect, view.frame)) {
       // View is at least partially visible, so remount it if unmounted
       [self.currentContainerView addSubview:view];
@@ -294,21 +291,19 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   if (!ReactNativeFeatureFlags::enableViewCulling()) {
     if (oldViewProps.removeClippedSubviews != newViewProps.removeClippedSubviews) {
       _removeClippedSubviews = newViewProps.removeClippedSubviews;
-      if (_removeClippedSubviews && self.currentContainerView.subviews.count > 0) {
-        _reactSubviews = [NSMutableArray arrayWithArray:self.currentContainerView.subviews];
-      }
+      [self _updateRemoveClippedSubviewsState];
     }
   }
 
   // `backgroundColor`
   if (oldViewProps.backgroundColor != newViewProps.backgroundColor) {
-    self.backgroundColor = RCTUIColorFromSharedColor(newViewProps.backgroundColor); // [macOS]
+    self.backgroundColor = RCTUIColorFromSharedColor(newViewProps.backgroundColor);
     needsInvalidateLayer = YES;
   }
 
   // `shadowColor`
   if (oldViewProps.shadowColor != newViewProps.shadowColor) {
-    RCTUIColor *shadowColor = RCTUIColorFromSharedColor(newViewProps.shadowColor); // [macOS]
+    UIColor *shadowColor = RCTUIColorFromSharedColor(newViewProps.shadowColor);
     self.layer.shadowColor = shadowColor.CGColor;
     needsInvalidateLayer = YES;
   }
@@ -341,19 +336,10 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     needsInvalidateLayer = YES;
   }
 
-  // `cursor`
-  if (oldViewProps.cursor != newViewProps.cursor) {
-    needsInvalidateLayer = YES;
-  }
-
   // `shouldRasterize`
   if (oldViewProps.shouldRasterize != newViewProps.shouldRasterize) {
     self.layer.shouldRasterize = newViewProps.shouldRasterize;
-#if !TARGET_OS_OSX // [macOS]
     self.layer.rasterizationScale = newViewProps.shouldRasterize ? self.traitCollection.displayScale : 1.0;
-#else // [macOS
-    self.layer.rasterizationScale = 1.0;
-#endif // macOS]
   }
 
   // `pointerEvents`
@@ -367,15 +353,6 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
       ![_propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN containsObject:@"transform"]) {
     auto newTransform = newViewProps.resolveTransform(_layoutMetrics);
     CATransform3D caTransform = RCTCATransform3DFromTransformMatrix(newTransform);
-#if TARGET_OS_OSX // [macOS
-    CGPoint anchorPoint = self.layer.anchorPoint;
-    if (CGPointEqualToPoint(anchorPoint, CGPointZero) && !CATransform3DEqualToTransform(caTransform, CATransform3DIdentity)) {
-      // https://developer.apple.com/documentation/quartzcore/calayer/1410817-anchorpoint
-      // This compensates for the fact that layer.anchorPoint is {0, 0} instead of {0.5, 0.5} on macOS for some reason.
-      CATransform3D originAdjust = CATransform3DTranslate(CATransform3DIdentity, self.frame.size.width / 2, self.frame.size.height / 2, 0);
-      caTransform = CATransform3DConcat(CATransform3DConcat(CATransform3DInvert(originAdjust), caTransform), originAdjust);
-    }
-#endif // macOS]
 
     self.layer.transform = caTransform;
     // Enable edge antialiasing in rotation, skew, or perspective transforms
@@ -418,11 +395,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
   // `accessible`
   if (oldViewProps.accessible != newViewProps.accessible) {
-#if !TARGET_OS_OSX // [macOS]
     self.accessibilityElement.isAccessibilityElement = newViewProps.accessible;
-#else // [macOS
-    self.accessibilityElement.accessibilityElement = newViewProps.accessible;
-#endif // macOS]
   }
 
   // `accessibilityLabel`
@@ -430,24 +403,17 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     self.accessibilityElement.accessibilityLabel = RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityLabel);
   }
 
-#if !TARGET_OS_OSX // [macOS]
   // `accessibilityLanguage`
   if (oldViewProps.accessibilityLanguage != newViewProps.accessibilityLanguage) {
     self.accessibilityElement.accessibilityLanguage =
         RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityLanguage);
   }
-#endif // [macOS]
 
   // `accessibilityHint`
   if (oldViewProps.accessibilityHint != newViewProps.accessibilityHint) {
-#if !TARGET_OS_OSX // [macOS]
     self.accessibilityElement.accessibilityHint = RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityHint);
-#else // [macOS
-    self.accessibilityElement.accessibilityHelp = RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityHint);
-#endif // macOS]
   }
 
-#if !TARGET_OS_OSX // [macOS]
   // `accessibilityViewIsModal`
   if (oldViewProps.accessibilityViewIsModal != newViewProps.accessibilityViewIsModal) {
     self.accessibilityElement.accessibilityViewIsModal = newViewProps.accessibilityViewIsModal;
@@ -460,6 +426,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
   // `accessibilityShowsLargeContentViewer`
   if (oldViewProps.accessibilityShowsLargeContentViewer != newViewProps.accessibilityShowsLargeContentViewer) {
+#if !TARGET_OS_TV
     if (@available(iOS 13.0, *)) {
       if (newViewProps.accessibilityShowsLargeContentViewer) {
         self.showsLargeContentViewer = YES;
@@ -469,15 +436,17 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
         self.showsLargeContentViewer = NO;
       }
     }
+#endif
   }
 
   // `accessibilityLargeContentTitle`
   if (oldViewProps.accessibilityLargeContentTitle != newViewProps.accessibilityLargeContentTitle) {
+#if !TARGET_OS_TV
     if (@available(iOS 13.0, *)) {
       self.largeContentTitle = RCTNSStringFromStringNilIfEmpty(newViewProps.accessibilityLargeContentTitle);
     }
+#endif
   }
-#endif // [macOS]
 
   // `accessibilityOrder`
   if (oldViewProps.accessibilityOrder != newViewProps.accessibilityOrder &&
@@ -499,19 +468,10 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
   // `accessibilityTraits`
   if (oldViewProps.accessibilityTraits != newViewProps.accessibilityTraits) {
-#if !TARGET_OS_OSX // [macOS]
     self.accessibilityElement.accessibilityTraits =
         RCTUIAccessibilityTraitsFromAccessibilityTraits(newViewProps.accessibilityTraits);
-#else // [macOS
-    // On macOS, accessibilityElement returns self (NSView*) which doesn't have accessibilityTraits.
-    // Set role directly on self based on traits.
-    RCTUIAccessibilityTraits traits = RCTUIAccessibilityTraitsFromAccessibilityTraits(newViewProps.accessibilityTraits);
-    self.accessibilityRole = RCTAccessibilityRoleFromTraits(traits);
-    self.accessibilityEnabled = (traits & RCTUIAccessibilityTraitNotEnabled) == 0;
-#endif // macOS]
   }
 
-#if !TARGET_OS_OSX // [macOS]
   // `accessibilityState`
   if (oldViewProps.accessibilityState != newViewProps.accessibilityState) {
     self.accessibilityTraits &= ~(UIAccessibilityTraitNotEnabled | UIAccessibilityTraitSelected);
@@ -528,7 +488,6 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   if (oldViewProps.accessibilityIgnoresInvertColors != newViewProps.accessibilityIgnoresInvertColors) {
     self.accessibilityIgnoresInvertColors = newViewProps.accessibilityIgnoresInvertColors;
   }
-#endif // [macOS]
 
   // `accessibilityValue`
   if (oldViewProps.accessibilityValue != newViewProps.accessibilityValue) {
@@ -548,19 +507,17 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     }
   }
 
-#if !TARGET_OS_OSX // [macOS]
   if (oldViewProps.accessibilityRespondsToUserInteraction != newViewProps.accessibilityRespondsToUserInteraction) {
     self.accessibilityElement.accessibilityRespondsToUserInteraction =
         newViewProps.accessibilityRespondsToUserInteraction;
   }
-#endif // [macOS]
 
   // `testId`
   if (oldViewProps.testId != newViewProps.testId) {
     SEL setAccessibilityIdentifierSelector = @selector(setAccessibilityIdentifier:);
     NSString *identifier = RCTNSStringFromString(newViewProps.testId);
     if ([self.accessibilityElement respondsToSelector:setAccessibilityIdentifierSelector]) {
-      RCTPlatformView *accessibilityView = (RCTPlatformView *)self.accessibilityElement; // [macOS]
+      UIView *accessibilityView = (UIView *)self.accessibilityElement;
       accessibilityView.accessibilityIdentifier = identifier;
     } else {
       self.accessibilityIdentifier = identifier;
@@ -572,6 +529,13 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     needsInvalidateLayer = YES;
   }
 
+  // `focusable`
+#if TARGET_OS_TV
+  if (oldViewProps.focusable != newViewProps.focusable) {
+    _focusable = (bool)newViewProps.focusable;
+  }
+#endif
+
   // `mixBlendMode`
   if (oldViewProps.mixBlendMode != newViewProps.mixBlendMode) {
     switch (newViewProps.mixBlendMode) {
@@ -620,6 +584,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
       case BlendMode::Luminosity:
         self.layer.compositingFilter = @"luminosityBlendMode";
         break;
+      case BlendMode::PlusLighter:
+        self.layer.compositingFilter = @"linearDodgeBlendMode";
+        break;
       case BlendMode::Normal:
         self.layer.compositingFilter = nil;
         break;
@@ -639,54 +606,6 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     needsInvalidateLayer = YES;
   }
 
-#if TARGET_OS_OSX // [macOS
-  // `acceptsFirstMouse`
-  if (oldViewProps.acceptsFirstMouse != newViewProps.acceptsFirstMouse) {
-    self.acceptsFirstMouse = newViewProps.acceptsFirstMouse;
-  }
-
-  // `mouseDownCanMoveWindow`
-  if (oldViewProps.mouseDownCanMoveWindow != newViewProps.mouseDownCanMoveWindow) {
-    self.mouseDownCanMoveWindow = newViewProps.mouseDownCanMoveWindow;
-  }
-
-  // `allowsVibrancy`
-  if (oldViewProps.allowsVibrancy != newViewProps.allowsVibrancy) {
-    _allowsVibrancy = newViewProps.allowsVibrancy;
-  }
-
-    // `draggedTypes`
-  if (oldViewProps.draggedTypes != newViewProps.draggedTypes) {
-    if (!oldViewProps.draggedTypes.empty()) {
-      [self unregisterDraggedTypes];
-    }
-
-    if (!newViewProps.draggedTypes.empty()) {
-      NSMutableArray<NSPasteboardType> *pasteboardTypes = [NSMutableArray arrayWithCapacity:newViewProps.draggedTypes.size()];
-      for (const auto &draggedType : newViewProps.draggedTypes) {
-        if (draggedType == "fileUrl") {
-          [pasteboardTypes addObject:NSFilenamesPboardType];
-        } else if (draggedType == "image") {
-          [pasteboardTypes addObject:NSPasteboardTypePNG];
-          [pasteboardTypes addObject:NSPasteboardTypeTIFF];
-        } else if (draggedType == "string") {
-          [pasteboardTypes addObject:NSPasteboardTypeString];
-        }
-      }
-      [self registerForDraggedTypes:pasteboardTypes];
-    }
-  }
-
-  // `tooltip`
-  if (oldViewProps.tooltip != newViewProps.tooltip) {
-    if (newViewProps.tooltip.has_value()) {
-      self.toolTip = RCTNSStringFromStringNilIfEmpty(newViewProps.tooltip.value());
-    } else {
-      self.toolTip = nil;
-    }
-  }
-#endif // macOS]
-
   _needsInvalidateLayer = _needsInvalidateLayer || needsInvalidateLayer;
 
   _props = std::static_pointer_cast<const ViewProps>(props);
@@ -705,6 +624,12 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   // re-applying individual sub-values which weren't changed.
   [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:_layoutMetrics];
 
+  // Capture the frame size that was used by updateProps to resolve the
+  // transform, before overwriting _layoutMetrics. This is important because
+  // _layoutMetrics may be stale (e.g., from a recycled view) and differ from
+  // the oldLayoutMetrics parameter (which comes from the shadow tree).
+  auto previousFrameSize = _layoutMetrics.frame.size;
+
   _layoutMetrics = layoutMetrics;
   _needsInvalidateLayer = YES;
 
@@ -722,8 +647,12 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     _backgroundColorLayer.frame = CGRectMake(0, 0, self.layer.bounds.size.width, self.layer.bounds.size.height);
   }
 
+  // Recompute the transform whenever the layout size differs from what was
+  // used in updateProps. Using previousFrameSize (the stored _layoutMetrics)
+  // instead of the oldLayoutMetrics parameter ensures correctness even when
+  // the view was recycled with stale dimensions.
   if ((_props->transformOrigin.isSet() || !_props->transform.operations.empty()) &&
-      layoutMetrics.frame.size != oldLayoutMetrics.frame.size) {
+      layoutMetrics.frame.size != previousFrameSize) {
     auto newTransform = _props->resolveTransform(layoutMetrics);
     self.layer.transform = RCTCATransform3DFromTransformMatrix(newTransform);
   }
@@ -753,11 +682,6 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
   _needsInvalidateLayer = NO;
   [self invalidateLayer];
-
-#if TARGET_OS_OSX // [macOS
-  [self updateTrackingAreas];
-  [self updateClipViewBoundsObserverIfNeeded];
-#endif // macOS]
 }
 
 - (void)prepareForRecycle
@@ -773,16 +697,32 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     self.layer.opacity = (float)props.opacity;
   }
 
+  // Clean up box shadow layers to prevent cross-component contamination
+  if (_boxShadowLayers != nullptr) {
+    for (CALayer *boxShadowLayer = nullptr in _boxShadowLayers) {
+      [boxShadowLayer removeFromSuperlayer];
+    }
+    [_boxShadowLayers removeAllObjects];
+    _boxShadowLayers = nil;
+  }
+
+  // Clean up other visual layers
+  [_backgroundColorLayer removeFromSuperlayer];
+  _backgroundColorLayer = nil;
+  [_borderLayer removeFromSuperlayer];
+  _borderLayer = nil;
+  [_outlineLayer removeFromSuperlayer];
+  _outlineLayer = nil;
+  [_filterLayer removeFromSuperlayer];
+  _filterLayer = nil;
+  [self clearExistingBackgroundImageLayers];
+
   _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN = nil;
   _eventEmitter.reset();
   _isJSResponder = NO;
   _removeClippedSubviews = NO;
   _reactSubviews = [NSMutableArray new];
-#if TARGET_OS_OSX // [macOS
-    _allowsVibrancy = NO;
-    self.acceptsFirstMouse = NO;
-    self.mouseDownCanMoveWindow = YES;
-#endif // macOS]
+  _layoutMetrics = {};
 }
 
 - (void)setPropKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN:(NSSet<NSString *> *_Nullable)props
@@ -795,7 +735,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   return _propKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN;
 }
 
-- (RCTPlatformView *)betterHitTest:(CGPoint)point withEvent:(UIEvent *)event // [macOS]
+- (UIView *)betterHitTest:(CGPoint)point withEvent:(UIEvent *)event
 {
   // This is a classic textbook implementation of `hitTest:` with a couple of improvements:
   //   * It does not stop algorithm if some touch is outside the view
@@ -803,19 +743,15 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   //   * Taking `layer.zIndex` field into an account is not required because
   //     lists of `ShadowView`s are already sorted based on `zIndex` prop.
 
-#if !TARGET_OS_OSX // [macOS]
   if (!self.userInteractionEnabled || self.hidden || self.alpha < 0.01) {
-#else // [macOS
-  if (!self.userInteractionEnabled || self.hidden || self.alphaValue < 0.01 ) {
-#endif // macOS]
     return nil;
   }
 
   BOOL isPointInside = [self pointInside:point withEvent:event];
 
-  RCTPlatformView *currentContainerView = self.currentContainerView; // [macOS]
+  UIView *currentContainerView = self.currentContainerView;
 
-  BOOL clipsToBounds = false; // [macOS]
+  BOOL clipsToBounds = currentContainerView.clipsToBounds;
 
   clipsToBounds = clipsToBounds || _layoutMetrics.overflowInset == EdgeInsets{};
 
@@ -823,8 +759,8 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     return nil;
   }
 
-  for (RCTPlatformView *subview = nullptr in [currentContainerView.subviews reverseObjectEnumerator]) { // [macOS]
-    RCTPlatformView *hitView = RCTUIViewHitTestWithEvent(subview, [subview convertPoint:point fromView:currentContainerView], event); // [macOS]
+  for (UIView *subview = nullptr in [currentContainerView.subviews reverseObjectEnumerator]) {
+    UIView *hitView = [subview hitTest:[subview convertPoint:point fromView:currentContainerView] withEvent:event];
     if (hitView) {
       return hitView;
     }
@@ -833,7 +769,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   return isPointInside ? self : nil;
 }
 
-- (RCTPlatformView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event // [macOS]
+- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event
 {
   switch (_props->pointerEvents) {
     case PointerEventsMode::Auto:
@@ -843,7 +779,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     case PointerEventsMode::BoxOnly:
       return [self pointInside:point withEvent:event] ? self : nil;
     case PointerEventsMode::BoxNone:
-      RCTPlatformView *view = [self betterHitTest:point withEvent:event]; // [macOS]
+      UIView *view = [self betterHitTest:point withEvent:event];
       return view != self ? view : nil;
   }
 }
@@ -883,8 +819,8 @@ static void RCTAddContourEffectToLayer(
     const UIEdgeInsets &contourInsets,
     const RCTBorderStyle &contourStyle)
 {
-  RCTUIImage *image = RCTGetBorderImage( // [macOS]
-      contourStyle, layer.bounds.size, cornerRadii, contourInsets, contourColors, [RCTUIColor clearColor], NO); // [macOS]
+  UIImage *image = RCTGetBorderImage(
+      contourStyle, layer.bounds.size, cornerRadii, contourInsets, contourColors, [UIColor clearColor], NO);
 
   if (image == nil) {
     layer.contents = nil;
@@ -943,88 +879,6 @@ static RCTBorderStyle RCTBorderStyleFromBorderStyle(BorderStyle borderStyle)
   }
 }
 
-#if TARGET_OS_OSX // [macOS
-static RCTCursor RCTCursorFromCursor(Cursor cursor)
-{
-  switch (cursor) {
-    case Cursor::Auto:
-      return RCTCursorAuto;
-    case Cursor::Alias:
-      return RCTCursorAlias;
-    case Cursor::AllScroll:
-      return RCTCursorAllScroll;
-    case Cursor::Cell:
-      return RCTCursorCell;
-    case Cursor::ColResize:
-      return RCTCursorColResize;
-    case Cursor::ContextMenu:
-      return RCTCursorContextMenu;
-    case Cursor::Copy:
-      return RCTCursorCopy;
-    case Cursor::Crosshair:
-      return RCTCursorCrosshair;
-    case Cursor::Default:
-      return RCTCursorDefault;
-    case Cursor::EResize:
-      return RCTCursorEResize;
-    case Cursor::EWResize:
-      return RCTCursorEWResize;
-    case Cursor::Grab:
-      return RCTCursorGrab;
-    case Cursor::Grabbing:
-      return RCTCursorGrabbing;
-    case Cursor::Help:
-      return RCTCursorHelp;
-    case Cursor::Move:
-      return RCTCursorMove;
-    case Cursor::NEResize:
-      return RCTCursorNEResize;
-    case Cursor::NESWResize:
-      return RCTCursorNESWResize;
-    case Cursor::NResize:
-      return RCTCursorNResize;
-    case Cursor::NSResize:
-      return RCTCursorNSResize;
-    case Cursor::NWResize:
-      return RCTCursorNWResize;
-    case Cursor::NWSEResize:
-      return RCTCursorNWSEResize;
-    case Cursor::NoDrop:
-      return RCTCursorNoDrop;
-    case Cursor::None:
-      return RCTCursorNone;
-    case Cursor::NotAllowed:
-      return RCTCursorNotAllowed;
-    case Cursor::Pointer:
-      return RCTCursorPointer;
-    case Cursor::Progress:
-      return RCTCursorProgress;
-    case Cursor::RowResize:
-      return RCTCursorRowResize;
-    case Cursor::SResize:
-      return RCTCursorSResize;
-    case Cursor::SEResize:
-      return RCTCursorSEResize;
-    case Cursor::SWResize:
-      return RCTCursorSWResize;
-    case Cursor::Text:
-      return RCTCursorText;
-    case Cursor::Url:
-      return RCTCursorUrl;
-    case Cursor::VerticalText:
-      return RCTCursorVerticalText;
-    case Cursor::WResize:
-      return RCTCursorWResize;
-    case Cursor::Wait:
-      return RCTCursorWait;
-    case Cursor::ZoomIn:
-      return RCTCursorZoomIn;
-    case Cursor::ZoomOut:
-      return RCTCursorZoomOut;
-  }
-}
-#endif // macOS]
-
 static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
 {
   switch (outlineStyle) {
@@ -1051,19 +905,19 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
 // `blur` applied, we need to wrap it in a SwiftUI view to render the effect.
 // In this case, `effectiveContentView` will be the content view inside the
 // SwiftUI wrapper.
-- (RCTPlatformView *)effectiveContentView // [macOS]
+- (UIView *)effectiveContentView
 {
   if (!ReactNativeFeatureFlags::enableSwiftUIBasedFilters()) {
     return self;
   }
 
-  RCTPlatformView *effectiveContentView = self; // [macOS]
+  UIView *effectiveContentView = self;
 
   if (self.styleNeedsSwiftUIContainer) {
     if (_swiftUIWrapper == nullptr) {
       _swiftUIWrapper = [RCTSwiftUIContainerViewWrapper new];
-      RCTPlatformView *swiftUIContentView = [[RCTPlatformView alloc] init]; // [macOS]
-      for (RCTPlatformView *subview = nullptr in self.subviews) { // [macOS]
+      UIView *swiftUIContentView = [[RCTUIView alloc] init];  // [macOS] needs a flipped, layer-backed view
+      for (UIView *subview = nullptr in self.subviews) {
         [swiftUIContentView addSubview:subview];
       }
       swiftUIContentView.clipsToBounds = self.clipsToBounds;
@@ -1080,8 +934,8 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
     effectiveContentView = _swiftUIWrapper.contentView;
   } else {
     if (_swiftUIWrapper != nullptr) {
-      RCTPlatformView *swiftUIContentView = _swiftUIWrapper.contentView; // [macOS]
-      for (RCTPlatformView *subview = nullptr in swiftUIContentView.subviews) { // [macOS]
+      UIView *swiftUIContentView = _swiftUIWrapper.contentView;
+      for (UIView *subview = nullptr in swiftUIContentView.subviews) {
         [self addSubview:subview];
       }
       self.clipsToBounds = swiftUIContentView.clipsToBounds;
@@ -1100,14 +954,14 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
 // This UIView is the UIView that holds all subviews. It is sometimes not self
 // because we want to render "overflow ink" that extends beyond the bounds of
 // the view and is not affected by clipping.
-- (RCTUIView *)currentContainerView // [macOS]
+- (UIView *)currentContainerView
 {
-  RCTPlatformView *effectiveContentView = self.effectiveContentView; // [macOS]
+  UIView *effectiveContentView = self.effectiveContentView;
 
   if (_useCustomContainerView) {
     if (!_containerView) {
-      _containerView = [[RCTPlatformView alloc] initWithFrame:CGRectMake(0, 0, self.bounds.size.width, self.bounds.size.height)]; // [macOS]
-      for (RCTPlatformView *subview = nullptr in effectiveContentView.subviews) { // [macOS]
+      _containerView = [[RCTUIView alloc] initWithFrame:CGRectMake(0, 0, self.bounds.size.width, self.bounds.size.height)];  // [macOS] needs a flipped, layer-backed view
+      for (UIView *subview = nullptr in effectiveContentView.subviews) {
         [_containerView addSubview:subview];
       }
       _containerView.clipsToBounds = effectiveContentView.clipsToBounds;
@@ -1120,7 +974,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
     effectiveContentView = _containerView;
   } else {
     if (_containerView) {
-      for (RCTPlatformView *subview in _containerView.subviews) { // [macOS]
+      for (UIView *subview in _containerView.subviews) {
         [effectiveContentView addSubview:subview];
       }
       effectiveContentView.clipsToBounds = _containerView.clipsToBounds;
@@ -1140,18 +994,6 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
     return;
   }
 
-#if TARGET_OS_OSX // [macOS
-  // On macOS, clipsToBounds doesn't automatically set layer.masksToBounds like iOS does.
-  // When _useCustomContainerView is true (boxShadow + overflow:hidden), the container
-  // view handles clipping children while the main layer stays unclipped for the shadow.
-  // The container view's masksToBounds is set in currentContainerView getter.
-  if (_useCustomContainerView) {
-    layer.masksToBounds = NO;
-  } else {
-    layer.masksToBounds = _props->getClipsContentToBounds();
-  }
-#endif // macOS]
-
   const auto borderMetrics = _props->resolveBorderMetrics(_layoutMetrics);
 
   // Stage 1. Shadow Path
@@ -1172,34 +1014,8 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
     layer.shadowPath = nil;
   }
 
-#if !TARGET_OS_OSX // [visionOS]
-  // Stage 1.5. Cursor / Hover Effects
-  if (@available(iOS 17.0, *)) {
-    UIHoverStyle *hoverStyle = nil;
-    if (_props->cursor == Cursor::Pointer) {
-      const RCTCornerInsets cornerInsets =
-          RCTGetCornerInsets(RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii), UIEdgeInsetsZero);
-#if TARGET_OS_IOS
-      // Due to an Apple bug, it seems on iOS, UIShapes made with `[UIShape shapeWithBezierPath:]`
-      // evaluate their shape on the superviews' coordinate space. This leads to the hover shape
-      // rendering incorrectly on iOS, iOS apps in compatibility mode on visionOS, but not on visionOS.
-      // To work around this, for iOS, we can calculate the border path based on `view.frame` (the
-      // superview's coordinate space) instead of view.bounds.
-      CGPathRef borderPath = RCTPathCreateWithRoundedRect(self.frame, cornerInsets, NULL, NO);
-#else // TARGET_OS_VISION
-      CGPathRef borderPath = RCTPathCreateWithRoundedRect(self.bounds, cornerInsets, NULL, NO);
-#endif
-      UIBezierPath *bezierPath = [UIBezierPath bezierPathWithCGPath:borderPath];
-      CGPathRelease(borderPath);
-      UIShape *shape = [UIShape shapeWithBezierPath:bezierPath];
-
-      hoverStyle = [UIHoverStyle styleWithEffect:[UIHoverAutomaticEffect effect] shape:shape];
-    }
-    [self setHoverStyle:hoverStyle];
-  }
-#endif // [visionOS]
-
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 170000 /* __IPHONE_17_0 */
+#if !TARGET_OS_TV && defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && \
+    __IPHONE_OS_VERSION_MAX_ALLOWED >= 170000 /* __IPHONE_17_0 */
   // Stage 1.5. Cursor / Hover Effects
   if (@available(iOS 17.0, *)) {
     UIHoverStyle *hoverStyle = nil;
@@ -1228,7 +1044,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
   const bool useCoreAnimationBorderRendering =
       borderMetrics.borderColors.isUniform() && borderMetrics.borderWidths.isUniform() &&
       borderMetrics.borderStyles.isUniform() && borderMetrics.borderStyles.left == BorderStyle::Solid &&
-      borderMetrics.borderRadii.isUniform() &&
+      areBorderRadiiCircular(borderMetrics.borderRadii) &&
       (
           // iOS draws borders in front of the content whereas CSS draws them behind
           // the content. For this reason, only use iOS border drawing when clipping
@@ -1238,11 +1054,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
            (*borderMetrics.borderColors.left).getUIColor() != nullptr));
 
   // background color
-#if !TARGET_OS_OSX // [macOS]
-  RCTUIColor *backgroundColor = [_backgroundColor resolvedColorWithTraitCollection:self.traitCollection];
-#else // [macOS
-  RCTUIColor *backgroundColor = _backgroundColor;
-#endif // macOS]
+  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
@@ -1271,13 +1083,10 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
     _borderLayer = nil;
 
     layer.borderWidth = (CGFloat)borderMetrics.borderWidths.left;
-    RCTUIColor *borderColor = RCTUIColorFromSharedColor(borderMetrics.borderColors.left); // [macOS]
+    UIColor *borderColor = RCTUIColorFromSharedColor(borderMetrics.borderColors.left);
     layer.borderColor = borderColor.CGColor;
     layer.cornerRadius = (CGFloat)borderMetrics.borderRadii.topLeft.horizontal;
-
     layer.cornerCurve = CornerCurveFromBorderCurve(borderMetrics.borderCurves.topLeft);
-
-    layer.backgroundColor = backgroundColor.CGColor;
   } else {
     if (!_borderLayer) {
       CALayer *borderLayer = [CALayer new];
@@ -1317,12 +1126,12 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
     _outlineLayer.frame = CGRectInset(
         layer.bounds, -_props->outlineOffset - _props->outlineWidth, -_props->outlineOffset - _props->outlineWidth);
 
-    if (borderMetrics.borderRadii.isUniform() && borderMetrics.borderRadii.topLeft.horizontal == 0) {
-      RCTUIColor *outlineColor = RCTUIColorFromSharedColor(_props->outlineColor); // [macOS]
+    if (areBorderRadiiCircular(borderMetrics.borderRadii) && borderMetrics.borderRadii.topLeft.horizontal == 0) {
+      UIColor *outlineColor = RCTUIColorFromSharedColor(_props->outlineColor);
       _outlineLayer.borderWidth = _props->outlineWidth;
       _outlineLayer.borderColor = outlineColor.CGColor;
     } else {
-      RCTUIColor *outlineColor = RCTUIColorFromSharedColor(_props->outlineColor); // [macOS]
+      UIColor *outlineColor = RCTUIColorFromSharedColor(_props->outlineColor);
 
       RCTAddContourEffectToLayer(
           _outlineLayer,
@@ -1348,7 +1157,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
       if (primitive.type == FilterType::DropShadow) {
         if (_swiftUIWrapper != nullptr && std::holds_alternative<DropShadowParams>(primitive.parameters)) {
           const auto &dropShadowParams = std::get<DropShadowParams>(primitive.parameters);
-          RCTUIColor *shadowColor = RCTUIColorFromSharedColor(dropShadowParams.color); // [macOS]
+          UIColor *shadowColor = RCTUIColorFromSharedColor(dropShadowParams.color);
           [_swiftUIWrapper updateDropShadow:@(dropShadowParams.standardDeviation)
                                           x:@(dropShadowParams.offsetX)
                                           y:@(dropShadowParams.offsetY)
@@ -1393,7 +1202,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
       _filterLayer = [CALayer layer];
       [self shapeLayerToMatchView:_filterLayer borderMetrics:borderMetrics];
       _filterLayer.compositingFilter = @"multiplyBlendMode";
-      _filterLayer.backgroundColor = [RCTUIColor colorWithRed:multiplicativeBrightness // [macOS]
+      _filterLayer.backgroundColor = [UIColor colorWithRed:multiplicativeBrightness
                                                      green:multiplicativeBrightness
                                                       blue:multiplicativeBrightness
                                                      alpha:self.layer.opacity]
@@ -1493,7 +1302,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
   if (self.currentContainerView.clipsToBounds) {
     BOOL clipToPaddingBox = ReactNativeFeatureFlags::enableIOSViewClipToPaddingBox();
     if (!clipToPaddingBox) {
-      if (borderMetrics.borderRadii.isUniform()) {
+      if (areBorderRadiiCircular(borderMetrics.borderRadii)) {
         self.currentContainerView.layer.cornerRadius = borderMetrics.borderRadii.topLeft.horizontal;
       } else {
         CALayer *maskLayer =
@@ -1503,8 +1312,8 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
         self.currentContainerView.layer.mask = maskLayer;
       }
 
-      for (RCTPlatformView *subview in self.currentContainerView.subviews) { // [macOS]
-        if ([subview isKindOfClass:[RCTUIImageView class]]) { // [macOS]
+      for (UIView *subview in self.currentContainerView.subviews) {
+        if ([subview isKindOfClass:[UIImageView class]]) {
           RCTCornerInsets cornerInsets = RCTGetCornerInsets(
               RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii),
               RCTUIEdgeInsetsFromEdgeInsets(borderMetrics.borderWidths));
@@ -1516,7 +1325,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
       }
     } else if (
         !borderMetrics.borderWidths.isUniform() || borderMetrics.borderWidths.left != 0 ||
-        !borderMetrics.borderRadii.isUniform()) {
+        !areBorderRadiiCircular(borderMetrics.borderRadii)) {
       CALayer *maskLayer = [self createMaskLayer:RCTCGRectFromRect(_layoutMetrics.getPaddingFrame())
                                     cornerInsets:RCTGetCornerInsets(
                                                      RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii),
@@ -1535,7 +1344,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
   // Bounds is needed here to account for scaling transforms properly and ensure
   // we do not scale twice
   layer.frame = CGRectMake(0, 0, self.layer.bounds.size.width, self.layer.bounds.size.height);
-  if (borderMetrics.borderRadii.isUniform()) {
+  if (areBorderRadiiCircular(borderMetrics.borderRadii)) {
     layer.mask = nil;
     layer.cornerRadius = borderMetrics.borderRadii.topLeft.horizontal;
     layer.cornerCurve = CornerCurveFromBorderCurve(borderMetrics.borderCurves.topLeft);
@@ -1571,11 +1380,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
 
 #pragma mark - Accessibility
 
-#if !TARGET_OS_OSX // [macOS]
 - (NSObject *)accessibilityElement
-#else // [macOS
-- (NSView *)accessibilityElement // macOS]
-#endif // macOS]
 {
   return self;
 }
@@ -1595,7 +1400,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
     return;
   }
 
-  NSMutableDictionary<NSString *, RCTPlatformView *> *nativeIdToView = [NSMutableDictionary new]; // [macOS]
+  NSMutableDictionary<NSString *, UIView *> *nativeIdToView = [NSMutableDictionary new];
   [RCTViewComponentView collectAccessibilityElements:self
                                       intoDictionary:nativeIdToView
                                            nativeIds:_accessibilityOrderNativeIDs];
@@ -1604,7 +1409,7 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
   for (const auto &childId : _props->accessibilityOrder) {
     NSString *nsStringChildId = RCTNSStringFromString(childId);
 
-    RCTPlatformView *viewWithMatchingNativeId = [nativeIdToView objectForKey:nsStringChildId]; // [macOS]
+    UIView *viewWithMatchingNativeId = [nativeIdToView objectForKey:nsStringChildId];
     if (viewWithMatchingNativeId != nil) {
       [accessibilityElements addObject:viewWithMatchingNativeId];
     }
@@ -1613,11 +1418,11 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
   self.accessibilityElements = accessibilityElements;
 }
 
-+ (void)collectAccessibilityElements:(RCTPlatformView *)view // [macOS]
-                      intoDictionary:(NSMutableDictionary<NSString *, RCTPlatformView *> *)dict // [macOS]
++ (void)collectAccessibilityElements:(UIView *)view
+                      intoDictionary:(NSMutableDictionary<NSString *, UIView *> *)dict
                            nativeIds:(NSSet<NSString *> *)nativeIds
 {
-  for (RCTPlatformView *subview in view.subviews) { // [macOS]
+  for (UIView *subview in view.subviews) {
     if ([subview isKindOfClass:[RCTViewComponentView class]] &&
         [nativeIds containsObject:((RCTViewComponentView *)subview).nativeId]) {
       [dict setObject:subview forKey:((RCTViewComponentView *)subview).nativeId];
@@ -1626,11 +1431,15 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
   }
 }
 
-static NSString *RCTRecursiveAccessibilityLabel(RCTUIView *view) // [macOS]
+static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
 {
   // Result string is initialized lazily to prevent useless but costly allocations.
   NSMutableString *result = nil;
-  for (RCTUIView *subview in view.subviews) { // [macOS]
+  for (UIView *subview in view.subviews) {
+    // Skip subviews that have accessibilityElementsHidden set to YES
+    if (subview.accessibilityElementsHidden) {
+      continue;
+    }
     NSString *label = subview.accessibilityLabel;
     if (!label) {
       label = RCTRecursiveAccessibilityLabel(subview);
@@ -1671,6 +1480,11 @@ static NSString *RCTRecursiveAccessibilityLabel(RCTUIView *view) // [macOS]
   return !super.accessibilityLabel && super.isAccessibilityElement;
 }
 
+- (BOOL)canBecomeFocused
+{
+  return _focusable;
+}
+
 - (BOOL)isAccessibilityElement
 {
   if (self.contentView != nil) {
@@ -1686,7 +1500,6 @@ static NSString *RCTRecursiveAccessibilityLabel(RCTUIView *view) // [macOS]
   const auto accessibilityState = props.accessibilityState.value_or(AccessibilityState{});
 
   // Handle Switch.
-#if !TARGET_OS_OSX // [macOS]
   if ((self.accessibilityTraits & AccessibilityTraitSwitch) == AccessibilityTraitSwitch) {
     if (accessibilityState.checked == AccessibilityState::Checked) {
       return @"1";
@@ -1694,7 +1507,6 @@ static NSString *RCTRecursiveAccessibilityLabel(RCTUIView *view) // [macOS]
       return @"0";
     }
   }
-#endif // [macOS]
 
   NSMutableArray *valueComponents = [NSMutableArray new];
   NSString *roleString = (props.role != Role::None) ? [NSString stringWithUTF8String:toString(props.role).c_str()]
@@ -1770,8 +1582,15 @@ static NSString *RCTRecursiveAccessibilityLabel(RCTUIView *view) // [macOS]
 
   NSMutableArray<UIAccessibilityCustomAction *> *customActions = [NSMutableArray array];
   for (const auto &accessibilityAction : accessibilityActions) {
+    NSString *actionName = RCTNSStringFromString(accessibilityAction.name);
+    NSString *actionLabel = actionName;
+
+    if (accessibilityAction.label.has_value()) {
+      actionLabel = RCTNSStringFromString(accessibilityAction.label.value());
+    }
+
     [customActions
-        addObject:[[UIAccessibilityCustomAction alloc] initWithName:RCTNSStringFromString(accessibilityAction.name)
+        addObject:[[UIAccessibilityCustomAction alloc] initWithName:actionLabel
                                                              target:self
                                                            selector:@selector(didActivateAccessibilityCustomAction:)]];
   }
@@ -1826,439 +1645,22 @@ static NSString *RCTRecursiveAccessibilityLabel(RCTUIView *view) // [macOS]
 - (BOOL)didActivateAccessibilityCustomAction:(UIAccessibilityCustomAction *)action
 {
   if (_eventEmitter && _props->onAccessibilityAction) {
-    _eventEmitter->onAccessibilityAction(RCTStringFromNSString(action.name));
-    return YES;
-  } else {
-    return NO;
-  }
-}
-
-#if TARGET_OS_OSX // [macOS
-
-# pragma mark - Focus Ring
-
-- (CGRect)focusRingMaskBounds
-{
-  return [self bounds];
-}
-
-- (void)drawFocusRingMask
-{
-  if (_props->enableFocusRing) {
-    CGContextRef context = NSGraphicsContext.currentContext.CGContext;
-
-    const auto borderMetrics = _props->resolveBorderMetrics(_layoutMetrics);
-    const RCTCornerInsets cornerInsets =
-        RCTGetCornerInsets(RCTCornerRadiiFromBorderRadii(borderMetrics.borderRadii), UIEdgeInsetsZero);
-    CGPathRef path = RCTPathCreateWithRoundedRect(self.bounds, cornerInsets, NULL, NO); // [macOS]
-
-    CGContextAddPath(context, path);
-    CGContextFillPath(context);
-    CGPathRelease(path);
-  }
-}
-
-- (BOOL)needsPanelToBecomeKey
-{
-	// We need to override this so that mouse clicks don't move keyboard focus on focusable views by default.
-	return false;
-}
-
-- (BOOL)acceptsFirstResponder
-{
-  return _props->focusable || [super acceptsFirstResponder];
-}
-
-#pragma mark - Keyboard Events
-
-- (BOOL)handleKeyboardEvent:(NSEvent *)event {
-  RCTAssert(
-    event.type == NSEventTypeKeyDown || event.type == NSEventTypeKeyUp,
-    @"Keyboard event must be keyDown, keyUp. Got type: %ld", (long)event.type);
-
-  // Convert the event to a KeyEvent
-  NSEventModifierFlags modifierFlags = event.modifierFlags;
-  facebook::react::KeyEvent keyEvent = {
-    .key = [[RCTViewKeyboardEvent keyFromEvent:event] UTF8String],
-    .altKey = static_cast<bool>(modifierFlags & NSEventModifierFlagOption),
-    .ctrlKey = static_cast<bool>(modifierFlags & NSEventModifierFlagControl),
-    .shiftKey = static_cast<bool>(modifierFlags & NSEventModifierFlagShift),
-    .metaKey = static_cast<bool>(modifierFlags & NSEventModifierFlagCommand),
-    .capsLockKey = static_cast<bool>(modifierFlags & NSEventModifierFlagCapsLock),
-    .numericPadKey = static_cast<bool>(modifierFlags & NSEventModifierFlagNumericPad),
-    .helpKey = static_cast<bool>(modifierFlags & NSEventModifierFlagHelp),
-    .functionKey = static_cast<bool>(modifierFlags & NSEventModifierFlagFunction),
-  };
-
-  if (_eventEmitter) {
-    // Emit the event to JS only once. By default, events, will bubble up the respnder chain
-    // when we call super, so let's emit the event only at the first responder. It would be
-    // simpler to check `if (self == self.window.firstResponder), however, that does not account
-    // for cases like TextInputComponentView, where the first responder may be a subview.
-    static const char kRCTViewKeyboardEventEmittedKey = 0;
-    NSNumber *emitted = objc_getAssociatedObject(event, &kRCTViewKeyboardEventEmittedKey);
-    BOOL alreadyEmitted = [emitted boolValue];
-    if (!alreadyEmitted) {
-      if (event.type == NSEventTypeKeyDown) {
-        _eventEmitter->onKeyDown(keyEvent);
-      } else {
-        _eventEmitter->onKeyUp(keyEvent);
-      }
-      objc_setAssociatedObject(event, &kRCTViewKeyboardEventEmittedKey, @(YES), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-    }
-  }
-
-  // If keyDownEvents or keyUpEvents specifies the event, block native handling of the event
-  auto const& handledKeyEvents = event.type == NSEventTypeKeyDown ? _props->keyDownEvents : _props->keyUpEvents;
-  return std::find(handledKeyEvents.cbegin(), handledKeyEvents.cend(), keyEvent) != handledKeyEvents.cend();
-}
-
-- (void)keyDown:(NSEvent *)event {
-  if (![self handleKeyboardEvent:event]) {
-    [super keyDown:event];
-  }
-}
-
-- (void)keyUp:(NSEvent *)event {
-  if (![self handleKeyboardEvent:event]) {
-    [super keyUp:event];
-  }
-}
-
-
-#pragma mark - Drag and Drop Events
-
-enum DragEventType {
-  DragEnter,
-  DragLeave,
-  Drop,
-};
-
-- (DataTransfer)dataTransferForPasteboard:(NSPasteboard *)pasteboard {
-  DataTransfer dataTransfer{};
-  auto &files = dataTransfer.files;
-  auto &items = dataTransfer.items;
-  auto &types = dataTransfer.types;
-
-  NSArray *fileNames = [pasteboard propertyListForType:NSFilenamesPboardType] ?: @[];
-  for (NSString *file in fileNames) {
-    NSURL *fileURL = [NSURL fileURLWithPath:file];
-    BOOL isDir = NO;
-    BOOL isValid = [[NSFileManager defaultManager] fileExistsAtPath:fileURL.path isDirectory:&isDir] && !isDir;
-    if (isValid) {
-
-      NSString *MIMETypeString = nil;
-      if (fileURL.pathExtension) {
-        CFStringRef fileExtension = (__bridge CFStringRef)fileURL.pathExtension;
-        CFStringRef UTI = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, fileExtension, NULL);
-        if (UTI != NULL) {
-          CFStringRef MIMEType = UTTypeCopyPreferredTagWithClass(UTI, kUTTagClassMIMEType);
-          CFRelease(UTI);
-          MIMETypeString = (__bridge_transfer NSString *)MIMEType;
-        }
-      }
-
-      NSNumber *fileSizeValue = nil;
-      NSError *fileSizeError = nil;
-      BOOL success = [fileURL getResourceValue:&fileSizeValue
-                                        forKey:NSURLFileSizeKey
-                                         error:&fileSizeError];
-
-      std::string typeString = MIMETypeString != nil ? [MIMETypeString UTF8String] : "";
-
-      DataTransferFile fileEntry = {
-        .name = fileURL.lastPathComponent ? fileURL.lastPathComponent.UTF8String : "",
-        .type = typeString,
-        .uri = fileURL.path ? fileURL.path.UTF8String : "",
-      };
-
-      if (success) {
-        fileEntry.size = fileSizeValue.intValue;
-      }
-
-      if ([MIMETypeString hasPrefix:@"image/"]) {
-        NSImage *image = [[NSImage alloc] initWithContentsOfURL:fileURL];
-        CGImageRef cgImage = [image CGImageForProposedRect:nil context:nil hints:nil];
-        fileEntry.width = static_cast<int>(CGImageGetWidth(cgImage));
-        fileEntry.height = static_cast<int>(CGImageGetHeight(cgImage));
+    // iOS defines the name as the localized label, so iterate through accessibilityActions to find the matching
+    // non-localized action name when passing to JS. This allows for standard action names across platforms.
+    NSString *actionName = action.name;
+    for (const auto &accessibilityAction : _props->accessibilityActions) {
+      if (accessibilityAction.label.has_value() &&
+          [RCTNSStringFromString(accessibilityAction.label.value()) isEqualToString:action.name]) {
+        actionName = RCTNSStringFromString(accessibilityAction.name);
+        break;
       }
-
-      files.push_back(fileEntry);
-      items.push_back({
-          .kind = "file",
-          .type = typeString,
-      });
-      types.push_back(typeString);
-    }
-  }
-
-  NSPasteboardType imageType = [pasteboard availableTypeFromArray:@[NSPasteboardTypePNG, NSPasteboardTypeTIFF]];
-  if (imageType && fileNames.count == 0) {
-    NSString *MIMETypeString = imageType == NSPasteboardTypePNG ?[UTTypePNG preferredMIMEType] : [UTTypeTIFF preferredMIMEType];
-    NSData *imageData = [pasteboard dataForType:imageType];
-    NSImage *image = [[NSImage alloc] initWithData:imageData];
-    CGImageRef cgImage = [image CGImageForProposedRect:nil context:nil hints:nil];
-
-    NSString *dataURLString = RCTDataURL(MIMETypeString, imageData).absoluteString;
-    std::string typeString = MIMETypeString != nil ? [MIMETypeString UTF8String] : "";
-
-    DataTransferFile fileEntry = {
-      .name = "",
-      .type = typeString,
-      .uri = dataURLString ? dataURLString.UTF8String : "",
-    };
-
-    fileEntry.size = static_cast<int>(imageData.length);
-    fileEntry.width = static_cast<int>(CGImageGetWidth(cgImage));
-    fileEntry.height = static_cast<int>(CGImageGetHeight(cgImage));
-
-    files.push_back(fileEntry);
-    items.push_back({
-        .kind = "image",
-        .type = typeString,
-    });
-    types.push_back(typeString);
-  }
-  return dataTransfer;
-}
-
-- (void)emitDragEvent:(DragEventType)eventType draggingInfo:(id<NSDraggingInfo>)sender {
-  if (!_eventEmitter) {
-    return;
-  }
-
-  NSPoint locationInWindow = sender.draggingLocation;
-  NSPasteboard *pasteboard = sender.draggingPasteboard;
-
-  DataTransfer dataTransfer = [self dataTransferForPasteboard:pasteboard];
-
-  NSPoint locationInView = [self convertPoint:locationInWindow fromView:nil];
-  NSEventModifierFlags modifierFlags = self.window.currentEvent.modifierFlags;
-
-  DragEvent dragEvent = {
-    {
-      .clientX = locationInView.x,
-      .clientY = locationInView.y,
-      .screenX = locationInWindow.x,
-      .screenY = locationInWindow.y,
-      .altKey = static_cast<bool>(modifierFlags & NSEventModifierFlagOption),
-      .ctrlKey = static_cast<bool>(modifierFlags & NSEventModifierFlagControl),
-      .shiftKey = static_cast<bool>(modifierFlags & NSEventModifierFlagShift),
-      .metaKey = static_cast<bool>(modifierFlags & NSEventModifierFlagCommand),
-    },
-    .dataTransfer = dataTransfer,
-  };
-
-  switch (eventType) {
-    case DragEnter:
-      _eventEmitter->onDragEnter(dragEvent);
-      break;
-
-    case DragLeave:
-      _eventEmitter->onDragLeave(dragEvent);
-      break;
-
-    case Drop:
-      _eventEmitter->onDrop(dragEvent);
-      break;
-  }
-}
-
-- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
-{
-  NSPasteboard *pboard = sender.draggingPasteboard;
-  NSDragOperation sourceDragMask = sender.draggingSourceOperationMask;
-
-  [self emitDragEvent:DragEnter draggingInfo:sender];
-
-  if ([pboard availableTypeFromArray:self.registeredDraggedTypes]) {
-    if (sourceDragMask & NSDragOperationLink) {
-      return NSDragOperationLink;
-    } else if (sourceDragMask & NSDragOperationCopy) {
-      return NSDragOperationCopy;
-    }
-  }
-  return NSDragOperationNone;
-}
-
-- (void)draggingExited:(id<NSDraggingInfo>)sender
-{
-  [self emitDragEvent:DragLeave draggingInfo:sender];
-}
-
-- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
-{
-  [self emitDragEvent:Drop draggingInfo:sender];
-  return YES;
-}
-
-
-#pragma mark - Mouse Events
-
-enum MouseEventType {
-  MouseEnter,
-  MouseLeave,
-  DoubleClick,
-};
-
-- (void)emitMouseEvent:(MouseEventType)eventType
-{
-  if (!_eventEmitter) {
-    return;
-  }
-
-  NSPoint locationInWindow = self.window.mouseLocationOutsideOfEventStream;
-  NSPoint locationInView = [self convertPoint:locationInWindow fromView:nil];
-
-  NSEventModifierFlags modifierFlags = self.window.currentEvent.modifierFlags;
-
-  MouseEvent mouseEvent = {
-    .clientX = locationInView.x,
-    .clientY = locationInView.y,
-    .screenX = locationInWindow.x,
-    .screenY = locationInWindow.y,
-    .altKey = static_cast<bool>(modifierFlags & NSEventModifierFlagOption),
-    .ctrlKey = static_cast<bool>(modifierFlags & NSEventModifierFlagControl),
-    .shiftKey = static_cast<bool>(modifierFlags & NSEventModifierFlagShift),
-    .metaKey = static_cast<bool>(modifierFlags & NSEventModifierFlagCommand),
-  };
-
-  switch (eventType) {
-    case MouseEnter:
-      _eventEmitter->onMouseEnter(mouseEvent);
-      break;
-
-    case MouseLeave:
-      _eventEmitter->onMouseLeave(mouseEvent);
-      break;
-
-    case DoubleClick:
-      _eventEmitter->onDoubleClick(mouseEvent);
-      break;
-  }
-}
-
-- (void)updateMouseOverIfNeeded
-{
-  // When an enclosing scrollview is scrolled using the scrollWheel or trackpad,
-  // the mouseExited: event does not get called on the view where mouseEntered: was previously called.
-  // This creates an unnatural pairing of mouse enter and exit events and can cause problems.
-  // We therefore explicitly check for this here and handle them by calling the appropriate callbacks.
-
-  BOOL hasMouseOver = _hasMouseOver;
-  NSPoint locationInWindow = self.window.mouseLocationOutsideOfEventStream;
-  NSPoint locationInView = [self convertPoint:locationInWindow fromView:nil];
-  BOOL insideBounds = NSPointInRect(locationInView, self.visibleRect);
-
-  // On macOS 14+ visibleRect can be larger than the view bounds
-  insideBounds &= NSPointInRect(locationInView, self.bounds);
-
-  if (hasMouseOver && !insideBounds) {
-    hasMouseOver = NO;
-  } else if (!hasMouseOver && insideBounds) {
-    // The window's frame view must be used for hit testing against `locationInWindow`
-    NSView *hitView = [self.window.contentView.superview hitTest:locationInWindow];
-    hasMouseOver = [hitView isDescendantOf:self];
-  }
-
-  if (hasMouseOver != _hasMouseOver) {
-    _hasMouseOver = hasMouseOver;
-    [self emitMouseEvent:hasMouseOver ? MouseEnter : MouseLeave];
-  }
-}
-
-- (void)updateClipViewBoundsObserverIfNeeded
-{
-  // Subscribe to view bounds changed notification so that the view can be notified when a
-  // scroll event occurs either due to trackpad/gesture based scrolling or a scrollwheel event
-  // both of which would not cause the mouseExited to be invoked.
-
-  NSClipView *clipView = self.window ? self.enclosingScrollView.contentView : nil;
-
-  BOOL hasMouseEventHandler =
-    _props->hostPlatformEvents[HostPlatformViewEvents::Offset::MouseEnter] ||
-    _props->hostPlatformEvents[HostPlatformViewEvents::Offset::MouseLeave];
-
-  if (_hasClipViewBoundsObserver && (!clipView || !hasMouseEventHandler)) {
-    _hasClipViewBoundsObserver = NO;
-    [[NSNotificationCenter defaultCenter] removeObserver:self
-                                                    name:NSViewBoundsDidChangeNotification
-                                                  object:nil];
-  } else if (!_hasClipViewBoundsObserver && clipView && hasMouseEventHandler) {
-    _hasClipViewBoundsObserver = YES;
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(updateMouseOverIfNeeded)
-                                                 name:NSViewBoundsDidChangeNotification
-                                               object:clipView];
-    [self updateMouseOverIfNeeded];
-  }
-}
-
-- (void)viewDidMoveToWindow
-{
-  [self updateClipViewBoundsObserverIfNeeded];
-  [super viewDidMoveToWindow];
-}
-
-- (void)updateTrackingAreas
-{
-  BOOL hasMouseEventHandler =
-    _props->hostPlatformEvents[HostPlatformViewEvents::Offset::MouseEnter] ||
-    _props->hostPlatformEvents[HostPlatformViewEvents::Offset::MouseLeave];
-  BOOL wouldRecreateIdenticalTrackingArea =
-    hasMouseEventHandler && _trackingArea && NSEqualRects(self.bounds, [_trackingArea rect]);
-
-  if (!wouldRecreateIdenticalTrackingArea) {
-    [self removeTrackingArea:_trackingArea];
-    if (hasMouseEventHandler) {
-      _trackingArea = [[NSTrackingArea alloc] initWithRect:self.bounds
-                                                   options:NSTrackingActiveAlways|NSTrackingMouseEnteredAndExited
-                                                     owner:self
-                                                  userInfo:nil];
-      [self addTrackingArea:_trackingArea];
-      [self updateMouseOverIfNeeded];
     }
-  }
-
-  [super updateTrackingAreas];
-}
-
-- (void)mouseEntered:(NSEvent *)event
-{
-  if (_hasMouseOver) {
-    return;
-  }
-
-  // The window's frame view must be used for hit testing against `locationInWindow`
-  NSView *hitView = [self.window.contentView.superview hitTest:event.locationInWindow];
-  if (![hitView isDescendantOf:self]) {
-    return;
-  }
-
-  _hasMouseOver = YES;
-  [self emitMouseEvent:MouseEnter];
-}
-
-- (void)mouseExited:(NSEvent *)event
-{
-  if (!_hasMouseOver) {
-    return;
-  }
-
-  _hasMouseOver = NO;
-  [self emitMouseEvent:MouseLeave];
-}
-
-- (void)mouseUp:(NSEvent *)event
-{
-  BOOL hasDoubleClickEventHandler = _props->hostPlatformEvents[HostPlatformViewEvents::Offset::DoubleClick];
-  if (hasDoubleClickEventHandler && event.clickCount == 2) {
-    [self emitMouseEvent :DoubleClick];
+    _eventEmitter->onAccessibilityAction(RCTStringFromNSString(actionName));
+    return YES;
   } else {
-    [super mouseUp:event];
+    return NO;
   }
 }
-#endif // macOS]
 
 - (SharedTouchEventEmitter)touchEventEmitterAtPoint:(CGPoint)point
 {
@@ -2270,11 +1672,6 @@ enum MouseEventType {
   return RCTNSStringFromString([[self class] componentDescriptorProvider].name);
 }
 
-- (BOOL)wantsUpdateLayer
-{
-  return YES;
-}
-
 - (BOOL)styleNeedsSwiftUIContainer
 {
   if (!_props->filter.empty()) {
@@ -2289,7 +1686,7 @@ enum MouseEventType {
   return NO;
 }
 
-- (void)transferVisualPropertiesFromView:(RCTPlatformView *)sourceView toView:(RCTPlatformView *)destinationView // [macOS]
+- (void)transferVisualPropertiesFromView:(UIView *)sourceView toView:(UIView *)destinationView
 {
   // shadow
   destinationView.layer.shadowColor = sourceView.layer.shadowColor;
@@ -2317,9 +1714,7 @@ enum MouseEventType {
   // corner
   destinationView.layer.cornerRadius = sourceView.layer.cornerRadius;
   sourceView.layer.cornerRadius = 0;
-#if !TARGET_OS_OSX // [macOS]
   destinationView.layer.cornerCurve = sourceView.layer.cornerCurve;
-#endif // [macOS]
 
   // custom layers
   if (_borderLayer != nullptr) {
@@ -2339,9 +1734,11 @@ enum MouseEventType {
   }
 }
 
+#pragma mark - Focus Events
+
 - (BOOL)canBecomeFirstResponder
 {
-  return YES;
+  return ReactNativeFeatureFlags::enableImperativeFocus();
 }
 
 - (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
@@ -2357,24 +1754,43 @@ enum MouseEventType {
   }
 }
 
+#if TARGET_OS_TV
+/// Finds the containing RCTSurfaceHostingProxyRootView by walking up the view
+/// hierarchy.
+- (RCTSurfaceHostingProxyRootView *)containingRootView
+{
+  UIView *view = self;
+  while (view != nil) {
+    if ([view isKindOfClass:[RCTSurfaceHostingProxyRootView class]]) {
+      return (RCTSurfaceHostingProxyRootView *)view;
+    }
+    view = view.superview;
+  }
+  return nil;
+}
+#endif
+
 - (void)focus
 {
-#if TARGET_OS_OSX // [macOS
-  [[self window] makeFirstResponder:self];
-#endif // macOS]
   [self becomeFirstResponder];
+
+#if TARGET_OS_TV
+  RCTSurfaceHostingProxyRootView *rootView = [self containingRootView];
+  if (rootView == nil) {
+    return;
+  }
+
+  rootView.reactPreferredFocusedView = self;
+  [rootView setNeedsFocusUpdate];
+  [rootView updateFocusIfNeeded];
+#endif
 }
 
 - (void)blur
 {
-#if TARGET_OS_OSX // [macOS
-  [[self window] resignFirstResponder];
-#endif // macOS]
   [self resignFirstResponder];
 }
 
-#pragma mark - Focus Events
-
 - (BOOL)becomeFirstResponder
 {
   if (![super becomeFirstResponder]) {
@@ -2401,6 +1817,30 @@ enum MouseEventType {
   return YES;
 }
 
+#if TARGET_OS_TV
+
+- (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
+       withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator
+{
+  if (context.previouslyFocusedView == context.nextFocusedView) {
+    return;
+  }
+
+  // Do not resignFirstRespodner if we lost focus, let whoever took focus
+  // becomeFirstResponder thereby resigning for us. If we resign here,
+  // first responder will be assigned to some ancestor view and they
+  // can temporarily call onFocus/onBlur
+  if (context.nextFocusedView == self) {
+    [self becomeFirstResponder];
+  } else if (context.previouslyFocusedView == self && context.nextFocusedView == nil) {
+    [self resignFirstResponder];
+  }
+
+  [super didUpdateFocusInContext:context withAnimationCoordinator:coordinator];
+}
+
+#endif
+
 @end
 
 #ifdef __cplusplus