react-native-windows 0.80.1 → 0.81.0-preview.4

package/Microsoft.ReactNative/CompositionSwitcher.idl

@@ -1,178 +1,179 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-#include "NamespaceRedirect.h"
 #include "DocString.h"
+#include "NamespaceRedirect.h"
 import "Composition.Input.idl";
 
-namespace Microsoft.ReactNative.Composition.Experimental
+namespace Microsoft.ReactNative.Composition.Experimental {
+enum CompositionStretch {
+  None,
+  Fill,
+  Uniform,
+  UniformToFill,
+};
+
+enum BackfaceVisibility { Inherit, Visible, Hidden };
+
+enum AnimationClass {
+  None = 0,
+  ScrollBar,
+  ScrollBarThumbHorizontal,
+  ScrollBarThumbVertical,
+  SwitchThumb,
+};
+
+enum SnapPointsAlignment {
+  Near = 0, // Start alignment (left/top)
+  Center = 1, // Center alignment
+  Far = 2, // End alignment (right/bottom)
+};
+
+[webhosthidden][uuid("172def51-9e1a-4e3c-841a-e5a470065acc")] // uuid needed for empty interfaces
+               [version(0)][experimental] interface IBrush {}
+
+                   [webhosthidden][experimental] interface IDrawingSurfaceBrush
+  requires IBrush
+{
+  void HorizontalAlignmentRatio(Single value);
+  void VerticalAlignmentRatio(Single value);
+  void Stretch(CompositionStretch value);
+}
+
+[webhosthidden][experimental] interface IDropShadow {
+  void Offset(Windows.Foundation.Numerics.Vector3 value);
+  void Opacity(Single value);
+  void BlurRadius(Single value);
+  void Color(Windows.UI.Color value);
+}
+
+    [webhosthidden][experimental] interface IVisual {
+  void InsertAt(IVisual visual, Int32 index);
+  void Remove(IVisual visual);
+  IVisual GetAt(UInt32 index);
+  void Opacity(Single opacity);
+  void Scale(Windows.Foundation.Numerics.Vector3 scale);
+  void TransformMatrix(Windows.Foundation.Numerics.Matrix4x4 transform);
+  void RotationAngle(Single angle);
+  void IsVisible(Boolean isVisible);
+  void Size(Windows.Foundation.Numerics.Vector2 size);
+  void Offset(Windows.Foundation.Numerics.Vector3 offset);
+  void Offset(Windows.Foundation.Numerics.Vector3 offset, Windows.Foundation.Numerics.Vector3 relativeAdjustment);
+  void RelativeSizeWithOffset(
+      Windows.Foundation.Numerics.Vector2 size, Windows.Foundation.Numerics.Vector2 relativeSizeAdjustment);
+  BackfaceVisibility BackfaceVisibility {
+    get;
+    set;
+  };
+  String Comment {
+    get;
+    set;
+  };
+  void AnimationClass(AnimationClass value);
+}
+
+[webhosthidden][experimental] interface ISpriteVisual
+  requires IVisual
+{
+  void Brush(IBrush brush);
+  void Shadow(IDropShadow shadow);
+}
+
+    [webhosthidden][experimental] interface IRoundedRectangleVisual
+  requires IVisual
 {
-  enum CompositionStretch
-  {
-    None,
-    Fill,
-    Uniform,
-    UniformToFill,
+  void Brush(IBrush brush);
+  void CornerRadius(Windows.Foundation.Numerics.Vector2 value);
+  void StrokeBrush(IBrush brush);
+  void StrokeThickness(Single value);
+}
+
+[webhosthidden][experimental] interface IScrollPositionChangedArgs {
+  Windows.Foundation.Numerics.Vector2 Position {
+    get;
   };
+}
 
-  enum BackfaceVisibility
-  {
-    Inherit,
-    Visible,
-    Hidden
+    [webhosthidden][experimental] interface IScrollVisual
+  requires IVisual
+{
+  void Brush(IBrush brush);
+  void ScrollEnabled(Boolean isScrollEnabled);
+  event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollPositionChanged;
+  event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollBeginDrag;
+  event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollEndDrag;
+  event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollMomentumBegin;
+  event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollMomentumEnd;
+  void ContentSize(Windows.Foundation.Numerics.Vector2 size);
+  Windows.Foundation.Numerics.Vector3 ScrollPosition {
+    get;
+  };
+  void ScrollBy(Windows.Foundation.Numerics.Vector3 offset, Boolean animate);
+  void TryUpdatePosition(Windows.Foundation.Numerics.Vector3 position, Boolean animate);
+  void OnPointerPressed(Microsoft.ReactNative.Composition.Input.PointerRoutedEventArgs args);
+  void SetDecelerationRate(Windows.Foundation.Numerics.Vector3 decelerationRate);
+  void SetMaximumZoomScale(Single maximumZoomScale);
+  void SetMinimumZoomScale(Single minimumZoomScale);
+  Boolean Horizontal;
+  void SetSnapPoints(
+      Boolean snapToStart, Boolean snapToEnd, Windows.Foundation.Collections.IVectorView<Single> offsets);
+  void PagingEnabled(Boolean pagingEnabled);
+  void SnapToInterval(Single interval);
+  void SnapToAlignment(SnapPointsAlignment alignment);
+}
+
+[webhosthidden][experimental] interface IActivityVisual
+  requires IVisual
+{
+  void Size(Single value);
+  void Brush(IBrush brush);
+  void StartAnimation();
+  void StopAnimation();
+}
+
+    [webhosthidden][experimental] interface ICaretVisual {
+  IVisual InnerVisual {
+    get;
   };
-  
-  enum AnimationClass
-  {
-    None = 0,
-    ScrollBar,
-    ScrollBarThumbHorizontal,
-    ScrollBarThumbVertical,
-    SwitchThumb,
+  void Size(Windows.Foundation.Numerics.Vector2 size);
+  void Position(Windows.Foundation.Numerics.Vector2 position);
+  Boolean IsVisible {
+    get;
+    set;
   };
+  void Brush(IBrush brush);
+}
 
-  [webhosthidden]
-  [uuid("172def51-9e1a-4e3c-841a-e5a470065acc")] // uuid needed for empty interfaces
-  [version(0)]
-  [experimental]
-  interface IBrush {
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface IDrawingSurfaceBrush requires IBrush
-  {
-    void HorizontalAlignmentRatio(Single value);
-    void VerticalAlignmentRatio(Single value);
-    void Stretch(CompositionStretch value);
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface IDropShadow {
-    void Offset(Windows.Foundation.Numerics.Vector3 value);
-    void Opacity(Single value);
-    void BlurRadius(Single value);
-    void Color(Windows.UI.Color value);
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface IVisual
-  {
-    void InsertAt(IVisual visual, Int32 index);
-    void Remove(IVisual visual);
-    IVisual GetAt(UInt32 index);
-    void Opacity(Single opacity);
-    void Scale(Windows.Foundation.Numerics.Vector3 scale);
-    void TransformMatrix(Windows.Foundation.Numerics.Matrix4x4 transform);
-    void RotationAngle(Single angle);
-    void IsVisible(Boolean isVisible);
-    void Size(Windows.Foundation.Numerics.Vector2 size);
-    void Offset(Windows.Foundation.Numerics.Vector3 offset);
-    void Offset(Windows.Foundation.Numerics.Vector3 offset, Windows.Foundation.Numerics.Vector3 relativeAdjustment);
-    void RelativeSizeWithOffset(Windows.Foundation.Numerics.Vector2 size, Windows.Foundation.Numerics.Vector2 relativeSizeAdjustment);
-    BackfaceVisibility BackfaceVisibility{ get; set; };
-    String Comment { get; set; };
-    void AnimationClass(AnimationClass value);
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface ISpriteVisual requires IVisual
-  {
-    void Brush(IBrush brush);
-    void Shadow(IDropShadow shadow);
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface IRoundedRectangleVisual requires IVisual
-  {
-    void Brush(IBrush brush);
-    void CornerRadius(Windows.Foundation.Numerics.Vector2 value);
-    void StrokeBrush(IBrush brush);
-    void StrokeThickness(Single value);
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface IScrollPositionChangedArgs
-  {
-    Windows.Foundation.Numerics.Vector2 Position { get; };
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface IScrollVisual requires IVisual
-  {
-    void Brush(IBrush brush);
-    void ScrollEnabled(Boolean isScrollEnabled);
-    event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollPositionChanged;
-    event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollBeginDrag;
-	  event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollEndDrag;
-    event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollMomentumBegin;
-    event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollMomentumEnd;
-    void ContentSize(Windows.Foundation.Numerics.Vector2 size);
-    Windows.Foundation.Numerics.Vector3 ScrollPosition { get; };
-    void ScrollBy(Windows.Foundation.Numerics.Vector3 offset, Boolean animate);
-    void TryUpdatePosition(Windows.Foundation.Numerics.Vector3 position, Boolean animate);
-    void OnPointerPressed(Microsoft.ReactNative.Composition.Input.PointerRoutedEventArgs args);
-    void SetDecelerationRate(Windows.Foundation.Numerics.Vector3 decelerationRate);
-    void SetMaximumZoomScale(Single maximumZoomScale);
-    void SetMinimumZoomScale(Single minimumZoomScale);
-    Boolean Horizontal;
-    void SetSnapPoints(Boolean snapToStart, Boolean snapToEnd, Windows.Foundation.Collections.IVectorView<Single> offsets);
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface IActivityVisual requires IVisual
-  {
-    void Size(Single value);
-    void Brush(IBrush brush);
-    void StartAnimation();
-    void StopAnimation();
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface ICaretVisual
-  {
-    IVisual InnerVisual { get; };
-    void Size(Windows.Foundation.Numerics.Vector2 size);
-    void Position(Windows.Foundation.Numerics.Vector2 position);
-    Boolean IsVisible { get; set; };
-    void Brush(IBrush brush);
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface IFocusVisual
-  {
-    IVisual InnerVisual { get; };
-    Boolean IsFocused { get; set; };
-    Single ScaleFactor { get; set; };
-  }
-
-  [webhosthidden]
-  [experimental]
-  interface ICompositionContext
-  {
-    ISpriteVisual CreateSpriteVisual();
-    IScrollVisual CreateScrollerVisual();
-    IRoundedRectangleVisual CreateRoundedRectangleVisual();
-    IActivityVisual CreateActivityVisual();
-    ICaretVisual CreateCaretVisual();
-    IFocusVisual CreateFocusVisual();
-    IDropShadow CreateDropShadow();
-    IBrush CreateColorBrush(Windows.UI.Color color);
-    IDrawingSurfaceBrush CreateDrawingSurfaceBrush(Windows.Foundation.Size surfaceSize,
+[webhosthidden][experimental] interface IFocusVisual {
+  IVisual InnerVisual {
+    get;
+  };
+  Boolean IsFocused {
+    get;
+    set;
+  };
+  Single ScaleFactor {
+    get;
+    set;
+  };
+}
+
+    [webhosthidden][experimental] interface ICompositionContext {
+  ISpriteVisual CreateSpriteVisual();
+  IScrollVisual CreateScrollerVisual();
+  IRoundedRectangleVisual CreateRoundedRectangleVisual();
+  IActivityVisual CreateActivityVisual();
+  ICaretVisual CreateCaretVisual();
+  IFocusVisual CreateFocusVisual();
+  IDropShadow CreateDropShadow();
+  IBrush CreateColorBrush(Windows.UI.Color color);
+  IDrawingSurfaceBrush CreateDrawingSurfaceBrush(
+      Windows.Foundation.Size surfaceSize,
       Windows.Graphics.DirectX.DirectXPixelFormat pixelFormat,
       Windows.Graphics.DirectX.DirectXAlphaMode alphaMode);
 
-    // TODO Add and hook up to rootnode - to notify the tree
-    // event Windows.Foundation.EventHandler<RenderingDeviceReplacedArgs> RenderingDeviceReplaced;
-  }
+  // TODO Add and hook up to rootnode - to notify the tree
+  // event Windows.Foundation.EventHandler<RenderingDeviceReplacedArgs> RenderingDeviceReplaced;
+}
 
-} // namespace Microsoft.ReactNative.Composition.Experimental
+} // namespace Microsoft.ReactNative.Composition. Experimental

package/Microsoft.ReactNative/Fabric/AbiComponentDescriptor.cpp

@@ -55,7 +55,7 @@ std::shared_ptr<facebook::react::ShadowNode> AbiComponentDescriptor::createShado
   return shadowNode;
 }
 
-facebook::react::ShadowNode::Unshared AbiComponentDescriptor::cloneShadowNode(
+std::shared_ptr<facebook::react::ShadowNode> AbiComponentDescriptor::cloneShadowNode(
     const facebook::react::ShadowNode &sourceShadowNode,
     const facebook::react::ShadowNodeFragment &fragment) const {
   auto shadowNode = std::make_shared<ShadowNodeT>(sourceShadowNode, fragment);
@@ -69,8 +69,8 @@ facebook::react::ShadowNode::Unshared AbiComponentDescriptor::cloneShadowNode(
 }
 
 void AbiComponentDescriptor::appendChild(
-    const facebook::react::ShadowNode::Shared &parentShadowNode,
-    const facebook::react::ShadowNode::Shared &childShadowNode) const {
+    const std::shared_ptr<const facebook::react::ShadowNode> &parentShadowNode,
+    const std::shared_ptr<const facebook::react::ShadowNode> &childShadowNode) const {
   auto concreteParentShadowNode = std::static_pointer_cast<const ShadowNodeT>(parentShadowNode);
   auto concreteNonConstParentShadowNode = std::const_pointer_cast<ShadowNodeT>(concreteParentShadowNode);
   concreteNonConstParentShadowNode->appendChild(childShadowNode);

package/Microsoft.ReactNative/Fabric/AbiComponentDescriptor.h

@@ -32,13 +32,13 @@ class AbiComponentDescriptor : public facebook::react::ComponentDescriptor {
   std::shared_ptr<facebook::react::ShadowNode> createShadowNode(
       const facebook::react::ShadowNodeFragment &fragment,
       facebook::react::ShadowNodeFamily::Shared const &family) const override;
-  facebook::react::ShadowNode::Unshared cloneShadowNode(
+  std::shared_ptr<facebook::react::ShadowNode> cloneShadowNode(
       const facebook::react::ShadowNode &sourceShadowNode,
       const facebook::react::ShadowNodeFragment &fragment) const override;
 
   void appendChild(
-      const facebook::react::ShadowNode::Shared &parentShadowNode,
-      const facebook::react::ShadowNode::Shared &childShadowNode) const override;
+      const std::shared_ptr<const facebook::react::ShadowNode> &parentShadowNode,
+      const std::shared_ptr<const facebook::react::ShadowNode> &childShadowNode) const override;
   virtual facebook::react::Props::Shared cloneProps(
       const facebook::react::PropsParserContext &context,
       const facebook::react::Props::Shared &props,

package/Microsoft.ReactNative/Fabric/AbiShadowNode.cpp

@@ -27,7 +27,8 @@ winrt::Microsoft::ReactNative::IComponentProps AbiProps::UserProps() const noexc
   return m_componentProps;
 }
 
-ShadowNode::ShadowNode(facebook::react::ShadowNode::Shared shadowNode) noexcept : m_shadowNode(shadowNode) {}
+ShadowNode::ShadowNode(std::shared_ptr<const facebook::react::ShadowNode> shadowNode) noexcept
+    : m_shadowNode(shadowNode) {}
 
 void ShadowNode::EnsureUnsealed() noexcept {
   if (auto shadowNode = m_shadowNode.lock()) {

package/Microsoft.ReactNative/Fabric/AbiShadowNode.h

@@ -34,7 +34,7 @@ class AbiProps final : public facebook::react::Props {
 };
 
 struct ShadowNode : ShadowNodeT<ShadowNode> {
-  ShadowNode(facebook::react::ShadowNode::Shared shadowNode) noexcept;
+  ShadowNode(std::shared_ptr<const facebook::react::ShadowNode> shadowNode) noexcept;
 
   void EnsureUnsealed() noexcept;
   winrt::Windows::Foundation::IInspectable Tag() const noexcept;
@@ -46,7 +46,7 @@ struct ShadowNode : ShadowNodeT<ShadowNode> {
   winrt::Microsoft::ReactNative::EventEmitter EventEmitter() const noexcept;
 
  protected:
-  facebook::react::ShadowNode::Weak m_shadowNode;
+  std::weak_ptr<const facebook::react::ShadowNode> m_shadowNode;
   winrt::Windows::Foundation::IInspectable m_tag;
 };
 

package/Microsoft.ReactNative/Fabric/AbiViewComponentDescriptor.h

@@ -70,7 +70,7 @@ class ConcreteAbiViewComponentDescriptor : public facebook::react::ComponentDesc
     return shadowNode;
   }
 
-  facebook::react::ShadowNode::Unshared cloneShadowNode(
+  std::shared_ptr<facebook::react::ShadowNode> cloneShadowNode(
       const facebook::react::ShadowNode &sourceShadowNode,
       const facebook::react::ShadowNodeFragment &fragment) const override {
     auto shadowNode = std::make_shared<ShadowNodeT>(sourceShadowNode, fragment);
@@ -83,8 +83,8 @@ class ConcreteAbiViewComponentDescriptor : public facebook::react::ComponentDesc
   }
 
   void appendChild(
-      const facebook::react::ShadowNode::Shared &parentShadowNode,
-      const facebook::react::ShadowNode::Shared &childShadowNode) const override {
+      const std::shared_ptr<const facebook::react::ShadowNode> &parentShadowNode,
+      const std::shared_ptr<const facebook::react::ShadowNode> &childShadowNode) const override {
     auto concreteParentShadowNode = std::static_pointer_cast<const ShadowNodeT>(parentShadowNode);
     auto concreteNonConstParentShadowNode = std::const_pointer_cast<ShadowNodeT>(concreteParentShadowNode);
     concreteNonConstParentShadowNode->appendChild(childShadowNode);

package/Microsoft.ReactNative/Fabric/AbiViewShadowNode.cpp

@@ -13,7 +13,8 @@
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
-YogaLayoutableShadowNode::YogaLayoutableShadowNode(facebook::react::ShadowNode::Shared shadowNode) noexcept
+YogaLayoutableShadowNode::YogaLayoutableShadowNode(
+    std::shared_ptr<const facebook::react::ShadowNode> shadowNode) noexcept
     : base_type(shadowNode) {}
 
 void YogaLayoutableShadowNode::Layout(winrt::Microsoft::ReactNative::LayoutContext layoutContext) noexcept {

package/Microsoft.ReactNative/Fabric/AbiViewShadowNode.h

@@ -49,7 +49,7 @@ struct LayoutContext : LayoutContextT<LayoutContext> {
 };
 
 struct YogaLayoutableShadowNode : YogaLayoutableShadowNodeT<YogaLayoutableShadowNode, implementation::ShadowNode> {
-  YogaLayoutableShadowNode(facebook::react::ShadowNode::Shared shadowNode) noexcept;
+  YogaLayoutableShadowNode(std::shared_ptr<const facebook::react::ShadowNode> shadowNode) noexcept;
 
   void Layout(winrt::Microsoft::ReactNative::LayoutContext layoutContext) noexcept;
 };

package/Microsoft.ReactNative/Fabric/Composition/CompositionContextHelper.cpp

@@ -910,6 +910,31 @@ struct CompScrollerVisual : winrt::implements<
         m_snapToOffsets.push_back(offset);
       }
     }
+    // Match Paper behavior: snapToOffsets disables pagingEnabled and snapToInterval
+    if (!m_snapToOffsets.empty()) {
+      m_pagingEnabled = false;
+      m_snapToInterval = 0.0f;
+    }
+    ConfigureSnapInertiaModifiers();
+  }
+
+  void PagingEnabled(bool pagingEnabled) noexcept {
+    m_pagingEnabled = pagingEnabled;
+    ConfigureSnapInertiaModifiers();
+  }
+
+  void SnapToInterval(float interval) noexcept {
+    m_snapToInterval = interval;
+    // Match Paper behavior: snapToOffsets disables snapToInterval
+    if (!m_snapToOffsets.empty()) {
+      m_snapToInterval = 0.0f;
+    }
+    ConfigureSnapInertiaModifiers();
+  }
+
+  void SnapToAlignment(
+      winrt::Microsoft::ReactNative::Composition::Experimental::SnapPointsAlignment alignment) noexcept {
+    m_snapToAlignment = alignment;
     ConfigureSnapInertiaModifiers();
   }
 
@@ -934,9 +959,13 @@ struct CompScrollerVisual : winrt::implements<
   }
 
   void Size(winrt::Windows::Foundation::Numerics::float2 const &size) noexcept {
+    bool sizeChanged = (m_visualSize.x != size.x || m_visualSize.y != size.y);
     m_visualSize = size;
     m_visual.Size(size);
     UpdateMaxPosition();
+    if (sizeChanged && m_pagingEnabled) {
+      ConfigureSnapInertiaModifiers();
+    }
   }
 
   void Offset(winrt::Windows::Foundation::Numerics::float3 const &offset) noexcept {
@@ -1046,9 +1075,13 @@ struct CompScrollerVisual : winrt::implements<
   }
 
   void ContentSize(winrt::Windows::Foundation::Numerics::float2 const &size) noexcept {
+    bool sizeChanged = (m_contentSize.x != size.x || m_contentSize.y != size.y);
     m_contentSize = size;
     m_contentVisual.Size(size);
     UpdateMaxPosition();
+    if (sizeChanged && m_pagingEnabled) {
+      ConfigureSnapInertiaModifiers();
+    }
   }
 
   winrt::Windows::Foundation::Numerics::float3 ScrollPosition() const noexcept {
@@ -1155,11 +1188,73 @@ struct CompScrollerVisual : winrt::implements<
     // Collect and deduplicate all snap positions
     std::vector<float> snapPositions;
 
-    if (m_snapToStart) {
-      snapPositions.push_back(0.0f);
+    // Priority: snapToOffsets > snapToInterval > pagingEnabled
+    if (!m_snapToOffsets.empty()) {
+      // Use explicit snap points when snapToOffsets is set (highest priority)
+      if (m_snapToStart) {
+        snapPositions.push_back(0.0f);
+      }
+      snapPositions.insert(snapPositions.end(), m_snapToOffsets.begin(), m_snapToOffsets.end());
+    } else if (m_snapToInterval > 0.0f) {
+      // Generate snap points at interval positions
+      float viewportSize = m_horizontal ? visualSize.x : visualSize.y;
+      float maxScroll =
+          m_horizontal ? std::max(contentSize.x - visualSize.x, 0.0f) : std::max(contentSize.y - visualSize.y, 0.0f);
+
+      // Calculate alignment offset based on snapToAlignment
+      float alignmentOffset = 0.0f;
+      using SnapPointsAlignment = winrt::Microsoft::ReactNative::Composition::Experimental::SnapPointsAlignment;
+      if (m_snapToAlignment == SnapPointsAlignment::Center) {
+        alignmentOffset = -viewportSize / 2.0f;
+      } else if (m_snapToAlignment == SnapPointsAlignment::Far) {
+        alignmentOffset = -viewportSize;
+      }
+      // Near (start) alignment has no offset (alignmentOffset = 0)
+
+      // Generate snap points at interval positions with alignment offset
+      for (float position = alignmentOffset; position <= maxScroll; position += m_snapToInterval) {
+        if (position >= 0.0f) { // Only include positions >= 0
+          snapPositions.push_back(position);
+        }
+      }
+
+      // Ensure we have at least the start position
+      if (snapPositions.empty() || snapPositions.front() > 0.0f) {
+        snapPositions.insert(snapPositions.begin(), 0.0f);
+      }
+
+      // Ensure the end position is included if not already
+      if (!snapPositions.empty() && snapPositions.back() < maxScroll) {
+        snapPositions.push_back(maxScroll);
+      }
+    } else if (m_pagingEnabled) {
+      // Generate snap points at viewport intervals (paging)
+      float viewportSize = m_horizontal ? visualSize.x : visualSize.y;
+      float maxScroll =
+          m_horizontal ? std::max(contentSize.x - visualSize.x, 0.0f) : std::max(contentSize.y - visualSize.y, 0.0f);
+
+      // Only generate paging snap points if viewport size is valid
+      if (viewportSize > 0 && maxScroll > 0) {
+        // Add snap points at each page (viewport size) interval
+        for (float position = 0.0f; position <= maxScroll; position += viewportSize) {
+          snapPositions.push_back(position);
+        }
+
+        // Ensure the end position is included if not already
+        if (!snapPositions.empty() && snapPositions.back() < maxScroll) {
+          snapPositions.push_back(maxScroll);
+        }
+      } else {
+        // If content fits in viewport or invalid size, just snap to start
+        snapPositions.push_back(0.0f);
+      }
+    } else {
+      // No interval or paging - use explicit snap points only
+      if (m_snapToStart) {
+        snapPositions.push_back(0.0f);
+      }
     }
 
-    snapPositions.insert(snapPositions.end(), m_snapToOffsets.begin(), m_snapToOffsets.end());
     std::sort(snapPositions.begin(), snapPositions.end());
     snapPositions.erase(std::unique(snapPositions.begin(), snapPositions.end()), snapPositions.end());
 
@@ -1222,7 +1317,8 @@ struct CompScrollerVisual : winrt::implements<
       restingValues.push_back(restingValue);
     }
 
-    if (m_snapToEnd) {
+    // Only add snapToEnd handling when NOT using pagingEnabled or snapToInterval (they already include end position)
+    if (m_snapToEnd && !m_pagingEnabled && m_snapToInterval <= 0.0f) {
       auto endRestingValue = TTypeRedirects::InteractionTrackerInertiaRestingValue::Create(compositor);
 
       // Create property sets to dynamically compute content - visual size
@@ -1286,6 +1382,10 @@ struct CompScrollerVisual : winrt::implements<
   bool m_horizontal{false};
   bool m_snapToStart{true};
   bool m_snapToEnd{true};
+  bool m_pagingEnabled{false};
+  float m_snapToInterval{0.0f};
+  winrt::Microsoft::ReactNative::Composition::Experimental::SnapPointsAlignment m_snapToAlignment{
+      winrt::Microsoft::ReactNative::Composition::Experimental::SnapPointsAlignment::Near};
   std::vector<float> m_snapToOffsets;
   bool m_inertia{false};
   bool m_custom{false};

package/Microsoft.ReactNative/Fabric/Composition/CompositionDynamicAutomationProvider.cpp

@@ -407,13 +407,24 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
     case UIA_IsOffscreenPropertyId: {
       pRetVal->vt = VT_BOOL;
 
-      // Check if element is offscreen - consider modal content special case
-      bool isOffscreen = (compositionView->getClipState() == ClipState::FullyClipped);
-
-      // Modal content may appear clipped but is visible in its own window
-      if (isOffscreen) {
-        if (const auto hwnd = compositionView->GetHwndForParenting()) {
-          isOffscreen = !(IsWindowVisible(hwnd) && !IsIconic(hwnd));
+      // Special handling for modal content - check if component is in a popup/modal window
+      bool isOffscreen = true;
+      auto clipState = compositionView->getClipState();
+
+      if (clipState != ClipState::FullyClipped) {
+        isOffscreen = false;
+      } else {
+        // Component appears clipped, but check if it's modal content
+        // Modal content may appear clipped due to lack of parent relationships
+        // but should still be considered visible if it's in its own window
+        if (auto hwnd = compositionView->GetHwndForParenting()) {
+          // Check if this window is visible and not minimized
+          if (IsWindowVisible(hwnd) && !IsIconic(hwnd)) {
+            isOffscreen = false; // Window is visible, so content is not offscreen
+          }
+        } else {
+          // If we can't get window info, fall back to clip state
+          isOffscreen = true;
         }
       }