react-native-windows 0.66.5 → 0.66.9

package/CHANGELOG.json

@@ -2,7 +2,67 @@
   "name": "react-native-windows",
   "entries": [
     {
-      "date": "Mon, 22 Nov 2021 16:09:45 GMT",
+      "date": "Mon, 31 Jan 2022 16:12:08 GMT",
+      "tag": "react-native-windows_v0.66.9",
+      "version": "0.66.9",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Better reporting of failures to load the bundle file",
+            "author": "30809111+acoates-ms@users.noreply.github.com",
+            "commit": "0951f3da2e746f1feb0bd7e96d3dd8d5d936d6fb",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 24 Jan 2022 16:11:33 GMT",
+      "tag": "react-native-windows_v0.66.8",
+      "version": "0.66.8",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Promote 0.66 to legacy",
+            "author": "ngerlem@microsoft.com",
+            "commit": "919d91a3e9845f9a60417fb8e47a36d7caedbc28",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 17 Jan 2022 16:12:35 GMT",
+      "tag": "react-native-windows_v0.66.7",
+      "version": "0.66.7",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Fork HoverState.js to allow hover events on Pressable",
+            "author": "saadnajmi2@gmail.com",
+            "commit": "1a70a3b499a0e695597e8669439b856d41096170",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 03 Jan 2022 16:10:55 GMT",
+      "tag": "react-native-windows_v0.66.6",
+      "version": "0.66.6",
+      "comments": {
+        "patch": [
+          {
+            "comment": "[0.66] Avoid capturing raw this pointer in WebSocket module",
+            "author": "julio.rocha@microsoft.com",
+            "commit": "1a0cec7754fdff58dad91fb15c483e884ef70aee",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 22 Nov 2021 16:09:58 GMT",
       "tag": "react-native-windows_v0.66.5",
       "version": "0.66.5",
       "comments": {

package/CHANGELOG.md

@@ -1,17 +1,49 @@
 # Change Log - react-native-windows
 
-This log was last generated on Mon, 22 Nov 2021 16:09:45 GMT and should not be manually modified.
+This log was last generated on Mon, 31 Jan 2022 16:12:08 GMT and should not be manually modified.
 
 <!-- Start content -->
 
-## 0.66.5
+## 0.66.9
 
-Mon, 22 Nov 2021 16:09:45 GMT
+Mon, 31 Jan 2022 16:12:08 GMT
 
 ### Patches
 
-- Fix C# Module Event invocation (vmorozov@microsoft.com)
+- Better reporting of failures to load the bundle file (30809111+acoates-ms@users.noreply.github.com)
 
+## 0.66.8
+
+Mon, 24 Jan 2022 16:11:33 GMT
+
+### Patches
+
+- Promote 0.66 to legacy (ngerlem@microsoft.com)
+
+## 0.66.7
+
+Mon, 17 Jan 2022 16:12:35 GMT
+
+### Patches
+
+- Fork HoverState.js to allow hover events on Pressable (saadnajmi2@gmail.com)
+
+## 0.66.6
+
+Mon, 03 Jan 2022 16:10:55 GMT
+
+### Patches
+
+- [0.66] Avoid capturing raw this pointer in WebSocket module (julio.rocha@microsoft.com)
+
+## 0.66.5
+
+Mon, 22 Nov 2021 16:09:58 GMT
+
+### Patches
+
+- Fix C# Module Event invocation (vmorozov@microsoft.com)
+
 ## 0.66.4
 
 Mon, 15 Nov 2021 16:09:53 GMT

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

@@ -25,6 +25,7 @@ import usePressability from '../../Pressability/usePressability';
 import {normalizeRect, type RectOrSize} from '../../StyleSheet/Rect';
 import type {
   LayoutEvent,
+  MouseEvent,
   PressEvent,
   // [Windows
   BlurEvent,
@@ -72,6 +73,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.
    */
@@ -98,6 +109,16 @@ type Props = $ReadOnly<{|
    */
   onLayout?: ?(event: LayoutEvent) => mixed,
 
+  /**
+   * 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.
    */
@@ -201,9 +222,13 @@ function Pressable(props: Props, forwardedRef): React.Node {
     android_ripple,
     cancelable,
     children,
+    delayHoverIn,
+    delayHoverOut,
     delayLongPress,
     disabled,
     focusable,
+    onHoverIn,
+    onHoverOut,
     onLongPress,
     onPress,
     onPressIn,
@@ -267,8 +292,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 {
@@ -301,9 +330,13 @@ function Pressable(props: Props, forwardedRef): React.Node {
       android_disableSound,
       android_rippleConfig,
       cancelable,
+      delayHoverIn,
+      delayHoverOut,
       delayLongPress,
       disabled,
       hitSlop,
+      onHoverIn,
+      onHoverOut,
       onLongPress,
       onPress,
       onPressIn,

package/Libraries/Pressability/HoverState.js

@@ -49,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

@@ -19,9 +19,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));
 }
 
 } // namespace Microsoft::React

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/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

@@ -224,9 +224,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));
@@ -468,7 +470,7 @@ 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));
@@ -483,6 +485,16 @@ void ReactInstanceWin::Initialize() noexcept {
             }
 #endif
 
+            // 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) {
@@ -558,7 +570,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()));
             }
@@ -629,13 +643,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);

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.

package/Shared/InspectorPackagerConnection.cpp

@@ -204,8 +204,7 @@ winrt::fire_and_forget InspectorPackagerConnection::connectAsync() {
   co_await winrt::resume_background();
 
   std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> certExceptions;
-  m_packagerWebSocketConnection =
-      std::make_shared<Microsoft::React::WinRTWebSocketResource>(m_url, std::move(certExceptions));
+  m_packagerWebSocketConnection = std::make_shared<Microsoft::React::WinRTWebSocketResource>(std::move(certExceptions));
 
   m_packagerWebSocketConnection->SetOnError([](const Microsoft::React::IWebSocketResource::Error &err) {
     facebook::react::tracing::error(err.Message.c_str());
@@ -270,7 +269,7 @@ winrt::fire_and_forget InspectorPackagerConnection::connectAsync() {
 
   Microsoft::React::IWebSocketResource::Protocols protocols;
   Microsoft::React::IWebSocketResource::Options options;
-  m_packagerWebSocketConnection->Connect(protocols, options);
+  m_packagerWebSocketConnection->Connect(std::string{m_url}, protocols, options);
 
   co_return;
 }

package/Shared/Modules/WebSocketModule.cpp

@@ -14,7 +14,9 @@
 #include <iomanip>
 
 using namespace facebook::xplat;
-using namespace folly;
+
+using facebook::react::Instance;
+using folly::dynamic;
 
 using Microsoft::Common::Unicode::Utf16ToUtf8;
 using Microsoft::Common::Unicode::Utf8ToUtf16;
@@ -24,17 +26,111 @@ using std::string;
 using std::weak_ptr;
 
 namespace {
+using Microsoft::React::IWebSocketResource;
+using Microsoft::React::WebSocketModule;
+
 constexpr char moduleName[] = "WebSocketModule";
+
+static void SendEvent(weak_ptr<Instance> weakInstance, string &&eventName, dynamic &&args) {
+  if (auto instance = weakInstance.lock()) {
+    instance->callJSFunction("RCTDeviceEventEmitter", "emit", dynamic::array(std::move(eventName), std::move(args)));
+  }
+}
+
+static shared_ptr<IWebSocketResource>
+GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedState> weakState) {
+  auto state = weakState.lock();
+  if (!state) {
+    return nullptr;
+  }
+
+  auto itr = state->ResourceMap.find(id);
+  if (itr == state->ResourceMap.end()) {
+    if (!state->Module) {
+      return nullptr;
+    }
+    auto weakInstance = state->Module->getInstance();
+
+    shared_ptr<IWebSocketResource> ws;
+    try {
+      ws = state->ResourceFactory(std::move(url));
+    } catch (const winrt::hresult_error &e) {
+      std::stringstream ss;
+      ss << "[" << std::hex << std::showbase << std::setw(8) << static_cast<uint32_t>(e.code()) << "] "
+         << winrt::to_string(e.message());
+
+      SendEvent(weakInstance, "webSocketFailed", dynamic::object("id", id)("message", std::move(ss.str())));
+
+      return nullptr;
+    } catch (const std::exception &e) {
+      SendEvent(weakInstance, "webSocketFailed", dynamic::object("id", id)("message", e.what()));
+
+      return nullptr;
+    } catch (...) {
+      SendEvent(
+          weakInstance,
+          "webSocketFailed",
+          dynamic::object("id", id)("message", "Unidentified error creating IWebSocketResource"));
+
+      return nullptr;
+    }
+
+    ws->SetOnError([id, weakInstance](const IWebSocketResource::Error &err) {
+      auto strongInstance = weakInstance.lock();
+      if (!strongInstance)
+        return;
+
+      auto errorObj = dynamic::object("id", id)("message", err.Message);
+      SendEvent(weakInstance, "websocketFailed", std::move(errorObj));
+    });
+    ws->SetOnConnect([id, weakInstance]() {
+      auto strongInstance = weakInstance.lock();
+      if (!strongInstance)
+        return;
+
+      auto args = dynamic::object("id", id);
+      SendEvent(weakInstance, "websocketOpen", std::move(args));
+    });
+    ws->SetOnMessage([id, weakInstance](size_t length, const string &message, bool isBinary) {
+      auto strongInstance = weakInstance.lock();
+      if (!strongInstance)
+        return;
+
+      auto args = dynamic::object("id", id)("data", message)("type", isBinary ? "binary" : "text");
+      SendEvent(weakInstance, "websocketMessage", std::move(args));
+    });
+    ws->SetOnClose([id, weakInstance](IWebSocketResource::CloseCode code, const string &reason) {
+      auto strongInstance = weakInstance.lock();
+      if (!strongInstance)
+        return;
+
+      auto args = dynamic::object("id", id)("code", static_cast<uint16_t>(code))("reason", reason);
+      SendEvent(weakInstance, "websocketClosed", std::move(args));
+    });
+
+    state->ResourceMap.emplace(id, ws);
+    return ws;
+  }
+
+  return itr->second;
+}
+
 } // anonymous namespace
 
 namespace Microsoft::React {
 
-WebSocketModule::WebSocketModule()
-    : m_resourceFactory{[](string &&url) { return IWebSocketResource::Make(std::move(url)); }} {}
+WebSocketModule::WebSocketModule() : m_sharedState{std::make_shared<SharedState>()} {
+  m_sharedState->ResourceFactory = [](string &&url) { return IWebSocketResource::Make(); };
+  m_sharedState->Module = this;
+}
+
+WebSocketModule::~WebSocketModule() noexcept /*override*/ {
+  m_sharedState->Module = nullptr;
+}
 
 void WebSocketModule::SetResourceFactory(
     std::function<shared_ptr<IWebSocketResource>(const string &)> &&resourceFactory) {
-  m_resourceFactory = std::move(resourceFactory);
+  m_sharedState->ResourceFactory = std::move(resourceFactory);
 }
 
 string WebSocketModule::getName() {
@@ -50,9 +146,9 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
 {
   return
   {
-    Method(
+    {
       "connect",
-      [this](dynamic args) // const string& url, dynamic protocols, dynamic options, int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // const string& url, dynamic protocols, dynamic options, int64_t id
       {
         IWebSocketResource::Protocols protocols;
         dynamic protocolsDynamic = jsArgAsDynamic(args, 1);
@@ -75,20 +171,21 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
           }
         }
 
-        weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 3), jsArgAsString(args, 0));
+        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 3), jsArgAsString(args, 0), weakState);
         if (auto sharedWs = weakWs.lock())
         {
-          sharedWs->Connect(protocols, options);
+          sharedWs->Connect(jsArgAsString(args, 0), protocols, options);
         }
-      }),
-    Method(
+      }
+    },
+    {
       "close",
-      [this](dynamic args) // [int64_t code, string reason,] int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // [int64_t code, string reason,] int64_t id
       {
         // See react-native\Libraries\WebSocket\WebSocket.js:_close
         if (args.size() == 3) // WebSocketModule.close(statusCode, closeReason, this._socketId);
         {
-          weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 2));
+          weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 2), {}, weakState);
           if (auto sharedWs = weakWs.lock())
           {
             sharedWs->Close(static_cast<IWebSocketResource::CloseCode>(jsArgAsInt(args, 0)), jsArgAsString(args, 1));
@@ -96,7 +193,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
         }
         else if (args.size() == 1) // WebSocketModule.close(this._socketId);
         {
-          weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 0));
+          weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 0), {}, weakState);
           if (auto sharedWs = weakWs.lock())
           {
             sharedWs->Close(IWebSocketResource::CloseCode::Normal, {});
@@ -104,137 +201,53 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
         }
         else
         {
-          auto errorObj = dynamic::object("id", -1)("message", "Incorrect number of parameters");
-          this->SendEvent("websocketFailed", std::move(errorObj));
+          auto state = weakState.lock();
+          if (state && state->Module) {
+            auto errorObj = dynamic::object("id", -1)("message", "Incorrect number of parameters");
+            SendEvent(state->Module->getInstance(), "websocketFailed", std::move(errorObj));
+          }
         }
-      }),
-    Method(
+      }
+    },
+    {
       "send",
-      [this](dynamic args) // const string& message, int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // const string& message, int64_t id
       {
-        weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 1));
+        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 1), {}, weakState);
         if (auto sharedWs = weakWs.lock())
         {
           sharedWs->Send(jsArgAsString(args, 0));
         }
-      }),
-    Method(
+      }
+    },
+    {
       "sendBinary",
-      [this](dynamic args) // const string& base64String, int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // const string& base64String, int64_t id
       {
-        weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 1));
+        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 1), {}, weakState);
         if (auto sharedWs = weakWs.lock())
         {
           sharedWs->SendBinary(jsArgAsString(args, 0));
         }
-      }),
-    Method(
+      }
+    },
+    {
       "ping",
-      [this](dynamic args) // int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // int64_t id
       {
-        weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 0));
+        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 0), {}, weakState);
         if (auto sharedWs = weakWs.lock())
         {
           sharedWs->Ping();
         }
-      })
+      }
+    }
   };
 } // getMethods
 // clang-format on
 
-#pragma region private members
-
-void WebSocketModule::SendEvent(string &&eventName, dynamic &&args) {
-  auto weakInstance = this->getInstance();
-  if (auto instance = weakInstance.lock()) {
-    instance->callJSFunction("RCTDeviceEventEmitter", "emit", dynamic::array(std::move(eventName), std::move(args)));
-  }
-}
-
-// clang-format off
-shared_ptr<IWebSocketResource> WebSocketModule::GetOrCreateWebSocket(int64_t id, string&& url)
-{
-  auto itr = m_webSockets.find(id);
-  if (itr == m_webSockets.end())
-  {
-    shared_ptr<IWebSocketResource> ws;
-    try
-    {
-      ws = m_resourceFactory(std::move(url));
-    }
-    catch (const winrt::hresult_error& e)
-    {
-      std::stringstream ss;
-      ss << "[" << std::hex << std::showbase << std::setw(8) << static_cast<uint32_t>(e.code()) << "] " <<
-        winrt::to_string(e.message());
-
-      SendEvent("webSocketFailed", dynamic::object("id", id)("message", std::move(ss.str())));
-
-      return nullptr;
-    }
-    catch (const std::exception& e)
-    {
-      SendEvent("webSocketFailed", dynamic::object("id", id)("message", e.what()));
-
-      return nullptr;
-    }
-    catch (...)
-    {
-      SendEvent("webSocketFailed", dynamic::object("id", id)("message", "Unidentified error creating IWebSocketResource"));
-
-      return nullptr;
-    }
-
-    auto weakInstance = this->getInstance();
-    ws->SetOnError([this, id, weakInstance](const IWebSocketResource::Error& err)
-    {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto errorObj = dynamic::object("id", id)("message", err.Message);
-      this->SendEvent("websocketFailed", std::move(errorObj));
-    });
-    ws->SetOnConnect([this, id, weakInstance]()
-    {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto args = dynamic::object("id", id);
-      this->SendEvent("websocketOpen", std::move(args));
-    });
-    ws->SetOnMessage([this, id, weakInstance](size_t length, const string& message, bool isBinary)
-    {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto args = dynamic::object("id", id)("data", message)("type", isBinary ? "binary" : "text");
-      this->SendEvent("websocketMessage", std::move(args));
-    });
-    ws->SetOnClose([this, id, weakInstance](IWebSocketResource::CloseCode code, const string& reason)
-    {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto args = dynamic::object("id", id)("code", static_cast<uint16_t>(code))("reason", reason);
-      this->SendEvent("websocketClosed", std::move(args));
-    });
-
-    m_webSockets.emplace(id, ws);
-    return ws;
-  }
-
-  return itr->second;
-}
-// clang-format on
-
-#pragma endregion private members
-
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule() noexcept {
-  return make_unique<WebSocketModule>();
+  return std::make_unique<WebSocketModule>();
 }
 
 } // namespace Microsoft::React

package/Shared/Modules/WebSocketModule.h

@@ -18,6 +18,26 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
 
   WebSocketModule();
 
+  ~WebSocketModule() noexcept override;
+
+  struct SharedState {
+    /// <summary>
+    /// Keeps <c>IWebSocketResource</c> instances identified by <c>id</c>.
+    /// As defined in WebSocket.js.
+    /// </summary>
+    std::map<int64_t, std::shared_ptr<IWebSocketResource>> ResourceMap{};
+
+    /// <summary>
+    /// Generates IWebSocketResource instances, defaulting to IWebSocketResource::Make.
+    /// </summary>
+    std::function<std::shared_ptr<IWebSocketResource>(std::string &&)> ResourceFactory;
+
+    /// <summary>
+    /// Keeps a raw reference to the module object to lazily retrieve the React Instance as needed.
+    /// </summary>
+    CxxModule *Module{nullptr};
+  };
+
 #pragma region CxxModule overrides
 
   /// <summary>
@@ -41,16 +61,6 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
   void SetResourceFactory(std::function<std::shared_ptr<IWebSocketResource>(const std::string &)> &&resourceFactory);
 
  private:
-  /// <summary>
-  /// Notifies an event to the current React Instance.
-  /// </summary>
-  void SendEvent(std::string &&eventName, folly::dynamic &&parameters);
-
-  /// <summary>
-  /// Creates or retrieves a raw <c>IWebSocketResource</c> pointer.
-  /// </summary>
-  std::shared_ptr<IWebSocketResource> GetOrCreateWebSocket(std::int64_t id, std::string &&url = {});
-
   /// <summary>
   /// Keeps <c>IWebSocketResource</c> instances identified by <c>id</c>.
   /// As defined in WebSocket.js.
@@ -58,9 +68,9 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
   std::map<int64_t, std::shared_ptr<IWebSocketResource>> m_webSockets;
 
   /// <summary>
-  /// Generates IWebSocketResource instances, defaulting to IWebSocketResource::Make.
+  /// Keeps members that can be accessed threads other than this module's owner accessible.
   /// </summary>
-  std::function<std::shared_ptr<IWebSocketResource>(std::string &&)> m_resourceFactory;
+  std::shared_ptr<SharedState> m_sharedState;
 };
 
 } // namespace Microsoft::React

package/Shared/OInstance.cpp

@@ -61,86 +61,6 @@
 #include <tracing/tracing.h>
 namespace fs = std::filesystem;
 
-namespace {
-
-#if (defined(_MSC_VER) && !defined(WINRT))
-
-std::string GetJSBundleDirectory(
-    const std::string &jsBundleBasePath,
-    const std::string &jsBundleRelativePath) noexcept {
-  // If there is a base path, use that to calculate the absolute path.
-  if (jsBundleBasePath.length() > 0) {
-    std::string jsBundleDirectory = jsBundleBasePath;
-    if (jsBundleDirectory.back() != '\\')
-      jsBundleDirectory += '\\';
-
-    return jsBundleDirectory += jsBundleRelativePath;
-  } else if (!PathIsRelativeA(jsBundleRelativePath.c_str())) {
-    // If the given path is an absolute path, return it as-is
-    return jsBundleRelativePath;
-  }
-  // Otherwise use the path of the executable file to construct the absolute
-  // path.
-  else {
-    wchar_t modulePath[MAX_PATH];
-
-    auto len = GetModuleFileNameW(nullptr, modulePath, _countof(modulePath));
-
-    if (len == 0 || (len == _countof(modulePath) && GetLastError() == ERROR_INSUFFICIENT_BUFFER))
-      return jsBundleRelativePath;
-
-    // remove the trailing filename as we are interested in only the path
-    auto succeeded = PathRemoveFileSpecW(modulePath);
-    if (!succeeded)
-      return jsBundleRelativePath;
-
-    std::string jsBundlePath = Microsoft::Common::Unicode::Utf16ToUtf8(modulePath, wcslen(modulePath));
-    if (!jsBundlePath.empty() && jsBundlePath.back() != '\\')
-      jsBundlePath += '\\';
-
-    return jsBundlePath += jsBundleRelativePath;
-  }
-}
-
-std::string GetJSBundleFilePath(const std::string &jsBundleBasePath, const std::string &jsBundleRelativePath) {
-  auto jsBundleFilePath = GetJSBundleDirectory(jsBundleBasePath, jsBundleRelativePath);
-
-  // Usually, the module name: "module name" + "." + "platform name", for
-  // example "lpc.win32". If we can not find the the bundle.js file under the
-  // normal folder, we are trying to find it under the folder without the dot
-  // (e.g. "lpcwin32"). VSO:1997035 remove this code after we have better name
-  // convension
-  if (PathFileExistsA((jsBundleFilePath + "\\bundle.js").c_str())) {
-    jsBundleFilePath += "\\bundle.js";
-  } else {
-    // remove the dot only if is belongs to the bundle file name.
-    size_t lastDotPosition = jsBundleFilePath.find_last_of('.');
-    size_t bundleFilePosition = jsBundleFilePath.find_last_of('\\');
-    if (lastDotPosition != std::string::npos &&
-        (bundleFilePosition == std::string::npos || lastDotPosition > bundleFilePosition)) {
-      jsBundleFilePath.erase(lastDotPosition, 1);
-    }
-
-    jsBundleFilePath += "\\bundle.js";
-
-    // Back before we have base path plumbed through, we made win32 force a
-    // seperate folder for each bundle by appending bundle.js Now that we have
-    // base path, we can handle multiple SDXs with the same index name so we
-    // should switch to using the same scheme as all the other platforms (and
-    // the bundle server)
-    // TODO: We should remove all the previous logic and use the same names as
-    // the other platforms...
-    if (!PathFileExistsA(jsBundleFilePath.c_str())) {
-      jsBundleFilePath = GetJSBundleDirectory(jsBundleBasePath, jsBundleRelativePath) + ".bundle";
-    }
-  }
-
-  return jsBundleFilePath;
-}
-#endif
-
-} // namespace
-
 using namespace facebook;
 using namespace Microsoft::JSI;
 
@@ -560,22 +480,13 @@ void InstanceImpl::loadBundleInternal(std::string &&jsBundleRelativePath, bool s
       }
     } else {
 #if (defined(_MSC_VER) && !defined(WINRT))
-      auto fullBundleFilePath = GetJSBundleFilePath(m_jsBundleBasePath, jsBundleRelativePath);
-
-      // If fullBundleFilePath exists, load User bundle.
-      // Otherwise all bundles (User and Platform) are loaded through
-      // platformBundles.
-      if (PathFileExistsA(fullBundleFilePath.c_str())) {
-        auto bundleString = FileMappingBigString::fromPath(fullBundleFilePath);
-        m_innerInstance->loadScriptFromString(std::move(bundleString), std::move(fullBundleFilePath), synchronously);
-      }
-
+      std::string bundlePath = (fs::path(m_devSettings->bundleRootPath) / jsBundleRelativePath).string();
+      auto bundleString = FileMappingBigString::fromPath(bundlePath);
 #else
       std::string bundlePath = (fs::path(m_devSettings->bundleRootPath) / (jsBundleRelativePath + ".bundle")).string();
-
       auto bundleString = std::make_unique<::Microsoft::ReactNative::StorageFileBigString>(bundlePath);
-      m_innerInstance->loadScriptFromString(std::move(bundleString), jsBundleRelativePath, synchronously);
 #endif
+      m_innerInstance->loadScriptFromString(std::move(bundleString), std::move(jsBundleRelativePath), synchronously);
     }
   } catch (const std::exception &e) {
     m_devSettings->errorCallback(e.what());

package/Shared/WinRTWebSocketResource.cpp

@@ -90,29 +90,21 @@ namespace Microsoft::React {
 // private
 WinRTWebSocketResource::WinRTWebSocketResource(
     IMessageWebSocket &&socket,
-    Uri &&uri,
     vector<ChainValidationResult> &&certExceptions)
-    : WinRTWebSocketResource(
-          std::move(socket),
-          DataWriter{socket.OutputStream()},
-          std::move(uri),
-          std::move(certExceptions)) {}
+    : WinRTWebSocketResource(std::move(socket), DataWriter{socket.OutputStream()}, std::move(certExceptions)) {}
 
 WinRTWebSocketResource::WinRTWebSocketResource(
     IMessageWebSocket &&socket,
     IDataWriter &&writer,
-    Uri &&uri,
     vector<ChainValidationResult> &&certExceptions)
-    : m_uri{std::move(uri)}, m_socket{std::move(socket)}, m_writer{std::move(writer)} {
-  m_socket.MessageReceived({this, &WinRTWebSocketResource::OnMessageReceived});
-
+    : m_socket{std::move(socket)}, m_writer{std::move(writer)} {
   for (const auto &certException : certExceptions) {
     m_socket.Control().IgnorableServerCertificateErrors().Append(certException);
   }
 }
 
-WinRTWebSocketResource::WinRTWebSocketResource(const string &urlString, vector<ChainValidationResult> &&certExceptions)
-    : WinRTWebSocketResource(MessageWebSocket{}, Uri{winrt::to_hstring(urlString)}, std::move(certExceptions)) {}
+WinRTWebSocketResource::WinRTWebSocketResource(vector<ChainValidationResult> &&certExceptions)
+    : WinRTWebSocketResource(MessageWebSocket{}, std::move(certExceptions)) {}
 
 WinRTWebSocketResource::~WinRTWebSocketResource() noexcept /*override*/
 {
@@ -123,13 +115,14 @@ WinRTWebSocketResource::~WinRTWebSocketResource() noexcept /*override*/
 
 #pragma region Private members
 
-IAsyncAction WinRTWebSocketResource::PerformConnect() noexcept {
+IAsyncAction WinRTWebSocketResource::PerformConnect(Uri &&uri) noexcept {
   auto self = shared_from_this();
+  auto coUri = std::move(uri);
 
   co_await resume_background();
 
   try {
-    auto async = self->m_socket.ConnectAsync(self->m_uri);
+    auto async = self->m_socket.ConnectAsync(coUri);
 
     co_await lessthrow_await_adapter<IAsyncAction>{async};
 
@@ -293,36 +286,6 @@ fire_and_forget WinRTWebSocketResource::PerformClose() noexcept {
   m_closePerformed.Set();
 }
 
-void WinRTWebSocketResource::OnMessageReceived(
-    IWebSocket const &sender,
-    IMessageWebSocketMessageReceivedEventArgs const &args) {
-  try {
-    string response;
-    IDataReader reader = args.GetDataReader();
-    auto len = reader.UnconsumedBufferLength();
-    if (args.MessageType() == SocketMessageType::Utf8) {
-      reader.UnicodeEncoding(UnicodeEncoding::Utf8);
-      vector<uint8_t> data(len);
-      reader.ReadBytes(data);
-
-      response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
-    } else {
-      auto buffer = reader.ReadBuffer(len);
-      winrt::hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
-
-      response = winrt::to_string(std::wstring_view(data));
-    }
-
-    if (m_readHandler) {
-      m_readHandler(response.length(), response, args.MessageType() == SocketMessageType::Binary);
-    }
-  } catch (hresult_error const &e) {
-    if (m_errorHandler) {
-      m_errorHandler({HResultToString(e), ErrorType::Receive});
-    }
-  }
-}
-
 void WinRTWebSocketResource::Synchronize() noexcept {
   // Ensure sequence of other operations
   if (m_connectRequested) {
@@ -334,7 +297,36 @@ void WinRTWebSocketResource::Synchronize() noexcept {
 
 #pragma region IWebSocketResource
 
-void WinRTWebSocketResource::Connect(const Protocols &protocols, const Options &options) noexcept {
+void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, const Options &options) noexcept {
+  m_socket.MessageReceived(
+      [self = shared_from_this()](IWebSocket const &sender, IMessageWebSocketMessageReceivedEventArgs const &args) {
+        try {
+          string response;
+          IDataReader reader = args.GetDataReader();
+          auto len = reader.UnconsumedBufferLength();
+          if (args.MessageType() == SocketMessageType::Utf8) {
+            reader.UnicodeEncoding(UnicodeEncoding::Utf8);
+            vector<uint8_t> data(len);
+            reader.ReadBytes(data);
+
+            response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
+          } else {
+            auto buffer = reader.ReadBuffer(len);
+            winrt::hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
+
+            response = winrt::to_string(std::wstring_view(data));
+          }
+
+          if (self->m_readHandler) {
+            self->m_readHandler(response.length(), response, args.MessageType() == SocketMessageType::Binary);
+          }
+        } catch (hresult_error const &e) {
+          if (self->m_errorHandler) {
+            self->m_errorHandler({HResultToString(e), ErrorType::Receive});
+          }
+        }
+      });
+
   m_readyState = ReadyState::Connecting;
 
   for (const auto &header : options) {
@@ -348,7 +340,24 @@ void WinRTWebSocketResource::Connect(const Protocols &protocols, const Options &
   }
 
   m_connectRequested = true;
-  PerformConnect();
+
+  Uri uri{nullptr};
+  try {
+    uri = Uri{winrt::to_hstring(url)};
+  } catch (hresult_error const &e) {
+    if (m_errorHandler) {
+      m_errorHandler({HResultToString(e), ErrorType::Connection});
+    }
+
+    // Abort - Mark connection as concluded.
+    SetEvent(m_connectPerformed.get());
+    m_connectPerformedPromise.set_value();
+    m_connectRequested = false;
+
+    return;
+  }
+
+  PerformConnect(std::move(uri));
 }
 
 void WinRTWebSocketResource::Ping() noexcept {

package/Shared/WinRTWebSocketResource.h

@@ -17,7 +17,6 @@
 namespace Microsoft::React {
 
 class WinRTWebSocketResource : public IWebSocketResource, public std::enable_shared_from_this<WinRTWebSocketResource> {
-  winrt::Windows::Foundation::Uri m_uri;
   winrt::Windows::Networking::Sockets::IMessageWebSocket m_socket;
   // TODO: Use or remove.
   winrt::Windows::Networking::Sockets::IMessageWebSocket::MessageReceived_revoker m_revoker;
@@ -45,28 +44,22 @@ class WinRTWebSocketResource : public IWebSocketResource, public std::enable_sha
 
   WinRTWebSocketResource(
       winrt::Windows::Networking::Sockets::IMessageWebSocket &&socket,
-      winrt::Windows::Foundation::Uri &&uri,
       std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);
 
-  winrt::Windows::Foundation::IAsyncAction PerformConnect() noexcept;
+  winrt::Windows::Foundation::IAsyncAction PerformConnect(winrt::Windows::Foundation::Uri &&uri) noexcept;
   winrt::fire_and_forget PerformPing() noexcept;
   winrt::fire_and_forget PerformWrite(std::string &&message, bool isBinary) noexcept;
   winrt::fire_and_forget PerformClose() noexcept;
 
-  void OnMessageReceived(
-      winrt::Windows::Networking::Sockets::IWebSocket const &sender,
-      winrt::Windows::Networking::Sockets::IMessageWebSocketMessageReceivedEventArgs const &args);
   void Synchronize() noexcept;
 
  public:
   WinRTWebSocketResource(
       winrt::Windows::Networking::Sockets::IMessageWebSocket &&socket,
       winrt::Windows::Storage::Streams::IDataWriter &&writer,
-      winrt::Windows::Foundation::Uri &&uri,
       std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);
 
   WinRTWebSocketResource(
-      const std::string &urlString,
       std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> &&certExceptions);
 
   ~WinRTWebSocketResource() noexcept override;
@@ -76,7 +69,7 @@ class WinRTWebSocketResource : public IWebSocketResource, public std::enable_sha
   /// <summary>
   /// <see cref="IWebSocketResource::Connect" />
   /// </summary>
-  void Connect(const Protocols &protocols, const Options &options) noexcept override;
+  void Connect(std::string &&url, const Protocols &protocols, const Options &options) noexcept override;
 
   /// <summary>
   /// <see cref="IWebSocketResource::Ping" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.66.5",
+  "version": "0.66.9",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,8 +26,8 @@
     "@react-native-community/cli": "^6.0.0",
     "@react-native-community/cli-platform-android": "^6.0.0",
     "@react-native-community/cli-platform-ios": "^6.0.0",
-    "@react-native-windows/cli": "0.66.1",
-    "@react-native-windows/virtualized-list": "0.66.0",
+    "@react-native-windows/cli": "0.66.2",
+    "@react-native-windows/virtualized-list": "0.66.1",
     "@react-native/assets": "1.0.0",
     "@react-native/normalize-color": "1.0.0",
     "@react-native/polyfills": "2.0.0",
@@ -58,7 +58,7 @@
     "ws": "^6.1.4"
   },
   "devDependencies": {
-    "@react-native-windows/codegen": "0.66.0",
+    "@react-native-windows/codegen": "0.66.1",
     "@rnw-scripts/eslint-config": "1.1.7",
     "@rnw-scripts/jest-out-of-tree-snapshot-resolver": "^1.0.1",
     "@rnx-kit/jest-preset": "^0.1.0",
@@ -84,7 +84,7 @@
     "react-native": "^0.66.0"
   },
   "beachball": {
-    "defaultNpmTag": "latest",
+    "defaultNpmTag": "v0.66-stable",
     "gitTags": true,
     "disallowedChangeTypes": [
       "major",