react-native-tvos 0.83.4-0 → 0.83.4-2

package/Libraries/Components/ScrollView/AndroidHorizontalScrollViewNativeComponent.js

@@ -59,6 +59,7 @@ export const __INTERNAL_VIEW_CONFIG: PartialViewConfig = {
       process: require('../../StyleSheet/processColor').default,
     },
     snapToItemPadding: true,
+    scrollAnimationEnabled: true,
     pointerEvents: true,
   },
 };

package/Libraries/Components/ScrollView/ScrollView.d.ts

@@ -745,6 +745,13 @@ export interface ScrollViewProps
    */
   removeClippedSubviews?: boolean | undefined;
 
+  /**
+   * (TV only)
+   * When false, the scroll view will jump to the correct offset without animation
+   * when focus changes. Defaults to true.
+   */
+  scrollAnimationEnabled?: boolean | undefined;
+
   /**
    * When true, shows a horizontal scroll indicator.
    */

package/Libraries/Components/ScrollView/ScrollView.js

@@ -662,6 +662,12 @@ type ScrollViewBaseProps = $ReadOnly<{
    * true.
    */
   removeClippedSubviews?: ?boolean,
+  /**
+   * (TV only)
+   * When false, the scroll view will jump to the correct offset without animation
+   * when focus changes. Defaults to true.
+   */
+  scrollAnimationEnabled?: ?boolean,
   /**
    * A RefreshControl component, used to provide pull-to-refresh
    * functionality for the ScrollView. Only works for vertical ScrollViews

package/Libraries/Components/ScrollView/ScrollViewNativeComponent.js

@@ -87,6 +87,7 @@ export const __INTERNAL_VIEW_CONFIG: PartialViewConfig =
             process: require('../../StyleSheet/processColor').default,
           },
           snapToItemPadding: true,
+          scrollAnimationEnabled: true,
           pointerEvents: true,
           isInvertedVirtualizedList: true,
         },
@@ -152,6 +153,7 @@ export const __INTERNAL_VIEW_CONFIG: PartialViewConfig =
           scrollsToTop: true,
           showsHorizontalScrollIndicator: true,
           showsVerticalScrollIndicator: true,
+          scrollAnimationEnabled: true,
           showsScrollIndex: true,
           snapToItemPadding: true,
           snapToAlignment: true,

package/Libraries/Components/ScrollView/ScrollViewNativeComponentType.js

@@ -72,6 +72,7 @@ export type ScrollViewNativeProps = $ReadOnly<{
   snapToItemPadding?: ?number,
   sendMomentumEvents?: ?boolean,
   showsHorizontalScrollIndicator?: ?boolean,
+  scrollAnimationEnabled?: ?boolean,
   showsScrollIndex?: ?boolean,
   showsVerticalScrollIndicator?: ?boolean,
   snapToAlignment?: ?('start' | 'center' | 'end' | 'item'),

package/Libraries/Core/ReactNativeVersion.js

@@ -29,7 +29,7 @@ export default class ReactNativeVersion {
   static major: number = 0;
   static minor: number = 83;
   static patch: number = 4;
-  static prerelease: string | null = '0';
+  static prerelease: string | null = '2';
 
   static getVersionString(): string {
     return `${this.major}.${this.minor}.${this.patch}${this.prerelease != null ? `-${this.prerelease}` : ''}`;

package/README.md

@@ -262,6 +262,58 @@ class Game2048 extends React.Component {
   
   - _TVTextScrollView_: On Apple TV, a ScrollView will not scroll unless there are focusable items inside it or above/below it.  This component works on both Apple TV and Android TV, using native code to allow scrolling using swipe gestures from the remote control.
 
+  - _ScrollView snap alignment_: The existing `snapToAlignment` prop has been extended with a new `'item'` value that enables per-item snap alignment on TV. Instead of snapping all items uniformly to `'start'`, `'center'`, or `'end'`, each child can specify its own alignment via the `scrollSnapAlign` View prop. Optional padding can be applied with `snapToItemPadding` on the ScrollView.
+
+  | Prop (ScrollView) | Value | Description |
+  |---|---|---|
+  | snapToAlignment | `'item'` | Enables per-item snap alignment (TV only). Requires `snapToInterval` to be set. |
+  | snapToItemPadding | number? | Extra padding (in dp/pt) applied around items when snapping. Only used with `snapToAlignment="item"`. |
+
+  | Prop (View) | Value | Description |
+  |---|---|---|
+  | scrollSnapAlign | `'start'` \| `'center'` \| `'end'` | Controls where this item snaps inside its parent ScrollView. Only used when the parent has `snapToAlignment="item"`. |
+
+  ```jsx
+  <ScrollView
+    horizontal
+    snapToInterval={300}
+    snapToAlignment="item"
+    snapToItemPadding={20}>
+    <Pressable scrollSnapAlign="start" style={{width: 300}}>
+      <Text>Snaps to start</Text>
+    </Pressable>
+    <Pressable scrollSnapAlign="center" style={{width: 200}}>
+      <Text>Snaps to center</Text>
+    </Pressable>
+    <Pressable scrollSnapAlign="end" style={{width: 300}}>
+      <Text>Snaps to end</Text>
+    </Pressable>
+  </ScrollView>
+  ```
+
+  - _ScrollView animation control_: The `scrollAnimationEnabled` prop allows disabling scroll animations when focus changes on TV. When set to `false`, the scroll view jumps instantly to the focused item instead of animating. This only affects TV platforms and has no effect on mobile.
+
+  | Prop (ScrollView) | Value | Description |
+  |---|---|---|
+  | scrollAnimationEnabled | boolean? | When `false`, disables animated scrolling on focus change. Defaults to `true`. TV only. |
+
+  ```jsx
+  <ScrollView horizontal scrollAnimationEnabled={false}>
+    <Pressable style={{width: 300}}><Text>Item 1</Text></Pressable>
+    <Pressable style={{width: 300}}><Text>Item 2</Text></Pressable>
+    <Pressable style={{width: 300}}><Text>Item 3</Text></Pressable>
+  </ScrollView>
+  ```
+
+  - _Interaction with existing ScrollView props_: The TV scroll props build on top of existing React Native ScrollView behavior. Here is how they interact:
+
+    - `snapToAlignment="item"` does not require `snapToInterval` to be set. It works as a standalone snapping mode where each child's `scrollSnapAlign` determines the snap position. If `snapToInterval` is also set, the interval is applied as an additional constraint after the item offset is computed.
+    - `snapToAlignment="item"` should not be combined with `pagingEnabled`. Both attempt to control scroll positioning independently, which leads to unpredictable behavior. Use one or the other.
+    - `snapToStart` and `snapToEnd` work independently of `snapToAlignment="item"`. They control edge behavior during swipe/drag momentum (whether the scroll view snaps to the first or last position), but do not affect focus driven item snapping.
+    - `scrollAnimationEnabled={false}` disables all scroll animations, including programmatic `scrollTo({animated: true})` calls. When disabled, all scrolling is instant.
+    - `decelerationRate` has no effect when `scrollAnimationEnabled={false}`, since there is no animation to decelerate.
+    - `scrollAnimationEnabled` and `snapToAlignment="item"` work well together. Snapping still occurs, but instantly instead of animated.
+
   - _VirtualizedList_: We extend `VirtualizedList` to make virtualization work well with focus management in mind. All of the improvements that we made are automatically available to all the VirtualizedList based components such as `FlatList`.
     - Defaults: VirtualizeList contents are automatically wrapped with a `TVFocusGuideView` with `trapFocus*` properties enabled depending on the orientation of the list. This default makes sure that focus doesn't leave the list accidentally due to a virtualization issue etc. until reaching the beginning or the end of the list.
     - New Props:

package/React/Base/RCTVersion.m

@@ -24,7 +24,7 @@ NSDictionary* RCTGetReactNativeVersion(void)
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(83),
                   RCTVersionPatch: @(4),
-                  RCTVersionPrerelease: @"0",
+                  RCTVersionPrerelease: @"2",
                   };
   });
   return __rnVersion;

package/React/Fabric/Mounting/ComponentViews/ScrollView/RCTEnhancedScrollView.h

@@ -52,6 +52,7 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) BOOL snapToEnd;
 @property (nonatomic, copy) NSArray<NSNumber *> *snapToOffsets;
 @property (nonatomic, assign) BOOL scrollSnapEnabled;
+@property (nonatomic, assign) BOOL scrollAnimationEnabled;
 
 /*
  * Makes `setContentOffset:` method no-op when given `block` is executed.

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

@@ -9,6 +9,28 @@
 #import <React/RCTUtils.h>
 #import <react/utils/FloatComparison.h>
 
+#if TARGET_OS_TV
+// Layer subclass that can block all animations when scrollAnimationEnabled is NO.
+// This intercepts animations at the point they're added to the layer, which catches
+// all animation sources: UIView animations, focus coordinator animations, and
+// Core Animation implicit/explicit animations.
+@interface RCTScrollViewLayer : CALayer
+@property (nonatomic, assign) BOOL blockAnimations;
+@end
+
+@implementation RCTScrollViewLayer
+
+- (void)addAnimation:(CAAnimation *)anim forKey:(NSString *)key
+{
+  if (_blockAnimations) {
+    return;
+  }
+  [super addAnimation:anim forKey:key];
+}
+
+@end
+#endif
+
 @interface RCTEnhancedScrollView () <UIScrollViewDelegate>
 @end
 
@@ -17,6 +39,13 @@
   BOOL _isSetContentOffsetDisabled;
 }
 
+#if TARGET_OS_TV
++ (Class)layerClass
+{
+  return [RCTScrollViewLayer class];
+}
+#endif
+
 + (BOOL)automaticallyNotifiesObserversForKey:(NSString *)key
 {
   if ([key isEqualToString:@"delegate"]) {
@@ -28,9 +57,18 @@
   return [super automaticallyNotifiesObserversForKey:key];
 }
 
+- (void)setScrollAnimationEnabled:(BOOL)scrollAnimationEnabled
+{
+  _scrollAnimationEnabled = scrollAnimationEnabled;
+#if TARGET_OS_TV
+  ((RCTScrollViewLayer *)self.layer).blockAnimations = !scrollAnimationEnabled;
+#endif
+}
+
 - (instancetype)initWithFrame:(CGRect)frame
 {
   if (self = [super initWithFrame:frame]) {
+    _scrollAnimationEnabled = YES;
     // 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.
@@ -102,6 +140,46 @@
       RCTSanitizeNaNValue(contentOffset.y, @"scrollView.contentOffset.y"));
 }
 
+- (void)setContentOffset:(CGPoint)contentOffset animated:(BOOL)animated
+{
+  if (_isSetContentOffsetDisabled) {
+    return;
+  }
+#if TARGET_OS_TV
+  animated = animated && _scrollAnimationEnabled;
+#endif
+  [super setContentOffset:CGPointMake(
+      RCTSanitizeNaNValue(contentOffset.x, @"scrollView.contentOffset.x"),
+      RCTSanitizeNaNValue(contentOffset.y, @"scrollView.contentOffset.y"))
+                 animated:animated];
+}
+
+- (void)scrollRectToVisible:(CGRect)rect animated:(BOOL)animated
+{
+#if TARGET_OS_TV
+  animated = animated && _scrollAnimationEnabled;
+#endif
+  [super scrollRectToVisible:rect animated:animated];
+}
+
+#if TARGET_OS_TV
+- (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
+       withAnimationCoordinator:(UIFocusAnimationCoordinator *)coordinator
+{
+  if (_scrollAnimationEnabled) {
+    [super didUpdateFocusInContext:context withAnimationCoordinator:coordinator];
+    return;
+  }
+
+  // When scrollAnimationEnabled is NO, don't call super and don't scroll here.
+  // RCTScrollViewComponentView.didUpdateFocusInContext handles all scrolling
+  // (both snap and non-snap cases) when animation is disabled. Scrolling here
+  // as well would cause conflicts — e.g. at the end of a snapToInterval list,
+  // this method computes a "just make visible" position while the component view
+  // computes the correct snapped position, causing a bounce effect.
+}
+#endif
+
 - (void)setFrame:(CGRect)frame
 {
   [super setFrame:frame];

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

@@ -434,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];
@@ -1235,7 +1238,7 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         ? CGPointMake(targetOffset, scrollView.contentOffset.y)
         : CGPointMake(scrollView.contentOffset.x, targetOffset);
     self.preferredContentOffset = targetContentOffset;
-    [_scrollView setContentOffset:targetContentOffset animated:YES];
+    [_scrollView setContentOffset:targetContentOffset animated:scrollProps.scrollAnimationEnabled];
 }
 
 - (void)didUpdateFocusInContext:(UIFocusUpdateContext *)context
@@ -1244,7 +1247,18 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
     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 || (!_props->isTVSelectable && !hasItemSnapAlignment)) {
+    if (context.previouslyFocusedView == context.nextFocusedView) {
+        return;
+    }
+    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) {
@@ -1410,10 +1424,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);
-        }];
+        }
     });
 }
 
@@ -1434,10 +1454,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/Views/ScrollView/RCTScrollViewManager.m

@@ -106,6 +106,7 @@ RCT_EXPORT_VIEW_PROPERTY(onMomentumScrollEnd, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(inverted, BOOL)
 #if TARGET_OS_TV
 RCT_EXPORT_VIEW_PROPERTY(showsScrollIndex, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(scrollAnimationEnabled, BOOL)
 #endif
 RCT_EXPORT_VIEW_PROPERTY(automaticallyAdjustsScrollIndicatorInsets, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(contentInsetAdjustmentBehavior, UIScrollViewContentInsetAdjustmentBehavior)

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.83.4-0
+VERSION_NAME=0.83.4-2
 react.internal.publishingGroup=io.github.react-native-tvos
 react.internal.hermesPublishingGroup=com.facebook.hermes
 

package/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsDefaults.kt

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<303c55a883b4798288716d168ce82d06>>
+ * @generated SignedSource<<5a6e678b586f0ad291c6a4d090dce5b5>>
  */
 
 /**
@@ -53,7 +53,7 @@ public open class ReactNativeFeatureFlagsDefaults : ReactNativeFeatureFlagsProvi
 
   override fun enableCppPropsIteratorSetter(): Boolean = false
 
-  override fun enableCustomFocusSearchOnClippedElementsAndroid(): Boolean = true
+  override fun enableCustomFocusSearchOnClippedElementsAndroid(): Boolean = false
 
   override fun enableDestroyShadowTreeRevisionAsync(): Boolean = false
 

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.kt

@@ -15,6 +15,6 @@ public object ReactNativeVersion {
     "major" to 0,
     "minor" to 83,
     "patch" to 4,
-    "prerelease" to "0"
+    "prerelease" to "2"
   )
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/common/UiModeUtils.kt

@@ -7,12 +7,32 @@
 
 package com.facebook.react.views.common
 
+import android.app.UiModeManager
 import android.content.Context
 import android.content.res.Configuration
 
 /** Utility object providing static methods for working with UI mode properties from Context. */
 internal object UiModeUtils {
 
+  private var isTVDeviceCached: Boolean? = null
+
+  /**
+   * Determines whether the device is a TV (Android TV / Fire TV).
+   * The result is cached after the first call.
+   *
+   * @param context The context to check the UI mode from
+   * @return true if the device is running in television mode, false otherwise
+   */
+  @JvmStatic
+  fun isTVDevice(context: Context): Boolean {
+    return isTVDeviceCached ?: run {
+      val uiModeManager = context.getSystemService(Context.UI_MODE_SERVICE) as? UiModeManager
+      val result = uiModeManager?.currentModeType == Configuration.UI_MODE_TYPE_TELEVISION
+      isTVDeviceCached = result
+      result
+    }
+  }
+
   /**
    * Determines whether the current UI mode is dark mode
    *

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactHorizontalScrollView.java

@@ -29,6 +29,7 @@ import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.ViewParent;
 import android.view.accessibility.AccessibilityNodeInfo;
 import android.widget.HorizontalScrollView;
 import android.widget.OverScroller;
@@ -38,6 +39,7 @@ import androidx.core.view.ViewCompat.FocusDirection;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.react.R;
 import com.facebook.react.common.ReactConstants;
 import com.facebook.react.common.build.ReactBuildConfig;
@@ -136,6 +138,8 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private int mFadingEdgeLengthStart = 0;
   private int mFadingEdgeLengthEnd = 0;
   private int mSnapToItemPadding;
+  private boolean mScrollAnimationEnabled = true;
+  private boolean mBlockScrollDelta = false;
 
   public ReactHorizontalScrollView(Context context) {
     this(context, null);
@@ -247,9 +251,21 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     return mScrollEnabled && super.canScrollHorizontally(direction);
   }
 
+  @Override
+  public void computeScroll() {
+    if (UiModeUtils.isTVDevice(getContext())
+        && !mScrollAnimationEnabled
+        && mScroller != null
+        && !mScroller.isFinished()) {
+      mScroller.forceFinished(true);
+      return;
+    }
+    super.computeScroll();
+  }
+
   @Override
   protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (!mScrollEnabled) {
+    if (!mScrollEnabled || mBlockScrollDelta) {
       return 0;
     }
     return super.computeScrollDeltaToGetChildRectOnScreen(rect);
@@ -388,6 +404,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     mSnapToItemPadding = snapToItemPadding;
   }
 
+  public void setScrollAnimationEnabled(boolean scrollAnimationEnabled) {
+    mScrollAnimationEnabled = scrollAnimationEnabled;
+  }
+
   @Override
   protected float getLeftFadingEdgeStrength() {
     float max = Math.max(mFadingEdgeLengthStart, mFadingEdgeLengthEnd);
@@ -603,7 +623,11 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    * unblocks such customization.
    */
   protected void requestChildFocusWithoutScroll(View child, View focused) {
+    // Temporarily block HorizontalScrollView's internal scrollToChild from running
+    // during super.requestChildFocus — we've already handled scrolling in requestChildFocus.
+    mBlockScrollDelta = true;
     super.requestChildFocus(child, focused);
+    mBlockScrollDelta = false;
   }
 
   @Override
@@ -654,6 +678,18 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     return scrollDelta != 0 && Math.abs(scrollDelta) < (mTempRect.width() / 2);
   }
 
+  /** Returns whether the given view is a descendant of the given ancestor */
+  private static boolean isDescendantOf(View view, View ancestor) {
+    ViewParent parent = view.getParent();
+    while (parent != null) {
+      if (parent == ancestor) {
+        return true;
+      }
+      parent = parent.getParent();
+    }
+    return false;
+  }
+
   private void scrollToChild(View child) {
     int scrollDelta = getScrollDelta(child);
 
@@ -796,21 +832,42 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   public boolean arrowScroll(int direction) {
     boolean handled = false;
 
-    if (mPagingEnabled) {
+    if (!mScrollAnimationEnabled) {
+      // When scroll animation is disabled, find the next focusable and request focus directly.
+      // This must come before the mPagingEnabled check because snapToInterval on Android
+      // auto-enables paging, and the paging branch uses smoothScrollToNextPage which
+      // scrolls by full page width instead of by snap interval.
+      // requestChildFocus → tryScrollSnapToChild/scrollToChild handles instant scrolling.
+      View currentFocused = findFocus();
+      View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
+      if (nextFocused != null && nextFocused != currentFocused && nextFocused != this) {
+        nextFocused.requestFocus(direction);
+        handled = true;
+      }
+    } else if (mPagingEnabled) {
       mPagedArrowScrolling = true;
 
       if (getChildCount() > 0) {
         View currentFocused = findFocus();
         View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
         View rootChild = getContentView();
-        if (rootChild != null && nextFocused != null && nextFocused.getParent() == rootChild) {
-          if (!isScrolledInView(nextFocused) && !isMostlyScrolledInView(nextFocused)) {
-            smoothScrollToNextPage(direction);
+        if (rootChild != null && nextFocused != null && isDescendantOf(nextFocused, rootChild)) {
+          if (mSnapToAlignment == SNAP_ALIGNMENT_ITEM) {
+            // When snapToAlignment is "item", don't use smoothScrollToNextPage (which scrolls
+            // by full page width and ignores snapToItemPadding). Instead just request focus —
+            // requestChildFocus → tryScrollSnapToChild handles scrolling with correct padding.
+            nextFocused.requestFocus();
+          } else {
+            if (!isScrolledInView(nextFocused) && !isMostlyScrolledInView(nextFocused)) {
+              smoothScrollToNextPage(direction);
+            }
+            nextFocused.requestFocus();
           }
-          nextFocused.requestFocus();
           handled = true;
         } else {
-          smoothScrollToNextPage(direction);
+          if (mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
+            smoothScrollToNextPage(direction);
+          }
           handled = true;
         }
       }
@@ -1595,7 +1652,11 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    * scroll view and state. Calling raw `smoothScrollTo` doesn't update state.
    */
   public void reactSmoothScrollTo(int x, int y) {
-    ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    if (mScrollAnimationEnabled || !UiModeUtils.isTVDevice(getContext())) {
+      ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    } else {
+      scrollTo(x, y);
+    }
     setPendingContentOffsets(x, y);
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactHorizontalScrollViewManager.kt

@@ -164,6 +164,11 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setSnapToItemPadding(px)
   }
 
+  @ReactProp(name = "scrollAnimationEnabled", defaultBoolean = true)
+  public fun setScrollAnimationEnabled(view: ReactHorizontalScrollView, value: Boolean) {
+    view.setScrollAnimationEnabled(value)
+  }
+
   @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
   public fun setRemoveClippedSubviews(
       view: ReactHorizontalScrollView,

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollView.java

@@ -38,6 +38,7 @@ import androidx.core.view.ViewCompat.FocusDirection;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.react.R;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.ReactConstants;
@@ -134,6 +135,8 @@ public class ReactScrollView extends ScrollView
   private int mFadingEdgeLengthStart;
   private int mFadingEdgeLengthEnd;
   private int mSnapToItemPadding;
+  private boolean mScrollAnimationEnabled = true;
+  private boolean mBlockScrollDelta = false;
 
   public ReactScrollView(Context context) {
     this(context, null);
@@ -358,6 +361,10 @@ public class ReactScrollView extends ScrollView
     mSnapToItemPadding = snapToItemPadding;
   }
 
+  public void setScrollAnimationEnabled(boolean scrollAnimationEnabled) {
+    mScrollAnimationEnabled = scrollAnimationEnabled;
+  }
+
   @Override
   protected float getTopFadingEdgeStrength() {
     float max = Math.max(mFadingEdgeLengthStart, mFadingEdgeLengthEnd);
@@ -562,7 +569,9 @@ public class ReactScrollView extends ScrollView
    * unblocks such customization.
    */
   protected void requestChildFocusWithoutScroll(View child, View focused) {
+    mBlockScrollDelta = true;
     super.requestChildFocus(child, focused);
+    mBlockScrollDelta = false;
   }
 
   private int getScrollDelta(View descendent) {
@@ -606,9 +615,24 @@ public class ReactScrollView extends ScrollView
     }
   }
 
+  @Override
+  public void computeScroll() {
+    if (UiModeUtils.isTVDevice(getContext())
+        && !mScrollAnimationEnabled
+        && mScroller != null
+        && !mScroller.isFinished()) {
+      // When scroll animation is disabled, just abort any in-flight smooth scroll.
+      // The correct position has already been set synchronously by
+      // requestChildFocus → tryScrollSnapToChild/scrollToChild.
+      mScroller.forceFinished(true);
+      return;
+    }
+    super.computeScroll();
+  }
+
   @Override
   protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
-    if (!mScrollEnabled) {
+    if (!mScrollEnabled || mBlockScrollDelta) {
       return 0;
     }
     return super.computeScrollDeltaToGetChildRectOnScreen(rect);
@@ -1362,7 +1386,11 @@ public class ReactScrollView extends ScrollView
    * scroll view and state. Calling raw `smoothScrollTo` doesn't update state.
    */
   public void reactSmoothScrollTo(int x, int y) {
-    ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    if (mScrollAnimationEnabled || !UiModeUtils.isTVDevice(getContext())) {
+      ReactScrollViewHelper.smoothScrollTo(this, x, y);
+    } else {
+      scrollTo(x, y);
+    }
     setPendingContentOffsets(x, y);
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewManager.kt

@@ -148,6 +148,11 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setSnapToItemPadding(px)
   }
 
+  @ReactProp(name = "scrollAnimationEnabled", defaultBoolean = true)
+  public fun setScrollAnimationEnabled(view: ReactScrollView, value: Boolean) {
+    view.setScrollAnimationEnabled(value)
+  }
+
   @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
   public fun setRemoveClippedSubviews(view: ReactScrollView, removeClippedSubviews: Boolean) {
     view.removeClippedSubviews = removeClippedSubviews

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextView.java

@@ -30,6 +30,7 @@ import androidx.appcompat.widget.TintContextWrapper;
 import androidx.core.view.AccessibilityDelegateCompat;
 import androidx.core.view.ViewCompat;
 import androidx.customview.widget.ExploreByTouchHelper;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
@@ -151,14 +152,38 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     //         mViewFlags = SOUND_EFFECTS_ENABLED | HAPTIC_FEEDBACK_ENABLED |
     // LAYOUT_DIRECTION_INHERIT;
     setEnabled(true);
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      setFocusable(View.FOCUSABLE_AUTO);
-    }
+    // Changed from FOCUSABLE_AUTO to NOT_FOCUSABLE to prevent Android TV's
+    // focus engine from landing on text views when no other views are available
+    setFocusable(View.NOT_FOCUSABLE);
 
     setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NONE);
     updateView(); // call after changing ellipsizeLocation in particular
   }
 
+  // On Android TV, prevent text views from becoming focusable.
+  // ReactTextAnchorViewManager.setAccessible() ties isFocusable to the
+  // "accessible" prop, which causes Android TV's D-pad focus engine to land
+  // on text views inside recycled list items (FlashList), triggering
+  // requestChildFocus -> scrollToChild scroll jumps.
+  // On non-TV devices, focusability is left unchanged for accessibility.
+  @Override
+  public void setFocusable(boolean focusable) {
+    if (UiModeUtils.isTVDevice(getContext())) {
+      super.setFocusable(false);
+    } else {
+      super.setFocusable(focusable);
+    }
+  }
+
+  @Override
+  public void setFocusable(int focusable) {
+    if (UiModeUtils.isTVDevice(getContext())) {
+      super.setFocusable(View.NOT_FOCUSABLE);
+    } else {
+      super.setFocusable(focusable);
+    }
+  }
+
   private static WritableMap inlineViewJson(
       int visibility, int index, int left, int top, int right, int bottom) {
     WritableMap json = Arguments.createMap();

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewGroup.kt

@@ -631,7 +631,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
       index++
     }
 
-    return firstFocusableElement!!
+    return firstFocusableElement
   }
 
   private fun moveFocusToFirstFocusable(viewGroup: ReactViewGroup): Boolean {

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -22,7 +22,7 @@ constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 83;
   int32_t Patch = 4;
-  std::string_view Prerelease = "0";
+  std::string_view Prerelease = "2";
 } ReactNativeVersion;
 
 } // namespace facebook::react

package/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDefaults.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<f8c2279957d1c654502ea5aa0f66beba>>
+ * @generated SignedSource<<044be89d81fef6507ed9fe1638a49a78>>
  */
 
 /**
@@ -88,7 +88,7 @@ class ReactNativeFeatureFlagsDefaults : public ReactNativeFeatureFlagsProvider {
   }
 
   bool enableCustomFocusSearchOnClippedElementsAndroid() override {
-    return true;
+    return false;
   }
 
   bool enableDestroyShadowTreeRevisionAsync() override {

package/ReactCommon/react/renderer/components/scrollview/BaseScrollViewProps.cpp

@@ -41,6 +41,15 @@ BaseScrollViewProps::BaseScrollViewProps(
                     "snapToItemPadding",
                     sourceProps.snapToItemPadding,
                     (Float)0)),
+      scrollAnimationEnabled(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.scrollAnimationEnabled
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "scrollAnimationEnabled",
+                    sourceProps.scrollAnimationEnabled,
+                    true)),
 #endif
       alwaysBounceHorizontal(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
@@ -410,6 +419,7 @@ void BaseScrollViewProps::setProp(
 #if TARGET_OS_TV
     RAW_SET_PROP_SWITCH_CASE_BASIC(showsScrollIndex);
     RAW_SET_PROP_SWITCH_CASE_BASIC(snapToItemPadding);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(scrollAnimationEnabled);
 #endif
     RAW_SET_PROP_SWITCH_CASE_BASIC(alwaysBounceHorizontal);
     RAW_SET_PROP_SWITCH_CASE_BASIC(alwaysBounceVertical);

package/ReactCommon/react/renderer/components/scrollview/BaseScrollViewProps.h

@@ -32,6 +32,7 @@ class BaseScrollViewProps : public ViewProps {
 #if TARGET_OS_TV
   bool showsScrollIndex{true};
   Float snapToItemPadding{0};
+  bool scrollAnimationEnabled{true};
 #endif
   bool alwaysBounceHorizontal{};
   bool alwaysBounceVertical{};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-tvos",
-  "version": "0.83.4-0",
+  "version": "0.83.4-2",
   "description": "A framework for building native apps using React",
   "license": "MIT",
   "repository": {
@@ -198,7 +198,7 @@
     "whatwg-fetch": "^3.0.0",
     "ws": "^7.5.10",
     "yargs": "^17.6.2",
-    "@react-native-tvos/virtualized-lists": "0.83.4-0"
+    "@react-native-tvos/virtualized-lists": "0.83.4-2"
   },
   "codegenConfig": {
     "libraries": [

package/src/private/featureflags/ReactNativeFeatureFlags.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<474b28e49cdb8a46a361a32df3c92eed>>
+ * @generated SignedSource<<c7dd7afe6bc76c1abb2b0499d3740ec2>>
  * @flow strict
  * @noformat
  */
@@ -279,7 +279,7 @@ export const enableCppPropsIteratorSetter: Getter<boolean> = createNativeFlagGet
 /**
  * This enables the fabric implementation of focus search so that we can focus clipped elements
  */
-export const enableCustomFocusSearchOnClippedElementsAndroid: Getter<boolean> = createNativeFlagGetter('enableCustomFocusSearchOnClippedElementsAndroid', true);
+export const enableCustomFocusSearchOnClippedElementsAndroid: Getter<boolean> = createNativeFlagGetter('enableCustomFocusSearchOnClippedElementsAndroid', false);
 /**
  * Enables destructor calls for ShadowTreeRevision in the background to reduce UI thread work.
  */

package/types/public/ReactNativeTVTypes.d.ts

@@ -11,6 +11,14 @@ declare module 'react-native' {
      * Only used when `snapToAlignment` is set to `'item'`.
      */
     snapToItemPadding?: number | undefined;
+
+    /**
+     * When false, the scroll view will jump to the correct offset without animation
+     * when focus changes. Defaults to true.
+     *
+     * @platform tv
+     */
+    scrollAnimationEnabled?: boolean | undefined;
   }
 
   interface ViewProps {