react-native-windows 0.74.29 → 0.74.31

package/Libraries/Components/Touchable/TouchableOpacity.windows.js

@@ -235,6 +235,13 @@ class TouchableOpacity extends React.Component<Props, State> {
         this.props['aria-expanded'] ?? this.props.accessibilityState?.expanded,
       selected:
         this.props['aria-selected'] ?? this.props.accessibilityState?.selected,
+      readOnly:
+        this.props['aria-readonly'] ?? this.props.accessibilityState?.readOnly, // Windows
+      multiselectable:
+        this.props['aria-multiselectable'] ??
+        this.props.accessibilityState?.multiselectable, // Windows
+      required:
+        this.props['aria-required'] ?? this.props.accessibilityState?.required, // Windows
     };
 
     _accessibilityState =

package/Libraries/Components/Touchable/TouchableWithoutFeedback.windows.js

@@ -59,6 +59,9 @@ type Props = $ReadOnly<{|
   'aria-disabled'?: ?boolean,
   'aria-expanded'?: ?boolean,
   'aria-selected'?: ?boolean,
+  'aria-readonly'?: ?boolean, // Windows
+  'aria-multiselectable'?: ?boolean, // Windows
+  'aria-required'?: ?boolean, // Windows
   'aria-hidden'?: ?boolean,
   'aria-live'?: ?('polite' | 'assertive' | 'off'),
   'aria-label'?: ?Stringish,
@@ -158,6 +161,13 @@ class TouchableWithoutFeedback extends React.Component<Props, State> {
         this.props['aria-expanded'] ?? this.props.accessibilityState?.expanded,
       selected:
         this.props['aria-selected'] ?? this.props.accessibilityState?.selected,
+      readonly:
+        this.props['aria-readonly'] ?? this.props.accessibilityState?.readOnly, // Windows
+      multiselectable:
+        this.props['aria-multiselectable'] ??
+        this.props.accessibilityState?.multiselectable, // Windows
+      required:
+        this.props['aria-required'] ?? this.props.accessibilityState?.required, // Windows
     };
 
     // BACKWARD-COMPATIBILITY: Focus and blur events were never supported before

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

@@ -47,12 +47,15 @@ const View: React.AbstractComponent<
       'aria-checked': ariaChecked,
       'aria-disabled': ariaDisabled,
       'aria-expanded': ariaExpanded,
+      'aria-multiselectable': ariaMultiselectable, // Windows
+      'aria-required': ariaRequired, // Windows
       'aria-hidden': ariaHidden,
       'aria-label': ariaLabel,
       'aria-labelledby': ariaLabelledBy,
       'aria-level': ariaLevel,
       'aria-live': ariaLive,
       'aria-posinset': ariaPosinset, // Windows
+      'aria-readonly': ariaReadOnly, // Windows
       'aria-selected': ariaSelected,
       'aria-setsize': ariaSetsize, // Windows
       'aria-valuemax': ariaValueMax,
@@ -80,7 +83,10 @@ const View: React.AbstractComponent<
       ariaChecked != null ||
       ariaDisabled != null ||
       ariaExpanded != null ||
-      ariaSelected != null
+      ariaSelected != null ||
+      ariaReadOnly != null || // Windows
+      ariaMultiselectable != null || // Windows
+      ariaRequired != null // Windows
     ) {
       _accessibilityState = {
         busy: ariaBusy ?? accessibilityState?.busy,
@@ -88,6 +94,10 @@ const View: React.AbstractComponent<
         disabled: ariaDisabled ?? accessibilityState?.disabled,
         expanded: ariaExpanded ?? accessibilityState?.expanded,
         selected: ariaSelected ?? accessibilityState?.selected,
+        readOnly: ariaReadOnly ?? accessibilityState?.readOnly, // Windows
+        multiselectable:
+          ariaMultiselectable ?? accessibilityState?.multiselectable, // Windows
+        required: ariaRequired ?? accessibilityState?.required, // Windows
       };
     }
     let _accessibilityValue;

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

@@ -183,6 +183,21 @@ export interface AccessibilityState {
    *  When present, informs accessible tools the element is expanded or collapsed
    */
   expanded?: boolean | undefined;
+  /**
+   *  When present, informs accessible tools the element is read only
+   *  @platform windows
+   */
+  readOnly?: boolean | undefined;
+  /**
+   *  When present, informs accessible tools the element can have multiple items selected
+   *  @platform windows
+   */
+  multiselectable?: boolean | undefined;
+  /**
+   *  When present, informs accessible tools the element requires selection
+   *  @platform windows
+   */
+  required?: boolean | undefined;
 }
 
 export interface AccessibilityValue {

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

@@ -179,8 +179,11 @@ export type AccessibilityState = {
   disabled?: boolean,
   selected?: boolean,
   checked?: ?boolean | 'mixed',
-  busy?: boolean,
-  expanded?: boolean,
+  busy?: ?boolean,
+  expanded?: ?boolean,
+  readOnly?: ?boolean, // Windows
+  multiselectable?: ?boolean, // Windows
+  required?: ?boolean, // Windows
   ...
 };
 

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

@@ -606,12 +606,15 @@ export type ViewProps = $ReadOnly<{|
   'aria-disabled'?: ?boolean,
   'aria-expanded'?: ?boolean,
   'aria-selected'?: ?boolean,
+  'aria-readonly'?: ?boolean, // Windows
   /** A value indicating whether the accessibility elements contained within
    * this accessibility element are hidden.
    *
    * See https://reactnative.dev/docs/view#aria-hidden
    */
   'aria-hidden'?: ?boolean,
+  'aria-multiselectable'?: ?boolean, // Windows
+  'aria-required'?: ?boolean, // Windows
 
   /**
    * Views that are only used to layout their children or otherwise don't draw

package/Libraries/Image/Image.windows.js

@@ -148,6 +148,9 @@ let BaseImage: AbstractImageIOS = React.forwardRef((props, forwardedRef) => {
     'aria-disabled': ariaDisabled,
     'aria-expanded': ariaExpanded,
     'aria-selected': ariaSelected,
+    'aria-readonly': ariaReadOnly, // Windows
+    'aria-multiselectable': ariaMultiselectable, // Windows
+    'aria-required': ariaRequired, // Windows
     height,
     src,
     width,
@@ -160,6 +163,10 @@ let BaseImage: AbstractImageIOS = React.forwardRef((props, forwardedRef) => {
     disabled: ariaDisabled ?? props.accessibilityState?.disabled,
     expanded: ariaExpanded ?? props.accessibilityState?.expanded,
     selected: ariaSelected ?? props.accessibilityState?.selected,
+    readOnly: ariaReadOnly ?? props.accessibilityState?.readOnly, // Windows
+    multiselectable:
+      ariaMultiselectable ?? props.accessibilityState?.multiselectable, // Windows
+    required: ariaRequired ?? props.accessibilityState?.required, // Windows
   };
   const accessibilityLabel = props['aria-label'] ?? props.accessibilityLabel;
 

package/Libraries/Text/Text.windows.js

@@ -46,11 +46,14 @@ const Text: React.AbstractComponent<
     'aria-checked': ariaChecked,
     'aria-disabled': ariaDisabled,
     'aria-expanded': ariaExpanded,
+    'aria-multiselectable': ariaMultiselectable, // Windows
+    'aria-required': ariaRequired, // Windows
     'aria-label': ariaLabel,
     'aria-level': ariaLevel, // Windows
     'aria-posinset': ariaPosinset, // Windows
     'aria-setsize': ariaSetsize, // Windows
     'aria-selected': ariaSelected,
+    'aria-readonly': ariaReadOnly, //Windows
     ellipsizeMode,
     id,
     nativeID,
@@ -78,7 +81,10 @@ const Text: React.AbstractComponent<
     ariaChecked != null ||
     ariaDisabled != null ||
     ariaExpanded != null ||
-    ariaSelected != null
+    ariaSelected != null ||
+    ariaReadOnly != null || // Windows
+    ariaMultiselectable != null || // Windows
+    ariaRequired != null // Windows
   ) {
     _accessibilityState = {
       busy: ariaBusy ?? accessibilityState?.busy,
@@ -86,6 +92,10 @@ const Text: React.AbstractComponent<
       disabled: ariaDisabled ?? accessibilityState?.disabled,
       expanded: ariaExpanded ?? accessibilityState?.expanded,
       selected: ariaSelected ?? accessibilityState?.selected,
+      readOnly: ariaReadOnly ?? accessibilityState?.readOnly, // Windows
+      multiselectable:
+        ariaMultiselectable ?? accessibilityState?.multiselectable, // Windows
+      required: ariaRequired ?? accessibilityState?.required, // Windows
     };
   }
 

package/Libraries/Text/TextProps.windows.js

@@ -97,6 +97,9 @@ export type TextProps = $ReadOnly<{|
   'aria-posinset'?: ?number, // Windows
   'aria-setsize'?: ?number, // Windows
   'aria-level'?: ?number, // Windows
+  'aria-readonly'?: ?boolean, // Windows
+  'aria-multiselectable'?: ?boolean, // Windows
+  'aria-required'?: ?boolean, // Windows
 
   /**
    * Represents the nativeID of the associated label text. When the assistive technology focuses on the component with this props, the text is read aloud.

package/Microsoft.ReactNative/CompositionComponentView.idl

@@ -7,6 +7,7 @@ import "ViewProps.idl";
 import "Composition.Input.idl";
 import "CompositionSwitcher.idl";
 import "IReactContext.idl";
+import "ReactNativeIsland.idl";
 
 #include "DocString.h"
 
@@ -110,8 +111,19 @@ namespace Microsoft.ReactNative.Composition
   [default_interface]
   runtimeclass RootComponentView : ViewComponentView {
     Microsoft.ReactNative.ComponentView GetFocusedComponent();
+    Microsoft.ReactNative.ReactNativeIsland ReactNativeIsland { get; };
+    DOC_STRING("Is non-null if this RootComponentView is the content of a portal")
+    PortalComponentView Portal { get; };
   };
-  
+
+  [experimental]
+  [webhosthidden]
+  [default_interface]
+  DOC_STRING("Used to implement UI that is hosted outside the main UI tree, such as modal.")
+  runtimeclass PortalComponentView : Microsoft.ReactNative.ComponentView {
+    RootComponentView ContentRoot { get; };
+  };
+
   [experimental]
   [webhosthidden]
   [default_interface]

package/Microsoft.ReactNative/Fabric/ComponentView.cpp

@@ -639,11 +639,10 @@ facebook::react::Tag ComponentView::hitTest(
 }
 
 winrt::IInspectable ComponentView::EnsureUiaProvider() noexcept {
-  assert(false);
   return nullptr;
 }
 
-std::optional<std::string> ComponentView::getAcccessiblityValue() noexcept {
+std::optional<std::string> ComponentView::getAccessiblityValue() noexcept {
   return std::nullopt;
 }
 

package/Microsoft.ReactNative/Fabric/ComponentView.h

@@ -207,7 +207,7 @@ struct ComponentView
   virtual facebook::react::Tag
   hitTest(facebook::react::Point pt, facebook::react::Point &localPt, bool ignorePointerEvents = false) const noexcept;
   virtual winrt::IInspectable EnsureUiaProvider() noexcept;
-  virtual std::optional<std::string> getAcccessiblityValue() noexcept;
+  virtual std::optional<std::string> getAccessiblityValue() noexcept;
   virtual void setAcccessiblityValue(std::string &&value) noexcept;
   virtual bool getAcccessiblityIsReadOnly() noexcept;
   virtual ToggleState getToggleState() noexcept;

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

@@ -15,8 +15,6 @@
 #include <Fabric/Composition/CompositionViewComponentView.h>
 #include <Fabric/Composition/DebuggingOverlayComponentView.h>
 #include <Fabric/Composition/ImageComponentView.h>
-#include <Fabric/Composition/Modal/WindowsModalHostViewComponentView.h>
-#include <Fabric/Composition/Modal/WindowsModalHostViewShadowNode.h>
 #include <Fabric/Composition/ParagraphComponentView.h>
 #include <Fabric/Composition/RootComponentView.h>
 #include <Fabric/Composition/ScrollViewComponentView.h>
@@ -59,9 +57,6 @@ ComponentViewDescriptor const &ComponentViewRegistry::dequeueComponentViewWithCo
   } else if (componentHandle == facebook::react::ImageShadowNode::Handle()) {
     view = winrt::Microsoft::ReactNative::Composition::implementation::ImageComponentView::Create(
         compContext, tag, m_context);
-  } else if (componentHandle == facebook::react::WindowsModalHostViewShadowNode::Handle()) {
-    view = winrt::Microsoft::ReactNative::Composition::implementation::WindowsModalHostComponentView::Create(
-        compContext, tag, m_context);
   } else if (componentHandle == facebook::react::WindowsTextInputShadowNode::Handle()) {
     view = winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView::Create(
         compContext, tag, m_context);

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

@@ -11,7 +11,21 @@ namespace winrt::Microsoft::ReactNative::implementation {
 
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
     const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept
-    : m_view{componentView} {}
+    : m_view{componentView} {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+  if (!props)
+    return;
+
+  if (props->accessibilityState.has_value() && props->accessibilityState->selected.has_value()) {
+    AddSelectionItemsToContainer(this);
+  }
+}
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::Navigate(
     NavigateDirection direction,
@@ -127,8 +141,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) {
@@ -171,7 +189,6 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
       winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
   if (props == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
-  auto accessibilityRole = props->accessibilityRole;
   // Invoke control pattern is used to support controls that do not maintain state
   // when activated but rather initiate or perform a single, unambiguous action.
   if (patternId == UIA_InvokePatternId && (props->onAccessibilityTap)) {
@@ -185,8 +202,15 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
   }
 
   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();
   }
@@ -203,6 +227,18 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
     AddRef();
   }
 
+  if (patternId == UIA_SelectionPatternId && props->accessibilityState.has_value() &&
+      props->accessibilityState->multiselectable.has_value() && props->accessibilityState->required.has_value()) {
+    *pRetVal = static_cast<ISelectionProvider *>(this);
+    AddRef();
+  }
+
+  if (patternId == UIA_SelectionItemPatternId && props->accessibilityState.has_value() &&
+      props->accessibilityState->selected.has_value()) {
+    *pRetVal = static_cast<ISelectionItemProvider *>(this);
+    AddRef();
+  }
+
   return S_OK;
 }
 
@@ -346,6 +382,7 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
     case UIA_IsOffscreenPropertyId: {
       pRetVal->vt = VT_BOOL;
       pRetVal->boolVal = (compositionView->getClipState() == ClipState::FullyClipped) ? VARIANT_TRUE : VARIANT_FALSE;
+      break;
     }
     case UIA_HelpTextPropertyId: {
       pRetVal->vt = VT_BSTR;
@@ -454,6 +491,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;
 }
@@ -467,7 +506,7 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_Value(BSTR *pRetVal)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
   *pRetVal = StringToBSTR(winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)
-                              ->getAcccessiblityValue()
+                              ->getAccessiblityValue()
                               .value_or(""));
   return S_OK;
 }
@@ -480,8 +519,88 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_IsReadOnly(BOOL *pRe
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  *pRetVal = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)
-                 ->getAcccessiblityIsReadOnly();
+  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;
+  auto accessibilityRole = props->accessibilityRole;
+  if (props->accessibilityState.has_value() && props->accessibilityState->readOnly.has_value()) {
+    *pRetVal = props->accessibilityState->readOnly.value();
+  } else {
+    // 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;
 }
 
@@ -552,4 +671,169 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Collapse() {
   return S_OK;
 }
 
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_CanSelectMultiple(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::ViewProps>(winrt::get_self<ComponentView>(strongView)->props());
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = (props->accessibilityState.has_value() && props->accessibilityState->multiselectable.has_value())
+      ? props->accessibilityState->multiselectable.value()
+      : false;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_IsSelectionRequired(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::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = (props->accessibilityState.has_value() && props->accessibilityState->required.has_value())
+      ? props->accessibilityState->required.value()
+      : false;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::GetSelection(SAFEARRAY **pRetVal) {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  std::vector<int> selectedItems;
+  for (size_t i = 0; i < m_selectionItems.size(); i++) {
+    auto selectionItem = m_selectionItems.at(i);
+    auto provider = selectionItem.as<CompositionDynamicAutomationProvider>();
+    BOOL selected;
+    auto hr = provider->get_IsSelected(&selected);
+    if (hr == S_OK && selected) {
+      selectedItems.push_back(int(i));
+    }
+  }
+
+  *pRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, ULONG(selectedItems.size()));
+  if (*pRetVal == nullptr)
+    return E_OUTOFMEMORY;
+
+  for (size_t i = 0; i < selectedItems.size(); i++) {
+    auto pos = static_cast<long>(i);
+    SafeArrayPutElement(*pRetVal, &pos, m_selectionItems.at(selectedItems.at(i)).get());
+  }
+  return S_OK;
+}
+
+void CompositionDynamicAutomationProvider::AddToSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item) {
+  if (std::find(m_selectionItems.begin(), m_selectionItems.end(), item) != m_selectionItems.end()) {
+    return;
+  }
+  m_selectionItems.push_back(item);
+}
+
+void CompositionDynamicAutomationProvider::RemoveFromSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item) {
+  std::erase(m_selectionItems, item);
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::AddToSelection() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  DispatchAccessibilityAction(m_view, "addToSelection");
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_IsSelected(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::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = (props->accessibilityState.has_value() && props->accessibilityState->selected.has_value())
+      ? props->accessibilityState->selected.value()
+      : false;
+
+  return S_OK;
+}
+
+IRawElementProviderSimple *findSelectionContainer(winrt::Microsoft::ReactNative::ComponentView current) {
+  if (!current)
+    return nullptr;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(current)->props());
+  if (props->accessibilityState.has_value() && props->accessibilityState->multiselectable.has_value() &&
+      props->accessibilityState->required.has_value()) {
+    auto uiaProvider =
+        current.as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>()->EnsureUiaProvider();
+    if (uiaProvider != nullptr) {
+      auto spProviderSimple = uiaProvider.try_as<IRawElementProviderSimple>();
+      if (spProviderSimple != nullptr) {
+        spProviderSimple->AddRef();
+        return spProviderSimple.get();
+      }
+    }
+  } else {
+    return findSelectionContainer(current.Parent());
+  }
+  return nullptr;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_SelectionContainer(IRawElementProviderSimple **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = findSelectionContainer(strongView.Parent());
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::RemoveFromSelection() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  DispatchAccessibilityAction(m_view, "removeFromSelection");
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::Select() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  DispatchAccessibilityAction(m_view, "select");
+  return S_OK;
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation