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

package/Microsoft.ReactNative/Modules/Animated/NativeAnimatedNodeManager.h

@@ -5,7 +5,6 @@
 // Licensed under the MIT License.
 
 #include <IReactInstance.h>
-#include <UI.Xaml.Media.h>
 #include "AnimatedNode.h"
 #include "AnimationDriver.h"
 #include "EventAnimationDriver.h"

package/Microsoft.ReactNative/Modules/Animated/PropsAnimatedNode.cpp

@@ -3,23 +3,14 @@
 
 #include "pch.h"
 
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-#include <Modules/NativeUIManager.h>
-#include <Modules/PaperUIManagerModule.h>
-#include <Views/ShadowNodeBase.h>
-#endif
-
 #include <Utils/Helpers.h>
-#include <Views/XamlFeatures.h>
 #include "NativeAnimatedNodeManager.h"
 #include "PropsAnimatedNode.h"
 #include "StyleAnimatedNode.h"
 
-#ifdef USE_FABRIC
 #include <Fabric/Composition/CompositionContextHelper.h>
 #include <Fabric/Composition/CompositionUIService.h>
 #include <Fabric/FabricUIManagerModule.h>
-#endif
 
 namespace Microsoft::ReactNative {
 PropsAnimatedNode::PropsAnimatedNode(
@@ -84,11 +75,6 @@ void PropsAnimatedNode::DisconnectFromView(int64_t viewTag) {
     }
 
     if (m_centerPointAnimation) {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-      if (const auto target = GetUIElement()) {
-        target.StopAnimation(m_centerPointAnimation);
-      }
-#endif
       m_centerPointAnimation = nullptr;
     }
     m_needsCenterPointAnimation = false;
@@ -142,33 +128,11 @@ void PropsAnimatedNode::UpdateView() {
   }
 }
 
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-static void EnsureUIElementDirtyForRender(xaml::UIElement uiElement) {
-  auto compositeMode = uiElement.CompositeMode();
-  switch (compositeMode) {
-    case xaml::Media::ElementCompositeMode::SourceOver:
-    case xaml::Media::ElementCompositeMode::MinBlend:
-      uiElement.CompositeMode(xaml::Media::ElementCompositeMode::Inherit);
-      break;
-    default:
-      uiElement.CompositeMode(xaml::Media::ElementCompositeMode::SourceOver);
-      break;
-  }
-  uiElement.CompositeMode(compositeMode);
-}
-#endif
-
 void PropsAnimatedNode::StartAnimations() {
   assert(m_useComposition);
   if (m_expressionAnimations.size()) {
     AnimationView view = GetAnimationView();
     if (view) {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-      // Work around for https://github.com/microsoft/microsoft-ui-xaml/issues/2511
-      if (view.m_element) {
-        EnsureUIElementDirtyForRender(view.m_element);
-      }
-#endif
       for (const auto &anim : m_expressionAnimations) {
         if (anim.second.Target() == L"Translation.X") {
           m_subchannelPropertySet.StartAnimation(L"TranslationX", anim.second);
@@ -183,11 +147,6 @@ void PropsAnimatedNode::StartAnimations() {
           m_subchannelPropertySet.StartAnimation(L"ScaleY", anim.second);
           StartAnimation(view, m_scaleCombined);
         } else if (anim.second.Target() == L"Rotation") {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-          if (view.m_element) {
-            view.m_element.RotationAxis(m_rotationAxis);
-          }
-#else
           if (view.m_componentView) {
             auto visual =
                 winrt::Microsoft::ReactNative::Composition::Experimental::CompositionContextHelper::InnerVisual(
@@ -196,7 +155,6 @@ void PropsAnimatedNode::StartAnimations() {
                         ->Visual());
             visual.RotationAxis(m_rotationAxis);
           }
-#endif
           StartAnimation(view, anim.second);
         } else {
           StartAnimation(view, anim.second);
@@ -330,49 +288,9 @@ void PropsAnimatedNode::MakeAnimation(int64_t valueNodeTag, FacadeType facadeTyp
   }
 }
 
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-Microsoft::ReactNative::ShadowNodeBase *PropsAnimatedNode::GetShadowNodeBase() {
-  if (const auto uiManager = Microsoft::ReactNative::GetNativeUIManager(m_context).lock()) {
-    if (const auto nativeUIManagerHost = uiManager->getHost()) {
-      return static_cast<Microsoft::ReactNative::ShadowNodeBase *>(
-          nativeUIManagerHost->FindShadowNodeForTag(m_connectedViewTag));
-    }
-  }
-  return nullptr;
-}
-
-xaml::UIElement PropsAnimatedNode::GetUIElement() {
-  if (IsRS5OrHigher()) {
-    if (const auto shadowNodeBase = GetShadowNodeBase()) {
-      if (const auto shadowNodeView = shadowNodeBase->GetView()) {
-        return shadowNodeView.as<xaml::UIElement>();
-      }
-    }
-  }
-  return nullptr;
-}
-#endif
-
-void PropsAnimatedNode::CommitProps() {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-  if (const auto node = GetShadowNodeBase()) {
-    if (!node->m_zombie) {
-      node->updateProperties(m_props);
-    }
-  }
-#endif
-}
+void PropsAnimatedNode::CommitProps() {}
 
 PropsAnimatedNode::AnimationView PropsAnimatedNode::GetAnimationView() {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-  if (IsRS5OrHigher()) {
-    if (const auto shadowNodeBase = GetShadowNodeBase()) {
-      if (const auto shadowNodeView = shadowNodeBase->GetView()) {
-        return {shadowNodeView.as<xaml::UIElement>()};
-      }
-    }
-  }
-#else
   if (auto fabricuiManager = FabricUIManager::FromProperties(m_context.Properties())) {
     auto componentView = fabricuiManager->GetViewRegistry().findComponentViewWithTag(
         static_cast<facebook::react::Tag>(m_connectedViewTag));
@@ -380,18 +298,12 @@ PropsAnimatedNode::AnimationView PropsAnimatedNode::GetAnimationView() {
       return {componentView};
     }
   }
-#endif
   return {nullptr};
 }
 
 void PropsAnimatedNode::StartAnimation(
     const AnimationView &view,
     const comp::CompositionAnimation &animation) noexcept {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-  if (view.m_element) {
-    view.m_element.StartAnimation(animation);
-  }
-#else
   if (view.m_componentView) {
     auto baseComponentView =
         view.m_componentView.as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
@@ -413,20 +325,13 @@ void PropsAnimatedNode::StartAnimation(
       visual.StartAnimation(targetProp, animation);
     }
   }
-#endif
 }
 
 comp::CompositionPropertySet PropsAnimatedNode::EnsureCenterPointPropertySet(const AnimationView &view) noexcept {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-  if (view.m_element) {
-    return GetShadowNodeBase()->EnsureTransformPS();
-  }
-#else
   if (view.m_componentView) {
     return view.m_componentView.as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>()
         ->EnsureCenterPointPropertySet();
   }
-#endif
   return nullptr;
 }
 

package/Microsoft.ReactNative/Modules/Animated/PropsAnimatedNode.h

@@ -10,9 +10,7 @@
 #include "FacadeType.h"
 #include "JSValue.h"
 
-#ifdef USE_FABRIC
 #include <Fabric/Composition/CompositionViewComponentView.h>
-#endif
 
 namespace Microsoft::ReactNative {
 struct ShadowNodeBase;
@@ -36,26 +34,14 @@ class PropsAnimatedNode final : public AnimatedNode {
 
  private:
   struct AnimationView {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-    xaml::UIElement m_element;
-#else
     winrt::Microsoft::ReactNative::ComponentView m_componentView;
-#endif
     operator bool() const noexcept {
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-      return m_element != nullptr;
-#else
       return m_componentView != nullptr;
-#endif
     }
   };
 
   void CommitProps();
   void MakeAnimation(int64_t valueNodeTag, FacadeType facadeType);
-#if !defined(CORE_ABI) && !defined(USE_FABRIC)
-  Microsoft::ReactNative::ShadowNodeBase *GetShadowNodeBase();
-  xaml::UIElement GetUIElement();
-#endif
   AnimationView GetAnimationView();
   void StartAnimation(const AnimationView &view, const comp::CompositionAnimation &animation) noexcept;
   comp::CompositionPropertySet EnsureCenterPointPropertySet(const AnimationView &view) noexcept;

package/Microsoft.ReactNative/Modules/AppStateModule.cpp

@@ -17,59 +17,6 @@ void AppState::Initialize(winrt::Microsoft::ReactNative::ReactContext const &rea
   m_context = reactContext;
   m_deactivated = false;
   m_enteredBackground = false;
-
-  // We need to register for notifications from the XAML thread.
-  if (auto dispatcher = reactContext.UIDispatcher()) {
-    dispatcher.Post([this]() {
-      auto currentApp = xaml::TryGetCurrentUwpXamlApplication();
-
-      if (!IsWinUI3Island() && currentApp != nullptr) {
-#ifndef USE_WINUI3
-        CoreWindow window = CoreWindow::GetForCurrentThread();
-
-        m_enteredBackgroundRevoker = currentApp.EnteredBackground(
-            winrt::auto_revoke,
-            [weakThis = weak_from_this()](
-                winrt::IInspectable const & /*sender*/,
-                winrt::Windows::ApplicationModel::EnteredBackgroundEventArgs const & /*e*/) noexcept {
-              if (auto strongThis = weakThis.lock()) {
-                strongThis->SetEnteredBackground(true);
-              }
-            });
-
-        m_leavingBackgroundRevoker = currentApp.LeavingBackground(
-            winrt::auto_revoke,
-            [weakThis = weak_from_this()](
-                winrt::IInspectable const & /*sender*/,
-                winrt::Windows::ApplicationModel::LeavingBackgroundEventArgs const & /*e*/) noexcept {
-              if (auto strongThis = weakThis.lock()) {
-                strongThis->SetEnteredBackground(false);
-              }
-            });
-        if (window != nullptr &&
-            winrt::Microsoft::ReactNative::implementation::QuirkSettings::GetMapWindowDeactivatedToAppStateInactive(
-                m_context.Properties())) {
-          m_activatedEventRevoker = window.Activated(
-              winrt::auto_revoke,
-              [weakThis = weak_from_this()](
-                  winrt::Windows::UI::Core::CoreWindow /*sender*/,
-                  winrt::Windows::UI::Core::WindowActivatedEventArgs args) {
-                if (auto strongThis = weakThis.lock()) {
-                  if (args.WindowActivationState() ==
-                      winrt::Windows::UI::Core::CoreWindowActivationState::Deactivated) {
-                    strongThis->SetDeactivated(true);
-                  } else {
-                    strongThis->SetDeactivated(false);
-                  }
-                }
-              });
-        }
-#endif
-      } else {
-        assert(IsXamlIsland());
-      }
-    });
-  }
 }
 
 void AppState::GetCurrentAppState(

package/Microsoft.ReactNative/Modules/AppStateModule.h

@@ -46,11 +46,6 @@ struct AppState : public std::enable_shared_from_this<AppState> {
   std::atomic<bool> m_enteredBackground;
   char const *m_lastState{nullptr};
   winrt::Microsoft::ReactNative::ReactContext m_context;
-#ifndef USE_WINUI3
-  xaml::Application::EnteredBackground_revoker m_enteredBackgroundRevoker;
-  xaml::Application::LeavingBackground_revoker m_leavingBackgroundRevoker;
-  winrt::Windows::UI::Core::CoreWindow::Activated_revoker m_activatedEventRevoker;
-#endif
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/AppThemeModuleUwp.cpp

@@ -42,18 +42,10 @@ static const React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<AppT
 
 AppThemeHolder::AppThemeHolder(const Mso::React::IReactContext &context) : m_context(&context) {
   NotifyHighContrastChanged();
-
-  if (auto currentApp = xaml::TryGetCurrentUwpXamlApplication()) {
-    if (IsWinUI3Island()) {
-      m_wmSubscription = SubscribeToWindowMessage(
-          ReactNotificationService(m_context->Notifications()), WM_THEMECHANGED, [this](const auto &, const auto &) {
-            NotifyHighContrastChanged();
-          });
-    } else {
-      m_highContrastChangedRevoker = m_accessibilitySettings.HighContrastChanged(
-          winrt::auto_revoke, [this](const auto &, const auto &) { NotifyHighContrastChanged(); });
-    }
-  }
+  m_wmSubscription = SubscribeToWindowMessage(
+      ReactNotificationService(m_context->Notifications()), WM_THEMECHANGED, [this](const auto &, const auto &) {
+        NotifyHighContrastChanged();
+      });
 }
 
 ReactNativeSpecs::AppThemeSpec_AppThemeData AppThemeHolder::GetConstants() noexcept {
@@ -75,8 +67,7 @@ void AppThemeHolder::SetCallback(
 }
 
 void AppThemeHolder::NotifyHighContrastChanged() noexcept {
-  m_appThemeData.isHighContrast =
-      xaml::TryGetCurrentUwpXamlApplication() ? m_accessibilitySettings.HighContrast() : IsInHighContrastWin32();
+  m_appThemeData.isHighContrast = IsInHighContrastWin32();
   m_appThemeData.highContrastColors.ButtonFaceColor =
       FormatRGB(m_uiSettings.UIElementColor(winrt::UIElementType::ButtonFace));
   m_appThemeData.highContrastColors.ButtonTextColor =

package/Microsoft.ReactNative/Modules/AppThemeModuleUwp.h

@@ -32,8 +32,6 @@ class AppThemeHolder {
   Mso::CntPtr<const Mso::React::IReactContext> m_context;
   Mso::Functor<void(winrt::Microsoft::ReactNative::JSValueObject &&)> m_notifyCallback;
   ReactNativeSpecs::AppThemeSpec_AppThemeData m_appThemeData;
-  winrt::Windows::UI::ViewManagement::AccessibilitySettings m_accessibilitySettings{};
-  winrt::Windows::UI::ViewManagement::AccessibilitySettings::HighContrastChanged_revoker m_highContrastChangedRevoker{};
   winrt::Windows::UI::ViewManagement::UISettings m_uiSettings{};
   winrt::Microsoft::ReactNative::ReactNotificationSubscription m_wmSubscription;
 };

package/Microsoft.ReactNative/Modules/AppearanceModule.cpp

@@ -50,10 +50,6 @@ ApplicationTheme CurrentThemeFromUISettings(const winrt::Windows::UI::ViewManage
 
 ApplicationTheme Appearance::GetCurrentTheme() noexcept {
   assert(m_context.UIDispatcher().HasThreadAccess()); // xaml::Application is only accessible on the UI thread
-  if (auto currentApp = xaml::TryGetCurrentUwpXamlApplication()) {
-    return currentApp.RequestedTheme();
-  }
-
   return CurrentThemeFromUISettings(m_uiSettings);
 }
 
@@ -74,11 +70,7 @@ void Appearance::RequeryTheme() noexcept {
 
 void Appearance::InitOnUIThread(const Mso::React::IReactContext &context) noexcept {
   xaml::ApplicationTheme theme = ApplicationTheme::Light;
-  if (auto currentApp = xaml::TryGetCurrentUwpXamlApplication()) {
-    theme = currentApp.RequestedTheme();
-  } else {
-    theme = CurrentThemeFromUISettings(winrt::Windows::UI::ViewManagement::UISettings());
-  }
+  theme = CurrentThemeFromUISettings(winrt::Windows::UI::ViewManagement::UISettings());
 
   winrt::Microsoft::ReactNative::ReactPropertyBag pb{context.Properties()};
   pb.Set(AppearanceCurrentThemePropertyId(), theme);

package/Microsoft.ReactNative/Modules/DevSettingsModule.cpp

@@ -32,10 +32,6 @@ void DevSettings::setHotLoadingEnabled(bool isHotLoadingEnabled) noexcept {
   Mso::React::ReactOptions::SetUseFastRefresh(m_context.Properties().Handle(), isHotLoadingEnabled);
 }
 
-void DevSettings::setIsDebuggingRemotely(bool isDebuggingRemotelyEnabled) noexcept {
-  Mso::React::ReactOptions::SetUseWebDebugger(m_context.Properties().Handle(), isDebuggingRemotelyEnabled);
-}
-
 void DevSettings::setProfilingEnabled(bool isProfilingEnabled) noexcept {
   assert(false);
 }

package/Microsoft.ReactNative/Modules/DevSettingsModule.h

@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 #pragma once
 
-#include <cxxreact/CxxModule.h>
 #include <functional/functor.h>
 
 #include "codegen/NativeDevSettingsSpec.g.h"
@@ -21,7 +20,6 @@ struct DevSettings {
   REACT_METHOD(reloadWithReason) void reloadWithReason(std::string reason) noexcept;
   REACT_METHOD(onFastRefresh) void onFastRefresh() noexcept;
   REACT_METHOD(setHotLoadingEnabled) void setHotLoadingEnabled(bool isHotLoadingEnabled) noexcept;
-  REACT_METHOD(setIsDebuggingRemotely) void setIsDebuggingRemotely(bool isDebuggingRemotelyEnabled) noexcept;
   REACT_METHOD(setProfilingEnabled) void setProfilingEnabled(bool isProfilingEnabled) noexcept;
   REACT_METHOD(toggleElementInspector) void toggleElementInspector() noexcept;
   REACT_METHOD(addMenuItem) void addMenuItem(std::string title) noexcept;

package/Microsoft.ReactNative/Modules/DeviceInfoModule.cpp

@@ -6,9 +6,6 @@
 #include <DesktopWindowBridge.h>
 #include <IReactDispatcher.h>
 #include <IReactPropertyBag.h>
-#ifndef USE_WINUI3
-#include <UI.Xaml.Hosting.DesktopWindowXamlSource.h>
-#endif
 #include <Utils/Helpers.h>
 #include <XamlUIService.h>
 #include <XamlUtils.h>
@@ -16,9 +13,7 @@
 #include <winrt/Windows.UI.Core.h>
 #include <winrt/Windows.UI.ViewManagement.h>
 
-#ifdef USE_FABRIC
 #include <ReactCoreInjection.h>
-#endif
 
 using namespace winrt::Microsoft::ReactNative;
 
@@ -36,52 +31,14 @@ DeviceInfoHolder::DeviceInfoHolder(const Mso::React::IReactContext &context) : m
 }
 
 void DeviceInfoHolder::InitDeviceInfoHolder(const Mso::React::IReactContext &context) noexcept {
-  if (xaml::TryGetCurrentUwpXamlApplication() || IsFabricEnabled(context.Properties())) {
+  if (IsFabricEnabled(context.Properties())) {
     auto deviceInfoHolder = std::make_shared<DeviceInfoHolder>(context);
 
     deviceInfoHolder->updateDeviceInfo();
     winrt::Microsoft::ReactNative::ReactPropertyBag pb{context.Properties()};
     pb.Set(DeviceInfoHolderPropertyId(), std::move(deviceInfoHolder));
 
-    uint64_t hwnd = 0;
-
-#ifdef USE_FABRIC
-    if (IsFabricEnabled(context.Properties())) {
-      hwnd = winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetTopLevelWindowId(pb.Handle());
-    }
-#endif
-
-    if (xaml::TryGetCurrentUwpXamlApplication()) {
-      if (auto window = xaml::Window::Current()) {
-        auto const &coreWindow = window.CoreWindow();
-
-        deviceInfoHolder->m_sizeChangedRevoker = coreWindow.SizeChanged(
-            winrt::auto_revoke, [weakHolder = std::weak_ptr(deviceInfoHolder)](auto &&, auto &&) {
-              if (auto strongHolder = weakHolder.lock()) {
-                strongHolder->updateDeviceInfo();
-              }
-            });
-      } else {
-        assert(IsXamlIsland());
-        // This is either a WinUI 3 island or a system XAML island
-        // system XAML islands have a CoreWindow so we want to use the GetForCurrentView APIs
-        // For WinUI 3 islands we require the app to forward window messages as ReactNotifications
-      }
-
-      if (!IsWinUI3Island()) {
-        // UWP or system XAML island
-        auto const &displayInfo = winrt::Windows::Graphics::Display::DisplayInformation::GetForCurrentView();
-
-        deviceInfoHolder->m_dpiChangedRevoker = displayInfo.DpiChanged(
-            winrt::auto_revoke, [weakHolder = std::weak_ptr(deviceInfoHolder)](const auto &, const auto &) {
-              if (auto strongHolder = weakHolder.lock()) {
-                strongHolder->updateDeviceInfo();
-              }
-            });
-      } else {
-        hwnd = XamlUIService::GetIslandWindowHandle(deviceInfoHolder->m_context->Properties());
-      }
-    }
+    uint64_t hwnd = winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetTopLevelWindowId(pb.Handle());
 
     if (hwnd) {
       deviceInfoHolder->m_wmSubscription = SubscribeToWindowMessage(
@@ -157,57 +114,26 @@ void DeviceInfoHolder::SetCallback(
 }
 
 void DeviceInfoHolder::updateDeviceInfo() noexcept {
-  if (xaml::TryGetCurrentUwpXamlApplication() && xaml::Window::Current()) {
-    auto const window = xaml::Window::Current().CoreWindow();
-
-    m_windowWidth = window.Bounds().Width;
-    m_windowHeight = window.Bounds().Height;
-  } else {
-    auto hwnd = XamlUIService::GetIslandWindowHandle(m_context->Properties());
-
-#ifdef USE_FABRIC
-    if (IsFabricEnabled(m_context->Properties())) {
-      winrt::Microsoft::ReactNative::ReactPropertyBag pb{m_context->Properties()};
-      hwnd = winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetTopLevelWindowId(pb.Handle());
-    }
-#endif
+  auto hwnd = XamlUIService::GetIslandWindowHandle(m_context->Properties());
 
-    if (hwnd) {
-      RECT rect{};
-      if (CALL_INDIRECT(L"user32.dll", GetWindowRect, reinterpret_cast<HWND>(hwnd), &rect)) {
-        m_windowWidth = (float)(rect.right - rect.left);
-        m_windowHeight = (float)(rect.bottom - rect.top);
-      }
-    }
+  if (IsFabricEnabled(m_context->Properties())) {
+    winrt::Microsoft::ReactNative::ReactPropertyBag pb{m_context->Properties()};
+    hwnd = winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetTopLevelWindowId(pb.Handle());
   }
 
-  winrt::Windows::UI::ViewManagement::UISettings uiSettings;
-  m_textScaleFactor = uiSettings.TextScaleFactor();
-  if (!IsWinUI3Island()) {
-    auto const displayInfo = winrt::Windows::Graphics::Display::DisplayInformation::GetForCurrentView();
-    m_scale = static_cast<float>(displayInfo.ResolutionScale()) / 100;
-    m_dpi = displayInfo.LogicalDpi();
-    m_screenWidth = displayInfo.ScreenWidthInRawPixels();
-    m_screenHeight = displayInfo.ScreenHeightInRawPixels();
-    notifyChanged();
-  } else {
-    RECT desktopRect{};
-
-    auto hwnd = XamlUIService::GetIslandWindowHandle(m_context->Properties());
-
-#ifdef USE_FABRIC
-    if (IsFabricEnabled(m_context->Properties())) {
-      winrt::Microsoft::ReactNative::ReactPropertyBag pb{m_context->Properties()};
-      hwnd = winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetTopLevelWindowId(pb.Handle());
-    }
-#endif
-
-    if (hwnd && CALL_INDIRECT(L"user32.dll", GetWindowRect, reinterpret_cast<HWND>(hwnd), &desktopRect)) {
-      m_screenWidth = static_cast<uint32_t>(desktopRect.right - desktopRect.left);
-      m_screenHeight = static_cast<uint32_t>(desktopRect.bottom - desktopRect.top);
+  if (hwnd) {
+    RECT rect{};
+    if (CALL_INDIRECT(L"user32.dll", GetWindowRect, reinterpret_cast<HWND>(hwnd), &rect)) {
+      m_windowWidth = (float)(rect.right - rect.left);
+      m_windowHeight = (float)(rect.bottom - rect.top);
+      m_screenWidth = static_cast<uint32_t>(rect.right - rect.left);
+      m_screenHeight = static_cast<uint32_t>(rect.bottom - rect.top);
       m_dpi = static_cast<float>(CALL_INDIRECT(L"user32.dll", GetDpiForWindow, reinterpret_cast<HWND>(hwnd)));
     }
   }
+
+  winrt::Windows::UI::ViewManagement::UISettings uiSettings;
+  m_textScaleFactor = uiSettings.TextScaleFactor();
 }
 
 ReactNativeSpecs::DeviceInfoSpec_DeviceInfoConstants DeviceInfo::GetConstants() noexcept {

package/Microsoft.ReactNative/Modules/I18nManagerModule.cpp

@@ -28,14 +28,9 @@ static const React::ReactPropertyId<bool> &ForceRTLPropertyId() noexcept {
 }
 
 void I18nManager::InitI18nInfo(const winrt::Microsoft::ReactNative::ReactPropertyBag &propertyBag) noexcept {
-  if (xaml::TryGetCurrentUwpXamlApplication() && !IsXamlIsland()) {
-    // TODO: Figure out packaged win32 app story for WinUI 3
-    auto layoutDirection = winrt::Windows::ApplicationModel::Resources::Core::ResourceContext()
-                               .GetForCurrentView()
-                               .QualifierValues()
-                               .Lookup(L"LayoutDirection");
-
-    propertyBag.Set(SystemIsRTLPropertyId(), layoutDirection != L"LTR");
+  DWORD dw;
+  if (GetProcessDefaultLayout(&dw)) {
+    propertyBag.Set(SystemIsRTLPropertyId(), dw == LAYOUT_RTL);
   }
 }
 

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.cpp

@@ -10,22 +10,16 @@
 
 #include "ImageViewManagerModule.h"
 
-#include <UI.Xaml.Media.Imaging.h>
-#include <Views/Image/ReactImage.h>
-#include <cxxreact/JsArgumentHelpers.h>
-#ifdef USE_FABRIC
 #include <Fabric/WindowsImageManager.h>
 #include <Utils/Helpers.h>
+#include <cxxreact/JsArgumentHelpers.h>
 #include <wincodec.h>
-#include "XamlUtils.h"
-#endif // USE_FABRIC
 #include <winrt/Windows.Storage.Streams.h>
 #include "Unicode.h"
 
 namespace winrt {
 using namespace Windows::Foundation;
 using namespace Windows::Storage::Streams;
-using namespace xaml::Media::Imaging;
 } // namespace winrt
 
 namespace Microsoft::ReactNative {
@@ -35,12 +29,7 @@ winrt::fire_and_forget GetImageSizeAsync(
     std::string uriString,
     winrt::Microsoft::ReactNative::JSValue &&headers,
     Mso::Functor<void(int32_t width, int32_t height)> successCallback,
-    Mso::Functor<void()> errorCallback
-#ifdef USE_FABRIC
-    ,
-    bool useFabric
-#endif // USE_FABRIC
-) {
+    Mso::Functor<void()> errorCallback) {
   bool succeeded{false};
 
   try {
@@ -63,32 +52,16 @@ winrt::fire_and_forget GetImageSizeAsync(
     } else if (inlineData) {
       memoryStream = co_await GetImageInlineDataAsync(source);
     }
-
-#ifdef USE_FABRIC
-    if (!useFabric) {
-#endif // USE_FABRIC
-      winrt::BitmapImage bitmap;
-      if (memoryStream) {
-        co_await bitmap.SetSourceAsync(memoryStream);
-      }
-      if (bitmap) {
-        successCallback(bitmap.PixelWidth(), bitmap.PixelHeight());
+    auto result = wicBitmapSourceFromStream(memoryStream);
+    if (!std::get<std::shared_ptr<facebook::react::ImageErrorInfo>>(result)) {
+      auto imagingFactory = std::get<winrt::com_ptr<IWICImagingFactory>>(result);
+      auto wicBmpSource = std::get<winrt::com_ptr<IWICBitmapSource>>(result);
+      UINT width, height;
+      if (SUCCEEDED(wicBmpSource->GetSize(&width, &height))) {
+        successCallback(width, height);
         succeeded = true;
       }
-#ifdef USE_FABRIC
-    } else {
-      auto result = wicBitmapSourceFromStream(memoryStream);
-      if (!std::get<std::shared_ptr<facebook::react::ImageErrorInfo>>(result)) {
-        auto imagingFactory = std::get<winrt::com_ptr<IWICImagingFactory>>(result);
-        auto wicBmpSource = std::get<winrt::com_ptr<IWICBitmapSource>>(result);
-        UINT width, height;
-        if (SUCCEEDED(wicBmpSource->GetSize(&width, &height))) {
-          successCallback(width, height);
-          succeeded = true;
-        }
-      }
     }
-#endif // USE_FABRIC
   } catch (winrt::hresult_error const &) {
   }
 
@@ -112,12 +85,7 @@ void ImageLoader::getSize(std::string uri, React::ReactPromise<std::vector<doubl
             [result](double width, double height) noexcept {
               result.Resolve(std::vector<double>{width, height});
             },
-            [result]() noexcept { result.Reject("Failed"); }
-#ifdef USE_FABRIC
-            ,
-            IsFabricEnabled(context.Properties().Handle())
-#endif // USE_FABRIC
-        );
+            [result]() noexcept { result.Reject("Failed"); });
       });
 }
 
@@ -137,12 +105,7 @@ void ImageLoader::getSizeWithHeaders(
         [result](double width, double height) noexcept {
           result.Resolve(Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType{width, height});
         },
-        [result]() noexcept { result.Reject("Failed"); }
-#ifdef USE_FABRIC
-        ,
-        IsFabricEnabled(context.Properties().Handle())
-#endif // USE_FABRIC
-    );
+        [result]() noexcept { result.Reject("Failed"); });
   });
 }
 

package/Microsoft.ReactNative/Modules/LinkingManagerModule.cpp

@@ -8,9 +8,6 @@
 #include "LinkingManagerModule.h"
 #include "Unicode.h"
 
-#include <cxxreact/Instance.h>
-#include <cxxreact/JsArgumentHelpers.h>
-
 #if _MSC_VER <= 1913
 // VC 19 (2015-2017.6) cannot optimize co_await/cppwinrt usage
 #pragma optimize("", off)