react-native-windows 0.77.3 → 0.77.5

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

@@ -1,6 +1,9 @@
 #include "pch.h"
 #include "CompositionDynamicAutomationProvider.h"
 #include <Fabric/ComponentView.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>
@@ -25,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>();
+  }
 }
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::Navigate(
@@ -141,8 +151,12 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_ProviderOptions(Prov
   return S_OK;
 }
 
-bool accessibilityValueHasValue(const facebook::react::AccessibilityValue &value) {
-  return (value.min.has_value() && value.max.has_value()) || value.now.has_value() || value.text.has_value();
+bool accessibilityValueHasTextValue(const facebook::react::AccessibilityValue &value) {
+  return value.text.has_value();
+}
+
+bool accessibilityValueHasNumericValue(const facebook::react::AccessibilityValue &value) {
+  return (value.min.has_value() && value.max.has_value() && value.now.has_value());
 }
 
 bool expandableControl(const facebook::react::SharedViewProps props) {
@@ -202,9 +216,22 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
     AddRef();
   }
 
+  if (patternId == UIA_ScrollPatternId &&
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ScrollViewComponentView>()) {
+    *pRetVal = static_cast<IScrollProvider *>(this);
+    AddRef();
+  }
+
   if (patternId == UIA_ValuePatternId &&
-      (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>() ||
-       accessibilityValueHasValue(props->accessibilityValue))) {
+      ((strongView
+            .try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>() &&
+        !accessibilityValueHasNumericValue(props->accessibilityValue)) ||
+       accessibilityValueHasTextValue(props->accessibilityValue))) {
+    *pRetVal = static_cast<IValueProvider *>(this);
+    AddRef();
+  }
+
+  if (patternId == UIA_RangeValuePatternId && accessibilityValueHasNumericValue(props->accessibilityValue)) {
     *pRetVal = static_cast<IValueProvider *>(this);
     AddRef();
   }
@@ -233,10 +260,21 @@ 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;
 }
 
-long GetControlType(const std::string &role) noexcept {
+long GetControlTypeFromString(const std::string &role) noexcept {
   if (role == "adjustable") {
     return UIA_SliderControlTypeId;
   } else if (role == "group" || role == "search" || role == "radiogroup" || role == "timer" || role.empty()) {
@@ -294,11 +332,103 @@ long GetControlType(const std::string &role) noexcept {
     return UIA_TreeControlTypeId;
   } else if (role == "treeitem") {
     return UIA_TreeItemControlTypeId;
+  } else if (role == "pane") {
+    return UIA_PaneControlTypeId;
   }
   assert(false);
   return UIA_GroupControlTypeId;
 }
 
+long GetControlTypeFromRole(const facebook::react::Role &role) noexcept {
+  switch (role) {
+    case facebook::react::Role::Alert:
+      return UIA_TextControlTypeId;
+    case facebook::react::Role::Application:
+      return UIA_WindowControlTypeId;
+    case facebook::react::Role::Button:
+      return UIA_ButtonControlTypeId;
+    case facebook::react::Role::Checkbox:
+      return UIA_CheckBoxControlTypeId;
+    case facebook::react::Role::Columnheader:
+      return UIA_HeaderControlTypeId;
+    case facebook::react::Role::Combobox:
+      return UIA_ComboBoxControlTypeId;
+    case facebook::react::Role::Document:
+      return UIA_DocumentControlTypeId;
+    case facebook::react::Role::Grid:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Group:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Heading:
+      return UIA_TextControlTypeId;
+    case facebook::react::Role::Img:
+      return UIA_ImageControlTypeId;
+    case facebook::react::Role::Link:
+      return UIA_HyperlinkControlTypeId;
+    case facebook::react::Role::List:
+      return UIA_ListControlTypeId;
+    case facebook::react::Role::Listitem:
+      return UIA_ListItemControlTypeId;
+    case facebook::react::Role::Menu:
+      return UIA_MenuControlTypeId;
+    case facebook::react::Role::Menubar:
+      return UIA_MenuBarControlTypeId;
+    case facebook::react::Role::Menuitem:
+      return UIA_MenuItemControlTypeId;
+    case facebook::react::Role::None:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Presentation:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Progressbar:
+      return UIA_ProgressBarControlTypeId;
+    case facebook::react::Role::Radio:
+      return UIA_RadioButtonControlTypeId;
+    case facebook::react::Role::Radiogroup:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Rowgroup:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Rowheader:
+      return UIA_HeaderControlTypeId;
+    case facebook::react::Role::Scrollbar:
+      return UIA_ScrollBarControlTypeId;
+    case facebook::react::Role::Searchbox:
+      return UIA_EditControlTypeId;
+    case facebook::react::Role::Separator:
+      return UIA_SeparatorControlTypeId;
+    case facebook::react::Role::Slider:
+      return UIA_SliderControlTypeId;
+    case facebook::react::Role::Spinbutton:
+      return UIA_SpinnerControlTypeId;
+    case facebook::react::Role::Status:
+      return UIA_StatusBarControlTypeId;
+    case facebook::react::Role::Summary:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Switch:
+      return UIA_ButtonControlTypeId;
+    case facebook::react::Role::Tab:
+      return UIA_TabItemControlTypeId;
+    case facebook::react::Role::Table:
+      return UIA_TableControlTypeId;
+    case facebook::react::Role::Tablist:
+      return UIA_TabControlTypeId;
+    case facebook::react::Role::Tabpanel:
+      return UIA_TabControlTypeId;
+    case facebook::react::Role::Timer:
+      return UIA_ButtonControlTypeId;
+    case facebook::react::Role::Toolbar:
+      return UIA_ToolBarControlTypeId;
+    case facebook::react::Role::Tooltip:
+      return UIA_ToolTipControlTypeId;
+    case facebook::react::Role::Tree:
+      return UIA_TreeControlTypeId;
+    case facebook::react::Role::Treegrid:
+      return UIA_TreeControlTypeId;
+    case facebook::react::Role::Treeitem:
+      return UIA_TreeItemControlTypeId;
+  }
+  return UIA_GroupControlTypeId;
+}
+
 HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERTYID propertyId, VARIANT *pRetVal) {
   if (pRetVal == nullptr)
     return E_POINTER;
@@ -324,8 +454,10 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
   switch (propertyId) {
     case UIA_ControlTypePropertyId: {
       pRetVal->vt = VT_I4;
-      auto role = props->accessibilityRole.empty() ? compositionView->DefaultControlType() : props->accessibilityRole;
-      pRetVal->lVal = GetControlType(role);
+      pRetVal->lVal = props->role == facebook::react::Role::None ? props->accessibilityRole.empty()
+              ? GetControlTypeFromString(compositionView->DefaultControlType())
+              : GetControlTypeFromString(props->accessibilityRole)
+                                                                 : GetControlTypeFromRole(props->role);
       break;
     }
     case UIA_AutomationIdPropertyId: {
@@ -365,12 +497,18 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
     }
     case UIA_IsContentElementPropertyId: {
       pRetVal->vt = VT_BOOL;
-      pRetVal->boolVal = (props->accessible && props->accessibilityRole != "none") ? VARIANT_TRUE : VARIANT_FALSE;
+      pRetVal->boolVal =
+          (props->accessible && (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
+          ? VARIANT_TRUE
+          : VARIANT_FALSE;
       break;
     }
     case UIA_IsControlElementPropertyId: {
       pRetVal->vt = VT_BOOL;
-      pRetVal->boolVal = (props->accessible && props->accessibilityRole != "none") ? VARIANT_TRUE : VARIANT_FALSE;
+      pRetVal->boolVal =
+          (props->accessible && (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
+          ? VARIANT_TRUE
+          : VARIANT_FALSE;
       break;
     }
     case UIA_IsOffscreenPropertyId: {
@@ -461,6 +599,156 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::ScrollIntoView() {
   return S_OK;
 }
 
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_HorizontalScrollPercent(double *pRetVal) {
+  BOOL horizontallyScrollable;
+  auto hr = get_HorizontallyScrollable(&horizontallyScrollable);
+  if (!SUCCEEDED(hr)) {
+    return hr;
+  }
+  if (!horizontallyScrollable) {
+    *pRetVal = UIA_ScrollPatternNoScroll;
+  } else {
+    auto strongView = m_view.view();
+    auto scrollComponentView =
+        strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ScrollViewComponentView>();
+    *pRetVal = scrollComponentView->getScrollPositionX();
+  }
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_VerticalScrollPercent(double *pRetVal) {
+  BOOL verticallyScrollable;
+  auto hr = get_VerticallyScrollable(&verticallyScrollable);
+  if (!SUCCEEDED(hr)) {
+    return hr;
+  }
+  if (!verticallyScrollable) {
+    *pRetVal = UIA_ScrollPatternNoScroll;
+  } else {
+    auto strongView = m_view.view();
+    auto scrollComponentView =
+        strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ScrollViewComponentView>();
+    *pRetVal = scrollComponentView->getScrollPositionY();
+  }
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_HorizontalViewSize(double *pRetVal) {
+  BOOL horizontallyScrollable;
+  auto hr = get_HorizontallyScrollable(&horizontallyScrollable);
+  if (!SUCCEEDED(hr)) {
+    return hr;
+  }
+  if (!horizontallyScrollable) {
+    *pRetVal = 100;
+  } else {
+    auto strongView = m_view.view();
+    auto scrollComponentView =
+        strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ScrollViewComponentView>();
+    *pRetVal = scrollComponentView->getHorizontalSize();
+  }
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_VerticalViewSize(double *pRetVal) {
+  BOOL verticallyScrollable;
+  auto hr = get_VerticallyScrollable(&verticallyScrollable);
+  if (!SUCCEEDED(hr)) {
+    return hr;
+  }
+  if (!verticallyScrollable) {
+    *pRetVal = 100;
+  } else {
+    auto strongView = m_view.view();
+    auto scrollComponentView =
+        strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ScrollViewComponentView>();
+    *pRetVal = scrollComponentView->getVerticalSize();
+  }
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_HorizontallyScrollable(BOOL *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ScrollViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  *pRetVal = (props->horizontal && props->scrollEnabled);
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_VerticallyScrollable(BOOL *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ScrollViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  *pRetVal = (!props->horizontal && props->scrollEnabled);
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::Scroll(
+    ScrollAmount horizontalAmount,
+    ScrollAmount verticalAmount) {
+  DispatchAccessibilityAction(m_view, "scroll");
+  auto strongView = m_view.view();
+  auto scrollComponentView =
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ScrollViewComponentView>();
+  BOOL verticallyScrollable;
+  BOOL horizontallyScrollable;
+  float vertical = 0.0f;
+  float horizontal = 0.0f;
+  auto hr = get_VerticallyScrollable(&verticallyScrollable);
+  if (!SUCCEEDED(hr)) {
+    return hr;
+  }
+  if (verticallyScrollable) {
+    if (verticalAmount == ScrollAmount_LargeIncrement) {
+      scrollComponentView->pageDown(true);
+    } else if (verticalAmount == ScrollAmount_LargeDecrement) {
+      scrollComponentView->pageUp(true);
+    } else if (verticalAmount == ScrollAmount_SmallIncrement) {
+      scrollComponentView->lineDown(true);
+    } else if (verticalAmount == ScrollAmount_SmallDecrement) {
+      scrollComponentView->lineUp(true);
+    }
+  }
+  hr = get_HorizontallyScrollable(&horizontallyScrollable);
+  if (!SUCCEEDED(hr)) {
+    return hr;
+  }
+  if (horizontallyScrollable) {
+    if (horizontalAmount == ScrollAmount_LargeIncrement) {
+      scrollComponentView->pageDown(true);
+    } else if (horizontalAmount == ScrollAmount_LargeDecrement) {
+      scrollComponentView->pageUp(true);
+    } else if (horizontalAmount == ScrollAmount_SmallIncrement) {
+      scrollComponentView->lineRight(true);
+    } else if (horizontalAmount == ScrollAmount_SmallDecrement) {
+      scrollComponentView->lineLeft(true);
+    }
+  }
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::SetScrollPercent(
+    double horiztonalPercent,
+    double verticalPercent) {
+  return S_OK;
+}
+
 BSTR StringToBSTR(const std::string &str) {
   // Calculate the required BSTR size in bytes
   int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, nullptr, 0);
@@ -485,6 +773,8 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::SetValue(LPCWSTR val) {
 
   winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)
       ->setAcccessiblityValue(winrt::to_string(val));
+  // TODO: Edit once/if onAccessibilityAction props supports returning UIA event data. See
+  // https://github.com/react-native-community/discussions-and-proposals/issues/843.
   DispatchAccessibilityAction(m_view, "setValue");
   return S_OK;
 }
@@ -515,23 +805,86 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_IsReadOnly(BOOL *pRe
       winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
   if (props == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
-  auto accessibilityRole = props->accessibilityRole;
-  if (accessibilityRole.empty()) {
-    // Control is using default control type. Use default IsReadOnly value.
-    *pRetVal = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)
-                   ->getAcccessiblityIsReadOnly();
-  } else if (
-      accessibilityRole == "textinput" || accessibilityRole == "searchbox" || accessibilityRole == "adjustable" ||
-      accessibilityRole == "spinbutton" || accessibilityRole == "combobox") {
-    // Control is using customized control type which should not be IsReadOnly for value pattern.
-    *pRetVal = false;
+  if (props->accessibilityState.has_value() && props->accessibilityState->readOnly.has_value()) {
+    *pRetVal = props->accessibilityState->readOnly.value();
   } else {
-    // Control is using customized control type which should be IsReadOnly for value pattern.
-    *pRetVal = true;
+    // Use default IsReadOnly value.
+    *pRetVal = false;
   }
   return S_OK;
 }
 
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_LargeChange(double *pRetVal) {
+  // no-op
+  return S_OK;
+}
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_Maximum(double *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = props->accessibilityValue.max.value();
+  return S_OK;
+}
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_Minimum(double *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = props->accessibilityValue.min.value();
+  return S_OK;
+}
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_SmallChange(double *pRetVal) {
+  // no-op
+  return S_OK;
+}
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_Value(double *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = props->accessibilityValue.now.value();
+  return S_OK;
+}
+HRESULT __stdcall CompositionDynamicAutomationProvider::SetValue(double val) {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  // TODO: Edit once/if onAccessibilityAction props supports returning UIA event data. See
+  // https://github.com/react-native-community/discussions-and-proposals/issues/843.
+  DispatchAccessibilityAction(m_view, "setValue");
+  return S_OK;
+}
+
 HRESULT __stdcall CompositionDynamicAutomationProvider::get_ToggleState(ToggleState *pRetVal) {
   if (pRetVal == nullptr)
     return E_POINTER;

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

@@ -15,7 +15,9 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
                                                  IRawElementProviderSimple,
                                                  IInvokeProvider,
                                                  IScrollItemProvider,
+                                                 IScrollProvider,
                                                  IValueProvider,
+                                                 IRangeValueProvider,
                                                  IToggleProvider,
                                                  IExpandCollapseProvider,
                                                  ISelectionProvider,
@@ -45,11 +47,29 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   // inherited via IScrollItemProvider
   HRESULT __stdcall ScrollIntoView() override;
 
+  // inherited via IScrollProvider
+  HRESULT __stdcall get_HorizontalScrollPercent(double *pRetVal) override;
+  HRESULT __stdcall get_VerticalScrollPercent(double *pRetVal) override;
+  HRESULT __stdcall get_HorizontalViewSize(double *pRetVal) override;
+  HRESULT __stdcall get_VerticalViewSize(double *pRetVal) override;
+  HRESULT __stdcall get_HorizontallyScrollable(BOOL *pRetVal) override;
+  HRESULT __stdcall get_VerticallyScrollable(BOOL *pRetVal) override;
+  HRESULT __stdcall Scroll(ScrollAmount horizontalAmount, ScrollAmount verticalAmount) override;
+  HRESULT __stdcall SetScrollPercent(double horiztonalPercent, double verticalPercent) override;
+
   // inherited via IValueProvider
   virtual HRESULT __stdcall SetValue(LPCWSTR val) override;
   virtual HRESULT __stdcall get_Value(BSTR *pRetVal) override;
   virtual HRESULT __stdcall get_IsReadOnly(BOOL *pRetVal) override;
 
+  // inherited via IRangeValueProvider
+  virtual HRESULT __stdcall get_LargeChange(double *pRetVal) override;
+  virtual HRESULT __stdcall get_Maximum(double *pRetVal) override;
+  virtual HRESULT __stdcall get_Minimum(double *pRetVal) override;
+  virtual HRESULT __stdcall get_SmallChange(double *pRetVal) override;
+  virtual HRESULT __stdcall get_Value(double *pRetVal) override;
+  virtual HRESULT __stdcall SetValue(double val) override;
+
   // inherited via IToggleProvider
   virtual HRESULT __stdcall get_ToggleState(ToggleState *pRetVal) override;
   virtual HRESULT __stdcall Toggle() override;
@@ -76,6 +96,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;
 };
 

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

@@ -0,0 +1,115 @@
+#include "pch.h"
+#include <Fabric/ComponentView.h>
+#include <Fabric/Composition/ParagraphComponentView.h>
+#include <Fabric/Composition/TextInput/WindowsTextInputComponentView.h>
+#include <Unicode.h>
+#include "CompositionTextRangeProvider.h"
+#include "RootComponentView.h"
+#include "UiaHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+CompositionTextProvider::CompositionTextProvider(
+    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+    CompositionDynamicAutomationProvider *parentProvider) noexcept
+    : m_view{componentView} {
+  m_parentProvider.copy_from(parentProvider);
+  EnsureTextRangeProvider();
+}
+
+void CompositionTextProvider::EnsureTextRangeProvider() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return;
+
+  if (!m_textRangeProvider) {
+    m_textRangeProvider =
+        winrt::make<CompositionTextRangeProvider>(
+            strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), m_parentProvider.get())
+            .try_as<ITextRangeProvider>();
+  }
+}
+
+HRESULT __stdcall CompositionTextProvider::get_DocumentRange(ITextRangeProvider **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  if (m_textRangeProvider == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  m_textRangeProvider.copy_to(pRetVal);
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::get_SupportedTextSelection(SupportedTextSelection *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  if (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>()) {
+    *pRetVal = SupportedTextSelection_Single;
+  } else if (
+      auto textView =
+          strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ParagraphComponentView>()) {
+    auto props = std::static_pointer_cast<const facebook::react::ParagraphProps>(textView->props());
+    if (props == nullptr)
+      return UIA_E_ELEMENTNOTAVAILABLE;
+    *pRetVal = props->isSelectable ? SupportedTextSelection_Single : SupportedTextSelection_None;
+  } else {
+    *pRetVal = SupportedTextSelection_None;
+  }
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::GetSelection(SAFEARRAY **pRetVal) {
+  // no-op
+  *pRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 0);
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::GetVisibleRanges(SAFEARRAY **pRetVal) {
+  *pRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 1);
+  if (m_textRangeProvider == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  LONG pos = 0;
+  return SafeArrayPutElement(*pRetVal, &pos, m_textRangeProvider.get());
+}
+
+HRESULT __stdcall CompositionTextProvider::RangeFromChild(
+    IRawElementProviderSimple *childElement,
+    ITextRangeProvider **pRetVal) {
+  // no-op
+  *pRetVal = nullptr;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::RangeFromPoint(UiaPoint point, ITextRangeProvider **pRetVal) {
+  // no-op
+  if (m_textRangeProvider == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  m_textRangeProvider.copy_to(pRetVal);
+  return S_OK;
+}
+HRESULT __stdcall CompositionTextProvider::GetCaretRange(BOOL *isActive, ITextRangeProvider **pRetVal) {
+  // no-op
+  *pRetVal = nullptr;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::RangeFromAnnotation(
+    IRawElementProviderSimple *annotationElement,
+    ITextRangeProvider **pRetVal) {
+  // no-op
+  *pRetVal = nullptr;
+  return S_OK;
+}
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
+#include <Fabric/Composition/CompositionViewComponentView.h>
+#include <Fabric/ReactTaggedView.h>
+#include <UIAutomation.h>
+#include <inspectable.h>
+#include <uiautomationcore.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+class CompositionTextProvider : public winrt::implements<CompositionTextProvider, ITextProvider, ITextProvider2> {
+ public:
+  CompositionTextProvider(
+      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+      CompositionDynamicAutomationProvider *parentProvider) noexcept;
+
+  // inherited via ITextProvider
+  virtual HRESULT __stdcall get_DocumentRange(ITextRangeProvider **pRetVal) override;
+  virtual HRESULT __stdcall get_SupportedTextSelection(SupportedTextSelection *pRetVal) override;
+  virtual HRESULT __stdcall GetSelection(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall GetVisibleRanges(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall RangeFromChild(IRawElementProviderSimple *childElement, ITextRangeProvider **pRetVal)
+      override;
+  virtual HRESULT __stdcall RangeFromPoint(UiaPoint point, ITextRangeProvider **pRetVal) override;
+
+  // inherited via ITextProvider2
+  virtual HRESULT __stdcall GetCaretRange(BOOL *isActive, ITextRangeProvider **pRetVal) override;
+  virtual HRESULT __stdcall RangeFromAnnotation(
+      IRawElementProviderSimple *annotationElement,
+      ITextRangeProvider **pRetVal) override;
+
+  void EnsureTextRangeProvider();
+
+ private:
+  ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::com_ptr<ITextRangeProvider> m_textRangeProvider;
+  winrt::com_ptr<CompositionDynamicAutomationProvider> m_parentProvider;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation