react-native-windows 0.80.0-preview.1 → 0.80.0-preview.10

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

@@ -27,7 +27,6 @@
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
 constexpr float c_scrollerLineDelta = 16.0f;
-constexpr auto c_maxSnapPoints = 1000;
 
 enum class ScrollbarHitRegion : int {
   Unknown = -1,
@@ -741,15 +740,6 @@ void ScrollViewComponentView::updateBackgroundColor(const facebook::react::Share
   }
 }
 
-winrt::Windows::Foundation::Collections::IVector<float> ScrollViewComponentView::CreateSnapToOffsets(
-    const std::vector<float> &offsets) {
-  auto snapToOffsets = winrt::single_threaded_vector<float>();
-  for (const auto &offset : offsets) {
-    snapToOffsets.Append(offset);
-  }
-  return snapToOffsets;
-}
-
 void ScrollViewComponentView::updateProps(
     facebook::react::Props::Shared const &props,
     facebook::react::Props::Shared const &oldProps) noexcept {
@@ -818,13 +808,11 @@ void ScrollViewComponentView::updateProps(
 
   if (oldViewProps.snapToStart != newViewProps.snapToStart || oldViewProps.snapToEnd != newViewProps.snapToEnd ||
       oldViewProps.snapToOffsets != newViewProps.snapToOffsets) {
-    if (oldViewProps.snapToInterval != newViewProps.snapToInterval) {
-      updateSnapPoints();
-    } else {
-      const auto snapToOffsets = CreateSnapToOffsets(newViewProps.snapToOffsets);
-      m_scrollVisual.SetSnapPoints(
-          newViewProps.snapToStart, newViewProps.snapToEnd, snapToOffsets.GetView(), SnapAlignment::Center);
+    const auto snapToOffsets = winrt::single_threaded_vector<float>();
+    for (const auto &offset : newViewProps.snapToOffsets) {
+      snapToOffsets.Append(static_cast<float>(offset));
     }
+    m_scrollVisual.SetSnapPoints(newViewProps.snapToStart, newViewProps.snapToEnd, snapToOffsets.GetView());
   }
 }
 
@@ -875,9 +863,6 @@ void ScrollViewComponentView::updateContentVisualSize() noexcept {
   m_verticalScrollbarComponent->ContentSize(contentSize);
   m_horizontalScrollbarComponent->ContentSize(contentSize);
   m_scrollVisual.ContentSize(contentSize);
-
-  // Update snap points if snapToInterval is being used, as content size affects the number of snap points
-  updateSnapPoints();
 }
 
 void ScrollViewComponentView::prepareForRecycle() noexcept {}
@@ -1354,6 +1339,32 @@ winrt::Microsoft::ReactNative::Composition::Experimental::IVisual ScrollViewComp
         }
       });
 
+  m_scrollMomentumBeginRevoker = m_scrollVisual.ScrollMomentumBegin(
+      winrt::auto_revoke,
+      [this](
+          winrt::IInspectable const & /*sender*/,
+          winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs const &args) {
+        auto eventEmitter = GetEventEmitter();
+        if (eventEmitter) {
+          auto scrollMetrics = getScrollMetrics(eventEmitter, args);
+          std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(eventEmitter)
+              ->onMomentumScrollBegin(scrollMetrics);
+        }
+      });
+
+  m_scrollMomentumEndRevoker = m_scrollVisual.ScrollMomentumEnd(
+      winrt::auto_revoke,
+      [this](
+          winrt::IInspectable const & /*sender*/,
+          winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs const &args) {
+        auto eventEmitter = GetEventEmitter();
+        if (eventEmitter) {
+          auto scrollMetrics = getScrollMetrics(eventEmitter, args);
+          std::static_pointer_cast<facebook::react::ScrollViewEventEmitter const>(eventEmitter)
+              ->onMomentumScrollEnd(scrollMetrics);
+        }
+      });
+
   return visual;
 }
 
@@ -1450,50 +1461,4 @@ void ScrollViewComponentView::updateShowsVerticalScrollIndicator(bool value) noe
 void ScrollViewComponentView::updateDecelerationRate(float value) noexcept {
   m_scrollVisual.SetDecelerationRate({value, value, value});
 }
-
-SnapAlignment ScrollViewComponentView::convertSnapToAlignment(
-    facebook::react::ScrollViewSnapToAlignment alignment) noexcept {
-  switch (alignment) {
-    case facebook::react::ScrollViewSnapToAlignment::Center:
-      return SnapAlignment::Center;
-    case facebook::react::ScrollViewSnapToAlignment::End:
-      return SnapAlignment::End;
-    case facebook::react::ScrollViewSnapToAlignment::Start:
-    default:
-      return SnapAlignment::Start;
-  }
-}
-
-void ScrollViewComponentView::updateSnapPoints() noexcept {
-  const auto &viewProps = *std::static_pointer_cast<const facebook::react::ScrollViewProps>(this->viewProps());
-  const auto snapToOffsets = CreateSnapToOffsets(viewProps.snapToOffsets);
-  // Typically used in combination with snapToAlignment and decelerationRate="fast"
-  auto snapAlignment = SnapAlignment::Center;
-  auto decelerationRate = viewProps.decelerationRate;
-
-  // snapToOffsets has priority over snapToInterval (matches React Native behavior)
-  if (viewProps.snapToInterval > 0 && decelerationRate >= 0.99) {
-    snapAlignment = convertSnapToAlignment(viewProps.snapToAlignment);
-    // Generate snap points based on interval
-    // Calculate the content size to determine how many intervals to create
-    float contentLength = viewProps.horizontal
-        ? std::max(m_contentSize.width, m_layoutMetrics.frame.size.width) * m_layoutMetrics.pointScaleFactor
-        : std::max(m_contentSize.height, m_layoutMetrics.frame.size.height) * m_layoutMetrics.pointScaleFactor;
-
-    float interval = static_cast<float>(viewProps.snapToInterval) * m_layoutMetrics.pointScaleFactor;
-
-    // Ensure we have a reasonable minimum interval to avoid infinite loops or excessive memory usage
-    if (interval >= 1.0f && contentLength > 0) {
-      // Generate offsets at each interval, but limit the number of snap points to avoid excessive memory usage
-      int snapPointCount = 0;
-
-      for (float offset = 0; offset <= contentLength && snapPointCount < c_maxSnapPoints; offset += interval) {
-        snapToOffsets.Append(offset);
-        snapPointCount++;
-      }
-    }
-  }
-
-  m_scrollVisual.SetSnapPoints(viewProps.snapToStart, viewProps.snapToEnd, snapToOffsets.GetView(), snapAlignment);
-}
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -18,8 +18,6 @@
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
-using namespace Microsoft::ReactNative::Composition::Experimental;
-
 struct ScrollBarComponent;
 
 struct ScrollViewComponentView : ScrollViewComponentViewT<ScrollViewComponentView, ViewComponentView> {
@@ -123,7 +121,6 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
  private:
   void updateDecelerationRate(float value) noexcept;
   void updateContentVisualSize() noexcept;
-  void updateSnapPoints() noexcept;
   bool scrollToEnd(bool animate) noexcept;
   bool scrollToStart(bool animate) noexcept;
   bool scrollDown(float delta, bool animate) noexcept;
@@ -137,8 +134,6 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
       winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs const &args) noexcept;
   void updateShowsHorizontalScrollIndicator(bool value) noexcept;
   void updateShowsVerticalScrollIndicator(bool value) noexcept;
-  SnapAlignment convertSnapToAlignment(facebook::react::ScrollViewSnapToAlignment alignment) noexcept;
-  winrt::Windows::Foundation::Collections::IVector<float> CreateSnapToOffsets(const std::vector<float> &offsets);
 
   facebook::react::Size m_contentSize;
   winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual m_scrollVisual{nullptr};
@@ -148,9 +143,12 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
       m_scrollPositionChangedRevoker{};
   winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual::ScrollBeginDrag_revoker
       m_scrollBeginDragRevoker{};
-
   winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual::ScrollEndDrag_revoker
       m_scrollEndDragRevoker{};
+  winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual::ScrollMomentumBegin_revoker
+      m_scrollMomentumBeginRevoker{};
+  winrt::Microsoft::ReactNative::Composition::Experimental::IScrollVisual::ScrollMomentumEnd_revoker
+      m_scrollMomentumEndRevoker{};
 
   float m_zoomFactor{1.0f};
   bool m_isScrollingFromInertia = false;

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

@@ -9,6 +9,7 @@
 #include <Fabric/AbiViewProps.h>
 #include "CompositionDynamicAutomationProvider.h"
 #include "RootComponentView.h"
+#include "UiaHelpers.h"
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
@@ -80,6 +81,16 @@ void SwitchComponentView::updateProps(
     m_visualUpdateRequired = true;
   }
 
+  if (oldViewProps.value != newViewProps.value) {
+    if (UiaClientsAreListening()) {
+      winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+          EnsureUiaProvider(),
+          UIA_ToggleToggleStatePropertyId,
+          oldViewProps.value ? ToggleState_On : ToggleState_Off,
+          newViewProps.value ? ToggleState_On : ToggleState_Off);
+    }
+  }
+
   Super::updateProps(props, oldProps);
 }
 

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

@@ -7,6 +7,7 @@
 #include "TextDrawing.h"
 
 #include <AutoDraw.h>
+#include <Fabric/platform/react/renderer/graphics/PlatformColorUtils.h>
 #include <Utils/ValueUtils.h>
 #include <unicode.h>
 #include <windows.ui.composition.interop.h>
@@ -35,11 +36,27 @@ void RenderText(
   // to cache and reuse a brush across all text elements instead, taking care to recreate
   // it in the event of device removed.
   winrt::com_ptr<ID2D1SolidColorBrush> brush;
+
+  // Check if we should use theme-aware default color instead of hardcoded black
+  bool useDefaultColor = false;
   if (textAttributes.foregroundColor) {
+    auto &color = *textAttributes.foregroundColor;
+    // If it's black (or very dark) without explicit PlatformColor, use theme-aware color
+    if (color.m_platformColor.empty() && color.m_color.R <= 10 && color.m_color.G <= 10 && color.m_color.B <= 10) {
+      useDefaultColor = true;
+    }
+  } else {
+    useDefaultColor = true;
+  }
+
+  if (useDefaultColor) {
+    // Use theme-aware TextFillColorPrimary which adapts to light/dark mode
+    auto d2dColor = theme.D2DPlatformColor("TextFillColorPrimary");
+    winrt::check_hresult(deviceContext.CreateSolidColorBrush(d2dColor, brush.put()));
+  } else {
+    // User set explicit color or PlatformColor - use it
     auto color = theme.D2DColor(*textAttributes.foregroundColor);
     winrt::check_hresult(deviceContext.CreateSolidColorBrush(color, brush.put()));
-  } else {
-    winrt::check_hresult(deviceContext.CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, 1.0f), brush.put()));
   }
 
   if (textAttributes.textDecorationLineType) {
@@ -72,12 +89,27 @@ void RenderText(
             (fragment.textAttributes.foregroundColor != textAttributes.foregroundColor) ||
         !isnan(fragment.textAttributes.opacity)) {
       winrt::com_ptr<ID2D1SolidColorBrush> fragmentBrush;
+
+      // Check if we should use theme-aware default color for this fragment
+      bool useFragmentDefaultColor = false;
       if (fragment.textAttributes.foregroundColor) {
+        auto &color = *fragment.textAttributes.foregroundColor;
+        // If it's black (or very dark) without explicit PlatformColor, use theme-aware color
+        if (color.m_platformColor.empty() && color.m_color.R <= 10 && color.m_color.G <= 10 && color.m_color.B <= 10) {
+          useFragmentDefaultColor = true;
+        }
+      } else {
+        useFragmentDefaultColor = true;
+      }
+
+      if (useFragmentDefaultColor) {
+        // Use theme-aware TextFillColorPrimary which adapts to light/dark mode
+        auto d2dColor = theme.D2DPlatformColor("TextFillColorPrimary");
+        winrt::check_hresult(deviceContext.CreateSolidColorBrush(d2dColor, fragmentBrush.put()));
+      } else {
+        // User set explicit color or PlatformColor - use it
         auto color = theme.D2DColor(*fragment.textAttributes.foregroundColor);
         winrt::check_hresult(deviceContext.CreateSolidColorBrush(color, fragmentBrush.put()));
-      } else {
-        winrt::check_hresult(
-            deviceContext.CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, 1.0f), fragmentBrush.put()));
       }
 
       if (fragment.textAttributes.textDecorationLineType) {

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.cpp

@@ -8,8 +8,11 @@
 #include <AutoDraw.h>
 #include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
 #include <Fabric/Composition/UiaHelpers.h>
+#include <Fabric/platform/react/renderer/graphics/PlatformColorUtils.h>
+#include <Utils/ThemeUtils.h>
 #include <Utils/ValueUtils.h>
 #include <react/renderer/components/textinput/TextInputState.h>
+#include <react/renderer/graphics/HostPlatformColor.h>
 #include <react/renderer/textlayoutmanager/WindowsTextLayoutManager.h>
 #include <tom.h>
 #include <unicode.h>
@@ -316,8 +319,10 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
     switch (nIndex) {
       case COLOR_WINDOWTEXT:
-        if (m_outer->windowsTextInputProps().textAttributes.foregroundColor)
-          return (*m_outer->windowsTextInputProps().textAttributes.foregroundColor).AsColorRefNoAlpha();
+        if (m_outer->windowsTextInputProps().textAttributes.foregroundColor) {
+          auto color = m_outer->theme()->Color(*m_outer->windowsTextInputProps().textAttributes.foregroundColor);
+          return RGB(color.R, color.G, color.B);
+        }
         // cr = 0x000000FF;
         break;
       case COLOR_WINDOW:
@@ -326,8 +331,10 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
         break;
 
       case COLOR_HIGHLIGHT:
-        if (m_outer->windowsTextInputProps().selectionColor)
-          return (*m_outer->windowsTextInputProps().selectionColor).AsColorRefNoAlpha();
+        if (m_outer->windowsTextInputProps().selectionColor) {
+          auto color = m_outer->theme()->Color(*m_outer->windowsTextInputProps().selectionColor);
+          return RGB(color.R, color.G, color.B);
+        }
         break;
 
       case COLOR_HIGHLIGHTTEXT:
@@ -340,8 +347,9 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
           int r = GetRValue(selectionColor);
           int g = GetGValue(selectionColor);
           int b = GetBValue(selectionColor);
-          int brightness = (r * 299 + g * 587 + b * 114) / 1000;
-          return brightness > 125 ? RGB(0, 0, 0) : RGB(255, 255, 255);
+          int brightness = ::Microsoft::ReactNative::CalculateColorBrightness(r, g, b);
+          return brightness > ::Microsoft::ReactNative::kCaretSelectionBrightnessThreshold ? RGB(0, 0, 0)
+                                                                                           : RGB(255, 255, 255);
         }
         break;
 
@@ -1077,13 +1085,9 @@ std::string WindowsTextInputComponentView::DefaultHelpText() const noexcept {
 void WindowsTextInputComponentView::updateCursorColor(
     const facebook::react::SharedColor &cursorColor,
     const facebook::react::SharedColor &foregroundColor) noexcept {
-  if (cursorColor) {
-    m_caretVisual.Brush(theme()->Brush(*cursorColor));
-  } else if (foregroundColor) {
-    m_caretVisual.Brush(theme()->Brush(*foregroundColor));
-  } else {
-    m_caretVisual.Brush(theme()->PlatformBrush("TextControlForeground"));
-  }
+  const auto &props = windowsTextInputProps();
+  auto caretColor = ::Microsoft::ReactNative::GetCaretColor(cursorColor, foregroundColor, props.backgroundColor);
+  m_caretVisual.Brush(theme()->Brush(*caretColor));
 }
 
 void WindowsTextInputComponentView::updateProps(
@@ -1595,6 +1599,8 @@ void WindowsTextInputComponentView::ensureDrawingSurface() noexcept {
 
 void WindowsTextInputComponentView::ShowCaret(bool show) noexcept {
   ensureVisual();
+  const auto &props = windowsTextInputProps();
+  updateCursorColor(props.cursorColor, props.textAttributes.foregroundColor);
   m_caretVisual.IsVisible(show);
 }
 
@@ -1689,8 +1695,20 @@ void WindowsTextInputComponentView::DrawText() noexcept {
           auto color = theme()->D2DColor(*props.placeholderTextColor);
           winrt::check_hresult(d2dDeviceContext->CreateSolidColorBrush(color, brush.put()));
         } else {
-          winrt::check_hresult(
-              d2dDeviceContext->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Gray, 1.0f), brush.put()));
+          // Use theme-aware placeholder color based on focus state and background
+          // Color selection follows Windows 11 design system semantic colors:
+          // - High contrast: System GrayText for accessibility
+          // - Light backgrounds: Darker grays for better contrast
+          // - Dark backgrounds: Lighter grays for readability
+          winrt::Windows::UI::Color backgroundColor = {};
+          if (facebook::react::isColorMeaningful(props.backgroundColor)) {
+            auto bgColor = (*props.backgroundColor).AsWindowsColor();
+            backgroundColor = bgColor;
+          }
+
+          auto placeholderColor = facebook::react::GetTextInputPlaceholderColor(m_hasFocus, backgroundColor);
+          auto d2dColor = theme()->D2DColor(*placeholderColor);
+          winrt::check_hresult(d2dDeviceContext->CreateSolidColorBrush(d2dColor, brush.put()));
         }
 
         // Create placeholder text layout

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

@@ -166,6 +166,24 @@ void UpdateUiaProperty(winrt::IInspectable provider, PROPERTYID propId, bool old
   UiaRaiseAutomationPropertyChangedEvent(spProviderSimple.get(), propId, CComVariant(oldValue), CComVariant(newValue));
 }
 
+void UpdateUiaProperty(winrt::IInspectable provider, PROPERTYID propId, int oldValue, int newValue) noexcept {
+  auto spProviderSimple = provider.try_as<IRawElementProviderSimple>();
+
+  if (spProviderSimple == nullptr || oldValue == newValue || !WasUiaPropertyAdvised(spProviderSimple, propId))
+    return;
+
+  UiaRaiseAutomationPropertyChangedEvent(spProviderSimple.get(), propId, CComVariant(oldValue), CComVariant(newValue));
+}
+
+void UpdateUiaProperty(winrt::IInspectable provider, PROPERTYID propId, long oldValue, long newValue) noexcept {
+  auto spProviderSimple = provider.try_as<IRawElementProviderSimple>();
+
+  if (spProviderSimple == nullptr || oldValue == newValue || !WasUiaPropertyAdvised(spProviderSimple, propId))
+    return;
+
+  UiaRaiseAutomationPropertyChangedEvent(spProviderSimple.get(), propId, CComVariant(oldValue), CComVariant(newValue));
+}
+
 void UpdateUiaProperty(
     winrt::IInspectable provider,
     PROPERTYID propId,
@@ -190,6 +208,29 @@ void UpdateUiaProperty(
   UpdateUiaProperty(provider, propId, oldData, newData);
 }
 
+void UpdateUiaPropertiesForAnnotation(
+    winrt::IInspectable provider,
+    const std::optional<facebook::react::AccessibilityAnnotation> &oldAnnotation,
+    const std::optional<facebook::react::AccessibilityAnnotation> &newAnnotation) noexcept {
+  // if no value fall back to a default value.
+  const auto &old_annotation = oldAnnotation.value_or(facebook::react::AccessibilityAnnotation());
+  const auto &new_annotation = newAnnotation.value_or(facebook::react::AccessibilityAnnotation());
+
+  // Update all annotation properties
+  UpdateUiaProperty(
+      provider,
+      UIA_AnnotationAnnotationTypeIdPropertyId,
+      GetAnnotationTypeId(old_annotation.typeID),
+      GetAnnotationTypeId(new_annotation.typeID));
+
+  UpdateUiaProperty(
+      provider, UIA_AnnotationAnnotationTypeNamePropertyId, old_annotation.typeName, new_annotation.typeName);
+
+  UpdateUiaProperty(provider, UIA_AnnotationAuthorPropertyId, old_annotation.author, new_annotation.author);
+
+  UpdateUiaProperty(provider, UIA_AnnotationDateTimePropertyId, old_annotation.dateTime, new_annotation.dateTime);
+}
+
 long GetLiveSetting(const std::string &liveRegion) noexcept {
   if (liveRegion == "polite") {
     return LiveSetting::Polite;
@@ -250,6 +291,190 @@ long GetAnnotationTypeId(const std::string &annotationType) noexcept {
   return AnnotationType_Unknown;
 }
 
+long GetControlTypeFromString(const std::string &role) noexcept {
+  if (role == "adjustable") {
+    return UIA_SliderControlTypeId;
+  } else if (role == "group" || role == "search" || role == "radiogroup" || role == "timer" || role.empty()) {
+    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 == "textinput" || role == "searchbox") {
+    return UIA_EditControlTypeId;
+  } else if (role == "toolbar") {
+    return UIA_ToolBarControlTypeId;
+  } else if (role == "tree") {
+    return UIA_TreeControlTypeId;
+  } else if (role == "treeitem") {
+    return UIA_TreeItemControlTypeId;
+  } else if (role == "pane") {
+    return UIA_PaneControlTypeId;
+  }
+  assert(false);
+  return UIA_GroupControlTypeId;
+}
+
+long GetControlTypeFromRole(const facebook::react::Role &role) noexcept {
+  switch (role) {
+    case facebook::react::Role::Alert:
+      return UIA_TextControlTypeId;
+    case facebook::react::Role::Application:
+      return UIA_WindowControlTypeId;
+    case facebook::react::Role::Button:
+      return UIA_ButtonControlTypeId;
+    case facebook::react::Role::Checkbox:
+      return UIA_CheckBoxControlTypeId;
+    case facebook::react::Role::Columnheader:
+      return UIA_HeaderControlTypeId;
+    case facebook::react::Role::Combobox:
+      return UIA_ComboBoxControlTypeId;
+    case facebook::react::Role::Document:
+      return UIA_DocumentControlTypeId;
+    case facebook::react::Role::Grid:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Group:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Heading:
+      return UIA_TextControlTypeId;
+    case facebook::react::Role::Img:
+      return UIA_ImageControlTypeId;
+    case facebook::react::Role::Link:
+      return UIA_HyperlinkControlTypeId;
+    case facebook::react::Role::List:
+      return UIA_ListControlTypeId;
+    case facebook::react::Role::Listitem:
+      return UIA_ListItemControlTypeId;
+    case facebook::react::Role::Menu:
+      return UIA_MenuControlTypeId;
+    case facebook::react::Role::Menubar:
+      return UIA_MenuBarControlTypeId;
+    case facebook::react::Role::Menuitem:
+      return UIA_MenuItemControlTypeId;
+    case facebook::react::Role::None:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Presentation:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Progressbar:
+      return UIA_ProgressBarControlTypeId;
+    case facebook::react::Role::Radio:
+      return UIA_RadioButtonControlTypeId;
+    case facebook::react::Role::Radiogroup:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Rowgroup:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Rowheader:
+      return UIA_HeaderControlTypeId;
+    case facebook::react::Role::Scrollbar:
+      return UIA_ScrollBarControlTypeId;
+    case facebook::react::Role::Searchbox:
+      return UIA_EditControlTypeId;
+    case facebook::react::Role::Separator:
+      return UIA_SeparatorControlTypeId;
+    case facebook::react::Role::Slider:
+      return UIA_SliderControlTypeId;
+    case facebook::react::Role::Spinbutton:
+      return UIA_SpinnerControlTypeId;
+    case facebook::react::Role::Status:
+      return UIA_StatusBarControlTypeId;
+    case facebook::react::Role::Summary:
+      return UIA_GroupControlTypeId;
+    case facebook::react::Role::Switch:
+      return UIA_ButtonControlTypeId;
+    case facebook::react::Role::Tab:
+      return UIA_TabItemControlTypeId;
+    case facebook::react::Role::Table:
+      return UIA_TableControlTypeId;
+    case facebook::react::Role::Tablist:
+      return UIA_TabControlTypeId;
+    case facebook::react::Role::Tabpanel:
+      return UIA_TabControlTypeId;
+    case facebook::react::Role::Timer:
+      return UIA_ButtonControlTypeId;
+    case facebook::react::Role::Toolbar:
+      return UIA_ToolBarControlTypeId;
+    case facebook::react::Role::Tooltip:
+      return UIA_ToolTipControlTypeId;
+    case facebook::react::Role::Tree:
+      return UIA_TreeControlTypeId;
+    case facebook::react::Role::Treegrid:
+      return UIA_TreeControlTypeId;
+    case facebook::react::Role::Treeitem:
+      return UIA_TreeItemControlTypeId;
+  }
+  return UIA_GroupControlTypeId;
+}
+
+long GetHeadingLevel(int headingLevel, const std::string &strRole, const facebook::react::Role &role) noexcept {
+  if (strRole != "header" && role != facebook::react::Role::Heading) {
+    return HeadingLevel_None;
+  }
+
+  switch (headingLevel) {
+    case 1:
+      return HeadingLevel1;
+    case 2:
+      return HeadingLevel2;
+    case 3:
+      return HeadingLevel3;
+    case 4:
+      return HeadingLevel4;
+    case 5:
+      return HeadingLevel5;
+    case 6:
+      return HeadingLevel6;
+    case 7:
+      return HeadingLevel7;
+    case 8:
+      return HeadingLevel8;
+    case 9:
+      return HeadingLevel9;
+    default:
+      return HeadingLevel_None;
+  }
+}
+
 bool accessibilityAnnotationHasValue(
     const std::optional<facebook::react::AccessibilityAnnotation> &annotation) noexcept {
   return annotation.has_value() &&

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

@@ -29,6 +29,18 @@ void UpdateUiaProperty(
     bool oldValue,
     bool newValue) noexcept;
 
+void UpdateUiaProperty(
+    winrt::Windows::Foundation::IInspectable provider,
+    PROPERTYID propId,
+    int oldValue,
+    int newValue) noexcept;
+
+void UpdateUiaProperty(
+    winrt::Windows::Foundation::IInspectable provider,
+    PROPERTYID propId,
+    long oldValue,
+    long newValue) noexcept;
+
 void UpdateUiaProperty(
     winrt::Windows::Foundation::IInspectable provider,
     PROPERTYID propId,
@@ -41,10 +53,21 @@ void UpdateUiaProperty(
     const std::optional<std::string> &oldValue,
     const std::optional<std::string> &newValue) noexcept;
 
+void UpdateUiaPropertiesForAnnotation(
+    winrt::Windows::Foundation::IInspectable provider,
+    const std::optional<facebook::react::AccessibilityAnnotation> &oldAnnotation,
+    const std::optional<facebook::react::AccessibilityAnnotation> &newAnnotation) noexcept;
+
 long GetLiveSetting(const std::string &liveRegion) noexcept;
 
 long GetAnnotationTypeId(const std::string &annotationType) noexcept;
 
+long GetControlTypeFromRole(const facebook::react::Role &role) noexcept;
+
+long GetControlTypeFromString(const std::string &role) noexcept;
+
+long GetHeadingLevel(int headingLevel, const std::string &strRole, const facebook::react::Role &role) noexcept;
+
 bool accessibilityAnnotationHasValue(
     const std::optional<facebook::react::AccessibilityAnnotation> &annotation) noexcept;
 

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -66,7 +66,8 @@ FabricUIManager::~FabricUIManager() {
 void FabricUIManager::installFabricUIManager() noexcept {
   std::lock_guard<std::mutex> schedulerLock(m_schedulerMutex);
 
-  facebook::react::ContextContainer::Shared contextContainer = std::make_shared<facebook::react::ContextContainer>();
+  std::shared_ptr<const facebook::react::ContextContainer> contextContainer =
+      std::make_shared<facebook::react::ContextContainer>();
 
   // This allows access to our ReactContext from the contextContainer thats passed around the fabric codebase
   contextContainer->insert("MSRN.ReactContext", m_context);
@@ -97,8 +98,9 @@ void FabricUIManager::installFabricUIManager() noexcept {
       };
 
   toolbox.contextContainer = contextContainer;
-  toolbox.componentRegistryFactory = [](facebook::react::EventDispatcher::Weak const &eventDispatcher,
-                                        facebook::react::ContextContainer::Shared const &contextContainer)
+  toolbox.componentRegistryFactory =
+      [](facebook::react::EventDispatcher::Weak const &eventDispatcher,
+         std::shared_ptr<const facebook::react::ContextContainer> const &contextContainer)
       -> facebook::react::ComponentDescriptorRegistry::Shared {
     auto providerRegistry =
         WindowsComponentDescriptorRegistry::FromProperties(