react-native-windows 0.75.9 → 0.75.11

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

@@ -165,6 +165,10 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Show the caret
   BOOL TxShowCaret(BOOL fShow) override {
+    // Only show the caret if we have focus
+    if (fShow && !m_outer->m_hasFocus) {
+      return false;
+    }
     m_outer->ShowCaret(m_outer->windowsTextInputProps().caretHidden ? false : fShow);
     return true;
   }
@@ -232,19 +236,25 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Establish a new cursor shape
   void TxSetCursor(HCURSOR hcur, BOOL fText) override {
-    assert(false);
+    m_outer->m_hcursor = hcur;
   }
 
   //@cmember Converts screen coordinates of a specified point to the client coordinates
   BOOL TxScreenToClient(LPPOINT lppt) override {
-    assert(false);
-    return {};
+    winrt::Windows::Foundation::Point pt{static_cast<float>(lppt->x), static_cast<float>(lppt->y)};
+    auto localpt = m_outer->ScreenToLocal(pt);
+    lppt->x = static_cast<LONG>(localpt.X);
+    lppt->y = static_cast<LONG>(localpt.Y);
+    return true;
   }
 
   //@cmember Converts the client coordinates of a specified point to screen coordinates
   BOOL TxClientToScreen(LPPOINT lppt) override {
-    assert(false);
-    return {};
+    winrt::Windows::Foundation::Point pt{static_cast<float>(lppt->x), static_cast<float>(lppt->y)};
+    auto screenpt = m_outer->LocalToScreen(pt);
+    lppt->x = static_cast<LONG>(screenpt.X);
+    lppt->y = static_cast<LONG>(screenpt.Y);
+    return true;
   }
 
   //@cmember Request host to activate text services
@@ -722,6 +732,9 @@ void WindowsTextInputComponentView::OnPointerMoved(
     auto hr = m_textServices->TxSendMessage(msg, static_cast<WPARAM>(wParam), static_cast<LPARAM>(lParam), &lresult);
     args.Handled(hr != S_FALSE);
   }
+
+  m_textServices->OnTxSetCursor(
+      DVASPECT_CONTENT, -1, nullptr, nullptr, nullptr, nullptr, nullptr, ptContainer.x, ptContainer.y);
 }
 
 void WindowsTextInputComponentView::OnKeyDown(
@@ -870,6 +883,7 @@ void WindowsTextInputComponentView::OnCharacterReceived(
   emitter->onKeyPress(onKeyPressArgs);
 
   WPARAM wParam = static_cast<WPARAM>(args.KeyCode());
+
   LPARAM lParam = 0;
   lParam = args.KeyStatus().RepeatCount; // bits 0-15
   lParam |= args.KeyStatus().ScanCode << 16; // bits 16-23
@@ -908,6 +922,7 @@ void WindowsTextInputComponentView::UnmountChildComponentView(
 
 void WindowsTextInputComponentView::onLostFocus(
     const winrt::Microsoft::ReactNative::Composition::Input::RoutedEventArgs &args) noexcept {
+  m_hasFocus = false;
   Super::onLostFocus(args);
   if (m_textServices) {
     LRESULT lresult;
@@ -919,6 +934,7 @@ void WindowsTextInputComponentView::onLostFocus(
 
 void WindowsTextInputComponentView::onGotFocus(
     const winrt::Microsoft::ReactNative::Composition::Input::RoutedEventArgs &args) noexcept {
+  m_hasFocus = true;
   Super::onGotFocus(args);
   if (m_textServices) {
     LRESULT lresult;
@@ -1022,6 +1038,10 @@ void WindowsTextInputComponentView::updateProps(
     m_submitKeyEvents.clear();
   }
 
+  if (oldTextInputProps.autoCapitalize != newTextInputProps.autoCapitalize) {
+    autoCapitalizeOnUpdateProps(oldTextInputProps.autoCapitalize, newTextInputProps.autoCapitalize);
+  }
+
   UpdatePropertyBits();
 }
 
@@ -1462,6 +1482,10 @@ WindowsTextInputComponentView::createVisual() noexcept {
   return visual;
 }
 
+std::pair<facebook::react::Cursor, HCURSOR> WindowsTextInputComponentView::cursor() const noexcept {
+  return {viewProps()->cursor, m_hcursor};
+}
+
 void WindowsTextInputComponentView::onThemeChanged() noexcept {
   const auto &props = windowsTextInputProps();
   updateCursorColor(props.cursorColor, props.textAttributes.foregroundColor);
@@ -1476,4 +1500,29 @@ winrt::Microsoft::ReactNative::ComponentView WindowsTextInputComponentView::Crea
   return winrt::make<WindowsTextInputComponentView>(compContext, tag, reactContext);
 }
 
+// This function assumes that previous and new capitalization types are different.
+void WindowsTextInputComponentView::autoCapitalizeOnUpdateProps(
+    const std::string &previousCapitalizationType,
+    const std::string &newCapitalizationType) noexcept {
+  /*
+    Possible values are:
+     Characters - All characters.
+     Words - First letter of each word.
+     Sentences - First letter of each sentence.
+     None - Do not autocapitalize anything.
+
+     For now, only characters and none are supported.
+  */
+
+  if (previousCapitalizationType == "characters") {
+    winrt::check_hresult(m_textServices->TxSendMessage(
+        EM_SETEDITSTYLE, 0 /* disable */, SES_UPPERCASE /* flag affected */, nullptr /* LRESULT */));
+  }
+
+  if (newCapitalizationType == "characters") {
+    winrt::check_hresult(m_textServices->TxSendMessage(
+        EM_SETEDITSTYLE, SES_UPPERCASE /* enable */, SES_UPPERCASE /* flag affected */, nullptr /* LRESULT */));
+  }
+}
+
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -78,6 +78,8 @@ struct WindowsTextInputComponentView
 
   winrt::Microsoft::ReactNative::Composition::Experimental::IVisual createVisual() noexcept;
 
+  std::pair<facebook::react::Cursor, HCURSOR> cursor() const noexcept override;
+
  private:
   struct DrawBlock {
     DrawBlock(WindowsTextInputComponentView &view);
@@ -104,6 +106,10 @@ struct WindowsTextInputComponentView
   void InternalFinalize() noexcept;
   void UpdatePropertyBits() noexcept;
 
+  void autoCapitalizeOnUpdateProps(
+      const std::string &previousCapitalizationType,
+      const std::string &newcapitalizationType) noexcept;
+
   winrt::Windows::UI::Composition::CompositionSurfaceBrush m_brush{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::ICaretVisual m_caretVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::IDrawingSurfaceBrush m_drawingSurface{nullptr};
@@ -124,10 +130,12 @@ struct WindowsTextInputComponentView
   int m_cDrawBlock{0};
   bool m_needsRedraw{false};
   bool m_drawing{false};
+  bool m_hasFocus{false};
   bool m_clearTextOnSubmit{false};
   bool m_multiline{false};
   DWORD m_propBitsMask{0};
   DWORD m_propBits{0};
+  HCURSOR m_hcursor{nullptr};
   std::vector<facebook::react::CompWindowsTextInputSubmitKeyEventsStruct> m_submitKeyEvents;
 };
 

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

@@ -330,7 +330,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"AcrylicInAppFillColorDefault", {0x9E, 0xFF, 0xFF, 0xFF}},
           {"SystemChromeMediumLowColor", {0xFF, 0xF2, 0xF2, 0xF2}},
           {"SystemControlForegroundBaseHighColor", {0xFF, 0x00, 0x00, 0x00}},
-          {"SystemControlTransientBorderColor", {0x24, 0x00, 0x00, 0x00}}};
+          {"SystemControlTransientBorderColor", {0x24, 0x00, 0x00, 0x00}},
+          {"FocusVisualPrimary", {0xFF, 0x00, 0x00, 0x00}},
+          {"FocusVisualSecondary", {0x99, 0xFF, 0xFF, 0xFF}}};
 
   static std::unordered_map<std::string, winrt::Windows::UI::Color, std::hash<std::string_view>, std::equal_to<>>
       s_darkColors = {
@@ -362,7 +364,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"AcrylicInAppFillColorDefault", {0x9E, 0x00, 0x00, 0x00}},
           {"SystemChromeMediumLowColor", {0xFF, 0x2B, 0x2B, 0x2B}},
           {"SystemControlForegroundBaseHighColor", {0xFF, 0xFF, 0xFF, 0xFF}},
-          {"SystemControlTransientBorderColor", {0x5C, 0x00, 0x00, 0x00}}};
+          {"SystemControlTransientBorderColor", {0x5C, 0x00, 0x00, 0x00}},
+          {"FocusVisualPrimary", {0xFF, 0xFF, 0xFF, 0xFF}},
+          {"FocusVisualSecondary", {0x99, 0x00, 0x00, 0x00F}}};
 
   static std::unordered_map<
       std::string,
@@ -399,7 +403,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"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, {}}}};
+          {"SystemControlTransientBorderColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}},
+          {"FocusVisualPrimary", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}},
+          {"FocusVisualSecondary", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}}};
 
   auto alias = s_xamlAliasedColors.find(platformColor);
   if (alias != s_xamlAliasedColors.end()) {

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

@@ -214,4 +214,15 @@ ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept {
   }
 }
 
+ToggleState GetToggleState(const std::optional<facebook::react::AccessibilityState> &state) noexcept {
+  if (state.has_value()) {
+    if (state->checked == facebook::react::AccessibilityState::Checked) {
+      return ToggleState::ToggleState_On;
+    } else if (state->checked == facebook::react::AccessibilityState::Mixed) {
+      return ToggleState::ToggleState_Indeterminate;
+    }
+  }
+  return ToggleState::ToggleState_Off;
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -36,4 +36,6 @@ std::string extractAccessibilityValue(const facebook::react::AccessibilityValue
 void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept;
 
 ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept;
+
+ToggleState GetToggleState(const std::optional<facebook::react::AccessibilityState> &state) noexcept;
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -26,7 +26,7 @@ UnimplementedNativeViewComponentView::UnimplementedNativeViewComponentView(
               ~(ComponentViewFeatures::Background | ComponentViewFeatures::ShadowProps |
                 ComponentViewFeatures::NativeBorder)) {
   m_labelVisual = compContext.CreateSpriteVisual();
-  OuterVisual().InsertAt(m_labelVisual, 1);
+  OuterVisual().InsertAt(m_labelVisual, 0);
 }
 
 winrt::Microsoft::ReactNative::ComponentView UnimplementedNativeViewComponentView::Create(

package/Microsoft.ReactNative/IReactCompositionViewComponentBuilder.idl

@@ -25,6 +25,29 @@ namespace Microsoft.ReactNative.Composition
   [webhosthidden]
   delegate Microsoft.UI.Composition.Visual CreateVisualDelegate(Microsoft.ReactNative.ComponentView view);
 
+  [experimental]
+  delegate void UpdateLayoutMetricsDelegate(Microsoft.ReactNative.ComponentView source, Microsoft.ReactNative.LayoutMetrics newLayoutMetrics, Microsoft.ReactNative.LayoutMetrics oldLayoutMetrics);
+
+  [experimental]
+  [webhosthidden]
+  delegate Microsoft.UI.Composition.Visual VisualToMountChildrenIntoDelegate(Microsoft.ReactNative.ComponentView view);
+
+  namespace Experimental {
+    [experimental]
+    [webhosthidden]
+    DOC_STRING("This type will be removed in future versions")
+    delegate Microsoft.ReactNative.Composition.Experimental.IVisual IVisualToMountChildrenIntoDelegate(Microsoft.ReactNative.ComponentView view);
+
+    [experimental]
+    [webhosthidden]
+    DOC_STRING("This interface is for use when running react-native-windows using a custom compositor. "
+      "This interface will be removed in future versions")
+    interface IReactCompositionViewComponentInternalBuilder
+    {
+      void SetIVisualToMountChildrenIntoHandler(IVisualToMountChildrenIntoDelegate impl);
+    };
+  }
+
   [webhosthidden]
   [experimental]
   DOC_STRING(".")
@@ -33,6 +56,9 @@ namespace Microsoft.ReactNative.Composition
     void SetViewComponentViewInitializer(ViewComponentViewInitializer initializer);
     void SetContentIslandComponentViewInitializer(ComponentIslandComponentViewInitializer initializer);
     void SetCreateVisualHandler(CreateVisualDelegate impl);
+    void SetViewFeatures(ComponentViewFeatures viewFeatures);
+    void SetUpdateLayoutMetricsHandler(UpdateLayoutMetricsDelegate impl);
+    void SetVisualToMountChildrenIntoHandler(VisualToMountChildrenIntoDelegate impl);
   };
 
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/IReactViewComponentBuilder.idl

@@ -56,7 +56,7 @@ namespace Microsoft.ReactNative
 
   [experimental]
   DOC_STRING("A delegate that creates a @IComponentProps object for an instance of @ViewProps. See @IReactViewComponentBuilder.SetCreateProps")
-  delegate IComponentProps ViewPropsFactory(ViewProps props);
+  delegate IComponentProps ViewPropsFactory(ViewProps props, IComponentProps cloneFrom);
 
   [experimental]
   delegate Windows.Foundation.Size MeasureContentHandler(ShadowNode shadowNode, LayoutContext layoutContext, LayoutConstraints layoutConstraints);

package/Microsoft.ReactNative/ReactNativeAppBuilder.cpp

@@ -1,43 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
 #include "pch.h"
 #include "ReactNativeAppBuilder.h"
 #include "ReactNativeAppBuilder.g.cpp"
-#include "IReactDispatcher.h"
-#include "ReactNativeHost.h"
+
 #include "ReactNativeWin32App.h"
+
+#include "winrt/Microsoft.ReactNative.h"
 #include "winrt/Microsoft.UI.Composition.h"
 #include "winrt/Microsoft.UI.Dispatching.h"
+#include "winrt/Microsoft.UI.Interop.h"
 #include "winrt/Microsoft.UI.Windowing.h"
-#include "winrt/microsoft.UI.Interop.h"
-
-// Scaling factor for the window's content based on the DPI of the display where the window is located.
-float ScaleFactor(HWND hwnd) noexcept {
-  return GetDpiForWindow(hwnd) / static_cast<float>(USER_DEFAULT_SCREEN_DPI);
-}
-
-void UpdateRootViewSizeToAppWindow(
-    winrt::Microsoft::ReactNative::ReactNativeIsland const &rootView,
-    winrt::Microsoft::UI::Windowing::AppWindow const &window) {
-  auto hwnd = winrt::Microsoft::UI::GetWindowFromWindowId(window.Id());
-  auto scaleFactor = ScaleFactor(hwnd);
-  winrt::Windows::Foundation::Size size{
-      window.ClientSize().Width / scaleFactor, window.ClientSize().Height / scaleFactor};
-  // Do not relayout when minimized
-  if (window.Presenter().as<winrt::Microsoft::UI::Windowing::OverlappedPresenter>().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});
-  }
-}
-
-namespace winrt::ReactNative {
-using namespace winrt::Microsoft::ReactNative;
-}
-
-namespace winrt::UI {
-using namespace winrt::Microsoft::UI;
-}
 
 namespace winrt::Microsoft::ReactNative::implementation {
 ReactNativeAppBuilder::ReactNativeAppBuilder() {
@@ -46,133 +20,55 @@ ReactNativeAppBuilder::ReactNativeAppBuilder() {
 
 ReactNativeAppBuilder::~ReactNativeAppBuilder() {}
 
-winrt::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::AddPackageProviders(
-    winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::ReactNative::IReactPackageProvider> const
-        &packageProviders) {
-  for (auto const &provider : packageProviders) {
-    m_reactNativeWin32App.ReactNativeHost().PackageProviders().Append(provider);
-  }
-
-  return *this;
-}
-
-winrt::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetReactInstanceSettings(
-    winrt::Microsoft::ReactNative::ReactInstanceSettings const &settings) {
-  m_reactNativeWin32App.ReactNativeHost().InstanceSettings(settings);
-
+winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetDispatcherQueueController(
+    winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController) {
+  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController(
+      dispatcherQueueController);
   return *this;
 }
 
-winrt::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetCompositor(
+winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetCompositor(
     winrt::Microsoft::UI::Composition::Compositor const &compositor) {
   m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor(compositor);
   return *this;
 }
 
-winrt::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetAppWindow(
+winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetAppWindow(
     winrt::Microsoft::UI::Windowing::AppWindow const &appWindow) {
   m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->AppWindow(appWindow);
 
   return *this;
 }
 
-winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetReactViewOptions(
-    winrt::Microsoft::ReactNative::ReactViewOptions const &reactViewOptions) {
-  m_reactViewOptions = reactViewOptions;
+winrt::Microsoft::ReactNative::ReactNativeWin32App ReactNativeAppBuilder::Build() {
+  // Create the DispatcherQueueController if the app developer doesn't provide one
+  if (m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController() == nullptr) {
+    assert(m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor() == nullptr);
 
-  return *this;
-}
-
-winrt::ReactNative::ReactNativeWin32App ReactNativeAppBuilder::Build() {
-  if (m_reactNativeWin32App.Compositor() == nullptr) {
-    // Create a DispatcherQueue for this thread.  This is needed for Composition, Content, and
-    // Input APIs.
+    // Create a DispatcherQueue for this thread. This is needed for Composition, Content, and Input APIs.
     auto dispatcherQueueController =
         winrt::Microsoft::UI::Dispatching::DispatcherQueueController::CreateOnCurrentThread();
 
-    m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatchQueueController(
+    m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController(
         dispatcherQueueController);
+  }
 
-    // Create the compositor on behalf of the App Developer
+  // Create the Compositor if the app developer doesn't provide one
+  if (m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor() == nullptr) {
+    // Create the compositor on behalf of the App Developer.
     auto compositor = winrt::Microsoft::UI::Composition::Compositor();
     m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor(compositor);
   }
 
-  // Create the AppWindow if the developer doesn't provide one
+  // Create the AppWindow if the app developer doesn't provide one
   if (m_reactNativeWin32App.AppWindow() == nullptr) {
     auto appWindow = winrt::Microsoft::UI::Windowing::AppWindow::Create();
-    appWindow.Title(L"SampleApplication");
+    appWindow.Title(L"ReactNativeWin32App");
     appWindow.Resize({1000, 1000});
-    appWindow.Show();
 
     m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->AppWindow(appWindow);
   }
 
-  // Currently set the property to use current thread dispatcher as a default UI dispatcher.
-  // TODO: Provision for setting dispatcher based on the thread dispatcherQueueController is created.
-  m_reactNativeWin32App.ReactNativeHost().InstanceSettings().Properties().Set(
-      ReactDispatcherHelper::UIDispatcherProperty(), ReactDispatcherHelper::UIThreadDispatcher());
-
-  auto hwnd{winrt::UI::GetWindowFromWindowId(m_reactNativeWin32App.AppWindow().Id())};
-
-  winrt::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
-      m_reactNativeWin32App.ReactNativeHost().InstanceSettings().Properties(), reinterpret_cast<uint64_t>(hwnd));
-
-  winrt::ReactNative::Composition::CompositionUIService::SetCompositor(
-      m_reactNativeWin32App.ReactNativeHost().InstanceSettings(), m_reactNativeWin32App.Compositor());
-
-  // Start the react-native instance, which will create a JavaScript runtime and load the applications bundle.
-  m_reactNativeWin32App.ReactNativeHost().ReloadInstance();
-
-  // Create a RootView which will present a react-native component
-  auto reactNativeIsland = winrt::Microsoft::ReactNative::ReactNativeIsland(m_reactNativeWin32App.Compositor());
-  reactNativeIsland.ReactViewHost(winrt::Microsoft::ReactNative::ReactCoreInjection::MakeViewHost(
-      m_reactNativeWin32App.ReactNativeHost(), m_reactViewOptions));
-
-  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->ReactNativeIsland(
-      std::move(reactNativeIsland));
-
-  // Update the size of the RootView when the AppWindow changes size
-  m_reactNativeWin32App.AppWindow().Changed(
-      [wkRootView = winrt::make_weak(m_reactNativeWin32App.ReactNativeIsland())](
-          winrt::Microsoft::UI::Windowing::AppWindow const &window,
-          winrt::Microsoft::UI::Windowing::AppWindowChangedEventArgs const &args) {
-        if (args.DidSizeChange() || args.DidVisibilityChange()) {
-          if (auto rootView = wkRootView.get()) {
-            UpdateRootViewSizeToAppWindow(rootView, window);
-          }
-        }
-      });
-
-  // Quit application when main window is closed
-  m_reactNativeWin32App.AppWindow().Destroying([this](
-                                                   winrt::Microsoft::UI::Windowing::AppWindow const &window,
-                                                   winrt::Windows::Foundation::IInspectable const & /*args*/) {
-    // Before we shutdown the application - unload the ReactNativeHost to give the javascript a chance to save any
-    // state
-    auto async = m_reactNativeWin32App.ReactNativeHost().UnloadInstance();
-    async.Completed([this](auto asyncInfo, winrt::Windows::Foundation::AsyncStatus asyncStatus) {
-      assert(asyncStatus == winrt::Windows::Foundation::AsyncStatus::Completed);
-      m_reactNativeWin32App.ReactNativeHost().InstanceSettings().UIDispatcher().Post([]() { PostQuitMessage(0); });
-    });
-  });
-
-  // DesktopChildSiteBridge create a ContentSite that can host the RootView ContentIsland
-  auto desktopChildSiteBridge = winrt::Microsoft::UI::Content::DesktopChildSiteBridge::Create(
-      m_reactNativeWin32App.Compositor(), m_reactNativeWin32App.AppWindow().Id());
-
-  desktopChildSiteBridge.Connect(m_reactNativeWin32App.ReactNativeIsland().Island());
-
-  desktopChildSiteBridge.ResizePolicy(winrt::Microsoft::UI::Content::ContentSizePolicy::ResizeContentToParentWindow);
-
-  auto scaleFactor = ScaleFactor(hwnd);
-  m_reactNativeWin32App.ReactNativeIsland().ScaleFactor(scaleFactor);
-
-  UpdateRootViewSizeToAppWindow(reactNativeIsland, m_reactNativeWin32App.AppWindow());
-
-  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DesktopChildSiteBridge(
-      std::move(desktopChildSiteBridge));
-
   return m_reactNativeWin32App;
 }
 

package/Microsoft.ReactNative/ReactNativeAppBuilder.h

@@ -1,6 +1,8 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
 #pragma once
+
 #include "ReactNativeAppBuilder.g.h"
-#include <winrt/Microsoft.UI.Content.h>
 
 namespace winrt::Microsoft::ReactNative::implementation {
 struct ReactNativeAppBuilder : ReactNativeAppBuilderT<ReactNativeAppBuilder> {
@@ -8,25 +10,15 @@ struct ReactNativeAppBuilder : ReactNativeAppBuilderT<ReactNativeAppBuilder> {
 
   ~ReactNativeAppBuilder();
 
-  winrt::Microsoft::ReactNative::ReactNativeAppBuilder AddPackageProviders(
-      winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::ReactNative::IReactPackageProvider> const
-          &packageProviders);
-  winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetReactInstanceSettings(
-      winrt::Microsoft::ReactNative::ReactInstanceSettings const &settings);
-
-  // TODO: Currently, SetCompositor API is not exposed to the developer.
-  // Compositor depends on the DispatcherQueue created by DispatcherQueueController on a current thread
-  // or dedicated thread. So we also have to make a provision for setting DispatcherQueueController.
+  winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetDispatcherQueueController(
+      winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController);
   winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetCompositor(
       winrt::Microsoft::UI::Composition::Compositor const &compositor);
   winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetAppWindow(
       winrt::Microsoft::UI::Windowing::AppWindow const &appWindow);
-  winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetReactViewOptions(
-      winrt::Microsoft::ReactNative::ReactViewOptions const &reactViewOptions);
   winrt::Microsoft::ReactNative::ReactNativeWin32App Build();
 
  private:
-  winrt::Microsoft::ReactNative::ReactViewOptions m_reactViewOptions{};
   winrt::Microsoft::ReactNative::ReactNativeWin32App m_reactNativeWin32App{nullptr};
 };
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactNativeAppBuilder.idl

@@ -9,60 +9,39 @@ import "IReactPackageProvider.idl";
 namespace Microsoft.ReactNative {
 
      [experimental]
-     DOC_STRING("ReactNativeWin32App is used to manage resources appropriately to be able to host ReactNative component in a contentIsland.")
+     DOC_STRING("ReactNativeWin32App sets up the infrastructure for the default experience of a ReactNative application filling a WinAppSDK window.")
      runtimeclass ReactNativeWin32App {
         // Properties
         Microsoft.UI.Windowing.AppWindow AppWindow {get;};
 
-        Microsoft.UI.Composition.Compositor Compositor {get;};
-
-        Microsoft.UI.Content.DesktopChildSiteBridge DesktopChildSiteBridge {get;};
-
         ReactNativeHost ReactNativeHost {get;};
 
-        ReactNativeIsland ReactNativeIsland {get;};
+        ReactViewOptions ReactViewOptions {get;};
+
+        // TODO: Hide these APIs for now until we're sure we need to expose them and can do so safely
+        // Microsoft.UI.Composition.Compositor Compositor {get;};
+        // Microsoft.UI.Content.DesktopChildSiteBridge DesktopChildSiteBridge {get;};
+        // Microsoft.UI.Dispatching DispatcherQueueController {get;};
+        // ReactNativeIsland ReactNativeIsland {get;};
 
         // Methods
         void Start();
      }
 
     [experimental]
-    DOC_STRING("This is the builder for creating ReactInstanceSettings.")
-    runtimeclass ReactInstanceSettingsBuilder
-    {
-        ReactInstanceSettingsBuilder();
-
-        // Properties
-        ReactInstanceSettings ReactInstanceSettings {get;};
-
-        // Methods
-        ReactInstanceSettingsBuilder UseDirectDebugger(Boolean state);
-
-        ReactInstanceSettingsBuilder UseDeveloperSupport(Boolean state);
-    
-        ReactInstanceSettingsBuilder BundleRootPath(String path);
-
-        ReactInstanceSettingsBuilder DebugBundlePath(String path);
-
-        ReactInstanceSettingsBuilder JavaScriptBundleFile(String file);
-
-        ReactInstanceSettingsBuilder UseFastRefresh(Boolean state);
-    }
-
-    [experimental]
-    DOC_STRING("ReactNativeAppBuilder initializes all the required infrastructure for a Win32 Fabric Application.")
+    DOC_STRING("ReactNativeAppBuilder builds a ReactNativeWin32App with the base WinAppSDK infrastructure.")
     runtimeclass ReactNativeAppBuilder
     {
         ReactNativeAppBuilder();
 
         // Methods
-        ReactNativeAppBuilder AddPackageProviders(Windows.Foundation.Collections.IVector<Microsoft.ReactNative.IReactPackageProvider> packageProviders);
-
-        ReactNativeAppBuilder SetReactInstanceSettings(ReactInstanceSettings settings);
 
         ReactNativeAppBuilder SetAppWindow(Microsoft.UI.Windowing.AppWindow appWindow);
 
-        ReactNativeAppBuilder SetReactViewOptions(Microsoft.ReactNative.ReactViewOptions reactViewOptions);
+        // TODO: Hide these APIs for now until we're sure we need to expose them and can do so safely
+        // Compositor depends on the DispatcherQueue created by DispatcherQueueController
+        // ReactNativeAppBuilder SetCompositor(Microsoft.UI.Composition.Compositor compositor);
+        // ReactNativeAppBuilder SetDispatcherQueueController(Microsoft.UI.Dispatching DispatcherQueueController);
 
         ReactNativeWin32App Build();
     }

package/Microsoft.ReactNative/ReactNativeIsland.idl

@@ -78,11 +78,12 @@ namespace Microsoft.ReactNative
   DOC_STRING("A windows composition component that hosts React Native UI elements.")
   runtimeclass ReactNativeIsland
   {
-    DOC_STRING("Creates a new instance of @ReactNativeIsland.")
+    DOC_STRING("Creates a new instance of @ReactNativeIsland. Can be implemented with a ReactViewHost or a ComponentView with reactContext")
     ReactNativeIsland();
 
 #ifdef USE_WINUI3
     ReactNativeIsland(Microsoft.UI.Composition.Compositor compositor);
+    ReactNativeIsland(Microsoft.UI.Composition.Compositor compositor, Microsoft.ReactNative.IReactContext context, Microsoft.ReactNative.ComponentView componentView);
 #endif
 
     DOC_STRING(
@@ -97,7 +98,7 @@ namespace Microsoft.ReactNative
 
     DOC_STRING("ScaleFactor for this windows (DPI/96)")
     Single ScaleFactor {get; set;};
-
+  
     Single FontSizeMultiplier { get; };
 
     DOC_STRING("Move focus to this @ReactNativeIsland")