react-native-windows 0.71.7 → 0.72.0-preview.1

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.cpp

@@ -101,14 +101,33 @@ void ImageLoader::Initialize(React::ReactContext const &reactContext) noexcept {
   m_context = reactContext;
 }
 
-void ImageLoader::getSize(std::string uri, React::ReactPromise<React::JSValue> &&result) noexcept {
-  getSizeWithHeaders(std::move(uri), {}, std::move(result));
+void ImageLoader::getSize(std::string uri, React::ReactPromise<std::vector<double>> &&result) noexcept {
+  m_context.UIDispatcher().Post(
+      [context = m_context, uri = std::move(uri), result = std::move(result)]() mutable noexcept {
+        GetImageSizeAsync(
+            std::move(uri),
+            {},
+            [result, context](double width, double height) noexcept {
+              context.JSDispatcher().Post([result = std::move(result), width, height]() noexcept {
+                result.Resolve(std::vector<double>{width, height});
+              });
+            },
+            [result, context]() noexcept {
+              context.JSDispatcher().Post([result = std::move(result)]() noexcept { result.Reject("Failed"); });
+            }
+#ifdef USE_FABRIC
+            ,
+            IsFabricEnabled(context.Properties().Handle())
+#endif // USE_FABRIC
+        );
+      });
 }
 
 void ImageLoader::getSizeWithHeaders(
     std::string uri,
     React::JSValue &&headers,
-    React::ReactPromise<React::JSValue> &&result) noexcept {
+    React::ReactPromise<Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType>
+        &&result) noexcept {
   m_context.UIDispatcher().Post([context = m_context,
                                  uri = std::move(uri),
                                  headers = std::move(headers),
@@ -116,9 +135,10 @@ void ImageLoader::getSizeWithHeaders(
     GetImageSizeAsync(
         std::move(uri),
         std::move(headers),
-        [result, context](int32_t width, int32_t height) noexcept {
+        [result, context](double width, double height) noexcept {
           context.JSDispatcher().Post([result = std::move(result), width, height]() noexcept {
-            result.Resolve(React::JSValueArray{width, height});
+            result.Resolve(
+                Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType{width, height});
           });
         },
         [result, context]() noexcept {
@@ -132,7 +152,7 @@ void ImageLoader::getSizeWithHeaders(
   });
 }
 
-void ImageLoader::prefetchImage(std::string uri, React::ReactPromise<React::JSValue> &&result) noexcept {
+void ImageLoader::prefetchImage(std::string uri, React::ReactPromise<bool> &&result) noexcept {
   // NYI
   result.Resolve(true);
 }
@@ -141,7 +161,7 @@ void ImageLoader::prefetchImageWithMetadata(
     std::string uri,
     std::string queryRootName,
     double rootTag,
-    React::ReactPromise<React::JSValue> &&result) noexcept {
+    React::ReactPromise<bool> &&result) noexcept {
   // NYI
   result.Resolve(true);
 }

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "codegen/NativeImageLoaderIOSSpec.g.h"
+#include <NativeImageLoaderIOSSpec.g.h>
 #include <NativeModules.h>
 #include <winrt/Windows.ApplicationModel.h>
 #include <winrt/Windows.Foundation.h>
@@ -19,21 +20,24 @@ struct ImageLoader {
   void Initialize(React::ReactContext const &reactContext) noexcept;
 
   REACT_METHOD(getSize)
-  void getSize(std::string uri, React::ReactPromise<React::JSValue> &&result) noexcept;
+  void getSize(std::string uri, React::ReactPromise<std::vector<double>> &&result) noexcept;
 
   REACT_METHOD(getSizeWithHeaders)
-  void
-  getSizeWithHeaders(std::string uri, React::JSValue &&headers, React::ReactPromise<React::JSValue> &&result) noexcept;
+  void getSizeWithHeaders(
+      std::string uri,
+      React::JSValue &&headers,
+      React::ReactPromise<Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType>
+          &&result) noexcept;
 
   REACT_METHOD(prefetchImage)
-  void prefetchImage(std::string uri, React::ReactPromise<React::JSValue> &&result) noexcept;
+  void prefetchImage(std::string uri, React::ReactPromise<bool> &&result) noexcept;
 
   REACT_METHOD(prefetchImageWithMetadata)
   void prefetchImageWithMetadata(
       std::string uri,
       std::string queryRootName,
       double rootTag,
-      React::ReactPromise<React::JSValue> &&result) noexcept;
+      React::ReactPromise<bool> &&result) noexcept;
 
   REACT_METHOD(queryCache)
   void queryCache(std::vector<std::string> const &uris, React::ReactPromise<React::JSValue> &&result) noexcept;

package/Microsoft.ReactNative/Modules/LinkingManagerModule.cpp

@@ -48,10 +48,8 @@ LinkingManager::~LinkingManager() noexcept {
   }
 }
 
-/*static*/ fire_and_forget LinkingManager::canOpenURL(
-    std::string url,
-    ::React::ReactPromise<::React::JSValue> result) noexcept {
-  winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(url));
+/*static*/ fire_and_forget LinkingManager::canOpenURL(std::wstring url, ::React::ReactPromise<bool> result) noexcept {
+  winrt::Windows::Foundation::Uri uri(url);
   auto status = co_await Launcher::QueryUriSupportAsync(uri, LaunchQuerySupportType::Uri);
   if (status == LaunchQuerySupportStatus::Available) {
     result.Resolve(true);
@@ -60,21 +58,21 @@ LinkingManager::~LinkingManager() noexcept {
   }
 }
 
-fire_and_forget openUrlAsync(std::string url, ::React::ReactPromise<::React::JSValue> result) noexcept {
+fire_and_forget openUrlAsync(std::wstring url, ::React::ReactPromise<void> result) noexcept {
   try {
-    winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(url));
+    winrt::Windows::Foundation::Uri uri(url);
 
     if (co_await Launcher::LaunchUriAsync(uri)) {
-      result.Resolve({});
+      result.Resolve();
     } else {
-      result.Reject(("Unable to open URL: " + url).c_str());
+      result.Reject(("Unable to open URL: " + Utf16ToUtf8(url)).c_str());
     }
   } catch (winrt::hresult_error &e) {
-    result.Reject(("Unable to open URL: " + url + "error: " + winrt::to_string(e.message())).c_str());
+    result.Reject(("Unable to open URL: " + Utf16ToUtf8(url) + "error: " + winrt::to_string(e.message())).c_str());
   }
 }
 
-void LinkingManager::openURL(std::string &&url, ::React::ReactPromise<::React::JSValue> &&result) noexcept {
+void LinkingManager::openURL(std::wstring &&url, ::React::ReactPromise<void> &&result) noexcept {
   m_context.UIDispatcher().Post(
       [url = std::move(url), result = std::move(result)]() { openUrlAsync(std::move(url), std::move(result)); });
 }
@@ -99,7 +97,7 @@ void LinkingManager::HandleOpenUri(winrt::hstring const &uri) noexcept {
   m_context.EmitJSEvent(L"RCTDeviceEventEmitter", L"url", React::JSValueObject{{"url", winrt::to_string(uri)}});
 }
 
-/*static*/ void LinkingManager::openSettings(::React::ReactPromise<::React::JSValue> &&result) noexcept {
+/*static*/ void LinkingManager::openSettings(::React::ReactPromise<void> &&result) noexcept {
   result.Reject(L"Could not open settings.  Not suported on this platform.");
 }
 
@@ -111,7 +109,7 @@ void LinkingManager::HandleOpenUri(winrt::hstring const &uri) noexcept {
   // no-op
 }
 
-/*static*/ void LinkingManager::getInitialURL(::React::ReactPromise<::React::JSValue> &&result) noexcept {
+/*static*/ void LinkingManager::getInitialURL(::React::ReactPromise<std::string> &&result) noexcept {
   if (s_initialUri) {
     result.Resolve(to_string(s_initialUri.AbsoluteUri()));
   } else {

package/Microsoft.ReactNative/Modules/LinkingManagerModule.h

@@ -22,13 +22,13 @@ struct LinkingManager {
   void Initialize(React::ReactContext const &reactContext) noexcept;
 
   REACT_METHOD(canOpenURL)
-  static winrt::fire_and_forget canOpenURL(std::string url, ::React::ReactPromise<::React::JSValue> result) noexcept;
+  static winrt::fire_and_forget canOpenURL(std::wstring url, ::React::ReactPromise<bool> result) noexcept;
 
   REACT_METHOD(openURL)
-  void openURL(std::string &&url, ::React::ReactPromise<::React::JSValue> &&result) noexcept;
+  void openURL(std::wstring &&url, ::React::ReactPromise<void> &&result) noexcept;
 
   REACT_METHOD(openSettings)
-  static void openSettings(::React::ReactPromise<::React::JSValue> &&result) noexcept;
+  static void openSettings(::React::ReactPromise<void> &&result) noexcept;
 
   REACT_METHOD(addListener)
   static void addListener(std::string eventName) noexcept;
@@ -37,7 +37,7 @@ struct LinkingManager {
   static void removeListeners(double count) noexcept;
 
   REACT_METHOD(getInitialURL)
-  static void getInitialURL(::React::ReactPromise<::React::JSValue> &&result) noexcept;
+  static void getInitialURL(::React::ReactPromise<std::string> &&result) noexcept;
 
   static void OpenUri(winrt::Windows::Foundation::Uri const &uri) noexcept;
 

package/Microsoft.ReactNative/Modules/NativeUIManager.cpp

@@ -3,6 +3,7 @@
 
 #include "pch.h"
 
+#include <QuirkSettings.h>
 #include <UI.Xaml.Controls.h>
 #include <UI.Xaml.Input.h>
 #include <UI.Xaml.Media.h>
@@ -1138,7 +1139,26 @@ void NativeUIManager::findSubviewIn(
 
 void NativeUIManager::focus(int64_t reactTag) {
   if (auto shadowNode = static_cast<ShadowNodeBase *>(m_host->FindShadowNodeForTag(reactTag))) {
-    xaml::Input::FocusManager::TryFocusAsync(shadowNode->GetView(), winrt::FocusState::Programmatic);
+    const auto view = shadowNode->GetView();
+
+    // Only allow focus on an element with a XamlRoot that matches the current XamlRoot or that
+    // has a different CoreDispatcher for the XamlRoot, otherwise focusing the element will steal
+    // window focus, which is generally not desired behavior.
+    const auto properties = React::ReactPropertyBag(m_context.Properties());
+    if (winrt::Microsoft::ReactNative::implementation::QuirkSettings::GetSuppressWindowFocusOnViewFocus(properties)) {
+      if (const auto uiElement = view.try_as<xaml::UIElement>()) {
+        if (const auto activeXamlRoot = React::XamlUIService::GetXamlRoot(properties.Handle())) {
+          const auto activeDispatcher = activeXamlRoot.Content() ? activeXamlRoot.Content().Dispatcher() : nullptr;
+          if (uiElement.XamlRoot() != activeXamlRoot && uiElement.Dispatcher() == activeDispatcher) {
+            const auto suppressedFocusMessage = L"Suppressed focus on view in XamlRoot not currently in focus.";
+            m_context.CallJSFunction(L"RCTLog", L"logToConsole", L"warn", suppressedFocusMessage);
+            return;
+          }
+        }
+      }
+    }
+
+    xaml::Input::FocusManager::TryFocusAsync(view, winrt::FocusState::Programmatic);
   }
 }
 

package/Microsoft.ReactNative/QuirkSettings.cpp

@@ -64,6 +64,13 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> MapWindowDeactivatedToAppSt
   properties.Set(MapWindowDeactivatedToAppStateInactiveProperty(), value);
 }
 
+winrt::Microsoft::ReactNative::ReactPropertyId<bool> SuppressWindowFocusOnViewFocusProperty() noexcept {
+  winrt::Microsoft::ReactNative::ReactPropertyId<bool> propId{
+      L"ReactNative.QuirkSettings", L"SuppressWindowFocusOnViewFocus"};
+
+  return propId;
+}
+
 #pragma region IDL interface
 
 /*static*/ void QuirkSettings::SetMatchAndroidAndIOSStretchBehavior(
@@ -96,6 +103,12 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> MapWindowDeactivatedToAppSt
   SetMapWindowDeactivatedToAppStateInactive(ReactPropertyBag(settings.Properties()), value);
 }
 
+/*static*/ void QuirkSettings::SetSuppressWindowFocusOnViewFocus(
+    winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
+    bool value) noexcept {
+  ReactPropertyBag(settings.Properties()).Set(SuppressWindowFocusOnViewFocusProperty(), value);
+}
+
 #pragma endregion IDL interface
 
 /*static*/ bool QuirkSettings::GetMatchAndroidAndIOSStretchBehavior(ReactPropertyBag properties) noexcept {
@@ -120,4 +133,8 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> MapWindowDeactivatedToAppSt
   return properties.Get(MapWindowDeactivatedToAppStateInactiveProperty()).value_or(false);
 }
 
+/*static*/ bool QuirkSettings::GetSuppressWindowFocusOnViewFocus(ReactPropertyBag properties) noexcept {
+  return properties.Get(SuppressWindowFocusOnViewFocusProperty()).value_or(false);
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/QuirkSettings.h

@@ -28,6 +28,7 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
   static bool GetAcceptSelfSigned(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
   static winrt::Microsoft::ReactNative::BackNavigationHandlerKind GetBackHandlerKind(
       winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
+  static bool GetSuppressWindowFocusOnViewFocus(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
   static bool GetEnableFabric(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
@@ -54,6 +55,10 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
   static void SetMapWindowDeactivatedToAppStateInactive(
       winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
       bool value) noexcept;
+
+  static void SetSuppressWindowFocusOnViewFocus(
+      winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
+      bool value) noexcept;
 #pragma endregion Public API - part of IDL interface
 };
 

package/Microsoft.ReactNative/QuirkSettings.idl

@@ -53,5 +53,11 @@ namespace Microsoft.ReactNative
       "`inactive` tracks the [Window.Activated Event](https://docs.microsoft.com/uwp/api/windows.ui.core.corewindow.activated) when the window is deactivated.")
     DOC_DEFAULT("false")
     static void SetMapWindowDeactivatedToAppStateInactive(ReactInstanceSettings settings, Boolean value);
+
+    DOC_STRING(
+        "When running multiple windows from a single UI thread, focusing a native view causes the parent "
+        "window of that view to get focus as well. Set this setting to true to prevent focus of a blurred "
+        "window when a view in that window is programmatically focused.")
+    static void SetSuppressWindowFocusOnViewFocus(ReactInstanceSettings settings, Boolean value);
   }
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/ReactApplication.cpp

@@ -97,6 +97,14 @@ void ReactApplication::JavaScriptBundleFile(hstring const &value) noexcept {
   InstanceSettings().JavaScriptBundleFile(value);
 }
 
+hstring ReactApplication::BundleAppId() noexcept {
+  return InstanceSettings().BundleAppId();
+}
+
+void ReactApplication::BundleAppId(hstring const &value) noexcept {
+  InstanceSettings().BundleAppId(value);
+}
+
 void ReactApplication::OnActivated(Windows::ApplicationModel::Activation::IActivatedEventArgs const &e) {
   if (e.Kind() == Windows::ApplicationModel::Activation::ActivationKind::Protocol) {
     auto protocolActivatedEventArgs{e.as<Windows::ApplicationModel::Activation::ProtocolActivatedEventArgs>()};

package/Microsoft.ReactNative/ReactApplication.h

@@ -91,6 +91,9 @@ struct ReactApplication : NoDefaultCtorReactApplication_base<ReactApplication, x
   hstring JavaScriptBundleFile() noexcept;
   void JavaScriptBundleFile(hstring const &value) noexcept;
 
+  hstring BundleAppId() noexcept;
+  void BundleAppId(hstring const &value) noexcept;
+
   void OnActivated(Windows::ApplicationModel::Activation::IActivatedEventArgs const &e);
   void OnLaunched(activation::LaunchActivatedEventArgs const &e);
   void OnSuspending(IInspectable const &, Windows::ApplicationModel::SuspendingEventArgs const &);

package/Microsoft.ReactNative/ReactApplication.idl

@@ -41,5 +41,8 @@ namespace Microsoft.ReactNative
 
     DOC_STRING("See @ReactInstanceSettings.JavaScriptBundleFile.")
     String JavaScriptBundleFile { get; set; };
+
+    DOC_STRING("See @ReactInstanceSettings.BundleAppId.")
+    String BundleAppId { get; set; };
   }
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/ReactCoreInjection.cpp

@@ -41,6 +41,11 @@ Mso::React::ReactViewOptions ReactViewOptions::CreateViewOptions() noexcept {
 
 ReactCoreInjection::ReactCoreInjection() noexcept {}
 
+static const ReactPropertyId<uint64_t> &TopLevelWindowIdPropertyId() noexcept {
+  static const ReactPropertyId<uint64_t> prop{L"ReactNative.Injection", L"TopLevelWindowId"};
+  return prop;
+}
+
 /*static*/ ReactPropertyId<UIBatchCompleteCallback> ReactCoreInjection::UIBatchCompleteCallbackProperty() noexcept {
   static ReactPropertyId<UIBatchCompleteCallback> prop{L"ReactNative.Injection", L"UIBatchCompleteCallback"};
   return prop;
@@ -80,6 +85,30 @@ ReactCoreInjection::PostToUIBatchingQueueProperty() noexcept {
   postFn(callback);
 }
 
+ReactPropertyId<winrt::hstring> PlatformNameOverrideProperty() noexcept {
+  static ReactPropertyId<winrt::hstring> prop{L"ReactNative.Injection", L"PlatformNameOverride"};
+  return prop;
+}
+
+/*static*/ void ReactCoreInjection::SetPlatformNameOverride(
+    IReactPropertyBag const &properties,
+    winrt::hstring const &platformName) noexcept {
+  ReactNative::ReactPropertyBag(properties).Set(PlatformNameOverrideProperty(), platformName);
+}
+/*static*/ std::string ReactCoreInjection::GetPlatformName(IReactPropertyBag const &properties) noexcept {
+  return winrt::to_string(ReactNative::ReactPropertyBag(properties)
+                              .Get(PlatformNameOverrideProperty())
+                              .value_or(winrt::to_hstring(STRING(RN_PLATFORM))));
+}
+
+uint64_t ReactCoreInjection::GetTopLevelWindowId(const IReactPropertyBag &properties) noexcept {
+  return ReactPropertyBag(properties).Get(TopLevelWindowIdPropertyId()).value_or(0);
+}
+
+void ReactCoreInjection::SetTopLevelWindowId(const IReactPropertyBag &properties, uint64_t windowId) noexcept {
+  ReactPropertyBag(properties).Set(TopLevelWindowIdPropertyId(), windowId);
+}
+
 ReactViewHost::ReactViewHost(
     const ReactNative::ReactNativeHost &host,
     Mso::React::IReactViewHost &viewHost,

package/Microsoft.ReactNative/ReactCoreInjection.h

@@ -46,6 +46,12 @@ struct ReactCoreInjection : ReactCoreInjectionT<ReactCoreInjection> {
   static void PostToUIBatchingQueue(
       ReactNative::IReactContext context,
       ReactNative::ReactDispatcherCallback callback) noexcept;
+
+  static void SetPlatformNameOverride(IReactPropertyBag const &properties, winrt::hstring const &platformName) noexcept;
+  static std::string GetPlatformName(IReactPropertyBag const &properties) noexcept;
+
+  static uint64_t GetTopLevelWindowId(const IReactPropertyBag &properties) noexcept;
+  static void SetTopLevelWindowId(const IReactPropertyBag &properties, uint64_t windowId) noexcept;
 };
 
 struct ReactViewHost : public winrt::implements<ReactViewHost, IReactViewHost> {

package/Microsoft.ReactNative/ReactCoreInjection.idl

@@ -89,6 +89,19 @@ DOC_STRING("Settings per each IReactViewHost associated with an IReactHost insta
 
     DOC_STRING("Post something to the main UI dispatcher using the batching queue")
     static void PostToUIBatchingQueue(IReactContext context, ReactDispatcherCallback callback);
+
+    DOC_STRING("Override platform name. This will change the platform used when requesting bundles from metro. Default: \"windows\"")
+    static void SetPlatformNameOverride(IReactPropertyBag properties, String platformName);
+    
+    DOC_STRING(
+      "Gets the window handle HWND (as an UInt64) for the active top level application window.")
+    static UInt64 GetTopLevelWindowId(IReactPropertyBag properties);
+
+    DOC_STRING(
+      "Sets the window handle HWND (as an UInt64) for the active top level application window."
+      "This must be manually provided to the @ReactInstanceSettings object when using ReactNativeWindows"
+      "without XAML for certain APIs work correctly.")
+    static void SetTopLevelWindowId(IReactPropertyBag properties, UInt64 windowId);
   }
 
 

package/Microsoft.ReactNative/ReactHost/MsoReactContext.cpp

@@ -93,6 +93,13 @@ std::string ReactSettingsSnapshot::JavaScriptBundleFile() const noexcept {
   return {};
 }
 
+std::string ReactSettingsSnapshot::BundleAppId() const noexcept {
+  if (auto instance = m_reactInstance.GetStrongPtr()) {
+    return instance->BundleAppId();
+  }
+  return {};
+}
+
 JSIEngine ReactSettingsSnapshot::JsiEngine() const noexcept {
   if (auto instance = m_reactInstance.GetStrongPtr()) {
     return instance->JsiEngine();

package/Microsoft.ReactNative/ReactHost/MsoReactContext.h

@@ -29,6 +29,7 @@ class ReactSettingsSnapshot final : public Mso::UnknownObject<IReactSettingsSnap
   uint16_t SourceBundlePort() const noexcept override;
   bool RequestInlineSourceMap() const noexcept override;
   std::string JavaScriptBundleFile() const noexcept override;
+  std::string BundleAppId() const noexcept override;
   bool UseDeveloperSupport() const noexcept override;
   JSIEngine JsiEngine() const noexcept override;
 

package/Microsoft.ReactNative/ReactHost/React.h

@@ -104,6 +104,7 @@ struct IReactSettingsSnapshot : IUnknown {
   virtual uint16_t SourceBundlePort() const noexcept = 0;
   virtual bool RequestInlineSourceMap() const noexcept = 0;
   virtual std::string JavaScriptBundleFile() const noexcept = 0;
+  virtual std::string BundleAppId() const noexcept = 0;
   virtual bool UseDeveloperSupport() const noexcept = 0;
   virtual JSIEngine JsiEngine() const noexcept = 0;
 };
@@ -150,6 +151,7 @@ struct ReactDevOptions {
   bool RequestInlineSourceMap{true}; // Request the source map inline
   std::string SourceBundleName; // Bundle name without any extension (e.g. "index.win32"). Default: "index.{PLATFORM}"
   std::string SourceBundleExtension; // Bundle name extension. Default: ".bundle".
+  std::string BundleAppId; // Bundle app id. Default: "".
 
   //! Module name used for loading the debug bundle.
   //! e.g. The modules name registered in the jsbundle via AppRegistry.registerComponent('ModuleName', () =>

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -35,23 +35,31 @@
 #include "DynamicWriter.h"
 #ifndef CORE_ABI
 #include "ConfigureBundlerDlg.h"
-#include "DevMenu.h"
 #endif
+#include "DevMenu.h"
 #include "IReactContext.h"
 #include "IReactDispatcher.h"
 #ifndef CORE_ABI
 #include "Modules/AccessibilityInfoModule.h"
 #include "Modules/AlertModule.h"
+#endif
+#if !defined(CORE_ABI) || defined(USE_FABRIC)
 #include "Modules/Animated/NativeAnimatedModule.h"
+#endif
+#ifndef CORE_ABI
 #include "Modules/AppStateModule.h"
 #include "Modules/AppThemeModuleUwp.h"
 #include "Modules/ClipboardModule.h"
 #endif
 #include "Modules/DevSettingsModule.h"
 #ifndef CORE_ABI
-#include <Modules/ImageViewManagerModule.h>
 #include "Modules/DeviceInfoModule.h"
 #include "Modules/I18nManagerModule.h"
+#endif
+#if !defined(CORE_ABI) || defined(USE_FABRIC)
+#include <Modules/ImageViewManagerModule.h>
+#endif
+#ifndef CORE_ABI
 #include "Modules/LinkingManagerModule.h"
 #include "Modules/LogBoxModule.h"
 #include "Modules/NativeUIManager.h"
@@ -78,6 +86,7 @@
 #include <tuple>
 #include "ChakraRuntimeHolder.h"
 
+#include <Utils/Helpers.h>
 #include "CrashManager.h"
 #include "JsiApi.h"
 #include "ReactCoreInjection.h"
@@ -246,6 +255,7 @@ ReactInstanceWin::ReactInstanceWin(
                                                                onDestroyed = m_options.OnInstanceDestroyed,
                                                                reactContext = m_reactContext]() noexcept {
         whenLoaded.TryCancel(); // It only has an effect if whenLoaded was not set before
+        facebook::react::HermesRuntimeHolder::storeTo(ReactPropertyBag(reactContext->Properties()), nullptr);
         if (onDestroyed) {
           onDestroyed.Get()->Invoke(reactContext);
         }
@@ -355,6 +365,17 @@ void ReactInstanceWin::LoadModules(
   registerTurboModule(
       L"NativeAnimatedModule",
       winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::NativeAnimatedModule>());
+
+#elif defined(CORE_ABI) && defined(USE_FABRIC)
+  if (Microsoft::ReactNative::IsFabricEnabled(m_reactContext->Properties())) {
+    registerTurboModule(
+        L"ImageLoader",
+        winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::ImageLoader>());
+
+    registerTurboModule(
+        L"NativeAnimatedModule",
+        winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::NativeAnimatedModule>());
+  }
 #endif
 
   registerTurboModule(
@@ -382,11 +403,13 @@ void ReactInstanceWin::Initialize() noexcept {
 #ifndef CORE_ABI
   // InitUIManager uses m_legacyReactInstance
   InitUIManager();
+#endif
 
   Microsoft::ReactNative::DevMenuManager::InitDevMenu(m_reactContext, [weakReactHost = m_weakReactHost]() noexcept {
+#ifndef CORE_ABI
     Microsoft::ReactNative::ShowConfigureBundlerDialog(weakReactHost);
+#endif // CORE_ABI
   });
-#endif
 
   m_uiQueue->Post([this, weakThis = Mso::WeakPtr{this}]() noexcept {
     // Objects that must be created on the UI thread
@@ -421,20 +444,19 @@ void ReactInstanceWin::Initialize() noexcept {
           devSettings->useWebDebugger = m_useWebDebugger;
           devSettings->useFastRefresh = m_isFastReloadEnabled;
           devSettings->bundleRootPath = BundleRootPath();
-
+          devSettings->platformName =
+              winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetPlatformName(
+                  strongThis->m_reactContext->Properties());
           devSettings->waitingForDebuggerCallback = GetWaitingForDebuggerCallback();
           devSettings->debuggerAttachCallback = GetDebuggerAttachCallback();
           devSettings->enableDefaultCrashHandler = m_options.EnableDefaultCrashHandler();
-
-#ifndef CORE_ABI
+          devSettings->bundleAppId = BundleAppId();
           devSettings->showDevMenuCallback = [weakThis]() noexcept {
             if (auto strongThis = weakThis.GetStrongPtr()) {
-              strongThis->m_uiQueue->Post([context = strongThis->m_reactContext]() {
-                Microsoft::ReactNative::DevMenuManager::Show(context->Properties());
-              });
+              strongThis->m_uiQueue->Post(
+                  [context = strongThis->m_reactContext]() { Microsoft::ReactNative::DevMenuManager::Show(context); });
             }
           };
-#endif
 
 #ifdef CORE_ABI
           std::vector<facebook::react::NativeModuleDescription> cxxModules;
@@ -463,10 +485,14 @@ void ReactInstanceWin::Initialize() noexcept {
           std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore = nullptr;
 
           switch (m_options.JsiEngine()) {
-            case JSIEngine::Hermes:
-              devSettings->jsiRuntimeHolder =
+            case JSIEngine::Hermes: {
+              auto hermesRuntimeHolder =
                   std::make_shared<facebook::react::HermesRuntimeHolder>(devSettings, m_jsMessageThread.Load());
+              facebook::react::HermesRuntimeHolder::storeTo(
+                  ReactPropertyBag(m_reactContext->Properties()), hermesRuntimeHolder);
+              devSettings->jsiRuntimeHolder = hermesRuntimeHolder;
               break;
+            }
             case JSIEngine::V8:
 #if defined(USE_V8)
             {
@@ -480,10 +506,20 @@ void ReactInstanceWin::Initialize() noexcept {
                       std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
                 }
               }
-            }
+
+              bool enableMultiThreadSupport{false};
+#ifdef USE_FABRIC
+              enableMultiThreadSupport = Microsoft::ReactNative::IsFabricEnabled(m_reactContext->Properties());
+#endif // USE_FABRIC
+
               devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
-                  devSettings, m_jsMessageThread.Load(), std::move(scriptStore), std::move(preparedScriptStore));
-              break;
+                  devSettings,
+                  m_jsMessageThread.Load(),
+                  std::move(scriptStore),
+                  std::move(preparedScriptStore),
+                  enableMultiThreadSupport);
+
+            } break;
 #endif // USE_V8
             case JSIEngine::Chakra:
 #ifndef CORE_ABI
@@ -542,7 +578,8 @@ void ReactInstanceWin::Initialize() noexcept {
 
             if (UseDeveloperSupport() && State() != ReactInstanceState::HasError) {
               folly::dynamic params = folly::dynamic::array(
-                  STRING(RN_PLATFORM),
+                  winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetPlatformName(
+                      m_reactContext->Properties()),
                   DebugBundlePath(),
                   SourceBundleHost(),
                   SourceBundlePort(),
@@ -1125,6 +1162,10 @@ std::string ReactInstanceWin::JavaScriptBundleFile() const noexcept {
   return m_options.Identity;
 }
 
+std::string ReactInstanceWin::BundleAppId() const noexcept {
+  return m_options.DeveloperSettings.BundleAppId;
+}
+
 bool ReactInstanceWin::UseDeveloperSupport() const noexcept {
   return m_options.UseDeveloperSupport();
 }

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -79,6 +79,7 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   uint16_t SourceBundlePort() const noexcept;
   bool RequestInlineSourceMap() const noexcept;
   std::string JavaScriptBundleFile() const noexcept;
+  std::string BundleAppId() const noexcept;
   bool UseDeveloperSupport() const noexcept;
   JSIEngine JsiEngine() const noexcept;