react-native-windows 0.71.7 → 0.72.0-preview.1

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

@@ -0,0 +1,144 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "AbiCompositionViewComponentView.h"
+
+#include <Fabric/DWriteHelpers.h>
+#include "CompositionDynamicAutomationProvider.h"
+#include "Unicode.h"
+
+namespace Microsoft::ReactNative {
+
+AbiCompositionViewComponentView::AbiCompositionViewComponentView(
+    const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+    facebook::react::Tag tag,
+    winrt::Microsoft::ReactNative::IReactViewComponentBuilder builder)
+    : Super(compContext, tag), m_builder(builder) {
+  static auto const defaultProps = std::make_shared<AbiViewProps const>();
+  m_props = defaultProps;
+  m_handle = Builder().CreateView(compContext);
+  m_visual = Builder().CreateVisual(m_handle);
+  OuterVisual().InsertAt(m_visual, 0);
+}
+
+std::shared_ptr<AbiCompositionViewComponentView> AbiCompositionViewComponentView::Create(
+    const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+    facebook::react::Tag tag,
+    winrt::Microsoft::ReactNative::IReactViewComponentBuilder builder) noexcept {
+  return std::shared_ptr<AbiCompositionViewComponentView>(
+      new AbiCompositionViewComponentView(compContext, tag, builder));
+}
+
+winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder &
+AbiCompositionViewComponentView::Builder() noexcept {
+  return *winrt::get_self<winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder>(m_builder);
+}
+
+void AbiCompositionViewComponentView::mountChildComponentView(
+    IComponentView &childComponentView,
+    uint32_t index) noexcept {
+  assert(false);
+}
+
+void AbiCompositionViewComponentView::unmountChildComponentView(
+    IComponentView &childComponentView,
+    uint32_t index) noexcept {
+  assert(false);
+}
+
+void AbiCompositionViewComponentView::updateProps(
+    facebook::react::Props::Shared const &props,
+    facebook::react::Props::Shared const &oldProps) noexcept {
+  const auto &oldViewProps = *std::static_pointer_cast<const AbiViewProps>(m_props);
+  const auto &newViewProps = *std::static_pointer_cast<const AbiViewProps>(props);
+
+  updateBorderProps(oldViewProps, newViewProps);
+  Builder().UpdateProps(m_handle, newViewProps.UserProps());
+
+  m_props = std::static_pointer_cast<AbiViewProps const>(props);
+}
+
+void AbiCompositionViewComponentView::updateLayoutMetrics(
+    facebook::react::LayoutMetrics const &layoutMetrics,
+    facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept {
+  if ((layoutMetrics.displayType != m_layoutMetrics.displayType)) {
+    OuterVisual().IsVisible(layoutMetrics.displayType != facebook::react::DisplayType::None);
+  }
+
+  updateBorderLayoutMetrics(layoutMetrics, *m_props);
+
+  winrt::Microsoft::ReactNative::Composition::LayoutMetrics lm;
+  Builder().UpdateLayoutMetrics(
+      m_handle,
+      {{layoutMetrics.frame.origin.x,
+        layoutMetrics.frame.origin.y,
+        layoutMetrics.frame.size.width,
+        layoutMetrics.frame.size.height},
+       layoutMetrics.pointScaleFactor});
+
+  m_layoutMetrics = layoutMetrics;
+}
+
+void AbiCompositionViewComponentView::updateState(
+    facebook::react::State::Shared const &state,
+    facebook::react::State::Shared const &oldState) noexcept {}
+
+void AbiCompositionViewComponentView::finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept {
+  Builder().FinalizeUpdates(m_handle);
+
+  if (m_needsBorderUpdate) {
+    m_needsBorderUpdate = false;
+    UpdateSpecialBorderLayers(m_layoutMetrics, *m_props);
+  }
+}
+
+bool AbiCompositionViewComponentView::focusable() const noexcept {
+  return m_props->focusable;
+}
+
+int64_t AbiCompositionViewComponentView::sendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept {
+  return Builder().SendMessage(m_handle, msg, wParam, lParam);
+}
+
+std::vector<facebook::react::ComponentDescriptorProvider>
+AbiCompositionViewComponentView::supplementalComponentDescriptorProviders() noexcept {
+  return {};
+}
+
+void AbiCompositionViewComponentView::prepareForRecycle() noexcept {}
+facebook::react::Props::Shared AbiCompositionViewComponentView::props() noexcept {
+  return m_props;
+}
+
+winrt::Microsoft::ReactNative::Composition::IVisual AbiCompositionViewComponentView::Visual() const noexcept {
+  return m_visual;
+}
+
+facebook::react::Tag AbiCompositionViewComponentView::hitTest(
+    facebook::react::Point pt,
+    facebook::react::Point &localPt) const noexcept {
+  facebook::react::Point ptLocal{pt.x - m_layoutMetrics.frame.origin.x, pt.y - m_layoutMetrics.frame.origin.y};
+
+  if ((m_props->pointerEvents == facebook::react::PointerEventsMode::Auto ||
+       m_props->pointerEvents == facebook::react::PointerEventsMode::BoxOnly) &&
+      ptLocal.x >= 0 && ptLocal.x <= m_layoutMetrics.frame.size.width && ptLocal.y >= 0 &&
+      ptLocal.y <= m_layoutMetrics.frame.size.height) {
+    localPt = ptLocal;
+    return tag();
+  }
+
+  return -1;
+}
+
+winrt::IInspectable AbiCompositionViewComponentView::EnsureUiaProvider() noexcept {
+  if (m_uiaProvider == nullptr) {
+    m_uiaProvider = winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>(
+        shared_from_this());
+  }
+  return m_uiaProvider;
+}
+
+} // namespace Microsoft::ReactNative

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

@@ -0,0 +1,63 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Fabric/AbiViewProps.h>
+#include <Fabric/ComponentView.h>
+#include <Microsoft.ReactNative.Cxx/ReactContext.h>
+#include "CompositionViewComponentView.h"
+
+#include <Fabric/Composition/ReactCompositionViewComponentBuilder.h>
+
+#include <react/components/rnwcore/ShadowNodes.h>
+
+namespace Microsoft::ReactNative {
+
+struct AbiCompositionViewComponentView : CompositionBaseComponentView {
+  using Super = CompositionBaseComponentView;
+
+  [[nodiscard]] static std::shared_ptr<AbiCompositionViewComponentView> Create(
+      const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+      facebook::react::Tag tag,
+      winrt::Microsoft::ReactNative::IReactViewComponentBuilder builder) noexcept;
+
+  winrt::IInspectable EnsureUiaProvider() noexcept override;
+
+  void mountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept override;
+  void unmountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept override;
+
+  void updateState(facebook::react::State::Shared const &state, facebook::react::State::Shared const &oldState) noexcept
+      override;
+
+  void updateProps(facebook::react::Props::Shared const &props, facebook::react::Props::Shared const &oldProps) noexcept
+      override;
+  void updateLayoutMetrics(
+      facebook::react::LayoutMetrics const &layoutMetrics,
+      facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept override;
+  void finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept override;
+  void prepareForRecycle() noexcept override;
+  bool focusable() const noexcept override;
+  int64_t sendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept override;
+  std::vector<facebook::react::ComponentDescriptorProvider> supplementalComponentDescriptorProviders() noexcept
+      override;
+  facebook::react::Props::Shared props() noexcept override;
+  facebook::react::Tag hitTest(facebook::react::Point pt, facebook::react::Point &localPt) const noexcept override;
+  winrt::Microsoft::ReactNative::Composition::IVisual Visual() const noexcept override;
+
+ private:
+  AbiCompositionViewComponentView(
+      const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+      facebook::react::Tag tag,
+      winrt::Microsoft::ReactNative::IReactViewComponentBuilder builder);
+
+  winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder &Builder() noexcept;
+
+  winrt::IInspectable m_handle;
+  winrt::Microsoft::ReactNative::IReactViewComponentBuilder m_builder;
+  std::shared_ptr<AbiViewProps const> m_props;
+  winrt::Microsoft::ReactNative::Composition::IVisual m_visual{nullptr};
+};
+
+} // namespace Microsoft::ReactNative

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

@@ -19,12 +19,17 @@
 #include <react/renderer/components/text/TextShadowNode.h>
 #include <react/renderer/components/view/ViewShadowNode.h>
 
+#include <Fabric/Composition/AbiCompositionViewComponentView.h>
 #include <Fabric/Composition/CompositionHelpers.h>
 #include <Fabric/Composition/CompositionViewComponentView.h>
 #include <Fabric/Composition/ImageComponentView.h>
 #include <Fabric/Composition/ParagraphComponentView.h>
+#include <Fabric/Composition/RootComponentView.h>
 #include <Fabric/Composition/ScrollViewComponentView.h>
+#include <Fabric/Composition/SwitchComponentView.h>
 #include <Fabric/Composition/TextInput/WindowsTextInputComponentView.h>
+#include <Fabric/Composition/UnimplementedNativeViewComponentView.h>
+#include <Fabric/WindowsComponentDescriptorRegistry.h>
 
 namespace Microsoft::ReactNative {
 
@@ -40,16 +45,32 @@ ComponentViewDescriptor const &ComponentViewRegistry::dequeueComponentViewWithCo
 
   std::shared_ptr<CompositionBaseComponentView> view;
 
-  if (componentHandle == facebook::react::ParagraphShadowNode::Handle()) {
-    view = std::make_shared<ParagraphComponentView>(compContext, tag);
+  if (componentHandle == facebook::react::ViewShadowNode::Handle()) {
+    view = CompositionViewComponentView::Create(compContext, tag);
+  } else if (componentHandle == facebook::react::ParagraphShadowNode::Handle()) {
+    view = ParagraphComponentView::Create(compContext, tag);
   } else if (componentHandle == facebook::react::ScrollViewShadowNode::Handle()) {
-    view = std::make_shared<ScrollViewComponentView>(compContext, tag);
+    view = ScrollViewComponentView::Create(compContext, tag);
   } else if (componentHandle == facebook::react::ImageShadowNode::Handle()) {
-    view = std::make_shared<ImageComponentView>(compContext, tag, m_context);
+    view = ImageComponentView::Create(compContext, tag, m_context);
   } else if (componentHandle == facebook::react::WindowsTextInputShadowNode::Handle()) {
-    view = std::make_shared<WindowsTextInputComponentView>(compContext, tag, m_context);
+    view = WindowsTextInputComponentView::Create(compContext, tag, m_context);
+  } else if (componentHandle == facebook::react::SwitchShadowNode::Handle()) {
+    view = SwitchComponentView::Create(compContext, tag, m_context);
+  } else if (componentHandle == facebook::react::RootShadowNode::Handle()) {
+    view = RootComponentView::Create(compContext, tag);
+  } else if (
+      componentHandle == facebook::react::RawTextShadowNode::Handle() ||
+      componentHandle == facebook::react::TextShadowNode::Handle()) {
+    // Review - Why do we get asked for ComponentViews for Text/RawText... do these get used?
+    view = CompositionViewComponentView::Create(compContext, tag);
+  } else if (componentHandle == facebook::react::UnimplementedNativeViewShadowNode::Handle()) {
+    view = UnimplementedNativeViewComponentView::Create(compContext, tag);
   } else {
-    view = std::make_shared<CompositionViewComponentView>(compContext, tag);
+    auto descriptor =
+        WindowsComponentDescriptorRegistry::FromProperties(m_context.Properties())->GetDescriptor(componentHandle);
+    view = AbiCompositionViewComponentView::Create(
+        compContext, tag, descriptor.as<winrt::Microsoft::ReactNative::IReactViewComponentBuilder>());
   }
 
   auto it = m_registry.insert({tag, ComponentViewDescriptor{view}});

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

@@ -192,6 +192,10 @@ struct CompVisual : public winrt::implements<
   }
 
   void SetClippingPath(ID2D1Geometry *clippingPath) noexcept {
+    if (!clippingPath) {
+      m_visual.Clip(nullptr);
+      return;
+    }
     auto geometry = winrt::make<GeometrySource>(clippingPath);
     auto path = winrt::Windows::UI::Composition::CompositionPath(geometry);
     auto pathgeo = m_visual.Compositor().CreatePathGeometry(path);
@@ -241,6 +245,14 @@ struct CompVisual : public winrt::implements<
     m_visual.RelativeSizeAdjustment(relativeSizeAdjustment);
   }
 
+  winrt::Microsoft::ReactNative::Composition::BackfaceVisibility BackfaceVisibility() {
+    return static_cast<winrt::Microsoft::ReactNative::Composition::BackfaceVisibility>(m_visual.BackfaceVisibility());
+  }
+
+  void BackfaceVisibility(winrt::Microsoft::ReactNative::Composition::BackfaceVisibility value) {
+    m_visual.BackfaceVisibility(static_cast<winrt::Windows::UI::Composition::CompositionBackfaceVisibility>(value));
+  }
+
  private:
   winrt::Windows::UI::Composition::Visual m_visual;
 };
@@ -327,6 +339,14 @@ struct CompSpriteVisual : winrt::Microsoft::ReactNative::Composition::implementa
     m_visual.RelativeSizeAdjustment(relativeSizeAdjustment);
   }
 
+  winrt::Microsoft::ReactNative::Composition::BackfaceVisibility BackfaceVisibility() {
+    return static_cast<winrt::Microsoft::ReactNative::Composition::BackfaceVisibility>(m_visual.BackfaceVisibility());
+  }
+
+  void BackfaceVisibility(winrt::Microsoft::ReactNative::Composition::BackfaceVisibility value) {
+    m_visual.BackfaceVisibility(static_cast<winrt::Windows::UI::Composition::CompositionBackfaceVisibility>(value));
+  }
+
   void SetClippingPath(ID2D1Geometry *clippingPath) noexcept {
     if (!clippingPath) {
       m_visual.Clip(nullptr);
@@ -511,7 +531,19 @@ struct CompScrollerVisual : winrt::Microsoft::ReactNative::Composition::implemen
     m_visual.RelativeSizeAdjustment(relativeSizeAdjustment);
   }
 
+  winrt::Microsoft::ReactNative::Composition::BackfaceVisibility BackfaceVisibility() {
+    return static_cast<winrt::Microsoft::ReactNative::Composition::BackfaceVisibility>(m_visual.BackfaceVisibility());
+  }
+
+  void BackfaceVisibility(winrt::Microsoft::ReactNative::Composition::BackfaceVisibility value) {
+    m_visual.BackfaceVisibility(static_cast<winrt::Windows::UI::Composition::CompositionBackfaceVisibility>(value));
+  }
+
   void SetClippingPath(ID2D1Geometry *clippingPath) noexcept {
+    if (!clippingPath) {
+      m_visual.Clip(nullptr);
+      return;
+    }
     auto geometry = winrt::make<GeometrySource>(clippingPath);
     auto path = winrt::Windows::UI::Composition::CompositionPath(geometry);
     auto pathgeo = m_visual.Compositor().CreatePathGeometry(path);
@@ -547,6 +579,19 @@ struct CompScrollerVisual : winrt::Microsoft::ReactNative::Composition::implemen
     m_interactionTracker.TryUpdatePositionBy(offset);
   };
 
+  void TryUpdatePosition(winrt::Windows::Foundation::Numerics::float3 const &position, bool animate) noexcept {
+    if (animate) {
+      auto compositor = m_visual.Compositor();
+      auto cubicBezier = compositor.CreateCubicBezierEasingFunction({0.17f, 0.67f}, {1.0f, 1.0f});
+      auto kfa = compositor.CreateVector3KeyFrameAnimation();
+      kfa.Duration(std::chrono::seconds{1});
+      kfa.InsertKeyFrame(1.0f, position, cubicBezier);
+      m_interactionTracker.TryUpdatePositionWithAnimation(kfa);
+    } else {
+      m_interactionTracker.TryUpdatePosition(position);
+    }
+  }
+
  private:
   void FireScrollPositionChanged(winrt::Windows::Foundation::Numerics::float2 position) {
     m_scrollPositionChangedEvent(*this, winrt::make<CompScrollPositionChangedArgs>(position));
@@ -628,6 +673,54 @@ struct CompCaretVisual : winrt::implements<CompCaretVisual, winrt::Microsoft::Re
   winrt::Windows::UI::Composition::Compositor m_compositor{nullptr};
 };
 
+struct CompFocusVisual : winrt::implements<CompFocusVisual, winrt::Microsoft::ReactNative::Composition::IFocusVisual> {
+  CompFocusVisual(winrt::Windows::UI::Composition::Compositor const &compositor)
+      : m_compVisual(compositor.CreateSpriteVisual()), m_brush(compositor.CreateNineGridBrush()) {
+    m_visual = winrt::make<Composition::CompSpriteVisual>(m_compVisual);
+
+    m_compVisual.Opacity(1.0f);
+    m_compVisual.RelativeSizeAdjustment({1, 1});
+
+    m_brush.Source(compositor.CreateColorBrush(winrt::Windows::UI::Colors::Black()));
+    m_brush.IsCenterHollow(true);
+  }
+
+  winrt::Microsoft::ReactNative::Composition::IVisual InnerVisual() const noexcept {
+    return m_visual;
+  }
+
+  bool IsFocused() const noexcept {
+    return m_compVisual.Brush() != nullptr;
+  }
+
+  void IsFocused(bool value) noexcept {
+    if (value) {
+      m_compVisual.Brush(m_brush);
+    } else {
+      m_compVisual.Brush(nullptr);
+    }
+  }
+
+  float ScaleFactor() const noexcept {
+    return m_scaleFactor;
+  }
+
+  void ScaleFactor(float scaleFactor) noexcept {
+    if (m_scaleFactor == scaleFactor) {
+      return;
+    }
+    m_scaleFactor = scaleFactor;
+    auto inset = 2 * scaleFactor;
+    m_brush.SetInsets(inset, inset, inset, inset);
+  }
+
+ private:
+  float m_scaleFactor{0};
+  const winrt::Windows::UI::Composition::CompositionNineGridBrush m_brush;
+  const winrt::Windows::UI::Composition::SpriteVisual m_compVisual;
+  winrt::Microsoft::ReactNative::Composition::IVisual m_visual{nullptr};
+};
+
 struct CompContext : winrt::implements<
                          CompContext,
                          winrt::Microsoft::ReactNative::Composition::ICompositionContext,
@@ -736,6 +829,10 @@ struct CompContext : winrt::implements<
     return winrt::make<Composition::CompCaretVisual>(m_compositor);
   }
 
+  winrt::Microsoft::ReactNative::Composition::IFocusVisual CreateFocusVisual() noexcept {
+    return winrt::make<Composition::CompFocusVisual>(m_compositor);
+  }
+
   winrt::Windows::UI::Composition::CompositionGraphicsDevice CompositionGraphicsDevice() noexcept {
     if (!m_compositionGraphicsDevice) {
       // To create a composition graphics device, we need to QI for another interface

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

@@ -0,0 +1,227 @@
+#include "pch.h"
+#include "CompositionDynamicAutomationProvider.h"
+#include <Fabric/ComponentView.h>
+#pragma warning(push)
+#pragma warning(disable : 4229)
+#define IN
+#define OUT
+#include <atlsafe.h>
+#pragma warning(pop)
+#include "RootComponentView.h"
+#include "UiaHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
+    const std::shared_ptr<::Microsoft::ReactNative::CompositionBaseComponentView> &componentView) noexcept
+    : m_view{std::static_pointer_cast<::Microsoft::ReactNative::IComponentView>(componentView)} {}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::Navigate(
+    NavigateDirection direction,
+    IRawElementProviderFragment **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  return UiaNavigateHelper(m_view, direction, *pRetVal);
+}
+
+// Implementations should return NULL for a top-level element that is hosted in a window. Other elements should return
+// an array that contains UiaAppendRuntimeId (defined in Uiautomationcoreapi.h), followed by a value that is unique
+// within an instance of the fragment.
+//
+// We'll use the react tag as our identifier for those situations
+HRESULT __stdcall CompositionDynamicAutomationProvider::GetRuntimeId(SAFEARRAY **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  CComSafeArray<int32_t> runtimeId;
+  auto hr = runtimeId.Create(2);
+
+  if (FAILED(hr))
+    return hr;
+
+  runtimeId[0] = UiaAppendRuntimeId;
+  runtimeId[1] = strongView->tag();
+
+  *pRetVal = runtimeId.Detach();
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_BoundingRectangle(UiaRect *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::GetEmbeddedFragmentRoots(SAFEARRAY **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::SetFocus(void) {
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_FragmentRoot(IRawElementProviderFragmentRoot **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto rootCV = strongView->rootComponentView();
+  if (rootCV == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto uiaProvider = rootCV->EnsureUiaProvider();
+  if (uiaProvider != nullptr) {
+    winrt::com_ptr<IRawElementProviderFragmentRoot> spReps;
+    uiaProvider.as(spReps);
+    *pRetVal = spReps.detach();
+  }
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_ProviderOptions(ProviderOptions *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = ProviderOptions_ServerSideProvider | ProviderOptions_UseComThreading;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTERNID patternId, IUnknown **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  return S_OK;
+}
+
+long GetControlType(const std::string &role) noexcept {
+  if (role == "adjustable") {
+    return UIA_SliderControlTypeId;
+  } else if (role == "group" || role == "search" || role == "radiogroup" || role == "timer" || role.empty()) {
+    return UIA_GroupControlTypeId;
+  } else if (role == "button" || role == "imagebutton" || role == "switch" || role == "togglebutton") {
+    return UIA_ButtonControlTypeId;
+  } else if (role == "checkbox") {
+    return UIA_CheckBoxControlTypeId;
+  } else if (role == "combobox") {
+    return UIA_ComboBoxControlTypeId;
+  } else if (role == "alert" || role == "header" || role == "summary" || role == "text") {
+    return UIA_TextControlTypeId;
+  } else if (role == "image") {
+    return UIA_ImageControlTypeId;
+  } else if (role == "keyboardkey") {
+    return UIA_CustomControlTypeId;
+  } else if (role == "link") {
+    return UIA_HyperlinkControlTypeId;
+  }
+  // list and listitem were added by RNW to better support UIA Control Types
+  else if (role == "list") {
+    return UIA_ListControlTypeId;
+  } else if (role == "listitem") {
+    return UIA_ListItemControlTypeId;
+  } else if (role == "menu") {
+    return UIA_MenuControlTypeId;
+  } else if (role == "menubar") {
+    return UIA_MenuBarControlTypeId;
+  } else if (role == "menuitem") {
+    return UIA_MenuItemControlTypeId;
+  }
+  // If role is "none", remove the element from the control tree
+  // and expose it as a plain element would in the raw tree.
+  else if (role == "none") {
+    return UIA_GroupControlTypeId;
+  } else if (role == "progressbar") {
+    return UIA_ProgressBarControlTypeId;
+  } else if (role == "radio") {
+    return UIA_RadioButtonControlTypeId;
+  } else if (role == "scrollbar") {
+    return UIA_ScrollBarControlTypeId;
+  } else if (role == "spinbutton") {
+    return UIA_SpinnerControlTypeId;
+  } else if (role == "splitbutton") {
+    return UIA_SplitButtonControlTypeId;
+  } else if (role == "tab") {
+    return UIA_TabItemControlTypeId;
+  } else if (role == "tablist") {
+    return UIA_TabControlTypeId;
+  } else if (role == "toolbar") {
+    return UIA_ToolBarControlTypeId;
+  } else if (role == "tree") {
+    return UIA_TreeControlTypeId;
+  } else if (role == "treeitem") {
+    return UIA_TreeItemControlTypeId;
+  }
+  assert(false);
+  return UIA_GroupControlTypeId;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERTYID propertyId, VARIANT *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  auto strongView = m_view.view();
+  if (strongView == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(strongView->props());
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  switch (propertyId) {
+    case UIA_ControlTypePropertyId: {
+      pRetVal->vt = VT_I4;
+      auto role = props->accessibilityRole;
+      pRetVal->lVal = GetControlType(role);
+      break;
+    }
+    case UIA_AutomationIdPropertyId: {
+      pRetVal->vt = VT_BSTR;
+      auto testId = props->testId;
+      CComBSTR temp(testId.c_str());
+      pRetVal->bstrVal = temp.Detach();
+      break;
+    }
+    case UIA_NamePropertyId: {
+      pRetVal->vt = VT_BSTR;
+      auto name = props->accessibilityLabel;
+      CComBSTR temp(name.c_str());
+      pRetVal->bstrVal = temp.Detach();
+      break;
+    }
+  }
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_HostRawElementProvider(
+    IRawElementProviderSimple **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  return S_OK;
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <Fabric/Composition/CompositionViewComponentView.h>
+#include <Fabric/ReactTaggedView.h>
+#include <UIAutomation.h>
+#include <inspectable.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+class CompositionDynamicAutomationProvider : public winrt::implements<
+                                                 CompositionDynamicAutomationProvider,
+                                                 IInspectable,
+                                                 IRawElementProviderFragment,
+                                                 IRawElementProviderSimple> {
+ public:
+  CompositionDynamicAutomationProvider(
+      const std::shared_ptr<::Microsoft::ReactNative::CompositionBaseComponentView> &componentView) noexcept;
+
+  // inherited via IRawElementProviderFragment
+  virtual HRESULT __stdcall Navigate(NavigateDirection direction, IRawElementProviderFragment **pRetVal) override;
+  virtual HRESULT __stdcall GetRuntimeId(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall get_BoundingRectangle(UiaRect *pRetVal) override;
+  virtual HRESULT __stdcall GetEmbeddedFragmentRoots(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall SetFocus(void) override;
+  virtual HRESULT __stdcall get_FragmentRoot(IRawElementProviderFragmentRoot **pRetVal) override;
+
+  // inherited via IRawElementProviderSimple2
+  virtual HRESULT __stdcall get_ProviderOptions(ProviderOptions *pRetVal) override;
+  virtual HRESULT __stdcall GetPatternProvider(PATTERNID patternId, IUnknown **pRetVal) override;
+  virtual HRESULT __stdcall GetPropertyValue(PROPERTYID propertyId, VARIANT *pRetVal) override;
+  virtual HRESULT __stdcall get_HostRawElementProvider(IRawElementProviderSimple **pRetVal) override;
+  // virtual HRESULT __stdcall ShowContextMenu() noexcept override;
+
+ private:
+  ::Microsoft::ReactNative::ReactTaggedView m_view;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation