react-native-windows 0.0.0-canary.782 → 0.0.0-canary.783

package/Microsoft.ReactNative/Fabric/Composition/CompositionRootView.cpp

@@ -14,6 +14,7 @@
 #include <ReactPropertyBag.h>
 #include <Utils/Helpers.h>
 #include <dispatchQueue/dispatchQueue.h>
+#include <eventWaitHandle/eventWaitHandle.h>
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/core/LayoutContext.h>
 #include <winrt/Microsoft.ReactNative.Composition.h>
@@ -64,21 +65,24 @@ void CompositionReactViewInstance::InitRootView(
                        .Get(winrt::Microsoft::ReactNative::ReactDispatcherHelper::UIDispatcherProperty())
                        .try_as<IReactDispatcher>();
 
-  PostInUIQueue([context{std::move(context)}, viewOptions{std::move(viewOptions)}](
-                    winrt::com_ptr<winrt::Microsoft::ReactNative::implementation::CompositionRootView>
-                        &rootControl) mutable noexcept {
+  assert(m_uiDispatcher.HasThreadAccess());
+  if (auto rootControl = m_weakRootControl.get()) {
     rootControl->InitRootView(std::move(context), std::move(viewOptions));
-  });
+  }
 }
 
 void CompositionReactViewInstance::UpdateRootView() noexcept {
-  PostInUIQueue([](winrt::com_ptr<winrt::Microsoft::ReactNative::implementation::CompositionRootView>
-                       &rootControl) mutable noexcept { rootControl->UpdateRootView(); });
+  assert(m_uiDispatcher.HasThreadAccess());
+  if (auto rootControl = m_weakRootControl.get()) {
+    rootControl->UpdateRootView();
+  }
 }
 
 void CompositionReactViewInstance::UninitRootView() noexcept {
-  PostInUIQueue([](winrt::com_ptr<winrt::Microsoft::ReactNative::implementation::CompositionRootView>
-                       &rootControl) mutable noexcept { rootControl->UninitRootView(); });
+  assert(m_uiDispatcher.HasThreadAccess());
+  if (auto rootControl = m_weakRootControl.get()) {
+    rootControl->UninitRootView();
+  }
 }
 
 //===========================================================================
@@ -355,6 +359,13 @@ void CompositionRootView::UninitRootView() noexcept {
 
     m_context.CallJSFunction(L"ReactFabric", L"unmountComponentAtNode", GetTag());
 
+    // This is needed to ensure that the unmount JS logic is completed before the the instance is shutdown during
+    // instance destruction. Aligns with similar code in ReactInstanceWin::DetachRootView for paper Future: Instead this
+    // method should return a Promise, which should be resolved when the JS logic is complete.
+    Mso::ManualResetEvent mre;
+    m_context.JSDispatcher().Post([&]() { mre.Set(); });
+    mre.Wait();
+
     // Paper version gives the JS thread time to finish executing - Is this needed?
     // m_jsMessageThread.Load()->runOnQueueSync([]() {});
   }

package/Microsoft.ReactNative/Fabric/Composition/CompositionUIService.cpp

@@ -4,6 +4,7 @@
 #include "pch.h"
 #include "CompositionUIService.h"
 #include "Composition.CompositionUIService.g.cpp"
+#include <QuirkSettings.h>
 
 #include <ReactPropertyBag.h>
 
@@ -18,6 +19,11 @@ void CompositionUIService::SetCompositionContext(
     IReactPropertyBag const &properties,
     ICompositionContext const &compositionContext) noexcept {
   ReactPropertyBag(properties).Set(CompositionContextPropertyId(), compositionContext);
+  // Default to using Bridgeless mode when using fabric
+  /*
+  winrt::Microsoft::ReactNative::implementation::QuirkSettings::SetIsBridgeless(
+      ReactPropertyBag(properties), !!compositionContext);
+  */
 }
 
 ICompositionContext CompositionUIService::GetCompositionContext(const IReactPropertyBag &properties) noexcept {

package/Microsoft.ReactNative/QuirkSettings.cpp

@@ -87,6 +87,12 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> IsBridgelessProperty() noex
   return properties.Get(IsBridgelessProperty()).value_or(false);
 }
 
+/*static*/ void QuirkSettings::SetIsBridgeless(
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+    bool value) noexcept {
+  properties.Set(IsBridgelessProperty(), value);
+}
+
 #pragma region IDL interface
 
 /*static*/ void QuirkSettings::SetMatchAndroidAndIOSStretchBehavior(

package/Microsoft.ReactNative/QuirkSettings.h

@@ -40,6 +40,7 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
       winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
   static bool GetIsBridgeless(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
+  static void SetIsBridgeless(const winrt::Microsoft::ReactNative::ReactPropertyBag &properties, bool value) noexcept;
 
 #pragma region Public API - part of IDL interface
   static void SetMatchAndroidAndIOSStretchBehavior(

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -529,6 +529,28 @@ std::shared_ptr<facebook::react::DevSettings> ReactInstanceWin::CreateDevSetting
   return devSettings;
 }
 
+Mso::DispatchQueueSettings CreateDispatchQueueSettings(
+    const winrt::Microsoft::ReactNative::IReactNotificationService &service) {
+  Mso::DispatchQueueSettings queueSettings{};
+  queueSettings.TaskStarting = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherTaskStartingEventName(), nullptr, nullptr);
+  };
+  queueSettings.IdleWaitStarting = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitStartingEventName(),
+        nullptr,
+        nullptr);
+  };
+  queueSettings.IdleWaitCompleted = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitCompletedEventName(),
+        nullptr,
+        nullptr);
+  };
+  return queueSettings;
+}
+
 #ifdef USE_FABRIC
 void ReactInstanceWin::InitializeBridgeless() noexcept {
   InitUIQueue();
@@ -550,12 +572,15 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
             // null moduleProvider since native modules are not supported in bridgeless
             LoadModules(devSettings, nullptr, m_options.TurboModuleProvider);
 
-            auto jsDispatchQueue = Mso::DispatchQueue::MakeLooperQueue();
+            auto jsDispatchQueue =
+                Mso::DispatchQueue::MakeLooperQueue(CreateDispatchQueueSettings(m_reactContext->Notifications()));
             auto jsDispatcher =
                 winrt::make<winrt::Microsoft::ReactNative::implementation::ReactDispatcher>(Mso::Copy(jsDispatchQueue));
             m_options.Properties.Set(ReactDispatcherHelper::JSDispatcherProperty(), jsDispatcher);
             m_jsMessageThread.Exchange(std::make_shared<Mso::React::MessageDispatchQueue>(
-                jsDispatchQueue, nullptr /*errorHandler*/, nullptr /*whenQuitPromise*/));
+                jsDispatchQueue,
+                Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError),
+                Mso::Copy(m_whenDestroyed)));
 
             auto timerRegistry = ::Microsoft::ReactNative::TimerRegistry::CreateTimerRegistry(
                 m_options.Properties.Get(ReactDispatcherHelper::UIDispatcherProperty()).try_as<IReactDispatcher>());
@@ -911,14 +936,7 @@ void ReactInstanceWin::LoadJSBundlesBridgeless(std::shared_ptr<facebook::react::
         [weakThis = Mso::WeakPtr{this},
          loadCallbackGuard = Mso::MakeMoveOnCopyWrapper(LoadedCallbackGuard{*this})]() noexcept {
           if (auto strongThis = weakThis.GetStrongPtr()) {
-            auto instance = strongThis->m_instance.LoadWithLock();
-            auto instanceWrapper = strongThis->m_instanceWrapper.LoadWithLock();
-            if (!instance || !instanceWrapper) {
-              return;
-            }
-
             try {
-              instanceWrapper->loadBundleSync(Mso::Copy(strongThis->JavaScriptBundleFile()));
               if (strongThis->State() != ReactInstanceState::HasError) {
                 strongThis->OnReactInstanceLoaded(Mso::ErrorCode{});
               }
@@ -973,6 +991,25 @@ Mso::Future<void> ReactInstanceWin::Destroy() noexcept {
     m_jsDispatchQueue.Exchange(nullptr);
   }
 
+#ifdef USE_FABRIC
+  if (m_bridgelessReactInstance) {
+    if (auto jsMessageThread = m_jsMessageThread.Exchange(nullptr)) {
+      jsMessageThread->runOnQueueSync([&]() noexcept {
+        {
+          // Release the JSI runtime
+          std::scoped_lock lock{m_mutex};
+
+          this->m_jsiRuntimeHolder = nullptr;
+          this->m_jsiRuntime = nullptr;
+        }
+        this->m_bridgelessReactInstance = nullptr;
+        jsMessageThread->quitSynchronous();
+      });
+    }
+    m_jsDispatchQueue.Exchange(nullptr);
+  }
+#endif
+
   return m_whenDestroyedResult;
 }
 
@@ -987,26 +1024,8 @@ ReactInstanceState ReactInstanceWin::State() const noexcept {
 void ReactInstanceWin::InitJSMessageThread() noexcept {
   m_instance.Exchange(std::make_shared<facebook::react::Instance>());
 
-  winrt::Microsoft::ReactNative::IReactNotificationService service = m_reactContext->Notifications();
-  Mso::DispatchQueueSettings queueSettings{};
-  queueSettings.TaskStarting = [service](Mso::DispatchQueue const &) noexcept {
-    service.SendNotification(
-        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherTaskStartingEventName(), nullptr, nullptr);
-  };
-  queueSettings.IdleWaitStarting = [service](Mso::DispatchQueue const &) noexcept {
-    service.SendNotification(
-        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitStartingEventName(),
-        nullptr,
-        nullptr);
-  };
-  queueSettings.IdleWaitCompleted = [service](Mso::DispatchQueue const &) noexcept {
-    service.SendNotification(
-        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitCompletedEventName(),
-        nullptr,
-        nullptr);
-  };
   auto scheduler = Mso::MakeJSCallInvokerScheduler(
-      queueSettings,
+      CreateDispatchQueueSettings(m_reactContext->Notifications()),
       m_instance.Load()->getJSCallInvoker(),
       Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError),
       Mso::Copy(m_whenDestroyed));
@@ -1201,6 +1220,7 @@ void ReactInstanceWin::OnJSError(facebook::react::MapBuffer errorMap) noexcept {
   m_state = ReactInstanceState::HasError;
   AbandonJSCallQueue();
 
+  OnReactInstanceLoaded(errorCode);
   if (m_redboxHandler && m_redboxHandler->isDevSupportEnabled()) {
     m_redboxHandler->showNewError(std::move(errorInfo), isFatal ? ErrorType::JSFatal : ErrorType::JSSoft);
   }

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.0.0-canary.782</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.0.0-canary.783</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>0</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>true</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>e46a18f7b78290373e1d65c63bc2e02fbf6f639e</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>c3f4edf2ba3f926a04c9a7573e155dfc573bc792</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.0.0-canary.782",
+  "version": "0.0.0-canary.783",
   "license": "MIT",
   "repository": {
     "type": "git",