react-native-windows 0.74.46 → 0.74.48

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

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

@@ -0,0 +1,319 @@
+#include "pch.h"
+#include "CompositionTextRangeProvider.h"
+#include <Fabric/ComponentView.h>
+#include <Fabric/Composition/ParagraphComponentView.h>
+#include <Fabric/Composition/TextInput/WindowsTextInputComponentView.h>
+#include <Fabric/platform/react/renderer/graphics/HostPlatformColor.h>
+#include <Unicode.h>
+#include "RootComponentView.h"
+#include "UiaHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+CompositionTextRangeProvider::CompositionTextRangeProvider(
+    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+    CompositionDynamicAutomationProvider *parentProvider) noexcept
+    : m_view{componentView} {
+  m_parentProvider.copy_from(parentProvider);
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::Clone(ITextRangeProvider **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  auto clone = winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionTextRangeProvider>(
+      m_view.view().as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), m_parentProvider.get());
+  *pRetVal = clone.detach();
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::Compare(ITextRangeProvider *range, BOOL *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  if (range == nullptr) {
+    *pRetVal = FALSE;
+    return S_OK;
+  }
+
+  // Try to cast to our type , considering provider only supports a single range per view
+  auto other = dynamic_cast<CompositionTextRangeProvider *>(range);
+  if (other && other->m_view.view() == m_view.view()) {
+    *pRetVal = TRUE;
+  } else {
+    *pRetVal = FALSE;
+  }
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::CompareEndpoints(
+    TextPatternRangeEndpoint endpoint,
+    ITextRangeProvider *targetRange,
+    TextPatternRangeEndpoint targetEndpoint,
+    int *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  // For a single-range provider, always equal:
+  *pRetVal = 0;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::ExpandToEnclosingUnit(TextUnit unit) {
+  // no-op
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::FindAttribute(
+    TEXTATTRIBUTEID attributeId,
+    VARIANT val,
+    BOOL backward,
+    ITextRangeProvider **pRetVal) {
+  // no-op
+  *pRetVal = nullptr;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::FindText(
+    BSTR text,
+    BOOL backward,
+    BOOL ignoreCase,
+    ITextRangeProvider **pRetVal) {
+  // no-op
+  *pRetVal = nullptr;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEID attributeId, VARIANT *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::ParagraphProps>(
+      winrt::get_self<ComponentView>(strongView)->props());
+
+  auto textinputProps = std::static_pointer_cast<const facebook::react::WindowsTextInputProps>(
+      winrt::get_self<ComponentView>(strongView)->props());
+
+  auto isTextInput =
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>();
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  if (attributeId == UIA_BackgroundColorAttributeId) {
+    pRetVal->vt = VT_I4;
+    pRetVal->lVal = (*props->backgroundColor).AsColorRefWithAlpha();
+  } else if (attributeId == UIA_CapStyleAttributeId) {
+    pRetVal->vt = VT_I4;
+    auto fontVariant = facebook::react::FontVariant::Default;
+    auto textTransform = facebook::react::TextTransform::None;
+    if (props->textAttributes.fontVariant.has_value()) {
+      fontVariant = props->textAttributes.fontVariant.value();
+    }
+    if (props->textAttributes.textTransform.has_value()) {
+      textTransform = props->textAttributes.textTransform.value();
+    }
+    if (fontVariant == facebook::react::FontVariant::SmallCaps) {
+      pRetVal->lVal = CapStyle_SmallCap;
+    } else if (textTransform == facebook::react::TextTransform::Capitalize) {
+      pRetVal->lVal = CapStyle_Titling;
+    } else if (textTransform == facebook::react::TextTransform::Lowercase) {
+      pRetVal->lVal = CapStyle_None;
+    } else if (textTransform == facebook::react::TextTransform::Uppercase) {
+      pRetVal->lVal = CapStyle_AllCap;
+    }
+  } else if (attributeId == UIA_FontNameAttributeId) {
+    pRetVal->vt = VT_BSTR;
+    auto fontName = props->textAttributes.fontFamily;
+    if (fontName.empty()) {
+      fontName = "Segoe UI";
+    }
+    std::wstring wfontName(fontName.begin(), fontName.end());
+    pRetVal->bstrVal = SysAllocString(wfontName.c_str());
+  } else if (attributeId == UIA_FontSizeAttributeId) {
+    pRetVal->vt = VT_R8;
+    pRetVal->dblVal = props->textAttributes.fontSize;
+  } else if (attributeId == UIA_FontWeightAttributeId) {
+    if (props->textAttributes.fontWeight.has_value()) {
+      pRetVal->vt = VT_I4;
+      pRetVal->lVal = static_cast<long>(props->textAttributes.fontWeight.value());
+    }
+  } else if (attributeId == UIA_ForegroundColorAttributeId) {
+    pRetVal->vt = VT_I4;
+    pRetVal->lVal = (*props->textAttributes.foregroundColor).AsColorRefWithAlpha();
+  } else if (attributeId == UIA_IsItalicAttributeId) {
+    pRetVal->vt = VT_BOOL;
+    pRetVal->boolVal = (props->textAttributes.fontStyle.has_value() &&
+                        props->textAttributes.fontStyle.value() == facebook::react::FontStyle::Italic)
+        ? VARIANT_TRUE
+        : VARIANT_FALSE;
+  } else if (attributeId == UIA_IsReadOnlyAttributeId) {
+    pRetVal->vt = VT_BOOL;
+    pRetVal->boolVal = isTextInput ? textinputProps->editable ? VARIANT_FALSE : VARIANT_TRUE : VARIANT_TRUE;
+  } else if (attributeId == UIA_HorizontalTextAlignmentAttributeId) {
+    pRetVal->vt = VT_I4;
+    auto textAlign = facebook::react::TextAlignment::Center;
+    if (props->textAttributes.alignment.has_value()) {
+      textAlign = props->textAttributes.alignment.value();
+    }
+    if (textAlign == facebook::react::TextAlignment::Left) {
+      pRetVal->lVal = HorizontalTextAlignment_Left;
+    } else if (textAlign == facebook::react::TextAlignment::Right) {
+      pRetVal->lVal = HorizontalTextAlignment_Right;
+    } else if (textAlign == facebook::react::TextAlignment::Center) {
+      pRetVal->lVal = HorizontalTextAlignment_Centered;
+    } else if (textAlign == facebook::react::TextAlignment::Justified) {
+      pRetVal->lVal = HorizontalTextAlignment_Justified;
+    } else if (textAlign == facebook::react::TextAlignment::Natural) {
+      pRetVal->lVal = HorizontalTextAlignment_Left;
+    }
+  } else if (attributeId == UIA_StrikethroughColorAttributeId) {
+    if (props->textAttributes.textDecorationLineType.has_value() &&
+        (props->textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::Strikethrough ||
+         props->textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
+      pRetVal->vt = VT_I4;
+      pRetVal->lVal = (*props->textAttributes.textDecorationColor).AsColorRefWithAlpha();
+    }
+  } else if (attributeId == UIA_StrikethroughStyleAttributeId) {
+    if (props->textAttributes.textDecorationLineType.has_value() &&
+        (props->textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::Strikethrough ||
+         props->textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
+      pRetVal->vt = VT_I4;
+      auto style = props->textAttributes.textDecorationStyle.value();
+      pRetVal->lVal = GetTextDecorationLineStyle(style);
+    }
+  } else if (attributeId == UIA_UnderlineColorAttributeId) {
+    if (props->textAttributes.textDecorationLineType.has_value() &&
+        (props->textAttributes.textDecorationLineType.value() == facebook::react::TextDecorationLineType::Underline ||
+         props->textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
+      pRetVal->vt = VT_I4;
+      pRetVal->lVal = (*props->textAttributes.textDecorationColor).AsColorRefWithAlpha();
+    }
+  } else if (attributeId == UIA_UnderlineStyleAttributeId) {
+    if (props->textAttributes.textDecorationLineType.has_value() &&
+        (props->textAttributes.textDecorationLineType.value() == facebook::react::TextDecorationLineType::Underline ||
+         props->textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
+      pRetVal->vt = VT_I4;
+      auto style = props->textAttributes.textDecorationStyle.value();
+      pRetVal->lVal = GetTextDecorationLineStyle(style);
+    }
+  }
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::GetBoundingRectangles(SAFEARRAY **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  UiaRect rect;
+  auto hr = m_parentProvider->get_BoundingRectangle(&rect);
+  if (FAILED(hr))
+    return hr;
+  *pRetVal = SafeArrayCreateVector(VT_R8, 0, 4);
+  double *pData = nullptr;
+  hr = SafeArrayAccessData(*pRetVal, reinterpret_cast<void **>(&pData));
+  if (FAILED(hr))
+    return hr;
+  pData[0] = rect.left;
+  pData[1] = rect.top;
+  pData[2] = rect.width;
+  pData[3] = rect.height;
+  hr = SafeArrayUnaccessData(*pRetVal);
+  if (FAILED(hr))
+    return hr;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::GetChildren(SAFEARRAY **pRetVal) {
+  // no-op
+  *pRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 0);
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::GetEnclosingElement(IRawElementProviderSimple **pRetVal) {
+  // no-op
+  *pRetVal = nullptr;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::GetText(int maxLength, BSTR *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  auto paragraphView =
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ParagraphComponentView>();
+  std::string text = "";
+  if (paragraphView) {
+    text = paragraphView->DefaultAccessibleName();
+  } else {
+    auto textInputView =
+        strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>();
+    if (textInputView) {
+      text = textInputView->getAccessiblityValue().value().empty() ? textInputView->DefaultAccessibleName()
+                                                                   : textInputView->getAccessiblityValue().value();
+    } else {
+      return UIA_E_NOTSUPPORTED;
+    }
+  }
+
+  std::wstring wtext(text.begin(), text.end());
+  *pRetVal = SysAllocString(wtext.c_str());
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::Move(TextUnit unit, int count, int *pRetVal) {
+  // no-op
+  *pRetVal = 0;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::MoveEndpointByRange(
+    TextPatternRangeEndpoint endpoint,
+    ITextRangeProvider *targetRange,
+    TextPatternRangeEndpoint targetEndpoint) {
+  // no-op
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::MoveEndpointByUnit(
+    TextPatternRangeEndpoint endpoint,
+    TextUnit unit,
+    int count,
+    int *pRetVal) {
+  // no-op
+  *pRetVal = 0;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextRangeProvider::ScrollIntoView(BOOL alignToTop) {
+  // no-op
+  return S_OK;
+}
+
+// All the below methods should be implemented once the selection comes for paragraph and TextInput
+
+HRESULT __stdcall CompositionTextRangeProvider::AddToSelection() {
+  // no-op
+  return S_OK;
+}
+HRESULT __stdcall CompositionTextRangeProvider::RemoveFromSelection() {
+  // no-op
+  return S_OK;
+}
+HRESULT __stdcall CompositionTextRangeProvider::Select() {
+  // no-op
+  return S_OK;
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
+#include <Fabric/Composition/CompositionTextProvider.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 CompositionTextRangeProvider : public winrt::implements<CompositionTextRangeProvider, ITextRangeProvider> {
+ public:
+  CompositionTextRangeProvider(
+      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+      CompositionDynamicAutomationProvider *parentProvider) noexcept;
+
+  // inherited via ITextRangeProvider
+  virtual HRESULT __stdcall Clone(ITextRangeProvider **pRetVal) override;
+  virtual HRESULT __stdcall Compare(ITextRangeProvider *range, BOOL *pRetVal) override;
+  virtual HRESULT __stdcall CompareEndpoints(
+      TextPatternRangeEndpoint endpoint,
+      ITextRangeProvider *targetRange,
+      TextPatternRangeEndpoint targetEndpoint,
+      int *pRetVal) override;
+  virtual HRESULT __stdcall ExpandToEnclosingUnit(TextUnit unit) override;
+  virtual HRESULT __stdcall FindAttribute(
+      TEXTATTRIBUTEID attributeId,
+      VARIANT val,
+      BOOL backward,
+      ITextRangeProvider **pRetVal) override;
+  virtual HRESULT __stdcall FindText(BSTR text, BOOL backward, BOOL ignoreCase, ITextRangeProvider **pRetVal) override;
+  virtual HRESULT __stdcall GetAttributeValue(TEXTATTRIBUTEID attributeId, VARIANT *pRetVal) override;
+  virtual HRESULT __stdcall GetBoundingRectangles(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall GetChildren(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall GetEnclosingElement(IRawElementProviderSimple **pRetVal) override;
+  virtual HRESULT __stdcall GetText(int maxLength, BSTR *pRetVal) override;
+  virtual HRESULT __stdcall Move(TextUnit unit, int count, int *pRetVal) override;
+  virtual HRESULT __stdcall MoveEndpointByRange(
+      TextPatternRangeEndpoint endpoint,
+      ITextRangeProvider *targetRange,
+      TextPatternRangeEndpoint targetEndpoint) override;
+  virtual HRESULT __stdcall MoveEndpointByUnit(
+      TextPatternRangeEndpoint endpoint,
+      TextUnit unit,
+      int count,
+      int *pRetVal) override;
+  virtual HRESULT __stdcall ScrollIntoView(BOOL alignToTop) override;
+  virtual HRESULT __stdcall AddToSelection() override;
+  virtual HRESULT __stdcall RemoveFromSelection() override;
+  virtual HRESULT __stdcall Select() override;
+
+ private:
+  ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::com_ptr<CompositionDynamicAutomationProvider> m_parentProvider;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -381,7 +381,7 @@ void ComponentView::onGotFocus(
       focusRect.size.height += (FOCUS_VISUAL_WIDTH * 2);
       focusVisualRoot(focusRect)->hostFocusVisual(true, get_strong());
     }
-    if (m_uiaProvider) {
+    if (EnsureUiaProvider()) {
       auto spProviderSimple = m_uiaProvider.try_as<IRawElementProviderSimple>();
       if (spProviderSimple != nullptr) {
         winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
@@ -780,6 +780,53 @@ void ComponentView::updateAccessibilityProps(
       oldViewProps.accessibilityLiveRegion,
       newViewProps.accessibilityLiveRegion);
 
+  winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+      EnsureUiaProvider(), UIA_LevelPropertyId, oldViewProps.accessibilityLevel, newViewProps.accessibilityLevel);
+
+  winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+      EnsureUiaProvider(),
+      UIA_AccessKeyPropertyId,
+      oldViewProps.accessibilityAccessKey,
+      newViewProps.accessibilityAccessKey);
+
+  winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+      EnsureUiaProvider(),
+      UIA_ItemTypePropertyId,
+      oldViewProps.accessibilityItemType,
+      newViewProps.accessibilityItemType);
+
+  winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+      EnsureUiaProvider(),
+      UIA_FullDescriptionPropertyId,
+      oldViewProps.accessibilityDescription,
+      newViewProps.accessibilityDescription);
+
+  winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+      EnsureUiaProvider(),
+      UIA_ValueValuePropertyId,
+      oldViewProps.accessibilityValue.text,
+      newViewProps.accessibilityValue.text);
+
+  // Handle expand/collapse state changes
+  if (oldViewProps.accessibilityState.has_value() != newViewProps.accessibilityState.has_value() ||
+      (oldViewProps.accessibilityState.has_value() && newViewProps.accessibilityState.has_value() &&
+       oldViewProps.accessibilityState->expanded != newViewProps.accessibilityState->expanded)) {
+    auto oldExpanded =
+        oldViewProps.accessibilityState.has_value() && oldViewProps.accessibilityState->expanded.has_value()
+        ? oldViewProps.accessibilityState->expanded.value()
+        : false;
+    auto newExpanded =
+        newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->expanded.has_value()
+        ? newViewProps.accessibilityState->expanded.value()
+        : false;
+
+    winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+        EnsureUiaProvider(),
+        UIA_ExpandCollapseExpandCollapseStatePropertyId,
+        static_cast<int>(winrt::Microsoft::ReactNative::implementation::GetExpandCollapseState(oldExpanded)),
+        static_cast<int>(winrt::Microsoft::ReactNative::implementation::GetExpandCollapseState(newExpanded)));
+  }
+
   if ((oldViewProps.accessibilityState.has_value() && oldViewProps.accessibilityState->selected.has_value()) !=
       ((newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->selected.has_value()))) {
     auto compProvider =