react-native-windows 0.78.5 → 0.78.6

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

@@ -708,10 +708,19 @@ struct CompScrollerVisual : winrt::implements<
         typename TTypeRedirects::InteractionTrackerInertiaStateEnteredArgs args) noexcept {
       m_outer->m_custom = false;
       m_outer->m_inertia = true;
+      m_outer->m_currentPosition = args.NaturalRestingPosition();
+      // When the user stops interacting with the object, tracker can go into two paths:
+      // 1. tracker goes into idle state immediately
+      // 2. tracker has just started gliding into Inertia state
+      // Fire ScrollEndDrag
+      m_outer->FireScrollEndDrag({args.NaturalRestingPosition().x, args.NaturalRestingPosition().y});
     }
     void InteractingStateEntered(
         typename TTypeRedirects::InteractionTracker sender,
-        typename TTypeRedirects::InteractionTrackerInteractingStateEnteredArgs args) noexcept {}
+        typename TTypeRedirects::InteractionTrackerInteractingStateEnteredArgs args) noexcept {
+      // Fire when the user starts dragging the object
+      m_outer->FireScrollBeginDrag({sender.Position().x, sender.Position().y});
+    }
     void RequestIgnored(
         typename TTypeRedirects::InteractionTracker sender,
         typename TTypeRedirects::InteractionTrackerRequestIgnoredArgs args) noexcept {}
@@ -834,6 +843,18 @@ struct CompScrollerVisual : winrt::implements<
     UpdateInteractionModes();
   }
 
+  void SetDecelerationRate(winrt::Windows::Foundation::Numerics::float3 const &decelerationRate) noexcept {
+    m_interactionTracker.PositionInertiaDecayRate(decelerationRate);
+  }
+
+  void SetMaximumZoomScale(float maximumZoomScale) const noexcept {
+    m_interactionTracker.MaxScale(maximumZoomScale);
+  }
+
+  void SetMinimumZoomScale(float minimumZoomScale) noexcept {
+    m_interactionTracker.MinScale(minimumZoomScale);
+  }
+
   void Opacity(float opacity) noexcept {
     m_visual.Opacity(opacity);
   }
@@ -918,10 +939,32 @@ struct CompScrollerVisual : winrt::implements<
     return m_scrollPositionChangedEvent.add(handler);
   }
 
+  winrt::event_token ScrollBeginDrag(
+      winrt::Windows::Foundation::EventHandler<
+          winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs> const
+          &handler) noexcept {
+    return m_scrollBeginDragEvent.add(handler);
+  }
+
+  winrt::event_token ScrollEndDrag(
+      winrt::Windows::Foundation::EventHandler<
+          winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs> const
+          &handler) noexcept {
+    return m_scrollEndDragEvent.add(handler);
+  }
+
   void ScrollPositionChanged(winrt::event_token const &token) noexcept {
     m_scrollPositionChangedEvent.remove(token);
   }
 
+  void ScrollBeginDrag(winrt::event_token const &token) noexcept {
+    m_scrollBeginDragEvent.remove(token);
+  }
+
+  void ScrollEndDrag(winrt::event_token const &token) noexcept {
+    m_scrollEndDragEvent.remove(token);
+  }
+
   void ContentSize(winrt::Windows::Foundation::Numerics::float2 const &size) noexcept {
     m_contentSize = size;
     m_contentVisual.Size(size);
@@ -992,6 +1035,14 @@ struct CompScrollerVisual : winrt::implements<
     m_scrollPositionChangedEvent(*this, winrt::make<CompScrollPositionChangedArgs>(position));
   }
 
+  void FireScrollBeginDrag(winrt::Windows::Foundation::Numerics::float2 position) noexcept {
+    m_scrollBeginDragEvent(*this, winrt::make<CompScrollPositionChangedArgs>(position));
+  }
+
+  void FireScrollEndDrag(winrt::Windows::Foundation::Numerics::float2 position) noexcept {
+    m_scrollEndDragEvent(*this, winrt::make<CompScrollPositionChangedArgs>(position));
+  }
+
   void UpdateMaxPosition() noexcept {
     m_interactionTracker.MaxPosition(
         {std::max<float>(m_contentSize.x - m_visualSize.x, 0),
@@ -1010,6 +1061,12 @@ struct CompScrollerVisual : winrt::implements<
   winrt::event<winrt::Windows::Foundation::EventHandler<
       winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs>>
       m_scrollPositionChangedEvent;
+  winrt::event<winrt::Windows::Foundation::EventHandler<
+      winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs>>
+      m_scrollBeginDragEvent;
+  winrt::event<winrt::Windows::Foundation::EventHandler<
+      winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs>>
+      m_scrollEndDragEvent;
   typename TTypeRedirects::SpriteVisual m_visual{nullptr};
   typename TTypeRedirects::SpriteVisual m_contentVisual{nullptr};
   typename TTypeRedirects::InteractionTracker m_interactionTracker{nullptr};
@@ -1357,16 +1414,7 @@ struct CompActivityVisual : winrt::implements<
     _themeProperties.InsertVector4(L"Foreground", ColorAsVector4({0, 0, 0, 0}));
 
     visual.Children().InsertAtTop(Root());
-
-    auto easing = _c.CreateLinearEasingFunction();
-    const auto progressAnimation = _c.CreateScalarKeyFrameAnimation();
-    progressAnimation.Duration(winrt::Windows::Foundation::TimeSpan{c_durationTicks});
-    progressAnimation.InsertKeyFrame(0.0f, 0.0f);
-    progressAnimation.InsertKeyFrame(1.0f, 1.0f, easing);
-    progressAnimation.IterationBehavior(TTypeRedirects::AnimationIterationBehavior::Forever);
-
-    _root.Properties().StartAnimation(L"Progress", progressAnimation);
-    _root.StartAnimation(L"Progress", progressAnimation);
+    StartAnimation();
   }
 
   void Brush(winrt::Microsoft::ReactNative::Composition::Experimental::IBrush brush) noexcept {
@@ -1492,6 +1540,24 @@ struct CompActivityVisual : winrt::implements<
     SetAnimationClass<TTypeRedirects>(value, m_visual);
   }
 
+  void StartAnimation() noexcept {
+    auto easing = _c.CreateLinearEasingFunction();
+    const auto progressAnimation = _c.CreateScalarKeyFrameAnimation();
+    progressAnimation.Duration(winrt::Windows::Foundation::TimeSpan{c_durationTicks});
+    progressAnimation.InsertKeyFrame(0.0f, 0.0f);
+    progressAnimation.InsertKeyFrame(1.0f, 1.0f, easing);
+    progressAnimation.IterationBehavior(TTypeRedirects::AnimationIterationBehavior::Forever);
+
+    _root.Properties().StartAnimation(L"Progress", progressAnimation);
+    _root.StartAnimation(L"Progress", progressAnimation);
+  }
+
+  void StopAnimation() noexcept {
+    _root.Properties().InsertScalar(L"Progress", 0.7f);
+    _root.Properties().StopAnimation(L"Progress");
+    _root.StopAnimation(L"Progress");
+  }
+
  private:
   typename TTypeRedirects::SpriteVisual m_visual{nullptr};
   typename TTypeRedirects::SpriteVisual m_contentVisual{nullptr};

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

@@ -1,12 +1,14 @@
 #include "pch.h"
 #include "CompositionDynamicAutomationProvider.h"
 #include <Fabric/ComponentView.h>
+#include <Fabric/Composition/CompositionAnnotationProvider.h>
 #include <Fabric/Composition/CompositionTextRangeProvider.h>
 #include <Fabric/Composition/ParagraphComponentView.h>
 #include <Fabric/Composition/ScrollViewComponentView.h>
 #include <Fabric/Composition/SwitchComponentView.h>
 #include <Fabric/Composition/TextInput/WindowsTextInputComponentView.h>
 #include <Unicode.h>
+#include <winrt/Microsoft.UI.Content.h>
 #include "RootComponentView.h"
 #include "UiaHelpers.h"
 
@@ -35,14 +37,33 @@ CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
                          strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), this)
                          .try_as<ITextProvider2>();
   }
+
+  if (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ViewComponentView>()) {
+    m_annotationProvider = winrt::make<CompositionAnnotationProvider>(
+                               strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), this)
+                               .try_as<IAnnotationProvider>();
+  }
 }
 
+CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
+    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+    const winrt::Microsoft::UI::Content::ChildSiteLink &childSiteLink) noexcept
+    : m_view{componentView}, m_childSiteLink{childSiteLink} {}
+
 HRESULT __stdcall CompositionDynamicAutomationProvider::Navigate(
     NavigateDirection direction,
     IRawElementProviderFragment **pRetVal) {
   if (pRetVal == nullptr)
     return E_POINTER;
 
+  if (m_childSiteLink) {
+    if (direction == NavigateDirection_FirstChild || direction == NavigateDirection_LastChild) {
+      auto fragment = m_childSiteLink.AutomationProvider().try_as<IRawElementProviderFragment>();
+      *pRetVal = fragment.detach();
+      return S_OK;
+    }
+  }
+
   return UiaNavigateHelper(m_view.view(), direction, *pRetVal);
 }
 
@@ -268,6 +289,11 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
       strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>()) {
     m_textProvider.as<IUnknown>().copy_to(pRetVal);
   }
+  if (patternId == UIA_AnnotationPatternId &&
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ViewComponentView>() &&
+      accessibilityAnnotationHasValue(props->accessibilityAnnotation)) {
+    m_annotationProvider.as<IUnknown>().copy_to(pRetVal);
+  }
 
   return S_OK;
 }
@@ -545,8 +571,24 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
           : SysAllocString(L"");
       break;
     }
+    case UIA_LevelPropertyId: {
+      pRetVal->vt = VT_I4;
+      pRetVal->lVal = props->accessibilityLevel;
+      break;
+    }
+    case UIA_AccessKeyPropertyId: {
+      pRetVal->vt = VT_BSTR;
+      auto accessKey = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityAccessKey.value_or(""));
+      pRetVal->bstrVal = SysAllocString(accessKey.c_str());
+      break;
+    }
+    case UIA_ItemTypePropertyId: {
+      pRetVal->vt = VT_BSTR;
+      auto itemtype = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityItemType.value_or(""));
+      pRetVal->bstrVal = SysAllocString(itemtype.c_str());
+      break;
+    }
   }
-
   return hr;
 }
 

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

@@ -26,6 +26,10 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   CompositionDynamicAutomationProvider(
       const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept;
 
+  CompositionDynamicAutomationProvider(
+      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+      const winrt::Microsoft::UI::Content::ChildSiteLink &childContentLink) noexcept;
+
   // inherited via IRawElementProviderFragment
   virtual HRESULT __stdcall Navigate(NavigateDirection direction, IRawElementProviderFragment **pRetVal) override;
   virtual HRESULT __stdcall GetRuntimeId(SAFEARRAY **pRetVal) override;
@@ -97,7 +101,10 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;
   winrt::com_ptr<ITextProvider2> m_textProvider;
+  winrt::com_ptr<IAnnotationProvider> m_annotationProvider;
   std::vector<winrt::com_ptr<IRawElementProviderSimple>> m_selectionItems;
+  // Non-null when this UIA node is the peer of a ContentIslandComponentView.
+  winrt::Microsoft::UI::Content::ChildSiteLink m_childSiteLink{nullptr};
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -196,6 +196,20 @@ void CompositionEventHandler::Initialize() noexcept {
       }
     });
 
+    m_pointerExitedToken = pointerSource.PointerExited([wkThis = weak_from_this()](
+                                                           winrt::Microsoft::UI::Input::InputPointerSource const &,
+                                                           winrt::Microsoft::UI::Input::PointerEventArgs const &args) {
+      if (auto strongThis = wkThis.lock()) {
+        if (auto strongRootView = strongThis->m_wkRootView.get()) {
+          if (strongThis->SurfaceId() == -1)
+            return;
+          auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+              args.CurrentPoint(), strongRootView.ScaleFactor());
+          strongThis->onPointerExited(pp, args.KeyModifiers());
+        }
+      }
+    });
+
     m_pointerCaptureLostToken =
         pointerSource.PointerCaptureLost([wkThis = weak_from_this()](
                                              winrt::Microsoft::UI::Input::InputPointerSource const &,
@@ -622,17 +636,6 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
 
   auto eventPathViews = GetTouchableViewsInPathToRoot(targetView);
 
-  // Over
-  if (targetView != nullptr && previousTargetTag != targetView.Tag()) {
-    bool shouldEmitOverEvent =
-        IsAnyViewInPathListeningToEvent(eventPathViews, facebook::react::ViewEvents::Offset::PointerOver);
-    const auto eventEmitter = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(targetView)
-                                  ->eventEmitterAtPoint(event.offsetPoint);
-    if (shouldEmitOverEvent && eventEmitter != nullptr) {
-      eventEmitter->onPointerOver(event);
-    }
-  }
-
   // Entering
 
   // We only want to emit events to JS if there is a view that is currently listening to said event
@@ -649,7 +652,6 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
     auto componentView = *itComponentView;
     bool shouldEmitEvent = componentView != nullptr &&
         (hasParentEnterListener ||
-         IsViewListeningToEvent(componentView, facebook::react::ViewEvents::Offset::PointerEnter) ||
          IsViewListeningToEvent(componentView, facebook::react::WindowsViewEvents::Offset::MouseEnter));
 
     if (std::find(currentlyHoveredViews.begin(), currentlyHoveredViews.end(), componentView) ==
@@ -659,16 +661,12 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
               m_context, componentView.Tag(), pointerPoint, keyModifiers);
       winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(componentView)
           ->OnPointerEntered(args);
-
       if (shouldEmitEvent) {
         const auto eventEmitter =
             winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(componentView)
                 ->eventEmitter();
-        if (eventEmitter) {
-          eventEmitter->onPointerEnter(event);
-          if (IsMousePointerEvent(event)) {
-            eventEmitter->onMouseEnter(event);
-          }
+        if (eventEmitter && IsMousePointerEvent(event)) {
+          eventEmitter->onMouseEnter(event);
         }
       }
     }
@@ -681,26 +679,13 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
   // Call the underlaying pointer handler
   handler(eventPathViews);
 
-  // Out
-  if (previousTargetTag != -1 && previousTargetTag != (targetView ? targetView.Tag() : -1)) {
-    bool shouldEmitOutEvent =
-        IsAnyViewInPathListeningToEvent(currentlyHoveredViews, facebook::react::ViewEvents::Offset::PointerOut);
-    const auto eventEmitter =
-        winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(prevTargetView)->eventEmitter();
-    if (shouldEmitOutEvent && eventEmitter != nullptr) {
-      eventEmitter->onPointerOut(event);
-    }
-  }
-
   // Leaving
 
   // pointerleave events need to be emitted from the deepest target to the root but
   // we also need to efficiently keep track of if a view has a parent which is listening to the leave events,
   // so we first iterate from the root to the target, collecting the views which need events fired for, of which
   // we reverse iterate (now from target to root), actually emitting the events.
-  std::vector<winrt::Microsoft::ReactNative::ComponentView>
-      viewsToEmitJSLeaveEventsTo; // NSMutableOrderedSet<UIView *> *viewsToEmitLeaveEventsTo =
-                                  // [NSMutableOrderedSet orderedSet];
+  std::vector<winrt::Microsoft::ReactNative::ComponentView> viewsToEmitJSLeaveEventsTo;
 
   std::vector<winrt::Microsoft::ReactNative::ComponentView> viewsToEmitLeaveEventsTo;
 
@@ -708,14 +693,11 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
 
   bool hasParentLeaveListener = false;
   for (auto itComponentView = currentlyHoveredViews.rbegin(); itComponentView != currentlyHoveredViews.rend();
-       itComponentView++) { //  for (RCTReactTaggedView *taggedView in [currentlyHoveredViews
-                            //  reverseObjectEnumerator])
-                            //  {
+       itComponentView++) {
     auto componentView = *itComponentView;
 
     bool shouldEmitJSEvent = componentView != nullptr &&
         (hasParentLeaveListener ||
-         IsViewListeningToEvent(componentView, facebook::react::ViewEvents::Offset::PointerLeave) ||
          IsViewListeningToEvent(componentView, facebook::react::WindowsViewEvents::Offset::MouseLeave));
 
     if (std::find(eventPathViews.begin(), eventPathViews.end(), componentView) == eventPathViews.end()) {
@@ -740,17 +722,13 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
   }
 
   for (auto itComponentView = viewsToEmitJSLeaveEventsTo.rbegin(); itComponentView != viewsToEmitJSLeaveEventsTo.rend();
-       itComponentView++) { //  for (UIView *componentView in [viewsToEmitJSLeaveEventsTo
-                            //  reverseObjectEnumerator]) {
+       itComponentView++) {
     auto componentView = *itComponentView;
 
     const auto eventEmitter =
         winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(componentView)->eventEmitter();
-    if (eventEmitter) {
-      eventEmitter->onPointerLeave(event);
-      if (IsMousePointerEvent(event)) {
-        eventEmitter->onMouseLeave(event);
-      }
+    if (eventEmitter && IsMousePointerEvent(event)) {
+      eventEmitter->onMouseLeave(event);
     }
   }
 
@@ -1045,21 +1023,78 @@ void CompositionEventHandler::onPointerMoved(
 
     facebook::react::PointerEvent pointerEvent = CreatePointerEventFromIncompleteHoverData(ptScaled, ptLocal);
 
-    auto handler = [&targetView,
-                    &pointerEvent](std::vector<winrt::Microsoft::ReactNative::ComponentView> &eventPathViews) {
+    // check if this pointer corresponds to active touch that has a responder
+    auto activeTouch = m_activeTouches.find(pointerId);
+    bool isActiveTouch = activeTouch != m_activeTouches.end() && activeTouch->second.eventEmitter != nullptr;
+
+    auto handler = [&, targetView, pointerEvent, isActiveTouch](
+                       std::vector<winrt::Microsoft::ReactNative::ComponentView> &eventPathViews) {
       const auto eventEmitter = targetView
           ? winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(targetView)
                 ->eventEmitterAtPoint(pointerEvent.offsetPoint)
-          : nullptr;
-      bool hasMoveEventListeners =
-          IsAnyViewInPathListeningToEvent(eventPathViews, facebook::react::ViewEvents::Offset::PointerMove) ||
-          IsAnyViewInPathListeningToEvent(eventPathViews, facebook::react::ViewEvents::Offset::PointerMoveCapture);
-      if (eventEmitter != nullptr && hasMoveEventListeners) {
+          : RootComponentView().eventEmitterAtPoint(pointerEvent.offsetPoint);
+
+      if (eventEmitter != nullptr) {
         eventEmitter->onPointerMove(pointerEvent);
+      } else {
+        ClearAllHoveredForPointer(pointerEvent);
       }
     };
 
     HandleIncomingPointerEvent(pointerEvent, targetView, pointerPoint, keyModifiers, handler);
+
+    if (isActiveTouch) {
+      // For active touches with responders, also dispatch through touch event system
+      UpdateActiveTouch(activeTouch->second, ptScaled, ptLocal);
+      DispatchTouchEvent(TouchEventType::Move, pointerId, pointerPoint, keyModifiers);
+    }
+  }
+}
+
+void CompositionEventHandler::ClearAllHoveredForPointer(const facebook::react::PointerEvent &pointerEvent) noexcept {
+  // special case if we have no target
+  // PointerEventsProcessor requires move events to keep track of the hovered components in core.
+  // It also treats a onPointerLeave event as a special case that removes the hover state of all currently hovered
+  // events. If we get null for the targetView, that means that the mouse is no over any components, so we have no
+  // element to send the move event to. However we need to send something so that any previously hovered elements
+  // are no longer hovered.
+  auto children = RootComponentView().Children();
+  if (auto size = children.Size()) {
+    auto firstChild = children.GetAt(0);
+    if (auto childEventEmitter =
+            winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(firstChild)->eventEmitter()) {
+      childEventEmitter->onPointerLeave(pointerEvent);
+    }
+  }
+}
+
+void CompositionEventHandler::onPointerExited(
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+    winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {
+  if (SurfaceId() == -1)
+    return;
+
+  int pointerId = pointerPoint.PointerId();
+  auto position = pointerPoint.Position();
+
+  if (std::shared_ptr<FabricUIManager> fabricuiManager =
+          ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
+    facebook::react::Tag tag = -1;
+    facebook::react::Point ptLocal, ptScaled;
+    getTargetPointerArgs(fabricuiManager, pointerPoint, tag, ptScaled, ptLocal);
+
+    tag = -1;
+
+    auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerRoutedEventArgs>(
+        m_context, tag, pointerPoint, keyModifiers);
+
+    facebook::react::PointerEvent pointerEvent = CreatePointerEventFromIncompleteHoverData(ptScaled, ptLocal);
+
+    auto handler = [&](std::vector<winrt::Microsoft::ReactNative::ComponentView> &eventPathViews) {
+      ClearAllHoveredForPointer(pointerEvent);
+    };
+
+    HandleIncomingPointerEvent(pointerEvent, nullptr, pointerPoint, keyModifiers, handler);
   }
 }
 
@@ -1345,12 +1380,7 @@ void CompositionEventHandler::DispatchTouchEvent(
           activeTouch.eventEmitter->onPointerDown(pointerEvent);
           break;
         case TouchEventType::Move: {
-          bool hasMoveEventListeners =
-              IsAnyViewInPathListeningToEvent(eventPathViews, facebook::react::ViewEvents::Offset::PointerMove) ||
-              IsAnyViewInPathListeningToEvent(eventPathViews, facebook::react::ViewEvents::Offset::PointerMoveCapture);
-          if (hasMoveEventListeners) {
-            activeTouch.eventEmitter->onPointerMove(pointerEvent);
-          }
+          activeTouch.eventEmitter->onPointerMove(pointerEvent);
           break;
         }
         case TouchEventType::End:

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

@@ -14,7 +14,6 @@
 #include <winrt/Windows.Devices.Input.h>
 #include <optional>
 #include <set>
-#include "Utils/BatchingEventEmitter.h"
 
 namespace winrt {
 using namespace Windows::UI;
@@ -57,6 +56,9 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
   void onPointerMoved(
       const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
       winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
+  void onPointerExited(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
   void onPointerWheelChanged(
       const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
       winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
@@ -96,6 +98,7 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
       const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
       winrt::Windows::System::VirtualKeyModifiers keyModifiers,
       std::function<void(std::vector<winrt::Microsoft::ReactNative::ComponentView> &)> handler);
+  void ClearAllHoveredForPointer(const facebook::react::PointerEvent &pointerEvent) noexcept;
 
   struct ActiveTouch {
     facebook::react::Touch touch;
@@ -169,6 +172,7 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
   winrt::event_token m_pointerMovedToken;
   winrt::event_token m_pointerWheelChangedToken;
   winrt::event_token m_pointerCaptureLostToken;
+  winrt::event_token m_pointerExitedToken;
   winrt::event_token m_keyDownToken;
   winrt::event_token m_keyUpToken;
   winrt::event_token m_characterReceivedToken;

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

@@ -174,7 +174,6 @@ HRESULT __stdcall CompositionRootAutomationProvider::get_FragmentRoot(IRawElemen
 
   *pRetVal = nullptr;
 
-#ifdef USE_EXPERIMENTAL_WINUI3
   if (m_island) {
     auto parentRoot = m_island.FragmentRootAutomationProvider();
     auto spFragment = parentRoot.try_as<IRawElementProviderFragmentRoot>();
@@ -183,7 +182,6 @@ HRESULT __stdcall CompositionRootAutomationProvider::get_FragmentRoot(IRawElemen
       return S_OK;
     }
   }
-#endif
 
   return S_OK;
 }
@@ -288,7 +286,6 @@ HRESULT __stdcall CompositionRootAutomationProvider::Navigate(
       }
     }
   } else if (direction == NavigateDirection_Parent) {
-#ifdef USE_EXPERIMENTAL_WINUI3
     if (m_island) {
       auto parent = m_island.ParentAutomationProvider();
       auto spFragment = parent.try_as<IRawElementProviderFragment>();
@@ -297,7 +294,6 @@ HRESULT __stdcall CompositionRootAutomationProvider::Navigate(
         return S_OK;
       }
     }
-#endif
   }
   *pRetVal = nullptr;
   return S_OK;

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

@@ -25,8 +25,6 @@ void CompositionUIService::SetCompositor(
       CompositionContextPropertyId(),
       winrt::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompositionContextHelper::CreateContext(
           compositor));
-  // Default to using Bridgeless mode when using fabric
-  winrt::Microsoft::ReactNative::implementation::QuirkSettings::SetIsBridgeless(properties, !!compositor);
 }
 
 winrt::Microsoft::UI::Composition::Compositor CompositionUIService::GetCompositor(