react-native-windows 0.73.11 → 0.74.0-preview.2

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

@@ -5,29 +5,44 @@
 #include "CompositionRootView.g.cpp"
 #include "FocusNavigationRequest.g.cpp"
 
+#include <AutoDraw.h>
 #include <DynamicWriter.h>
 #include <Fabric/FabricUIManagerModule.h>
 #include <IReactInstance.h>
 #include <Modules/ReactRootViewTagGenerator.h>
 #include <QuirkSettings.h>
 #include <ReactHost/MsoUtils.h>
+#include <ReactPropertyBag.h>
 #include <Utils/Helpers.h>
 #include <dispatchQueue/dispatchQueue.h>
+#include <eventWaitHandle/eventWaitHandle.h>
+#include <react/renderer/attributedstring/AttributedStringBox.h>
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/core/LayoutContext.h>
+#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+#include <winrt/Microsoft.ReactNative.h>
 #include <winrt/Windows.UI.Core.h>
 #include "CompositionContextHelper.h"
 #include "CompositionHelpers.h"
+#include "CompositionRootAutomationProvider.h"
+#include "CompositionUIService.h"
 #include "ReactNativeHost.h"
 #include "RootComponentView.h"
+#include "TextDrawing.h"
 
 #ifdef USE_WINUI3
 #include <winrt/Microsoft.UI.Content.h>
-#include "CompositionRootAutomationProvider.h"
 #endif
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
+constexpr float loadingActivitySize = 12.0f;
+constexpr float loadingActivityHorizontalOffset = 16.0f;
+constexpr float loadingBarHeight = 36.0f;
+constexpr float loadingBarFontSize = 20.0f;
+constexpr float loadingTextHorizontalOffset = 48.0f;
+
 //! This class ensures that we access ReactRootView from UI thread.
 struct CompositionReactViewInstance
     : public winrt::implements<CompositionReactViewInstance, winrt::Microsoft::ReactNative::IReactViewInstance> {
@@ -61,21 +76,28 @@ void CompositionReactViewInstance::InitRootView(
                        .Get(winrt::Microsoft::ReactNative::ReactDispatcherHelper::UIDispatcherProperty())
                        .try_as<IReactDispatcher>();
 
-  PostInUIQueue([context{std::move(context)}, viewOptions{std::move(viewOptions)}](
-                    winrt::com_ptr<winrt::Microsoft::ReactNative::implementation::CompositionRootView>
-                        &rootControl) mutable noexcept {
+  assert(m_uiDispatcher.HasThreadAccess());
+  if (auto rootControl = m_weakRootControl.get()) {
     rootControl->InitRootView(std::move(context), std::move(viewOptions));
-  });
+  }
 }
 
 void CompositionReactViewInstance::UpdateRootView() noexcept {
-  PostInUIQueue([](winrt::com_ptr<winrt::Microsoft::ReactNative::implementation::CompositionRootView>
-                       &rootControl) mutable noexcept { rootControl->UpdateRootView(); });
+  assert(m_uiDispatcher.HasThreadAccess());
+  if (auto rootControl = m_weakRootControl.get()) {
+    rootControl->UpdateRootView();
+  }
 }
 
 void CompositionReactViewInstance::UninitRootView() noexcept {
-  PostInUIQueue([](winrt::com_ptr<winrt::Microsoft::ReactNative::implementation::CompositionRootView>
-                       &rootControl) mutable noexcept { rootControl->UninitRootView(); });
+  // m_uiDispatcher will not be initialized if InitRootView has not been run in which case we do not need to run
+  // UninitRootView
+  if (m_uiDispatcher) {
+    assert(m_uiDispatcher.HasThreadAccess());
+    if (auto rootControl = m_weakRootControl.get()) {
+      rootControl->UninitRootView();
+    }
+  }
 }
 
 //===========================================================================
@@ -137,15 +159,52 @@ void CompositionRootView::RootVisual(winrt::Microsoft::ReactNative::Composition:
   if (m_rootVisual != value) {
     assert(!m_rootVisual);
     m_rootVisual = value;
+    UpdateRootVisualSize();
   }
 }
 
+void CompositionRootView::AddRenderedVisual(
+    const winrt::Microsoft::ReactNative::Composition::IVisual &visual) noexcept {
+  assert(!m_hasRenderedVisual);
+  RootVisual().InsertAt(visual, 0);
+  m_hasRenderedVisual = true;
+}
+
+void CompositionRootView::RemoveRenderedVisual(
+    const winrt::Microsoft::ReactNative::Composition::IVisual &visual) noexcept {
+  assert(m_hasRenderedVisual);
+  RootVisual().Remove(visual);
+  m_hasRenderedVisual = false;
+}
+
 winrt::Windows::Foundation::Size CompositionRootView::Size() noexcept {
   return m_size;
 }
 
 void CompositionRootView::Size(winrt::Windows::Foundation::Size value) noexcept {
   m_size = value;
+  UpdateRootVisualSize();
+}
+
+void CompositionRootView::UpdateRootVisualSize() noexcept {
+  if (m_rootVisual)
+    m_rootVisual.Size({m_size.Width * m_scaleFactor, m_size.Height * m_scaleFactor});
+
+  UpdateLoadingVisualSize();
+}
+
+void CompositionRootView::UpdateLoadingVisualSize() noexcept {
+  if (m_loadingVisual) {
+    auto drawingSurface = CreateLoadingVisualBrush();
+    m_loadingVisual.Brush(drawingSurface);
+    m_loadingVisual.Offset({0.0f, -(loadingBarHeight * m_scaleFactor / 2.0f), 0.0f}, {0.0f, 0.5f, 0.0f});
+    m_loadingVisual.Size({m_size.Width * m_scaleFactor, loadingBarHeight * m_scaleFactor});
+    m_loadingActivityVisual.Size(loadingActivitySize * m_scaleFactor);
+    const float loadingActivityVerticalOffset = ((loadingBarHeight - (loadingActivitySize * 2)) * m_scaleFactor) / 2;
+
+    m_loadingActivityVisual.Offset(
+        {loadingActivityHorizontalOffset * m_scaleFactor, loadingActivityVerticalOffset, 0.0f});
+  }
 }
 
 float CompositionRootView::ScaleFactor() noexcept {
@@ -153,19 +212,78 @@ float CompositionRootView::ScaleFactor() noexcept {
 }
 
 void CompositionRootView::ScaleFactor(float value) noexcept {
-  m_scaleFactor = value;
+  if (m_scaleFactor != value) {
+    m_scaleFactor = value;
+    UpdateRootVisualSize();
+  }
 }
 
-winrt::IInspectable CompositionRootView::GetUiaProvider() noexcept {
-  auto componentView = GetComponentView();
-  if (componentView == nullptr)
-    return nullptr;
+winrt::Microsoft::ReactNative::Composition::Theme CompositionRootView::Theme() noexcept {
+  if (!m_theme) {
+    Theme(winrt::Microsoft::ReactNative::Composition::Theme::GetDefaultTheme(m_context.Handle()));
+    m_themeChangedSubscription = m_context.Notifications().Subscribe(
+        winrt::Microsoft::ReactNative::ReactNotificationId<void>(
+            winrt::Microsoft::ReactNative::Composition::Theme::ThemeChangedEventName()),
+        m_context.UIDispatcher(),
+        [wkThis = get_weak()](
+            IInspectable const & /*sender*/,
+            winrt::Microsoft::ReactNative::ReactNotificationArgs<void> const & /*args*/) {
+          auto pThis = wkThis.get();
+          pThis->Theme(winrt::Microsoft::ReactNative::Composition::Theme::GetDefaultTheme(pThis->m_context.Handle()));
+        });
+  }
+  return m_theme;
+}
+
+void CompositionRootView::Theme(const winrt::Microsoft::ReactNative::Composition::Theme &value) noexcept {
+  if (m_themeChangedSubscription) {
+    m_themeChangedSubscription.Unsubscribe();
+    m_themeChangedSubscription = nullptr;
+  }
 
-  return componentView->EnsureUiaProvider();
+  if (value == m_theme)
+    return;
+
+  m_theme = value;
+
+  m_themeChangedRevoker = m_theme.ThemeChanged(
+      winrt::auto_revoke,
+      [this](
+          const winrt::Windows::Foundation::IInspectable & /*sender*/,
+          const winrt::Windows::Foundation::IInspectable & /*args*/) {
+        if (auto rootView = GetComponentView()) {
+          Mso::Functor<bool(const winrt::Microsoft::ReactNative::ComponentView &)> fn =
+              [](const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+                winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(view)->onThemeChanged();
+                return false;
+              };
+
+          winrt::Microsoft::ReactNative::ComponentView view{nullptr};
+          winrt::check_hresult(rootView->QueryInterface(
+              winrt::guid_of<winrt::Microsoft::ReactNative::ComponentView>(), winrt::put_abi(view)));
+          walkTree(view, true, fn);
+        }
+      });
+
+  if (auto rootView = GetComponentView()) {
+    rootView->theme(winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::Theme>(value));
+  }
 }
 
-winrt::Microsoft::ReactNative::Composition::IVisual CompositionRootView::GetVisual() const noexcept {
-  return m_rootVisual;
+winrt::IInspectable CompositionRootView::GetUiaProvider() noexcept {
+  if (m_uiaProvider == nullptr) {
+    m_uiaProvider =
+        winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionRootAutomationProvider>(*this);
+    if (m_hwnd) {
+      auto pRootProvider =
+          static_cast<winrt::Microsoft::ReactNative::implementation::CompositionRootAutomationProvider *>(
+              m_uiaProvider.as<IRawElementProviderSimple>().get());
+      if (pRootProvider != nullptr) {
+        pRootProvider->SetHwnd(m_hwnd);
+      }
+    }
+  }
+  return m_uiaProvider;
 }
 
 std::string CompositionRootView::JSComponentName() const noexcept {
@@ -188,12 +306,19 @@ void CompositionRootView::SetTag(int64_t tag) noexcept {
   m_rootTag = tag;
 }
 
+void CompositionRootView::SetWindow(uint64_t hwnd) noexcept {
+  m_hwnd = reinterpret_cast<HWND>(hwnd);
+}
+
 int64_t CompositionRootView::SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept {
   if (m_rootTag == -1)
     return 0;
 
+  // SetWindow must be called when not using ContentIsland hosting
+  assert(m_hwnd);
+
   if (m_CompositionEventHandler) {
-    auto result = m_CompositionEventHandler->SendMessage(msg, wParam, lParam);
+    auto result = m_CompositionEventHandler->SendMessage(m_hwnd, msg, wParam, lParam);
     if (result)
       return result;
   }
@@ -201,6 +326,27 @@ int64_t CompositionRootView::SendMessage(uint32_t msg, uint64_t wParam, int64_t
   return 0;
 }
 
+bool CompositionRootView::CapturePointer(
+    const winrt::Microsoft::ReactNative::Composition::Input::Pointer &pointer,
+    facebook::react::Tag tag) noexcept {
+  if (m_hwnd) {
+    SetCapture(m_hwnd);
+  }
+  return m_CompositionEventHandler->CapturePointer(pointer, tag);
+}
+
+void CompositionRootView::ReleasePointerCapture(
+    const winrt::Microsoft::ReactNative::Composition::Input::Pointer &pointer,
+    facebook::react::Tag tag) noexcept {
+  if (m_CompositionEventHandler->ReleasePointerCapture(pointer, tag)) {
+    if (m_hwnd) {
+      if (m_hwnd == GetCapture()) {
+        ReleaseCapture();
+      }
+    }
+  }
+}
+
 void CompositionRootView::InitRootView(
     winrt::Microsoft::ReactNative::IReactContext &&context,
     winrt::Microsoft::ReactNative::ReactViewOptions &&viewOptions) noexcept {
@@ -262,7 +408,12 @@ void CompositionRootView::UninitRootView() noexcept {
         winrt::Microsoft::ReactNative::ReactPropertyBag(m_context.Properties()));
     uiManager->stopSurface(static_cast<facebook::react::SurfaceId>(GetTag()));
 
-    m_context.CallJSFunction(L"ReactFabric", L"unmountComponentAtNode", GetTag());
+    // This is needed to ensure that the unmount JS logic is completed before the the instance is shutdown during
+    // instance destruction. Aligns with similar code in ReactInstanceWin::DetachRootView for paper Future: Instead this
+    // method should return a Promise, which should be resolved when the JS logic is complete.
+    Mso::ManualResetEvent mre;
+    m_context.JSDispatcher().Post([&]() { mre.Set(); });
+    mre.Wait();
 
     // Paper version gives the JS thread time to finish executing - Is this needed?
     // m_jsMessageThread.Load()->runOnQueueSync([]() {});
@@ -275,7 +426,15 @@ void CompositionRootView::UninitRootView() noexcept {
   m_isInitialized = false;
 }
 
-void CompositionRootView::ClearLoadingUI() noexcept {}
+void CompositionRootView::ClearLoadingUI() noexcept {
+  if (!m_loadingVisual)
+    return;
+
+  RootVisual().Remove(m_loadingVisual);
+
+  m_loadingVisual = nullptr;
+  m_loadingActivityVisual = nullptr;
+}
 
 void CompositionRootView::EnsureLoadingUI() noexcept {}
 
@@ -288,20 +447,103 @@ void CompositionRootView::ShowInstanceLoaded() noexcept {
 
     auto rootTag = ::Microsoft::ReactNative::getNextRootViewTag();
     SetTag(rootTag);
-    uiManager->startSurface(
-        this, rootTag, JSComponentName(), DynamicWriter::ToDynamic(Mso::Copy(m_reactViewOptions.InitialProps())));
+    auto initProps = DynamicWriter::ToDynamic(Mso::Copy(m_reactViewOptions.InitialProps()));
+    if (initProps.isNull()) {
+      initProps = folly::dynamic::object();
+    }
+    initProps["concurrentRoot"] = true;
+    uiManager->startSurface(*this, rootTag, JSComponentName(), initProps);
 
     m_isJSViewAttached = true;
   }
 }
 
-void CompositionRootView::ShowInstanceError() noexcept {}
+void CompositionRootView::ShowInstanceError() noexcept {
+  ClearLoadingUI();
+}
+
+Composition::IDrawingSurfaceBrush CompositionRootView::CreateLoadingVisualBrush() noexcept {
+  auto compContext =
+      winrt::Microsoft::ReactNative::Composition::implementation::CompositionUIService::GetCompositionContext(
+          m_context.Properties().Handle());
+
+  winrt::Windows::Foundation::Size surfaceSize = {
+      m_size.Width * m_scaleFactor, std::min(m_size.Height, loadingBarHeight) * m_scaleFactor};
+  auto drawingSurface = compContext.CreateDrawingSurfaceBrush(
+      surfaceSize,
+      winrt::Windows::Graphics::DirectX::DirectXPixelFormat::B8G8R8A8UIntNormalized,
+      winrt::Windows::Graphics::DirectX::DirectXAlphaMode::Premultiplied);
+
+  POINT offset;
+  {
+    ::Microsoft::ReactNative::Composition::AutoDrawDrawingSurface autoDraw(drawingSurface, &offset);
+    if (auto d2dDeviceContext = autoDraw.GetRenderTarget()) {
+      d2dDeviceContext->Clear(D2D1::ColorF(D2D1::ColorF::Green));
+
+      facebook::react::LayoutConstraints constraints;
+      constraints.maximumSize.width = std::max(0.0f, m_size.Width - loadingTextHorizontalOffset);
+      constraints.maximumSize.height = std::max(0.0f, m_size.Height - loadingBarHeight);
+
+      auto attributedString = facebook::react::AttributedString{};
+      auto fragment = facebook::react::AttributedString::Fragment{};
+      fragment.string = "Loading";
+      fragment.textAttributes.fontSize = loadingBarFontSize;
+      attributedString.appendFragment(fragment);
+      auto attributedStringBox = facebook::react::AttributedStringBox{attributedString};
+
+      auto textAttributes = facebook::react::TextAttributes{};
+      textAttributes.foregroundColor = facebook::react::whiteColor();
+
+      winrt::com_ptr<::IDWriteTextLayout> textLayout;
+      facebook::react::TextLayoutManager::GetTextLayout(
+          attributedStringBox, {} /*paragraphAttributes*/, constraints, textLayout);
+
+      DWRITE_TEXT_METRICS tm;
+      textLayout->GetMetrics(&tm);
+      const float textVerticalOffsetWithinLoadingBar = ((loadingBarHeight - tm.height) * m_scaleFactor) / 2;
+
+      auto theme = winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::Theme>(Theme());
+
+      Composition::RenderText(
+          *d2dDeviceContext,
+          *textLayout,
+          attributedStringBox.getValue(),
+          textAttributes,
+          {static_cast<float>(offset.x + (loadingTextHorizontalOffset * m_scaleFactor)),
+           static_cast<float>(offset.y + textVerticalOffsetWithinLoadingBar)},
+          m_scaleFactor,
+          *theme);
+    }
+  }
+
+  return drawingSurface;
+}
 
 void CompositionRootView::ShowInstanceLoading() noexcept {
   if (!Mso::React::ReactOptions::UseDeveloperSupport(m_context.Properties().Handle()))
     return;
 
-  // TODO: Show loading UI here
+  if (m_loadingVisual)
+    return;
+
+  auto compContext =
+      winrt::Microsoft::ReactNative::Composition::implementation::CompositionUIService::GetCompositionContext(
+          m_context.Properties().Handle());
+
+  auto drawingSurface = CreateLoadingVisualBrush();
+
+  m_loadingVisual = compContext.CreateSpriteVisual();
+  m_loadingVisual.Brush(drawingSurface);
+
+  auto foregroundBrush = compContext.CreateColorBrush({255, 255, 255, 255});
+
+  m_loadingActivityVisual = compContext.CreateActivityVisual();
+  m_loadingActivityVisual.Brush(foregroundBrush);
+  m_loadingVisual.InsertAt(m_loadingActivityVisual, 0);
+
+  UpdateLoadingVisualSize();
+
+  RootVisual().InsertAt(m_loadingVisual, m_hasRenderedVisual ? 1 : 0);
 }
 
 winrt::Windows::Foundation::Size CompositionRootView::Measure(
@@ -374,7 +616,6 @@ winrt::Microsoft::UI::Content::ContentIsland CompositionRootView::Island() noexc
 
   if (!m_island) {
     auto rootVisual = m_compositor.CreateSpriteVisual();
-    rootVisual.RelativeSizeAdjustment({1, 1});
 
     RootVisual(winrt::Microsoft::ReactNative::Composition::MicrosoftCompositionContextHelper::CreateVisual(rootVisual));
     m_island = winrt::Microsoft::UI::Content::ContentIsland::Create(rootVisual);
@@ -398,15 +639,19 @@ winrt::Microsoft::UI::Content::ContentIsland CompositionRootView::Island() noexc
 }
 #endif
 
-::Microsoft::ReactNative::RootComponentView *CompositionRootView::GetComponentView() noexcept {
-  if (!m_context || m_context.Handle().LoadingState() != winrt::Microsoft::ReactNative::LoadingState::Loaded)
+winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *
+CompositionRootView::GetComponentView() noexcept {
+  if (!m_context || m_context.Handle().LoadingState() != winrt::Microsoft::ReactNative::LoadingState::Loaded ||
+      m_rootTag == -1)
     return nullptr;
 
   if (auto fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
           winrt::Microsoft::ReactNative::ReactPropertyBag(m_context.Properties()))) {
     auto rootComponentViewDescriptor = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(
         static_cast<facebook::react::SurfaceId>(m_rootTag));
-    return static_cast<::Microsoft::ReactNative::RootComponentView *>(rootComponentViewDescriptor.view.get());
+    return rootComponentViewDescriptor.view
+        .as<winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView>()
+        .get();
   }
   return nullptr;
 }

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

@@ -64,20 +64,32 @@ struct CompositionRootView : CompositionRootViewT<CompositionRootView>, ::Micros
   float ScaleFactor() noexcept;
   void ScaleFactor(float value) noexcept;
 
+  void AddRenderedVisual(const winrt::Microsoft::ReactNative::Composition::IVisual &visual) noexcept;
+  void RemoveRenderedVisual(const winrt::Microsoft::ReactNative::Composition::IVisual &visual) noexcept;
+
+  winrt::Microsoft::ReactNative::Composition::Theme Theme() noexcept;
+  void Theme(const winrt::Microsoft::ReactNative::Composition::Theme &value) noexcept;
+
   winrt::Windows::Foundation::Size Measure(winrt::Windows::Foundation::Size const &availableSize) const;
   winrt::Windows::Foundation::Size Arrange(winrt::Windows::Foundation::Size finalSize) const;
 
   winrt::Microsoft::ReactNative::FocusNavigationResult NavigateFocus(
       const winrt::Microsoft::ReactNative::FocusNavigationRequest &request) noexcept;
 
-  ::Microsoft::ReactNative::RootComponentView *GetComponentView() noexcept;
+  winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *GetComponentView() noexcept;
 
   IInspectable GetUiaProvider() noexcept;
 
+  // When driving the rootview without an island
+  void SetWindow(uint64_t hwnd) noexcept;
   int64_t SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept;
 
- public: // ICompositionRootView
-  winrt::Microsoft::ReactNative::Composition::IVisual GetVisual() const noexcept override;
+  bool CapturePointer(
+      const winrt::Microsoft::ReactNative::Composition::Input::Pointer &pointer,
+      facebook::react::Tag tag) noexcept;
+  void ReleasePointerCapture(
+      const winrt::Microsoft::ReactNative::Composition::Input::Pointer &pointer,
+      facebook::react::Tag tag) noexcept;
 
  public: // IReactRootView
   std::string JSComponentName() const noexcept override;
@@ -99,9 +111,13 @@ struct CompositionRootView : CompositionRootViewT<CompositionRootView>, ::Micros
   winrt::Microsoft::UI::Content::ContentIsland m_island{nullptr};
 #endif
 
+  HWND m_hwnd{0};
   bool m_isInitialized{false};
   bool m_isJSViewAttached{false};
+  bool m_hasRenderedVisual{false};
+  bool m_showingLoadingUI{false};
   IReactDispatcher m_uiDispatcher{nullptr};
+  winrt::IInspectable m_uiaProvider{nullptr};
   int64_t m_rootTag{-1};
   float m_scaleFactor{1.0};
   winrt::Windows::Foundation::Size m_size;
@@ -110,12 +126,21 @@ struct CompositionRootView : CompositionRootViewT<CompositionRootView>, ::Micros
   winrt::Microsoft::ReactNative::ReactViewOptions m_reactViewOptions;
   std::shared_ptr<::Microsoft::ReactNative::CompositionEventHandler> m_CompositionEventHandler;
   winrt::Microsoft::ReactNative::Composition::IVisual m_rootVisual{nullptr};
+  winrt::Microsoft::ReactNative::Composition::ISpriteVisual m_loadingVisual{nullptr};
+  winrt::Microsoft::ReactNative::Composition::IActivityVisual m_loadingActivityVisual{nullptr};
+  winrt::Microsoft::ReactNative::Composition::Theme m_theme{nullptr};
+  winrt::Microsoft::ReactNative::ReactNotificationSubscription m_themeChangedSubscription{nullptr};
+  winrt::Microsoft::ReactNative::Composition::Theme::ThemeChanged_revoker m_themeChangedRevoker;
+
   void UpdateRootViewInternal() noexcept;
   void ClearLoadingUI() noexcept;
   void EnsureLoadingUI() noexcept;
   void ShowInstanceLoaded() noexcept;
   void ShowInstanceError() noexcept;
   void ShowInstanceLoading() noexcept;
+  void UpdateRootVisualSize() noexcept;
+  void UpdateLoadingVisualSize() noexcept;
+  Composition::IDrawingSurfaceBrush CreateLoadingVisualBrush() noexcept;
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -53,11 +53,12 @@ float CompositionRootView::ScaleFactor() noexcept {
 
 void CompositionRootView::ScaleFactor(float) noexcept {}
 
-winrt::IInspectable CompositionRootView::GetUiaProvider() noexcept {
+winrt::Microsoft::ReactNative::Composition::Theme CompositionRootView::Theme() noexcept {
   return nullptr;
 }
+void CompositionRootView::Theme(const winrt::Microsoft::ReactNative::Composition::Theme &) noexcept {}
 
-winrt::Microsoft::ReactNative::Composition::IVisual CompositionRootView::GetVisual() const noexcept {
+winrt::IInspectable CompositionRootView::GetUiaProvider() noexcept {
   return nullptr;
 }
 
@@ -79,6 +80,8 @@ int64_t CompositionRootView::GetTag() const noexcept {
 
 void CompositionRootView::SetTag(int64_t) noexcept {}
 
+void CompositionRootView::SetWindow(uint64_t) noexcept {}
+
 int64_t CompositionRootView::SendMessage(uint32_t, uint64_t, int64_t) noexcept {
   return 0;
 }
@@ -111,7 +114,8 @@ Windows::Foundation::Size CompositionRootView::Arrange(Windows::Foundation::Size
   return {};
 }
 
-::Microsoft::ReactNative::RootComponentView *CompositionRootView::GetComponentView() noexcept {
+winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *
+CompositionRootView::GetComponentView() noexcept {
   return nullptr;
 }
 

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

@@ -4,6 +4,7 @@
 #include "pch.h"
 #include "CompositionUIService.h"
 #include "Composition.CompositionUIService.g.cpp"
+#include <QuirkSettings.h>
 
 #include <ReactPropertyBag.h>
 
@@ -18,6 +19,9 @@ void CompositionUIService::SetCompositionContext(
     IReactPropertyBag const &properties,
     ICompositionContext const &compositionContext) noexcept {
   ReactPropertyBag(properties).Set(CompositionContextPropertyId(), compositionContext);
+  // Default to using Bridgeless mode when using fabric
+  winrt::Microsoft::ReactNative::implementation::QuirkSettings::SetIsBridgeless(
+      ReactPropertyBag(properties), !!compositionContext);
 }
 
 ICompositionContext CompositionUIService::GetCompositionContext(const IReactPropertyBag &properties) noexcept {