react-native-windows 0.72.14 → 0.73.0-preview.1

package/Microsoft.ReactNative/Fabric/Composition/ReactCompositionViewComponentBuilder.h

@@ -33,11 +33,21 @@ struct ReactCompositionViewComponentBuilder : winrt::implements<
   // (Object handle, UInt32 Msg, UInt64 WParam, Int64 LParam) => Int64
   void SetMessageHandler(MessageHandler impl) noexcept;
 
+  void SetKeyDownHandler(KeyHandler impl) noexcept;
+  void SetKeyUpHandler(KeyHandler impl) noexcept;
+
+  void SetPointerEnteredHandler(PointerHandler impl) noexcept;
+  void SetPointerExitedHandler(PointerHandler impl) noexcept;
+  void SetPointerReleasedHandler(PointerHandler impl) noexcept;
+  void SetPointerPressedHandler(PointerHandler impl) noexcept;
+  void SetPointerMovedHandler(PointerHandler impl) noexcept;
+  void SetPointerWheelChangedHandler(PointerHandler impl) noexcept;
+
  public:
   IComponentProps CreateProps(ViewProps props) noexcept;
 
-  winrt::Windows::Foundation::IInspectable CreateView(ICompositionContext context) noexcept;
-  bool HandeCommand(
+  winrt::Windows::Foundation::IInspectable CreateView(IReactContext reactContext, ICompositionContext context) noexcept;
+  bool HandleCommand(
       winrt::Windows::Foundation::IInspectable handle,
       winrt::hstring commandName,
       IJSValueReader args) noexcept;
@@ -47,6 +57,32 @@ struct ReactCompositionViewComponentBuilder : winrt::implements<
   IVisual CreateVisual(winrt::Windows::Foundation::IInspectable handle) noexcept;
   int64_t
   SendMessage(winrt::Windows::Foundation::IInspectable handle, uint32_t Msg, uint64_t WParam, int64_t LParam) noexcept;
+  void OnKeyDown(
+      winrt::Windows::Foundation::IInspectable handle,
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept;
+  void OnKeyUp(
+      winrt::Windows::Foundation::IInspectable handle,
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept;
+  void OnPointerEntered(
+      winrt::Windows::Foundation::IInspectable handle,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnPointerExited(
+      winrt::Windows::Foundation::IInspectable handle,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnPointerPressed(
+      winrt::Windows::Foundation::IInspectable handle,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnPointerReleased(
+      winrt::Windows::Foundation::IInspectable handle,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnPointerMoved(
+      winrt::Windows::Foundation::IInspectable handle,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnPointerWheelChanged(
+      winrt::Windows::Foundation::IInspectable handle,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
 
  private:
   ViewPropsFactory m_propsFactory;
@@ -58,6 +94,14 @@ struct ReactCompositionViewComponentBuilder : winrt::implements<
   UpdateFinalizer m_finalizer;
   VisualCreator m_visualCreator;
   MessageHandler m_messageHandler;
+  KeyHandler m_keyUp;
+  KeyHandler m_keyDown;
+  PointerHandler m_pointerEntered;
+  PointerHandler m_pointerExited;
+  PointerHandler m_pointerReleased;
+  PointerHandler m_pointerPressed;
+  PointerHandler m_pointerMoved;
+  PointerHandler m_pointerWheelChanged;
 };
 
 } // namespace winrt::Microsoft::ReactNative::Composition

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

@@ -6,6 +6,7 @@
 
 #include "RootComponentView.h"
 
+#include <Fabric/FabricUIManagerModule.h>
 #include "CompositionRootAutomationProvider.h"
 #include "CompositionRootView.h"
 
@@ -13,13 +14,15 @@ namespace Microsoft::ReactNative {
 
 RootComponentView::RootComponentView(
     const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
-    facebook::react::Tag tag)
-    : Super(compContext, tag) {}
+    facebook::react::Tag tag,
+    winrt::Microsoft::ReactNative::ReactContext const &reactContext)
+    : Super(compContext, tag), m_context(reactContext) {}
 
 std::shared_ptr<RootComponentView> RootComponentView::Create(
     const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
-    facebook::react::Tag tag) noexcept {
-  return std::shared_ptr<RootComponentView>(new RootComponentView(compContext, tag));
+    facebook::react::Tag tag,
+    winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
+  return std::shared_ptr<RootComponentView>(new RootComponentView(compContext, tag, reactContext));
 }
 
 RootComponentView *RootComponentView::rootComponentView() noexcept {
@@ -81,6 +84,14 @@ bool RootComponentView::NavigateFocus(const winrt::Microsoft::ReactNative::Focus
   return view != nullptr;
 }
 
+bool RootComponentView::TrySetFocusedComponent(IComponentView &view) noexcept {
+  if (view.focusable()) {
+    view.rootComponentView()->SetFocusedComponent(&view);
+    return true;
+  }
+  return false;
+}
+
 bool RootComponentView::TryMoveFocus(bool next) noexcept {
   if (!m_focusedComponent) {
     return NavigateFocus(winrt::Microsoft::ReactNative::FocusNavigationRequest(
@@ -91,11 +102,8 @@ bool RootComponentView::TryMoveFocus(bool next) noexcept {
   Mso::Functor<bool(IComponentView &)> fn = [currentlyFocused = m_focusedComponent](IComponentView &view) noexcept {
     if (&view == currentlyFocused)
       return false;
-    if (view.focusable()) {
-      view.rootComponentView()->SetFocusedComponent(&view);
-      return true;
-    }
-    return false;
+
+    return view.rootComponentView()->TrySetFocusedComponent(view);
   };
 
   return walkTree(*m_focusedComponent, next, fn);
@@ -113,4 +121,23 @@ std::shared_ptr<RootComponentView> RootComponentView::getPtr() {
   return std::static_pointer_cast<RootComponentView>(shared_from_this());
 }
 
+winrt::IInspectable RootComponentView::UiaProviderFromPoint(const POINT &ptPixels) noexcept {
+  facebook::react::Point ptDips{
+      static_cast<facebook::react::Float>(ptPixels.x) / m_layoutMetrics.pointScaleFactor,
+      static_cast<facebook::react::Float>(ptPixels.y) / m_layoutMetrics.pointScaleFactor};
+
+  facebook::react::Point localPt;
+  auto tag = hitTest(ptDips, localPt, true);
+
+  auto uiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties());
+  if (uiManager == nullptr)
+    return nullptr;
+
+  auto view = uiManager->GetViewRegistry().findComponentViewWithTag(tag);
+  if (view == nullptr)
+    return nullptr;
+
+  return view->EnsureUiaProvider();
+}
+
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/Composition/RootComponentView.h

@@ -18,12 +18,14 @@ struct RootComponentView : CompositionViewComponentView {
 
   [[nodiscard]] static std::shared_ptr<RootComponentView> Create(
       const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
-      facebook::react::Tag tag) noexcept;
+      facebook::react::Tag tag,
+      winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
   std::shared_ptr<RootComponentView> getPtr();
 
   ::Microsoft::ReactNative::IComponentView *GetFocusedComponent() noexcept;
   void SetFocusedComponent(::Microsoft::ReactNative::IComponentView *value) noexcept;
+  bool TrySetFocusedComponent(::Microsoft::ReactNative::IComponentView &view) noexcept;
 
   bool NavigateFocus(const winrt::Microsoft::ReactNative::FocusNavigationRequest &request) noexcept;
 
@@ -33,11 +35,15 @@ struct RootComponentView : CompositionViewComponentView {
 
   winrt::IInspectable EnsureUiaProvider() noexcept override;
 
+  winrt::IInspectable UiaProviderFromPoint(const POINT &ptPixels) noexcept;
+
  private:
   RootComponentView(
       const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
-      facebook::react::Tag tag);
+      facebook::react::Tag tag,
+      winrt::Microsoft::ReactNative::ReactContext const &reactContext);
   ::Microsoft::ReactNative::IComponentView *m_focusedComponent = nullptr;
+  winrt::Microsoft::ReactNative::ReactContext m_context;
 };
 
 } // namespace Microsoft::ReactNative

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

@@ -21,6 +21,8 @@
 
 namespace Microsoft::ReactNative {
 
+constexpr float c_scrollerLineDelta = 16.0f;
+
 std::shared_ptr<ScrollViewComponentView> ScrollViewComponentView::Create(
     const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
     facebook::react::Tag tag) noexcept {
@@ -149,32 +151,20 @@ void ScrollViewComponentView::updateProps(
 
   if (!oldProps || oldViewProps.backgroundColor != newViewProps.backgroundColor) {
     if (newViewProps.backgroundColor) {
-      m_scrollVisual.Brush(m_compContext.CreateColorBrush((*newViewProps.backgroundColor).m_color));
+      m_scrollVisual.Brush(m_compContext.CreateColorBrush(newViewProps.backgroundColor.AsWindowsColor()));
     } else {
       m_scrollVisual.Brush(m_compContext.CreateColorBrush({0, 0, 0, 0}));
     }
   }
 
-  /*
-  if (oldViewProps.borderColors != newViewProps.borderColors) {
-    if (newViewProps.borderColors.all) {
-      m_element.BorderBrush(SolidColorBrushFrom(*newViewProps.borderColors.all));
-    } else {
-      m_element.ClearValue(winrt::Microsoft::ReactNative::ViewPanel::BorderBrushProperty());
-    }
-  }
-
-  if (oldViewProps.borderStyles != newViewProps.borderStyles) {
-    m_needsBorderUpdate = true;
-  }
-  */
-
+  // update BaseComponentView props
+  updateShadowProps(oldViewProps, newViewProps, m_visual);
+  updateTransformProps(oldViewProps, newViewProps, m_visual);
   updateBorderProps(oldViewProps, newViewProps);
+
   m_props = std::static_pointer_cast<facebook::react::ViewProps const>(props);
 }
 
-void ScrollViewComponentView::updateEventEmitter(facebook::react::EventEmitter::Shared const &eventEmitter) noexcept {}
-
 void ScrollViewComponentView::updateState(
     facebook::react::State::Shared const &state,
     facebook::react::State::Shared const &oldState) noexcept {
@@ -219,8 +209,7 @@ void ScrollViewComponentView::finalizeUpdates(RNComponentViewUpdateMask updateMa
 }
 void ScrollViewComponentView::prepareForRecycle() noexcept {}
 facebook::react::Props::Shared ScrollViewComponentView::props() noexcept {
-  assert(false);
-  return {};
+  return static_cast<facebook::react::Props::Shared>(m_props);
 }
 
 /*
@@ -268,38 +257,156 @@ void ScrollViewComponentView::OnPointerDown(const winrt::Windows::UI::Input::Poi
 }
 */
 
-bool ScrollViewComponentView::ScrollWheel(facebook::react::Point pt, int32_t delta) noexcept {
-  facebook::react::Point ptViewport{pt.x - m_layoutMetrics.frame.origin.x, pt.y - m_layoutMetrics.frame.origin.y};
+void ScrollViewComponentView::onPointerWheelChanged(
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
+  auto ppp = args.GetCurrentPoint(-1).Properties();
+  auto delta = static_cast<float>(ppp.MouseWheelDelta());
+  if (ppp.IsHorizontalMouseWheel()) {
+    if (delta > 0) {
+      if (scrollLeft(delta * m_layoutMetrics.pointScaleFactor, true)) {
+        args.Handled(true);
+      }
+    } else if (delta < 0) {
+      if (scrollRight(-delta * m_layoutMetrics.pointScaleFactor, true)) {
+        args.Handled(true);
+      }
+    }
+  } else {
+    if (delta > 0) {
+      if (scrollUp(delta * m_layoutMetrics.pointScaleFactor, true)) {
+        args.Handled(true);
+      }
+    } else if (delta < 0) {
+      if (scrollDown(-delta * m_layoutMetrics.pointScaleFactor, true)) {
+        args.Handled(true);
+      }
+    }
+  }
+}
 
-  facebook::react::Point ptContent{
-      ptViewport.x + m_scrollVisual.ScrollPosition().x / m_layoutMetrics.pointScaleFactor,
-      ptViewport.y + m_scrollVisual.ScrollPosition().y / m_layoutMetrics.pointScaleFactor};
+void ScrollViewComponentView::onKeyDown(
+    const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
+    const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept {
+  switch (args.Key()) {
+    case winrt::Windows::System::VirtualKey::End:
+      args.Handled(scrollToEnd(true));
+      break;
+    case winrt::Windows::System::VirtualKey::Home:
+      args.Handled(scrollToStart(true));
+      break;
+    case winrt::Windows::System::VirtualKey::PageDown:
+      args.Handled(pageDown(true));
+      break;
+    case winrt::Windows::System::VirtualKey::PageUp:
+      args.Handled(pageUp(true));
+      break;
+    case winrt::Windows::System::VirtualKey::Up:
+      args.Handled(lineUp(true));
+      break;
+    case winrt::Windows::System::VirtualKey::Down:
+      args.Handled(lineDown(true));
+      break;
+    case winrt::Windows::System::VirtualKey::Left:
+      args.Handled(lineLeft(true));
+      break;
+    case winrt::Windows::System::VirtualKey::Right:
+      args.Handled(lineRight(true));
+      break;
+  }
+}
 
-  if (std::any_of(m_children.rbegin(), m_children.rend(), [ptContent, delta](auto child) {
-        return const_cast<CompositionBaseComponentView *>(static_cast<const CompositionBaseComponentView *>(child))
-            ->ScrollWheel(ptContent, delta);
-      }))
-    return true;
+bool ScrollViewComponentView::scrollToEnd(bool animate) noexcept {
+  if ((((m_contentSize.height - m_layoutMetrics.frame.size.height) * m_layoutMetrics.pointScaleFactor) -
+       m_scrollVisual.ScrollPosition().y) < 1.0f) {
+    return false;
+  }
 
-  if (ptViewport.x >= 0 && ptViewport.x <= m_layoutMetrics.frame.size.width && ptViewport.y >= 0 &&
-      ptViewport.y <= m_layoutMetrics.frame.size.height) {
-    m_scrollVisual.ScrollBy({0, static_cast<float>(-delta), 0});
-    return true;
+  auto x = (m_contentSize.width - m_layoutMetrics.frame.size.width) * m_layoutMetrics.pointScaleFactor;
+  auto y = (m_contentSize.height - m_layoutMetrics.frame.size.height) * m_layoutMetrics.pointScaleFactor;
+  m_scrollVisual.TryUpdatePosition({static_cast<float>(x), static_cast<float>(y), 0.0f}, animate);
+  return true;
+}
+
+bool ScrollViewComponentView::scrollToStart(bool animate) noexcept {
+  m_scrollVisual.TryUpdatePosition({0.0f, 0.0f, 0.0f}, animate);
+  return true;
+}
+
+bool ScrollViewComponentView::pageUp(bool animate) noexcept {
+  return scrollUp(m_layoutMetrics.frame.size.height * m_layoutMetrics.pointScaleFactor, animate);
+}
+
+bool ScrollViewComponentView::pageDown(bool animate) noexcept {
+  return scrollDown(m_layoutMetrics.frame.size.height * m_layoutMetrics.pointScaleFactor, animate);
+}
+
+bool ScrollViewComponentView::lineUp(bool animate) noexcept {
+  return scrollUp(c_scrollerLineDelta * m_layoutMetrics.pointScaleFactor, animate);
+}
+
+bool ScrollViewComponentView::lineDown(bool animate) noexcept {
+  return scrollDown(c_scrollerLineDelta * m_layoutMetrics.pointScaleFactor, animate);
+}
+
+bool ScrollViewComponentView::lineLeft(bool animate) noexcept {
+  return scrollLeft(c_scrollerLineDelta * m_layoutMetrics.pointScaleFactor, animate);
+}
+
+bool ScrollViewComponentView::lineRight(bool animate) noexcept {
+  return scrollRight(c_scrollerLineDelta * m_layoutMetrics.pointScaleFactor, animate);
+}
+
+bool ScrollViewComponentView::scrollDown(float delta, bool animate) noexcept {
+  if (((m_contentSize.height - m_layoutMetrics.frame.size.height) * m_layoutMetrics.pointScaleFactor) -
+          m_scrollVisual.ScrollPosition().y <
+      1.0f) {
+    return false;
+  }
+
+  m_scrollVisual.ScrollBy({0, delta, 0}, animate);
+  return true;
+}
+
+bool ScrollViewComponentView::scrollUp(float delta, bool animate) noexcept {
+  if (m_scrollVisual.ScrollPosition().y <= 0.0f) {
+    return false;
+  }
+
+  m_scrollVisual.ScrollBy({0, -delta, 0}, animate);
+  return true;
+}
+
+bool ScrollViewComponentView::scrollLeft(float delta, bool animate) noexcept {
+  if (m_scrollVisual.ScrollPosition().x <= 0.0f) {
+    return false;
   }
 
-  return false;
+  m_scrollVisual.ScrollBy({delta, 0, 0}, animate);
+  return true;
+}
+
+bool ScrollViewComponentView::scrollRight(float delta, bool animate) noexcept {
+  if (((m_contentSize.width - m_layoutMetrics.frame.size.width) * m_layoutMetrics.pointScaleFactor) -
+          m_scrollVisual.ScrollPosition().x <
+      1.0f) {
+    return false;
+  }
+
+  m_scrollVisual.ScrollBy({delta, 0, 0}, animate);
+  return true;
 }
 
 void ScrollViewComponentView::handleCommand(std::string const &commandName, folly::dynamic const &arg) noexcept {
   if (commandName == "scrollTo") {
-    auto x = arg[0].asDouble();
-    auto y = arg[1].asDouble();
+    auto x = arg[0].asDouble() * m_layoutMetrics.pointScaleFactor;
+    auto y = arg[1].asDouble() * m_layoutMetrics.pointScaleFactor;
     auto animate = arg[2].asBool();
     m_scrollVisual.TryUpdatePosition({static_cast<float>(x), static_cast<float>(y), 0.0f}, animate);
   } else if (commandName == "flashScrollIndicators") {
     // No-op for now
   } else if (commandName == "scrollToEnd") {
-    // No-op for now
+    auto animate = arg[0].asBool();
+    scrollToEnd(animate);
   } else if (commandName == "zoomToRect") {
     // No-op for now
   } else {
@@ -307,6 +414,98 @@ void ScrollViewComponentView::handleCommand(std::string const &commandName, foll
   }
 }
 
+void ScrollViewComponentView::StartBringIntoView(BringIntoViewOptions &&options) noexcept {
+  RECT rc{getClientRect()};
+
+  if (!options.TargetRect) {
+    Super::StartBringIntoView(std::move(options));
+    return;
+  }
+
+  bool needsScroll = false;
+  float scrollToVertical = m_scrollVisual.ScrollPosition().y;
+  float scrollToHorizontal = m_scrollVisual.ScrollPosition().x;
+  float viewerHeight = m_layoutMetrics.frame.size.height * m_layoutMetrics.pointScaleFactor;
+  float viewerWidth = m_layoutMetrics.frame.size.width * m_layoutMetrics.pointScaleFactor;
+  float targetBottom = options.TargetRect->origin.y + options.TargetRect->size.height;
+  float targetRight = options.TargetRect->origin.x + options.TargetRect->size.width;
+
+  if (isnan(options.VerticalAlignmentRatio)) {
+    // Scroll Down
+    if (targetBottom > (m_scrollVisual.ScrollPosition().y + viewerHeight) &&
+        options.TargetRect->origin.y > m_scrollVisual.ScrollPosition().y) {
+      needsScroll = true;
+      if (options.TargetRect->size.height > viewerHeight) {
+        scrollToVertical = options.TargetRect->origin.y + options.VerticalOffset;
+      } else {
+        scrollToVertical = (targetBottom - viewerHeight) + options.VerticalOffset;
+      }
+      // Scroll Up
+    } else if (
+        options.TargetRect->origin.y < m_scrollVisual.ScrollPosition().y &&
+        targetBottom < (m_scrollVisual.ScrollPosition().y + viewerHeight)) {
+      needsScroll = true;
+      if (options.TargetRect->size.height > viewerHeight) {
+        scrollToVertical = targetBottom - viewerHeight - options.VerticalOffset;
+      } else {
+        scrollToVertical = options.TargetRect->origin.y - options.VerticalOffset;
+      }
+    }
+  } else {
+    needsScroll = true;
+    scrollToVertical = options.TargetRect->getMidY() - (viewerHeight * options.VerticalAlignmentRatio);
+  }
+
+  if (isnan(options.HorizontalAlignmentRatio)) {
+    // Scroll Right
+    if (targetRight > (m_scrollVisual.ScrollPosition().x + viewerWidth) &&
+        options.TargetRect->origin.x > m_scrollVisual.ScrollPosition().x) {
+      needsScroll = true;
+      if (options.TargetRect->size.width > viewerWidth) {
+        scrollToHorizontal = options.TargetRect->origin.x + options.HorizontalOffset;
+      } else {
+        scrollToHorizontal = (targetRight - viewerWidth) + options.HorizontalOffset;
+      }
+      // Scroll Left
+    } else if (
+        options.TargetRect->origin.x < m_scrollVisual.ScrollPosition().x &&
+        targetRight < (m_scrollVisual.ScrollPosition().x + viewerWidth)) {
+      needsScroll = true;
+      if (options.TargetRect->size.width > viewerWidth) {
+        scrollToHorizontal = targetRight - viewerWidth - options.HorizontalOffset;
+      } else {
+        scrollToHorizontal = options.TargetRect->origin.x - options.HorizontalOffset;
+      }
+    }
+  } else {
+    needsScroll = true;
+    scrollToHorizontal = options.TargetRect->getMidX() - (viewerWidth * options.HorizontalAlignmentRatio);
+  }
+
+  if (needsScroll) {
+    m_scrollVisual.TryUpdatePosition(
+        {static_cast<float>(scrollToHorizontal), static_cast<float>(scrollToVertical), 0.0f}, options.AnimationDesired);
+  }
+
+  if (m_parent) {
+    options.TargetRect->origin.y += m_layoutMetrics.frame.origin.y * m_layoutMetrics.pointScaleFactor;
+    options.TargetRect->origin.x += m_layoutMetrics.frame.origin.x * m_layoutMetrics.pointScaleFactor;
+
+    options.TargetRect->origin.y -= m_scrollVisual.ScrollPosition().y;
+    options.TargetRect->origin.x -= m_scrollVisual.ScrollPosition().x;
+
+    facebook::react::Rect viewerRect = {
+        {m_layoutMetrics.frame.origin.x * m_layoutMetrics.pointScaleFactor,
+         m_layoutMetrics.frame.origin.y * m_layoutMetrics.pointScaleFactor},
+        {m_layoutMetrics.frame.size.width * m_layoutMetrics.pointScaleFactor,
+         m_layoutMetrics.frame.size.height * m_layoutMetrics.pointScaleFactor}};
+
+    options.TargetRect = facebook::react::Rect::intersect(viewerRect, options.TargetRect.value());
+
+    m_parent->StartBringIntoView(std::move(options));
+  }
+}
+
 void ScrollViewComponentView::ensureVisual() noexcept {
   if (!m_visual) {
     m_visual = m_compContext.CreateSpriteVisual();
@@ -316,7 +515,7 @@ void ScrollViewComponentView::ensureVisual() noexcept {
         winrt::auto_revoke,
         [this](
             winrt::IInspectable const & /*sender*/,
-            winrt::Microsoft::ReactNative::Composition::ScrollPositionChangedArgs const &args) {
+            winrt::Microsoft::ReactNative::Composition::IScrollPositionChangedArgs const &args) {
           auto eventEmitter = GetEventEmitter();
           if (eventEmitter) {
             facebook::react::ScrollViewMetrics scrollMetrics;
@@ -335,8 +534,10 @@ void ScrollViewComponentView::ensureVisual() noexcept {
   }
 }
 
-facebook::react::Tag ScrollViewComponentView::hitTest(facebook::react::Point pt, facebook::react::Point &localPt)
-    const noexcept {
+facebook::react::Tag ScrollViewComponentView::hitTest(
+    facebook::react::Point pt,
+    facebook::react::Point &localPt,
+    bool ignorePointerEvents) const noexcept {
   facebook::react::Point ptViewport{pt.x - m_layoutMetrics.frame.origin.x, pt.y - m_layoutMetrics.frame.origin.y};
 
   facebook::react::Point ptContent{
@@ -344,7 +545,7 @@ facebook::react::Tag ScrollViewComponentView::hitTest(facebook::react::Point pt,
       ptViewport.y + m_scrollVisual.ScrollPosition().y / m_layoutMetrics.pointScaleFactor};
 
   facebook::react::Tag targetTag;
-  if ((m_props->pointerEvents == facebook::react::PointerEventsMode::Auto ||
+  if ((ignorePointerEvents || m_props->pointerEvents == facebook::react::PointerEventsMode::Auto ||
        m_props->pointerEvents == facebook::react::PointerEventsMode::BoxNone) &&
       std::any_of(m_children.rbegin(), m_children.rend(), [&targetTag, &ptContent, &localPt](auto child) {
         targetTag = static_cast<const CompositionBaseComponentView *>(child)->hitTest(ptContent, localPt);
@@ -352,7 +553,7 @@ facebook::react::Tag ScrollViewComponentView::hitTest(facebook::react::Point pt,
       }))
     return targetTag;
 
-  if ((m_props->pointerEvents == facebook::react::PointerEventsMode::Auto ||
+  if ((ignorePointerEvents || m_props->pointerEvents == facebook::react::PointerEventsMode::Auto ||
        m_props->pointerEvents == facebook::react::PointerEventsMode::BoxOnly) &&
       ptViewport.x >= 0 && ptViewport.x <= m_layoutMetrics.frame.size.width && ptViewport.y >= 0 &&
       ptViewport.y <= m_layoutMetrics.frame.size.height) {
@@ -367,4 +568,8 @@ winrt::Microsoft::ReactNative::Composition::IVisual ScrollViewComponentView::Vis
   return m_visual;
 }
 
+std::string ScrollViewComponentView::DefaultControlType() const noexcept {
+  return "scrollbar";
+}
+
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/Composition/ScrollViewComponentView.h

@@ -60,7 +60,6 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
   void unmountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept override;
   void updateProps(facebook::react::Props::Shared const &props, facebook::react::Props::Shared const &oldProps) noexcept
       override;
-  void updateEventEmitter(facebook::react::EventEmitter::Shared const &eventEmitter) noexcept override;
   void updateState(facebook::react::State::Shared const &state, facebook::react::State::Shared const &oldState) noexcept
       override;
   void updateLayoutMetrics(
@@ -69,13 +68,20 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
   void finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept override;
   void prepareForRecycle() noexcept override;
   facebook::react::Props::Shared props() noexcept override;
+  void onKeyDown(
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept override;
 
   void handleCommand(std::string const &commandName, folly::dynamic const &arg) noexcept override;
-  facebook::react::Tag hitTest(facebook::react::Point pt, facebook::react::Point &localPt) const noexcept override;
+  facebook::react::Tag hitTest(facebook::react::Point pt, facebook::react::Point &localPt, bool ignorePointerEvents)
+      const noexcept override;
   winrt::Microsoft::ReactNative::Composition::IVisual Visual() const noexcept override;
 
-  // void OnPointerDown(const winrt::Windows::UI::Input::PointerPoint &pp) noexcept override;
-  bool ScrollWheel(facebook::react::Point pt, int32_t delta) noexcept override;
+  void onPointerWheelChanged(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept override;
+
+  void StartBringIntoView(BringIntoViewOptions &&args) noexcept override;
+  virtual std::string DefaultControlType() const noexcept;
 
  private:
   ScrollViewComponentView(
@@ -84,11 +90,23 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
 
   void ensureVisual() noexcept;
   void updateContentVisualSize() noexcept;
+  bool scrollToEnd(bool animate) noexcept;
+  bool scrollToStart(bool animate) noexcept;
+  bool pageUp(bool animate) noexcept;
+  bool pageDown(bool animate) noexcept;
+  bool lineUp(bool animate) noexcept;
+  bool lineDown(bool animate) noexcept;
+  bool lineLeft(bool animate) noexcept;
+  bool lineRight(bool animate) noexcept;
+  bool scrollDown(float delta, bool animate) noexcept;
+  bool scrollUp(float delta, bool animate) noexcept;
+  bool scrollLeft(float delta, bool aniamte) noexcept;
+  bool scrollRight(float delta, bool animate) noexcept;
 
   facebook::react::Size m_contentSize;
-  winrt::Microsoft::ReactNative::Composition::IVisual m_visual{nullptr};
-  winrt::Microsoft::ReactNative::Composition::ScrollVisual m_scrollVisual{nullptr};
-  winrt::Microsoft::ReactNative::Composition::ScrollVisual::ScrollPositionChanged_revoker
+  winrt::Microsoft::ReactNative::Composition::ISpriteVisual m_visual{nullptr};
+  winrt::Microsoft::ReactNative::Composition::IScrollVisual m_scrollVisual{nullptr};
+  winrt::Microsoft::ReactNative::Composition::IScrollVisual::ScrollPositionChanged_revoker
       m_scrollPositionChangedRevoker{};
 
   facebook::react::SharedViewProps m_props;
@@ -96,7 +114,6 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
   bool m_isScrollingFromInertia = false;
   bool m_isScrolling = false;
   bool m_isHorizontal = false;
-  bool m_isScrollingEnabled = true;
   bool m_changeViewAfterLoaded = false;
   bool m_dismissKeyboardOnDrag = false;