react-native-windows 0.81.3 → 0.81.5

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

@@ -0,0 +1,245 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "pch.h"
+#include "ReactNativeWindow.h"
+#include "ReactNativeWindow.g.cpp"
+
+#include <Fabric/Composition/CompositionUIService.h>
+#include <winrt/Microsoft.UI.Content.h>
+#include <winrt/Microsoft.UI.Input.h>
+#include <winrt/Microsoft.UI.interop.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+void ReactNativeWindow::UpdateRootViewSizeToAppWindow(
+    winrt::Microsoft::ReactNative::ReactNativeIsland const &rootView,
+    winrt::Microsoft::UI::Windowing::AppWindow const &window) noexcept {
+  if (!rootView) {
+    return;
+  }
+
+  if (m_resizePolicy != winrt::Microsoft::ReactNative::ContentSizePolicy::ResizeContentToParentWindow) {
+    return;
+  }
+
+  auto scaleFactor = GetDpiForWindow(winrt::Microsoft::UI::GetWindowFromWindowId(window.Id())) /
+      static_cast<float>(USER_DEFAULT_SCREEN_DPI);
+  winrt::Windows::Foundation::Size size{
+      window.ClientSize().Width / scaleFactor, window.ClientSize().Height / scaleFactor};
+  // Do not relayout when minimized
+  auto presenter = window.Presenter().try_as<winrt::Microsoft::UI::Windowing::OverlappedPresenter>();
+  if (!presenter || presenter.State() != winrt::Microsoft::UI::Windowing::OverlappedPresenterState::Minimized) {
+    winrt::Microsoft::ReactNative::LayoutConstraints constraints;
+    constraints.LayoutDirection = winrt::Microsoft::ReactNative::LayoutDirection::Undefined;
+    constraints.MaximumSize = constraints.MinimumSize = size;
+    rootView.Arrange(constraints, {0, 0});
+  }
+}
+
+ReactNativeWindow::ReactNativeWindow() noexcept {}
+
+winrt::Microsoft::ReactNative::ReactNativeWindow ReactNativeWindow::CreateFromCompositor(
+    const winrt::Microsoft::UI::Composition::Compositor &compositor) noexcept {
+  auto reactNativeWindow = make_self<ReactNativeWindow>();
+  reactNativeWindow->m_compositor = compositor;
+  reactNativeWindow->AppWindow(winrt::Microsoft::UI::Windowing::AppWindow::Create());
+  return *reactNativeWindow;
+}
+
+winrt::Microsoft::ReactNative::ReactNativeWindow ReactNativeWindow::CreateFromWindow(
+    const winrt::Microsoft::UI::Windowing::AppWindow &appWindow,
+    const winrt::Microsoft::UI::Composition::Compositor &compositor) noexcept {
+  auto reactNativeWindow = make_self<ReactNativeWindow>();
+  reactNativeWindow->m_compositor = compositor;
+  reactNativeWindow->AppWindow(appWindow);
+  return *reactNativeWindow;
+}
+
+winrt::Microsoft::ReactNative::ReactNativeWindow ReactNativeWindow::CreateFromWindowAndIsland(
+    const winrt::Microsoft::UI::Windowing::AppWindow &appWindow,
+    const winrt::Microsoft::ReactNative::ReactNativeIsland &island) noexcept {
+  auto reactNativeWindow = make_self<ReactNativeWindow>();
+  reactNativeWindow->AppWindow(appWindow);
+  reactNativeWindow->ReactNativeIsland(island);
+  return *reactNativeWindow;
+}
+
+winrt::Microsoft::ReactNative::ReactNativeWindow ReactNativeWindow::CreateFromContentSiteBridgeAndIsland(
+    const winrt::Microsoft::UI::Content::IContentSiteBridge &bridge,
+    const winrt::Microsoft::ReactNative::ReactNativeIsland &island) {
+  auto reactNativeWindow = make_self<ReactNativeWindow>();
+  reactNativeWindow->m_bridge = bridge;
+
+  if (auto desktopSiteBridge = bridge.try_as<winrt::Microsoft::UI::Content::DesktopSiteBridge>()) {
+    reactNativeWindow->AppWindow(
+        winrt::Microsoft::UI::Windowing::AppWindow::GetFromWindowId(desktopSiteBridge.WindowId()));
+  } else if (auto desktopPopupSiteBridge = bridge.as<winrt::Microsoft::UI::Content::DesktopPopupSiteBridge>()) {
+    reactNativeWindow->AppWindow(
+        winrt::Microsoft::UI::Windowing::AppWindow::GetFromWindowId(desktopPopupSiteBridge.WindowId()));
+  } else {
+    throw winrt::hresult_not_implemented(L"Unsupported ContentSiteBridge type");
+  }
+
+  reactNativeWindow->ReactNativeIsland(island);
+  return *reactNativeWindow;
+}
+
+ReactNativeWindow::~ReactNativeWindow() noexcept {
+  Close();
+}
+
+winrt::Microsoft::UI::Windowing::AppWindow ReactNativeWindow::AppWindow() noexcept {
+  if (!m_appWindow) {
+    AppWindow(winrt::Microsoft::UI::Windowing::AppWindow::Create());
+  }
+
+  return m_appWindow;
+}
+
+void ReactNativeWindow::AppWindow(const winrt::Microsoft::UI::Windowing::AppWindow &appWindow) noexcept {
+  assert(!m_appWindow);
+
+  m_appWindow = appWindow;
+
+  if (!m_appWindow)
+    return;
+
+  // Update the size of the RootView when the AppWindow changes size
+  m_appWindowChangedToken = m_appWindow.Changed(
+      [this](
+          winrt::Microsoft::UI::Windowing::AppWindow const &window,
+          winrt::Microsoft::UI::Windowing::AppWindowChangedEventArgs const &args) { AppWindow_Changed(window, args); });
+
+  UpdateRootViewSizeToAppWindow(m_island, m_appWindow);
+}
+
+void ReactNativeWindow::AppWindow_Changed(
+    winrt::Microsoft::UI::Windowing::AppWindow const &window,
+    winrt::Microsoft::UI::Windowing::AppWindowChangedEventArgs const &args) noexcept {
+  if (args.DidSizeChange() || args.DidVisibilityChange()) {
+    UpdateRootViewSizeToAppWindow(m_island, m_appWindow);
+  }
+}
+
+winrt::Microsoft::ReactNative::ReactNativeIsland ReactNativeWindow::ReactNativeIsland() noexcept {
+  if (!m_island) {
+    ReactNativeIsland(winrt::Microsoft::ReactNative::ReactNativeIsland(Compositor()));
+  }
+
+  return m_island;
+}
+
+void ReactNativeWindow::Connect(winrt::Microsoft::UI::Content::ContentIsland contentIsland) noexcept {
+  if (auto desktopSiteBridge = ContentSiteBridge().try_as<winrt::Microsoft::UI::Content::DesktopChildSiteBridge>())
+    desktopSiteBridge.Connect(contentIsland);
+  else {
+    // Only support DesktopChildSiteBridge and DesktopPopupSiteBridge currently
+    auto popupSiteBridge = m_bridge.as<winrt::Microsoft::UI::Content::DesktopPopupSiteBridge>();
+    popupSiteBridge.Connect(contentIsland);
+  }
+}
+
+void ReactNativeWindow::ReactNativeIsland(const winrt::Microsoft::ReactNative::ReactNativeIsland &value) noexcept {
+  if (m_island && m_bridge) {
+    Connect(nullptr);
+  }
+
+  m_island = value;
+
+  if (m_island) {
+    m_island.as<winrt::Microsoft::ReactNative::Composition::Experimental::IInternalCompositionRootView>().SetWindow(
+        reinterpret_cast<uint64_t>(winrt::Microsoft::UI::GetWindowFromWindowId(m_appWindow.Id())));
+    Connect(m_island.Island());
+    UpdateIslandScaleFactor();
+    EnsureResizePolicyState();
+  }
+}
+
+winrt::Microsoft::UI::Composition::Compositor ReactNativeWindow::Compositor() noexcept {
+  if (!m_compositor)
+    m_compositor = ReactNativeIsland().Compositor();
+
+  return m_compositor;
+}
+
+winrt::Microsoft::UI::Content::IContentSiteBridge ReactNativeWindow::ContentSiteBridge() noexcept {
+  if (!m_bridge) {
+    auto desktopChildSiteBridge =
+        winrt::Microsoft::UI::Content::DesktopChildSiteBridge::Create(Compositor(), m_appWindow.Id());
+    desktopChildSiteBridge.ResizePolicy(winrt::Microsoft::UI::Content::ContentSizePolicy::ResizeContentToParentWindow);
+    m_bridge = desktopChildSiteBridge;
+
+    UpdateIslandScaleFactor();
+
+    desktopChildSiteBridge.Show();
+  }
+
+  return m_bridge;
+}
+
+void ReactNativeWindow::UpdateIslandScaleFactor() noexcept {
+  if (m_island) {
+    auto scaleFactor = GetDpiForWindow(winrt::Microsoft::UI::GetWindowFromWindowId(m_appWindow.Id())) /
+        static_cast<float>(USER_DEFAULT_SCREEN_DPI);
+    m_island.ScaleFactor(scaleFactor);
+  }
+}
+
+void ReactNativeWindow::ResizePolicy(winrt::Microsoft::ReactNative::ContentSizePolicy value) noexcept {
+  if (m_resizePolicy == value) {
+    return;
+  }
+
+  m_sizeChangedRevoker.revoke();
+
+  m_resizePolicy = value;
+
+  EnsureResizePolicyState();
+}
+
+void ReactNativeWindow::EnsureResizePolicyState() noexcept {
+  if (!m_island)
+    return;
+
+  if (m_resizePolicy == winrt::Microsoft::ReactNative::ContentSizePolicy::ResizeParentWindowToContent) {
+    m_sizeChangedRevoker = ReactNativeIsland().SizeChanged(
+        winrt::auto_revoke,
+        [compositor = Compositor(), appWindow = m_appWindow](
+            auto /*sender*/, const winrt::Microsoft::ReactNative::RootViewSizeChangedEventArgs &args) {
+          auto async = compositor.RequestCommitAsync();
+          async.Completed([appWindow, size = args.Size()](
+                              auto /*asyncInfo*/, winrt::Windows::Foundation::AsyncStatus /*asyncStatus*/) {
+            appWindow.ResizeClient({static_cast<int>(size.Width), static_cast<int>(size.Height)});
+          });
+        });
+    ReactNativeIsland().Arrange(m_layoutConstraints, {0, 0});
+  }
+
+  if (m_island && m_resizePolicy == winrt::Microsoft::ReactNative::ContentSizePolicy::ResizeContentToParentWindow)
+    UpdateRootViewSizeToAppWindow(m_island, m_appWindow);
+}
+
+winrt::Microsoft::ReactNative::ContentSizePolicy ReactNativeWindow::ResizePolicy() const noexcept {
+  return m_resizePolicy;
+}
+
+winrt::Microsoft::ReactNative::LayoutConstraints ReactNativeWindow::LayoutConstraints() const noexcept {
+  return m_layoutConstraints;
+}
+
+void ReactNativeWindow::LayoutConstraints(winrt::Microsoft::ReactNative::LayoutConstraints const &value) noexcept {
+  m_layoutConstraints = value;
+  ReactNativeIsland().Arrange(m_layoutConstraints, {0, 0});
+}
+
+void ReactNativeWindow::Close() noexcept {
+  if (m_bridge)
+    m_bridge.Close();
+
+  if (m_appWindow) {
+    m_appWindow.Changed(m_appWindowChangedToken);
+    m_appWindow.Destroy();
+  }
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+#include "ReactNativeWindow.g.h"
+
+#include <ReactContext.h>
+#include <winrt/Microsoft.ReactNative.Composition.Experimental.h>
+#include <winrt/Microsoft.ReactNative.h>
+#include <winrt/Microsoft.UI.Content.h>
+#include <winrt/Microsoft.UI.Windowing.h>
+#include <winrt/Windows.UI.ViewManagement.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+struct ReactNativeWindow : ReactNativeWindowT<ReactNativeWindow> {
+  ~ReactNativeWindow() noexcept;
+  ReactNativeWindow() noexcept;
+
+  static winrt::Microsoft::ReactNative::ReactNativeWindow CreateFromCompositor(
+      const winrt::Microsoft::UI::Composition::Compositor &compositor) noexcept;
+  static winrt::Microsoft::ReactNative::ReactNativeWindow CreateFromWindow(
+      const winrt::Microsoft::UI::Windowing::AppWindow &appWindow,
+      const winrt::Microsoft::UI::Composition::Compositor &compositor) noexcept;
+  static winrt::Microsoft::ReactNative::ReactNativeWindow CreateFromWindowAndIsland(
+      const winrt::Microsoft::UI::Windowing::AppWindow &appWindow,
+      const winrt::Microsoft::ReactNative::ReactNativeIsland &island) noexcept;
+  static winrt::Microsoft::ReactNative::ReactNativeWindow CreateFromContentSiteBridgeAndIsland(
+      const winrt::Microsoft::UI::Content::IContentSiteBridge &bridge,
+      const winrt::Microsoft::ReactNative::ReactNativeIsland &island);
+
+  winrt::Microsoft::ReactNative::ReactNativeIsland ReactNativeIsland() noexcept;
+
+  winrt::Microsoft::UI::Windowing::AppWindow AppWindow() noexcept;
+
+  winrt::Microsoft::UI::Content::IContentSiteBridge ContentSiteBridge() noexcept;
+
+  winrt::Microsoft::ReactNative::ContentSizePolicy ResizePolicy() const noexcept;
+  void ResizePolicy(winrt::Microsoft::ReactNative::ContentSizePolicy value) noexcept;
+
+  winrt::Microsoft::ReactNative::LayoutConstraints LayoutConstraints() const noexcept;
+  void LayoutConstraints(winrt::Microsoft::ReactNative::LayoutConstraints const &value) noexcept;
+
+  void Close() noexcept;
+
+ private:
+  void Connect(winrt::Microsoft::UI::Content::ContentIsland contentIsland) noexcept;
+  winrt::Microsoft::UI::Composition::Compositor Compositor() noexcept;
+  void AppWindow(const winrt::Microsoft::UI::Windowing::AppWindow &appWindow) noexcept;
+  void AppWindow_Changed(
+      winrt::Microsoft::UI::Windowing::AppWindow const &window,
+      winrt::Microsoft::UI::Windowing::AppWindowChangedEventArgs const &args) noexcept;
+
+  void ReactNativeIsland(const winrt::Microsoft::ReactNative::ReactNativeIsland &value) noexcept;
+
+  void UpdateIslandScaleFactor() noexcept;
+  void EnsureResizePolicyState() noexcept;
+  void UpdateRootViewSizeToAppWindow(
+      winrt::Microsoft::ReactNative::ReactNativeIsland const &rootView,
+      winrt::Microsoft::UI::Windowing::AppWindow const &window) noexcept;
+
+  winrt::Microsoft::UI::Composition::Compositor m_compositor{nullptr};
+  winrt::Microsoft::ReactNative::ReactNativeIsland m_island{nullptr};
+  winrt::event_token m_appWindowChangedToken;
+  winrt::Microsoft::ReactNative::ReactNativeIsland::SizeChanged_revoker m_sizeChangedRevoker;
+  winrt::Microsoft::ReactNative::ContentSizePolicy m_resizePolicy{
+      winrt::Microsoft::ReactNative::ContentSizePolicy::ResizeContentToParentWindow};
+  winrt::Microsoft::UI::Content::IContentSiteBridge m_bridge{nullptr};
+  winrt::Microsoft::UI::Windowing::AppWindow m_appWindow{nullptr};
+  winrt::Microsoft::ReactNative::LayoutConstraints m_layoutConstraints{
+      {0, 0},
+      {0, 0},
+      winrt::Microsoft::ReactNative::LayoutDirection::Undefined};
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation
+
+namespace winrt::Microsoft::ReactNative::factory_implementation {
+struct ReactNativeWindow : ReactNativeWindowT<ReactNativeWindow, implementation::ReactNativeWindow> {};
+} // namespace winrt::Microsoft::ReactNative::factory_implementation

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

@@ -6,7 +6,7 @@
 
 #include "ScrollViewComponentView.h"
 
-#include <UI.Xaml.Controls.h>
+#include <Fabric/ComponentView.h>
 #include <Utils/ValueUtils.h>
 
 #pragma warning(push)
@@ -20,6 +20,8 @@
 #include <AutoDraw.h>
 #include <Fabric/DWriteHelpers.h>
 #include <unicode.h>
+#include <functional>
+#include "ContentIslandComponentView.h"
 #include "JSValueReader.h"
 #include "RootComponentView.h"
 
@@ -885,6 +887,13 @@ void ScrollViewComponentView::updateContentVisualSize() noexcept {
 
 void ScrollViewComponentView::prepareForRecycle() noexcept {}
 
+void ScrollViewComponentView::updateChildrenClippingPath(
+    facebook::react::LayoutMetrics const & /*layoutMetrics*/,
+    const facebook::react::ViewProps & /*viewProps*/) noexcept {
+  // No-op: ScrollView mounts children into m_scrollVisual (not Visual()),
+  // and scroll visuals inherently clip their content.
+}
+
 /*
 ScrollViewComponentView::ScrollInteractionTrackerOwner::ScrollInteractionTrackerOwner(
     ScrollViewComponentView *outer)
@@ -1326,6 +1335,10 @@ winrt::Microsoft::ReactNative::Composition::Experimental::IVisual ScrollViewComp
             m_allowNextScrollNoMatterWhat = false;
           }
         }
+
+        // Issue #15557: Notify listeners that scroll position has changed,
+        // so ContentIslandComponentView can update LocalToParentTransformMatrix
+        FireViewChanged();
       });
 
   m_scrollBeginDragRevoker = m_scrollVisual.ScrollBeginDrag(
@@ -1333,6 +1346,9 @@ winrt::Microsoft::ReactNative::Composition::Experimental::IVisual ScrollViewComp
       [this](
           winrt::IInspectable const & /*sender*/,
           winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs const &args) {
+        // Issue #15557: Notify listeners that scroll position has changed
+        FireViewChanged();
+
         m_allowNextScrollNoMatterWhat = true; // Ensure next scroll event is recorded, regardless of throttle
         updateStateWithContentOffset();
         auto eventEmitter = GetEventEmitter();
@@ -1479,4 +1495,20 @@ void ScrollViewComponentView::updateShowsVerticalScrollIndicator(bool value) noe
 void ScrollViewComponentView::updateDecelerationRate(float value) noexcept {
   m_scrollVisual.SetDecelerationRate({value, value, value});
 }
+
+// Issue #15557: Notify listeners that scroll position has changed.
+// ContentIslandComponentView subscribes to this to update LocalToParentTransformMatrix.
+void ScrollViewComponentView::FireViewChanged() noexcept {
+  m_viewChangedEvent(*this, nullptr);
+}
+
+// Issue #15557: Event accessors for ViewChanged
+winrt::event_token ScrollViewComponentView::ViewChanged(
+    winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable> const &handler) noexcept {
+  return m_viewChangedEvent.add(handler);
+}
+
+void ScrollViewComponentView::ViewChanged(winrt::event_token const &token) noexcept {
+  m_viewChangedEvent.remove(token);
+}
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -118,6 +118,18 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
   double getVerticalSize() noexcept;
   double getHorizontalSize() noexcept;
 
+  // Issue #15557: Event accessors for ViewChanged (used by ContentIslandComponentView for transform update)
+  winrt::event_token ViewChanged(
+      winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable> const &handler) noexcept;
+  void ViewChanged(winrt::event_token const &token) noexcept;
+
+ protected:
+  // ScrollView mounts children into m_scrollVisual (not Visual()), and scroll visuals
+  // inherently clip their content, so we skip the children container clipping logic.
+  void updateChildrenClippingPath(
+      facebook::react::LayoutMetrics const &layoutMetrics,
+      const facebook::react::ViewProps &viewProps) noexcept override;
+
  private:
   void updateDecelerationRate(float value) noexcept;
   void updateContentVisualSize() noexcept;
@@ -129,6 +141,8 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
   bool scrollRight(float delta, bool animate) noexcept;
   void updateBackgroundColor(const facebook::react::SharedColor &color) noexcept;
   void updateStateWithContentOffset() noexcept;
+  // Issue #15557: Notify listeners that scroll position has changed
+  void FireViewChanged() noexcept;
   facebook::react::ScrollViewEventEmitter::Metrics getScrollMetrics(
       facebook::react::SharedViewEventEmitter const &eventEmitter,
       winrt::Microsoft::ReactNative::Composition::Experimental::IScrollPositionChangedArgs const &args) noexcept;
@@ -160,6 +174,9 @@ struct ScrollInteractionTrackerOwner : public winrt::implements<
   bool m_allowNextScrollNoMatterWhat{false};
   std::chrono::steady_clock::time_point m_lastScrollEventTime{};
   std::shared_ptr<facebook::react::ScrollViewShadowNode::ConcreteState const> m_state;
+
+  // Issue #15557: Event for notifying listeners when scroll position changes
+  winrt::event<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>> m_viewChangedEvent;
 };
 
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -186,6 +186,7 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
     auto pt = m_outer->getClientOffset();
     m_outer->m_caretVisual.Position({x - pt.x, y - pt.y});
+    m_outer->m_caretPosition = {x, y};
     return true;
   }
 
@@ -696,17 +697,10 @@ void WindowsTextInputComponentView::OnPointerPressed(
   }
 
   if (m_textServices && msg) {
-    if (msg == WM_RBUTTONUP && !windowsTextInputProps().contextMenuHidden) {
-      ShowContextMenu(position);
-      args.Handled(true);
-    } else if (msg == WM_RBUTTONUP && windowsTextInputProps().contextMenuHidden) {
-      args.Handled(true);
-    } else {
-      LRESULT lresult;
-      DrawBlock db(*this);
-      auto hr = m_textServices->TxSendMessage(msg, static_cast<WPARAM>(wParam), static_cast<LPARAM>(lParam), &lresult);
-      args.Handled(hr != S_FALSE);
-    }
+    LRESULT lresult;
+    DrawBlock db(*this);
+    auto hr = m_textServices->TxSendMessage(msg, static_cast<WPARAM>(wParam), static_cast<LPARAM>(lParam), &lresult);
+    args.Handled(hr != S_FALSE);
   }
 
   // Emits the OnPressIn event
@@ -768,10 +762,18 @@ void WindowsTextInputComponentView::OnPointerReleased(
   }
 
   if (m_textServices && msg) {
-    LRESULT lresult;
-    DrawBlock db(*this);
-    auto hr = m_textServices->TxSendMessage(msg, static_cast<WPARAM>(wParam), static_cast<LPARAM>(lParam), &lresult);
-    args.Handled(hr != S_FALSE);
+    // Show context menu on right button release (standard Windows behavior)
+    if (msg == WM_RBUTTONUP && !windowsTextInputProps().contextMenuHidden) {
+      ShowContextMenu(LocalToScreen(position));
+      args.Handled(true);
+    } else if (msg == WM_RBUTTONUP) {
+      // Context menu is hidden - don't mark as handled, let app add custom behavior
+    } else {
+      LRESULT lresult;
+      DrawBlock db(*this);
+      auto hr = m_textServices->TxSendMessage(msg, static_cast<WPARAM>(wParam), static_cast<LPARAM>(lParam), &lresult);
+      args.Handled(hr != S_FALSE);
+    }
   }
 
   // Emits the OnPressOut event
@@ -1225,8 +1227,11 @@ void WindowsTextInputComponentView::updateState(
   if (m_mostRecentEventCount == m_state->getData().mostRecentEventCount) {
     m_comingFromState = true;
     auto &fragments = m_state->getData().attributedStringBox.getValue().getFragments();
-    UpdateText(fragments.size() ? fragments[0].string : "");
-
+    {
+      // DrawBlock defers DrawText() until after UpdateText completes
+      DrawBlock db(*this);
+      UpdateText(fragments.size() ? fragments[0].string : "");
+    }
     m_comingFromState = false;
   }
 }
@@ -1375,7 +1380,7 @@ void WindowsTextInputComponentView::EmitOnScrollEvent() noexcept {
 }
 
 void WindowsTextInputComponentView::OnSelectionChanged(LONG start, LONG end) noexcept {
-  if (m_eventEmitter && !m_comingFromState /* && !m_comingFromJS ?? */) {
+  if (m_eventEmitter && !m_comingFromState && !m_comingFromJS) {
     auto emitter = std::static_pointer_cast<const facebook::react::WindowsTextInputEventEmitter>(m_eventEmitter);
     facebook::react::WindowsTextInputEventEmitter::OnSelectionChange onSelectionChangeArgs;
     onSelectionChangeArgs.selection.start = start;
@@ -1676,7 +1681,8 @@ void WindowsTextInputComponentView::DrawText() noexcept {
   }
 
   bool isZeroSized =
-      m_layoutMetrics.frame.size.width <= (m_layoutMetrics.contentInsets.left + m_layoutMetrics.contentInsets.right);
+      m_layoutMetrics.frame.size.width <= (m_layoutMetrics.contentInsets.left + m_layoutMetrics.contentInsets.right) ||
+      m_layoutMetrics.frame.size.height <= (m_layoutMetrics.contentInsets.top + m_layoutMetrics.contentInsets.bottom);
   if (!m_drawingSurface || isZeroSized)
     return;
 
@@ -1870,6 +1876,21 @@ void WindowsTextInputComponentView::updateSpellCheck(bool enable) noexcept {
       m_textServices->TxSendMessage(EM_SETLANGOPTIONS, IMF_SPELLCHECKING, enable ? newLangOptions : 0, &lresult));
 }
 
+void WindowsTextInputComponentView::OnContextMenuKey(
+    const winrt::Microsoft::ReactNative::Composition::Input::ContextMenuKeyEventArgs &args) noexcept {
+  // Handle context menu key event (SHIFT+F10 or Context Menu key)
+  if (!windowsTextInputProps().contextMenuHidden) {
+    // m_caretPosition is stored from TxSetCaretPos in RichEdit client rect space (physical pixels).
+    // LocalToScreen expects logical (DIP) coordinates, so divide by pointScaleFactor.
+    auto screenPt = LocalToScreen(winrt::Windows::Foundation::Point{
+        static_cast<float>(m_caretPosition.x) / m_layoutMetrics.pointScaleFactor,
+        static_cast<float>(m_caretPosition.y) / m_layoutMetrics.pointScaleFactor});
+    ShowContextMenu(screenPt);
+    args.Handled(true);
+  }
+  // If contextMenuHidden, don't mark as handled - let app handle it
+}
+
 void WindowsTextInputComponentView::ShowContextMenu(const winrt::Windows::Foundation::Point &position) noexcept {
   HMENU menu = CreatePopupMenu();
   if (!menu)
@@ -1889,13 +1910,16 @@ void WindowsTextInputComponentView::ShowContextMenu(const winrt::Windows::Founda
   AppendMenuW(menu, MF_STRING | (canPaste ? 0 : MF_GRAYED), 3, L"Paste");
   AppendMenuW(menu, MF_STRING | (!isEmpty && !isReadOnly ? 0 : MF_GRAYED), 4, L"Select All");
 
-  POINT cursorPos;
-  GetCursorPos(&cursorPos);
-
   HWND hwnd = GetActiveWindow();
 
   int cmd = TrackPopupMenu(
-      menu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD | TPM_NONOTIFY, cursorPos.x, cursorPos.y, 0, hwnd, NULL);
+      menu,
+      TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD | TPM_NONOTIFY,
+      static_cast<int>(position.X),
+      static_cast<int>(position.Y),
+      0,
+      hwnd,
+      NULL);
 
   if (cmd == 1) { // Cut
     m_textServices->TxSendMessage(WM_CUT, 0, 0, &res);

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

@@ -67,6 +67,8 @@ struct WindowsTextInputComponentView
   void OnKeyUp(const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept override;
   void OnCharacterReceived(const winrt::Microsoft::ReactNative::Composition::Input::CharacterReceivedRoutedEventArgs
                                &args) noexcept override;
+  void OnContextMenuKey(
+      const winrt::Microsoft::ReactNative::Composition::Input::ContextMenuKeyEventArgs &args) noexcept override;
   void onMounted() noexcept override;
 
   std::optional<std::string> getAccessiblityValue() noexcept override;
@@ -146,6 +148,7 @@ struct WindowsTextInputComponentView
   DWORD m_propBitsMask{0};
   DWORD m_propBits{0};
   HCURSOR m_hcursor{nullptr};
+  POINT m_caretPosition{0, 0};
   std::chrono::steady_clock::time_point m_lastClickTime{};
   std::vector<facebook::react::CompWindowsTextInputSubmitKeyEventsStruct> m_submitKeyEvents;
 };

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

@@ -5,6 +5,7 @@
 
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/attributedstring/PlaceholderAttributedString.h>
 #include <react/renderer/attributedstring/TextAttributes.h>
 #include <react/renderer/components/text/BaseTextShadowNode.h>
 #include <react/renderer/core/LayoutConstraints.h>
@@ -185,6 +186,7 @@ AttributedString WindowsTextInputShadowNode::getPlaceholderAttributedString(cons
   const auto &props = getConcreteProps();
 
   AttributedString attributedString;
+  attributedString.setBaseTextAttributes(props.textAttributes);
   //[windows
   if (!props.placeholder.empty()) {
     auto textAttributes = TextAttributes::defaultTextAttributes();
@@ -203,7 +205,7 @@ AttributedString WindowsTextInputShadowNode::getPlaceholderAttributedString(cons
   }
   // windows]
 
-  return attributedString;
+  return ensurePlaceholderIfEmpty_DO_NOT_USE(attributedString);
 }
 
 #pragma mark - LayoutableShadowNode

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

@@ -48,7 +48,8 @@ HRESULT UiaNavigateHelper(
         uint32_t index = children.Size() - 1;
         do {
           auto child = children.GetAt(index).as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
-          if (uiaProvider = child->EnsureUiaProvider()) {
+          uiaProvider = child->EnsureUiaProvider();
+          if (uiaProvider) {
             break;
           }
         } while (index-- != 0);
@@ -60,7 +61,8 @@ HRESULT UiaNavigateHelper(
         uint32_t index = 0;
         do {
           auto child = children.GetAt(index).as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
-          if (uiaProvider = child->EnsureUiaProvider()) {
+          uiaProvider = child->EnsureUiaProvider();
+          if (uiaProvider) {
             break;
           }
         } while (++index != children.Size());
@@ -74,7 +76,8 @@ HRESULT UiaNavigateHelper(
 
         while (++it != children.end()) {
           auto nextchild = (*it).as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
-          if (uiaProvider = nextchild->EnsureUiaProvider()) {
+          uiaProvider = nextchild->EnsureUiaProvider();
+          if (uiaProvider) {
             break;
           }
         }
@@ -91,7 +94,8 @@ HRESULT UiaNavigateHelper(
           do {
             it--;
             auto prevchild = (*it).as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
-            if (uiaProvider = prevchild->EnsureUiaProvider()) {
+            uiaProvider = prevchild->EnsureUiaProvider();
+            if (uiaProvider) {
               break;
             }
           } while (it != children.begin());