react-native-windows 0.64.25 → 0.64.29

package/JSI/Shared/ChakraApi.cpp

@@ -144,17 +144,9 @@ ChakraApi::JsRefHolder::~JsRefHolder() noexcept {
   JsPropertyIdRef propertyId{JS_INVALID_REFERENCE};
   // We use a #ifdef here because we can avoid a UTF-8 to UTF-16 conversion
   // using ChakraCore's JsCreatePropertyId API.
-#ifdef CHAKRACORE
-  if (React::GetRuntimeOptionBool("JSI.ForceSystemChakra")) {
-    std::wstring utf16 = Common::Unicode::Utf8ToUtf16(name.data(), name.length());
-    ChakraVerifyJsErrorElseThrow(JsGetPropertyIdFromName(utf16.data(), &propertyId));
-  } else {
-    ChakraVerifyJsErrorElseThrow(JsCreatePropertyId(name.data(), name.length(), &propertyId));
-  }
-#else
   std::wstring utf16 = Common::Unicode::Utf8ToUtf16(name.data(), name.length());
   ChakraVerifyJsErrorElseThrow(JsGetPropertyIdFromName(utf16.data(), &propertyId));
-#endif
+
   return propertyId;
 }
 
@@ -275,18 +267,7 @@ ChakraApi::JsRefHolder::~JsRefHolder() noexcept {
 /*static*/ JsValueRef ChakraApi::PointerToString(std::string_view value) {
   ChakraVerifyElseThrow(value.data(), "Cannot convert a nullptr to a JS string.");
 
-  // ChakraCore  API helps to reduce cost of UTF-8 to UTF-16 conversion.
-#ifdef CHAKRACORE
-  if (React::GetRuntimeOptionBool("JSI.ForceSystemChakra")) {
-    return PointerToString(Common::Unicode::Utf8ToUtf16(value));
-  } else {
-    JsValueRef result{JS_INVALID_REFERENCE};
-    ChakraVerifyJsErrorElseThrow(JsCreateString(value.data(), value.length(), &result));
-    return result;
-  }
-#else
   return PointerToString(Common::Unicode::Utf8ToUtf16(value));
-#endif
 }
 
 /*static*/ std::wstring_view ChakraApi::StringToPointer(JsValueRef string) {
@@ -300,24 +281,7 @@ ChakraApi::JsRefHolder::~JsRefHolder() noexcept {
   ChakraVerifyElseThrow(
       GetValueType(string) == JsString, "Cannot convert a non JS string ChakraObjectRef to a std::string.");
 
-  // We use a #ifdef here because we can avoid a UTF-8 to UTF-16 conversion
-  // using ChakraCore's JsCopyString API.
-#ifdef CHAKRACORE
-  if (React::GetRuntimeOptionBool("JSI.ForceSystemChakra")) {
-    return Common::Unicode::Utf16ToUtf8(StringToPointer(string));
-  } else {
-    size_t length{0};
-    ChakraVerifyJsErrorElseThrow(JsCopyString(string, nullptr, 0, &length));
-
-    std::string result(length, 'a');
-    ChakraVerifyJsErrorElseThrow(JsCopyString(string, result.data(), result.length(), &length));
-
-    ChakraVerifyElseThrow(length == result.length(), "Failed to convert a JS string to a std::string.");
-    return result;
-  }
-#else
   return Common::Unicode::Utf16ToUtf8(StringToPointer(string));
-#endif
 }
 
 /*static*/ JsValueRef ChakraApi::ConvertValueToString(JsValueRef value) {

package/JSI/Shared/ChakraApi.h

@@ -3,14 +3,10 @@
 
 #pragma once
 
-#ifdef CHAKRACORE
-#include "ChakraCore.h"
-#else
 #ifndef USE_EDGEMODE_JSRT
 #define USE_EDGEMODE_JSRT
 #endif
 #include <jsrt.h>
-#endif
 
 #include <cassert>
 #include <cstddef>

package/JSI/Shared/ChakraJsiRuntime_edgemode.cpp

@@ -15,7 +15,7 @@ JsStartDebugging();
 
 namespace Microsoft::JSI {
 
-#if defined(USE_EDGEMODE_JSRT) && !defined(CHAKRACORE)
+#if defined(USE_EDGEMODE_JSRT)
 /*static*/ void ChakraRuntime::initRuntimeVersion() noexcept {}
 #endif
 
@@ -42,11 +42,7 @@ std::unique_ptr<const facebook::jsi::Buffer> SystemChakraRuntime::generatePrepar
   const std::wstring scriptUTF16 =
       Microsoft::Common::Unicode::Utf8ToUtf16(reinterpret_cast<const char *>(sourceBuffer.data()), sourceBuffer.size());
 
-#ifdef CHAKRACORE
-  unsigned int bytecodeSize = 0;
-#else
   unsigned long bytecodeSize = 0;
-#endif
   if (JsSerializeScript(scriptUTF16.c_str(), nullptr, &bytecodeSize) == JsNoError) {
     std::unique_ptr<ByteArrayBuffer> bytecodeBuffer(std::make_unique<ByteArrayBuffer>(bytecodeSize));
     if (JsSerializeScript(scriptUTF16.c_str(), bytecodeBuffer->data(), &bytecodeSize) == JsNoError) {

package/JSI/Shared/ChakraRuntime.cpp

@@ -17,14 +17,10 @@
 #include <sstream>
 #include <unordered_set>
 
-#ifdef CHAKRACORE
-#include <ChakraCore.h>
-#else
 #ifndef USE_EDGEMODE_JSRT
 #define USE_EDGEMODE_JSRT
 #endif
 #include <jsrt.h>
-#endif
 
 namespace Microsoft::JSI {
 
@@ -1027,15 +1023,7 @@ std::once_flag ChakraRuntime::s_runtimeVersionInitFlag;
 uint64_t ChakraRuntime::s_runtimeVersion = 0;
 
 std::unique_ptr<facebook::jsi::Runtime> makeChakraRuntime(ChakraRuntimeArgs &&args) noexcept {
-#ifdef CHAKRACORE
-  if (React::GetRuntimeOptionBool("JSI.ForceSystemChakra")) {
-    return MakeSystemChakraRuntime(std::move(args));
-  } else {
-    return MakeChakraCoreRuntime(std::move(args));
-  }
-#else
   return MakeSystemChakraRuntime(std::move(args));
-#endif // CHAKRACORE
 }
 
 } // namespace Microsoft::JSI

package/JSI/Shared/ChakraRuntimeFactory.h

@@ -11,7 +11,5 @@ struct ChakraRuntimeArgs;
 
 std::unique_ptr<facebook::jsi::Runtime> makeChakraRuntime(ChakraRuntimeArgs &&args) noexcept;
 
-std::unique_ptr<facebook::jsi::Runtime> MakeChakraCoreRuntime(ChakraRuntimeArgs &&args) noexcept;
-
 std::unique_ptr<facebook::jsi::Runtime> MakeSystemChakraRuntime(ChakraRuntimeArgs &&args) noexcept;
 } // namespace Microsoft::JSI

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/Microsoft.ReactNative.vcxproj

@@ -123,8 +123,6 @@
         REACTWINDOWS_BUILD - building with REACTWINDOWS_API as dll exports
         OLD_CPPWINRT is a workaround to make target version to 19H1
       -->
-      <PreprocessorDefinitions Condition="'$(CHAKRACOREUWP)'=='true'">CHAKRACORE;CHAKRACORE_UWP;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(CHAKRACOREUWP)'!='true'">USE_EDGEMODE_JSRT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PreprocessorDefinitions>
         REACTWINDOWS_BUILD;
         RN_PLATFORM=windows;

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/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/PropertySheets/React.Cpp.props

@@ -82,6 +82,7 @@
         BOOST_NO_TYPEID               - Configure boost not to check typeid (not to use RTTI)
         BOOST_SYSTEM_SOURCE           - Build boost::system symbols from sources (drop dependency on boost_system.lib).
         GTEST_HAS_RTTI                - Let GTest know not to use RTTI
+        USE_EDGEMODE_JSRT               When using Chakra, enforce System Chakra instead of JS9.
         WIN32_LEAN_AND_MEAN           - Reduce the Windows API included surface.
         WINRT_LEAN_AND_MEAN           - Disable rarely used cppwinrt templates that impact compile-time/PCH size.
       -->
@@ -93,6 +94,7 @@
         BOOST_NO_TYPEID;
         BOOST_SYSTEM_SOURCE;
         GTEST_HAS_RTTI=0;
+        USE_EDGEMODE_JSRT;
         WIN32_LEAN_AND_MEAN;
         %(PreprocessorDefinitions)
       </PreprocessorDefinitions>

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.