react-native-windows 0.74.46 → 0.74.48

package/Directory.Build.props

@@ -22,7 +22,7 @@
     <FmtVersion>10.1.0</FmtVersion>
     <FmtCommitHash>ca2e3685b160617d3d95fcd9e789c4e06ca88</FmtCommitHash>
     <!-- Commit hash for https://github.com/microsoft/node-api-jsi code. -->
-    <NodeApiJsiCommitHash>83cfef428a97627c9185c73da097e42742de56eb</NodeApiJsiCommitHash>
+    <NodeApiJsiCommitHash>21b47f08b762b21b1d4d970940ab23f59f43249c</NodeApiJsiCommitHash>
   </PropertyGroup>
 
   <!--

package/Libraries/Components/View/View.windows.js

@@ -38,6 +38,7 @@ const View: React.AbstractComponent<
       accessibilityLabel,
       accessibilityLabelledBy,
       accessibilityLevel, // Windows
+      accessibilityDescription, //Windows
       accessibilityLiveRegion,
       accessibilityPosInSet, // Windows
       accessibilitySetSize, // Windows
@@ -49,6 +50,7 @@ const View: React.AbstractComponent<
       'aria-expanded': ariaExpanded,
       'aria-multiselectable': ariaMultiselectable, // Windows
       'aria-required': ariaRequired, // Windows
+      'aria-description': ariaDescription, //Windows
       'aria-hidden': ariaHidden,
       'aria-label': ariaLabel,
       'aria-labelledby': ariaLabelledBy,
@@ -227,6 +229,13 @@ const View: React.AbstractComponent<
 
     // Windows]
 
+    const computedImportantForAccessibility =
+      ariaHidden === true ||
+      importantForAccessibility === 'no-hide-descendants' ||
+      accessibilityElementsHidden === true
+        ? 'no-hide-descendants'
+        : importantForAccessibility;
+
     return (
       // [Windows
       // In core this is a TextAncestor.Provider value={false} See
@@ -248,6 +257,9 @@ const View: React.AbstractComponent<
               }
               accessibilityLabel={ariaLabel ?? accessibilityLabel}
               accessibilityLevel={ariaLevel ?? accessibilityLevel}
+              accessibilityDescription={
+                ariaDescription ?? accessibilityDescription
+              }
               accessibilityPosInSet={ariaPosinset ?? accessibilityPosInSet}
               accessibilitySetSize={ariaSetsize ?? accessibilitySetSize}
               focusable={_focusable}
@@ -258,11 +270,7 @@ const View: React.AbstractComponent<
               }
               accessibilityLabelledBy={_accessibilityLabelledBy}
               accessibilityValue={_accessibilityValue}
-              importantForAccessibility={
-                ariaHidden === true
-                  ? 'no-hide-descendants'
-                  : importantForAccessibility
-              }
+              importantForAccessibility={computedImportantForAccessibility}
               nativeID={id ?? nativeID}
               style={style}
               // $FlowFixMe[incompatible-type]

package/Libraries/Components/View/ViewAccessibility.d.ts

@@ -14,6 +14,7 @@ import {NativeSyntheticEvent} from '../../Types/CoreEventTypes';
  */
 export interface AccessibilityProps
   extends AccessibilityPropsAndroid,
+    AccessibilityPropsWindows,
     AccessibilityPropsIOS {
   /**
    * When true, indicates that the view is an accessibility element.
@@ -258,6 +259,72 @@ export type AccessibilityRole =
   | 'listitem' // Windows
   | 'toolbar';
 
+// [Windows]
+export type AnnotationType =
+  | 'AdvanceProofingIssue'
+  | 'Author'
+  | 'CircularReferenceError'
+  | 'Comment'
+  | 'ConflictingChange'
+  | 'DataValidationError'
+  | 'DeletionChange'
+  | 'EditingLockedChange'
+  | 'Endnote'
+  | 'ExternalChange'
+  | 'Footer'
+  | 'Footnote'
+  | 'FormatChange'
+  | 'FormulaError'
+  | 'GrammarError'
+  | 'Header'
+  | 'Highlighted'
+  | 'InsertionChange'
+  | 'Mathematics'
+  | 'MoveChange'
+  | 'SpellingError'
+  | 'TrackChanges'
+  | 'Unknown'
+  | 'UnsyncedChange';
+
+// [Windows]
+export type AccessibilityAnnotationInfo = Readonly<{
+  typeID: AnnotationType;
+  typeName?: string;
+  author?: string;
+  dateTime?: string;
+  target?: string;
+}>;
+export interface AccessibilityPropsWindows {
+  /**
+   * Tells a person using a screen reader what kind of annotation they
+   * have selected. If available, it will also tell a person the author of the annotation and
+   * the date and time the annotation was posted.
+   *
+   * Note: If typeID is 'Unknown', a typeName must be provided.
+   */
+  accessibilityAnnotation?: AccessibilityAnnotationInfo; //Windows
+
+  /**
+   * Identifies the ItemType property, which is a text string describing the type of the automation element.
+   * ItemType is used to obtain information about items in a list, tree view, or data grid. For example, an item in a file directory view might be a "Document File" or a "Folder".
+   */
+  accessibilityItemType?: string; //Windows
+
+  /**
+   * An access key to hook up to the UIA_AccessKey_Property.
+   * Access keys are used in keyboard navigation to allow quick navigation to UI in an application.
+   */
+  accessibilityAccessKey?: string; //Windows
+
+  /**
+   * accessibilityDescription provides more detailed information specific to the element (i.e. last edit date, full location for a file)
+   * while accessibilityHint provides information on what will happen when they perform an action.
+   *
+   */
+  accessibilityDescription?: string; // Windows
+  'aria-description'?: string; // Windows
+}
+
 export interface AccessibilityPropsAndroid {
   /**
    * Identifies the element that labels the element it is applied to. When the assistive technology focuses on the component with this props,

package/Libraries/Components/View/ViewPropTypes.windows.js

@@ -505,6 +505,8 @@ type WindowsViewProps = $ReadOnly<{|
   'aria-posinset'?: ?number,
   accessibilitySetSize?: ?number,
   'aria-setsize'?: ?number,
+  accessibilityDescription?: ?string,
+  'aria-description'?: ?string,
 
   /**
    * Specifies if the control should show System focus visuals

package/Libraries/NativeComponent/BaseViewConfig.windows.js

@@ -359,6 +359,10 @@ const validAttributesForNonEventProps = {
   accessibilityLiveRegion: true, // [Windows]
   accessibilityPosInSet: true, // [Windows]
   accessibilitySetSize: true, // [Windows]
+  accessibilityAnnotation: true, // [Windows]
+  accessibilityItemType: true, // [Windows]
+  accessibilityAccessKey: true, // [Windows]
+  accessibilityDescription: true, // [Windows]
   disabled: true, // [Windows]
   focusable: true, // [Windows]
   keyDownEvents: true, // [Windows]

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

@@ -787,7 +787,7 @@ struct CompScrollerVisual : winrt::implements<
           m_horizontal ? TTypeRedirects::InteractionSourceMode::Disabled
                        : TTypeRedirects::InteractionSourceMode::EnabledWithInertia);
       m_visualInteractionSource.ManipulationRedirectionMode(
-          TTypeRedirects::VisualInteractionSourceRedirectionMode::CapableTouchpadAndPointerWheel);
+          TTypeRedirects::VisualInteractionSourceRedirectionMode::CapableTouchpadOnly);
     } else {
       m_visualInteractionSource.PositionXSourceMode(TTypeRedirects::InteractionSourceMode::Disabled);
       m_visualInteractionSource.PositionYSourceMode(TTypeRedirects::InteractionSourceMode::Disabled);

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

@@ -1,6 +1,8 @@
 #include "pch.h"
 #include "CompositionDynamicAutomationProvider.h"
 #include <Fabric/ComponentView.h>
+#include <Fabric/Composition/CompositionTextRangeProvider.h>
+#include <Fabric/Composition/ParagraphComponentView.h>
 #include <Fabric/Composition/SwitchComponentView.h>
 #include <Fabric/Composition/TextInput/WindowsTextInputComponentView.h>
 #include <Unicode.h>
@@ -26,6 +28,13 @@ CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
   if (props->accessibilityState.has_value() && props->accessibilityState->selected.has_value()) {
     AddSelectionItemsToContainer(this);
   }
+
+  if (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>() ||
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ParagraphComponentView>()) {
+    m_textProvider = winrt::make<CompositionTextProvider>(
+                         strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), this)
+                         .try_as<ITextProvider2>();
+  }
 }
 
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
@@ -253,6 +262,17 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
     AddRef();
   }
 
+  if (patternId == UIA_TextPatternId &&
+      (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>() ||
+       strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ParagraphComponentView>())) {
+    m_textProvider.as<IUnknown>().copy_to(pRetVal);
+  }
+
+  if (patternId == UIA_TextPattern2Id &&
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>()) {
+    m_textProvider.as<IUnknown>().copy_to(pRetVal);
+  }
+
   return S_OK;
 }
 
@@ -527,6 +547,29 @@ 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;
+    }
+    case UIA_FullDescriptionPropertyId: {
+      pRetVal->vt = VT_BSTR;
+      auto desc = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityDescription.value_or(""));
+      pRetVal->bstrVal = SysAllocString(desc.c_str());
+      break;
+    }
   }
 
   return hr;
@@ -769,7 +812,9 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Expand() {
 
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
+
   DispatchAccessibilityAction(m_view, "expand");
+
   return S_OK;
 }
 
@@ -778,7 +823,9 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Collapse() {
 
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
+
   DispatchAccessibilityAction(m_view, "collapse");
+
   return S_OK;
 }
 

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

@@ -89,6 +89,7 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
 
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::com_ptr<ITextProvider2> m_textProvider;
   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};

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

@@ -9,7 +9,6 @@
 #include <IReactContext.h>
 #include <React.h>
 #include <Views/DevMenu.h>
-#include <Views/ShadowNodeBase.h>
 #include <windows.h>
 #include <windowsx.h>
 #include <winrt/Windows.UI.Core.h>
@@ -637,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
@@ -664,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) ==
@@ -674,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);
         }
       }
     }
@@ -696,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;
 
@@ -723,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()) {
@@ -755,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);
     }
   }
 
@@ -815,41 +778,41 @@ void CompositionEventHandler::SetCursor(facebook::react::Cursor cursor, HCURSOR
           case facebook::react::Cursor::Pointer:
             type = winrt::Windows::UI::Core::CoreCursorType::Hand;
             break;
-            /* -- Additional cursors not added in core until later version
-              case facebook::react::Cursor::Help:
-                type = winrt::Windows::UI::Core::CoreCursorType::Help;
-                break;
-              case facebook::react::Cursor::NotAllowed:
-                type = winrt::Windows::UI::Core::CoreCursorType::UniversalNo;
-                break;
-              case facebook::react::Cursor::Wait:
-                type = winrt::Windows::UI::Core::CoreCursorType::Wait;
-                break;
-              case facebook::react::Cursor::Move:
-                type = winrt::Windows::UI::Core::CoreCursorType::SizeAll;
-                break;
-              case facebook::react::Cursor::NESWResize:
-                type = winrt::Windows::UI::Core::CoreCursorType::SizeNortheastSouthwest;
-                break;
-              case facebook::react::Cursor::NSResize:
-                type = winrt::Windows::UI::Core::CoreCursorType::SizeNorthSouth;
-                break;
-              case facebook::react::Cursor::NWSEResize:
-                type = winrt::Windows::UI::Core::CoreCursorType::SizeNorthwestSoutheast;
-                break;
-              case facebook::react::Cursor::EWResize:
-                type = winrt::Windows::UI::Core::CoreCursorType::SizeWestEast;
-                break;
-              case facebook::react::Cursor::Text:
-                type = winrt::Windows::UI::Core::CoreCursorType::IBeam;
-                break;
-              case facebook::react::Cursor::Progress:
-                type = winrt::Windows::UI::Core::CoreCursorType::Wait; // IDC_APPSTARTING not mapped to CoreCursor?
-                break;
-              case facebook::react::Cursor::Crosshair:
-                type = winrt::Windows::UI::Core::CoreCursorType::Cross;
-                break;
-                */
+            /*
+          case facebook::react::Cursor::Help:
+            type = winrt::Windows::UI::Core::CoreCursorType::Help;
+            break;
+          case facebook::react::Cursor::NotAllowed:
+            type = winrt::Windows::UI::Core::CoreCursorType::UniversalNo;
+            break;
+          case facebook::react::Cursor::Wait:
+            type = winrt::Windows::UI::Core::CoreCursorType::Wait;
+            break;
+          case facebook::react::Cursor::Move:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeAll;
+            break;
+          case facebook::react::Cursor::NESWResize:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeNortheastSouthwest;
+            break;
+          case facebook::react::Cursor::NSResize:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeNorthSouth;
+            break;
+          case facebook::react::Cursor::NWSEResize:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeNorthwestSoutheast;
+            break;
+          case facebook::react::Cursor::EWResize:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeWestEast;
+            break;
+          case facebook::react::Cursor::Text:
+            type = winrt::Windows::UI::Core::CoreCursorType::IBeam;
+            break;
+          case facebook::react::Cursor::Progress:
+            type = winrt::Windows::UI::Core::CoreCursorType::Wait; // IDC_APPSTARTING not mapped to CoreCursor?
+            break;
+          case facebook::react::Cursor::Crosshair:
+            type = winrt::Windows::UI::Core::CoreCursorType::Cross;
+            break;
+            */
           default:
             break;
         }
@@ -880,7 +843,7 @@ void CompositionEventHandler::SetCursor(facebook::react::Cursor cursor, HCURSOR
           case facebook::react::Cursor::Pointer:
             idc = IDC_HAND;
             break;
-            /* -- Additional cursors not added in core until later version
+            /*
           case facebook::react::Cursor::Help:
             idc = IDC_HELP;
             break;
@@ -1064,21 +1027,48 @@ 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);
+    }
   }
 }
 
@@ -1104,7 +1094,9 @@ void CompositionEventHandler::onPointerExited(
 
     facebook::react::PointerEvent pointerEvent = CreatePointerEventFromIncompleteHoverData(ptScaled, ptLocal);
 
-    auto handler = [](std::vector<winrt::Microsoft::ReactNative::ComponentView> &eventPathViews) {};
+    auto handler = [&](std::vector<winrt::Microsoft::ReactNative::ComponentView> &eventPathViews) {
+      ClearAllHoveredForPointer(pointerEvent);
+    };
 
     HandleIncomingPointerEvent(pointerEvent, nullptr, pointerPoint, keyModifiers, handler);
   }
@@ -1392,12 +1384,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;
@@ -99,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;