react-native-windows 0.67.0 → 0.68.0-preview.3

package/Microsoft.ReactNative/Modules/LinkingManagerModule.cpp

@@ -16,8 +16,6 @@
 #pragma optimize("", off)
 #endif
 
-using Callback = facebook::xplat::module::CxxModule::Callback;
-
 using namespace winrt;
 using namespace Windows::Foundation;
 using namespace Windows::System;
@@ -26,40 +24,23 @@ using namespace ::Microsoft::Common::Unicode;
 namespace Microsoft::ReactNative {
 
 //
-// LinkingManagerModule helpers
+// LinkingManager
 //
 
-static fire_and_forget openURLAsync(Uri uri, Callback success, Callback error) {
-  if (co_await Launcher::LaunchUriAsync(uri)) {
-    success({true});
-  } else {
-    error({folly::dynamic::object("code", 1)("message", "Unable to open URL: " + Utf16ToUtf8(uri.DisplayUri()))});
-  }
-}
-
-static fire_and_forget canOpenURLAsync(Uri uri, Callback success, Callback /*error*/) {
-  auto status = co_await Launcher::QueryUriSupportAsync(uri, LaunchQuerySupportType::Uri);
-  if (status == LaunchQuerySupportStatus::Available) {
-    success({true});
-  } else {
-    success({false});
-  }
+void LinkingManager::Initialize(React::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
 }
 
-//
-// LinkingManagerModule
-//
-const char *LinkingManagerModule::name = "LinkingManager";
-/*static*/ std::mutex LinkingManagerModule::s_mutex;
-/*static*/ Uri LinkingManagerModule::s_initialUri{nullptr};
-/*static*/ std::vector<LinkingManagerModule *> LinkingManagerModule::s_linkingModules;
+/*static*/ std::mutex LinkingManager::s_mutex;
+/*static*/ Uri LinkingManager::s_initialUri{nullptr};
+/*static*/ std::vector<LinkingManager *> LinkingManager::s_linkingModules;
 
-LinkingManagerModule::LinkingManagerModule() noexcept {
+LinkingManager::LinkingManager() noexcept {
   std::scoped_lock lock{s_mutex};
   s_linkingModules.push_back(this);
 }
 
-LinkingManagerModule::~LinkingManagerModule() noexcept {
+LinkingManager::~LinkingManager() noexcept {
   std::scoped_lock lock{s_mutex};
   auto it = std::find(s_linkingModules.begin(), s_linkingModules.end(), this);
   if (it != s_linkingModules.end()) {
@@ -67,12 +48,43 @@ LinkingManagerModule::~LinkingManagerModule() noexcept {
   }
 }
 
-/*static*/ void LinkingManagerModule::OpenUri(winrt::Windows::Foundation::Uri const &uri) noexcept {
+/*static*/ fire_and_forget LinkingManager::canOpenURL(
+    std::string url,
+    ::React::ReactPromise<::React::JSValue> result) noexcept {
+  winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(url));
+  auto status = co_await Launcher::QueryUriSupportAsync(uri, LaunchQuerySupportType::Uri);
+  if (status == LaunchQuerySupportStatus::Available) {
+    result.Resolve(true);
+  } else {
+    result.Resolve(false);
+  }
+}
+
+fire_and_forget openUrlAsync(std::string url, ::React::ReactPromise<::React::JSValue> result) noexcept {
+  try {
+    winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(url));
+
+    if (co_await Launcher::LaunchUriAsync(uri)) {
+      result.Resolve({});
+    } else {
+      result.Reject(("Unable to open URL: " + url).c_str());
+    }
+  } catch (winrt::hresult_error &e) {
+    result.Reject(("Unable to open URL: " + url + "error: " + winrt::to_string(e.message())).c_str());
+  }
+}
+
+void LinkingManager::openURL(std::string &&url, ::React::ReactPromise<::React::JSValue> &&result) noexcept {
+  m_context.UIDispatcher().Post(
+      [url = std::move(url), result = std::move(result)]() { openUrlAsync(std::move(url), std::move(result)); });
+}
+
+/*static*/ void LinkingManager::OpenUri(winrt::Windows::Foundation::Uri const &uri) noexcept {
   if (!s_initialUri) {
     s_initialUri = uri;
   }
 
-  std::vector<LinkingManagerModule *> modules;
+  std::vector<LinkingManager *> modules;
   {
     std::scoped_lock lock{s_mutex};
     modules = s_linkingModules;
@@ -83,55 +95,28 @@ LinkingManagerModule::~LinkingManagerModule() noexcept {
   }
 }
 
-void LinkingManagerModule::HandleOpenUri(winrt::hstring const &uri) noexcept {
-  if (auto instance = getInstance().lock()) {
-    instance->callJSFunction(
-        "RCTDeviceEventEmitter", "emit", folly::dynamic::array("url", folly::dynamic::object("url", to_string(uri))));
-  }
+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 {
+  result.Reject(L"Could not open settings.  Not suported on this platform.");
 }
 
-std::string LinkingManagerModule::getName() {
-  return name;
+/*static*/ void LinkingManager::addListener(std::string eventName) noexcept {
+  // no-op
 }
 
-std::map<std::string, folly::dynamic> LinkingManagerModule::getConstants() {
-  return {};
+/*static*/ void LinkingManager::removeListeners(double count) noexcept {
+  // no-op
 }
 
-auto LinkingManagerModule::getMethods() -> std::vector<Method> {
-  return {
-      Method(
-          "openURL",
-          [](folly::dynamic args, Callback successCallback, Callback errorCallback) {
-            auto inputUrl = facebook::xplat::jsArgAsString(args, 0);
-            try {
-              winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(inputUrl));
-              openURLAsync(uri, successCallback, errorCallback);
-            } catch (winrt::hresult_error &e) {
-              errorCallback(
-                  {folly::dynamic::object("code", e.code().value)("message", "Unable to open URL: " + inputUrl)});
-            }
-          }),
-      Method(
-          "canOpenURL",
-          [](folly::dynamic args, Callback successCallback, Callback errorCallback) {
-            try {
-              winrt::Windows::Foundation::Uri uri(Utf8ToUtf16(facebook::xplat::jsArgAsString(args, 0)));
-              canOpenURLAsync(uri, successCallback, errorCallback);
-            } catch (winrt::hresult_error &e) {
-              successCallback({false});
-            }
-          }),
-      Method(
-          "getInitialURL",
-          [](folly::dynamic /*args*/, Callback successCallback, Callback /*errorCallback*/) {
-            if (s_initialUri) {
-              successCallback({to_string(s_initialUri.AbsoluteUri())});
-            } else {
-              successCallback({nullptr});
-            }
-          }),
-  };
+/*static*/ void LinkingManager::getInitialURL(::React::ReactPromise<::React::JSValue> &&result) noexcept {
+  if (s_initialUri) {
+    result.Resolve(to_string(s_initialUri.AbsoluteUri()));
+  } else {
+    result.Resolve(nullptr);
+  }
 }
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/LinkingManagerModule.h

@@ -3,29 +3,51 @@
 
 #pragma once
 
-#include <cxxreact/CxxModule.h>
-#include <folly/dynamic.h>
+#include "../../codegen/NativeLinkingManagerSpec.g.h"
+#include <NativeModules.h>
+#include <winrt/Windows.ApplicationModel.h>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Graphics.Display.h>
 
 namespace Microsoft::ReactNative {
 
-struct LinkingManagerModule final : facebook::xplat::module::CxxModule {
-  LinkingManagerModule() noexcept;
-  ~LinkingManagerModule() noexcept override;
+REACT_MODULE(LinkingManager)
+struct LinkingManager {
+  LinkingManager() noexcept;
+  ~LinkingManager() noexcept;
 
-  static void OpenUri(winrt::Windows::Foundation::Uri const &uri) noexcept;
-  void HandleOpenUri(winrt::hstring const &uri) noexcept;
+  using ModuleSpec = ReactNativeSpecs::LinkingManagerSpec;
+
+  REACT_INIT(Initialize)
+  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;
+
+  REACT_METHOD(openURL)
+  void openURL(std::string &&url, ::React::ReactPromise<::React::JSValue> &&result) noexcept;
+
+  REACT_METHOD(openSettings)
+  static void openSettings(::React::ReactPromise<::React::JSValue> &&result) noexcept;
 
- public: // CxxModule
-  std::string getName() override;
-  std::map<std::string, folly::dynamic> getConstants() override;
-  std::vector<Method> getMethods() override;
+  REACT_METHOD(addListener)
+  static void addListener(std::string eventName) noexcept;
 
-  static const char *name;
+  REACT_METHOD(removeListeners)
+  static void removeListeners(double count) noexcept;
+
+  REACT_METHOD(getInitialURL)
+  static void getInitialURL(::React::ReactPromise<::React::JSValue> &&result) noexcept;
+
+  static void OpenUri(winrt::Windows::Foundation::Uri const &uri) noexcept;
 
  private:
+  void HandleOpenUri(winrt::hstring const &uri) noexcept;
+
   static std::mutex s_mutex;
+  React::ReactContext m_context;
   static winrt::Windows::Foundation::Uri s_initialUri;
-  static std::vector<LinkingManagerModule *> s_linkingModules;
+  static std::vector<LinkingManager *> s_linkingModules;
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/LogBoxModule.h

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 #pragma once
 
+#include "../../codegen/NativeLogBoxSpec.g.h"
 #include <NativeModules.h>
 #include <winrt/Windows.ApplicationModel.h>
 #include <winrt/Windows.Foundation.h>
@@ -11,6 +12,8 @@ namespace Microsoft::ReactNative {
 
 REACT_MODULE(LogBox)
 struct LogBox : public std::enable_shared_from_this<LogBox> {
+  using ModuleSpec = ReactNativeSpecs::LogBoxSpec;
+
   REACT_INIT(Initialize)
   void Initialize(React::ReactContext const &reactContext) noexcept;
 

package/Microsoft.ReactNative/Modules/PaperUIManagerModule.cpp

@@ -530,7 +530,7 @@ UIManager::UIManager() : m_module(std::make_shared<UIManagerModule>()) {}
 UIManager::~UIManager() {
   // To make sure that we destroy UI components in UI thread.
   if (!m_context.UIDispatcher().HasThreadAccess()) {
-    m_context.UIDispatcher().Post([module = std::move(m_module)]() {});
+    m_context.UIDispatcher().Post([module = std::move(m_module)]() mutable { module = nullptr; });
   }
 }
 

package/Microsoft.ReactNative/Modules/PaperUIManagerModule.h

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 #pragma once
 
+#include "../../codegen/NativeUIManagerSpec.g.h"
 #include <CxxMessageQueue.h>
 #include <INativeUIManager.h>
 #include <NativeModules.h>
@@ -31,6 +32,11 @@ std::weak_ptr<NativeUIManager> GetNativeUIManager(const Mso::React::IReactContex
 
 REACT_MODULE(UIManager)
 struct UIManager final {
+  // TODO:
+  // Spec incorrectly reports commandID as a number, but its actually a number | string..
+  // There is also other issues to catch up, so dont use the spec for now
+  // using ModuleSpec = ReactNativeSpecs::UIManagerSpec;
+
   UIManager();
   ~UIManager();
 

package/Microsoft.ReactNative/ReactApplication.cpp

@@ -96,7 +96,7 @@ void ReactApplication::JavaScriptBundleFile(hstring const &value) noexcept {
 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>()};
-    ::Microsoft::ReactNative::LinkingManagerModule::OpenUri(protocolActivatedEventArgs.Uri());
+    ::Microsoft::ReactNative::LinkingManager::OpenUri(protocolActivatedEventArgs.Uri());
   }
   this->OnCreate(e);
 }

package/Microsoft.ReactNative/ReactCoreInjection.cpp

@@ -139,14 +139,9 @@ struct ReactViewInstance : public Mso::UnknownObject<Mso::RefCountStrategy::Weak
   inline Mso::Future<void> PostInUIQueue(winrt::delegate<ReactNative::IReactViewInstance> const &action) noexcept {
     Mso::Promise<void> promise;
 
-    // ReactViewInstance has shorter lifetime than ReactRootControl. Thus, we capture this WeakPtr.
-    m_uiDispatcher.Post([weakThis = Mso::WeakPtr{this}, promise, action{std::move(action)}]() mutable noexcept {
-      if (auto strongThis = weakThis.GetStrongPtr()) {
-        action(strongThis->m_rootControl);
-        promise.SetValue();
-      } else {
-        promise.TryCancel();
-      }
+    m_uiDispatcher.Post([control = m_rootControl, promise, action{std::move(action)}]() mutable noexcept {
+      action(control);
+      promise.SetValue();
     });
     return promise.AsFuture();
   }
@@ -159,9 +154,7 @@ winrt::Windows::Foundation::IAsyncAction ReactViewHost::AttachViewInstance(
 }
 
 winrt::Windows::Foundation::IAsyncAction ReactViewHost::DetachViewInstance() noexcept {
-  Mso::Promise<void> promise;
-  promise.SetValue();
-  return make<Mso::AsyncActionFutureAdapter>(promise.AsFuture());
+  return make<Mso::AsyncActionFutureAdapter>(m_viewHost->DetachViewInstance());
 }
 
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactHost/ReactContext.h

@@ -5,9 +5,9 @@
 
 #include "React.h"
 
-namespace facebook::jsi {
+namespace Microsoft::JSI {
 struct RuntimeHolderLazyInit;
-} // namespace facebook::jsi
+} // namespace Microsoft::JSI
 
 namespace Mso::React {
 

package/Microsoft.ReactNative/ReactHost/ReactHost.cpp

@@ -379,8 +379,13 @@ Mso::Future<void> ReactHost::LoadInQueue(ReactOptions &&options) noexcept {
       }
     }
 
-    return whenLoaded.AsFuture().Then(m_executor, [this](Mso::Maybe<void> && /*value*/) noexcept {
+    return whenLoaded.AsFuture().Then(m_executor, [this](Mso::Maybe<void> &&value) noexcept {
       std::vector<Mso::Future<void>> loadCompletionList;
+
+      if (value.IsError()) {
+        return Mso::MakeFailedFuture<void>(std::move(value.TakeError()));
+      }
+
       ForEachViewHost([&loadCompletionList](auto &viewHost) noexcept {
         loadCompletionList.push_back(viewHost.UpdateViewInstanceInQueue());
       });

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -8,6 +8,7 @@
 #include <Base/CoreNativeModules.h>
 #include <Threading/MessageDispatchQueue.h>
 #include <Threading/MessageQueueThreadFactory.h>
+#include <appModel.h>
 #include <comUtil/qiCast.h>
 
 #ifndef CORE_ABI
@@ -16,17 +17,6 @@
 #include "ReactErrorProvider.h"
 
 #include "Microsoft.ReactNative/IReactNotificationService.h"
-
-#include "../../codegen/NativeAccessibilityInfoSpec.g.h"
-#include "../../codegen/NativeAppStateSpec.g.h"
-#include "../../codegen/NativeClipboardSpec.g.h"
-#include "../../codegen/NativeDevSettingsSpec.g.h"
-#include "../../codegen/NativeDeviceInfoSpec.g.h"
-#include "../../codegen/NativeDialogManagerWindowsSpec.g.h"
-#include "../../codegen/NativeI18nManagerSpec.g.h"
-#include "../../codegen/NativeImageLoaderIOSSpec.g.h"
-#include "../../codegen/NativeLogBoxSpec.g.h"
-#include "../../codegen/NativeUIManagerSpec.g.h"
 #include "NativeModules.h"
 #include "NativeModulesProvider.h"
 #include "Unicode.h"
@@ -52,6 +42,7 @@
 #include "Modules/AccessibilityInfoModule.h"
 #include "Modules/AlertModule.h"
 #include "Modules/AppStateModule.h"
+#include "Modules/AppThemeModuleUwp.h"
 #include "Modules/ClipboardModule.h"
 #endif
 #include "Modules/DevSettingsModule.h"
@@ -59,6 +50,7 @@
 #include <Modules/ImageViewManagerModule.h>
 #include "Modules/DeviceInfoModule.h"
 #include "Modules/I18nManagerModule.h"
+#include "Modules/LinkingManagerModule.h"
 #include "Modules/LogBoxModule.h"
 #include "Modules/NativeUIManager.h"
 #include "Modules/PaperUIManagerModule.h"
@@ -227,9 +219,11 @@ ReactInstanceWin::ReactInstanceWin(
   m_whenLoaded.AsFuture()
       .Then<Mso::Executors::Inline>(
           [onLoaded = m_options.OnInstanceLoaded, reactContext = m_reactContext](Mso::Maybe<void> &&value) noexcept {
+            auto errCode = value.IsError() ? value.TakeError() : Mso::ErrorCode();
             if (onLoaded) {
-              onLoaded.Get()->Invoke(reactContext, value.IsError() ? value.TakeError() : Mso::ErrorCode());
+              onLoaded.Get()->Invoke(reactContext, errCode);
             }
+            return Mso::Maybe<void>(errCode);
           })
       .Then(Queue(), [whenLoaded = std::move(whenLoaded)](Mso::Maybe<void> &&value) noexcept {
         whenLoaded.SetValue(std::move(value));
@@ -260,11 +254,6 @@ ReactInstanceWin::~ReactInstanceWin() noexcept {}
 void ReactInstanceWin::LoadModules(
     const std::shared_ptr<winrt::Microsoft::ReactNative::NativeModulesProvider> &nativeModulesProvider,
     const std::shared_ptr<winrt::Microsoft::ReactNative::TurboModulesProvider> &turboModulesProvider) noexcept {
-  auto registerNativeModule = [&nativeModulesProvider](
-                                  const wchar_t *name, const ReactModuleProvider &provider) noexcept {
-    nativeModulesProvider->AddModuleProvider(name, provider);
-  };
-
   auto registerTurboModule = [this, &nativeModulesProvider, &turboModulesProvider](
                                  const wchar_t *name, const ReactModuleProvider &provider) noexcept {
     if (m_options.UseWebDebugger()) {
@@ -285,64 +274,46 @@ void ReactInstanceWin::LoadModules(
 #ifndef CORE_ABI
   registerTurboModule(
       L"UIManager",
-      // Spec incorrectly reports commandID as a number, but its actually a number | string.. so dont use the spec for
-      // now
-      // winrt::Microsoft::ReactNative::MakeTurboModuleProvider < ::Microsoft::ReactNative::UIManager,
-      //::Microsoft::ReactNativeSpecs::UIManagerSpec>());
+      // TODO: Use MakeTurboModuleProvider after it satisfies ReactNativeSpecs::UIManagerSpec
       winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::UIManager>());
 
   registerTurboModule(
       L"AccessibilityInfo",
-      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-          ::Microsoft::ReactNative::AccessibilityInfo,
-          ::Microsoft::ReactNativeSpecs::AccessibilityInfoSpec>());
+      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::AccessibilityInfo>());
+
+  registerTurboModule(
+      L"Alert", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::Alert>());
 
   registerTurboModule(
-      L"Alert",
-      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-          ::Microsoft::ReactNative::Alert,
-          ::Microsoft::ReactNativeSpecs::DialogManagerWindowsSpec>());
+      L"AppState", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::AppState>());
 
   registerTurboModule(
-      L"AppState",
-      winrt::Microsoft::ReactNative::
-          MakeTurboModuleProvider<::Microsoft::ReactNative::AppState, ::Microsoft::ReactNativeSpecs::AppStateSpec>());
+      L"AppTheme", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::AppTheme>());
 
   registerTurboModule(
-      L"LogBox",
-      winrt::Microsoft::ReactNative::
-          MakeTurboModuleProvider<::Microsoft::ReactNative::LogBox, ::Microsoft::ReactNativeSpecs::LogBoxSpec>());
+      L"LogBox", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::LogBox>());
 
   registerTurboModule(
-      L"Clipboard",
-      winrt::Microsoft::ReactNative::
-          MakeTurboModuleProvider<::Microsoft::ReactNative::Clipboard, ::Microsoft::ReactNativeSpecs::ClipboardSpec>());
+      L"Clipboard", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::Clipboard>());
 
   registerTurboModule(
-      L"DeviceInfo",
-      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-          ::Microsoft::ReactNative::DeviceInfo,
-          ::Microsoft::ReactNativeSpecs::DeviceInfoSpec>());
+      L"DeviceInfo", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::DeviceInfo>());
 
   registerTurboModule(
-      L"ImageLoader",
-      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-          ::Microsoft::ReactNative::ImageLoader,
-          ::Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec>());
+      L"ImageLoader", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::ImageLoader>());
 #endif
 
   registerTurboModule(
-      L"DevSettings",
-      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-          ::Microsoft::ReactNative::DevSettings,
-          ::Microsoft::ReactNativeSpecs::DevSettingsSpec>());
+      L"DevSettings", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::DevSettings>());
 
 #ifndef CORE_ABI
   registerTurboModule(
-      L"I18nManager",
-      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
-          ::Microsoft::ReactNative::I18nManager,
-          ::Microsoft::ReactNativeSpecs::I18nManagerSpec>());
+      L"I18nManager", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::I18nManager>());
+
+  registerTurboModule(
+      L"LinkingManager",
+      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::LinkingManager>());
+
 #endif
 }
 
@@ -365,8 +336,7 @@ void ReactInstanceWin::Initialize() noexcept {
     // Objects that must be created on the UI thread
     if (auto strongThis = weakThis.GetStrongPtr()) {
 #ifndef CORE_ABI
-      strongThis->m_appTheme = std::make_shared<Microsoft::ReactNative::AppTheme>(
-          strongThis->GetReactContext(), strongThis->m_uiMessageThread.LoadWithLock());
+      Microsoft::ReactNative::AppThemeHolder::InitAppThemeHolder(strongThis->GetReactContext());
       Microsoft::ReactNative::I18nManager::InitI18nInfo(
           winrt::Microsoft::ReactNative::ReactPropertyBag(strongThis->Options().Properties));
       strongThis->m_appearanceListener = Mso::Make<Microsoft::ReactNative::AppearanceChangeListener>(
@@ -414,11 +384,7 @@ void ReactInstanceWin::Initialize() noexcept {
           // Acquire default modules and then populate with custom modules.
           // Note that some of these have custom thread affinity.
           std::vector<facebook::react::NativeModuleDescription> cxxModules = Microsoft::ReactNative::GetCoreModules(
-              m_batchingUIThread,
-              m_jsMessageThread.Load(),
-              std::move(m_appTheme),
-              std::move(m_appearanceListener),
-              m_reactContext);
+              m_batchingUIThread, m_jsMessageThread.Load(), std::move(m_appearanceListener), m_reactContext);
 #endif
 
           auto nmp = std::make_shared<winrt::Microsoft::ReactNative::NativeModulesProvider>();
@@ -446,10 +412,19 @@ void ReactInstanceWin::Initialize() noexcept {
               break;
             case JSIEngine::V8:
 #if defined(USE_V8)
-#ifndef CORE_ABI
-              preparedScriptStore =
-                  std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(getApplicationLocalFolder());
-#endif // CORE_ABI
+            {
+              uint32_t length{0};
+              if (GetCurrentPackageFullName(&length, nullptr) != APPMODEL_ERROR_NO_PACKAGE) {
+                preparedScriptStore =
+                    std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(getApplicationTempFolder());
+              } else {
+                wchar_t tempPath[MAX_PATH];
+                if (GetTempPathW(static_cast<DWORD>(std::size(tempPath)), tempPath)) {
+                  preparedScriptStore =
+                      std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
+                }
+              }
+            }
               devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
                   devSettings, m_jsMessageThread.Load(), std::move(scriptStore), std::move(preparedScriptStore));
               break;
@@ -481,11 +456,21 @@ void ReactInstanceWin::Initialize() noexcept {
                 m_options.TurboModuleProvider,
                 std::make_unique<BridgeUIBatchInstanceCallback>(weakThis),
                 m_jsMessageThread.Load(),
-                Mso::Copy(m_batchingUIThread),
+                m_nativeMessageThread.Load(),
                 std::move(devSettings));
 
             m_instanceWrapper.Exchange(std::move(instanceWrapper));
 
+            // The InstanceCreated event can be used to augment the JS environment for all JS code.  So it needs to be
+            // triggered before any platform JS code is run. Using m_jsMessageThread instead of jsDispatchQueue avoids
+            // waiting for the JSCaller which can delay the event until after certain JS code has already run
+            m_jsMessageThread.Load()->runOnQueue(
+                [onCreated = m_options.OnInstanceCreated, reactContext = m_reactContext]() noexcept {
+                  if (onCreated) {
+                    onCreated.Get()->Invoke(reactContext);
+                  }
+                });
+
 #ifdef USE_FABRIC
             // Eagerly init the FabricUI binding
             if (!m_options.UseWebDebugger()) {
@@ -571,7 +556,9 @@ void ReactInstanceWin::LoadJSBundles() noexcept {
 
             try {
               instanceWrapper->loadBundleSync(Mso::Copy(strongThis->JavaScriptBundleFile()));
-              strongThis->OnReactInstanceLoaded(Mso::ErrorCode{});
+              if (strongThis->State() != ReactInstanceState::HasError) {
+                strongThis->OnReactInstanceLoaded(Mso::ErrorCode{});
+              }
             } catch (...) {
               strongThis->OnReactInstanceLoaded(Mso::ExceptionErrorProvider().MakeErrorCode(std::current_exception()));
             }
@@ -642,13 +629,6 @@ void ReactInstanceWin::InitJSMessageThread() noexcept {
       Mso::Copy(m_whenDestroyed));
   auto jsDispatchQueue = Mso::DispatchQueue::MakeCustomQueue(Mso::CntPtr(scheduler));
 
-  // This work item will be processed as a first item in JS queue when the react instance is created.
-  jsDispatchQueue.Post([onCreated = m_options.OnInstanceCreated, reactContext = m_reactContext]() noexcept {
-    if (onCreated) {
-      onCreated.Get()->Invoke(reactContext);
-    }
-  });
-
   auto jsDispatcher =
       winrt::make<winrt::Microsoft::ReactNative::implementation::ReactDispatcher>(Mso::Copy(jsDispatchQueue));
   m_options.Properties.Set(ReactDispatcherHelper::JSDispatcherProperty(), jsDispatcher);
@@ -899,7 +879,7 @@ void ReactInstanceWin::DispatchEvent(int64_t viewTag, std::string &&eventName, f
 }
 
 winrt::Microsoft::ReactNative::JsiRuntime ReactInstanceWin::JsiRuntime() noexcept {
-  std::shared_ptr<facebook::jsi::RuntimeHolderLazyInit> jsiRuntimeHolder;
+  std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> jsiRuntimeHolder;
   {
     std::scoped_lock lock{m_mutex};
     if (m_jsiRuntime) {
@@ -1005,8 +985,8 @@ Mso::CntPtr<IReactInstanceInternal> MakeReactInstance(
 }
 
 #if defined(USE_V8)
-std::string ReactInstanceWin::getApplicationLocalFolder() {
-  auto local = winrt::Windows::Storage::ApplicationData::Current().LocalFolder().Path();
+std::string ReactInstanceWin::getApplicationTempFolder() {
+  auto local = winrt::Windows::Storage::ApplicationData::Current().TemporaryFolder().Path();
 
   return Microsoft::Common::Unicode::Utf16ToUtf8(local.c_str(), local.size()) + "\\";
 }

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -11,7 +11,6 @@
 #include "activeObject/activeObject.h"
 
 #ifndef CORE_ABI
-#include <Modules/AppThemeModuleUwp.h>
 #include <Modules/AppearanceModule.h>
 #include <Modules/I18nManagerModule.h>
 #include <Views/ExpressionAnimationStore.h>
@@ -131,7 +130,7 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   };
 
 #if defined(USE_V8)
-  static std::string getApplicationLocalFolder();
+  static std::string getApplicationTempFolder();
 #endif
 
  private: // immutable fields
@@ -178,13 +177,12 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
 
   std::shared_ptr<IRedBoxHandler> m_redboxHandler;
 #ifndef CORE_ABI
-  std::shared_ptr<Microsoft::ReactNative::AppTheme> m_appTheme;
   Mso::CntPtr<Microsoft::ReactNative::AppearanceChangeListener> m_appearanceListener;
 #endif
   Mso::CntPtr<Mso::React::IDispatchQueue2> m_uiQueue;
   std::deque<JSCallEntry> m_jsCallQueue;
 
-  std::shared_ptr<facebook::jsi::RuntimeHolderLazyInit> m_jsiRuntimeHolder;
+  std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> m_jsiRuntimeHolder;
   winrt::Microsoft::ReactNative::JsiRuntime m_jsiRuntime{nullptr};
 };