react-native-windows 0.84.0-preview.9 → 0.85.0-preview.1

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -68,20 +68,17 @@
 #include <react/threading/MessageQueueThreadImpl.h>
 #include "Inspector/ReactInspectorThread.h"
 
-#ifndef CORE_ABI
-#include <Utils/UwpPreparedScriptStore.h>
-#include <Utils/UwpScriptStore.h>
 #include "Modules/AccessibilityInfoModule.h"
 #include "Modules/AlertModule.h"
 #include "Modules/AppStateModule.h"
 #include "Modules/AppThemeModuleUwp.h"
+#include "Modules/AppearanceModule.h"
 #include "Modules/ClipboardModule.h"
 #include "Modules/DeviceInfoModule.h"
+#include "Modules/ExceptionsManager.h"
 #include "Modules/I18nManagerModule.h"
 #include "Modules/LinkingManagerModule.h"
 #include "Modules/LogBoxModule.h"
-#endif
-#include "Modules/ExceptionsManager.h"
 #include "Modules/PlatformConstantsWinModule.h"
 #include "Modules/ReactRootViewTagGenerator.h"
 #include "Modules/SourceCode.h"
@@ -244,8 +241,8 @@ void ReactInstanceWin::LoadModules(
   registerTurboModule(
       L"FabricUIManagerBinding",
       winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::FabricUIManager>());
+  turboModulesProvider->AddEagerInit("FabricUIManagerBinding");
 
-#ifndef CORE_ABI
   registerTurboModule(
       L"AccessibilityInfo",
       winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::AccessibilityInfo>());
@@ -278,15 +275,6 @@ void ReactInstanceWin::LoadModules(
       L"NativeAnimatedModule",
       winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::NativeAnimatedModule>());
 
-#else
-  registerTurboModule(
-      L"ImageLoader", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::ImageLoader>());
-
-  registerTurboModule(
-      L"NativeAnimatedModule",
-      winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::NativeAnimatedModule>());
-#endif
-
   turboModulesProvider->AddModuleProvider(
       L"SampleTurboModule",
       winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::SampleTurboModule>(),
@@ -330,14 +318,12 @@ void ReactInstanceWin::LoadModules(
   registerTurboModule(
       L"DevSettings", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::DevSettings>());
 
-#ifndef CORE_ABI
   registerTurboModule(
       L"I18nManager", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::I18nManager>());
 
   registerTurboModule(
       L"LinkingManager",
       winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::LinkingManager>());
-#endif
 
   registerTurboModule(L"Timing", winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::Timing>());
 
@@ -362,13 +348,11 @@ void ReactInstanceWin::InitDevMenu() noexcept {
 }
 
 void ReactInstanceWin::InitUIDependentCalls() noexcept {
-#ifndef CORE_ABI
   Microsoft::ReactNative::AppThemeHolder::InitAppThemeHolder(GetReactContext());
   Microsoft::ReactNative::I18nManager::InitI18nInfo(
       winrt::Microsoft::ReactNative::ReactPropertyBag(Options().Properties));
   Microsoft::ReactNative::Appearance::InitOnUIThread(GetReactContext());
   Microsoft::ReactNative::DeviceInfoHolder::InitDeviceInfoHolder(GetReactContext());
-#endif // CORE_ABI
 }
 
 std::shared_ptr<facebook::react::DevSettings> ReactInstanceWin::CreateDevSettings() noexcept {
@@ -400,11 +384,6 @@ std::shared_ptr<facebook::react::DevSettings> ReactInstanceWin::CreateDevSetting
     }
   };
 
-  bool useRuntimeScheduler = winrt::Microsoft::ReactNative::implementation::QuirkSettings::GetUseRuntimeScheduler(
-      winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()));
-
-  devSettings->useRuntimeScheduler = useRuntimeScheduler;
-
   devSettings->inspectorHostTarget = m_options.InspectorHostTarget;
 
   return devSettings;
@@ -797,14 +776,12 @@ facebook::react::NativeLoggingHook ReactInstanceWin::GetLoggingCallback() noexce
 std::shared_ptr<IRedBoxHandler> ReactInstanceWin::GetRedBoxHandler() noexcept {
   if (m_options.RedBoxHandler) {
     return m_options.RedBoxHandler;
-#ifndef CORE_ABI
   } else if (UseDeveloperSupport()) {
     auto localWkReactHost = m_weakReactHost;
     return CreateDefaultRedBoxHandler(
         winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()),
         std::move(localWkReactHost),
         *m_uiQueue);
-#endif
   } else {
     return {};
   }

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -12,11 +12,6 @@
 #include "React_win.h"
 #include "activeObject/activeObject.h"
 
-#ifndef CORE_ABI
-#include <Modules/AppearanceModule.h>
-#include <Modules/I18nManagerModule.h>
-#endif
-
 #include <react/runtime/ReactInstance.h>
 
 namespace winrt::Microsoft::ReactNative {

package/Microsoft.ReactNative/ReactHost/React_Win.h

@@ -3,9 +3,7 @@
 
 #pragma once
 
-#ifndef CORE_ABI
 #include <IReactInstance.h>
-#endif
 
 #include <functional/functor.h>
 #include <string>

package/Microsoft.ReactNative/ReactNativeAppBuilder.idl

@@ -3,6 +3,7 @@ import "ReactNativeHost.idl";
 import "ReactNativeIsland.idl";
 import "ReactInstanceSettings.idl";
 import "IReactPackageProvider.idl";
+import "ReactNativeWindow.idl";
 
 #include "DocString.h"
 
@@ -14,6 +15,8 @@ namespace Microsoft.ReactNative {
         // Properties
         Microsoft.UI.Windowing.AppWindow AppWindow {get;};
 
+        ReactNativeWindow ReactNativeWindow {get;};
+
         ReactNativeHost ReactNativeHost {get;};
 
         ReactViewOptions ReactViewOptions {get;};

package/Microsoft.ReactNative/ReactPackageBuilder.cpp

@@ -34,6 +34,13 @@ void ReactPackageBuilder::AddTurboModule(
   m_turboModulesProvider->AddModuleProvider(moduleName, moduleProvider, true);
 }
 
+void ReactPackageBuilder::AddEagerInitTurboModule(
+    hstring const &moduleName,
+    ReactModuleProvider const &moduleProvider) noexcept {
+  m_turboModulesProvider->AddModuleProvider(moduleName, moduleProvider, true);
+  m_turboModulesProvider->AddEagerInit(winrt::to_string(moduleName));
+}
+
 void ReactPackageBuilder::AddViewComponent(
     winrt::hstring componentName,
     ReactViewComponentProvider const &viewComponentProvider) noexcept {

package/Microsoft.ReactNative/ReactPackageBuilder.h

@@ -20,6 +20,7 @@ struct ReactPackageBuilder : winrt::implements<ReactPackageBuilder, IReactPackag
  public: // IReactPackageBuilder
   void AddModule(hstring const &moduleName, ReactModuleProvider const &moduleProvider) noexcept;
   void AddTurboModule(hstring const &moduleName, ReactModuleProvider const &moduleProvider) noexcept;
+  void AddEagerInitTurboModule(hstring const &moduleName, ReactModuleProvider const &moduleProvider) noexcept;
 
   // IReactPackageBuilderFabric
   void AddViewComponent(winrt::hstring componentName, ReactViewComponentProvider const &viewComponentProvider) noexcept;

package/Microsoft.ReactNative/RedBox.cpp

@@ -14,8 +14,6 @@
 #include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Foundation.h>
 
-#ifndef CORE_ABI
-
 #include <ReactCoreInjection.h>
 #include <Shobjidl.h>
 #include <Utils/Helpers.h>
@@ -27,7 +25,6 @@
 #include <winrt/Windows.Web.Http.h>
 #include "CppWinRTIncludes.h"
 #include "Utils/Helpers.h"
-#endif // CORE_ABI
 #include "XamlUtils.h"
 
 using namespace winrt::Windows::Foundation;
@@ -36,7 +33,6 @@ namespace Mso::React {
 
 using IInspectable = winrt::Windows::Foundation::IInspectable;
 
-#ifndef CORE_ABI
 struct RedBox : public std::enable_shared_from_this<RedBox> {
   RedBox(
       winrt::Microsoft::ReactNative::ReactPropertyBag &propBag,
@@ -272,7 +268,6 @@ struct DefaultRedBoxHandler final : public std::enable_shared_from_this<DefaultR
   std::vector<std::shared_ptr<RedBox>> m_redBoxes; // Protected by m_lockRedBox
   const Mso::WeakPtr<IReactHost> m_weakReactHost;
 };
-#endif // CORE_ABI
 
 struct RedBoxHandler final : public Mso::React::IRedBoxHandler {
   RedBoxHandler(winrt::Microsoft::ReactNative::IRedBoxHandler const &redBoxHandler) : m_redBoxHandler(redBoxHandler) {}
@@ -316,11 +311,7 @@ std::shared_ptr<IRedBoxHandler> CreateDefaultRedBoxHandler(
     const winrt::Microsoft::ReactNative::ReactPropertyBag &propBag,
     Mso::WeakPtr<IReactHost> &&weakReactHost,
     const Mso::React::IDispatchQueue2 &uiQueue) noexcept {
-#ifndef CORE_ABI
   return std::make_shared<DefaultRedBoxHandler>(propBag, std::move(weakReactHost), uiQueue);
-#else
-  return nullptr;
-#endif
 }
 
 } // namespace Mso::React

package/Microsoft.ReactNative/RedBoxHandler.cpp

@@ -61,11 +61,7 @@ struct DefaultRedBoxHandler : winrt::implements<DefaultRedBoxHandler, IRedBoxHan
 };
 
 IRedBoxHandler RedBoxHelper::CreateDefaultHandler(winrt::Microsoft::ReactNative::ReactNativeHost const &host) noexcept {
-#ifndef CORE_ABI
   return winrt::make<DefaultRedBoxHandler>(host);
-#else
-  return nullptr;
-#endif
 }
 
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/TurboModulesProvider.cpp

@@ -494,16 +494,11 @@ std::shared_ptr<facebook::react::TurboModule> TurboModulesProvider::getModule(
 }
 
 std::vector<std::string> TurboModulesProvider::getEagerInitModuleNames() noexcept {
-  std::vector<std::string> eagerModules;
-  auto it = m_moduleProviders.find("UIManager");
-  if (it != m_moduleProviders.end()) {
-    eagerModules.push_back("UIManager");
-  }
-  it = m_moduleProviders.find("FabricUIManagerBinding");
-  if (it != m_moduleProviders.end()) {
-    eagerModules.push_back("FabricUIManagerBinding");
-  }
-  return eagerModules;
+  return m_eagerInitModuleNames;
+}
+
+void TurboModulesProvider::AddEagerInit(std::string moduleName) noexcept {
+  m_eagerInitModuleNames.push_back(moduleName);
 }
 
 void TurboModulesProvider::SetReactContext(const IReactContext &reactContext) noexcept {

package/Microsoft.ReactNative/TurboModulesProvider.h

@@ -26,6 +26,7 @@ class TurboModulesProvider final : public facebook::react::TurboModuleRegistry {
       winrt::hstring const &moduleName,
       ReactModuleProvider const &moduleProvider,
       bool overwriteExisting) noexcept;
+  void AddEagerInit(std::string moduleName) noexcept;
   std::shared_ptr<facebook::react::LongLivedObjectCollection> const &LongLivedObjectCollection() noexcept;
 
  private:
@@ -33,6 +34,7 @@ class TurboModulesProvider final : public facebook::react::TurboModuleRegistry {
   std::shared_ptr<facebook::react::LongLivedObjectCollection> m_longLivedObjectCollection{
       std::make_shared<facebook::react::LongLivedObjectCollection>()};
   std::unordered_map<std::string, ReactModuleProvider> m_moduleProviders;
+  std::vector<std::string> m_eagerInitModuleNames;
   IReactContext m_reactContext;
 };
 

package/Microsoft.ReactNative/Utils/LocalBundleReader.cpp

@@ -54,7 +54,29 @@ std::string GetBundleFromEmbeddedResource(const winrt::Windows::Foundation::Uri
   return std::string(start, start + size);
 }
 
-std::future<std::string> LocalBundleReader::LoadBundleAsync(const std::wstring bundleUri) {
+namespace {
+
+std::string BufferToString(const winrt::Windows::Storage::Streams::IBuffer &buffer) {
+  std::string result(buffer.Length(), '\0');
+  if (!result.empty()) {
+    auto reader = winrt::Windows::Storage::Streams::DataReader::FromBuffer(buffer);
+    reader.ReadBytes(winrt::array_view<uint8_t>{
+        reinterpret_cast<uint8_t *>(&result[0]), reinterpret_cast<uint8_t *>(&result[result.length()])});
+  }
+  return result;
+}
+
+winrt::Windows::Storage::Streams::IBuffer BytesToBuffer(const void *data, uint32_t size) {
+  winrt::Windows::Storage::Streams::DataWriter writer;
+  auto bytes = static_cast<const uint8_t *>(data);
+  writer.WriteBytes(winrt::array_view<const uint8_t>(bytes, bytes + size));
+  return writer.DetachBuffer();
+}
+
+} // namespace
+
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IBuffer>
+LocalBundleReader::LoadBundleAsync(const std::wstring bundleUri) {
   try {
     co_await winrt::resume_background();
 
@@ -66,41 +88,26 @@ std::future<std::string> LocalBundleReader::LoadBundleAsync(const std::wstring b
       file = co_await winrt::Windows::Storage::StorageFile::GetFileFromApplicationUriAsync(uri);
     } else if (bundleUri.starts_with(L"resource://")) {
       winrt::Windows::Foundation::Uri uri(bundleUri);
-      co_return GetBundleFromEmbeddedResource(uri);
+      auto bytes = GetBundleFromEmbeddedResource(uri);
+      co_return BytesToBuffer(bytes.data(), static_cast<uint32_t>(bytes.size()));
     } else {
       file = co_await winrt::Windows::Storage::StorageFile::GetFileFromPathAsync(bundleUri);
     }
 
-    // Read the buffer manually to avoid a Utf8 -> Utf16 -> Utf8 encoding
-    // roundtrip.
-    auto fileBuffer{co_await winrt::Windows::Storage::FileIO::ReadBufferAsync(file)};
-    auto dataReader{winrt::Windows::Storage::Streams::DataReader::FromBuffer(fileBuffer)};
-
-    // No need to use length + 1, STL guarantees that string storage is null-terminated.
-    std::string script(fileBuffer.Length(), '\0');
-
-    // Construct the array_view to slice into the first fileBuffer.Length bytes.
-    // DataReader.ReadBytes will read as many bytes as are present in the
-    // array_view. The backing string has fileBuffer.Length() + 1 bytes, without
-    // an explicit end it will read 1 byte to many and throw.
-    dataReader.ReadBytes(winrt::array_view<uint8_t>{
-        reinterpret_cast<uint8_t *>(&script[0]), reinterpret_cast<uint8_t *>(&script[script.length()])});
-    dataReader.Close();
-
-    co_return script;
+    co_return co_await winrt::Windows::Storage::FileIO::ReadBufferAsync(file);
   }
   // RuntimeScheduler only handles std::exception or jsi::JSError
-  catch (winrt::hresult_error const &e) {
-    throw std::exception(winrt::to_string(e.message()).c_str());
+  catch (winrt::hresult_error const &) {
+    throw;
   }
 }
 
 std::string LocalBundleReader::LoadBundle(const std::wstring &bundlePath) {
-  return LoadBundleAsync(bundlePath).get();
+  return BufferToString(LoadBundleAsync(bundlePath).get());
 }
 
 StorageFileBigString::StorageFileBigString(const std::wstring &path) {
-  m_futureBuffer = LocalBundleReader::LoadBundleAsync(path);
+  m_pendingLoad = LocalBundleReader::LoadBundleAsync(path);
 }
 
 bool StorageFileBigString::isAscii() const {
@@ -118,8 +125,9 @@ size_t StorageFileBigString::size() const {
 }
 
 void StorageFileBigString::ensure() const {
-  if (m_string.empty()) {
-    m_string = m_futureBuffer.get();
+  if (m_pendingLoad) {
+    m_string = BufferToString(m_pendingLoad.get());
+    m_pendingLoad = nullptr;
   }
 }
 

package/Microsoft.ReactNative/Utils/LocalBundleReader.h

@@ -3,14 +3,16 @@
 
 #pragma once
 #include <cxxreact/JSBigString.h>
-#include <future>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Storage.Streams.h>
 #include <string>
 
 namespace Microsoft::ReactNative {
 
 class LocalBundleReader {
  public:
-  static std::future<std::string> LoadBundleAsync(const std::wstring bundlePath);
+  static winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IBuffer> LoadBundleAsync(
+      const std::wstring bundlePath);
   static std::string LoadBundle(const std::wstring &bundlePath);
 };
 
@@ -24,7 +26,7 @@ class StorageFileBigString : public facebook::react::JSBigString {
   void ensure() const;
 
  private:
-  mutable std::future<std::string> m_futureBuffer;
+  mutable winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IBuffer> m_pendingLoad;
   mutable std::string m_string;
 };
 

package/Microsoft.ReactNative/Utils/ValueUtils.cpp

@@ -48,7 +48,7 @@ struct ColorComp {
 };
 
 winrt::Color ColorFromNumber(DWORD argb) noexcept {
-  return xaml::FromArgb(GetAFromArgb(argb), GetRFromArgb(argb), GetGFromArgb(argb), GetBFromArgb(argb));
+  return winrt::Windows::UI::Color{GetAFromArgb(argb), GetRFromArgb(argb), GetGFromArgb(argb), GetBFromArgb(argb)};
 }
 
 REACTWINDOWS_API_(winrt::Color) ColorFrom(const folly::dynamic &d) {

package/Microsoft.ReactNative.Cxx/CppWinRTIncludes.h

@@ -2,14 +2,11 @@
 // Licensed under the MIT License.
 
 #pragma once
-#include "NamespaceRedirect.h"
-
 #include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Foundation.h>
 
 #include <winrt/Microsoft.UI.Xaml.h>
 
-#define XAML_CPPWINRT_NAMESPACE winrt::Microsoft::UI::Xaml
 namespace xaml = winrt::Microsoft::UI::Xaml;
 namespace comp = winrt::Microsoft::UI::Composition;
 namespace ui = winrt::Microsoft::UI;
@@ -28,7 +25,3 @@ using namespace Windows::UI::Core;
 using namespace Windows::Foundation;
 using namespace Windows::Foundation::Collections;
 } // namespace winrt
-
-#define _QUOTE(x) L#x
-#define QUOTE(x) _QUOTE(x)
-#define XAML_NAMESPACE_STR QUOTE(XAML_NAMESPACE)

package/Microsoft.ReactNative.Cxx/DesktopWindowBridge.h

@@ -8,9 +8,6 @@
 #include <winrt/Windows.Foundation.h>
 #include <functional>
 
-#if !defined(CORE_ABI) && !defined(__APPLE__) && \
-    WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM | WINAPI_PARTITION_GAMES)
-
 #include <winrt/Microsoft.ReactNative.h>
 
 #include "CppWinRTIncludes.h"
@@ -63,25 +60,6 @@ inline std::unordered_map<uint32_t, ReactNotificationSubscription> SubscribeToWi
   return result;
 }
 
-#else
-namespace winrt::Microsoft::ReactNative {
-
-/// Stubs for UWP
-template <typename... T>
-void ForwardWindowMessage(const ReactNotificationService &svc, T &&...) noexcept {}
-
-template <typename... T>
-ReactNotificationSubscription SubscribeToWindowMessage(const ReactNotificationService &svc, T &&...) noexcept {
-  return nullptr;
-}
-
-template <typename... T>
-std::unordered_map<uint32_t, ReactNotificationSubscription>
-SubscribeToWindowMessage(const ReactNotificationService &svc, std::initializer_list<uint32_t> msgs, T &&...) noexcept {
-  return std::unordered_map<uint32_t, ReactNotificationSubscription>{};
-}
-#endif
-
 namespace details {
 struct IndirectLibraryDeleter {
   void operator()(void *l) {

package/Microsoft.ReactNative.Cxx/ModuleRegistration.cpp

@@ -18,7 +18,10 @@ ModuleRegistration::ModuleRegistration(wchar_t const *moduleName) noexcept : m_m
 void AddAttributedModules(IReactPackageBuilder const &packageBuilder, bool useTurboModules) noexcept {
   for (auto const *reg = ModuleRegistration::Head(); reg != nullptr; reg = reg->Next()) {
     if (useTurboModules || reg->ShouldRegisterAsTurboModule())
-      packageBuilder.AddTurboModule(reg->ModuleName(), reg->MakeModuleProvider());
+      if (reg->IsEagerInit())
+        packageBuilder.AddEagerInitTurboModule(reg->ModuleName(), reg->MakeModuleProvider());
+      else
+        packageBuilder.AddTurboModule(reg->ModuleName(), reg->MakeModuleProvider());
     else
       packageBuilder.AddModule(reg->ModuleName(), reg->MakeModuleProvider());
   }
@@ -31,7 +34,10 @@ bool TryAddAttributedModule(
   for (auto const *reg = ModuleRegistration::Head(); reg != nullptr; reg = reg->Next()) {
     if (moduleName == reg->ModuleName()) {
       if (useTurboModule || reg->ShouldRegisterAsTurboModule()) {
-        packageBuilder.AddTurboModule(moduleName, reg->MakeModuleProvider());
+        if (reg->IsEagerInit())
+          packageBuilder.AddEagerInitTurboModule(moduleName, reg->MakeModuleProvider());
+        else
+          packageBuilder.AddTurboModule(moduleName, reg->MakeModuleProvider());
       } else {
         packageBuilder.AddModule(moduleName, reg->MakeModuleProvider());
       }

package/Microsoft.ReactNative.Cxx/ModuleRegistration.h

@@ -17,19 +17,24 @@
 // The macros below are internal implementation details for macro defined in nativeModules.h
 //
 
+// ADL-based fallback: returns false for any type not tagged by the macros below.
+// Using ADL instead of explicit template specialization allows the macros to be
+// used inside a namespace (explicit specializations of a global template must
+// occur at global scope, which the macros cannot guarantee).
 template <typename T>
-struct IsReactTurboModule;
+constexpr bool ReactIsReactTurboModuleImpl(T *) noexcept {
+  return false;
+}
 
-// Default to false if no specific override
 template <typename T>
-struct IsReactTurboModule : std::false_type {};
+struct IsReactTurboModule : std::bool_constant<ReactIsReactTurboModuleImpl(static_cast<T *>(nullptr))> {};
 
 #define INTERNAL_REACT_MODULE_REGISTRATION_AND_PROVIDER(                                                            \
-    moduleStruct, moduleName, eventEmitterName, isReactTurboModule)                                                 \
+    moduleStruct, moduleName, eventEmitterName, isReactTurboModule, isEagerInit)                                    \
   struct moduleStruct;                                                                                              \
                                                                                                                     \
-  template <>                                                                                                       \
-  struct IsReactTurboModule<moduleStruct> : std::isReactTurboModule##_type {};                                      \
+  constexpr bool ReactIsReactTurboModuleImpl(moduleStruct *) noexcept { return isReactTurboModule; }                \
+  constexpr bool ReactIsEagerInitTurboModuleImpl(moduleStruct *) noexcept { return isEagerInit; }                   \
                                                                                                                     \
   template <class TDummy>                                                                                           \
   struct moduleStruct##_ModuleRegistration final : winrt::Microsoft::ReactNative::ModuleRegistration {              \
@@ -40,6 +45,7 @@ struct IsReactTurboModule : std::false_type {};
     }                                                                                                               \
                                                                                                                     \
     bool ShouldRegisterAsTurboModule() const noexcept override { return isReactTurboModule; }                       \
+    bool IsEagerInit() const noexcept override { return isEagerInit; }                                              \
                                                                                                                     \
     static const moduleStruct##_ModuleRegistration Registration;                                                    \
   };                                                                                                                \
@@ -55,7 +61,7 @@ struct IsReactTurboModule : std::false_type {};
   }
 
 #define INTERNAL_REACT_MODULE_3_ARGS(moduleStruct, moduleName, eventEmitterName) \
-  INTERNAL_REACT_MODULE_REGISTRATION_AND_PROVIDER(moduleStruct, moduleName, eventEmitterName, false)
+  INTERNAL_REACT_MODULE_REGISTRATION_AND_PROVIDER(moduleStruct, moduleName, eventEmitterName, false, false)
 
 #define INTERNAL_REACT_MODULE_2_ARGS(moduleStruct, moduleName) \
   INTERNAL_REACT_MODULE_3_ARGS(moduleStruct, moduleName, L"")
@@ -66,17 +72,16 @@ struct IsReactTurboModule : std::false_type {};
   INTERNAL_REACT_RECOMPOSER_4(     \
       (__VA_ARGS__, INTERNAL_REACT_MODULE_3_ARGS, INTERNAL_REACT_MODULE_2_ARGS, INTERNAL_REACT_MODULE_1_ARG, ))
 
-#define INTERNAL_REACT_MODULE_NO_REGISTRATION_AND_PROVIDER(                                            \
-    moduleStruct, moduleName, eventEmitterName, isReactTurboModule)                                    \
-  struct moduleStruct;                                                                                 \
-                                                                                                       \
-  template <>                                                                                          \
-  struct IsReactTurboModule<moduleStruct> : std::isReactTurboModule##_type {};                         \
-                                                                                                       \
-  template <class TRegistry>                                                                           \
-  constexpr void GetReactModuleInfo(moduleStruct *, TRegistry &registry) noexcept {                    \
-    registry.RegisterModule(                                                                           \
-        moduleName, eventEmitterName, winrt::Microsoft::ReactNative::ReactAttributeId<__COUNTER__>{}); \
+#define INTERNAL_REACT_MODULE_NO_REGISTRATION_AND_PROVIDER(                                                           \
+    moduleStruct, moduleName, eventEmitterName, isReactTurboModule)                                                   \
+  struct moduleStruct;                                                                                                \
+                                                                                                                      \
+  [[maybe_unused]] constexpr bool ReactIsReactTurboModuleImpl(moduleStruct *) noexcept { return isReactTurboModule; } \
+                                                                                                                      \
+  template <class TRegistry>                                                                                          \
+  constexpr void GetReactModuleInfo(moduleStruct *, TRegistry &registry) noexcept {                                   \
+    registry.RegisterModule(                                                                                          \
+        moduleName, eventEmitterName, winrt::Microsoft::ReactNative::ReactAttributeId<__COUNTER__>{});                \
   }
 
 // Another version of REACT_MODULE but does not do auto registration
@@ -101,17 +106,27 @@ struct IsReactTurboModule : std::false_type {};
 
 // Register struct as a ReactNative module.
 #define INTERNAL_REACT_TURBO_MODULE_2_ARGS(moduleStruct, moduleName) \
-  INTERNAL_REACT_MODULE_REGISTRATION_AND_PROVIDER(moduleStruct, moduleName, L"", true)
+  INTERNAL_REACT_MODULE_REGISTRATION_AND_PROVIDER(moduleStruct, moduleName, L"", true, false)
+
+#define INTERNAL_REACT_EAGER_TURBO_MODULE_2_ARGS(moduleStruct, moduleName) \
+  INTERNAL_REACT_MODULE_REGISTRATION_AND_PROVIDER(moduleStruct, moduleName, L"", true, true)
 
 #define INTERNAL_REACT_TURBO_MODULE_1_ARG(moduleStruct) \
   INTERNAL_REACT_TURBO_MODULE_2_ARGS(moduleStruct, L## #moduleStruct)
 
+#define INTERNAL_REACT_EAGER_TURBO_MODULE_1_ARG(moduleStruct) \
+  INTERNAL_REACT_EAGER_TURBO_MODULE_2_ARGS(moduleStruct, L## #moduleStruct)
+
 #define INTERNAL_REACT_TURBO_MODULE(...) \
   INTERNAL_REACT_RECOMPOSER_3((__VA_ARGS__, INTERNAL_REACT_TURBO_MODULE_2_ARGS, INTERNAL_REACT_TURBO_MODULE_1_ARG, ))
 
+#define INTERNAL_REACT_EAGER_TURBO_MODULE(...) \
+  INTERNAL_REACT_RECOMPOSER_3(                 \
+      (__VA_ARGS__, INTERNAL_REACT_EAGER_TURBO_MODULE_2_ARGS, INTERNAL_REACT_EAGER_TURBO_MODULE_1_ARG, ))
+
 // Another version of REACT_MODULE but does not do auto registration
 #define INTERNAL_REACT_TURBO_MODULE_NOREG_2_ARGS(moduleStruct, moduleName) \
-  INTERNAL_REACT_MODULE_NO_REGISTRATION_AND_PROVIDER(moduleStruct, moduleName, L"", true)
+  INTERNAL_REACT_MODULE_NO_REGISTRATION_AND_PROVIDER(moduleStruct, moduleName, L"", true, false)
 
 #define INTERNAL_REACT_TURBO_MODULE_NOREG_1_ARG(moduleStruct) \
   INTERNAL_REACT_TURBO_MODULE_NOREG_2_ARGS(moduleStruct, L## #moduleStruct)
@@ -150,6 +165,7 @@ struct ModuleRegistration {
 
   virtual ReactModuleProvider MakeModuleProvider() const noexcept = 0;
   virtual bool ShouldRegisterAsTurboModule() const noexcept = 0;
+  virtual bool IsEagerInit() const noexcept = 0;
 
   static ModuleRegistration const *Head() noexcept {
     return s_head;

package/Microsoft.ReactNative.Cxx/NamespaceRedirect.h

@@ -1,4 +1 @@
 #pragma once
-
-#define XAML_NAMESPACE Microsoft.UI.Xaml
-#define COMP_NAMESPACE Microsoft.UI.Composition

package/Microsoft.ReactNative.Cxx/NativeModules.h

@@ -47,6 +47,11 @@
 #define REACT_TURBO_MODULE(/* moduleStruct, [opt] moduleName */...) \
   INTERNAL_REACT_TURBO_MODULE(__VA_ARGS__)(__VA_ARGS__)
 
+// Same as REACT_TURBO_MODULE, but will register using AddEagerInitTurboModule, and this module
+// will be created and init'd on instance creation.
+#define REACT_EAGER_TURBO_MODULE(/* moduleStruct, [opt] moduleName */...) \
+  INTERNAL_REACT_EAGER_TURBO_MODULE(__VA_ARGS__)(__VA_ARGS__)
+
 // REACT_MODULE_NOREG is REACT_MODULE without auto registration
 // they have the same arguments
 #define REACT_MODULE_NOREG(/* moduleStruct, [opt] moduleName, [opt] eventEmitterName */...) \
@@ -522,7 +527,8 @@ struct ModuleJsiInitMethodInfo<void (TModule::*)(ReactContext const &, facebook:
     return
         [module = static_cast<ModuleType *>(module), method](
             ReactContext const &reactContext, winrt::Windows::Foundation::IInspectable const &runtimeHandle) noexcept {
-          (module->*method)(reactContext, GetOrCreateContextRuntime(reactContext, runtimeHandle));
+          if (runtimeHandle)
+            (module->*method)(reactContext, GetOrCreateContextRuntime(reactContext, runtimeHandle));
         };
   }
 };
@@ -918,7 +924,7 @@ struct ModuleEventFieldInfo<TFunc<void(TArgs...)> TModule::*> {
       return [module = static_cast<ModuleType *>(module), field](IReactContext const &) noexcept {
         // Default emitter will do nothing
         // This will be replaced with a method that will call the jsi EventEmitter when JS requests the emitter
-        module->*field = [](TArgs... args) noexcept {};
+        module->*field = [](TArgs... /*args*/) noexcept {};
       };
     } else {
       return [module = static_cast<ModuleType *>(module), field, eventName, eventEmitterName](

package/Microsoft.ReactNative.Cxx/XamlUtils.h

@@ -30,12 +30,3 @@ WINRT_IMPL_GetModuleHandleW(_In_opt_ LPCWSTR lpModuleName);
 #endif
 WINRT_IMPL_LINK(GetModuleHandleW, 4);
 #undef WINRT_IMPL_LINK
-
-namespace XAML_CPPWINRT_NAMESPACE {
-
-// Using Windows::UI::ColorHelper causes the process to load Windows.UI.Xaml.dll which is not needed just to fill a
-// Color struct
-inline winrt::Windows::UI::Color FromArgb(uint8_t a, uint8_t r, uint8_t g, uint8_t b) {
-  return winrt::Windows::UI::Color{a, r, g, b};
-}
-} // namespace XAML_CPPWINRT_NAMESPACE