react-native-windows 0.72.1 → 0.72.3

package/Shared/Modules/HttpModule.cpp

@@ -5,6 +5,7 @@
 
 #include "HttpModule.h"
 
+#include <CreateModules.h>
 #include <Modules/CxxModuleUtilities.h>
 #include <ReactPropertyBag.h>
 
@@ -14,6 +15,7 @@
 
 using facebook::react::Instance;
 using folly::dynamic;
+using std::function;
 using std::shared_ptr;
 using std::string;
 using std::weak_ptr;
@@ -23,12 +25,15 @@ using winrt::Microsoft::ReactNative::ReactPropertyBag;
 using winrt::Microsoft::ReactNative::ReactPropertyId;
 using winrt::Windows::Foundation::IInspectable;
 
+namespace msrn = winrt::Microsoft::ReactNative;
+
 namespace {
 
 using Microsoft::React::Modules::SendEvent;
 using Microsoft::React::Networking::IHttpResource;
 
-constexpr char moduleName[] = "Networking";
+constexpr char s_moduleName[] = "Networking";
+constexpr wchar_t s_moduleNameW[] = L"Networking";
 
 // React event names
 constexpr char completedResponse[] = "didCompleteNetworkResponse";
@@ -38,6 +43,15 @@ constexpr char receivedIncrementalData[] = "didReceiveNetworkIncrementalData";
 constexpr char receivedDataProgress[] = "didReceiveNetworkDataProgress";
 constexpr char receivedData[] = "didReceiveNetworkData";
 
+constexpr wchar_t completedResponseW[] = L"didCompleteNetworkResponse";
+constexpr wchar_t receivedResponseW[] = L"didReceiveNetworkResponse";
+constexpr wchar_t sentDataW[] = L"didSendNetworkData";
+constexpr wchar_t receivedIncrementalDataW[] = L"didReceiveNetworkIncrementalData";
+constexpr wchar_t receivedDataProgressW[] = L"didReceiveNetworkDataProgress";
+constexpr wchar_t receivedDataW[] = L"didReceiveNetworkData";
+
+msrn::ReactModuleProvider s_moduleProvider = msrn::MakeTurboModuleProvider<Microsoft::React::HttpTurboModule>();
+
 static void SetUpHttpResource(
     shared_ptr<IHttpResource> resource,
     weak_ptr<Instance> weakReactInstance,
@@ -65,10 +79,11 @@ static void SetUpHttpResource(
   });
 
   // Explicitly declaring function type to avoid type inference ambiguity.
-  std::function<void(int64_t, dynamic &&)> onDataDynamic = [weakReactInstance](
-                                                               int64_t requestId, dynamic &&responseData) {
-    SendEvent(weakReactInstance, receivedData, dynamic::array(requestId, std::move(responseData)));
-  };
+  function<void(int64_t, msrn::JSValueObject &&)> onDataDynamic =
+      [weakReactInstance](int64_t requestId, msrn::JSValueObject &&responseData) {
+        auto responseDynamic = Microsoft::React::Modules::ToDynamic(msrn::JSValue{std::move(responseData)});
+        SendEvent(weakReactInstance, receivedData, dynamic::array(requestId, std::move(responseDynamic)));
+      };
   resource->SetOnData(std::move(onDataDynamic));
 
   resource->SetOnIncrementalData(
@@ -101,6 +116,104 @@ static void SetUpHttpResource(
 
 namespace Microsoft::React {
 
+#pragma region HttpTurboModule
+
+void HttpTurboModule::Initialize(msrn::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
+  m_resource = IHttpResource::Make(m_context.Properties().Handle());
+
+  m_resource->SetOnRequestSuccess([context = m_context](int64_t requestId) {
+    SendEvent(context, completedResponseW, msrn::JSValueArray{requestId});
+  });
+
+  m_resource->SetOnResponse([context = m_context](int64_t requestId, IHttpResource::Response &&response) {
+    auto headers = msrn::JSValueObject{};
+    for (auto &header : response.Headers) {
+      headers[header.first] = header.second;
+    }
+
+    // TODO: Test response content?
+    auto args = msrn::JSValueArray{requestId, response.StatusCode, std::move(headers), response.Url};
+
+    SendEvent(context, receivedResponseW, std::move(args));
+  });
+
+  m_resource->SetOnData([context = m_context](int64_t requestId, string &&responseData) {
+    SendEvent(context, receivedDataW, msrn::JSValueArray{requestId, std::move(responseData)});
+  });
+
+  // Explicitly declaring function type to avoid type inference ambiguity.
+  function<void(int64_t, msrn::JSValueObject &&)> onDataObject =
+      [context = m_context](int64_t requestId, msrn::JSValueObject &&responseData) {
+        SendEvent(context, receivedDataW, msrn::JSValueArray{requestId, std::move(responseData)});
+      };
+  m_resource->SetOnData(std::move(onDataObject));
+
+  m_resource->SetOnIncrementalData(
+      [context = m_context](int64_t requestId, string &&responseData, int64_t progress, int64_t total) {
+        SendEvent(
+            context, receivedIncrementalDataW, msrn::JSValueArray{requestId, std::move(responseData), progress, total});
+      });
+
+  m_resource->SetOnDataProgress([context = m_context](int64_t requestId, int64_t progress, int64_t total) {
+    SendEvent(context, receivedDataProgressW, msrn::JSValueArray{requestId, progress, total});
+  });
+
+  m_resource->SetOnResponseComplete([context = m_context](int64_t requestId) {
+    SendEvent(context, completedResponseW, msrn::JSValueArray{requestId});
+  });
+
+  m_resource->SetOnError([context = m_context](int64_t requestId, string &&message, bool isTimeout) {
+    auto args = msrn::JSValueArray{requestId, std::move(message)};
+    if (isTimeout) {
+      args.push_back(true);
+    }
+
+    SendEvent(context, completedResponseW, std::move(args));
+  });
+}
+
+void HttpTurboModule::SendRequest(
+    ReactNativeSpecs::NetworkingIOSSpec_sendRequest_query &&query,
+    function<void(double)> const &callback) noexcept {
+  m_requestId++;
+  auto &headersObj = query.headers.AsObject();
+  IHttpResource::Headers headers;
+  for (auto &entry : headersObj) {
+    headers.emplace(entry.first, entry.second.AsString());
+  }
+
+  m_resource->SendRequest(
+      std::move(query.method),
+      std::move(query.url),
+      m_requestId,
+      std::move(headers),
+      query.data.MoveObject(),
+      std::move(query.responseType),
+      query.incrementalUpdates,
+      static_cast<int64_t>(query.timeout),
+      query.withCredentials,
+      [&callback](int64_t requestId) { callback({static_cast<double>(requestId)}); });
+}
+
+void HttpTurboModule::AbortRequest(double requestId) noexcept {
+  m_resource->AbortRequest(static_cast<int64_t>(requestId));
+}
+
+void HttpTurboModule::ClearCookies(function<void(bool)> const &callback) noexcept {
+  m_resource->ClearCookies();
+}
+
+void HttpTurboModule::AddListener(string &&eventName) noexcept { /*NOOP*/
+}
+
+void HttpTurboModule::RemoveListeners(double count) noexcept { /*NOOP*/
+}
+
+#pragma endregion HttpTurboModule
+
+#pragma region HttpModule
+
 HttpModule::HttpModule(IInspectable const &inspectableProperties) noexcept
     : m_holder{std::make_shared<ModuleHolder>()},
       m_inspectableProperties{inspectableProperties},
@@ -115,7 +228,7 @@ HttpModule::~HttpModule() noexcept /*override*/ {
 #pragma region CxxModule
 
 string HttpModule::getName() /*override*/ {
-  return moduleName;
+  return s_moduleName;
 }
 
 std::map<string, dynamic> HttpModule::getConstants() {
@@ -142,6 +255,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
           SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
           holder->Module->m_isResourceSetup = true;
         }
+        holder->Module->m_requestId++;
 
         auto params = facebook::xplat::jsArgAsObject(args, 0);
         IHttpResource::Headers headers;
@@ -152,9 +266,9 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
         resource->SendRequest(
           params["method"].asString(),
           params["url"].asString(),
-          params["requestId"].asInt(),
+          holder->Module->m_requestId,
           std::move(headers),
-          std::move(params["data"]),
+          Modules::ToJSValue(params["data"]).MoveObject(),
           params["responseType"].asString(),
           params["incrementalUpdates"].asBool(),
           static_cast<int64_t>(params["timeout"].asDouble()),
@@ -211,8 +325,18 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
 
 #pragma endregion CxxModule
 
+#pragma endregion HttpModule
+
 /*extern*/ const char *GetHttpModuleName() noexcept {
-  return moduleName;
+  return s_moduleName;
+}
+
+/*extern*/ const wchar_t *GetHttpTurboModuleName() noexcept {
+  return s_moduleNameW;
+}
+
+/*extern*/ const msrn::ReactModuleProvider &GetHttpModuleProvider() noexcept {
+  return s_moduleProvider;
 }
 
 } // namespace Microsoft::React

package/Shared/Modules/HttpModule.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <NativeNetworkingIOSSpec.g.h>
+#include <NativeModules.h>
 #include <Networking/IHttpResource.h>
 
 // React Native
@@ -13,6 +15,36 @@
 
 namespace Microsoft::React {
 
+REACT_MODULE(HttpTurboModule, L"Networking")
+struct HttpTurboModule {
+  using ModuleSpec = ReactNativeSpecs::NetworkingIOSSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  REACT_METHOD(SendRequest, L"sendRequest")
+  void SendRequest(
+      ReactNativeSpecs::NetworkingIOSSpec_sendRequest_query &&query,
+      std::function<void(double)> const &callback) noexcept;
+
+  REACT_METHOD(AbortRequest, L"abortRequest")
+  void AbortRequest(double requestId) noexcept;
+
+  REACT_METHOD(ClearCookies, L"clearCookies")
+  void ClearCookies(std::function<void(bool)> const &callback) noexcept;
+
+  REACT_METHOD(AddListener, L"addListener")
+  void AddListener(std::string &&eventName) noexcept;
+
+  REACT_METHOD(RemoveListeners, L"removeListeners")
+  void RemoveListeners(double count) noexcept;
+
+ private:
+  std::shared_ptr<Networking::IHttpResource> m_resource;
+  winrt::Microsoft::ReactNative::ReactContext m_context;
+  int64_t m_requestId{0};
+};
+
 ///
 /// Realizes <c>NativeModules</c> projection.
 /// <remarks>See src\Libraries\Network\RCTNetworking.windows.js</remarks>
@@ -53,6 +85,7 @@ class HttpModule : public facebook::xplat::module::CxxModule {
   std::shared_ptr<Networking::IHttpResource> m_resource;
   std::shared_ptr<ModuleHolder> m_holder;
   bool m_isResourceSetup{false};
+  int64_t m_requestId{0};
 
   // Property bag high level reference.
   winrt::Windows::Foundation::IInspectable m_inspectableProperties;

package/Shared/Modules/IRequestBodyHandler.h

@@ -3,8 +3,8 @@
 
 #pragma once
 
-// Folly
-#include <folly/dynamic.h>
+// React Native Windows
+#include <JSValue.h>
 
 // Standard Library
 #include <string>
@@ -26,7 +26,7 @@ struct IRequestBodyHandler {
   /// true  - <paramref name="data" /> contains a blob reference.
   /// false - <paramref name="data" /> does not contain a blob reference.
   /// </returns>
-  virtual bool Supports(folly::dynamic &data) = 0;
+  virtual bool Supports(winrt::Microsoft::ReactNative::JSValueObject &data) = 0;
 
   /// <summary>
   /// Returns the {@link RequestBody} for the JS body payload.
@@ -46,7 +46,9 @@ struct IRequestBodyHandler {
   /// "bytes" - Raw body content
   ///           NOTE: This is an arbitrary key. Pending non-folly structured object to model request body.
   /// </returns>
-  virtual folly::dynamic ToRequestBody(folly::dynamic &data, std::string &contentType) = 0;
+  virtual winrt::Microsoft::ReactNative::JSValueObject ToRequestBody(
+      winrt::Microsoft::ReactNative::JSValueObject &data,
+      std::string &contentType) = 0;
 };
 
 } // namespace Microsoft::React

package/Shared/Modules/IResponseHandler.h

@@ -1,7 +1,7 @@
 #pragma once
 
-// Folly
-#include <folly/dynamic.h>
+// React Native Windows
+#include <JSValue.h>
 
 // Standard Library
 #include <string>
@@ -21,7 +21,7 @@ struct IResponseHandler {
   /// <summary>
   /// Returns the JS body payload for the {@link ResponseBody}.
   /// </summary>
-  virtual folly::dynamic ToResponseData(std::vector<uint8_t> &&content) = 0;
+  virtual winrt::Microsoft::ReactNative::JSValueObject ToResponseData(std::vector<uint8_t> &&content) = 0;
 };
 
 } // namespace Microsoft::React

package/Shared/Modules/IUriHandler.h

@@ -3,8 +3,8 @@
 
 #pragma once
 
-// Folly
-#include <folly/dynamic.h>
+// React Native Windows
+#include <JSValue.h>
 
 // Standard Library
 #include <string>
@@ -31,7 +31,7 @@ struct IUriHandler {
   /// "size"        - Number of bytes fetched from blob
   /// "name"        - File name obtained from the URI
   /// "lastModified - Last write to local file in milliseconds
-  virtual folly::dynamic Fetch(std::string &uri) = 0;
+  virtual winrt::Microsoft::ReactNative::JSValueObject Fetch(std::string &uri) = 0;
 };
 
 } // namespace Microsoft::React

package/Shared/Modules/IWebSocketModuleContentHandler.h

@@ -3,8 +3,8 @@
 
 #pragma once
 
-// React Native
-#include <folly/dynamic.h>
+// React Native Windows
+#include <JSValue.h>
 
 // Standard Library
 #include <string>
@@ -18,9 +18,11 @@ namespace Microsoft::React {
 struct IWebSocketModuleContentHandler {
   virtual ~IWebSocketModuleContentHandler() noexcept {}
 
-  virtual void ProcessMessage(std::string &&message, folly::dynamic &params) = 0;
+  virtual void ProcessMessage(std::string &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
 
-  virtual void ProcessMessage(std::vector<uint8_t> &&message, folly::dynamic &params) = 0;
+  virtual void ProcessMessage(
+      std::vector<uint8_t> &&message,
+      winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
 };
 
 } // namespace Microsoft::React

package/Shared/Modules/WebSocketModule.cpp

@@ -4,11 +4,16 @@
 #include "pch.h"
 
 #include <Modules/WebSocketModule.h>
+#include <Modules/WebSocketTurboModule.h>
 
+#include <CreateModules.h>
 #include <Modules/CxxModuleUtilities.h>
 #include <Modules/IWebSocketModuleContentHandler.h>
 #include <ReactPropertyBag.h>
 
+// fmt
+#include <fmt/format.h>
+
 // React Native
 #include <cxxreact/Instance.h>
 #include <cxxreact/JsArgumentHelpers.h>
@@ -19,6 +24,8 @@
 // Standard Libriary
 #include <iomanip>
 
+namespace msrn = winrt::Microsoft::ReactNative;
+
 using namespace facebook::xplat;
 
 using facebook::react::Instance;
@@ -26,6 +33,7 @@ using folly::dynamic;
 
 using std::shared_ptr;
 using std::string;
+using std::vector;
 using std::weak_ptr;
 
 using winrt::Microsoft::ReactNative::IReactPropertyBag;
@@ -42,7 +50,10 @@ using Microsoft::React::WebSocketModule;
 using Microsoft::React::Modules::SendEvent;
 using Microsoft::React::Networking::IWebSocketResource;
 
-constexpr char moduleName[] = "WebSocketModule";
+constexpr char s_moduleName[] = "WebSocketModule";
+constexpr wchar_t s_moduleNameW[] = L"WebSocketModule";
+
+msrn::ReactModuleProvider s_moduleProvider = msrn::MakeTurboModuleProvider<Microsoft::React::WebSocketTurboModule>();
 
 static shared_ptr<IWebSocketResource>
 GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedState> weakState) {
@@ -105,7 +116,7 @@ GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedS
           if (!strongInstance)
             return;
 
-          dynamic args = dynamic::object("id", id)("type", isBinary ? "binary" : "text");
+          auto args = msrn::JSValueObject{{"id", id}, {"type", isBinary ? "binary" : "text"}};
           shared_ptr<Microsoft::React::IWebSocketModuleContentHandler> contentHandler;
           auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<Microsoft::React::IWebSocketModuleContentHandler>>>{
               L"BlobModule.ContentHandler"};
@@ -117,7 +128,7 @@ GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedS
               auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(message));
               winrt::com_array<uint8_t> arr;
               CryptographicBuffer::CopyToByteArray(buffer, arr);
-              auto data = std::vector<uint8_t>(arr.begin(), arr.end());
+              auto data = vector<uint8_t>(arr.begin(), arr.end());
 
               contentHandler->ProcessMessage(std::move(data), args);
             } else {
@@ -127,7 +138,7 @@ GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedS
             args["data"] = message;
           }
 
-          SendEvent(weakInstance, "websocketMessage", std::move(args));
+          SendEvent(weakInstance, "websocketMessage", Microsoft::React::Modules::ToDynamic(std::move(args)));
         });
     ws->SetOnClose([id, weakInstance](IWebSocketResource::CloseCode code, const string &reason) {
       auto strongInstance = weakInstance.lock();
@@ -179,7 +190,7 @@ void WebSocketModule::SetResourceFactory(
 }
 
 string WebSocketModule::getName() {
-  return moduleName;
+  return s_moduleName;
 }
 
 std::map<string, dynamic> WebSocketModule::getConstants() {
@@ -187,7 +198,7 @@ std::map<string, dynamic> WebSocketModule::getConstants() {
 }
 
 // clang-format off
-std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMethods()
+vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMethods()
 {
   return
   {
@@ -312,8 +323,172 @@ void WebSocketModuleProxy::SendBinary(std::string &&base64String, int64_t id) no
 
 #pragma endregion WebSocketModuleProxy
 
+#pragma region WebSocketTurboModule
+
+shared_ptr<IWebSocketResource> WebSocketTurboModule::CreateResource(int64_t id, string &&url) noexcept {
+  shared_ptr<IWebSocketResource> rc;
+  try {
+    rc = IWebSocketResource::Make();
+  } catch (const winrt::hresult_error &e) {
+    auto error = fmt::format("[0x{:0>8x}] {}", static_cast<uint32_t>(e.code()), winrt::to_string(e.message()));
+    SendEvent(m_context, L"webSocketFailed", {{"id", id}, {"message", std::move(error)}});
+
+    return nullptr;
+  } catch (const std::exception &e) {
+    SendEvent(m_context, L"webSocketFailed", {{"id", id}, {"message", e.what()}});
+
+    return nullptr;
+  } catch (...) {
+    SendEvent(
+        m_context, L"webSocketFailed", {{"id", id}, {"message", "Unidentified error creating IWebSocketResource"}});
+
+    return nullptr;
+  }
+
+  // Set up resource
+  rc->SetOnConnect([id, context = m_context]() {
+    SendEvent(context, L"websocketOpen", msrn::JSValueObject{{"id", id}});
+  });
+
+  rc->SetOnMessage([id, context = m_context](size_t length, const string &message, bool isBinary) {
+    auto args = msrn::JSValueObject{{"id", id}, {"type", isBinary ? "binary" : "text"}};
+    shared_ptr<IWebSocketModuleContentHandler> contentHandler;
+    auto propId =
+        ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleContentHandler>>>{L"BlobModule.ContentHandler"};
+    auto propBag = context.Properties();
+    if (auto prop = propBag.Get(propId))
+      contentHandler = prop.Value().lock();
+
+    if (contentHandler) {
+      if (isBinary) {
+        auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(message));
+        winrt::com_array<uint8_t> arr;
+        CryptographicBuffer::CopyToByteArray(buffer, arr);
+        auto data = vector<uint8_t>(arr.begin(), arr.end());
+
+        contentHandler->ProcessMessage(std::move(data), args);
+      } else {
+        contentHandler->ProcessMessage(string{message}, args);
+      }
+    } else {
+      args["data"] = message;
+    }
+
+    SendEvent(context, L"websocketMessage", std::move(args));
+  });
+
+  rc->SetOnClose([id, context = m_context](IWebSocketResource::CloseCode code, const string &reason) {
+    auto args = msrn::JSValueObject{{"id", id}, {"code", static_cast<uint16_t>(code)}, {"reason", reason}};
+
+    SendEvent(context, L"websocketClosed", std::move(args));
+  });
+
+  rc->SetOnError([id, context = m_context](const IWebSocketResource::Error &err) {
+    auto errorObj = msrn::JSValueObject{{"id", id}, {"message", err.Message}};
+
+    SendEvent(context, L"websocketFailed", std::move(errorObj));
+  });
+
+  m_resourceMap.emplace(static_cast<double>(id), rc);
+
+  return rc;
+}
+
+void WebSocketTurboModule::Initialize(msrn::ReactContext const &reactContext) noexcept {
+  m_context = reactContext.Handle();
+}
+
+void WebSocketTurboModule::Connect(
+    string &&url,
+    std::optional<vector<string>> protocols,
+    ReactNativeSpecs::WebSocketModuleSpec_connect_options &&options,
+    double socketID) noexcept {
+  IWebSocketResource::Protocols rcProtocols;
+  for (const auto &protocol : protocols.value_or(vector<string>{})) {
+    rcProtocols.push_back(protocol);
+  }
+
+  IWebSocketResource::Options rcOptions;
+  auto &optHeaders = options.headers;
+  if (optHeaders.has_value()) {
+    auto &headersVal = optHeaders.value();
+    for (const auto &headerVal : headersVal.AsArray()) {
+      // Each header JSValueObject should only contain one key-value pair
+      const auto &entry = *headerVal.AsObject().cbegin();
+      rcOptions.emplace(winrt::to_hstring(entry.first), entry.second.AsString());
+    }
+  }
+
+  weak_ptr<IWebSocketResource> weakRc;
+  auto rcItr = m_resourceMap.find(socketID);
+  if (rcItr != m_resourceMap.cend()) {
+    weakRc = (*rcItr).second;
+  } else {
+    weakRc = CreateResource(static_cast<int64_t>(socketID), string{url});
+  }
+
+  if (auto rc = weakRc.lock()) {
+    rc->Connect(std::move(url), rcProtocols, rcOptions);
+  }
+}
+
+void WebSocketTurboModule::Close(double code, string &&reason, double socketID) noexcept {
+  auto rcItr = m_resourceMap.find(socketID);
+  if (rcItr == m_resourceMap.cend()) {
+    return; // TODO: Send error instead?
+  }
+
+  weak_ptr<IWebSocketResource> weakRc = (*rcItr).second;
+  if (auto rc = weakRc.lock()) {
+    rc->Close(static_cast<IWebSocketResource::CloseCode>(code), std::move(reason));
+  }
+}
+
+void WebSocketTurboModule::Send(string &&message, double forSocketID) noexcept {
+  auto rcItr = m_resourceMap.find(forSocketID);
+  if (rcItr == m_resourceMap.cend()) {
+    return; // TODO: Send error instead?
+  }
+
+  weak_ptr<IWebSocketResource> weakRc = (*rcItr).second;
+  if (auto rc = weakRc.lock()) {
+    rc->Send(std::move(message));
+  }
+}
+
+void WebSocketTurboModule::SendBinary(string &&base64String, double forSocketID) noexcept {
+  auto rcItr = m_resourceMap.find(forSocketID);
+  if (rcItr == m_resourceMap.cend()) {
+    return; // TODO: Send error instead?
+  }
+
+  weak_ptr<IWebSocketResource> weakRc = (*rcItr).second;
+  if (auto rc = weakRc.lock()) {
+    rc->SendBinary(std::move(base64String));
+  }
+}
+
+void WebSocketTurboModule::Ping(double socketID) noexcept {
+  auto rcItr = m_resourceMap.find(socketID);
+  if (rcItr == m_resourceMap.cend()) {
+    return; // TODO: Send error instead?
+  }
+
+  weak_ptr<IWebSocketResource> weakRc = (*rcItr).second;
+  if (auto rc = weakRc.lock()) {
+    rc->Ping();
+  }
+}
+
+// See react-native/ReactAndroid/src/main/java/com/facebook/react/modules/websocket/WebSocketModule.java
+void WebSocketTurboModule::AddListener(string && /*eventName*/) noexcept {}
+
+void WebSocketTurboModule::RemoveListeners(double /*count*/) noexcept {}
+
+#pragma endregion WebSocketTurboModule
+
 /*extern*/ const char *GetWebSocketModuleName() noexcept {
-  return moduleName;
+  return s_moduleName;
 }
 
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule(
@@ -324,4 +499,12 @@ void WebSocketModuleProxy::SendBinary(std::string &&base64String, int64_t id) no
   return nullptr;
 }
 
+/*extern*/ const wchar_t *GetWebSocketTurboModuleName() noexcept {
+  return s_moduleNameW;
+}
+
+/*extern*/ const msrn::ReactModuleProvider &GetWebSocketModuleProvider() noexcept {
+  return s_moduleProvider;
+}
+
 } // namespace Microsoft::React

package/Shared/Modules/WebSocketTurboModule.h

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <NativeWebSocketModuleSpec.g.h>
+#include <Modules/IWebSocketModuleProxy.h>
+#include <NativeModules.h>
+#include <Networking/IWebSocketResource.h>
+
+namespace Microsoft::React {
+
+REACT_MODULE(WebSocketTurboModule, L"WebSocketModule")
+struct WebSocketTurboModule {
+  using ModuleSpec = ReactNativeSpecs::WebSocketModuleSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  REACT_METHOD(Connect, L"connect")
+  void Connect(
+      std::string &&url,
+      std::optional<std::vector<std::string>> protocols,
+      ReactNativeSpecs::WebSocketModuleSpec_connect_options &&options,
+      double socketID) noexcept;
+
+  REACT_METHOD(Close, L"close")
+  void Close(double code, std::string &&reason, double socketID) noexcept;
+
+  REACT_METHOD(Send, L"send")
+  void Send(std::string &&message, double forSocketID) noexcept;
+
+  REACT_METHOD(SendBinary, L"sendBinary")
+  void SendBinary(std::string &&base64String, double forSocketID) noexcept;
+
+  REACT_METHOD(Ping, L"ping")
+  void Ping(double socketID) noexcept;
+
+  REACT_METHOD(AddListener, L"addListener")
+  void AddListener(std::string &&eventName) noexcept;
+
+  REACT_METHOD(RemoveListeners, L"removeListeners")
+  void RemoveListeners(double count) noexcept;
+
+ private:
+  std::shared_ptr<Networking::IWebSocketResource> CreateResource(int64_t id, std::string &&url) noexcept;
+
+  winrt::Microsoft::ReactNative::ReactContext m_context;
+  std::unordered_map<double, std::shared_ptr<Networking::IWebSocketResource>> m_resourceMap;
+};
+
+} // namespace Microsoft::React