react-native-windows 0.81.1 → 0.82.0-preview.1

package/Microsoft.ReactNative/Views/DevMenu.cpp

@@ -6,28 +6,12 @@
 #include "DevMenu.h"
 
 #include <winrt/Windows.ApplicationModel.DataTransfer.h>
-#include "Hermes/HermesSamplingProfiler.h"
 #include "IReactDispatcher.h"
 #include "Modules/DevSettingsModule.h"
 
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-#include <XamlUtils.h>
-#include "DevMenuControl.h"
-#include "UI.Xaml.Controls.Primitives.h"
-#include "UI.Xaml.Controls.h"
-#include "UI.Xaml.Input.h"
-#include "UI.Xaml.Markup.h"
-#include "Utils/Helpers.h"
-#include "Utils/KeyboardUtils.h"
-#include "winrt/Windows.UI.Core.h"
-#include "winrt/Windows.UI.Xaml.Interop.h"
-#endif // CORE_ABI
-
-#if defined(CORE_ABI) || defined(USE_FABRIC)
 #include <ReactCoreInjection.h>
 #include <Shobjidl.h>
 #include "winrt/Windows.UI.Popups.h"
-#endif
 
 using namespace winrt::Windows::ApplicationModel;
 
@@ -37,15 +21,6 @@ struct IDevMenu {
   virtual void Show() noexcept = 0;
 };
 
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-bool IsCtrlShiftD(winrt::Windows::System::VirtualKey key) noexcept {
-  return (
-      key == winrt::Windows::System::VirtualKey::D &&
-      IsModifiedKeyPressed(winrt::CoreWindow::GetForCurrentThread(), winrt::Windows::System::VirtualKey::Shift) &&
-      IsModifiedKeyPressed(winrt::CoreWindow::GetForCurrentThread(), winrt::Windows::System::VirtualKey::Control));
-}
-#endif // CORE_ABI
-
 React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<IDevMenu>>> DevMenuImplProperty() noexcept {
   static React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<IDevMenu>>> propId{
       L"ReactNative.DevMenuManager", L"DevMenuImpl"};
@@ -92,209 +67,11 @@ void ToggleFastRefresh(Mso::CntPtr<Mso::React::IReactContext> const &reactContex
   DevSettings::Reload(React::ReactPropertyBag(reactContext->Properties()));
 }
 
-winrt::fire_and_forget ToggleHermesProfiler(Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept {
-  if (!Microsoft::ReactNative::HermesSamplingProfiler::IsStarted()) {
-    Microsoft::ReactNative::HermesSamplingProfiler::Start(reactContext);
-  } else {
-    auto traceFilePath = co_await Microsoft::ReactNative::HermesSamplingProfiler::Stop(reactContext);
-    auto uiDispatcher = React::implementation::ReactDispatcher::GetUIDispatcher(reactContext->Properties());
-    uiDispatcher.Post([traceFilePath]() {
-      DataTransfer::DataPackage data;
-      data.SetText(winrt::to_hstring(traceFilePath));
-      DataTransfer::Clipboard::SetContentWithOptions(data, nullptr);
-    });
-  }
-}
-
 const wchar_t *FastRefreshLabel(Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept {
   return Mso::React::ReactOptions::UseFastRefresh(reactContext->Properties()) ? L"Disable Fast Refresh"
                                                                               : L"Enable Fast Refresh";
 }
 
-const wchar_t *HermesProfilerLabel(Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept {
-  return !Microsoft::ReactNative::HermesSamplingProfiler::IsStarted() ? L"Start Hermes sampling profiler"
-                                                                      : L"Stop and copy trace path to clipboard";
-}
-
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-struct InAppXamlDevMenu : public IDevMenu, public std::enable_shared_from_this<InAppXamlDevMenu> {
-  InAppXamlDevMenu(Mso::CntPtr<Mso::React::IReactContext> const &reactContext) : m_context(reactContext) {}
-
- private:
-  void Show() noexcept override {
-    winrt::Microsoft::ReactNative::DevMenuControl devMenu{};
-
-    devMenu.FastRefreshText().Text(FastRefreshLabel(m_context));
-    if (Mso::React::ReactOptions::JsiEngine(m_context->Properties()) == Mso::React::JSIEngine::Hermes) {
-      devMenu.SamplingProfilerText().Text(HermesProfilerLabel(m_context));
-      devMenu.SamplingProfilerIcon().Glyph(
-          !Microsoft::ReactNative::HermesSamplingProfiler::IsStarted() ? L"\ue1e5" : L"\ue15b");
-
-      std::ostringstream os;
-      if (Microsoft::ReactNative::HermesSamplingProfiler::IsStarted()) {
-        os << "Hermes Sampling profiler is running!";
-      } else {
-        os << "Click to start.";
-      }
-
-      auto lastTraceFilePath = Microsoft::ReactNative::HermesSamplingProfiler::GetLastTraceFilePath();
-      if (!lastTraceFilePath.empty()) {
-        os << std::endl
-           << "Samples from last invocation are stored at " << winrt::to_string(lastTraceFilePath)
-           << "  (path copied to clipboard).";
-        os << std::endl << "Navigate to \"edge:\\tracing\" and load the trace file.";
-      }
-
-      devMenu.SamplingProfilerDescText().Text(winrt::to_hstring(os.str()));
-    }
-
-    devMenu.DirectDebugText().Text(DirectDebuggerLabel(m_context));
-    devMenu.DirectDebugDesc().Text(
-        L"If using Chakra, this will allow Visual Studio to be attached directly to the application using \"Script Debugging\" to debug the JS running directly in this app.\nIf using V8/Hermes, this will enable standard JS debugging tools such as VSCode to attach to the application.");
-
-    devMenu.BreakOnNextLineText().Text(BreakOnNextLineLabel(m_context));
-
-    m_reloadJSRevoker = devMenu.Reload().Click(
-        winrt::auto_revoke,
-        [wkThis = weak_from_this()](auto const & /*sender*/, xaml::RoutedEventArgs const & /*args*/) noexcept {
-          if (auto strongThis = wkThis.lock()) {
-            strongThis->Hide();
-            DevSettings::Reload(React::ReactPropertyBag(strongThis->m_context->Properties()));
-          }
-        });
-
-    m_directDebuggingRevoker = devMenu.DirectDebug().Click(
-        winrt::auto_revoke,
-        [wkThis = weak_from_this()](auto const & /*sender*/, xaml::RoutedEventArgs const & /*args*/) noexcept {
-          if (auto strongThis = wkThis.lock()) {
-            strongThis->Hide();
-            ToggleDirectDebugger(strongThis->m_context);
-          }
-        });
-
-    m_breakOnNextLineRevoker = devMenu.BreakOnNextLine().Click(
-        winrt::auto_revoke,
-        [wkThis = weak_from_this()](auto const & /*sender*/, xaml::RoutedEventArgs const & /*args*/) noexcept {
-          if (auto strongThis = wkThis.lock()) {
-            strongThis->Hide();
-            ToggleBreakOnNextLine(strongThis->m_context);
-          }
-        });
-
-    m_fastRefreshRevoker = devMenu.FastRefresh().Click(
-        winrt::auto_revoke,
-        [wkThis = weak_from_this()](auto & /*sender*/, xaml::RoutedEventArgs const & /*args*/) noexcept {
-          if (auto strongThis = wkThis.lock()) {
-            strongThis->Hide();
-            ToggleFastRefresh(strongThis->m_context);
-          }
-        });
-
-    if (Mso::React::ReactOptions::JsiEngine(m_context->Properties()) == Mso::React::JSIEngine::Hermes) {
-      m_samplingProfilerRevoker = devMenu.SamplingProfiler().Click(
-          winrt::auto_revoke,
-          [wkThis = weak_from_this()](auto & /*sender*/, xaml::RoutedEventArgs const & /*args*/) noexcept {
-            if (auto strongThis = wkThis.lock()) {
-              strongThis->Hide();
-              ToggleHermesProfiler(strongThis->m_context);
-            }
-          });
-    } else {
-      devMenu.SamplingProfiler().Visibility(xaml::Visibility::Collapsed);
-    }
-
-    m_toggleInspectorRevoker = devMenu.Inspector().Click(
-        winrt::auto_revoke,
-        [wkThis = weak_from_this()](auto const & /*sender*/, xaml::RoutedEventArgs const & /*args*/) noexcept {
-          if (auto strongThis = wkThis.lock()) {
-            strongThis->Hide();
-            DevSettings::ToggleElementInspector(*(strongThis->m_context));
-          }
-        });
-
-    m_configBundlerRevoker = devMenu.ConfigBundler().Click(
-        winrt::auto_revoke,
-        [wkThis = weak_from_this()](auto const & /*sender*/, xaml::RoutedEventArgs const & /*args*/) noexcept {
-          if (auto strongThis = wkThis.lock()) {
-            strongThis->Hide();
-            React::ReactPropertyBag(strongThis->m_context->Properties()).Get(ConfigureBundlerProperty())();
-          }
-        });
-    // Only show Configure Bundler when connected to a bundler
-    devMenu.ConfigBundler().Visibility(
-        (Mso::React::ReactOptions::UseFastRefresh(m_context->Properties()) ||
-         Mso::React::ReactOptions::UseWebDebugger(m_context->Properties()))
-            ? xaml::Visibility::Visible
-            : xaml::Visibility::Collapsed);
-
-    m_cancelRevoker = devMenu.Cancel().Click(
-        winrt::auto_revoke,
-        [wkThis = weak_from_this()](auto const & /*sender*/, xaml::RoutedEventArgs const & /*args*/) {
-          if (auto strongThis = wkThis.lock()) {
-            strongThis->Hide();
-          }
-        });
-
-    m_flyout = xaml::Controls::Flyout{};
-    m_flyout.Content(devMenu);
-    if (Is19H1OrHigher()) {
-      // ShouldConstrainToRootBounds added in 19H1
-      m_flyout.ShouldConstrainToRootBounds(false);
-    }
-
-    xaml::UIElement root{nullptr};
-    auto xamlRoot = React::XamlUIService::GetXamlRoot(m_context->Properties());
-    if (xamlRoot) {
-      m_flyout.XamlRoot(xamlRoot);
-      root = xamlRoot.Content();
-    } else {
-      auto window = xaml::Window::Current();
-      root = window.Content();
-    }
-
-    m_flyout.LightDismissOverlayMode(xaml::Controls::LightDismissOverlayMode::On);
-    devMenu.XYFocusKeyboardNavigation(xaml::Input::XYFocusKeyboardNavigationMode::Enabled);
-
-    auto style = xaml::Style(winrt::xaml_typename<xaml::Controls::FlyoutPresenter>());
-    style.Setters().Append(xaml::Setter(
-        xaml::Controls::ScrollViewer::HorizontalScrollBarVisibilityProperty(),
-        winrt::box_value(xaml::Controls::ScrollBarVisibility::Disabled)));
-    style.Setters().Append(xaml::Setter(
-        xaml::Controls::ScrollViewer::VerticalScrollBarVisibilityProperty(),
-        winrt::box_value(xaml::Controls::ScrollBarVisibility::Disabled)));
-    style.Setters().Append(xaml::Setter(
-        xaml::Controls::ScrollViewer::HorizontalScrollModeProperty(),
-        winrt::box_value(xaml::Controls::ScrollMode::Disabled)));
-    style.Setters().Append(xaml::Setter(
-        xaml::Controls::ScrollViewer::VerticalScrollModeProperty(),
-        winrt::box_value(xaml::Controls::ScrollMode::Disabled)));
-
-    m_flyout.FlyoutPresenterStyle(style);
-    m_flyout.ShowAt(root.as<xaml::FrameworkElement>());
-  }
-
-  void Hide() noexcept {
-    if (!m_flyout)
-      return;
-    m_flyout.Hide();
-    m_flyout = nullptr;
-  }
-
- private:
-  const Mso::CntPtr<Mso::React::IReactContext> m_context;
-  xaml::Controls::Flyout m_flyout{nullptr};
-  xaml::Controls::Button::Click_revoker m_cancelRevoker{};
-  xaml::Controls::Button::Click_revoker m_toggleInspectorRevoker{};
-  xaml::Controls::Button::Click_revoker m_configBundlerRevoker{};
-  xaml::Controls::Button::Click_revoker m_reloadJSRevoker{};
-  xaml::Controls::Button::Click_revoker m_fastRefreshRevoker{};
-  xaml::Controls::Button::Click_revoker m_directDebuggingRevoker{};
-  xaml::Controls::Button::Click_revoker m_breakOnNextLineRevoker{};
-  xaml::Controls::Button::Click_revoker m_samplingProfilerRevoker{};
-};
-#endif // CORE_ABI
-
-#if defined(CORE_ABI) || defined(USE_FABRIC)
 struct WindowsPopupMenuDevMenu : public IDevMenu, public std::enable_shared_from_this<WindowsPopupMenuDevMenu> {
   WindowsPopupMenuDevMenu(Mso::CntPtr<Mso::React::IReactContext> const &reactContext) : m_context(reactContext) {}
 
@@ -330,12 +107,6 @@ struct WindowsPopupMenuDevMenu : public IDevMenu, public std::enable_shared_from
           DevSettings::ToggleElementInspector(*context);
         }));
 
-    if (Mso::React::ReactOptions::JsiEngine(m_context->Properties()) == Mso::React::JSIEngine::Hermes) {
-      m_menu.Commands().Append(winrt::Windows::UI::Popups::UICommand(
-          HermesProfilerLabel(m_context),
-          [context = m_context](winrt::Windows::UI::Popups::IUICommand const &) { ToggleHermesProfiler(context); }));
-    }
-
     m_menu.ShowAsync({0, 0});
   }
 
@@ -343,44 +114,10 @@ struct WindowsPopupMenuDevMenu : public IDevMenu, public std::enable_shared_from
   winrt::Windows::UI::Popups::PopupMenu m_menu{nullptr};
   const Mso::CntPtr<Mso::React::IReactContext> m_context;
 };
-#endif // defined(CORE_ABI) || defined(USE_FABRIC)
 
 DevMenuManager::DevMenuManager(Mso::CntPtr<Mso::React::IReactContext> const &reactContext) : m_context(reactContext) {}
 
-void DevMenuManager::Init() noexcept {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-  auto uiDispatcher = React::implementation::ReactDispatcher::GetUIDispatcher(m_context->Properties());
-  uiDispatcher.Post([weakThis = weak_from_this()]() {
-    if (auto strongThis = weakThis.lock()) {
-      auto context = strongThis->m_context;
-
-      if (Is19H1OrHigher()) {
-        // XamlRoot added in 19H1
-        if (auto xamlRoot = React::XamlUIService::GetXamlRoot(strongThis->m_context->Properties())) {
-          if (auto rootContent = xamlRoot.Content()) {
-            strongThis->m_keyDownRevoker = rootContent.KeyDown(
-                winrt::auto_revoke, [context](const auto & /*sender*/, const xaml::Input::KeyRoutedEventArgs &args) {
-                  if (IsCtrlShiftD(args.Key())) {
-                    DevMenuManager::Show(context);
-                  }
-                });
-            return;
-          }
-        }
-      }
-
-      if (auto coreWindow = winrt::CoreWindow::GetForCurrentThread()) {
-        strongThis->m_coreDispatcherAKARevoker = coreWindow.Dispatcher().AcceleratorKeyActivated(
-            winrt::auto_revoke, [context](const auto & /*sender*/, const winrt::AcceleratorKeyEventArgs &args) {
-              if (IsCtrlShiftD(args.VirtualKey())) {
-                DevMenuManager::Show(context);
-              }
-            });
-      }
-    }
-  });
-#endif // CORE_ABI
-}
+void DevMenuManager::Init() noexcept {}
 
 /*static*/ void DevMenuManager::InitDevMenu(
     Mso::CntPtr<Mso::React::IReactContext> const &reactContext,
@@ -396,20 +133,7 @@ std::shared_ptr<IDevMenu> GetOrCreateDevMenu(Mso::CntPtr<Mso::React::IReactConte
       .GetOrCreate(
           DevMenuImplProperty(),
           [reactContext]() -> std::shared_ptr<IDevMenu> {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-            if (xaml::TryGetCurrentUwpXamlApplication()) {
-              auto devMenu = std::make_shared<InAppXamlDevMenu>(reactContext);
-              return devMenu;
-            } else
-#endif // CORE_ABI
-
-#if defined(CORE_ABI) || defined(USE_FABRIC)
-            {
-              auto devMenu = std::make_shared<WindowsPopupMenuDevMenu>(reactContext);
-              return devMenu;
-            }
-#endif
-            return nullptr;
+            return std::make_shared<WindowsPopupMenuDevMenu>(reactContext);
           })
       .Value();
 }

package/Microsoft.ReactNative/Views/DevMenu.h

@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 #pragma once
 
-#include <cxxreact/CxxModule.h>
 #include <functional/functor.h>
 
 #include <NativeModules.h>
@@ -21,10 +20,6 @@ struct DevMenuManager : public std::enable_shared_from_this<DevMenuManager> {
  private:
   void Init() noexcept;
   const Mso::CntPtr<Mso::React::IReactContext> m_context;
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-  winrt::CoreDispatcher::AcceleratorKeyActivated_revoker m_coreDispatcherAKARevoker{};
-  xaml::UIElement::KeyDown_revoker m_keyDownRevoker;
-#endif
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/XamlApplication.cpp

@@ -0,0 +1,71 @@
+#include "pch.h"
+#include "XamlApplication.h"
+#include "Xaml.XamlApplication.g.cpp"
+
+#include "winrt/Microsoft.UI.Xaml.XamlTypeInfo.h"
+
+namespace winrt::Microsoft::ReactNative::Xaml::implementation {
+using namespace ::winrt::Microsoft::UI::Xaml;
+using namespace ::winrt::Microsoft::UI::Xaml::Markup;
+using namespace ::winrt::Windows::UI::Xaml::Interop;
+XamlApplication::XamlApplication() {
+  s_current = *this;
+
+  // TODO: It's probably not a good idea to only load the controls pri file, there are other ones too.
+  auto resourceManager =
+      winrt::Microsoft::Windows::ApplicationModel::Resources::ResourceManager(L"Microsoft.UI.Xaml.Controls.pri");
+
+  this->ResourceManagerRequested([resourceManager](auto &&, ResourceManagerRequestedEventArgs args) {
+    args.CustomResourceManager(resourceManager);
+  });
+  winrt::Microsoft::UI::Xaml::Hosting::WindowsXamlManager::InitializeForCurrentThread();
+
+  m_providers.push_back(
+      winrt::make_self<winrt::Microsoft::ReactNative::implementation::XamlMetaDataProvider>()
+          .as<winrt::Microsoft::UI::Xaml::Markup::IXamlMetadataProvider>()); // Default generated provider
+  m_providers.push_back(winrt::Microsoft::UI::Xaml::XamlTypeInfo::XamlControlsXamlMetaDataProvider());
+
+  auto winUIResources = winrt::Microsoft::UI::Xaml::Controls::XamlControlsResources();
+  Resources().MergedDictionaries().Append(winUIResources);
+}
+
+XamlApplication::~XamlApplication() {
+  s_current = nullptr;
+}
+
+void XamlApplication::AddMetadataProvider(
+    winrt::Microsoft::UI::Xaml::Markup::IXamlMetadataProvider const &otherProvider) {
+  m_providers.push_back(otherProvider);
+}
+
+winrt::Microsoft::UI::Xaml::Markup::IXamlType XamlApplication::GetXamlType(
+    winrt::Windows::UI::Xaml::Interop::TypeName const &type) {
+  for (const auto &provider : m_providers) {
+    if (auto result = provider.GetXamlType(type)) {
+      return result;
+    }
+  }
+  return nullptr;
+}
+
+winrt::Microsoft::UI::Xaml::Markup::IXamlType XamlApplication::GetXamlType(hstring const &fullName) {
+  for (const auto &provider : m_providers) {
+    if (auto result = provider.GetXamlType(fullName)) {
+      return result;
+    }
+  }
+
+  return nullptr;
+}
+com_array<winrt::Microsoft::UI::Xaml::Markup::XmlnsDefinition> XamlApplication::GetXmlnsDefinitions() {
+  std::vector<::winrt::Microsoft::UI::Xaml::Markup::XmlnsDefinition> allDefinitions;
+  for (const auto &provider : m_providers) {
+    const auto &definitions = provider.GetXmlnsDefinitions();
+    allDefinitions.insert(allDefinitions.cend(), definitions.cbegin(), definitions.cend());
+  }
+  return winrt::com_array<::winrt::Microsoft::UI::Xaml::Markup::XmlnsDefinition>(
+      allDefinitions.begin(), allDefinitions.end());
+}
+
+winrt::Microsoft::ReactNative::Xaml::XamlApplication XamlApplication::s_current{nullptr};
+} // namespace winrt::Microsoft::ReactNative::Xaml::implementation

package/Microsoft.ReactNative/XamlApplication.h

@@ -0,0 +1,47 @@
+#pragma once
+#include "Xaml.XamlApplication.g.h"
+
+#include <winrt/Microsoft.UI.Composition.h>
+#include <winrt/Microsoft.UI.Dispatching.h>
+#include <winrt/Microsoft.UI.Xaml.Controls.Primitives.h>
+#include <winrt/Microsoft.UI.Xaml.Controls.h>
+#include <winrt/Microsoft.Windows.ApplicationModel.Resources.h>
+#include <winrt/Windows.Foundation.h>
+
+#include "winrt/Microsoft.UI.Xaml.Hosting.h"
+#include "winrt/Microsoft.UI.Xaml.Interop.h"
+#include "winrt/Microsoft.UI.Xaml.Markup.h"
+#include "winrt/Microsoft.UI.Xaml.h"
+
+#include "winrt/Windows.UI.Xaml.Interop.h"
+
+#include "XamlMetaDataProvider.h"
+
+namespace winrt::Microsoft::ReactNative::Xaml::implementation {
+struct XamlApplication : XamlApplicationT<XamlApplication> {
+  XamlApplication();
+  ~XamlApplication();
+
+  static void EnsureCreated() {
+    if (Current() == nullptr) {
+      s_current = winrt::make<winrt::Microsoft::ReactNative::Xaml::implementation::XamlApplication>();
+    }
+  }
+
+  static winrt::Microsoft::ReactNative::Xaml::XamlApplication Current() {
+    return s_current;
+  }
+
+  void AddMetadataProvider(winrt::Microsoft::UI::Xaml::Markup::IXamlMetadataProvider const &otherProvider);
+  winrt::Microsoft::UI::Xaml::Markup::IXamlType GetXamlType(winrt::Windows::UI::Xaml::Interop::TypeName const &type);
+  winrt::Microsoft::UI::Xaml::Markup::IXamlType GetXamlType(hstring const &fullName);
+  com_array<winrt::Microsoft::UI::Xaml::Markup::XmlnsDefinition> GetXmlnsDefinitions();
+
+ private:
+  static winrt::Microsoft::ReactNative::Xaml::XamlApplication s_current;
+  std::vector<winrt::Microsoft::UI::Xaml::Markup::IXamlMetadataProvider> m_providers;
+};
+} // namespace winrt::Microsoft::ReactNative::Xaml::implementation
+namespace winrt::Microsoft::ReactNative::Xaml::factory_implementation {
+struct XamlApplication : XamlApplicationT<XamlApplication, implementation::XamlApplication> {};
+} // namespace winrt::Microsoft::ReactNative::Xaml::factory_implementation

package/Microsoft.ReactNative/XamlApplication.idl

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "DocString.h"
+
+namespace Microsoft.ReactNative.Xaml {
+[webhosthidden][default_interface] runtimeclass XamlApplication : Microsoft.UI.Xaml.Application,
+    Microsoft.UI.Xaml.Markup.IXamlMetadataProvider {
+  DOC_STRING("Initializes a new XamlApplication instance for RNW-hosted WinUI/XAML.")
+  XamlApplication();
+
+  DOC_STRING("Gets the process-wide XamlApplication singleton.")
+  static XamlApplication Current {
+    get;
+  };
+
+  DOC_STRING("Adds an additional XAML metadata provider to the application.")
+  void AddMetadataProvider(Microsoft.UI.Xaml.Markup.IXamlMetadataProvider otherProvider);
+}
+} // namespace Microsoft.ReactNative.Xaml

package/Microsoft.ReactNative/XamlUIService.cpp

@@ -5,15 +5,7 @@
 #include "XamlUIService.h"
 #include "XamlUIService.g.cpp"
 
-#ifndef USE_FABRIC
-#include <Modules/NativeUIManager.h>
-#include <Modules/PaperUIManagerModule.h>
-#include "ShadowNodeBase.h"
-#include "Views/ShadowNodeBase.h"
-#endif
-
 #include "DynamicWriter.h"
-#include "XamlView.h"
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
@@ -25,52 +17,6 @@ XamlUIService::XamlUIService(Mso::CntPtr<Mso::React::IReactContext> &&context) n
       .try_as<winrt::Microsoft::ReactNative::XamlUIService>();
 }
 
-#ifndef USE_FABRIC
-xaml::DependencyObject XamlUIService::ElementFromReactTag(int64_t reactTag) noexcept {
-  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
-    auto shadowNode = uiManager->getHost()->FindShadowNodeForTag(reactTag);
-    if (!shadowNode)
-      return nullptr;
-
-    return static_cast<::Microsoft::ReactNative::ShadowNodeBase *>(shadowNode)->GetView();
-  }
-  return nullptr;
-}
-
-void XamlUIService::DispatchEvent(
-    xaml::FrameworkElement const &view,
-    hstring const &eventName,
-    JSValueArgWriter const &eventDataArgWriter) noexcept {
-  auto paramsWriter = winrt::make_self<DynamicWriter>();
-  paramsWriter->WriteArrayBegin();
-  paramsWriter->WriteInt64(::Microsoft::ReactNative::GetTag(view));
-  paramsWriter->WriteString(eventName);
-  if (eventDataArgWriter) {
-    eventDataArgWriter(*paramsWriter);
-  } else {
-    paramsWriter->WriteNull();
-  }
-  paramsWriter->WriteArrayEnd();
-  auto params = paramsWriter->TakeValue();
-  m_context->CallJSFunction("RCTEventEmitter", "receiveEvent", std::move(params));
-}
-
-winrt::Microsoft::ReactNative::ReactRootView XamlUIService::GetReactRootView(
-    xaml::FrameworkElement const &view) noexcept {
-  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
-    const auto reactTag = ::Microsoft::ReactNative::GetTag(view);
-    if (auto shadowNode = static_cast<::Microsoft::ReactNative::ShadowNodeBase *>(
-            uiManager->getHost()->FindShadowNodeForTag(reactTag))) {
-      if (auto rootNode = static_cast<::Microsoft::ReactNative::ShadowNodeBase *>(
-              uiManager->getHost()->FindShadowNodeForTag(shadowNode->m_rootTag))) {
-        return rootNode->GetView().as<winrt::Microsoft::ReactNative::ReactRootView>();
-      }
-    }
-  }
-  return nullptr;
-}
-#endif
-
 /*static*/ ReactPropertyId<XamlUIService> XamlUIService::XamlUIServiceProperty() noexcept {
   static ReactPropertyId<XamlUIService> uiManagerProperty{L"ReactNative.UIManager", L"XamlUIManager"};
   return uiManagerProperty;

package/Microsoft.ReactNative/XamlUIService.h

@@ -4,7 +4,6 @@
 #pragma once
 
 #include "XamlUIService.g.h"
-#include "INativeUIManager.h"
 #include "ReactHost/React.h"
 #include "ReactPropertyBag.h"
 #include "winrt/Microsoft.ReactNative.h"
@@ -17,16 +16,6 @@ struct XamlUIService : XamlUIServiceT<XamlUIService> {
 
   static winrt::Microsoft::ReactNative::XamlUIService FromContext(IReactContext context);
 
-#ifndef USE_FABRIC
-  xaml::DependencyObject ElementFromReactTag(int64_t reactTag) noexcept;
-  void DispatchEvent(
-      xaml::FrameworkElement const &view,
-      hstring const &eventName,
-      JSValueArgWriter const &eventDataArgWriter) noexcept;
-
-  winrt::Microsoft::ReactNative::ReactRootView GetReactRootView(xaml::FrameworkElement const &view) noexcept;
-#endif
-
   static void SetXamlRoot(IReactPropertyBag const &properties, xaml::XamlRoot const &xamlRoot) noexcept;
   static void SetAccessibleRoot(
       IReactPropertyBag const &properties,
@@ -38,7 +27,6 @@ struct XamlUIService : XamlUIServiceT<XamlUIService> {
   static uint64_t GetIslandWindowHandle(IReactPropertyBag const &properties) noexcept;
 
  private:
-  std::weak_ptr<::Microsoft::ReactNative::INativeUIManagerHost> m_wkUIManager;
   Mso::CntPtr<Mso::React::IReactContext> m_context;
 };
 

package/Microsoft.ReactNative/XamlUIService.idl

@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 import "IReactContext.idl";
-import "ReactRootView.idl";
 
 #include "NamespaceRedirect.h"
 #include "DocString.h"
@@ -19,17 +18,6 @@ namespace Microsoft.ReactNative
     DOC_STRING("Use this method to get access to the @XamlUIService associated with the @IReactContext.")
     static XamlUIService FromContext(IReactContext context);
 
-#ifndef USE_FABRIC
-    DOC_STRING("Gets the backing XAML element from a react tag.")
-    XAML_NAMESPACE.DependencyObject ElementFromReactTag(Int64 reactTag);
-
-    DOC_STRING("Dispatches an event to a JS component.")
-    void DispatchEvent(XAML_NAMESPACE.FrameworkElement view, String eventName, JSValueArgWriter eventDataArgWriter);
-
-    DOC_STRING("Gets the @ReactRootView view for a given element.")
-    ReactRootView GetReactRootView(XAML_NAMESPACE.FrameworkElement view);
-#endif
-
     DOC_STRING(
       "Sets the @Windows.UI.Xaml.XamlRoot element for the app. "
       "This must be manually provided to the @ReactInstanceSettings object when using XAML Islands "

package/Microsoft.ReactNative.Cxx/CppWinRTIncludes.h

@@ -7,22 +7,6 @@
 #include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Foundation.h>
 
-#ifndef USE_WINUI3
-
-#include <winrt/Windows.System.h>
-#include <winrt/Windows.UI.Xaml.h>
-
-#define XAML_CPPWINRT_NAMESPACE winrt::Windows::UI::Xaml
-namespace xaml = winrt::Windows::UI::Xaml;
-namespace comp = winrt::Windows::UI::Composition;
-namespace ui = winrt::Windows::UI;
-namespace winrt {
-namespace dispatching = winrt::Windows::System;
-using Colors = winrt::Windows::UI::Colors;
-} // namespace winrt
-#else
-
-#include <winrt/Microsoft.UI.Dispatching.h>
 #include <winrt/Microsoft.UI.Xaml.h>
 
 #define XAML_CPPWINRT_NAMESPACE winrt::Microsoft::UI::Xaml
@@ -30,7 +14,6 @@ namespace xaml = winrt::Microsoft::UI::Xaml;
 namespace comp = winrt::Microsoft::UI::Composition;
 namespace ui = winrt::Microsoft::UI;
 namespace winrt {
-namespace dispatching = winrt::Microsoft::UI::Dispatching;
 using Colors = winrt::Microsoft::UI::Colors;
 } // namespace winrt
 
@@ -40,8 +23,6 @@ using IUIElement9 = UIElement;
 using IUIElement10 = UIElement;
 } // namespace winrt::Microsoft::UI::Xaml
 
-#endif
-
 namespace winrt {
 using namespace Windows::UI::Core;
 using namespace Windows::Foundation;

package/Microsoft.ReactNative.Cxx/DesktopWindowBridge.h

@@ -8,7 +8,7 @@
 #include <winrt/Windows.Foundation.h>
 #include <functional>
 
-#if defined(USE_WINUI3) && !defined(CORE_ABI) && !defined(__APPLE__) && \
+#if !defined(CORE_ABI) && !defined(__APPLE__) && \
     WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM | WINAPI_PARTITION_GAMES)
 
 #include <winrt/Microsoft.ReactNative.h>