react-native-windows 0.81.1 → 0.81.3

package/Libraries/Components/Pressable/Pressable.d.ts

@@ -120,6 +120,14 @@ export interface PressableProps
    */
   disabled?: null | boolean | undefined;
 
+  //[ Windows
+  /**
+   * When the pressable is pressed it will take focus
+   * Default value: true
+   */
+  focusOnPress?: null | boolean | undefined;
+  // Windows]
+
   /**
    * Additional distance outside of this view in which a press is detected.
    */

package/Libraries/Components/Pressable/Pressable.windows.js

@@ -71,6 +71,14 @@ type PressableBaseProps = $ReadOnly<{
    */
   disabled?: ?boolean,
 
+  // [Windows
+  /**
+   * When the pressable is pressed it will take focus
+   * Default value: true
+   */
+  focusOnPress?: ?boolean,
+  // Windows]
+
   /**
    * Additional distance outside of this view in which a press is detected.
    */
@@ -238,6 +246,7 @@ function Pressable({
     delayLongPress,
     disabled,
     focusable,
+    focusOnPress, // Windows
     hitSlop,
     onBlur,
     onFocus,
@@ -309,6 +318,16 @@ function Pressable({
     hitSlop,
   };
 
+  const onPressWithFocus = React.useCallback(
+    (args: GestureResponderEvent) => {
+      if (focusable !== false && focusOnPress !== false) {
+        viewRef?.current?.focus();
+      }
+      onPress?.(args);
+    },
+    [focusOnPress, onPress, focusable],
+  );
+
   const config = useMemo(
     () => ({
       cancelable,
@@ -325,7 +344,7 @@ function Pressable({
       onHoverIn,
       onHoverOut,
       onLongPress,
-      onPress,
+      onPress: onPressWithFocus,
       onPressIn(event: GestureResponderEvent): void {
         if (android_rippleConfig != null) {
           android_rippleConfig.onPressIn(event);
@@ -369,7 +388,7 @@ function Pressable({
       onHoverIn,
       onHoverOut,
       onLongPress,
-      onPress,
+      onPressWithFocus,
       onPressIn,
       onPressMove,
       onPressOut,

package/Microsoft.ReactNative/Fabric/ComponentView.cpp

@@ -8,6 +8,7 @@
 #include "DynamicReader.h"
 
 #include "ComponentView.g.cpp"
+#include "CreateAutomationPeerArgs.g.h"
 #include "LayoutMetricsChangedArgs.g.cpp"
 #include "MountChildComponentViewArgs.g.cpp"
 #include "UnmountChildComponentViewArgs.g.cpp"
@@ -641,7 +642,32 @@ facebook::react::Tag ComponentView::hitTest(
   return -1;
 }
 
+struct CreateAutomationPeerArgs
+    : public winrt::Microsoft::ReactNative::implementation::CreateAutomationPeerArgsT<CreateAutomationPeerArgs> {
+  CreateAutomationPeerArgs(winrt::Windows::Foundation::IInspectable defaultAutomationPeer)
+      : m_defaultAutomationPeer(defaultAutomationPeer) {}
+
+  winrt::Windows::Foundation::IInspectable DefaultAutomationPeer() const noexcept {
+    return m_defaultAutomationPeer;
+  }
+
+ private:
+  winrt::Windows::Foundation::IInspectable m_defaultAutomationPeer;
+};
+
 winrt::IInspectable ComponentView::EnsureUiaProvider() noexcept {
+  if (m_uiaProvider == nullptr) {
+    if (m_builder && m_builder->CreateAutomationPeerHandler()) {
+      m_uiaProvider = m_builder->CreateAutomationPeerHandler()(
+          *this, winrt::make<CreateAutomationPeerArgs>(CreateAutomationProvider()));
+    } else {
+      m_uiaProvider = CreateAutomationProvider();
+    }
+  }
+  return m_uiaProvider;
+}
+
+winrt::Windows::Foundation::IInspectable ComponentView::CreateAutomationProvider() noexcept {
   return nullptr;
 }
 

package/Microsoft.ReactNative/Fabric/ComponentView.h

@@ -208,6 +208,7 @@ struct ComponentView
   virtual facebook::react::Tag
   hitTest(facebook::react::Point pt, facebook::react::Point &localPt, bool ignorePointerEvents = false) const noexcept;
   virtual winrt::Windows::Foundation::IInspectable EnsureUiaProvider() noexcept;
+  virtual winrt::Windows::Foundation::IInspectable CreateAutomationProvider() noexcept;
   virtual std::optional<std::string> getAccessiblityValue() noexcept;
   virtual void setAcccessiblityValue(std::string &&value) noexcept;
   virtual bool getAcccessiblityIsReadOnly() noexcept;
@@ -265,6 +266,7 @@ struct ComponentView
   facebook::react::LayoutMetrics m_layoutMetrics;
   winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::ReactNative::ComponentView> m_children{
       winrt::single_threaded_vector<winrt::Microsoft::ReactNative::ComponentView>()};
+  winrt::Windows::Foundation::IInspectable m_uiaProvider{nullptr};
 
   winrt::event<
       winrt::Windows::Foundation::EventHandler<winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs>>

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

@@ -4,7 +4,6 @@
 #pragma once
 
 #include "ActivityIndicatorComponentView.h"
-#include "CompositionDynamicAutomationProvider.h"
 
 #include <Windows.UI.Composition.h>
 #include <Windows.h>

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

@@ -8,11 +8,8 @@
 namespace winrt::Microsoft::ReactNative::implementation {
 
 CompositionAnnotationProvider::CompositionAnnotationProvider(
-    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
-    CompositionDynamicAutomationProvider *parentProvider) noexcept
-    : m_view{componentView} {
-  m_parentProvider.copy_from(parentProvider);
-}
+    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept
+    : m_view{componentView} {}
 HRESULT __stdcall CompositionAnnotationProvider::get_AnnotationTypeId(int *retVal) {
   if (retVal == nullptr)
     return E_POINTER;

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

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
 #include <Fabric/Composition/CompositionViewComponentView.h>
 #include <Fabric/ReactTaggedView.h>
 #include <UIAutomation.h>
@@ -12,8 +11,7 @@ namespace winrt::Microsoft::ReactNative::implementation {
 class CompositionAnnotationProvider : public winrt::implements<CompositionAnnotationProvider, IAnnotationProvider> {
  public:
   CompositionAnnotationProvider(
-      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
-      CompositionDynamicAutomationProvider *parentProvider) noexcept;
+      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept;
 
   // inherited via IAnnotationProvider
   virtual HRESULT __stdcall get_AnnotationTypeId(int *retVal) override;
@@ -25,7 +23,6 @@ class CompositionAnnotationProvider : public winrt::implements<CompositionAnnota
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;
   winrt::com_ptr<IAnnotationProvider> m_annotationProvider;
-  winrt::com_ptr<CompositionDynamicAutomationProvider> m_parentProvider;
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -2,6 +2,7 @@
 #include "CompositionDynamicAutomationProvider.h"
 #include <Fabric/ComponentView.h>
 #include <Fabric/Composition/CompositionAnnotationProvider.h>
+#include <Fabric/Composition/CompositionTextProvider.h>
 #include <Fabric/Composition/CompositionTextRangeProvider.h>
 #include <Fabric/Composition/ParagraphComponentView.h>
 #include <Fabric/Composition/ScrollViewComponentView.h>
@@ -45,19 +46,6 @@ 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>();
-  }
-
-  if (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ViewComponentView>()) {
-    m_annotationProvider = winrt::make<CompositionAnnotationProvider>(
-                               strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), this)
-                               .try_as<IAnnotationProvider>();
-  }
 }
 
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
@@ -161,6 +149,13 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::SetFocus(void) {
   return UiaSetFocusHelper(m_view);
 }
 
+winrt::IUnknown CompositionDynamicAutomationProvider::TryGetChildSiteLinkAutomationProvider() {
+  if (m_childSiteLink) {
+    return m_childSiteLink.AutomationProvider().as<winrt::IUnknown>();
+  }
+  return nullptr;
+}
+
 HRESULT __stdcall CompositionDynamicAutomationProvider::get_FragmentRoot(IRawElementProviderFragmentRoot **pRetVal) {
   if (pRetVal == nullptr)
     return E_POINTER;
@@ -297,16 +292,31 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
   if (patternId == UIA_TextPatternId &&
       (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>() ||
        strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ParagraphComponentView>())) {
+    if (!m_textProvider) {
+      m_textProvider = winrt::make<CompositionTextProvider>(
+                           strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>())
+                           .as<ITextProvider2>();
+    }
     m_textProvider.as<IUnknown>().copy_to(pRetVal);
   }
 
   if (patternId == UIA_TextPattern2Id &&
       strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>()) {
+    if (!m_textProvider) {
+      m_textProvider = winrt::make<CompositionTextProvider>(
+                           strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>())
+                           .as<ITextProvider2>();
+    }
     m_textProvider.as<IUnknown>().copy_to(pRetVal);
   }
   if (patternId == UIA_AnnotationPatternId &&
       strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ViewComponentView>() &&
       accessibilityAnnotationHasValue(props->accessibilityAnnotation)) {
+    if (!m_annotationProvider) {
+      m_annotationProvider = winrt::make<CompositionAnnotationProvider>(
+                                 strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>())
+                                 .as<IAnnotationProvider>();
+    }
     m_annotationProvider.as<IUnknown>().copy_to(pRetVal);
   }
 
@@ -949,9 +959,18 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetSelection(SAFEARRAY *
   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>();
+
+    winrt::com_ptr<IUnknown> unkSelectionItemProvider;
+    auto hr = selectionItem->GetPatternProvider(UIA_SelectionItemPatternId, unkSelectionItemProvider.put());
+    if (FAILED(hr))
+      return hr;
+
+    auto selectionItemProvider = unkSelectionItemProvider.try_as<ISelectionItemProvider>();
+    if (!selectionItemProvider)
+      return E_FAIL;
+
     BOOL selected;
-    auto hr = provider->get_IsSelected(&selected);
+    hr = selectionItemProvider->get_IsSelected(&selected);
     if (hr == S_OK && selected) {
       selectedItems.push_back(int(i));
     }
@@ -1010,27 +1029,28 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_IsSelected(BOOL *pRe
   return S_OK;
 }
 
-IRawElementProviderSimple *findSelectionContainer(winrt::Microsoft::ReactNative::ComponentView current) {
+winrt::Microsoft::ReactNative::ComponentView findSelectionContainer(
+    winrt::Microsoft::ReactNative::ComponentView current) noexcept {
   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();
-      }
+  if (auto viewbase = current.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>()) {
+    auto props = viewbase->viewProps();
+    if (props->accessibilityState.has_value() && props->accessibilityState->multiselectable.has_value() &&
+        props->accessibilityState->required.has_value()) {
+      return current;
     }
-  } else {
-    return findSelectionContainer(current.Parent());
   }
-  return nullptr;
+  return findSelectionContainer(current.Parent());
+}
+
+winrt::Microsoft::ReactNative::ComponentView CompositionDynamicAutomationProvider::GetSelectionContainer() noexcept {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return nullptr;
+
+  return findSelectionContainer(strongView.Parent());
 }
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::get_SelectionContainer(IRawElementProviderSimple **pRetVal) {
@@ -1041,7 +1061,20 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_SelectionContainer(I
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  *pRetVal = findSelectionContainer(strongView.Parent());
+  *pRetVal = nullptr;
+
+  auto selectionContainerView = GetSelectionContainer();
+  auto uiaProvider =
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(selectionContainerView)
+          ->EnsureUiaProvider();
+  if (uiaProvider != nullptr) {
+    auto spProviderSimple = uiaProvider.try_as<IRawElementProviderSimple>();
+    if (spProviderSimple != nullptr) {
+      spProviderSimple->AddRef();
+      *pRetVal = spProviderSimple.get();
+    }
+  }
+
   return S_OK;
 }
 

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

@@ -97,6 +97,15 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
 
   void AddToSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item);
   void RemoveFromSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item);
+  winrt::Microsoft::ReactNative::ComponentView GetSelectionContainer() noexcept;
+
+  void SetChildSiteLink(winrt::Microsoft::UI::Content::ChildSiteLink childSiteLink) {
+    m_childSiteLink = childSiteLink;
+  }
+
+  // If this object is for a ChildSiteLink, returns the ChildSiteLink's automation provider.
+  // This will be a provider object from the hosted framework (for example, WinUI).
+  winrt::IUnknown TryGetChildSiteLinkAutomationProvider();
 
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;

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

@@ -15,6 +15,7 @@
 #include <winrt/Windows.UI.Input.h>
 #include "Composition.Input.h"
 #include "CompositionViewComponentView.h"
+#include "ParagraphComponentView.h"
 #include "ReactNativeIsland.h"
 #include "RootComponentView.h"
 
@@ -1101,6 +1102,13 @@ void CompositionEventHandler::onPointerExited(
 void CompositionEventHandler::onPointerPressed(
     const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
     winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {
+  namespace Composition = winrt::Microsoft::ReactNative::Composition;
+
+  // Clears any active text selection when left pointer is pressed
+  if (pointerPoint.Properties().PointerUpdateKind() != Composition::Input::PointerUpdateKind::RightButtonPressed) {
+    RootComponentView().ClearCurrentTextSelection();
+  }
+
   PointerId pointerId = pointerPoint.PointerId();
 
   auto staleTouch = std::find_if(m_activeTouches.begin(), m_activeTouches.end(), [pointerId](const auto &pair) {

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

@@ -219,7 +219,8 @@ HRESULT __stdcall CompositionRootAutomationProvider::ElementProviderFromPoint(
     auto local = rootView->ConvertScreenToLocal({static_cast<float>(x), static_cast<float>(y)});
     auto provider = rootView->UiaProviderFromPoint(
         {static_cast<LONG>(local.X * rootView->LayoutMetrics().PointScaleFactor),
-         static_cast<LONG>(local.Y * rootView->LayoutMetrics().PointScaleFactor)});
+         static_cast<LONG>(local.Y * rootView->LayoutMetrics().PointScaleFactor)},
+        {static_cast<LONG>(x), static_cast<LONG>(y)});
     auto spFragment = provider.try_as<IRawElementProviderFragment>();
     if (spFragment) {
       *pRetVal = spFragment.detach();

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

@@ -10,10 +10,8 @@
 namespace winrt::Microsoft::ReactNative::implementation {
 
 CompositionTextProvider::CompositionTextProvider(
-    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
-    CompositionDynamicAutomationProvider *parentProvider) noexcept
+    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept
     : m_view{componentView} {
-  m_parentProvider.copy_from(parentProvider);
   EnsureTextRangeProvider();
 }
 
@@ -24,10 +22,9 @@ void CompositionTextProvider::EnsureTextRangeProvider() {
     return;
 
   if (!m_textRangeProvider) {
-    m_textRangeProvider =
-        winrt::make<CompositionTextRangeProvider>(
-            strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), m_parentProvider.get())
-            .try_as<ITextRangeProvider>();
+    m_textRangeProvider = winrt::make<CompositionTextRangeProvider>(
+                              strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>())
+                              .as<ITextRangeProvider>();
   }
 }
 

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

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
 #include <Fabric/Composition/CompositionViewComponentView.h>
 #include <Fabric/ReactTaggedView.h>
 #include <UIAutomation.h>
@@ -11,9 +10,7 @@ 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;
+  CompositionTextProvider(const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept;
 
   // inherited via ITextProvider
   virtual HRESULT __stdcall get_DocumentRange(ITextRangeProvider **pRetVal) override;
@@ -35,7 +32,6 @@ class CompositionTextProvider : public winrt::implements<CompositionTextProvider
  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

@@ -11,18 +11,14 @@
 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);
-}
+    const winrt::Microsoft::ReactNative::ComponentView &componentView) noexcept
+    : m_view{componentView} {}
 
 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());
+  auto clone = winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionTextRangeProvider>(m_view.view());
   *pRetVal = clone.detach();
   return S_OK;
 }
@@ -91,13 +87,13 @@ HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEI
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  auto props = std::static_pointer_cast<const facebook::react::ParagraphProps>(
+  auto props = std::static_pointer_cast<const facebook::react::BaseViewProps>(
       winrt::get_self<ComponentView>(strongView)->props());
 
-  auto textinputProps = std::static_pointer_cast<const facebook::react::WindowsTextInputProps>(
-      winrt::get_self<ComponentView>(strongView)->props());
+  auto asParagraph =
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ParagraphComponentView>();
 
-  auto isTextInput =
+  auto asTextInput =
       strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>();
 
   if (props == nullptr)
@@ -106,15 +102,16 @@ HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEI
   if (attributeId == UIA_BackgroundColorAttributeId) {
     pRetVal->vt = VT_I4;
     pRetVal->lVal = (*props->backgroundColor).AsColorRefWithAlpha();
-  } else if (attributeId == UIA_CapStyleAttributeId) {
+  } else if (attributeId == UIA_CapStyleAttributeId && asParagraph) {
     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 (asParagraph->paragraphProps().textAttributes.fontVariant.has_value()) {
+      fontVariant = asParagraph->paragraphProps().textAttributes.fontVariant.value();
     }
-    if (props->textAttributes.textTransform.has_value()) {
-      textTransform = props->textAttributes.textTransform.value();
+    if (asParagraph->paragraphProps().textAttributes.textTransform.has_value()) {
+      textTransform = asParagraph->paragraphProps().textAttributes.textTransform.value();
     }
     if (fontVariant == facebook::react::FontVariant::SmallCaps) {
       pRetVal->lVal = CapStyle_SmallCap;
@@ -125,39 +122,44 @@ HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEI
     } else if (textTransform == facebook::react::TextTransform::Uppercase) {
       pRetVal->lVal = CapStyle_AllCap;
     }
-  } else if (attributeId == UIA_FontNameAttributeId) {
+  } else if (attributeId == UIA_FontNameAttributeId && asParagraph) {
     pRetVal->vt = VT_BSTR;
-    auto fontName = props->textAttributes.fontFamily;
+    auto fontName = asParagraph->paragraphProps().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) {
+  } else if (attributeId == UIA_FontSizeAttributeId && asParagraph) {
     pRetVal->vt = VT_R8;
-    pRetVal->dblVal = props->textAttributes.fontSize;
-  } else if (attributeId == UIA_FontWeightAttributeId) {
-    if (props->textAttributes.fontWeight.has_value()) {
+    pRetVal->dblVal = asParagraph->paragraphProps().textAttributes.fontSize;
+  } else if (attributeId == UIA_FontWeightAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.fontWeight.has_value()) {
       pRetVal->vt = VT_I4;
-      pRetVal->lVal = static_cast<long>(props->textAttributes.fontWeight.value());
+      pRetVal->lVal = static_cast<long>(asParagraph->paragraphProps().textAttributes.fontWeight.value());
     }
-  } else if (attributeId == UIA_ForegroundColorAttributeId) {
+  } else if (attributeId == UIA_ForegroundColorAttributeId && asParagraph) {
     pRetVal->vt = VT_I4;
-    pRetVal->lVal = (*props->textAttributes.foregroundColor).AsColorRefWithAlpha();
-  } else if (attributeId == UIA_IsItalicAttributeId) {
+    pRetVal->lVal = (*asParagraph->paragraphProps().textAttributes.foregroundColor).AsColorRefWithAlpha();
+  } else if (attributeId == UIA_IsItalicAttributeId && asParagraph) {
     pRetVal->vt = VT_BOOL;
-    pRetVal->boolVal = (props->textAttributes.fontStyle.has_value() &&
-                        props->textAttributes.fontStyle.value() == facebook::react::FontStyle::Italic)
+    pRetVal->boolVal =
+        (asParagraph->paragraphProps().textAttributes.fontStyle.has_value() &&
+         asParagraph->paragraphProps().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) {
+    if (asTextInput) {
+      pRetVal->boolVal = asTextInput->windowsTextInputProps().editable ? VARIANT_FALSE : VARIANT_TRUE;
+    } else {
+      pRetVal->boolVal = VARIANT_TRUE;
+    }
+  } else if (attributeId == UIA_HorizontalTextAlignmentAttributeId && asParagraph) {
     pRetVal->vt = VT_I4;
     auto textAlign = facebook::react::TextAlignment::Center;
-    if (props->textAttributes.alignment.has_value()) {
-      textAlign = props->textAttributes.alignment.value();
+    if (asParagraph->paragraphProps().textAttributes.alignment.has_value()) {
+      textAlign = asParagraph->paragraphProps().textAttributes.alignment.value();
     }
     if (textAlign == facebook::react::TextAlignment::Left) {
       pRetVal->lVal = HorizontalTextAlignment_Left;
@@ -170,40 +172,42 @@ HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEI
     } 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() ==
+  } else if (attributeId == UIA_StrikethroughColorAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.textDecorationLineType.has_value() &&
+        (asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::Strikethrough ||
-         props->textAttributes.textDecorationLineType.value() ==
+         asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
       pRetVal->vt = VT_I4;
-      pRetVal->lVal = (*props->textAttributes.textDecorationColor).AsColorRefWithAlpha();
+      pRetVal->lVal = (*asParagraph->paragraphProps().textAttributes.textDecorationColor).AsColorRefWithAlpha();
     }
-  } else if (attributeId == UIA_StrikethroughStyleAttributeId) {
-    if (props->textAttributes.textDecorationLineType.has_value() &&
-        (props->textAttributes.textDecorationLineType.value() ==
+  } else if (attributeId == UIA_StrikethroughStyleAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.textDecorationLineType.has_value() &&
+        (asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::Strikethrough ||
-         props->textAttributes.textDecorationLineType.value() ==
+         asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
       pRetVal->vt = VT_I4;
-      auto style = props->textAttributes.textDecorationStyle.value();
+      auto style = asParagraph->paragraphProps().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() ==
+  } else if (attributeId == UIA_UnderlineColorAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.textDecorationLineType.has_value() &&
+        (asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::Underline ||
+         asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
       pRetVal->vt = VT_I4;
-      pRetVal->lVal = (*props->textAttributes.textDecorationColor).AsColorRefWithAlpha();
+      pRetVal->lVal = (*asParagraph->paragraphProps().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() ==
+  } else if (attributeId == UIA_UnderlineStyleAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.textDecorationLineType.has_value() &&
+        (asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::Underline ||
+         asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
       pRetVal->vt = VT_I4;
-      auto style = props->textAttributes.textDecorationStyle.value();
+      auto style = asParagraph->paragraphProps().textAttributes.textDecorationStyle.value();
       pRetVal->lVal = GetTextDecorationLineStyle(style);
     }
   }
@@ -214,7 +218,18 @@ HRESULT __stdcall CompositionTextRangeProvider::GetBoundingRectangles(SAFEARRAY
   if (pRetVal == nullptr)
     return E_POINTER;
   UiaRect rect;
-  auto hr = m_parentProvider->get_BoundingRectangle(&rect);
+
+  auto strongView = m_view.view();
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto componentView = strongView.as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
+  auto provider = componentView->EnsureUiaProvider();
+  auto repf = provider.try_as<IRawElementProviderFragment>();
+  if (!repf)
+    return E_FAIL;
+
+  auto hr = repf->get_BoundingRectangle(&rect);
   if (FAILED(hr))
     return hr;
   *pRetVal = SafeArrayCreateVector(VT_R8, 0, 4);