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

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

@@ -1,6 +1,7 @@
 
 #include "pch.h"
 #include "CompositionContextHelper.h"
+#include <algorithm>
 #if __has_include("Composition.Experimental.SystemCompositionContextHelper.g.cpp")
 #include "Composition.Experimental.SystemCompositionContextHelper.g.cpp"
 #endif
@@ -74,6 +75,10 @@ struct CompositionTypeTraits<WindowsTypeTag> {
       winrt::Windows::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs;
   using InteractionTrackerValuesChangedArgs =
       winrt::Windows::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs;
+  using InteractionTrackerInertiaRestingValue =
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue;
+  using InteractionTrackerInertiaModifier =
+      winrt::Windows::UI::Composition::Interactions::InteractionTrackerInertiaModifier;
   using ScalarKeyFrameAnimation = winrt::Windows::UI::Composition::ScalarKeyFrameAnimation;
   using ShapeVisual = winrt::Windows::UI::Composition::ShapeVisual;
   using SpriteVisual = winrt::Windows::UI::Composition::SpriteVisual;
@@ -143,6 +148,10 @@ struct CompositionTypeTraits<MicrosoftTypeTag> {
       winrt::Microsoft::UI::Composition::Interactions::InteractionTrackerRequestIgnoredArgs;
   using InteractionTrackerValuesChangedArgs =
       winrt::Microsoft::UI::Composition::Interactions::InteractionTrackerValuesChangedArgs;
+  using InteractionTrackerInertiaRestingValue =
+      winrt::Microsoft::UI::Composition::Interactions::InteractionTrackerInertiaRestingValue;
+  using InteractionTrackerInertiaModifier =
+      winrt::Microsoft::UI::Composition::Interactions::InteractionTrackerInertiaModifier;
   using ScalarKeyFrameAnimation = winrt::Microsoft::UI::Composition::ScalarKeyFrameAnimation;
   using ShapeVisual = winrt::Microsoft::UI::Composition::ShapeVisual;
   using SpriteVisual = winrt::Microsoft::UI::Composition::SpriteVisual;
@@ -700,8 +709,23 @@ struct CompScrollerVisual : winrt::implements<
     void IdleStateEntered(
         typename TTypeRedirects::InteractionTracker sender,
         typename TTypeRedirects::InteractionTrackerIdleStateEnteredArgs args) noexcept {
+      // If we were in inertia and are now idle, momentum has ended
+      if (m_outer->m_inertia) {
+        m_outer->FireScrollMomentumEnd({sender.Position().x, sender.Position().y});
+      }
+
+      // If we were interacting but never entered inertia (Interacting -> Idle),
+      // and the interaction was user-driven (requestId == 0), fire end-drag here.
+      // Note: if the interactionRequestId was non-zero it was caused by a Try* call
+      // (programmatic), so we should not fire onScrollEndDrag.
+      if (m_outer->m_interacting && args.RequestId() == 0) {
+        m_outer->FireScrollEndDrag({sender.Position().x, sender.Position().y});
+      }
+
+      // Clear state flags
       m_outer->m_custom = false;
       m_outer->m_inertia = false;
+      m_outer->m_interacting = false;
     }
     void InertiaStateEntered(
         typename TTypeRedirects::InteractionTracker sender,
@@ -709,15 +733,26 @@ struct CompScrollerVisual : winrt::implements<
       m_outer->m_custom = false;
       m_outer->m_inertia = true;
       m_outer->m_currentPosition = args.NaturalRestingPosition();
-      // When the user stops interacting with the object, tracker can go into two paths:
-      // 1. tracker goes into idle state immediately
-      // 2. tracker has just started gliding into Inertia state
-      // Fire ScrollEndDrag
-      m_outer->FireScrollEndDrag({args.NaturalRestingPosition().x, args.NaturalRestingPosition().y});
+
+      if (!m_outer->m_interacting && args.RequestId() == 0) {
+        m_outer->FireScrollBeginDrag({args.NaturalRestingPosition().x, args.NaturalRestingPosition().y});
+      }
+
+      // If interaction was user-driven (requestId == 0),
+      // fire ScrollEndDrag here (Interacting -> Inertia caused by user lift).
+      if (m_outer->m_interacting && args.RequestId() == 0) {
+        m_outer->FireScrollEndDrag({args.NaturalRestingPosition().x, args.NaturalRestingPosition().y});
+      }
+
+      // Fire momentum scroll begin when we enter inertia (user or programmatic)
+      m_outer->FireScrollMomentumBegin({args.NaturalRestingPosition().x, args.NaturalRestingPosition().y});
     }
     void InteractingStateEntered(
         typename TTypeRedirects::InteractionTracker sender,
         typename TTypeRedirects::InteractionTrackerInteractingStateEnteredArgs args) noexcept {
+      // Mark that we're now interacting and remember the requestId (user manipulations => 0)
+      m_outer->m_interacting = true;
+
       // Fire when the user starts dragging the object
       m_outer->FireScrollBeginDrag({sender.Position().x, sender.Position().y});
     }
@@ -727,6 +762,10 @@ struct CompScrollerVisual : winrt::implements<
     void ValuesChanged(
         typename TTypeRedirects::InteractionTracker sender,
         typename TTypeRedirects::InteractionTrackerValuesChangedArgs args) noexcept {
+      if (!m_outer->m_interacting && args.RequestId() == 0) {
+        m_outer->FireScrollBeginDrag({args.Position().x, args.Position().y});
+      }
+      m_outer->m_interacting = true;
       m_outer->m_currentPosition = args.Position();
       m_outer->FireScrollPositionChanged({args.Position().x, args.Position().y});
     }
@@ -782,9 +821,13 @@ struct CompScrollerVisual : winrt::implements<
   }
 
   void Horizontal(bool value) noexcept {
+    bool previousHorizontal = m_horizontal;
     m_horizontal = value;
 
-    UpdateInteractionModes();
+    if (previousHorizontal != m_horizontal) {
+      UpdateInteractionModes();
+      ConfigureSnapInertiaModifiers(); // Reconfigure modifiers when direction changes
+    }
   }
 
   void UpdateInteractionModes() noexcept {
@@ -855,6 +898,21 @@ struct CompScrollerVisual : winrt::implements<
     m_interactionTracker.MinScale(minimumZoomScale);
   }
 
+  void SetSnapPoints(
+      bool snapToStart,
+      bool snapToEnd,
+      winrt::Windows::Foundation::Collections::IVectorView<float> const &offsets) noexcept {
+    m_snapToStart = snapToStart;
+    m_snapToEnd = snapToEnd;
+    m_snapToOffsets.clear();
+    if (offsets) {
+      for (auto const &offset : offsets) {
+        m_snapToOffsets.push_back(offset);
+      }
+    }
+    ConfigureSnapInertiaModifiers();
+  }
+
   void Opacity(float opacity) noexcept {
     m_visual.Opacity(opacity);
   }
@@ -953,6 +1011,20 @@ struct CompScrollerVisual : winrt::implements<
     return m_scrollEndDragEvent.add(handler);
   }
 
+  winrt::event_token ScrollMomentumBegin(
+      winrt::Windows::Foundation::EventHandler<
+          winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs> const
+          &handler) noexcept {
+    return m_scrollMomentumBeginEvent.add(handler);
+  }
+
+  winrt::event_token ScrollMomentumEnd(
+      winrt::Windows::Foundation::EventHandler<
+          winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs> const
+          &handler) noexcept {
+    return m_scrollMomentumEndEvent.add(handler);
+  }
+
   void ScrollPositionChanged(winrt::event_token const &token) noexcept {
     m_scrollPositionChangedEvent.remove(token);
   }
@@ -965,6 +1037,14 @@ struct CompScrollerVisual : winrt::implements<
     m_scrollEndDragEvent.remove(token);
   }
 
+  void ScrollMomentumBegin(winrt::event_token const &token) noexcept {
+    m_scrollMomentumBeginEvent.remove(token);
+  }
+
+  void ScrollMomentumEnd(winrt::event_token const &token) noexcept {
+    m_scrollMomentumEndEvent.remove(token);
+  }
+
   void ContentSize(winrt::Windows::Foundation::Numerics::float2 const &size) noexcept {
     m_contentSize = size;
     m_contentVisual.Size(size);
@@ -1043,6 +1123,14 @@ struct CompScrollerVisual : winrt::implements<
     m_scrollEndDragEvent(*this, winrt::make<CompScrollPositionChangedArgs>(position));
   }
 
+  void FireScrollMomentumBegin(winrt::Windows::Foundation::Numerics::float2 position) noexcept {
+    m_scrollMomentumBeginEvent(*this, winrt::make<CompScrollPositionChangedArgs>(position));
+  }
+
+  void FireScrollMomentumEnd(winrt::Windows::Foundation::Numerics::float2 position) noexcept {
+    m_scrollMomentumEndEvent(*this, winrt::make<CompScrollPositionChangedArgs>(position));
+  }
+
   void UpdateMaxPosition() noexcept {
     m_interactionTracker.MaxPosition(
         {std::max<float>(m_contentSize.x - m_visualSize.x, 0),
@@ -1050,10 +1138,158 @@ struct CompScrollerVisual : winrt::implements<
          0});
   }
 
+  void ConfigureSnapInertiaModifiers() noexcept {
+    if (!m_visual || !m_contentVisual || !m_interactionTracker) {
+      return;
+    }
+
+    auto visualSize = m_visual.Size();
+    auto contentSize = m_contentVisual.Size();
+    if (visualSize.x <= 0 || visualSize.y <= 0 || contentSize.x <= 0 || contentSize.y <= 0) {
+      OutputDebugStringW(L"Invalid visual/content size\n");
+      return;
+    }
+
+    auto compositor = m_interactionTracker.Compositor();
+
+    // Collect and deduplicate all snap positions
+    std::vector<float> snapPositions;
+
+    if (m_snapToStart) {
+      snapPositions.push_back(0.0f);
+    }
+
+    snapPositions.insert(snapPositions.end(), m_snapToOffsets.begin(), m_snapToOffsets.end());
+    std::sort(snapPositions.begin(), snapPositions.end());
+    snapPositions.erase(std::unique(snapPositions.begin(), snapPositions.end()), snapPositions.end());
+
+    std::vector<typename TTypeRedirects::InteractionTrackerInertiaRestingValue> restingValues;
+
+    for (size_t i = 0; i < snapPositions.size(); ++i) {
+      const auto position = snapPositions[i];
+      auto restingValue = TTypeRedirects::InteractionTrackerInertiaRestingValue::Create(compositor);
+
+      winrt::hstring axisComponent = m_horizontal ? L"X" : L"Y";
+      winrt::hstring conditionExpr;
+
+      // Build condition expression based on whether there's one or multiple snap points
+      if (snapPositions.size() == 1) {
+        conditionExpr = L"abs(this.Target.NaturalRestingPosition." + axisComponent + L" - snap) < 50";
+      } else {
+        if (i == 0) {
+          conditionExpr = L"this.Target.NaturalRestingPosition." + axisComponent + L" < midpoint";
+        } else if (i == snapPositions.size() - 1) {
+          conditionExpr = L"this.Target.NaturalRestingPosition." + axisComponent + L" >= midpoint";
+        } else {
+          conditionExpr = L"this.Target.NaturalRestingPosition." + axisComponent +
+              L" >= prevMidpoint && this.Target.NaturalRestingPosition." + axisComponent + L" < nextMidpoint";
+        }
+      }
+
+      auto conditionAnim = compositor.CreateExpressionAnimation();
+      conditionAnim.Expression(conditionExpr);
+
+      if (snapPositions.size() == 1) {
+        conditionAnim.SetScalarParameter(L"snap", position);
+      } else {
+        // Multiple snap points - use range-based conditions
+        if (i == 0) {
+          const auto nextPosition = snapPositions[i + 1];
+          const auto midpoint = (position + nextPosition) / 2.0f;
+          conditionAnim.SetScalarParameter(L"midpoint", midpoint);
+        } else if (i == snapPositions.size() - 1) {
+          const auto prevPosition = snapPositions[i - 1];
+          const auto midpoint = (prevPosition + position) / 2.0f;
+          conditionAnim.SetScalarParameter(L"midpoint", midpoint);
+        } else {
+          const auto prevPosition = snapPositions[i - 1];
+          const auto nextPosition = snapPositions[i + 1];
+          const auto prevMidpoint = (prevPosition + position) / 2.0f;
+          const auto nextMidpoint = (position + nextPosition) / 2.0f;
+          conditionAnim.SetScalarParameter(L"prevMidpoint", prevMidpoint);
+          conditionAnim.SetScalarParameter(L"nextMidpoint", nextMidpoint);
+        }
+      }
+
+      restingValue.Condition(conditionAnim);
+
+      // Resting value simply snaps to this position
+      auto restingAnim = compositor.CreateExpressionAnimation();
+      restingAnim.Expression(L"snap");
+      restingAnim.SetScalarParameter(L"snap", position);
+      restingValue.RestingValue(restingAnim);
+
+      restingValues.push_back(restingValue);
+    }
+
+    if (m_snapToEnd) {
+      auto endRestingValue = TTypeRedirects::InteractionTrackerInertiaRestingValue::Create(compositor);
+
+      // Create property sets to dynamically compute content - visual size
+      auto contentSizePropertySet = compositor.CreatePropertySet();
+      contentSizePropertySet.InsertVector2(L"Size", m_contentVisual.Size());
+
+      auto visualSizePropertySet = compositor.CreatePropertySet();
+      visualSizePropertySet.InsertVector2(L"Size", m_visual.Size());
+
+      winrt::hstring endPositionExpr = m_horizontal ? L"max(contentSize.Size.x - visualSize.Size.x, 0)"
+                                                    : L"max(contentSize.Size.y - visualSize.Size.y, 0)";
+
+      float prevPosition = snapPositions.empty() ? 0.0f : snapPositions.back();
+
+      winrt::hstring endConditionExpr = m_horizontal
+          ? L"this.Target.NaturalRestingPosition.X >= ((max(contentSize.Size.x - visualSize.Size.x, 0) + prevSnap) / 2.0)"
+          : L"this.Target.NaturalRestingPosition.Y >= ((max(contentSize.Size.y - visualSize.Size.y, 0) + prevSnap) / 2.0)";
+
+      auto endCondition = compositor.CreateExpressionAnimation();
+      endCondition.Expression(endConditionExpr);
+      endCondition.SetReferenceParameter(L"contentSize", contentSizePropertySet);
+      endCondition.SetReferenceParameter(L"visualSize", visualSizePropertySet);
+      endCondition.SetScalarParameter(L"prevSnap", prevPosition);
+
+      auto endResting = compositor.CreateExpressionAnimation();
+      endResting.Expression(endPositionExpr);
+      endResting.SetReferenceParameter(L"contentSize", contentSizePropertySet);
+      endResting.SetReferenceParameter(L"visualSize", visualSizePropertySet);
+
+      endRestingValue.Condition(endCondition);
+      endRestingValue.RestingValue(endResting);
+
+      restingValues.push_back(endRestingValue);
+    }
+
+    if (!restingValues.empty()) {
+      auto modifiers = winrt::single_threaded_vector<typename TTypeRedirects::InteractionTrackerInertiaModifier>();
+      for (auto &v : restingValues) {
+        auto modifier = v.as<typename TTypeRedirects::InteractionTrackerInertiaModifier>();
+        if (modifier) {
+          modifiers.Append(modifier);
+        }
+      }
+
+      if (m_horizontal) {
+        m_interactionTracker.ConfigurePositionXInertiaModifiers(modifiers);
+      } else {
+        m_interactionTracker.ConfigurePositionYInertiaModifiers(modifiers);
+      }
+    } else {
+      // Clear inertia modifiers when no snapping is configured
+      if (m_horizontal) {
+        m_interactionTracker.ConfigurePositionXInertiaModifiers({});
+      } else {
+        m_interactionTracker.ConfigurePositionYInertiaModifiers({});
+      }
+    }
+  }
+
   bool m_isScrollEnabled{true};
   bool m_horizontal{false};
+  bool m_snapToStart{true};
+  bool m_snapToEnd{true};
+  std::vector<float> m_snapToOffsets;
   bool m_inertia{false};
   bool m_custom{false};
+  bool m_interacting{false};
   winrt::Windows::Foundation::Numerics::float3 m_targetPosition;
   winrt::Windows::Foundation::Numerics::float3 m_currentPosition;
   winrt::Windows::Foundation::Numerics::float2 m_contentSize{0};
@@ -1067,6 +1303,12 @@ struct CompScrollerVisual : winrt::implements<
   winrt::event<winrt::Windows::Foundation::EventHandler<
       winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs>>
       m_scrollEndDragEvent;
+  winrt::event<winrt::Windows::Foundation::EventHandler<
+      winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs>>
+      m_scrollMomentumBeginEvent;
+  winrt::event<winrt::Windows::Foundation::EventHandler<
+      winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs>>
+      m_scrollMomentumEndEvent;
   typename TTypeRedirects::SpriteVisual m_visual{nullptr};
   typename TTypeRedirects::SpriteVisual m_contentVisual{nullptr};
   typename TTypeRedirects::InteractionTracker m_interactionTracker{nullptr};

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

@@ -14,6 +14,21 @@
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
+// Helper function to check if any parent has NoHideDescendants
+bool IsHiddenByParent(const winrt::Microsoft::ReactNative::ComponentView &view) {
+  auto parent = view.Parent();
+  while (parent) {
+    auto parentProps = std::static_pointer_cast<const facebook::react::ViewProps>(
+        winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(parent)->props());
+    if (parentProps &&
+        parentProps->importantForAccessibility == facebook::react::ImportantForAccessibility::NoHideDescendants) {
+      return true;
+    }
+    parent = parent.Parent();
+  }
+  return false;
+}
+
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
     const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept
     : m_view{componentView} {
@@ -298,161 +313,6 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
   return S_OK;
 }
 
-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;
-}
-
 HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERTYID propertyId, VARIANT *pRetVal) {
   if (pRetVal == nullptr)
     return E_POINTER;
@@ -521,23 +381,43 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
     }
     case UIA_IsContentElementPropertyId: {
       pRetVal->vt = VT_BOOL;
-      pRetVal->boolVal =
-          (props->accessible && (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
+      // Check if this element or any parent has NoHideDescendants
+      bool isHidden =
+          props->importantForAccessibility == facebook::react::ImportantForAccessibility::NoHideDescendants ||
+          IsHiddenByParent(strongView);
+      pRetVal->boolVal = (!isHidden && props->accessible &&
+                          (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
           ? VARIANT_TRUE
           : VARIANT_FALSE;
       break;
     }
+
     case UIA_IsControlElementPropertyId: {
       pRetVal->vt = VT_BOOL;
-      pRetVal->boolVal =
-          (props->accessible && (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
+      // Check if this element or any parent has NoHideDescendants
+      bool isHidden =
+          props->importantForAccessibility == facebook::react::ImportantForAccessibility::NoHideDescendants ||
+          IsHiddenByParent(strongView);
+      pRetVal->boolVal = (!isHidden && props->accessible &&
+                          (props->accessibilityRole != "none" || props->role != facebook::react::Role::None))
           ? VARIANT_TRUE
           : VARIANT_FALSE;
       break;
     }
     case UIA_IsOffscreenPropertyId: {
       pRetVal->vt = VT_BOOL;
-      pRetVal->boolVal = (compositionView->getClipState() == ClipState::FullyClipped) ? VARIANT_TRUE : VARIANT_FALSE;
+
+      // Check if element is offscreen - consider modal content special case
+      bool isOffscreen = (compositionView->getClipState() == ClipState::FullyClipped);
+
+      // Modal content may appear clipped but is visible in its own window
+      if (isOffscreen) {
+        if (const auto hwnd = compositionView->GetHwndForParenting()) {
+          isOffscreen = !(IsWindowVisible(hwnd) && !IsIconic(hwnd));
+        }
+      }
+
+      pRetVal->boolVal = isOffscreen ? VARIANT_TRUE : VARIANT_FALSE;
       break;
     }
     case UIA_HelpTextPropertyId: {
@@ -588,6 +468,17 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
       pRetVal->bstrVal = SysAllocString(itemtype.c_str());
       break;
     }
+    case UIA_FullDescriptionPropertyId: {
+      pRetVal->vt = VT_BSTR;
+      auto desc = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityDescription.value_or(""));
+      pRetVal->bstrVal = SysAllocString(desc.c_str());
+      break;
+    }
+    case UIA_HeadingLevelPropertyId: {
+      pRetVal->vt = VT_I4;
+      pRetVal->lVal = GetHeadingLevel(props->accessibilityLevel, props->accessibilityRole, props->role);
+      break;
+    }
   }
   return hr;
 }
@@ -979,7 +870,9 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Expand() {
 
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
+
   DispatchAccessibilityAction(m_view, "expand");
+
   return S_OK;
 }
 
@@ -988,7 +881,9 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Collapse() {
 
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
+
   DispatchAccessibilityAction(m_view, "collapse");
+
   return S_OK;
 }