react-native-tvos 0.84.0-0rc5 → 0.85.0-0

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.mm

@@ -30,6 +30,7 @@
 #import <React/RCTTVRemoteHandler.h>
 #import <React/RCTTVNavigationEventNotification.h>
 #import "React/RCTI18nUtil.h"
+#import "RCTViewComponentView.h"
 #endif
 
 using namespace facebook::react;
@@ -40,6 +41,7 @@ static NSString *kOnScrollEndEvent = @"onScrollEnded";
 
 static const CGFloat kClippingLeeway = 44.0;
 static const float TV_DEFAULT_SWIPE_DURATION = 0.3;
+static const CGPoint NO_PREFERRED_CONTENT_OFFSET = CGPointMake(CGFLOAT_MIN, CGFLOAT_MIN);
 
 static UIScrollViewKeyboardDismissMode RCTUIKeyboardDismissModeFromProps(const ScrollViewProps &props)
 {
@@ -97,6 +99,8 @@ RCTSendScrollEventForNativeAnimations_DEPRECATED(UIScrollView *scrollView, NSInt
     RCTScrollableProtocol,
     RCTEnhancedScrollViewOverridingDelegate>
 
+@property (nonatomic, assign) CGPoint preferredContentOffset;
+
 @end
 
 @implementation RCTScrollViewComponentView {
@@ -172,6 +176,7 @@ RCTSendScrollEventForNativeAnimations_DEPRECATED(UIScrollView *scrollView, NSInt
     _endDraggingSensitivityMultiplier = 1;
       
     _tvRemoteGestureRecognizers = [NSMutableDictionary new];
+    _preferredContentOffset = NO_PREFERRED_CONTENT_OFFSET;
   }
 
   return self;
@@ -429,6 +434,9 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
 
   scrollView.snapToStart = newScrollViewProps.snapToStart;
   scrollView.snapToEnd = newScrollViewProps.snapToEnd;
+#if TARGET_OS_TV
+  scrollView.scrollAnimationEnabled = newScrollViewProps.scrollAnimationEnabled;
+#endif
 
   if (oldScrollViewProps.snapToOffsets != newScrollViewProps.snapToOffsets) {
     NSMutableArray<NSNumber *> *snapToOffsets = [NSMutableArray array];
@@ -465,6 +473,12 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
     scrollView.keyboardDismissMode = RCTUIKeyboardDismissModeFromProps(newScrollViewProps);
   }
 
+#if TARGET_OS_TV
+  if (oldScrollViewProps.snapToAlignment != newScrollViewProps.snapToAlignment) {
+    scrollView.scrollSnapEnabled = newScrollViewProps.snapToAlignment == ScrollViewSnapToAlignment::Item;
+  }
+#endif
+
   [super updateProps:props oldProps:oldProps];
 }
 
@@ -702,6 +716,11 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
   _scrollView.contentOffset = RCTCGPointFromPoint(props.contentOffset);
   // Reset zoom scale to default
   _scrollView.zoomScale = 1.0;
+  // Invalidate cached content size so that updateState: recalculates the
+  // container frame after zoomScale reset (which may have mutated it in RTL).
+  _contentSize = CGSizeZero;
+  // Reset contentInset to prevent stale insets leaking into recycled scroll views.
+  _scrollView.contentInset = UIEdgeInsetsZero;
   // We set the default behavior to "never" so that iOS
   // doesn't do weird things to UIScrollView insets automatically
   // and keeps it as an opt-in behavior.
@@ -724,7 +743,10 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
                      withVelocity:(CGPoint)velocity
               targetContentOffset:(inout CGPoint *)targetContentOffset
 {
-  if (fabs(_endDraggingSensitivityMultiplier - 1) > 0.0001f) {
+    if (!CGPointEqualToPoint(self.preferredContentOffset, NO_PREFERRED_CONTENT_OFFSET))
+    {
+        *targetContentOffset = self.preferredContentOffset;
+    } else if (fabs(_endDraggingSensitivityMultiplier - 1) > 0.0001f) {
     if (targetContentOffset->y > 0) {
       const CGFloat travel = targetContentOffset->y - scrollView.contentOffset.y;
       targetContentOffset->y = scrollView.contentOffset.y + travel * _endDraggingSensitivityMultiplier;
@@ -1139,20 +1161,133 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
 #pragma mark Apple TV swipe and focus handling
 
 #if TARGET_OS_TV
+- (void)sendFocusEvent
+{
+  self->_eventEmitter->onFocus();
+}
+
+- (void)sendBlurEvent
+{
+  self->_eventEmitter->onBlur();
+}
+
+// Focus marker helper: traverses view hierarchy to find scrollSnapAlign prop
+// Returns the view that has the property via the output parameter
+- (NSString *)findScrollSnapAlignInView:(UIView *)view foundView:(UIView **)outView
+{
+    UIView *testView = view;
+    UIView *snapTarget;
+    NSString *marker;
+
+    while (testView && testView != self) {
+        if (![testView isKindOfClass:RCTViewComponentView.class])
+        {
+            testView = [testView superview];
+            continue;
+        }
+        RCTViewComponentView *componentView = (RCTViewComponentView *)testView;
+
+        const auto &viewProps = static_cast<const facebook::react::BaseViewProps &>(*componentView.props);
+        if (viewProps.scrollSnapAlign.has_value() && !viewProps.scrollSnapAlign.value().empty()) {
+            marker = [NSString stringWithUTF8String:viewProps.scrollSnapAlign.value().c_str()];
+            snapTarget = componentView;
+        }
+
+        testView = [testView superview];
+    }
+    *outView = snapTarget;
+    return marker;
+}
+
+- (void)_handleScrollSnapForFocusedView:(UIView *)focusedView
+{
+    const auto &scrollProps = static_cast<const ScrollViewProps &>(*_props);
+    UIView *snapAlignView = nil;
+    NSString *scrollSnapAlign = [self findScrollSnapAlignInView:focusedView foundView:&snapAlignView];
+    if (scrollSnapAlign == nil || snapAlignView == nil) {
+        return;
+    }
+
+    RCTEnhancedScrollView *scrollView = (RCTEnhancedScrollView *)_scrollView;
+    CGRect focusedFrame = [snapAlignView convertRect:snapAlignView.bounds toView:_scrollView];
+    CGFloat targetOffset;
+    CGFloat snapToItemPadding = scrollProps.snapToItemPadding;
+
+    BOOL isHorizontalSnap = _scrollView.contentSize.width > self.frame.size.width;
+    // Determine axis-specific properties
+    CGFloat viewportSize, focusedOrigin, focusedSize, currentOffset, maxContentSize;
+    if (isHorizontalSnap) {
+        viewportSize = scrollView.bounds.size.width;
+        focusedOrigin = focusedFrame.origin.x;
+        focusedSize = focusedFrame.size.width;
+        currentOffset = scrollView.contentOffset.x;
+        maxContentSize = scrollView.contentSize.width;
+    } else {
+        viewportSize = scrollView.bounds.size.height;
+        focusedOrigin = focusedFrame.origin.y;
+        focusedSize = focusedFrame.size.height;
+        currentOffset = scrollView.contentOffset.y;
+        maxContentSize = scrollView.contentSize.height;
+    }
+    // Calculate target offset based on scrollSnapAlign (unified for both axes)
+    if ([scrollSnapAlign isEqualToString:@"start"]) {
+        targetOffset = focusedOrigin - snapToItemPadding;
+    } else if ([scrollSnapAlign isEqualToString:@"center"]) {
+        CGFloat viewportCenter = viewportSize / 2;
+        CGFloat focusedCenter = focusedOrigin + (focusedSize / 2);
+        targetOffset = focusedCenter - viewportCenter + (snapToItemPadding / 2);
+    } else if ([scrollSnapAlign isEqualToString:@"end"]) {
+        targetOffset = (focusedOrigin + focusedSize) - viewportSize + snapToItemPadding;
+    } else {
+        targetOffset = currentOffset;
+    }
+
+    // Apply snap-to-interval if configured
+    if (scrollView.snapToInterval > 0) {
+        CGFloat interval = scrollView.snapToInterval;
+        targetOffset = floor(targetOffset / interval) * interval;
+    }
+
+    // Clamp to valid range
+    CGFloat maxOffset = MAX(maxContentSize - viewportSize, 0);
+    targetOffset = MAX(0, MIN(targetOffset, maxOffset));
+    CGPoint targetContentOffset = isHorizontalSnap
+        ? CGPointMake(targetOffset, scrollView.contentOffset.y)
+        : CGPointMake(scrollView.contentOffset.x, targetOffset);
+    self.preferredContentOffset = targetContentOffset;
+    [_scrollView setContentOffset:targetContentOffset animated:scrollProps.scrollAnimationEnabled];
+}
+
 - (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
        withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator
 {
-    if (context.previouslyFocusedView == context.nextFocusedView || !_props->isTVSelectable) {
+    self.preferredContentOffset = NO_PREFERRED_CONTENT_OFFSET;
+    const auto &scrollProps = static_cast<const ScrollViewProps &>(*_props);
+    BOOL hasItemSnapAlignment = scrollProps.snapToAlignment == ScrollViewSnapToAlignment::Item;
+    if (context.previouslyFocusedView == context.nextFocusedView) {
         return;
     }
-    if (context.nextFocusedView == self) {
+    if (!_props->isTVSelectable && !hasItemSnapAlignment) {
+        if (!scrollProps.scrollAnimationEnabled && [context.nextFocusedView isDescendantOfView:_scrollView]) {
+            // When animations are disabled and there's no snap alignment, manually scroll
+            // the focused view into view instantly. We can't let UIScrollView's default
+            // focus handling do this because it uses deceleration (timer-based) that can't
+            // be blocked by the animation-blocking layer.
+            CGRect targetRect = [context.nextFocusedView convertRect:context.nextFocusedView.bounds toView:_scrollView];
+            [_scrollView scrollRectToVisible:targetRect animated:NO];
+        }
+        return;
+    }
+    if (_props->isTVSelectable && context.nextFocusedView == self) {
         [self becomeFirstResponder];
         [self addSwipeGestureRecognizers];
+        [self sendFocusEvent];
         // if we enter the scroll view from different view then block first touch event since it is the event that triggered the focus
         _blockFirstTouch = (unsigned long)context.focusHeading != 0;
         [self addArrowsListeners];
-    } else if (context.previouslyFocusedView == self) {
+    } else if (_props->isTVSelectable && context.previouslyFocusedView == self) {
         [self removeArrowsListeners];
+        [self sendBlurEvent];
         [self removeSwipeGestureRecognizers];
         [self resignFirstResponder];
         // If scrolling is enabled:
@@ -1173,6 +1308,8 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
                 [self scrollToHorizontalOffset:scrollView.contentSize.width];
             }
         }
+    } else if ([context.nextFocusedView isDescendantOfView:_scrollView]) {
+        [self _handleScrollSnapForFocusedView:context.nextFocusedView];
     }
 }
 
@@ -1306,10 +1443,16 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         limitedOffset = MAX(limitedOffset, 0.0);
         limitedOffset = MIN(limitedOffset, maxOffset);
 
-        [UIView animateWithDuration:[self swipeDuration] animations:^{
+        const auto &scrollProps = static_cast<const ScrollViewProps &>(*self->_props);
+        if (scrollProps.scrollAnimationEnabled) {
+            [UIView animateWithDuration:[self swipeDuration] animations:^{
+                self.scrollView.contentOffset =
+                CGPointMake(self.scrollView.contentOffset.x, limitedOffset);
+            }];
+        } else {
             self.scrollView.contentOffset =
             CGPointMake(self.scrollView.contentOffset.x, limitedOffset);
-        }];
+        }
     });
 }
 
@@ -1330,10 +1473,16 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         limitedOffset = MAX(limitedOffset, 0.0);
         limitedOffset = MIN(limitedOffset, maxOffset);
 
-        [UIView animateWithDuration:[self swipeDuration] animations:^{
+        const auto &scrollProps = static_cast<const ScrollViewProps &>(*self->_props);
+        if (scrollProps.scrollAnimationEnabled) {
+            [UIView animateWithDuration:[self swipeDuration] animations:^{
+                self.scrollView.contentOffset =
+                CGPointMake(limitedOffset, self.scrollView.contentOffset.y);
+            }];
+        } else {
             self.scrollView.contentOffset =
             CGPointMake(limitedOffset, self.scrollView.contentOffset.y);
-        }];
+        }
     });
 }
 

package/React/Fabric/Mounting/ComponentViews/Switch/RCTSwitchComponentView.mm

@@ -18,17 +18,22 @@
 
 using namespace facebook::react;
 
+@interface RCTSwitchComponentView () <RCTSwitchViewProtocol>
+@end
+
 #if TARGET_OS_TV
 
-@implementation RCTSwitchComponentView
+@implementation RCTSwitchComponentView {
+}
+
+- (void)setValue:(BOOL)value
+{
+}
 
 @end
 
 #else
 
-@interface RCTSwitchComponentView () <RCTSwitchViewProtocol>
-@end
-
 @implementation RCTSwitchComponentView {
   UISwitch *_switchView;
   BOOL _isInitialValueSet;
@@ -135,7 +140,7 @@ using namespace facebook::react;
 
 @end
 
-#endif // TARGET_OS_TV
+#endif
 
 Class<RCTComponentViewProtocol> RCTSwitchCls(void)
 {

package/React/Fabric/Mounting/ComponentViews/Text/RCTParagraphComponentView.mm

@@ -39,6 +39,9 @@ using namespace facebook::react;
 
 @property (nonatomic, nullable) UIEditMenuInteraction *editMenuInteraction API_AVAILABLE(ios(16.0));
 
+@end
+#else
+@interface RCTParagraphComponentView ()
 @end
 #endif
 
@@ -282,6 +285,7 @@ using namespace facebook::react;
 
 #pragma mark - Context Menu
 
+#if !TARGET_OS_TV
 - (void)enableContextMenu
 {
 #if !TARGET_OS_TV
@@ -367,6 +371,15 @@ using namespace facebook::react;
   pasteboard.items = @[ item ];
 #endif
 }
+#else
+- (void)enableContextMenu
+{
+}
+
+- (void)disableContextMenu
+{
+}
+#endif
 
 @end
 

package/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputComponentView.mm

@@ -30,18 +30,15 @@ static const CGFloat kSingleLineKeyboardBottomOffset = 15.0;
 
 using namespace facebook::react;
 
-#if TARGET_OS_TV
 @interface RCTTextInputComponentView () <
     RCTBackedTextInputDelegate,
-    RCTTextInputViewProtocol>
-@end
-#else
-@interface RCTTextInputComponentView () <
-    RCTBackedTextInputDelegate,
-    RCTTextInputViewProtocol,
-    UIDropInteractionDelegate>
-@end
+    RCTTextInputViewProtocol
+#if !TARGET_OS_TV
+    ,
+    UIDropInteractionDelegate
 #endif
+    >
+@end
 
 static NSSet<NSNumber *> *returnKeyTypesSet;
 
@@ -225,7 +222,7 @@ static NSSet<NSNumber *> *returnKeyTypesSet;
         RCTUITextViewDataDetectorTypesFromStringVector(newTextInputProps.traits.dataDetectorTypes);
   }
 #endif
-  
+
   if (newTextInputProps.traits.enablesReturnKeyAutomatically !=
       oldTextInputProps.traits.enablesReturnKeyAutomatically) {
     _backedTextInputView.enablesReturnKeyAutomatically = newTextInputProps.traits.enablesReturnKeyAutomatically;
@@ -692,11 +689,10 @@ static NSSet<NSNumber *> *returnKeyTypesSet;
                                                                   action:@selector(handleInputAccessoryDoneButton)];
     toolbarView.items = @[ flexibleSpace, doneButton ];
     _backedTextInputView.inputAccessoryView = toolbarView;
-  } else
-#endif
-  {
+  } else {
     _backedTextInputView.inputAccessoryView = nil;
   }
+#endif
 
   if (_backedTextInputView.isFirstResponder) {
     [_backedTextInputView reloadInputViews];

package/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputUtils.h

@@ -41,6 +41,8 @@ UITextInputPasswordRules *RCTUITextInputPasswordRulesFromString(const std::strin
 
 UITextSmartInsertDeleteType RCTUITextSmartInsertDeleteTypeFromOptionalBool(std::optional<bool> smartInsertDelete);
 
+#if !TARGET_OS_TV
 UIDataDetectorTypes RCTUITextViewDataDetectorTypesFromStringVector(const std::vector<std::string> &dataDetectorTypes);
+#endif
 
 NS_ASSUME_NONNULL_END

package/React/Fabric/Mounting/ComponentViews/TextInput/RCTTextInputUtils.mm

@@ -271,6 +271,7 @@ UITextSmartInsertDeleteType RCTUITextSmartInsertDeleteTypeFromOptionalBool(std::
       : UITextSmartInsertDeleteTypeDefault;
 }
 
+#if !TARGET_OS_TV
 UIDataDetectorTypes RCTUITextViewDataDetectorTypesFromStringVector(const std::vector<std::string> &dataDetectorTypes)
 {
 #if TARGET_OS_TV
@@ -302,3 +303,4 @@ UIDataDetectorTypes RCTUITextViewDataDetectorTypesFromStringVector(const std::ve
   return ret;
 #endif
 }
+#endif

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

@@ -80,6 +80,8 @@ NS_ASSUME_NONNULL_BEGIN
 @property(nonatomic, nullable) UIFocusGuide *focusGuideLeft;
 @property(nonatomic, nullable) UIFocusGuide *focusGuideRight;
 @property(nonatomic, nullable, strong) RCTTVRemoteSelectHandler *tvRemoteSelectHandler;
+
+- (NSString *)scrollSnapAlign;
 #endif
 
 /**

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

@@ -87,7 +87,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   BOOL _trapFocusRight;
   NSArray* _focusDestinations;
   id<UIFocusItem> _previouslyFocusedItem;
+  NSString *_scrollSnapAlign;
   RCTSwiftUIContainerViewWrapper *_swiftUIWrapper;
+  BOOL _shouldFocusOnMount;
 }
 
 #ifdef RCT_DYNAMIC_FRAMEWORKS
@@ -102,6 +104,9 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   if (self = [super initWithFrame:frame]) {
     _props = ViewShadowNode::defaultSharedProps();
     _reactSubviews = [NSMutableArray new];
+#if !TARGET_OS_TV
+    self.multipleTouchEnabled = YES;
+#endif
     _useCustomContainerView = NO;
     _removeClippedSubviews = NO;
 #if TARGET_OS_TV
@@ -113,8 +118,8 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
     _tvParallaxProperties.pressMagnification = 1.0f;
     _tvParallaxProperties.pressDuration = 0.3f;
     _tvParallaxProperties.pressDelay = 0.0f;
-#else
-    self.multipleTouchEnabled = YES;
+    
+    _shouldFocusOnMount = false;
 #endif
   }
   return self;
@@ -170,6 +175,15 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 
 #pragma mark - Apple TV methods
 
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+
+  if (self->_shouldFocusOnMount) {
+    self->_shouldFocusOnMount = false;
+    [self focusSelf];
+  }
+}
+
 - (RCTSurfaceHostingProxyRootView *)containingRootView
 {
   UIView *rootview = self;
@@ -205,10 +219,8 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   if (!focusedSync) {
     // `focusSelf` function relies on `rootView` which may not be present on the first render.
     // `focusSelf` fails and returns `false` in that case. We try re-executing the same action
-    // by putting it to the main queue to make sure it runs after UI creation is completed.
-    dispatch_async(dispatch_get_main_queue(), ^{
-      [self focusSelf];
-    });
+    // when the view has moved to the window. This is tracked by the `_shouldFocusOnMount` flag.
+    self->_shouldFocusOnMount = true;
   }
 }
 
@@ -431,6 +443,13 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   _motionEffectsAdded = NO;
 }
 
+- (NSString *)scrollSnapAlign
+{
+#if TARGET_OS_TV
+  return _scrollSnapAlign;
+#endif
+  return nil;
+}
 
 - (BOOL)isTVFocusGuide
 {
@@ -902,6 +921,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
 #if !TARGET_OS_TV
   // `accessibilityShowsLargeContentViewer`
   if (oldViewProps.accessibilityShowsLargeContentViewer != newViewProps.accessibilityShowsLargeContentViewer) {
+#if !TARGET_OS_TV
     if (@available(iOS 13.0, *)) {
       if (newViewProps.accessibilityShowsLargeContentViewer) {
         self.showsLargeContentViewer = YES;
@@ -911,13 +931,16 @@ 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
 
@@ -1160,6 +1183,15 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   _trapFocusDown = newViewProps.trapFocusDown;
   _trapFocusLeft = newViewProps.trapFocusLeft;
   _trapFocusRight = newViewProps.trapFocusRight;
+
+  // `scrollSnapAlign`
+  if (oldViewProps.scrollSnapAlign != newViewProps.scrollSnapAlign) {
+    if (newViewProps.scrollSnapAlign.has_value()) {
+      _scrollSnapAlign = [[NSString alloc] initWithUTF8String:newViewProps.scrollSnapAlign.value().c_str()];
+    } else {
+      _scrollSnapAlign = nil;
+    }
+  }
 #endif
 
   _needsInvalidateLayer = _needsInvalidateLayer || needsInvalidateLayer;
@@ -1185,6 +1217,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;
 
@@ -1202,8 +1240,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);
   }
@@ -1287,6 +1329,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   _isJSResponder = NO;
   _removeClippedSubviews = NO;
   _reactSubviews = [NSMutableArray new];
+  _layoutMetrics = {};
 }
 
 - (void)setPropKeysManagedByAnimated_DO_NOT_USE_THIS_IS_BROKEN:(NSSet<NSString *> *_Nullable)props
@@ -1578,7 +1621,8 @@ static RCTBorderStyle RCTBorderStyleFromOutlineStyle(OutlineStyle outlineStyle)
     layer.shadowPath = nil;
   }
 
-#if defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && __IPHONE_OS_VERSION_MAX_ALLOWED >= 170000 /* __IPHONE_17_0 */ && !TARGET_OS_TV
+#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;
@@ -1999,6 +2043,10 @@ static NSString *RCTRecursiveAccessibilityLabel(UIView *view)
   // Result string is initialized lazily to prevent useless but costly allocations.
   NSMutableString *result = nil;
   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);

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

@@ -8,10 +8,11 @@
 #import <UIKit/UIKit.h>
 
 #import <React/RCTViewComponentView.h>
+#import <React/RCTVirtualViewProtocol.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
-@interface RCTVirtualViewComponentView : RCTViewComponentView
+@interface RCTVirtualViewComponentView : RCTViewComponentView <RCTVirtualViewProtocol>
 
 + (instancetype)new NS_UNAVAILABLE;
 - (instancetype)init NS_UNAVAILABLE;