react-native-windows 0.81.4 → 0.81.5

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

@@ -32,6 +32,8 @@ struct ContentIslandComponentView : ContentIslandComponentViewT<ContentIslandCom
       uint32_t index) noexcept override;
   void Connect(const winrt::Microsoft::UI::Content::ContentIsland &contentIsland) noexcept;
 
+  winrt::Microsoft::UI::Content::ChildSiteLink ChildSiteLink() noexcept;
+
   void updateLayoutMetrics(
       facebook::react::LayoutMetrics const &layoutMetrics,
       facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept;
@@ -59,14 +61,12 @@ struct ContentIslandComponentView : ContentIslandComponentViewT<ContentIslandCom
   void OnUnmounted() noexcept;
   void ParentLayoutChanged() noexcept;
   void ConnectInternal() noexcept;
-  void RegisterForRootIslandEvents() noexcept;
-  void UnregisterForRootIslandEvents() noexcept;
   winrt::Microsoft::UI::Content::ContentIsland ParentContentIsland() noexcept;
 
   bool m_layoutChangePosted{false};
   winrt::Microsoft::UI::Content::ContentIsland m_parentContentIsland{nullptr};
   winrt::Microsoft::UI::Content::ContentIsland m_islandToConnect{nullptr};
-  winrt::event_token m_islandStateChangedToken;
+  std::optional<winrt::Microsoft::UI::Input::FocusNavigationReason> m_pendingNavigateFocus;
 
   winrt::event_token m_mountedToken;
   winrt::event_token m_unmountedToken;
@@ -74,6 +74,14 @@ struct ContentIslandComponentView : ContentIslandComponentViewT<ContentIslandCom
   winrt::Microsoft::UI::Content::ChildSiteLink m_childSiteLink{nullptr};
   winrt::Microsoft::UI::Input::InputFocusNavigationHost m_navigationHost{nullptr};
   winrt::event_token m_navigationHostDepartFocusRequestedToken{};
+  std::optional<winrt::Microsoft::UI::Input::FocusNavigationReason> m_pendingFocus;
+
+  // Issue #15557: Store ViewChanged subscriptions to parent ScrollViews for transform updates
+  struct ViewChangedSubscription {
+    winrt::weak_ref<winrt::Microsoft::ReactNative::Composition::ScrollViewComponentView> scrollView;
+    winrt::event_token token;
+  };
+  std::vector<ViewChangedSubscription> m_viewChangedSubscriptions;
 
   // Automation
   void ConfigureChildSiteLinkAutomation() noexcept;

package/Microsoft.ReactNative/Fabric/Composition/Modal/WindowsModalHostViewComponentView.cpp

@@ -37,9 +37,9 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
   ~ModalHostView() {
     if (m_popUp) {
       // Unregister closing event handler
-      if (m_appWindow && m_appWindowClosingToken) {
-        m_appWindow.Closing(m_appWindowClosingToken);
-        m_appWindowClosingToken.value = 0;
+      if (m_appWindowClosingToken) {
+        m_rnWindow.AppWindow().Closing(m_appWindowClosingToken);
+        m_appWindowClosingToken = {};
       }
 
       // Reset topWindowID before destroying
@@ -49,21 +49,15 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
         m_prevWindowID = 0;
       }
 
-      // Close island
-      if (m_reactNativeIsland) {
-        m_reactNativeIsland.Island().Close();
-        m_reactNativeIsland = nullptr;
-      }
-
       // Hide popup
       if (m_popUp.IsVisible()) {
         m_popUp.Hide();
       }
 
       // Destroy AppWindow this automatically resumes parent window to receive inputs
-      if (m_appWindow) {
-        m_appWindow.Destroy();
-        m_appWindow = nullptr;
+      if (m_rnWindow.AppWindow()) {
+        m_rnWindow.Close();
+        m_rnWindow = nullptr;
       }
 
       // Bring parent window to foreground
@@ -111,11 +105,11 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     }
 
     // Update Title if changed and AppWindow exists
-    if (m_appWindow && (!oldProps || newViewProps.title != oldViewProps.title)) {
+    if (m_rnWindow && (!oldProps || newViewProps.title != oldViewProps.title)) {
       // Use empty string if title is not set
       winrt::hstring titleValue =
           newViewProps.title.has_value() ? winrt::to_hstring(newViewProps.title.value()) : winrt::hstring();
-      m_appWindow.Title(titleValue);
+      m_rnWindow.AppWindow().Title(titleValue);
     }
 
     ::Microsoft::ReactNativeSpecs::BaseModalHostView<ModalHostView>::UpdateProps(view, newProps, oldProps);
@@ -181,7 +175,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
   }
 
   void AdjustWindowSize(const winrt::Microsoft::ReactNative::LayoutMetrics &layoutMetrics) noexcept {
-    if (!m_appWindow) {
+    if (!m_rnWindow) {
       return;
     }
 
@@ -198,17 +192,17 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     clientHeightPx = std::max(100, clientHeightPx);
 
     // Size the client area directly
-    m_appWindow.ResizeClient({clientWidthPx, clientHeightPx});
+    m_rnWindow.AppWindow().ResizeClient({clientWidthPx, clientHeightPx});
 
     // Center the window on its parent
     RECT parentRC;
     GetWindowRect(m_parentHwnd, &parentRC);
-    auto outerSize = m_appWindow.Size();
+    auto outerSize = m_rnWindow.AppWindow().Size();
 
     int32_t xCor = parentRC.left + (parentRC.right - parentRC.left - outerSize.Width) / 2;
     int32_t yCor = parentRC.top + (parentRC.bottom - parentRC.top - outerSize.Height) / 2;
 
-    m_appWindow.Move({xCor, yCor});
+    m_rnWindow.AppWindow().Move({xCor, yCor});
   };
 
   void ShowOnUIThread(const winrt::Microsoft::ReactNative::ComponentView &view) {
@@ -231,8 +225,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
 
       // dispatch onShow event
       if (auto eventEmitter = EventEmitter()) {
-        ::Microsoft::ReactNativeSpecs::ModalHostViewEventEmitter::OnShow eventArgs;
-        eventEmitter->onShow(eventArgs);
+        eventEmitter->onShow({});
       }
     }
   }
@@ -261,8 +254,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
 
     // Dispatch onDismiss event
     if (auto eventEmitter = EventEmitter()) {
-      ::Microsoft::ReactNativeSpecs::ModalHostViewEventEmitter::OnDismiss eventArgs;
-      eventEmitter->onDismiss(eventArgs);
+      eventEmitter->onDismiss({});
     }
   }
 
@@ -279,59 +271,55 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
         view.as<::Microsoft::ReactNative::Composition::Experimental::IComponentViewInterop>()->GetHwndForParenting();
 
     auto portal = view.as<winrt::Microsoft::ReactNative::Composition::PortalComponentView>();
-    m_reactNativeIsland = winrt::Microsoft::ReactNative::ReactNativeIsland::CreatePortal(portal);
-    auto contentIsland = m_reactNativeIsland.Island();
-
     m_popUp = winrt::Microsoft::UI::Content::DesktopPopupSiteBridge::Create(
         portal.Parent()
             .as<winrt::Microsoft::ReactNative::Composition::ComponentView>()
             .Root()
             .ReactNativeIsland()
             .Island());
-    m_popUp.Connect(contentIsland);
 
     // Get AppWindow and configure presenter
-    m_appWindow = winrt::Microsoft::UI::Windowing::AppWindow::GetFromWindowId(m_popUp.WindowId());
-    if (m_appWindow) {
-      auto overlappedPresenter = winrt::Microsoft::UI::Windowing::OverlappedPresenter::Create();
-
-      // Configure presenter for modal behavior
-      overlappedPresenter.IsModal(true);
-      overlappedPresenter.SetBorderAndTitleBar(true, true);
-
-      // modal should only have close button
-      overlappedPresenter.IsMinimizable(false);
-      overlappedPresenter.IsMaximizable(false);
-
-      // Apply the presenter to the window
-      m_appWindow.SetPresenter(overlappedPresenter);
-
-      // Hide the title bar icon
-      m_appWindow.TitleBar().IconShowOptions(winrt::Microsoft::UI::Windowing::IconShowOptions::HideIconAndSystemMenu);
-
-      // Set initial title using the stored local props
-      if (m_localProps && m_localProps->title.has_value()) {
-        winrt::hstring titleValue = winrt::to_hstring(m_localProps->title.value());
-        m_appWindow.Title(titleValue);
-      } else {
-        m_appWindow.Title(L""); // Empty title if not provided
-      }
+    m_rnWindow = winrt::Microsoft::ReactNative::ReactNativeWindow::CreateFromContentSiteBridgeAndIsland(
+        m_popUp, winrt::Microsoft::ReactNative::ReactNativeIsland::CreatePortal(portal));
+    m_rnWindow.ResizePolicy(winrt::Microsoft::ReactNative::ContentSizePolicy::None);
+    auto overlappedPresenter = winrt::Microsoft::UI::Windowing::OverlappedPresenter::Create();
+
+    // Configure presenter for modal behavior
+    overlappedPresenter.IsModal(true);
+    overlappedPresenter.SetBorderAndTitleBar(true, true);
+
+    // modal should only have close button
+    overlappedPresenter.IsMinimizable(false);
+    overlappedPresenter.IsMaximizable(false);
+
+    // Apply the presenter to the window
+    m_rnWindow.AppWindow().SetPresenter(overlappedPresenter);
+
+    // Hide the title bar icon
+    m_rnWindow.AppWindow().TitleBar().IconShowOptions(
+        winrt::Microsoft::UI::Windowing::IconShowOptions::HideIconAndSystemMenu);
+
+    // Set initial title using the stored local props
+    if (m_localProps && m_localProps->title.has_value()) {
+      winrt::hstring titleValue = winrt::to_hstring(m_localProps->title.value());
+      m_rnWindow.AppWindow().Title(titleValue);
+    } else {
+      m_rnWindow.AppWindow().Title(L""); // Empty title if not provided
+    }
 
-      // Handle close request ('X' button)
-      m_appWindowClosingToken =
-          m_appWindow.Closing([wkThis = get_weak()](
-                                  const winrt::Microsoft::UI::Windowing::AppWindow & /*sender*/,
-                                  const winrt::Microsoft::UI::Windowing::AppWindowClosingEventArgs &args) {
-            args.Cancel(true); // Prevent default close
-            if (auto strongThis = wkThis.get()) {
-              // Dispatch onRequestClose event
-              if (auto eventEmitter = strongThis->EventEmitter()) {
-                ::Microsoft::ReactNativeSpecs::ModalHostViewEventEmitter::OnRequestClose eventArgs;
-                eventEmitter->onRequestClose(eventArgs);
-              }
+    // Handle close request ('X' button)
+    m_appWindowClosingToken =
+        m_rnWindow.AppWindow().Closing([wkThis = get_weak()](
+                                           const winrt::Microsoft::UI::Windowing::AppWindow & /*sender*/,
+                                           const winrt::Microsoft::UI::Windowing::AppWindowClosingEventArgs &args) {
+          args.Cancel(true); // Prevent default close
+          if (auto strongThis = wkThis.get()) {
+            // Dispatch onRequestClose event
+            if (auto eventEmitter = strongThis->EventEmitter()) {
+              eventEmitter->onRequestClose({});
             }
-          });
-    }
+          }
+        });
 
     // set the top-level windows as the new hwnd
     winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
@@ -352,10 +340,10 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
         });
         */
 
-    m_islandStateChangedToken =
-        contentIsland.StateChanged([weakThis = get_weak()](
-                                       winrt::Microsoft::UI::Content::ContentIsland const &island,
-                                       winrt::Microsoft::UI::Content::ContentIslandStateChangedEventArgs const &args) {
+    m_islandStateChangedToken = m_rnWindow.ReactNativeIsland().Island().StateChanged(
+        [weakThis = get_weak()](
+            winrt::Microsoft::UI::Content::ContentIsland const &island,
+            winrt::Microsoft::UI::Content::ContentIslandStateChangedEventArgs const &args) {
           if (auto pThis = weakThis.get()) {
             if (args.DidRasterizationScaleChange() || args.DidLayoutDirectionChange()) {
               pThis->UpdateConstraints();
@@ -375,7 +363,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
         m_popUp.SiteView().EnvironmentView().DisplayId());
     auto workArea = displayArea.WorkArea();
 
-    float scale = m_reactNativeIsland.Island().RasterizationScale();
+    float scale = m_rnWindow.ReactNativeIsland().Island().RasterizationScale();
 
     winrt::Microsoft::ReactNative::LayoutConstraints constraints;
     constraints.MinimumSize = {0, 0};
@@ -384,7 +372,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
         static_cast<float>((workArea.Width / scale) * 0.9), static_cast<float>((workArea.Height / scale) * 0.9)};
     constraints.LayoutDirection = winrt::Microsoft::ReactNative::LayoutDirection::Undefined;
 
-    auto layoutDirection = m_reactNativeIsland.Island().LayoutDirection();
+    auto layoutDirection = m_rnWindow.ReactNativeIsland().Island().LayoutDirection();
     if (layoutDirection == winrt::Microsoft::UI::Content::ContentLayoutDirection::LeftToRight)
       constraints.LayoutDirection = winrt::Microsoft::ReactNative::LayoutDirection::LeftToRight;
     else if (layoutDirection == winrt::Microsoft::UI::Content::ContentLayoutDirection::RightToLeft)
@@ -394,7 +382,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     // When no constraint is set (maxSize is std::numeric_limits<Float>::infinity()), yoga will layout the content to a
     // desired size If we provide a specific max size, then contents with a flex:1 will expand to fill that size. We
     // might want to provide a windows specific property to control this behavior.
-    m_state.UpdateState(winrt::make<ModalHostState>(constraints, m_reactNativeIsland.Island().RasterizationScale()));
+    m_state.UpdateState(winrt::make<ModalHostState>(constraints, scale));
   }
 
   static void TrySetFocus(const winrt::Microsoft::ReactNative::ComponentView &view) {
@@ -414,9 +402,8 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
   winrt::event_token m_departFocusToken;
   winrt::event_token m_childLayoutMetricsToken;
   winrt::Microsoft::ReactNative::IComponentState m_state{nullptr};
-  winrt::Microsoft::ReactNative::ReactNativeIsland m_reactNativeIsland{nullptr};
+  winrt::Microsoft::ReactNative::ReactNativeWindow m_rnWindow{nullptr};
   winrt::Microsoft::UI::Content::DesktopPopupSiteBridge m_popUp{nullptr};
-  winrt::Microsoft::UI::Windowing::AppWindow m_appWindow{nullptr};
   winrt::event_token m_appWindowClosingToken;
   winrt::com_ptr<::Microsoft::ReactNativeSpecs::ModalHostViewProps> m_localProps{nullptr};
 };

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

@@ -168,9 +168,6 @@ winrt::Microsoft::ReactNative::ReactNativeIsland ReactNativeIsland::CreatePortal
   return winrt::make<ReactNativeIsland>(portal);
 }
 
-ReactNativeIsland::ReactNativeIsland() noexcept
-    : ReactNativeIsland(winrt::Microsoft::UI::Composition::Compositor{nullptr}) {}
-
 ReactNativeIsland::~ReactNativeIsland() noexcept {
 #ifdef USE_WINUI3
   if (m_island) {
@@ -220,6 +217,10 @@ void ReactNativeIsland::ReactViewHost(winrt::Microsoft::ReactNative::IReactViewH
   }
 }
 
+winrt::Microsoft::UI::Composition::Compositor ReactNativeIsland::Compositor() noexcept {
+  return m_compositor;
+}
+
 winrt::Microsoft::UI::Composition::Visual ReactNativeIsland::RootVisual() noexcept {
   return winrt::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompositionContextHelper::InnerVisual(
       m_rootVisual);

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

@@ -48,7 +48,6 @@ struct FocusNavigationResult : FocusNavigationResultT<FocusNavigationResult> {
 
 struct ReactNativeIsland
     : ReactNativeIslandT<ReactNativeIsland, Composition::Experimental::IInternalCompositionRootView> {
-  ReactNativeIsland() noexcept;
   ~ReactNativeIsland() noexcept;
 
   ReactNativeIsland(const winrt::Microsoft::UI::Composition::Compositor &compositor) noexcept;
@@ -65,6 +64,8 @@ struct ReactNativeIsland
   ReactNative::IReactViewHost ReactViewHost() noexcept;
   void ReactViewHost(ReactNative::IReactViewHost const &value);
 
+  winrt::Microsoft::UI::Composition::Compositor Compositor() noexcept;
+
   winrt::Microsoft::UI::Composition::Visual RootVisual() noexcept;
 
   // property RootVisual

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