react-native-windows 0.74.21 → 0.74.22

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

@@ -296,7 +296,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"ScrollBarThumbFillDisabled", "ControlStrongFillColorDisabled"},
           {"ScrollBarTrackFill",
            "AcrylicInAppFillColorDefault"}, // TODO make AcrylicInAppFillColorDefault a real acrylic brush
-      };
+          {"ToolTipBackground", "SystemChromeMediumLowColor"},
+          {"ToolTipForeground", "SystemControlForegroundBaseHighColor"},
+          {"ToolTipBorderBrush", "SystemControlTransientBorderColor"}};
 
   static std::unordered_map<std::string, winrt::Windows::UI::Color, std::hash<std::string_view>, std::equal_to<>>
       s_lightColors = {
@@ -326,7 +328,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"ControlStrongFillColorDefault", {0x72, 0x00, 0x00, 0x00}},
           {"ControlStrongFillColorDisabled", {0x51, 0x00, 0x00, 0x00}},
           {"AcrylicInAppFillColorDefault", {0x9E, 0xFF, 0xFF, 0xFF}},
-      };
+          {"SystemChromeMediumLowColor", {0xFF, 0xF2, 0xF2, 0xF2}},
+          {"SystemControlForegroundBaseHighColor", {0xFF, 0x00, 0x00, 0x00}},
+          {"SystemControlTransientBorderColor", {0x24, 0x00, 0x00, 0x00}}};
 
   static std::unordered_map<std::string, winrt::Windows::UI::Color, std::hash<std::string_view>, std::equal_to<>>
       s_darkColors = {
@@ -356,7 +360,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"ControlStrongFillColorDefault", {0x8B, 0xFF, 0xFF, 0xFF}},
           {"ControlStrongFillColorDisabled", {0x3F, 0xFF, 0xFF, 0xFF}},
           {"AcrylicInAppFillColorDefault", {0x9E, 0x00, 0x00, 0x00}},
-      };
+          {"SystemChromeMediumLowColor", {0xFF, 0x2B, 0x2B, 0x2B}},
+          {"SystemControlForegroundBaseHighColor", {0xFF, 0xFF, 0xFF, 0xFF}},
+          {"SystemControlTransientBorderColor", {0x5C, 0x00, 0x00, 0x00}}};
 
   static std::unordered_map<
       std::string,
@@ -391,7 +397,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"SubtleFillColorSecondary", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
           {"ControlStrongFillColorDefault", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
           {"ControlStrongFillColorDisabled", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
-      };
+          {"SystemChromeMediumLowColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
+          {"SystemControlForegroundBaseHighColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}},
+          {"SystemControlTransientBorderColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}}};
 
   auto alias = s_xamlAliasedColors.find(platformColor);
   if (alias != s_xamlAliasedColors.end()) {

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

@@ -0,0 +1,338 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "TooltipService.h"
+
+#include <CompositionSwitcher.Experimental.interop.h>
+#include <Fabric/Composition/CompositionViewComponentView.h>
+#include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+#include "TextDrawing.h"
+#include "dwmapi.h"
+
+namespace winrt::Microsoft::ReactNative {
+
+constexpr PCWSTR c_tooltipWindowClassName = L"RN_TOOLTIP";
+constexpr auto TooltipDataProperty = L"TooltipData";
+constexpr float tooltipFontSize = 12;
+constexpr float tooltipMaxHeight = 1000;
+constexpr float tooltipMaxWidth = 320;
+constexpr float tooltipHorizontalPadding = 8;
+constexpr float tooltipTopPadding = 5;
+constexpr float tooltipBottomPadding = 7;
+constexpr float toolTipBorderThickness = 1;
+constexpr int toolTipPlacementMargin = 12;
+constexpr int toolTipAnimationTimeMs = 200;
+constexpr int toolTipTimeToShowMs = 1000;
+
+struct TooltipData {
+  TooltipData(const winrt::Microsoft::ReactNative::ComponentView &view) : view(view) {}
+
+  static TooltipData *GetFromWindow(HWND hwnd) {
+    auto data = reinterpret_cast<TooltipData *>(GetProp(hwnd, TooltipDataProperty));
+    return data;
+  }
+
+  int width;
+  int height;
+  ::Microsoft::ReactNative::ReactTaggedView view;
+  winrt::com_ptr<::IDWriteTextLayout> textLayout;
+  facebook::react::AttributedStringBox attributedString;
+  winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext compositionContext;
+};
+
+facebook::react::AttributedStringBox CreateTooltipAttributedString(const std::string &tooltip) noexcept {
+  auto attributedString = facebook::react::AttributedString{};
+  auto fragment = facebook::react::AttributedString::Fragment{};
+  fragment.string = tooltip;
+  fragment.textAttributes.fontSize = tooltipFontSize;
+  attributedString.appendFragment(fragment);
+  return facebook::react::AttributedStringBox{attributedString};
+}
+
+LRESULT CALLBACK TooltipWndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) noexcept {
+  switch (message) {
+    case WM_DESTROY: {
+      delete TooltipData::GetFromWindow(hwnd);
+      SetProp(hwnd, TooltipDataProperty, 0);
+      return 0;
+    }
+    case WM_PRINTCLIENT:
+    case WM_PAINT: {
+      HDC hdc;
+      PAINTSTRUCT ps;
+
+      if (message != WM_PRINTCLIENT)
+        hdc = BeginPaint(hwnd, &ps);
+      else
+        hdc = (HDC)wparam;
+      auto data = TooltipData::GetFromWindow(hwnd);
+
+      if (auto view = data->view.view()) {
+        auto scaleFactor = view.LayoutMetrics().PointScaleFactor;
+
+        auto ccInterop = data->compositionContext
+                             .as<::Microsoft::ReactNative::Composition::Experimental::ICompositionContextInterop>();
+        winrt::com_ptr<ID2D1Factory1> factory;
+        ccInterop->D2DFactory(factory.put());
+
+        winrt::com_ptr<ID2D1DCRenderTarget> renderTarget;
+
+        D2D1_RENDER_TARGET_PROPERTIES props = D2D1::RenderTargetProperties(
+            D2D1_RENDER_TARGET_TYPE_DEFAULT,
+            D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE),
+            0,
+            0,
+            D2D1_RENDER_TARGET_USAGE_NONE,
+            D2D1_FEATURE_LEVEL_DEFAULT);
+        winrt::check_hresult(factory->CreateDCRenderTarget(&props, renderTarget.put()));
+        RECT rc;
+        GetClientRect(hwnd, &rc);
+        winrt::check_hresult(renderTarget->BindDC(hdc, &rc));
+        auto theme = view.as<winrt::Microsoft::ReactNative::Composition::ComponentView>().Theme();
+        auto selfTheme = winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::Theme>(theme);
+
+        renderTarget->BeginDraw();
+        renderTarget->Clear(selfTheme->D2DPlatformColor("ToolTipBackground"));
+
+        auto textAttributes = facebook::react::TextAttributes{};
+        facebook::react::Color fgColor;
+        fgColor.m_platformColor.push_back("ToolTipForeground");
+        textAttributes.foregroundColor = fgColor;
+
+        winrt::Microsoft::ReactNative::Composition::RenderText(
+            *renderTarget,
+            *data->textLayout,
+            data->attributedString.getValue(),
+            textAttributes,
+            {std::round(tooltipHorizontalPadding * scaleFactor), std::round(tooltipTopPadding * scaleFactor)},
+            scaleFactor,
+            *selfTheme);
+
+        auto hr = renderTarget->EndDraw();
+      }
+
+      if (message != WM_PRINTCLIENT)
+        EndPaint(hwnd, &ps);
+      return 0;
+    }
+    case WM_NCCREATE: {
+      auto cs = reinterpret_cast<CREATESTRUCT *>(lparam);
+      auto data = static_cast<TooltipData *>(cs->lpCreateParams);
+      WINRT_ASSERT(data);
+      SetProp(hwnd, TooltipDataProperty, reinterpret_cast<HANDLE>(data));
+      break;
+    }
+  }
+
+  return DefWindowProc(hwnd, message, wparam, lparam);
+}
+
+void RegisterTooltipWndClass() noexcept {
+  static bool registered = false;
+  if (registered) {
+    return;
+  }
+
+  HINSTANCE hInstance =
+      GetModuleHandle(NULL); // returns a handle to the file used to create the calling process (.exe file)
+
+  WNDCLASSEX wcex = {}; // contains window class information
+  wcex.cbSize = sizeof(wcex); // size of windows class (bytes)
+  wcex.style = CS_HREDRAW | CS_VREDRAW; // class style (redraw window on size adjustment)
+  wcex.lpfnWndProc = &TooltipWndProc; // pointer to windows procedure
+  wcex.cbClsExtra = DLGWINDOWEXTRA; // extra bytes to allocate
+  wcex.cbWndExtra = sizeof(TooltipData *); // extra bytes to allocate
+  wcex.hInstance = hInstance;
+  wcex.hCursor = LoadCursor(nullptr, IDC_ARROW); // handle to class cursor
+  wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); // background color
+  wcex.lpszClassName = c_tooltipWindowClassName; // specify resource name
+  ATOM classId = RegisterClassEx(&wcex); // register new windows class
+  WINRT_VERIFY(classId); // 0 = fail
+  winrt::check_win32(!classId);
+
+  registered = true;
+}
+
+TooltipTracker::TooltipTracker(
+    const winrt::Microsoft::ReactNative::ComponentView &view,
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+    TooltipService *outer)
+    : m_view(view), m_properties(properties), m_outer(outer) {
+  view.PointerEntered({this, &TooltipTracker::OnPointerEntered});
+  view.PointerExited({this, &TooltipTracker::OnPointerExited});
+  view.PointerMoved({this, &TooltipTracker::OnPointerMoved});
+  view.Unmounted({this, &TooltipTracker::OnUnmounted});
+}
+
+TooltipTracker::~TooltipTracker() {
+  DestroyTimer();
+  DestroyTooltip();
+}
+
+facebook::react::Tag TooltipTracker::Tag() const noexcept {
+  return m_view.Tag();
+}
+
+void TooltipTracker::OnPointerEntered(
+    const winrt::Windows::Foundation::IInspectable &sender,
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
+  if (args.Pointer().PointerDeviceType() !=
+          winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse &&
+      args.Pointer().PointerDeviceType() != winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Pen)
+    return;
+
+  auto pp = args.GetCurrentPoint(-1);
+  m_pos = pp.Position();
+
+  m_timer = winrt::Microsoft::ReactNative::Timer::Create(m_properties.Handle());
+  m_timer.Interval(std::chrono::milliseconds(toolTipTimeToShowMs));
+  m_timer.Tick({this, &TooltipTracker::OnTick});
+  m_timer.Start();
+}
+
+void TooltipTracker::OnPointerMoved(
+    const winrt::Windows::Foundation::IInspectable &sender,
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
+  if (args.Pointer().PointerDeviceType() !=
+          winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse &&
+      args.Pointer().PointerDeviceType() != winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Pen)
+    return;
+
+  auto pp = args.GetCurrentPoint(-1);
+  m_pos = pp.Position();
+}
+
+void TooltipTracker::OnTick(
+    const winrt::Windows::Foundation::IInspectable &,
+    const winrt::Windows::Foundation::IInspectable &) noexcept {
+  ShowTooltip(m_view.view());
+}
+
+void TooltipTracker::OnPointerExited(
+    const winrt::Windows::Foundation::IInspectable &sender,
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
+  if (args.Pointer().PointerDeviceType() !=
+          winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse &&
+      args.Pointer().PointerDeviceType() != winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Pen)
+    return;
+  DestroyTimer();
+  DestroyTooltip();
+}
+
+void TooltipTracker::OnUnmounted(
+    const winrt::Windows::Foundation::IInspectable &,
+    const winrt::Microsoft::ReactNative::ComponentView &) noexcept {
+  DestroyTimer();
+  DestroyTooltip();
+}
+
+void TooltipTracker::ShowTooltip(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+  auto viewCompView = view.as<winrt::Microsoft::ReactNative::Composition::ViewComponentView>();
+
+  auto selfView =
+      winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::ViewComponentView>(viewCompView);
+  auto parentHwnd = selfView->GetHwndForParenting();
+  DestroyTimer();
+
+  if (!m_hwndTip) {
+    auto tooltipData = std::make_unique<TooltipData>(view);
+    tooltipData->attributedString = CreateTooltipAttributedString(*selfView->viewProps()->tooltip);
+
+    tooltipData->compositionContext = selfView->CompositionContext();
+    tooltipData->view = view;
+
+    auto scaleFactor = view.LayoutMetrics().PointScaleFactor;
+    facebook::react::LayoutConstraints layoutConstraints;
+    layoutConstraints.layoutDirection = facebook::react::LayoutDirection::Undefined;
+    layoutConstraints.maximumSize.height = tooltipMaxHeight * scaleFactor;
+    layoutConstraints.maximumSize.width = tooltipMaxWidth * scaleFactor;
+    layoutConstraints.minimumSize.height = 0;
+    layoutConstraints.minimumSize.width = 0;
+
+    facebook::react::TextLayoutManager::GetTextLayout(
+        tooltipData->attributedString, {} /*paragraphAttributes*/, layoutConstraints, tooltipData->textLayout);
+
+    DWRITE_TEXT_METRICS tm;
+    winrt::check_hresult(tooltipData->textLayout->GetMetrics(&tm));
+
+    tooltipData->width =
+        static_cast<int>(tm.width + ((tooltipHorizontalPadding + tooltipHorizontalPadding) * scaleFactor));
+    tooltipData->height = static_cast<int>(tm.height + ((tooltipTopPadding + tooltipBottomPadding) * scaleFactor));
+
+    POINT pt = {static_cast<LONG>(m_pos.X), static_cast<LONG>(m_pos.Y)};
+    ClientToScreen(parentHwnd, &pt);
+
+    RegisterTooltipWndClass();
+    HINSTANCE hInstance = GetModuleHandle(NULL);
+    m_hwndTip = CreateWindow(
+        c_tooltipWindowClassName,
+        L"Tooltip",
+        WS_POPUP,
+        pt.x - tooltipData->width / 2,
+        static_cast<int>(pt.y - tooltipData->height - (toolTipPlacementMargin * scaleFactor)),
+        tooltipData->width,
+        tooltipData->height,
+        parentHwnd,
+        NULL,
+        hInstance,
+        tooltipData.get());
+
+    DWM_WINDOW_CORNER_PREFERENCE preference = DWMWCP_ROUNDSMALL;
+    UINT borderThickness = 0;
+    DwmSetWindowAttribute(m_hwndTip, DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(preference));
+
+    tooltipData.release();
+    AnimateWindow(m_hwndTip, toolTipAnimationTimeMs, AW_BLEND);
+  }
+}
+
+void TooltipTracker::DestroyTooltip() noexcept {
+  if (m_hwndTip) {
+    AnimateWindow(m_hwndTip, toolTipAnimationTimeMs, AW_BLEND | AW_HIDE);
+    DestroyWindow(m_hwndTip);
+    m_hwndTip = nullptr;
+  }
+}
+
+void TooltipTracker::DestroyTimer() noexcept {
+  if (m_timer) {
+    m_timer.Stop();
+    m_timer = nullptr;
+  }
+}
+
+TooltipService::TooltipService(const winrt::Microsoft::ReactNative::ReactPropertyBag &properties)
+    : m_properties(properties) {}
+
+void TooltipService::StartTracking(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+  m_trackers.push_back(std::make_shared<TooltipTracker>(view, m_properties, this));
+}
+
+void TooltipService::StopTracking(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+  for (auto it = m_trackers.begin(); it != m_trackers.end();) {
+    if ((*it)->Tag() == view.Tag())
+      it = m_trackers.erase(it);
+    else
+      ++it;
+  }
+}
+
+static const ReactPropertyId<winrt::Microsoft::ReactNative::ReactNonAbiValue<std::shared_ptr<TooltipService>>>
+    &TooltipServicePropertyId() noexcept {
+  static const ReactPropertyId<winrt::Microsoft::ReactNative::ReactNonAbiValue<std::shared_ptr<TooltipService>>> prop{
+      L"ReactNative", L"TooltipService"};
+  return prop;
+}
+
+std::shared_ptr<TooltipService> TooltipService::GetCurrent(
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties) noexcept {
+  return *properties.GetOrCreate(TooltipServicePropertyId(), [properties]() -> std::shared_ptr<TooltipService> {
+    return std::make_shared<TooltipService>(properties);
+  });
+}
+
+} // namespace winrt::Microsoft::ReactNative

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

@@ -0,0 +1,66 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Fabric/ReactTaggedView.h>
+#include <winrt/Microsoft.ReactNative.h>
+
+namespace winrt::Microsoft::ReactNative {
+
+struct TooltipService;
+
+struct TooltipTracker {
+  TooltipTracker(
+      const winrt::Microsoft::ReactNative::ComponentView &view,
+      const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+      TooltipService *outer);
+  ~TooltipTracker();
+
+  void OnPointerEntered(
+      const winrt::Windows::Foundation::IInspectable &sender,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnPointerMoved(
+      const winrt::Windows::Foundation::IInspectable &sender,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnPointerExited(
+      const winrt::Windows::Foundation::IInspectable &sender,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnTick(
+      const winrt::Windows::Foundation::IInspectable &,
+      const winrt::Windows::Foundation::IInspectable &) noexcept;
+  void OnUnmounted(
+      const winrt::Windows::Foundation::IInspectable &,
+      const winrt::Microsoft::ReactNative::ComponentView &) noexcept;
+
+  facebook::react::Tag Tag() const noexcept;
+
+ private:
+  void ShowTooltip(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept;
+  void DestroyTimer() noexcept;
+  void DestroyTooltip() noexcept;
+
+  TooltipService *m_outer;
+  winrt::Windows::Foundation::Point m_pos;
+  ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::Microsoft::ReactNative::ITimer m_timer;
+  HWND m_hwndTip{nullptr};
+  winrt::Microsoft::ReactNative::ReactPropertyBag m_properties;
+};
+
+struct TooltipService {
+  TooltipService(const winrt::Microsoft::ReactNative::ReactPropertyBag &properties);
+  void StartTracking(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept;
+  void StopTracking(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept;
+
+  static std::shared_ptr<TooltipService> GetCurrent(
+      const winrt::Microsoft::ReactNative::ReactPropertyBag &properties) noexcept;
+
+ private:
+  std::vector<std::shared_ptr<TooltipTracker>> m_enteredTrackers;
+  std::vector<std::shared_ptr<TooltipTracker>> m_trackers;
+  winrt::Microsoft::ReactNative::ReactPropertyBag m_properties;
+};
+
+} // namespace winrt::Microsoft::ReactNative

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

@@ -72,9 +72,10 @@ HRESULT UiaNavigateHelper(
       auto parentCV = view.Parent().as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
       if (parentCV != nullptr) {
         auto children = parentCV->Children();
-        for (auto it = children.end(); it != children.begin(); --it) {
-          if (*it == view) {
-            uiaProvider = (*it)
+        for (auto i = children.Size() - 1; i > 0; i--) {
+          auto child = children.GetAt(i);
+          if (child == view) {
+            uiaProvider = children.GetAt(i - 1)
                               .as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>()
                               ->EnsureUiaProvider();
             break;
@@ -121,7 +122,9 @@ HRESULT UiaSetFocusHelper(::Microsoft::ReactNative::ReactTaggedView &view) noexc
   if (rootCV == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  return rootCV->TrySetFocusedComponent(strongView) ? S_OK : E_FAIL;
+  return rootCV->TrySetFocusedComponent(strongView, winrt::Microsoft::ReactNative::FocusNavigationDirection::None)
+      ? S_OK
+      : E_FAIL;
 }
 
 bool WasUiaPropertyAdvised(winrt::com_ptr<IRawElementProviderSimple> &providerSimple, PROPERTYID propId) noexcept {
@@ -181,4 +184,34 @@ std::string extractAccessibilityValue(const facebook::react::AccessibilityValue
   }
 }
 
+void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept {
+  auto strongView = view.view();
+
+  if (!strongView)
+    return;
+
+  auto baseView = strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
+  if (baseView == nullptr)
+    return;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(baseView->props());
+  if (props == nullptr)
+    return;
+
+  auto accessibilityActions = props->accessibilityActions;
+  for (size_t i = 0; i < accessibilityActions.size(); i++) {
+    if (accessibilityActions[i].name == action) {
+      baseView->GetEventEmitter()->onAccessibilityAction(action);
+    }
+  }
+}
+
+ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept {
+  if (expanded) {
+    return ExpandCollapseState_Expanded;
+  } else {
+    return ExpandCollapseState_Collapsed;
+  }
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -33,4 +33,7 @@ long GetLiveSetting(const std::string &liveRegion) noexcept;
 
 std::string extractAccessibilityValue(const facebook::react::AccessibilityValue &value) noexcept;
 
+void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept;
+
+ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept;
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -37,8 +37,7 @@ winrt::Microsoft::ReactNative::ComponentView UnimplementedNativeViewComponentVie
 }
 
 void UnimplementedNativeViewComponentView::HandleCommand(
-    winrt::hstring commandName,
-    const winrt::Microsoft::ReactNative::IJSValueReader &args) noexcept {
+    const winrt::Microsoft::ReactNative::HandleCommandArgs &args) noexcept {
   // Do not call base to avoid unknown command asserts
 }
 

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

@@ -25,8 +25,7 @@ struct UnimplementedNativeViewComponentView
       facebook::react::LayoutMetrics const &layoutMetrics,
       facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept override;
 
-  void HandleCommand(winrt::hstring commandName, const winrt::Microsoft::ReactNative::IJSValueReader &args) noexcept
-      override;
+  void HandleCommand(const winrt::Microsoft::ReactNative::HandleCommandArgs &args) noexcept override;
 
   UnimplementedNativeViewComponentView(
       const winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compContext,

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -2,12 +2,15 @@
 // Licensed under the MIT License.
 
 #include "pch.h"
+#include "HandleCommandArgs.g.cpp"
+#include "HandleCommandArgs.g.h"
 #include <AsynchronousEventBeat.h>
 #include <DynamicReader.h>
 #include <DynamicWriter.h>
 #include <Fabric/ComponentView.h>
 #include <Fabric/Composition/CompositionUIService.h>
 #include <Fabric/Composition/CompositionViewComponentView.h>
+#include <Fabric/Composition/ReactNativeIsland.h>
 #include <Fabric/Composition/RootComponentView.h>
 #include <Fabric/FabricUIManagerModule.h>
 #include <Fabric/ReactNativeConfigProperties.h>
@@ -160,7 +163,7 @@ void FabricUIManager::startSurface(
 
   facebook::react::LayoutContext layoutContext;
   layoutContext.pointScaleFactor = rootView.ScaleFactor();
-  layoutContext.fontSizeMultiplier = rootView.ScaleFactor();
+  layoutContext.fontSizeMultiplier = rootView.FontSizeMultiplier();
 
   m_surfaceManager->startSurface(
       surfaceId,
@@ -173,6 +176,9 @@ void FabricUIManager::startSurface(
 
 void FabricUIManager::stopSurface(facebook::react::SurfaceId surfaceId) noexcept {
   m_surfaceManager->stopSurface(surfaceId);
+  auto &rootDescriptor = m_registry.componentViewDescriptorWithTag(surfaceId);
+  m_registry.enqueueComponentViewWithComponentHandle(
+      facebook::react::RootShadowNode::Handle(), surfaceId, rootDescriptor);
 }
 
 winrt::Microsoft::ReactNative::ReactNativeIsland FabricUIManager::GetReactNativeIsland(
@@ -384,6 +390,28 @@ void FabricUIManager::schedulerDidRequestPreliminaryViewAllocation(
   */
 }
 
+struct HandleCommandArgs : public winrt::Microsoft::ReactNative::implementation::HandleCommandArgsT<HandleCommandArgs> {
+  HandleCommandArgs(winrt::hstring commandName, folly::dynamic const &arg) : m_commandName(commandName), m_args(arg) {}
+
+  winrt::hstring CommandName() const noexcept {
+    return m_commandName;
+  }
+  winrt::Microsoft::ReactNative::IJSValueReader CommandArgs() const noexcept {
+    return winrt::make<winrt::Microsoft::ReactNative::DynamicReader>(m_args);
+  }
+  bool Handled() const noexcept {
+    return m_handled;
+  }
+  void Handled(bool value) noexcept {
+    m_handled = value;
+  }
+
+ private:
+  folly::dynamic const &m_args;
+  const winrt::hstring m_commandName;
+  bool m_handled{false};
+};
+
 void FabricUIManager::schedulerDidDispatchCommand(
     facebook::react::ShadowView const &shadowView,
     std::string const &commandName,
@@ -391,7 +419,7 @@ void FabricUIManager::schedulerDidDispatchCommand(
   if (m_context.UIDispatcher().HasThreadAccess()) {
     auto descriptor = m_registry.componentViewDescriptorWithTag(shadowView.tag);
     winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(descriptor.view)
-        ->HandleCommand(winrt::to_hstring(commandName), winrt::make<winrt::Microsoft::ReactNative::DynamicReader>(arg));
+        ->HandleCommand(winrt::make<HandleCommandArgs>(winrt::to_hstring(commandName), arg));
   } else {
     m_context.UIDispatcher().Post(
         [wkThis = weak_from_this(), commandName, tag = shadowView.tag, args = folly::dynamic(arg)]() {
@@ -399,7 +427,7 @@ void FabricUIManager::schedulerDidDispatchCommand(
             auto view = pThis->m_registry.findComponentViewWithTag(tag);
             if (view) {
               winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(view)->HandleCommand(
-                  winrt::to_hstring(commandName), winrt::make<winrt::Microsoft::ReactNative::DynamicReader>(args));
+                  winrt::make<HandleCommandArgs>(winrt::to_hstring(commandName), args));
             }
           }
         });

package/Microsoft.ReactNative/Fabric/ReactTaggedView.h

@@ -31,6 +31,10 @@ struct ReactTaggedView {
     return strongView;
   }
 
+  facebook::react::Tag Tag() const noexcept {
+    return m_tag;
+  }
+
  private:
   facebook::react::Tag m_tag;
   winrt::weak_ref<winrt::Microsoft::ReactNative::ComponentView> m_view;

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -27,6 +27,10 @@ HostPlatformViewProps::HostPlatformViewProps(
           CoreFeatures::enablePropIteratorSetter
               ? sourceProps.focusable
               : convertRawProp(context, rawProps, "focusable", sourceProps.focusable, {})),
+      tooltip(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.tooltip
+              : convertRawProp(context, rawProps, "tooltip", sourceProps.tooltip, {})),
       accessibilityPosInSet(
           CoreFeatures::enablePropIteratorSetter
               ? sourceProps.accessibilityPosInSet
@@ -82,6 +86,7 @@ void HostPlatformViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLiveRegion);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyDownEvents);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyUpEvents);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(tooltip);
   }
 }
 

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.h

@@ -29,7 +29,7 @@ class HostPlatformViewProps : public BaseViewProps {
   std::string accessibilityLiveRegion{"none"};
 
   // std::optional<std::string> overflowAnchor{};
-  // std::optional<std::string> tooltip{};
+  std::optional<std::string> tooltip{};
   std::vector<HandledKeyEvent> keyDownEvents{};
   std::vector<HandledKeyEvent> keyUpEvents{};
 };

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -13,7 +13,7 @@ inline bool formsStackingContext(ViewProps const &viewProps) {
   // Only Views which are marked as focusable can actually trigger the events, which will already avoid being collapsed.
   constexpr decltype(WindowsViewEvents::bits) focusEventsMask = {
       (1 << (int)WindowsViewEvents::Offset::Focus) & (1 << (int)WindowsViewEvents::Offset::Blur)};
-  return (viewProps.windowsEvents.bits & focusEventsMask).any();
+  return (viewProps.windowsEvents.bits & focusEventsMask).any() || viewProps.tooltip;
 }
 
 inline bool formsView(ViewProps const &viewProps) {