react-native-windows 0.64.26 → 0.64.30

package/CHANGELOG.json

@@ -2,7 +2,109 @@
   "name": "react-native-windows",
   "entries": [
     {
-      "date": "Mon, 15 Nov 2021 16:08:58 GMT",
+      "date": "Mon, 07 Feb 2022 16:13:15 GMT",
+      "tag": "react-native-windows_v0.64.30",
+      "version": "0.64.30",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Replace __APPLE__ with __clang__ where applicable (#9461)",
+            "author": "julio.rocha@microsoft.com",
+            "commit": "b25b46d1c2e5aa3f7e3656c95a4cfd924e2554cd",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 31 Jan 2022 16:12:51 GMT",
+      "tag": "react-native-windows_v0.64.29",
+      "version": "0.64.29",
+      "comments": {
+        "patch": [
+          {
+            "comment": "[0.64] Avoid capturing raw this pointer in WebSocket module",
+            "author": "julio.rocha@microsoft.com",
+            "commit": "73ce66236d54a2e0e4bbeb83ba785e9252893c73",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 17 Jan 2022 16:10:13 GMT",
+      "tag": "react-native-windows_v0.64.28",
+      "version": "0.64.28",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Fork HoverState.js to allow hover events on Pressable",
+            "author": "saadnajmi2@gmail.com",
+            "commit": "acfb47a7924f4d4e34e020838423bbbab026d670",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 06 Dec 2021 16:10:29 GMT",
+      "tag": "react-native-windows_v0.64.27",
+      "version": "0.64.27",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Remove legacy logic to find win32 bundle",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "e45efd8c14e912ab6c865b71f01727e741faf911",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "InstanceCreated should fire before any JS code is run",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "e45efd8c14e912ab6c865b71f01727e741faf911",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "ReloadInstance async task and InstanceLoaded event were not correctly reporting failures",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "e45efd8c14e912ab6c865b71f01727e741faf911",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Better reporting of failures to load the bundle file",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "e45efd8c14e912ab6c865b71f01727e741faf911",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Fix crash when adding a ReactRootView while reloading a ReactHost",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "e45efd8c14e912ab6c865b71f01727e741faf911",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Prevent TurboModules from leaking on instance shutdown",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "e45efd8c14e912ab6c865b71f01727e741faf911",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Websocket is hitting the UI queue unnecessarily",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "e45efd8c14e912ab6c865b71f01727e741faf911",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Hook up DetachViewInstance method for custom UI implementations",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "e45efd8c14e912ab6c865b71f01727e741faf911",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 15 Nov 2021 16:09:20 GMT",
       "tag": "react-native-windows_v0.64.26",
       "version": "0.64.26",
       "comments": {

package/CHANGELOG.md

@@ -1,18 +1,57 @@
 # Change Log - react-native-windows
 
-This log was last generated on Mon, 15 Nov 2021 16:08:58 GMT and should not be manually modified.
+This log was last generated on Mon, 07 Feb 2022 16:13:15 GMT and should not be manually modified.
 
 <!-- Start content -->
 
-## 0.64.26
+## 0.64.30
 
-Mon, 15 Nov 2021 16:08:58 GMT
+Mon, 07 Feb 2022 16:13:15 GMT
 
 ### Patches
 
-- Fix crash loading bundle in win32 (30809111+acoates-ms@users.noreply.github.com)
-- Drop ChakraCore dependency (#9056) (julio.rocha@microsoft.com)
+- Replace __APPLE__ with __clang__ where applicable (#9461) (julio.rocha@microsoft.com)
 
+## 0.64.29
+
+Mon, 31 Jan 2022 16:12:51 GMT
+
+### Patches
+
+- [0.64] Avoid capturing raw this pointer in WebSocket module (julio.rocha@microsoft.com)
+
+## 0.64.28
+
+Mon, 17 Jan 2022 16:10:13 GMT
+
+### Patches
+
+- Fork HoverState.js to allow hover events on Pressable (saadnajmi2@gmail.com)
+
+## 0.64.27
+
+Mon, 06 Dec 2021 16:10:29 GMT
+
+### Patches
+
+- Remove legacy logic to find win32 bundle (30809111+acoates-ms@users.noreply.github.com)
+- InstanceCreated should fire before any JS code is run (30809111+acoates-ms@users.noreply.github.com)
+- ReloadInstance async task and InstanceLoaded event were not correctly reporting failures (30809111+acoates-ms@users.noreply.github.com)
+- Better reporting of failures to load the bundle file (30809111+acoates-ms@users.noreply.github.com)
+- Fix crash when adding a ReactRootView while reloading a ReactHost (30809111+acoates-ms@users.noreply.github.com)
+- Prevent TurboModules from leaking on instance shutdown (30809111+acoates-ms@users.noreply.github.com)
+- Websocket is hitting the UI queue unnecessarily (30809111+acoates-ms@users.noreply.github.com)
+- Hook up DetachViewInstance method for custom UI implementations (30809111+acoates-ms@users.noreply.github.com)
+
+## 0.64.26
+
+Mon, 15 Nov 2021 16:09:20 GMT
+
+### Patches
+
+- Fix crash loading bundle in win32 (30809111+acoates-ms@users.noreply.github.com)
+- Drop ChakraCore dependency (#9056) (julio.rocha@microsoft.com)
+
 ## 0.64.25
 
 Wed, 27 Oct 2021 19:04:04 GMT

package/Libraries/Components/Pressable/Pressable.windows.js

@@ -29,6 +29,7 @@ import type {
   LayoutEvent,
   PressEvent,
   // [Windows
+  MouseEvent,
   BlurEvent,
   FocusEvent, // Windows]
 } from '../../Types/CoreEventTypes';
@@ -66,6 +67,16 @@ type Props = $ReadOnly<{|
    */
   children: React.Node | ((state: StateCallbackType) => React.Node),
 
+  /**
+   * Duration to wait after hover in before calling `onHoverIn`.
+   */
+  delayHoverIn?: ?number,
+
+  /**
+   * Duration to wait after hover out before calling `onHoverOut`.
+   */
+  delayHoverOut?: ?number,
+
   /**
    * Duration (in milliseconds) from `onPressIn` before `onLongPress` is called.
    */
@@ -92,6 +103,16 @@ type Props = $ReadOnly<{|
    */
   onLayout?: ?(event: LayoutEvent) => void,
 
+  /**
+   * Called when the hover is activated to provide visual feedback.
+   */
+  onHoverIn?: ?(event: MouseEvent) => mixed,
+
+  /**
+   * Called when the hover is deactivated to undo visual feedback.
+   */
+  onHoverOut?: ?(event: MouseEvent) => mixed,
+
   /**
    * Called when a long-tap gesture is detected.
    */
@@ -164,9 +185,13 @@ function Pressable(props: Props, forwardedRef): React.Node {
     android_disableSound,
     android_ripple,
     children,
+    delayHoverIn,
+    delayHoverOut,
     delayLongPress,
     disabled,
     focusable,
+    onHoverIn,
+    onHoverOut,
     onLongPress,
     onPress,
     onPressIn,
@@ -221,8 +246,12 @@ function Pressable(props: Props, forwardedRef): React.Node {
       hitSlop,
       pressRectOffset: pressRetentionOffset,
       android_disableSound,
+      delayHoverIn,
+      delayHoverOut,
       delayLongPress,
       delayPressIn: unstable_pressDelay,
+      onHoverIn,
+      onHoverOut,
       onLongPress,
       onPress,
       onPressIn(event: PressEvent): void {
@@ -252,9 +281,13 @@ function Pressable(props: Props, forwardedRef): React.Node {
     [
       android_disableSound,
       android_rippleConfig,
+      delayHoverIn,
+      delayHoverOut,
       delayLongPress,
       disabled,
       hitSlop,
+      onHoverIn,
+      onHoverOut,
       onLongPress,
       onPress,
       onPressIn,

package/Libraries/Pressability/HoverState.js

@@ -8,8 +8,6 @@
  * @format
  */
 
-'use strict';
-
 import Platform from '../Utilities/Platform';
 
 let isEnabled = false;
@@ -51,6 +49,10 @@ if (Platform.OS === 'web') {
     document.addEventListener('touchmove', disableHover, true);
     document.addEventListener('mousemove', enableHover, true);
   }
+  // [Windows
+} else if (Platform.OS === 'windows') {
+  isEnabled = true;
+  // Windows]
 }
 
 export function isHoverEnabled(): boolean {

package/Microsoft.ReactNative/Modules/CreateModules.cpp

@@ -21,9 +21,9 @@ using winrt::Microsoft::ReactNative::implementation::QuirkSettings;
 
 namespace Microsoft::React {
 
-std::shared_ptr<IWebSocketResource> IWebSocketResource::Make(std::string &&urlString) {
+std::shared_ptr<IWebSocketResource> IWebSocketResource::Make() {
   std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> certExceptions;
-  return std::make_shared<WinRTWebSocketResource>(std::move(urlString), std::move(certExceptions));
+  return std::make_shared<WinRTWebSocketResource>(std::move(certExceptions));
 }
 
 std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule(

package/Microsoft.ReactNative/ReactCoreInjection.cpp

@@ -141,14 +141,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();
   }
@@ -161,9 +156,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/ReactHost.cpp

@@ -245,8 +245,8 @@ size_t ReactHost::PendingUnloadActionId() const noexcept {
   return m_pendingUnloadActionId;
 }
 
-bool ReactHost::IsInstanceLoaded() const noexcept {
-  return m_isInstanceLoaded.Load();
+bool ReactHost::IsInstanceUnloading() const noexcept {
+  return m_isInstanceUnloading.Load();
 }
 
 /*static*/ Mso::DispatchQueue ReactHost::EnsureSerialQueue(Mso::DispatchQueue const &queue) noexcept {
@@ -345,10 +345,13 @@ Mso::Future<void> ReactHost::LoadInQueue(ReactOptions &&options) noexcept {
       }
     }
 
-    return whenLoaded.AsFuture().Then(m_executor, [this](Mso::Maybe<void> && /*value*/) noexcept {
-      m_isInstanceLoaded.Store(true);
-
+    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());
       });
@@ -370,6 +373,9 @@ Mso::Future<void> ReactHost::UnloadInQueue(size_t unloadActionId) noexcept {
   // Clear the pending unload action Id
   m_pendingUnloadActionId = 0;
 
+  // This allows us to avoid initializing any new ReactViews against the old instance that is being unloaded
+  m_isInstanceUnloading.Store(true);
+
   std::vector<Mso::Future<void>> unloadCompletionList;
   ForEachViewHost([&unloadCompletionList](auto &viewHost) noexcept {
     unloadCompletionList.push_back(viewHost.UninitViewInstanceInQueue(0));
@@ -380,10 +386,10 @@ Mso::Future<void> ReactHost::UnloadInQueue(size_t unloadActionId) noexcept {
   return Mso::WhenAllCompleted(unloadCompletionList).Then(m_executor, [this](Mso::Maybe<void> && /*value*/) noexcept {
     Mso::Future<void> onUnloaded;
     if (auto reactInstance = m_reactInstance.Exchange(nullptr)) {
-      m_isInstanceLoaded.Store(false);
       onUnloaded = reactInstance->Destroy();
     }
 
+    m_isInstanceUnloading.Store(false);
     m_lastError.Store({});
 
     if (!onUnloaded) {
@@ -523,10 +529,10 @@ Mso::Future<void> ReactViewHost::InitViewInstanceInQueue() noexcept {
     return Mso::MakeCanceledFuture();
   }
 
-  //// We cannot load if instance is not loaded.
-  // if (!m_reactHost->IsInstanceLoaded()) {
-  //  return Mso::MakeCanceledFuture();
-  //}
+  // We cannot load if instance is in the process of being unloaded.
+  if (m_reactHost->IsInstanceUnloading()) {
+    return Mso::MakeCanceledFuture();
+  }
 
   // Make sure that we have a ReactInstance
   if (!m_reactHost->Instance()) {

package/Microsoft.ReactNative/ReactHost/ReactHost.h

@@ -59,7 +59,7 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
   bool IsClosed() const noexcept;
 
   size_t PendingUnloadActionId() const noexcept;
-  bool IsInstanceLoaded() const noexcept;
+  bool IsInstanceUnloading() const noexcept;
 
   template <class TCallback>
   Mso::Future<void> PostInQueue(TCallback &&callback) noexcept;
@@ -91,7 +91,7 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
   const Mso::ActiveReadableField<Mso::Promise<void>> m_notifyWhenClosed{nullptr, Queue(), m_mutex};
   size_t m_pendingUnloadActionId{0};
   size_t m_nextUnloadActionId{0};
-  const Mso::ActiveField<bool> m_isInstanceLoaded{false, Queue()};
+  const Mso::ActiveField<bool> m_isInstanceUnloading{false, Queue()};
 };
 
 //! Implements a cross-platform host for a React view

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -219,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));
@@ -467,11 +469,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);
+                  }
+                });
+
             LoadJSBundles();
 
             if (UseDeveloperSupport() && State() != ReactInstanceState::HasError) {
@@ -546,7 +558,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()));
             }
@@ -565,7 +579,7 @@ void ReactInstanceWin::OnReactInstanceLoaded(const Mso::ErrorCode &errorCode) no
     } else {
       m_state = ReactInstanceState::HasError;
       m_whenLoaded.SetError(errorCode);
-      AbandonJSCallQueue();
+      OnError(errorCode);
     }
   }
 }
@@ -617,13 +631,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);
@@ -758,22 +765,23 @@ std::function<void(std::string)> ReactInstanceWin::GetErrorCallback() noexcept {
 }
 
 void ReactInstanceWin::OnErrorWithMessage(const std::string &errorMessage) noexcept {
+  OnError(Mso::React::ReactErrorProvider().MakeErrorCode(Mso::React::ReactError{errorMessage.c_str()}));
+}
+
+void ReactInstanceWin::OnError(const Mso::ErrorCode &errorCode) noexcept {
   m_state = ReactInstanceState::HasError;
   AbandonJSCallQueue();
 
   if (m_redboxHandler && m_redboxHandler->isDevSupportEnabled()) {
     ErrorInfo errorInfo;
-    errorInfo.Message = errorMessage;
+    errorInfo.Message = errorCode.ToString();
     errorInfo.Id = 0;
     m_redboxHandler->showNewError(std::move(errorInfo), ErrorType::Native);
   }
 
-  OnError(Mso::React::ReactErrorProvider().MakeErrorCode(Mso::React::ReactError{errorMessage.c_str()}));
-  m_updateUI();
-}
-
-void ReactInstanceWin::OnError(const Mso::ErrorCode &errorCode) noexcept {
   InvokeInQueue([this, errorCode]() noexcept { m_options.OnError(errorCode); });
+
+  m_updateUI();
 }
 
 void ReactInstanceWin::OnLiveReload() noexcept {

package/Microsoft.ReactNative/TurboModulesProvider.cpp

@@ -310,23 +310,13 @@ class TurboModuleImpl : public facebook::react::TurboModule {
 TurboModulesProvider::TurboModulePtr TurboModulesProvider::getModule(
     const std::string &moduleName,
     const CallInvokerPtr &callInvoker) noexcept {
-  // see if the expected turbo module has been cached
-  auto pair = std::make_pair(moduleName, callInvoker);
-  auto itCached = m_cachedModules.find(pair);
-  if (itCached != m_cachedModules.end()) {
-    return itCached->second;
-  }
-
   // fail if the expected turbo module has not been registered
   auto it = m_moduleProviders.find(moduleName);
   if (it == m_moduleProviders.end()) {
     return nullptr;
   }
 
-  // cache and return the turbo module
-  auto tm = std::make_shared<TurboModuleImpl>(m_reactContext, moduleName, callInvoker, it->second);
-  m_cachedModules.insert({pair, tm});
-  return tm;
+  return std::make_shared<TurboModuleImpl>(m_reactContext, moduleName, callInvoker, it->second);
 }
 
 std::vector<std::string> TurboModulesProvider::getEagerInitModuleNames() noexcept {
@@ -351,8 +341,6 @@ void TurboModulesProvider::AddModuleProvider(
     m_moduleProviders.insert({key, moduleProvider});
   } else {
     // turbo modules should be replaceable before the first time it is requested
-    // if a turbo module has been requested, it will be cached in m_cachedModules
-    // in this case, changing m_moduleProviders affects nothing
     it->second = moduleProvider;
   }
 }

package/Microsoft.ReactNative/TurboModulesProvider.h

@@ -30,7 +30,6 @@ class TurboModulesProvider final : public facebook::react::TurboModuleRegistry {
 
  private:
   std::unordered_map<std::string, ReactModuleProvider> m_moduleProviders;
-  std::unordered_map<std::pair<std::string, CallInvokerPtr>, TurboModulePtr> m_cachedModules;
   IReactContext m_reactContext;
 };
 

package/Microsoft.ReactNative.Cxx/NativeModules.h

@@ -280,7 +280,7 @@ constexpr void ValidateCoroutineArg() noexcept {
     static_assert(
         !std::is_reference_v<TArg> && !std::is_pointer_v<TArg>,
         "Coroutine parameter must be passed by value for safe access"
-#ifndef __APPLE__
+#ifndef __clang__
         ": " __FUNCSIG__
 #endif
     );

package/Mso/future/futureWinRT.h

@@ -27,18 +27,20 @@ struct AsyncActionFutureAdapter : winrt::implements<
           if (strongThis->m_status == AsyncStatus::Started) {
             if (result.IsValue()) {
               strongThis->m_status = AsyncStatus::Completed;
-              if (strongThis->m_completedAssigned) {
-                handler = std::move(strongThis->m_completed);
-              }
             } else {
-              strongThis->m_status = AsyncStatus::Error;
               strongThis->m_error = result.GetError();
+              strongThis->m_status = Mso::CancellationErrorProvider().TryGetErrorInfo(strongThis->m_error, false)
+                  ? AsyncStatus::Canceled
+                  : AsyncStatus::Error;
+            }
+            if (strongThis->m_completedAssigned) {
+              handler = std::move(strongThis->m_completed);
             }
           }
         }
 
         if (handler) {
-          invoke(handler, *strongThis, AsyncStatus::Completed);
+          invoke(handler, *strongThis, strongThis->m_status);
         }
       }
     });

package/Shared/IWebSocketResource.h

@@ -79,17 +79,17 @@ struct IWebSocketResource {
   /// <summary>
   /// Creates an <c>IWebSocketResource</c> instance.
   /// </summary>
-  /// <param name="url">
-  /// WebSocket URL address the instance will connect to.
-  /// The address's scheme can be either ws:// or wss://.
-  /// </param>
-  static std::shared_ptr<IWebSocketResource> Make(std::string &&url);
+  static std::shared_ptr<IWebSocketResource> Make();
 
   virtual ~IWebSocketResource() noexcept {}
 
   /// <summary>
   /// Establishes a continuous connection with the remote endpoint.
   /// </summary>
+  /// <param name="url">
+  /// WebSocket URL address the instance will connect to.
+  /// The address's scheme can be either ws:// or wss://.
+  /// </param>
   /// <param name="protocols">
   /// Currently unused
   /// </param>
@@ -97,7 +97,7 @@ struct IWebSocketResource {
   /// HTTP header fields passed by the remote endpoint, to be used in the
   /// handshake process.
   /// </param>
-  virtual void Connect(const Protocols &protocols = {}, const Options &options = {}) noexcept = 0;
+  virtual void Connect(std::string &&url, const Protocols &protocols = {}, const Options &options = {}) noexcept = 0;
 
   /// <summary>
   /// Sends a ping frame to the remote endpoint.