react-native-tvos 0.83.3-0 → 0.83.4-0

package/Libraries/Components/ScrollView/AndroidHorizontalScrollViewNativeComponent.js

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

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

@@ -515,8 +515,9 @@ export interface ScrollViewPropsIOS {
    *      - `start` (the default) will align the snap at the left (horizontal) or top (vertical)
    *      - `center` will align the snap in the center
    *      - `end` will align the snap at the right (horizontal) or bottom (vertical)
+   *      - `item` will align the snap according to the value of `scrollSnapAlign` for individual items in the scroll view (TV platforms only).
    */
-  snapToAlignment?: 'start' | 'center' | 'end' | undefined;
+  snapToAlignment?: 'start' | 'center' | 'end' | 'item' | undefined;
 
   /**
    * Fires when the scroll view scrolls to top after the status bar has been tapped

package/Libraries/Components/ScrollView/ScrollView.js

@@ -612,8 +612,15 @@ type ScrollViewBaseProps = $ReadOnly<{
    *   - `'start'` (the default) will align the snap at the left (horizontal) or top (vertical)
    *   - `'center'` will align the snap in the center
    *   - `'end'` will align the snap at the right (horizontal) or bottom (vertical)
+   *   - `'item'` will align the snap according to the value of `scrollSnapAlign` for individual items in the scroll view (TV platforms only).
    */
-  snapToAlignment?: ?('start' | 'center' | 'end'),
+  snapToAlignment?: ?('start' | 'center' | 'end' | 'item'),
+  /**
+   * Padding applied when snapping to items using `snapToAlignment="item"`.
+   * This is set on the parent scroll view, not directly on child items.
+   * Only used when `snapToAlignment` is set to `'item'`.
+   */
+  snapToItemPadding?: ?number,
   /**
    * When set, causes the scroll view to stop at multiples of the value of
    * `snapToInterval`. This can be used for paginating through children

package/Libraries/Components/ScrollView/ScrollViewNativeComponent.js

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

package/Libraries/Components/ScrollView/ScrollViewNativeComponentType.js

@@ -69,11 +69,12 @@ export type ScrollViewNativeProps = $ReadOnly<{
   scrollPerfTag?: ?string,
   scrollToOverflowEnabled?: ?boolean,
   scrollsToTop?: ?boolean,
+  snapToItemPadding?: ?number,
   sendMomentumEvents?: ?boolean,
   showsHorizontalScrollIndicator?: ?boolean,
   showsScrollIndex?: ?boolean,
   showsVerticalScrollIndicator?: ?boolean,
-  snapToAlignment?: ?('start' | 'center' | 'end'),
+  snapToAlignment?: ?('start' | 'center' | 'end' | 'item'),
   snapToEnd?: ?boolean,
   snapToInterval?: ?number,
   snapToOffsets?: ?$ReadOnlyArray<number>,

package/Libraries/Components/TV/TVViewPropTypes.js

@@ -124,4 +124,11 @@ export type TVViewProps = $ReadOnly<{|
    *
    */
   nextFocusUp?: ?number,
+
+  /**
+   * Scroll snap alignment (used with snapToAlignment="item" in ScrollView).
+   *
+   */
+  scrollSnapAlign?: ?('start' | 'center' | 'end'),
+
 |}>;

package/Libraries/Components/View/View.js

@@ -153,6 +153,12 @@ component View(
     delete processedProps.isTVSelectable;
   }
 
+  // Views with scrollSnapAlign must not be flattened by Fabric, otherwise
+  // the prop never reaches the native view and scroll snapping breaks.
+  if (processedProps.scrollSnapAlign != null) {
+    processedProps.collapsable = false;
+  }
+
   const actualView =
     ref == null ? (
       <ViewNativeComponent {...processedProps} />

package/Libraries/Core/ReactNativeVersion.js

@@ -28,7 +28,7 @@
 export default class ReactNativeVersion {
   static major: number = 0;
   static minor: number = 83;
-  static patch: number = 3;
+  static patch: number = 4;
   static prerelease: string | null = '0';
 
   static getVersionString(): string {

package/Libraries/NativeComponent/TVViewConfig.js

@@ -25,5 +25,6 @@ export const validAttributesForTVProps = {
   trapFocusRight: true,
   trapFocusDown: true,
   trapFocusUp: true,
+  scrollSnapAlign: true,
 };
 

package/Libraries/Pressability/Pressability.js

@@ -398,6 +398,7 @@ export default class Pressability {
   _touchActivateTime: ?number;
   _touchState: TouchState = 'NOT_RESPONDER';
   _longPressSent: boolean = false;
+  _tvPressInReceived: boolean = false;
 
   constructor(config: PressabilityConfig) {
     this.configure(config);
@@ -416,6 +417,7 @@ export default class Pressability {
     this._cancelLongPressDelayTimeout();
     this._cancelPressDelayTimeout();
     this._cancelPressOutDelayTimeout();
+    this._tvPressInReceived = false;
 
     // Ensure that, if any async event handlers are fired after unmount
     // due to a race, we don't call any configured callbacks.
@@ -443,6 +445,7 @@ export default class Pressability {
           return;
         }
 
+        this._tvPressInReceived = true;
         this._longPressSent = false;
 
         const {onPressIn, onLongPress} = this._config;
@@ -463,6 +466,10 @@ export default class Pressability {
         if (this._config.disabled === true) {
           return;
         }
+        if (!this._tvPressInReceived) {
+          return;
+        }
+        this._tvPressInReceived = false;
         this._cancelLongPressDelayTimeout();
         const {onPress, onLongPress, onPressOut, android_disableSound} =
           this._config;

package/React/Base/RCTVersion.m

@@ -23,7 +23,7 @@ NSDictionary* RCTGetReactNativeVersion(void)
     __rnVersion = @{
                   RCTVersionMajor: @(0),
                   RCTVersionMinor: @(83),
-                  RCTVersionPatch: @(3),
+                  RCTVersionPatch: @(4),
                   RCTVersionPrerelease: @"0",
                   };
   });

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

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

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

@@ -132,6 +132,9 @@
 
 - (id<UIScrollViewDelegate>)delegate
 {
+  if (_scrollSnapEnabled) {
+    return [super delegate];
+  }
   return _publicDelegate;
 }
 

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;
@@ -465,6 +470,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];
 }
 
@@ -722,7 +733,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;
@@ -1137,19 +1151,109 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
 #pragma mark Apple TV swipe and focus handling
 
 #if TARGET_OS_TV
+// 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:YES];
+}
+
 - (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 || (!_props->isTVSelectable && !hasItemSnapAlignment)) {
         return;
     }
-    if (context.nextFocusedView == self) {
+    if (_props->isTVSelectable && context.nextFocusedView == self) {
         [self becomeFirstResponder];
         [self addSwipeGestureRecognizers];
         // 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 removeSwipeGestureRecognizers];
         [self resignFirstResponder];
@@ -1171,6 +1275,8 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
                 [self scrollToHorizontalOffset:scrollView.contentSize.width];
             }
         }
+    } else if ([context.nextFocusedView isDescendantOfView:_scrollView]) {
+        [self _handleScrollSnapForFocusedView:context.nextFocusedView];
     }
 }
 

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,6 +87,7 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   BOOL _trapFocusRight;
   NSArray* _focusDestinations;
   id<UIFocusItem> _previouslyFocusedItem;
+  NSString *_scrollSnapAlign;
   RCTSwiftUIContainerViewWrapper *_swiftUIWrapper;
   BOOL _shouldFocusOnMount;
 }
@@ -441,6 +442,13 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
   _motionEffectsAdded = NO;
 }
 
+- (NSString *)scrollSnapAlign
+{
+#if TARGET_OS_TV
+  return _scrollSnapAlign;
+#endif
+  return nil;
+}
 
 - (BOOL)isTVFocusGuide
 {
@@ -1170,6 +1178,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;

package/ReactAndroid/gradle.properties

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

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

@@ -14,7 +14,7 @@ public object ReactNativeVersion {
   public val VERSION: Map<String, Any?> = mapOf(
     "major" to 0,
     "minor" to 83,
-    "patch" to 3,
+    "patch" to 4,
     "prerelease" to "0"
   )
 }

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

@@ -10,6 +10,7 @@ package com.facebook.react.views.scroll;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_CENTER;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_DISABLED;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_END;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_ITEM;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_START;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.findNextFocusableView;
 
@@ -134,6 +135,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private @Nullable MaintainVisibleScrollPositionHelper mMaintainVisibleContentPositionHelper;
   private int mFadingEdgeLengthStart = 0;
   private int mFadingEdgeLengthEnd = 0;
+  private int mSnapToItemPadding;
 
   public ReactHorizontalScrollView(Context context) {
     this(context, null);
@@ -382,6 +384,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     invalidate();
   }
 
+  public void setSnapToItemPadding(int snapToItemPadding) {
+    mSnapToItemPadding = snapToItemPadding;
+  }
+
   @Override
   protected float getLeftFadingEdgeStrength() {
     float max = Math.max(mFadingEdgeLengthStart, mFadingEdgeLengthEnd);
@@ -538,6 +544,40 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     }
   }
 
+  /**
+   * Attempts to scroll-snap to the focused child based on snapToAlignment/scrollSnapAlign.
+   * Returns true if snap scrolling was performed, false otherwise.
+   */
+  private boolean tryScrollSnapToChild(View focused) {
+    if (mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
+      return false;
+    }
+
+    kotlin.Pair<View, String> result = ReactScrollViewHelper.findScrollSnapAlign(focused, this);
+    if (result == null) {
+      return false;
+    }
+
+    View snapTarget = result.getFirst();
+    String alignment = result.getSecond();
+
+    Rect rect = new Rect();
+    snapTarget.getDrawingRect(rect);
+    offsetDescendantRectToMyCoords(snapTarget, rect);
+
+    int viewportWidth = getWidth() - getPaddingLeft() - getPaddingRight();
+    int maxScrollX = Math.max(0, computeHorizontalScrollRange() - getWidth());
+
+    Integer targetOffset = ReactScrollViewHelper.computeScrollSnapOffset(
+        rect.left, rect.right, viewportWidth, alignment, mSnapInterval, mSnapToItemPadding, maxScrollX);
+    if (targetOffset == null) {
+      return false;
+    }
+
+    reactSmoothScrollTo(targetOffset, getScrollY());
+    return true;
+  }
+
   /**
    * Since ReactHorizontalScrollView handles layout changes on JS side, it does not call
    * super.onlayout due to which mIsLayoutDirty flag in HorizontalScrollView remains true and
@@ -547,8 +587,12 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
    */
   @Override
   public void requestChildFocus(View child, View focused) {
-    if (focused != null && !mPagingEnabled) {
-      scrollToChild(focused);
+    if (focused != null) {
+      if (!tryScrollSnapToChild(focused)) {
+        if (!mPagingEnabled) {
+          scrollToChild(focused);
+        }
+      }
     }
     requestChildFocusWithoutScroll(child, focused);
   }
@@ -832,7 +876,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
             && (mPagingEnabled
                 || mSnapInterval != 0
                 || mSnapOffsets != null
-                || mSnapToAlignment != SNAP_ALIGNMENT_DISABLED)) {
+                || (mSnapToAlignment != SNAP_ALIGNMENT_DISABLED && mSnapToAlignment != SNAP_ALIGNMENT_ITEM))) {
           // Cancel any pending runnable and reschedule
           if (mPostTouchRunnable != null) {
             removeCallbacks(mPostTouchRunnable);
@@ -1280,7 +1324,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     }
 
     // pagingEnabled only allows snapping one interval at a time
-    if (mSnapInterval == 0 && mSnapOffsets == null && mSnapToAlignment == SNAP_ALIGNMENT_DISABLED) {
+    if (mSnapInterval == 0 && mSnapOffsets == null && (mSnapToAlignment == SNAP_ALIGNMENT_DISABLED || mSnapToAlignment == SNAP_ALIGNMENT_ITEM)) {
       smoothScrollAndSnap(velocityX);
       return;
     }
@@ -1324,7 +1368,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
           }
         }
       }
-    } else if (mSnapToAlignment != SNAP_ALIGNMENT_DISABLED) {
+    } else if (mSnapToAlignment != SNAP_ALIGNMENT_DISABLED && mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
       if (mSnapInterval > 0) {
         double ratio = (double) targetOffset / mSnapInterval;
         smallerOffset =

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

@@ -157,6 +157,13 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setSnapToEnd(snapToEnd)
   }
 
+  @ReactProp(name = "snapToItemPadding")
+  public fun setSnapToItemPadding(view: ReactHorizontalScrollView, value: Float) {
+    val density = getDisplayMetricDensity()
+    val px = (value * density).toInt()
+    view.setSnapToItemPadding(px)
+  }
+
   @ReactProp(name = ReactClippingViewGroupHelper.PROP_REMOVE_CLIPPED_SUBVIEWS)
   public fun setRemoveClippedSubviews(
       view: ReactHorizontalScrollView,

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

@@ -10,6 +10,7 @@ package com.facebook.react.views.scroll;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_CENTER;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_DISABLED;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_END;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_ITEM;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_START;
 import static com.facebook.react.views.scroll.ReactScrollViewHelper.findNextFocusableView;
 
@@ -132,6 +133,7 @@ public class ReactScrollView extends ScrollView
   private @Nullable MaintainVisibleScrollPositionHelper mMaintainVisibleContentPositionHelper;
   private int mFadingEdgeLengthStart;
   private int mFadingEdgeLengthEnd;
+  private int mSnapToItemPadding;
 
   public ReactScrollView(Context context) {
     this(context, null);
@@ -352,6 +354,10 @@ public class ReactScrollView extends ScrollView
     invalidate();
   }
 
+  public void setSnapToItemPadding(int snapToItemPadding) {
+    mSnapToItemPadding = snapToItemPadding;
+  }
+
   @Override
   protected float getTopFadingEdgeStrength() {
     float max = Math.max(mFadingEdgeLengthStart, mFadingEdgeLengthEnd);
@@ -499,6 +505,40 @@ public class ReactScrollView extends ScrollView
     return nextFocus;
   }
 
+  /**
+   * Attempts to scroll-snap to the focused child based on snapToAlignment/scrollSnapAlign.
+   * Returns true if snap scrolling was performed, false otherwise.
+   */
+  private boolean tryScrollSnapToChild(View focused) {
+    if (mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
+      return false;
+    }
+
+    kotlin.Pair<View, String> result = ReactScrollViewHelper.findScrollSnapAlign(focused, this);
+    if (result == null) {
+      return false;
+    }
+
+    View snapTarget = result.getFirst();
+    String alignment = result.getSecond();
+
+    Rect rect = new Rect();
+    snapTarget.getDrawingRect(rect);
+    offsetDescendantRectToMyCoords(snapTarget, rect);
+
+    int viewportHeight = getHeight() - getPaddingTop() - getPaddingBottom();
+    int maxScrollY = getMaxScrollY();
+
+    Integer targetOffset = ReactScrollViewHelper.computeScrollSnapOffset(
+        rect.top, rect.bottom, viewportHeight, alignment, mSnapInterval, mSnapToItemPadding, maxScrollY);
+    if (targetOffset == null) {
+      return false;
+    }
+
+    reactSmoothScrollTo(getScrollX(), targetOffset);
+    return true;
+  }
+
   /**
    * Since ReactScrollView handles layout changes on JS side, it does not call super.onlayout due to
    * which mIsLayoutDirty flag in ScrollView remains true and prevents scrolling to child when
@@ -509,7 +549,9 @@ public class ReactScrollView extends ScrollView
   @Override
   public void requestChildFocus(View child, View focused) {
     if (focused != null) {
-      scrollToChild(focused);
+      if (!tryScrollSnapToChild(focused)) {
+        scrollToChild(focused);
+      }
     }
     requestChildFocusWithoutScroll(child, focused);
   }
@@ -686,7 +728,7 @@ public class ReactScrollView extends ScrollView
             && (mPagingEnabled
                 || mSnapInterval != 0
                 || mSnapOffsets != null
-                || mSnapToAlignment != SNAP_ALIGNMENT_DISABLED)) {
+                || (mSnapToAlignment != SNAP_ALIGNMENT_DISABLED && mSnapToAlignment != SNAP_ALIGNMENT_ITEM))) {
           // Cancel any pending post-touch runnable and reschedule
           if (mPostTouchRunnable != null) {
             removeCallbacks(mPostTouchRunnable);
@@ -1043,7 +1085,7 @@ public class ReactScrollView extends ScrollView
     }
 
     // pagingEnabled only allows snapping one interval at a time
-    if (mSnapInterval == 0 && mSnapOffsets == null && mSnapToAlignment == SNAP_ALIGNMENT_DISABLED) {
+    if (mSnapInterval == 0 && mSnapOffsets == null && (mSnapToAlignment == SNAP_ALIGNMENT_DISABLED || mSnapToAlignment == SNAP_ALIGNMENT_ITEM)) {
       smoothScrollAndSnap(velocityY);
       return;
     }
@@ -1082,7 +1124,7 @@ public class ReactScrollView extends ScrollView
         }
       }
 
-    } else if (mSnapToAlignment != SNAP_ALIGNMENT_DISABLED) {
+    } else if (mSnapToAlignment != SNAP_ALIGNMENT_DISABLED && mSnapToAlignment != SNAP_ALIGNMENT_ITEM) {
       if (mSnapInterval > 0) {
         double ratio = (double) targetOffset / mSnapInterval;
         smallerOffset =

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

@@ -11,6 +11,7 @@ import android.animation.Animator
 import android.animation.ValueAnimator
 import android.content.Context
 import android.graphics.Point
+import android.graphics.Rect
 import android.os.Build
 import android.view.View
 import android.view.ViewGroup
@@ -32,6 +33,7 @@ import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.common.UIManagerType
 import com.facebook.react.uimanager.common.ViewUtil
+import com.facebook.react.views.view.ReactViewGroup
 import java.lang.ref.WeakReference
 import java.util.concurrent.CopyOnWriteArrayList
 import kotlin.math.abs
@@ -54,6 +56,7 @@ public object ReactScrollViewHelper {
   public const val SNAP_ALIGNMENT_START: Int = 1
   public const val SNAP_ALIGNMENT_CENTER: Int = 2
   public const val SNAP_ALIGNMENT_END: Int = 3
+  public const val SNAP_ALIGNMENT_ITEM: Int = 4
 
   // Support global native listeners for scroll events
   private val scrollListeners = CopyOnWriteArrayList<WeakReference<ScrollListener>>()
@@ -209,6 +212,8 @@ public object ReactScrollViewHelper {
       SNAP_ALIGNMENT_CENTER
     } else if ("end" == alignment) {
       SNAP_ALIGNMENT_END
+    } else if ("item".equals(alignment, ignoreCase = true)) {
+      SNAP_ALIGNMENT_ITEM
     } else {
       FLog.w(ReactConstants.TAG, "wrong snap alignment value: $alignment")
       SNAP_ALIGNMENT_DISABLED
@@ -569,6 +574,70 @@ public object ReactScrollViewHelper {
     return host.findViewById(nextFocusableViewId)
   }
 
+  /**
+   * Walks up the view hierarchy from the focused view to find a ReactViewGroup with
+   * scrollSnapAlign set. Returns a Pair of (snapTarget, alignment) or null if not found.
+   *
+   * Shared by [ReactScrollView] and [ReactHorizontalScrollView].
+   */
+  @JvmStatic
+  public fun findScrollSnapAlign(focused: View, scrollView: ViewGroup): Pair<View, String>? {
+    var view: View? = focused
+    var snapTarget: View? = null
+    var alignment: String? = null
+    while (view != null && view !== scrollView) {
+      if (view is ReactViewGroup) {
+        val snap = view.scrollSnapAlign
+        if (snap != null) {
+          alignment = snap
+          snapTarget = view
+        }
+      }
+      val parent = view.parent
+      view = if (parent is View) parent else null
+    }
+    return if (alignment != null && snapTarget != null) Pair(snapTarget, alignment) else null
+  }
+
+  /**
+   * Computes the target scroll offset for scroll-snap based on the focused view's position,
+   * alignment, snap interval, scroll padding, and maximum scroll range.
+   *
+   * Returns the clamped target offset, or null if the alignment is unknown.
+   *
+   * Shared by [ReactScrollView] and [ReactHorizontalScrollView].
+   *
+   * @param focusedStart the start coordinate of the snap target in scroll view coordinates
+   * @param focusedEnd the end coordinate of the snap target in scroll view coordinates
+   * @param viewportSize the visible viewport size on the scroll axis
+   * @param alignment the scrollSnapAlign value ("start", "center", or "end")
+   * @param snapInterval the snap interval (0 if not set)
+   * @param snapToItemPadding the snap-to-item padding value
+   * @param maxScrollOffset the maximum scroll offset for clamping
+   */
+  @JvmStatic
+  public fun computeScrollSnapOffset(
+      focusedStart: Int,
+      focusedEnd: Int,
+      viewportSize: Int,
+      alignment: String,
+      snapInterval: Int,
+      snapToItemPadding: Int,
+      maxScrollOffset: Int,
+  ): Int? {
+    val focusedCenter = (focusedStart + focusedEnd) / 2
+    var targetOffset = when (alignment) {
+      "start" -> focusedStart - snapToItemPadding
+      "center" -> focusedCenter - (viewportSize / 2) + (snapToItemPadding / 2)
+      "end" -> focusedEnd - viewportSize + snapToItemPadding
+      else -> return null
+    }
+    if (snapInterval > 0) {
+      targetOffset = (Math.floor(targetOffset.toDouble() / snapInterval) * snapInterval).toInt()
+    }
+    return Math.max(0, Math.min(targetOffset, maxScrollOffset))
+  }
+
   @JvmStatic
   public fun resolveAbsoluteDirection(
       @FocusRealDirection direction: Int,

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

@@ -141,6 +141,13 @@ constructor(private val fpsListener: FpsListener? = null) :
     view.setSnapToEnd(snapToEnd)
   }
 
+  @ReactProp(name = "snapToItemPadding")
+  public fun setSnapToItemPadding(view: ReactScrollView, value: Float) {
+    val density = getDisplayMetricDensity()
+    val px = (value * density).toInt()
+    view.setSnapToItemPadding(px)
+  }
+
   @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/view/ReactViewGroup.kt

@@ -173,6 +173,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
   private var childrenLayoutChangeListener: ChildrenLayoutChangeListener? = null
   private var onInterceptTouchEventListener: OnInterceptTouchEventListener? = null
   private var needsOffscreenAlphaCompositing = false
+  public var scrollSnapAlign: String? = null
   private var backfaceOpacity = 0f
   private var backfaceVisible = false
   private var childrenRemovedWhileTransitioning: MutableSet<Int>? = null

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

@@ -190,6 +190,10 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
     view.setTrapFocusRight(enabled)
   }
 
+  @ReactProp(name = "scrollSnapAlign")
+  public open fun setScrollSnapAlign(view: ReactViewGroup, value: String?) {
+    view.scrollSnapAlign = value
+  }
 
   @ReactProp(name = ViewProps.BACKGROUND_IMAGE, customType = "BackgroundImage")
   public open fun setBackgroundImage(view: ReactViewGroup, backgroundImage: ReadableArray?) {

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -14,14 +14,14 @@
 
 #define REACT_NATIVE_VERSION_MAJOR 0
 #define REACT_NATIVE_VERSION_MINOR 83
-#define REACT_NATIVE_VERSION_PATCH 3
+#define REACT_NATIVE_VERSION_PATCH 4
 
 namespace facebook::react {
 
 constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 83;
-  int32_t Patch = 3;
+  int32_t Patch = 4;
   std::string_view Prerelease = "0";
 } ReactNativeVersion;
 

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

@@ -32,6 +32,15 @@ BaseScrollViewProps::BaseScrollViewProps(
                     "showsScrollIndex",
                     sourceProps.showsScrollIndex,
                     {})),
+      snapToItemPadding(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.snapToItemPadding
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "snapToItemPadding",
+                    sourceProps.snapToItemPadding,
+                    (Float)0)),
 #endif
       alwaysBounceHorizontal(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
@@ -400,6 +409,7 @@ void BaseScrollViewProps::setProp(
   switch (hash) {
 #if TARGET_OS_TV
     RAW_SET_PROP_SWITCH_CASE_BASIC(showsScrollIndex);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(snapToItemPadding);
 #endif
     RAW_SET_PROP_SWITCH_CASE_BASIC(alwaysBounceHorizontal);
     RAW_SET_PROP_SWITCH_CASE_BASIC(alwaysBounceVertical);

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

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

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

@@ -30,6 +30,10 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
     result = ScrollViewSnapToAlignment::End;
     return;
   }
+  if (string == "item") {
+    result = ScrollViewSnapToAlignment::Item;
+    return;
+  }
   abort();
 }
 
@@ -117,6 +121,8 @@ inline std::string toString(const ScrollViewSnapToAlignment &value)
       return "center";
     case ScrollViewSnapToAlignment::End:
       return "end";
+    case ScrollViewSnapToAlignment::Item:
+      return "item";
   }
 }
 

package/ReactCommon/react/renderer/components/scrollview/platform/android/react/renderer/components/scrollview/HostPlatformScrollViewProps.cpp

@@ -65,7 +65,16 @@ HostPlatformScrollViewProps::HostPlatformScrollViewProps(
                     rawProps,
                     "endFillColor",
                     sourceProps.endFillColor,
-                    clearColor())) {}
+                    clearColor())),
+      snapToItemPadding(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.snapToItemPadding
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "snapToItemPadding",
+                    sourceProps.snapToItemPadding,
+                    {})) {}
 
 void HostPlatformScrollViewProps::setProp(
     const PropsParserContext& context,
@@ -85,6 +94,7 @@ void HostPlatformScrollViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(fadingEdgeLength);
     RAW_SET_PROP_SWITCH_CASE_BASIC(overScrollMode);
     RAW_SET_PROP_SWITCH_CASE_BASIC(endFillColor);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(snapToItemPadding);
   }
 }
 
@@ -327,6 +337,9 @@ folly::dynamic HostPlatformScrollViewProps::getDiffProps(
       case ScrollViewSnapToAlignment::End:
         result["snapToAlignment"] = "end";
         break;
+      case ScrollViewSnapToAlignment::Item:
+        result["snapToAlignment"] = "item";
+        break;
     }
   }
 
@@ -396,6 +409,10 @@ folly::dynamic HostPlatformScrollViewProps::getDiffProps(
     result["endFillColor"] = *endFillColor;
   }
 
+  if (snapToItemPadding != oldProps->snapToItemPadding) {
+    result["snapToItemPadding"] = snapToItemPadding;
+  }
+
   return result;
 }
 

package/ReactCommon/react/renderer/components/scrollview/platform/android/react/renderer/components/scrollview/HostPlatformScrollViewProps.h

@@ -33,6 +33,8 @@ class HostPlatformScrollViewProps : public BaseScrollViewProps {
   std::string overScrollMode{"auto"};
   SharedColor endFillColor{clearColor()};
 
+  Float snapToItemPadding{0};
+
 #pragma mark - DebugStringConvertible
 
 #if RN_DEBUG_STRING_CONVERTIBLE

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

@@ -12,7 +12,7 @@
 
 namespace facebook::react {
 
-enum class ScrollViewSnapToAlignment { Start, Center, End };
+enum class ScrollViewSnapToAlignment { Start, Center, End, Item };
 
 enum class ScrollViewIndicatorStyle { Default, Black, White };
 

package/ReactCommon/react/renderer/components/view/BaseViewProps.cpp

@@ -447,7 +447,16 @@ BaseViewProps::BaseViewProps(
                     rawProps,
                     "removeClippedSubviews",
                     sourceProps.removeClippedSubviews,
-                    false)) {}
+                    false))
+#if TARGET_OS_TV
+      ,scrollSnapAlign(ReactNativeFeatureFlags::enableCppPropsIteratorSetter() ? sourceProps.scrollSnapAlign : convertRawProp(
+          context,
+          rawProps,
+          "scrollSnapAlign",
+          sourceProps.scrollSnapAlign,
+          {}))
+#endif
+      {}
 
 #define VIEW_EVENT_CASE(eventType)                      \
   case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): { \
@@ -518,6 +527,7 @@ void BaseViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(trapFocusDown);
     RAW_SET_PROP_SWITCH_CASE_BASIC(trapFocusLeft);
     RAW_SET_PROP_SWITCH_CASE_BASIC(trapFocusRight);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(scrollSnapAlign);
 #endif
     // events field
     VIEW_EVENT_CASE(PointerEnter);

package/ReactCommon/react/renderer/components/view/BaseViewProps.h

@@ -124,6 +124,10 @@ class BaseViewProps : public YogaStylableProps, public AccessibilityProps {
 
   bool removeClippedSubviews{false};
 
+#if TARGET_OS_TV
+  std::optional<std::string> scrollSnapAlign;
+#endif
+
 #pragma mark - Convenience Methods
 
   CascadedBorderWidths getBorderWidths() const;

package/ReactCommon/react/renderer/components/view/platform/android/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -99,6 +99,15 @@ HostPlatformViewProps::HostPlatformViewProps(
           "trapFocusRight",
           sourceProps.trapFocusRight,
           false)),
+      scrollSnapAlign(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.scrollSnapAlign
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "scrollSnapAlign",
+                    sourceProps.scrollSnapAlign,
+                    {})),
       needsOffscreenAlphaCompositing(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.needsOffscreenAlphaCompositing
@@ -201,6 +210,7 @@ void HostPlatformViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE(nativeForeground, "nativeForegroundAndroid");
     RAW_SET_PROP_SWITCH_CASE_BASIC(focusable);
     RAW_SET_PROP_SWITCH_CASE_BASIC(hasTVPreferredFocus);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(scrollSnapAlign);
     RAW_SET_PROP_SWITCH_CASE_BASIC(needsOffscreenAlphaCompositing);
     RAW_SET_PROP_SWITCH_CASE_BASIC(renderToHardwareTextureAndroid);
     RAW_SET_PROP_SWITCH_CASE_BASIC(screenReaderFocusable);
@@ -1105,6 +1115,14 @@ folly::dynamic HostPlatformViewProps::getDiffProps(
     }
   }
 
+  if (scrollSnapAlign != oldProps->scrollSnapAlign) {
+    if (scrollSnapAlign.has_value()) {
+      result["scrollSnapAlign"] = scrollSnapAlign.value();
+    } else {
+      result["scrollSnapAlign"] = folly::dynamic(nullptr);
+    }
+  }
+
   return result;
 }
 

package/ReactCommon/react/renderer/components/view/platform/android/react/renderer/components/view/HostPlatformViewProps.h

@@ -47,6 +47,7 @@ class HostPlatformViewProps : public BaseViewProps {
   bool trapFocusDown{false};
   bool trapFocusLeft{false};
   bool trapFocusRight{false};
+  std::optional<std::string> scrollSnapAlign{};
 
   bool needsOffscreenAlphaCompositing{false};
   bool renderToHardwareTextureAndroid{false};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-tvos",
-  "version": "0.83.3-0",
+  "version": "0.83.4-0",
   "description": "A framework for building native apps using React",
   "license": "MIT",
   "repository": {
@@ -165,12 +165,12 @@
   },
   "dependencies": {
     "@jest/create-cache-key-function": "^29.7.0",
-    "@react-native/assets-registry": "0.83.3",
-    "@react-native/codegen": "0.83.3",
-    "@react-native/community-cli-plugin": "0.83.3",
-    "@react-native/gradle-plugin": "0.83.3",
-    "@react-native/js-polyfills": "0.83.3",
-    "@react-native/normalize-colors": "0.83.3",
+    "@react-native/assets-registry": "0.83.4",
+    "@react-native/codegen": "0.83.4",
+    "@react-native/community-cli-plugin": "0.83.4",
+    "@react-native/gradle-plugin": "0.83.4",
+    "@react-native/js-polyfills": "0.83.4",
+    "@react-native/normalize-colors": "0.83.4",
     "abort-controller": "^3.0.0",
     "anser": "^1.4.9",
     "ansi-regex": "^5.0.0",
@@ -198,7 +198,7 @@
     "whatwg-fetch": "^3.0.0",
     "ws": "^7.5.10",
     "yargs": "^17.6.2",
-    "@react-native-tvos/virtualized-lists": "0.83.3-0"
+    "@react-native-tvos/virtualized-lists": "0.83.4-0"
   },
   "codegenConfig": {
     "libraries": [

package/types/public/ReactNativeTVTypes.d.ts

@@ -4,7 +4,24 @@ import type { View, ScrollViewProps, HostComponent, EventSubscription, TVParalla
 declare module 'react-native' {
   export type FocusDestination = null | number | React.Component<any, any> | React.ComponentClass<any>;
 
+  interface ScrollViewProps {
+    /**
+     * Padding applied when snapping to items using `snapToAlignment="item"`.
+     * Set on the parent scroll view, not directly on child items.
+     * Only used when `snapToAlignment` is set to `'item'`.
+     */
+    snapToItemPadding?: number | undefined;
+  }
+
   interface ViewProps {
+  /**
+   * Controls the scroll snap alignment when this view receives focus inside a ScrollView.
+   * Used with snapToAlignment="item" on the parent ScrollView.
+   *
+   * @platform tv
+   */
+  scrollSnapAlign?: 'start' | 'center' | 'end' | undefined;
+
   /**
    * Android TV only prop
    */
@@ -54,8 +71,8 @@ declare module 'react-native' {
 
   /**
    * Hardware event received from TVEventHandler
-   * 
-   * Note: The 'blur' and 'focus' event types are deprecated and will no longer be 
+   *
+   * Note: The 'blur' and 'focus' event types are deprecated and will no longer be
    * emitted on new architecture (Fabric). Use onFocus/onBlur component props instead.
    * See: https://github.com/react-native-tvos/react-native-tvos/issues/1037
    */