react-native-windows 0.78.3 → 0.78.5

package/Microsoft.ReactNative/Fabric/Composition/Modal/WindowsModalHostViewComponentView.cpp

@@ -14,6 +14,24 @@
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
+struct ModalHostState
+    : winrt::implements<ModalHostState, winrt::Microsoft::ReactNative::Composition::IPortalStateData> {
+  ModalHostState(winrt::Microsoft::ReactNative::LayoutConstraints layoutConstraints, float scaleFactor)
+      : m_layoutConstraints(layoutConstraints), m_pointScaleFactor(scaleFactor) {}
+
+  winrt::Microsoft::ReactNative::LayoutConstraints LayoutConstraints() const noexcept {
+    return m_layoutConstraints;
+  }
+
+  float PointScaleFactor() const noexcept {
+    return m_pointScaleFactor;
+  }
+
+ private:
+  float m_pointScaleFactor{1.0f};
+  winrt::Microsoft::ReactNative::LayoutConstraints m_layoutConstraints;
+};
+
 struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::Foundation::IInspectable>,
                        ::Microsoft::ReactNativeSpecs::BaseModalHostView<ModalHostView> {
   ~ModalHostView() {
@@ -37,6 +55,13 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
       m_window.Destroy();
       m_window = nullptr;
     }
+
+#ifdef USE_EXPERIMENTAL_WINUI3
+    if (m_popUp) {
+      m_popUp.Close();
+      m_popUp = nullptr;
+    }
+#endif
   }
 
   void InitializePortalViewComponent(
@@ -65,13 +90,32 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     ::Microsoft::ReactNativeSpecs::BaseModalHostView<ModalHostView>::UpdateProps(view, newProps, oldProps);
   }
 
-  void UpdateLayoutMetrics(
-      const winrt::Microsoft::ReactNative::ComponentView &view,
-      const winrt::Microsoft::ReactNative::LayoutMetrics &newLayoutMetrics,
-      const winrt::Microsoft::ReactNative::LayoutMetrics & /*oldLayoutMetrics*/) noexcept override {
-    if (m_window) {
-      AdjustWindowSize(newLayoutMetrics);
-    }
+  void UpdateState(
+      const winrt::Microsoft::ReactNative::ComponentView & /*view*/,
+      const winrt::Microsoft::ReactNative::IComponentState &newState) noexcept override {
+    m_state = newState;
+  }
+
+  void MountChildComponentView(
+      const winrt::Microsoft::ReactNative::ComponentView & /*view*/,
+      const winrt::Microsoft::ReactNative::MountChildComponentViewArgs &args) noexcept override {
+    AdjustWindowSize(args.Child().LayoutMetrics());
+    assert(!m_childLayoutMetricsToken);
+    m_childLayoutMetricsToken = args.Child().LayoutMetricsChanged(
+        [wkThis = get_weak()](
+            auto &sender, const winrt::Microsoft::ReactNative::LayoutMetricsChangedArgs &layoutMetricsChangedArgs) {
+          if (auto strongThis = wkThis.get()) {
+            strongThis->AdjustWindowSize(layoutMetricsChangedArgs.NewLayoutMetrics());
+          }
+        });
+  }
+
+  void UnmountChildComponentView(
+      const winrt::Microsoft::ReactNative::ComponentView & /*view*/,
+      const winrt::Microsoft::ReactNative::UnmountChildComponentViewArgs &args) noexcept override {
+    assert(m_childLayoutMetricsToken);
+    args.Child().LayoutMetricsChanged(m_childLayoutMetricsToken);
+    m_childLayoutMetricsToken.value = 0;
   }
 
   void FinalizeUpdate(
@@ -85,7 +129,6 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
  private:
   void OnMounted(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
     m_mounted = true;
-
     if (m_showQueued) {
       ShowOnUIThread(view);
     }
@@ -96,6 +139,14 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
   }
 
   void AdjustWindowSize(const winrt::Microsoft::ReactNative::LayoutMetrics &layoutMetrics) noexcept {
+#ifdef USE_EXPERIMENTAL_WINUI3
+    if (!m_popUp) {
+#else
+    if (!m_window) {
+#endif
+      return;
+    }
+
     if (layoutMetrics.Frame.Width == 0 && layoutMetrics.Frame.Height == 0) {
       return;
     }
@@ -108,11 +159,23 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     int32_t yCor = static_cast<int32_t>(
         (parentRC.top + parentRC.bottom - layoutMetrics.Frame.Height * layoutMetrics.PointScaleFactor) / 2);
 
+#ifdef USE_EXPERIMENTAL_WINUI3
+    winrt::Windows::Graphics::RectInt32 rect2{
+        (int)xCor,
+        (int)yCor,
+        static_cast<int32_t>(layoutMetrics.Frame.Width * (layoutMetrics.PointScaleFactor)),
+        static_cast<int32_t>(layoutMetrics.Frame.Height * (layoutMetrics.PointScaleFactor))};
+    m_popUp.MoveAndResize(rect2);
+#else
+    // Fix for https://github.com/microsoft/microsoft-ui-xaml/issues/9529
+    auto titleBarHeight = m_window.TitleBar().Height();
+
     // Adjust window position and size
     m_window.ResizeClient(
         {static_cast<int32_t>(layoutMetrics.Frame.Width * (layoutMetrics.PointScaleFactor)),
-         static_cast<int32_t>(layoutMetrics.Frame.Height * (layoutMetrics.PointScaleFactor))});
+         static_cast<int32_t>(layoutMetrics.Frame.Height * (layoutMetrics.PointScaleFactor)) - titleBarHeight});
     m_window.Move({xCor, yCor});
+#endif
   };
 
   void ShowOnUIThread(const winrt::Microsoft::ReactNative::ComponentView &view) {
@@ -122,6 +185,24 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     m_showQueued = false;
     EnsureModalCreated(view);
 
+#ifdef USE_EXPERIMENTAL_WINUI3
+    if (m_popUp) {
+      m_bridge.Enable();
+      m_popUp.Show();
+
+      auto navHost = winrt::Microsoft::UI::Input::InputFocusNavigationHost::GetForSiteBridge(
+          m_popUp.as<winrt::Microsoft::UI::Content::IContentSiteBridge>());
+      auto result = navHost.NavigateFocus(winrt::Microsoft::UI::Input::FocusNavigationRequest::Create(
+          winrt::Microsoft::UI::Input::FocusNavigationReason::First));
+
+      // dispatch onShow event
+      if (auto eventEmitter = EventEmitter()) {
+        ::Microsoft::ReactNativeSpecs::ModalHostViewEventEmitter::OnShow eventArgs;
+        eventEmitter->onShow(eventArgs);
+      }
+    }
+#endif
+
     if (m_window && !m_window.IsVisible()) {
       m_bridge.Enable();
       m_window.Show(true);
@@ -146,6 +227,12 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
       m_window.Hide();
     }
 
+#ifdef USE_EXPERIMENTAL_WINUI3
+    if (m_popUp) {
+      m_popUp.Hide();
+    }
+#endif
+
     // dispatch onDismiss event
     if (auto eventEmitter = EventEmitter()) {
       ::Microsoft::ReactNativeSpecs::ModalHostViewEventEmitter::OnDismiss eventArgs;
@@ -168,6 +255,11 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
       return;
     }
 
+#ifdef USE_EXPERIMENTAL_WINUI3
+    if (m_popUp) {
+      return;
+    }
+#endif
     // get the root hwnd
     m_prevWindowID =
         winrt::Microsoft::ReactNative::ReactCoreInjection::GetTopLevelWindowId(view.ReactContext().Properties());
@@ -175,6 +267,34 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     m_parentHwnd =
         view.as<::Microsoft::ReactNative::Composition::Experimental::IComponentViewInterop>()->GetHwndForParenting();
 
+    auto portal = view.as<winrt::Microsoft::ReactNative::Composition::PortalComponentView>();
+
+#ifdef USE_EXPERIMENTAL_WINUI3
+    m_bridge = winrt::Microsoft::UI::Content::DesktopChildSiteBridge::Create(
+        view.Parent().as<winrt::Microsoft::ReactNative::Composition::ComponentView>().Compositor(),
+        winrt::Microsoft::UI::GetWindowIdFromWindow(m_parentHwnd));
+    m_reactNativeIsland = winrt::Microsoft::ReactNative::ReactNativeIsland::CreatePortal(portal);
+    auto contentIsland = m_reactNativeIsland.Island();
+
+    m_popUp = m_bridge.TryCreatePopupSiteBridge();
+    m_popUp.Connect(contentIsland);
+
+    // set the top-level windows as the new hwnd
+    winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
+        view.ReactContext().Properties(),
+        reinterpret_cast<uint64_t>(winrt::Microsoft::UI::GetWindowFromWindowId(m_popUp.WindowId())));
+
+    auto navHost = winrt::Microsoft::UI::Input::InputFocusNavigationHost::GetForSiteBridge(
+        m_popUp.as<winrt::Microsoft::UI::Content::IContentSiteBridge>());
+    m_departFocusToken = navHost.DepartFocusRequested(
+        [wkView = winrt::make_weak(view)](
+            const auto &sender, const winrt::Microsoft::UI::Input::FocusNavigationRequestEventArgs &args) {
+          if (auto strongView = wkView.get()) {
+            TrySetFocus(strongView.Parent());
+          }
+        });
+
+#else
     auto presenter = winrt::Microsoft::UI::Windowing::OverlappedPresenter::CreateForDialog();
     presenter.SetBorderAndTitleBar(true, false);
     presenter.IsModal(true);
@@ -190,8 +310,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     // create a react native island - code taken from CompositionHwndHost
     m_bridge = winrt::Microsoft::UI::Content::DesktopChildSiteBridge::Create(
         view.Parent().as<winrt::Microsoft::ReactNative::Composition::ComponentView>().Compositor(), m_window.Id());
-    m_reactNativeIsland = winrt::Microsoft::ReactNative::ReactNativeIsland::CreatePortal(
-        view.as<winrt::Microsoft::ReactNative::Composition::PortalComponentView>());
+    m_reactNativeIsland = winrt::Microsoft::ReactNative::ReactNativeIsland::CreatePortal(portal);
     auto contentIsland = m_reactNativeIsland.Island();
 
     auto navHost = winrt::Microsoft::UI::Input::InputFocusNavigationHost::GetForSiteBridge(m_bridge);
@@ -202,13 +321,56 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
             TrySetFocus(strongView.Parent());
           }
         });
-
-    m_bridge.ResizePolicy(winrt::Microsoft::UI::Content::ContentSizePolicy::ResizeContentToParentWindow);
     m_bridge.Connect(contentIsland);
-    AdjustWindowSize(view.LayoutMetrics());
+#endif
+    m_bridge.ResizePolicy(winrt::Microsoft::UI::Content::ContentSizePolicy::ResizeContentToParentWindow);
+
+    m_islandStateChangedToken =
+        contentIsland.StateChanged([weakThis = get_weak()](
+                                       winrt::Microsoft::UI::Content::ContentIsland const &island,
+                                       winrt::Microsoft::UI::Content::ContentIslandStateChangedEventArgs const &args) {
+          if (auto pThis = weakThis.get()) {
+            if (args.DidRasterizationScaleChange() || args.DidLayoutDirectionChange()) {
+              pThis->UpdateConstraints();
+            }
+          }
+        });
+
+    UpdateConstraints();
+
+    if (portal.ContentRoot().Children().Size()) {
+      AdjustWindowSize(portal.ContentRoot().Children().GetAt(0).LayoutMetrics());
+    }
     m_bridge.Show();
   }
 
+  void UpdateConstraints() noexcept {
+    auto displayArea = winrt::Microsoft::UI::Windowing::DisplayArea::GetFromDisplayId(
+        m_bridge.SiteView().EnvironmentView().DisplayId());
+    auto workArea = displayArea.WorkArea();
+
+    float scale = m_reactNativeIsland.Island().RasterizationScale();
+
+    winrt::Microsoft::ReactNative::LayoutConstraints constraints;
+    constraints.MinimumSize = {0, 0};
+    // Constrain the size of the modal to 90% of the screen size
+    constraints.MaximumSize = {
+        static_cast<float>((workArea.Width / scale) * 0.9), static_cast<float>((workArea.Height / scale) * 0.9)};
+    constraints.LayoutDirection = winrt::Microsoft::ReactNative::LayoutDirection::Undefined;
+
+    auto layoutDirection = m_reactNativeIsland.Island().LayoutDirection();
+    if (layoutDirection == winrt::Microsoft::UI::Content::ContentLayoutDirection::LeftToRight)
+      constraints.LayoutDirection = winrt::Microsoft::ReactNative::LayoutDirection::LeftToRight;
+    else if (layoutDirection == winrt::Microsoft::UI::Content::ContentLayoutDirection::RightToLeft)
+      constraints.LayoutDirection = winrt::Microsoft::ReactNative::LayoutDirection::RightToLeft;
+
+    // By setting a custom contraint here the behavior of the modal slightly changes.
+    // When no constraint is set (maxSize is std::numeric_limits<Float>::infinity()), yoga will layout the content to a
+    // desired size If we provide a specific max size, then contents with a flex:1 will expand to fill that size. We
+    // might want to provide a windows specific property to control this behavior.
+    m_state.UpdateState(winrt::make<ModalHostState>(constraints, m_reactNativeIsland.Island().RasterizationScale()));
+  }
+
   static void TrySetFocus(const winrt::Microsoft::ReactNative::ComponentView &view) {
     auto focusController = winrt::Microsoft::UI::Input::InputFocusController::GetForIsland(
         view.as<winrt::Microsoft::ReactNative::Composition::ComponentView>().Root().ReactNativeIsland().Island());
@@ -222,10 +384,16 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
   bool m_showTitleBar{false};
   bool m_showQueued{false};
   bool m_mounted{false};
+  winrt::event_token m_islandStateChangedToken;
   winrt::Microsoft::UI::Input::InputFocusNavigationHost::DepartFocusRequested_revoker m_departFocusRevoker;
   winrt::event_token m_departFocusToken;
+  winrt::event_token m_childLayoutMetricsToken;
+  winrt::Microsoft::ReactNative::IComponentState m_state{nullptr};
   winrt::Microsoft::UI::Content::DesktopChildSiteBridge m_bridge{nullptr};
   winrt::Microsoft::ReactNative::ReactNativeIsland m_reactNativeIsland{nullptr};
+#ifdef USE_EXPERIMENTAL_WINUI3
+  winrt::Microsoft::UI::Content::PopupWindowSiteBridge m_popUp{nullptr};
+#endif
 };
 
 void RegisterWindowsModalHostNativeComponent(

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

@@ -30,11 +30,23 @@ void PortalComponentView::MountChildComponentView(
     const winrt::Microsoft::ReactNative::ComponentView &childComponentView,
     uint32_t index) noexcept {
   m_rootComponentView->MountChildComponentView(childComponentView, index);
+  if (m_builder && m_builder->MountChildComponentViewHandler()) {
+    m_builder->MountChildComponentViewHandler()(
+        *this,
+        winrt::make<winrt::Microsoft::ReactNative::implementation::MountChildComponentViewArgs>(
+            childComponentView, index));
+  }
 }
 
 void PortalComponentView::UnmountChildComponentView(
     const winrt::Microsoft::ReactNative::ComponentView &childComponentView,
     uint32_t index) noexcept {
+  if (m_builder && m_builder->UnmountChildComponentViewHandler()) {
+    m_builder->UnmountChildComponentViewHandler()(
+        *this,
+        winrt::make<winrt::Microsoft::ReactNative::implementation::UnmountChildComponentViewArgs>(
+            childComponentView, index));
+  }
   m_rootComponentView->UnmountChildComponentView(childComponentView, index);
 }
 

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

@@ -3,6 +3,7 @@
 
 #include "pch.h"
 #include "ReactCompositionViewComponentBuilder.h"
+#include <Fabric/AbiViewComponentDescriptor.h>
 #include <Fabric/Composition/CompositionViewComponentView.h>
 #include <Fabric/Composition/ContentIslandComponentView.h>
 #include <Fabric/Composition/PortalComponentView.h>
@@ -128,7 +129,7 @@ void ReactCompositionViewComponentBuilder::SetPortalComponentViewInitializer(
   };
   m_descriptorConstructorFactory = []() {
     return &facebook::react::concreteComponentDescriptorConstructor<
-        ::Microsoft::ReactNative::AbiViewComponentDescriptor>;
+        ::Microsoft::ReactNative::AbiPortalComponentDescriptor>;
   };
 }
 

package/Microsoft.ReactNative/Fabric/Composition/ReactCompositionViewComponentBuilder.h

@@ -3,7 +3,6 @@
 // Licensed under the MIT License.
 
 #include <Fabric/AbiComponentDescriptor.h>
-#include <Fabric/AbiViewComponentDescriptor.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProvider.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include "winrt/Microsoft.ReactNative.Composition.Experimental.h"

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

@@ -913,21 +913,23 @@ winrt::Microsoft::UI::Content::ContentIsland ReactNativeIsland::Island() {
           }
         });
 #ifdef USE_EXPERIMENTAL_WINUI3
-    m_islandConnectedToken = m_island.Connected(
-        [weakThis = get_weak()](
-            winrt::IInspectable const &, winrt::Microsoft::UI::Content::ContentIsland const &island) {
-          if (auto pThis = weakThis.get()) {
-            pThis->OnMounted();
-          }
-        });
+    if (!m_isFragment) {
+      m_islandConnectedToken = m_island.Connected(
+          [weakThis = get_weak()](
+              winrt::IInspectable const &, winrt::Microsoft::UI::Content::ContentIsland const &island) {
+            if (auto pThis = weakThis.get()) {
+              pThis->OnMounted();
+            }
+          });
 
-    m_islandDisconnectedToken = m_island.Disconnected(
-        [weakThis = get_weak()](
-            winrt::IInspectable const &, winrt::Microsoft::UI::Content::ContentIsland const &island) {
-          if (auto pThis = weakThis.get()) {
-            pThis->OnUnmounted();
-          }
-        });
+      m_islandDisconnectedToken = m_island.Disconnected(
+          [weakThis = get_weak()](
+              winrt::IInspectable const &, winrt::Microsoft::UI::Content::ContentIsland const &island) {
+            if (auto pThis = weakThis.get()) {
+              pThis->OnUnmounted();
+            }
+          });
+    }
 #endif
   }
   return m_island;

package/Microsoft.ReactNative/IReactCompositionViewComponentBuilder.idl

@@ -52,6 +52,15 @@ namespace Microsoft.ReactNative.Composition
     };
   }
 
+  [webhosthidden]
+  [experimental]
+  DOC_STRING("StateData type to be used with a PortalComponentView. The LayoutConstraints and PointScaleFactor will be used to layout the content of the Portal")
+  interface IPortalStateData
+  {
+    Microsoft.ReactNative.LayoutConstraints LayoutConstraints { get; };
+    Single PointScaleFactor { get; };
+  };
+
   [webhosthidden]
   [experimental]
   DOC_STRING(".")
@@ -66,4 +75,4 @@ namespace Microsoft.ReactNative.Composition
     void SetVisualToMountChildrenIntoHandler(VisualToMountChildrenIntoDelegate impl);
   };
 
-} // namespace Microsoft.ReactNative
+} // namespace Microsoft.ReactNative.Composition

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.78.3</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.78.5</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>78</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>3</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>5</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>04930ad6dce2cbc6d2e5d79760b13b77443912e4</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>70356efc9bee07541301328d98c4a78b7f89637f</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/Networking/WinRTWebSocketResource.cpp

@@ -89,7 +89,6 @@ DispatchQueue GetCurrentOrSerialQueue() noexcept {
 
   return queue;
 }
-
 } // namespace
 
 namespace Microsoft::React::Networking {
@@ -104,7 +103,6 @@ WinRTWebSocketResource2::WinRTWebSocketResource2(
     : m_socket{std::move(socket)},
       m_writer(std::move(writer)),
       m_readyState{ReadyState::Connecting},
-      m_connectPerformed{CreateEvent(/*attributes*/ nullptr, /*manual reset*/ true, /*state*/ false, /*name*/ nullptr)},
       m_callingQueue{callingQueue} {
   for (const auto &certException : certExceptions) {
     m_socket.Control().IgnorableServerCertificateErrors().Append(certException);
@@ -221,120 +219,112 @@ void WinRTWebSocketResource2::OnClosed(IWebSocket const &sender, IWebSocketClose
 
 fire_and_forget WinRTWebSocketResource2::PerformConnect(Uri &&uri) noexcept {
   auto self = shared_from_this();
-  auto coUri = std::move(uri);
+  auto movedUri = std::move(uri);
 
   co_await resume_in_queue(self->m_backgroundQueue);
 
-  auto async = self->m_socket.ConnectAsync(coUri);
-  co_await lessthrow_await_adapter<IAsyncAction>{async};
-
-  co_await resume_in_queue(self->m_callingQueue);
-
-  auto result = async.ErrorCode();
-
-  try {
-    if (result >= 0) { // Non-failing HRESULT
-      co_await resume_in_queue(self->m_backgroundQueue);
-      self->m_readyState = ReadyState::Open;
-
-      co_await resume_in_queue(self->m_callingQueue);
-      if (self->m_connectHandler) {
-        self->m_connectHandler();
-      }
-    } else {
-      self->Fail(std::move(result), ErrorType::Connection);
-    }
-  } catch (hresult_error const &e) {
-    self->Fail(e, ErrorType::Connection);
-  } catch (std::exception const &e) {
-    self->Fail(e.what(), ErrorType::Connection);
-  }
-
-  SetEvent(self->m_connectPerformed.get());
+  co_await self->m_sequencer.QueueTaskAsync(
+      [self = self->shared_from_this(), coUri = std::move(movedUri)]() -> IAsyncAction {
+        auto coSelf = self->shared_from_this();
+
+        auto async = coSelf->m_socket.ConnectAsync(coUri);
+        co_await lessthrow_await_adapter<IAsyncAction>{async};
+
+        auto result = async.ErrorCode();
+        try {
+          if (result >= 0) { // Non-failing HRESULT
+            coSelf->m_readyState = ReadyState::Open;
+
+            co_await resume_in_queue(coSelf->m_callingQueue);
+            if (coSelf->m_connectHandler) {
+              coSelf->m_connectHandler();
+            }
+          } else {
+            coSelf->Fail(std::move(result), ErrorType::Connection);
+          }
+        } catch (hresult_error const &e) {
+          coSelf->Fail(e, ErrorType::Connection);
+        } catch (std::exception const &e) {
+          coSelf->Fail(e.what(), ErrorType::Connection);
+        }
+      });
 }
 
 fire_and_forget WinRTWebSocketResource2::PerformClose() noexcept {
   auto self = shared_from_this();
 
-  co_await resume_on_signal(self->m_connectPerformed.get());
-
   co_await resume_in_queue(self->m_backgroundQueue);
 
-  // See https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close
-  co_await self->SendPendingMessages();
+  co_await self->m_sequencer.QueueTaskAsync([self = self->shared_from_this()]() -> IAsyncAction {
+    auto coSelf = self->shared_from_this();
 
-  try {
-    self->m_socket.Close(static_cast<uint16_t>(m_closeCode), winrt::to_hstring(m_closeReason));
-    self->m_readyState = ReadyState::Closing;
-  } catch (winrt::hresult_invalid_argument const &e) {
-    Fail(e, ErrorType::Close);
-  } catch (hresult_error const &e) {
-    Fail(e, ErrorType::Close);
-  } catch (const std::exception &e) {
-    Fail(e.what(), ErrorType::Close);
-  }
+    try {
+      coSelf->m_socket.Close(static_cast<uint16_t>(coSelf->m_closeCode), winrt::to_hstring(coSelf->m_closeReason));
+      coSelf->m_readyState = ReadyState::Closing;
+    } catch (winrt::hresult_invalid_argument const &e) {
+      coSelf->Fail(e, ErrorType::Close);
+    } catch (hresult_error const &e) {
+      coSelf->Fail(e, ErrorType::Close);
+    } catch (const std::exception &e) {
+      coSelf->Fail(e.what(), ErrorType::Close);
+    }
+
+    co_return;
+  });
 }
 
-fire_and_forget WinRTWebSocketResource2::PerformWrite(string &&message, bool isBinary) noexcept {
+fire_and_forget WinRTWebSocketResource2::EnqueueWrite(string &&message, bool isBinary) noexcept {
   auto self = shared_from_this();
   string coMessage = std::move(message);
 
-  co_await resume_in_queue(self->m_backgroundQueue); // Ensure writes happen sequentially
-  self->m_outgoingMessages.emplace(std::move(coMessage), isBinary);
-
-  co_await resume_on_signal(self->m_connectPerformed.get());
-
   co_await resume_in_queue(self->m_backgroundQueue);
 
-  co_await self->SendPendingMessages();
+  co_await self->m_sequencer.QueueTaskAsync(
+      [self = self->shared_from_this(), message = std::move(coMessage), isBinary]() -> IAsyncAction {
+        auto coSelf = self->shared_from_this();
+        auto coMessage = std::move(message);
+
+        co_await coSelf->PerformWrite(std::move(coMessage), isBinary);
+      });
 }
 
-IAsyncAction WinRTWebSocketResource2::SendPendingMessages() noexcept {
+IAsyncAction WinRTWebSocketResource2::PerformWrite(string &&message, bool isBinary) noexcept {
   auto self = shared_from_this();
 
-  while (!self->m_outgoingMessages.empty()) {
-    if (self->m_readyState != ReadyState::Open) {
-      co_return;
-    }
-
-    size_t length = 0;
-    string messageLocal;
-    bool isBinaryLocal;
-    try {
-      std::tie(messageLocal, isBinaryLocal) = self->m_outgoingMessages.front();
-      self->m_outgoingMessages.pop();
-      if (isBinaryLocal) {
-        self->m_socket.Control().MessageType(SocketMessageType::Binary);
-
-        auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(messageLocal));
-        if (buffer) {
-          length = buffer.Length();
-          self->m_writer.WriteBuffer(buffer);
-        }
-      } else {
-        self->m_socket.Control().MessageType(SocketMessageType::Utf8);
+  try {
+    if (isBinary) {
+      self->m_socket.Control().MessageType(SocketMessageType::Binary);
 
-        length = messageLocal.size();
-        winrt::array_view<const uint8_t> view(
-            CheckedReinterpretCast<const uint8_t *>(messageLocal.c_str()),
-            CheckedReinterpretCast<const uint8_t *>(messageLocal.c_str()) + messageLocal.length());
-        self->m_writer.WriteBytes(view);
+      auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(message));
+      if (buffer) {
+        self->m_writer.WriteBuffer(buffer);
       }
-    } catch (hresult_error const &e) { // TODO: Remove after fixing unit tests exceptions.
-      self->Fail(e, ErrorType::Send);
-      co_return;
-    } catch (const std::exception &e) {
-      self->Fail(e.what(), ErrorType::Send);
-      co_return;
+    } else {
+      self->m_socket.Control().MessageType(SocketMessageType::Utf8);
+
+      winrt::array_view<const uint8_t> view(
+          CheckedReinterpretCast<const uint8_t *>(message.c_str()),
+          CheckedReinterpretCast<const uint8_t *>(message.c_str()) + message.length());
+      self->m_writer.WriteBytes(view);
     }
+  } catch (hresult_error const &e) { // TODO: Remove after fixing unit tests exceptions.
+    self->Fail(e, ErrorType::Send);
+  } catch (const std::exception &e) {
+    self->Fail(e.what(), ErrorType::Send);
+  }
 
-    auto async = self->m_writer.StoreAsync();
-    co_await lessthrow_await_adapter<DataWriterStoreOperation>{async};
+  co_await resume_in_queue(self->m_backgroundQueue);
+  // If an exception occurred, abort write process.
+  if (self->m_readyState != ReadyState::Open) {
+    co_return;
+  }
 
-    auto result = async.ErrorCode();
-    if (result < 0) {
-      Fail(std::move(result), ErrorType::Send);
-    }
+  auto async = self->m_writer.StoreAsync();
+  co_await lessthrow_await_adapter<DataWriterStoreOperation>{async};
+
+  auto result = async.ErrorCode();
+  if (result < 0) {
+    self->Fail(std::move(result), ErrorType::Send);
   }
 }
 
@@ -388,11 +378,7 @@ void WinRTWebSocketResource2::Connect(string &&url, const Protocols &protocols,
       m_socket.SetRequestHeader(L"Origin", std::move(origin));
     }
   } catch (hresult_error const &e) {
-    Fail(e, ErrorType::Connection);
-
-    SetEvent(m_connectPerformed.get());
-
-    return;
+    return Fail(e, ErrorType::Connection);
   }
 
   PerformConnect(std::move(uri));
@@ -401,11 +387,11 @@ void WinRTWebSocketResource2::Connect(string &&url, const Protocols &protocols,
 void WinRTWebSocketResource2::Ping() noexcept {}
 
 void WinRTWebSocketResource2::Send(string &&message) noexcept {
-  PerformWrite(std::move(message), false);
+  EnqueueWrite(std::move(message), false);
 }
 
 void WinRTWebSocketResource2::SendBinary(string &&base64String) noexcept {
-  PerformWrite(std::move(base64String), true);
+  EnqueueWrite(std::move(base64String), true);
 }
 
 void WinRTWebSocketResource2::Close(CloseCode code, const string &reason) noexcept {