react-native-tvos 0.85.3-0 → 0.85.3-2

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

@@ -515,7 +515,7 @@ 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).
+   *      - `item` will align the snap according to each item's own `scrollSnapAlign` or `scrollSnapOffset` prop (TV platforms only).
    */
   snapToAlignment?: 'start' | 'center' | 'end' | 'item' | undefined;
 

package/Libraries/Components/ScrollView/ScrollView.js

@@ -620,7 +620,7 @@ 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).
+   *   - `'item'` will align the snap according to each item's own `scrollSnapAlign` or `scrollSnapOffset` prop (TV platforms only).
    */
   snapToAlignment?: ?('start' | 'center' | 'end' | 'item'),
   /**

package/Libraries/Components/TV/TVViewPropTypes.js

@@ -131,4 +131,13 @@ export type TVViewProps = $ReadOnly<{|
    */
   scrollSnapAlign?: ?('start' | 'center' | 'end'),
 
+  /**
+   * Per-item scroll snap offset in dp/pt. When set on a View inside a
+   * ScrollView with `snapToAlignment="item"`, the focus engine lands the
+   * View's top at viewport y = scrollSnapOffset. Standalone alternative to
+   * `scrollSnapAlign` — set one or the other; if both are set on the same
+   * View, `scrollSnapOffset` takes precedence.
+   */
+  scrollSnapOffset?: ?number,
+
 |}>;

package/Libraries/Components/View/View.js

@@ -153,9 +153,13 @@ 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) {
+  // Views with scrollSnapAlign or scrollSnapOffset must not be flattened by
+  // Fabric, otherwise the prop never reaches the native view and scroll
+  // snapping breaks.
+  if (
+    processedProps.scrollSnapAlign != null ||
+    processedProps.scrollSnapOffset != null
+  ) { 
     processedProps.collapsable = false;
   }
 

package/Libraries/Core/ReactNativeVersion.js

@@ -29,7 +29,7 @@ export default class ReactNativeVersion {
   static major: number = 0;
   static minor: number = 85;
   static patch: number = 3;
-  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/Libraries/NativeComponent/TVViewConfig.js

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

package/README.md

@@ -272,6 +272,7 @@ class Game2048 extends React.Component {
   | 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"`. |
+  | scrollSnapOffset | `number` | Per-item pixel offset (in dp/pt). When set, the focus engine lands this item's leading edge at `scrollSnapOffset` from the viewport origin. Standalone alternative to `scrollSnapAlign` — takes precedence if both are set on the same item. Only used when the parent has `snapToAlignment="item"`. |
 
   ```jsx
   <ScrollView
@@ -291,6 +292,16 @@ class Game2048 extends React.Component {
   </ScrollView>
   ```
 
+  `scrollSnapOffset` is useful when different items in the same ScrollView need to land at different positions — e.g. a hero row peeking 27dp from the top while poster rows peek 550dp:
+
+  ```jsx
+  <ScrollView snapToAlignment="item">
+    <View scrollSnapOffset={27}><Hero /></View>
+    <View scrollSnapOffset={100}><Featured /></View>
+    <View scrollSnapOffset={550}><PosterRow /></View>
+  </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 |
@@ -307,7 +318,8 @@ class Game2048 extends React.Component {
 
   - _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"` does not require `snapToInterval` to be set. It works as a standalone snapping mode where each child's `scrollSnapAlign` or `scrollSnapOffset` determines the snap position. If `snapToInterval` is also set, the interval is applied as an additional constraint after the item offset is computed.
+    - `scrollSnapOffset` ignores `snapToItemPadding`. The padding is a global value applied to `scrollSnapAlign` cases; `scrollSnapOffset` is itself a per-item pixel offset that fully specifies where the item lands.
     - `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.

package/React/Base/RCTVersion.m

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

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

@@ -1171,13 +1171,20 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
   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
+// Focus marker helper: traverses view hierarchy to find either scrollSnapAlign
+// or scrollSnapOffset. Returns the view that has the property via the output
+// parameter and the marker type via outAlign/outOffset (exactly one non-nil on
+// return). Walk is inner→outer, latest marker wins (same as PR-1068's
+// scrollSnapAlign behavior). On a single view declaring both, scrollSnapOffset
+// wins as the more specific config.
+- (UIView *)findScrollSnapInView:(UIView *)view
+                        outAlign:(NSString **)outAlign
+                       outOffset:(NSNumber **)outOffset
 {
     UIView *testView = view;
     UIView *snapTarget;
-    NSString *marker;
+    NSString *align;
+    NSNumber *offset;
 
     while (testView && testView != self) {
         if (![testView isKindOfClass:RCTViewComponentView.class])
@@ -1188,28 +1195,37 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         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()];
+        if (viewProps.scrollSnapOffset.has_value()) {
+            offset = @(viewProps.scrollSnapOffset.value());
+            align = nil;
+            snapTarget = componentView;
+        } else if (viewProps.scrollSnapAlign.has_value() && !viewProps.scrollSnapAlign.value().empty()) {
+            align = [NSString stringWithUTF8String:viewProps.scrollSnapAlign.value().c_str()];
+            offset = nil;
             snapTarget = componentView;
         }
 
         testView = [testView superview];
     }
-    *outView = snapTarget;
-    return marker;
+    *outAlign = align;
+    *outOffset = offset;
+    return snapTarget;
 }
 
 - (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) {
+
+    NSString *scrollSnapAlign = nil;
+    NSNumber *scrollSnapOffset = nil;
+    UIView *snapTargetView = [self findScrollSnapInView:focusedView
+                                               outAlign:&scrollSnapAlign
+                                              outOffset:&scrollSnapOffset];
+    if (snapTargetView == nil || (scrollSnapAlign == nil && scrollSnapOffset == nil)) {
         return;
     }
-
     RCTEnhancedScrollView *scrollView = (RCTEnhancedScrollView *)_scrollView;
-    CGRect focusedFrame = [snapAlignView convertRect:snapAlignView.bounds toView:_scrollView];
+    CGRect focusedFrame = [snapTargetView convertRect:snapTargetView.bounds toView:_scrollView];
     CGFloat targetOffset;
     CGFloat snapToItemPadding = scrollProps.snapToItemPadding;
 
@@ -1229,8 +1245,12 @@ static inline UIViewAnimationOptions animationOptionsWithCurve(UIViewAnimationCu
         currentOffset = scrollView.contentOffset.y;
         maxContentSize = scrollView.contentSize.height;
     }
-    // Calculate target offset based on scrollSnapAlign (unified for both axes)
-    if ([scrollSnapAlign isEqualToString:@"start"]) {
+
+    if (scrollSnapOffset != nil) {
+        // Per-item pixel offset path: land the snap target's leading edge
+        // at viewport coordinate = scrollSnapOffset.
+        targetOffset = focusedOrigin - scrollSnapOffset.doubleValue;
+    } else if ([scrollSnapAlign isEqualToString:@"start"]) {
         targetOffset = focusedOrigin - snapToItemPadding;
     } else if ([scrollSnapAlign isEqualToString:@"center"]) {
         CGFloat viewportCenter = viewportSize / 2;

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

@@ -611,11 +611,10 @@ const CGFloat BACKGROUND_COLOR_ZPOSITION = -1024.0f;
       // [self isTVFocusGuide] is false when autofocus and destinations are not used, so we cannot use that.
       // Generally speaking, it would happen for any non-collapsable `View`.
     } else if (context.previouslyFocusedView == self) {
-      [self disableDirectionalFocusGuides];
       [coordinator addCoordinatedAnimations:^(void){
           [self removeParallaxMotionEffects];
           if (self->_eventEmitter) self->_eventEmitter->onBlur();
-      } completion:^(void){}];
+      } completion:^(void){[self disableDirectionalFocusGuides];}];
       [self resignFirstResponder];
     }
 }

package/ReactAndroid/gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=0.85.3-0
+VERSION_NAME=0.85.3-2
 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

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

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

@@ -586,29 +586,39 @@ 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.
+   * Attempts to scroll-snap to the focused child based on snapToAlignment/scrollSnapAlign
+   * or scrollSnapOffset. 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);
+    kotlin.Triple<View, String, Integer> result =
+        ReactScrollViewHelper.findScrollSnap(focused, this);
     if (result == null) {
       return false;
     }
 
     View snapTarget = result.getFirst();
     String alignment = result.getSecond();
+    Integer snapOffset = result.getThird();
 
     Rect rect = new Rect();
     snapTarget.getDrawingRect(rect);
     offsetDescendantRectToMyCoords(snapTarget, rect);
 
-    int viewportWidth = getWidth() - getPaddingLeft() - getPaddingRight();
     int maxScrollX = Math.max(0, computeHorizontalScrollRange() - getWidth());
 
+    if (snapOffset != null) {
+      int targetOffset = ReactScrollViewHelper.computeScrollSnapTargetForOffset(
+          rect.left, snapOffset, mSnapInterval, maxScrollX);
+      reactSmoothScrollTo(targetOffset, getScrollY());
+      return true;
+    }
+
+    int viewportWidth = getWidth() - getPaddingLeft() - getPaddingRight();
+
     Integer targetOffset = ReactScrollViewHelper.computeScrollSnapOffset(
         rect.left, rect.right, viewportWidth, alignment, mSnapInterval, mSnapToItemPadding, maxScrollX);
     if (targetOffset == null) {

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

@@ -519,29 +519,39 @@ public class ReactScrollView extends ScrollView
   }
 
   /**
-   * Attempts to scroll-snap to the focused child based on snapToAlignment/scrollSnapAlign.
-   * Returns true if snap scrolling was performed, false otherwise.
+   * Attempts to scroll-snap to the focused child based on snapToAlignment/scrollSnapAlign
+   * or scrollSnapOffset. 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);
+    kotlin.Triple<View, String, Integer> result =
+        ReactScrollViewHelper.findScrollSnap(focused, this);
     if (result == null) {
       return false;
     }
 
     View snapTarget = result.getFirst();
     String alignment = result.getSecond();
+    Integer snapOffset = result.getThird();
 
     Rect rect = new Rect();
     snapTarget.getDrawingRect(rect);
     offsetDescendantRectToMyCoords(snapTarget, rect);
 
-    int viewportHeight = getHeight() - getPaddingTop() - getPaddingBottom();
     int maxScrollY = getMaxScrollY();
 
+    if (snapOffset != null) {
+      int targetOffset = ReactScrollViewHelper.computeScrollSnapTargetForOffset(
+          rect.top, snapOffset, mSnapInterval, maxScrollY);
+      reactSmoothScrollTo(getScrollX(), targetOffset);
+      return true;
+    }
+
+    int viewportHeight = getHeight() - getPaddingTop() - getPaddingBottom();
+
     Integer targetOffset = ReactScrollViewHelper.computeScrollSnapOffset(
         rect.top, rect.bottom, viewportHeight, alignment, mSnapInterval, mSnapToItemPadding, maxScrollY);
     if (targetOffset == null) {

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

@@ -569,27 +569,67 @@ public object ReactScrollViewHelper {
 
   /**
    * 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.
+   * either scrollSnapAlign or scrollSnapOffset set. Returns a Triple of (snapTarget,
+   * alignment, offsetPx) or null if neither marker was found. Exactly one of
+   * alignment/offsetPx is non-null on return.
+   *
+   * Walk is inner→outer, latest marker wins. On a single view declaring both,
+   * scrollSnapOffset wins as the more specific config.
    *
    * Shared by [ReactScrollView] and [ReactHorizontalScrollView].
    */
   @JvmStatic
-  public fun findScrollSnapAlign(focused: View, scrollView: ViewGroup): Pair<View, String>? {
+  public fun findScrollSnap(focused: View, scrollView: ViewGroup): Triple<View, String?, Int?>? {
     var view: View? = focused
     var snapTarget: View? = null
     var alignment: String? = null
+    var offset: Int? = null
     while (view != null && view !== scrollView) {
       if (view is ReactViewGroup) {
-        val snap = view.scrollSnapAlign
-        if (snap != null) {
-          alignment = snap
+        val o = view.scrollSnapOffset
+        val a = view.scrollSnapAlign
+        if (o != null) {
+          offset = o
+          alignment = null
+          snapTarget = view
+        } else if (a != null) {
+          alignment = a
+          offset = null
           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
+    return if (snapTarget != null && (alignment != null || offset != null))
+        Triple(snapTarget, alignment, offset) else null
+  }
+
+  /**
+   * Computes the target scroll offset for the per-item scrollSnapOffset path:
+   * land the snap target's leading edge at `snapOffset` pixels from the viewport origin.
+   *
+   * Returns the clamped target offset.
+   *
+   * Shared by [ReactScrollView] and [ReactHorizontalScrollView].
+   *
+   * @param focusedStart the start coordinate of the snap target in scroll view coordinates
+   * @param snapOffset the per-item pixel offset from the viewport origin
+   * @param snapInterval the snap interval (0 if not set)
+   * @param maxScrollOffset the maximum scroll offset for clamping
+   */
+  @JvmStatic
+  public fun computeScrollSnapTargetForOffset(
+      focusedStart: Int,
+      snapOffset: Int,
+      snapInterval: Int,
+      maxScrollOffset: Int,
+  ): Int {
+    var targetOffset = focusedStart - snapOffset
+    if (snapInterval > 0) {
+      targetOffset = (Math.floor(targetOffset.toDouble() / snapInterval) * snapInterval).toInt()
+    }
+    return Math.max(0, Math.min(targetOffset, maxScrollOffset))
   }
 
   /**

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

@@ -174,6 +174,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
   private var onInterceptTouchEventListener: OnInterceptTouchEventListener? = null
   private var needsOffscreenAlphaCompositing = false
   public var scrollSnapAlign: String? = null
+  public var scrollSnapOffset: Int? = 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

@@ -195,6 +195,11 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
     view.scrollSnapAlign = value
   }
 
+  @ReactProp(name = "scrollSnapOffset", defaultFloat = Float.NaN)
+  public open fun setScrollSnapOffset(view: ReactViewGroup, value: Float) {
+    view.scrollSnapOffset = if (value.isNaN()) null else value.dpToPx().toInt()
+  }
+
   @ReactProp(name = ViewProps.BACKGROUND_IMAGE, customType = "BackgroundImage")
   public open fun setBackgroundImage(view: ReactViewGroup, backgroundImage: ReadableArray?) {
     if (ViewUtil.getUIManagerType(view) == UIManagerType.FABRIC) {

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -22,7 +22,7 @@ struct ReactNativeVersionType {
   int32_t Major = 0;
   int32_t Minor = 85;
   int32_t Patch = 3;
-  std::string_view Prerelease = "0";
+  std::string_view Prerelease = "2";
 };
 
 constexpr ReactNativeVersionType ReactNativeVersion;

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

@@ -455,6 +455,12 @@ BaseViewProps::BaseViewProps(
           "scrollSnapAlign",
           sourceProps.scrollSnapAlign,
           {}))
+      ,scrollSnapOffset(ReactNativeFeatureFlags::enableCppPropsIteratorSetter() ? sourceProps.scrollSnapOffset : convertRawProp(
+          context,
+          rawProps,
+          "scrollSnapOffset",
+          sourceProps.scrollSnapOffset,
+          {}))
 #endif
       {}
 
@@ -528,6 +534,7 @@ void BaseViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(trapFocusLeft);
     RAW_SET_PROP_SWITCH_CASE_BASIC(trapFocusRight);
     RAW_SET_PROP_SWITCH_CASE_BASIC(scrollSnapAlign);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(scrollSnapOffset);
 #endif
     // events field
     VIEW_EVENT_CASE(PointerEnter);

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

@@ -126,6 +126,7 @@ class BaseViewProps : public YogaStylableProps, public AccessibilityProps {
 
 #if TARGET_OS_TV
   std::optional<std::string> scrollSnapAlign;
+  std::optional<int> scrollSnapOffset;
 #endif
 
 #pragma mark - Convenience Methods

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

@@ -109,6 +109,15 @@ HostPlatformViewProps::HostPlatformViewProps(
                     "scrollSnapAlign",
                     sourceProps.scrollSnapAlign,
                     {})),
+      scrollSnapOffset(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.scrollSnapOffset
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "scrollSnapOffset",
+                    sourceProps.scrollSnapOffset,
+                    {})),
       needsOffscreenAlphaCompositing(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.needsOffscreenAlphaCompositing
@@ -212,6 +221,7 @@ void HostPlatformViewProps::setProp(
     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(scrollSnapOffset);
     RAW_SET_PROP_SWITCH_CASE_BASIC(needsOffscreenAlphaCompositing);
     RAW_SET_PROP_SWITCH_CASE_BASIC(renderToHardwareTextureAndroid);
     RAW_SET_PROP_SWITCH_CASE_BASIC(screenReaderFocusable);
@@ -1065,6 +1075,14 @@ folly::dynamic HostPlatformViewProps::getDiffProps(
     }
   }
 
+  if (scrollSnapOffset != oldProps->scrollSnapOffset) {
+    if (scrollSnapOffset.has_value()) {
+      result["scrollSnapOffset"] = scrollSnapOffset.value();
+    } else {
+      result["scrollSnapOffset"] = folly::dynamic(nullptr);
+    }
+  }
+
   return result;
 }
 

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-tvos",
-  "version": "0.85.3-0",
+  "version": "0.85.3-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.85.3-0"
+    "@react-native-tvos/virtualized-lists": "0.85.3-2"
   },
   "codegenConfig": {
     "libraries": [

package/types/public/ReactNativeTVTypes.d.ts

@@ -30,6 +30,15 @@ declare module 'react-native' {
    */
   scrollSnapAlign?: 'start' | 'center' | 'end' | undefined;
 
+  /**
+   * Per-item scroll snap offset in dp/pt. When set, the focus engine lands
+   * this view's top at viewport y = scrollSnapOffset. Standalone alternative
+   * to `scrollSnapAlign`; takes precedence if both are set on the same View.
+   *
+   * @platform tv
+   */
+  scrollSnapOffset?: number | undefined;
+
   /**
    * Android TV only prop
    */