react-native-windows 0.71.24 → 0.71.26

package/Shared/Modules/CxxModuleUtilities.h

@@ -9,6 +9,9 @@
 // React Native
 #include <cxxreact/Instance.h>
 
+// React Native Windows
+#include <ReactContext.h>
+
 // Standard Library
 #include <memory>
 #include <string>
@@ -20,4 +23,18 @@ void SendEvent(
     std::string &&eventName,
     folly::dynamic &&args);
 
+void SendEvent(
+    winrt::Microsoft::ReactNative::ReactContext const &reactContext,
+    std::wstring_view &&eventName,
+    winrt::Microsoft::ReactNative::JSValueObject &&args) noexcept;
+
+void SendEvent(
+    winrt::Microsoft::ReactNative::ReactContext const &reactContext,
+    std::wstring_view &&eventName,
+    winrt::Microsoft::ReactNative::JSValueArray &&args) noexcept;
+
+winrt::Microsoft::ReactNative::JSValue ToJSValue(folly::dynamic &value) noexcept;
+
+folly::dynamic ToDynamic(const winrt::Microsoft::ReactNative::JSValue &value) noexcept;
+
 } // namespace Microsoft::React::Modules

package/Shared/Modules/FileReaderModule.cpp

@@ -3,6 +3,7 @@
 
 #include "FileReaderModule.h"
 
+#include <CreateModules.h>
 #include <ReactPropertyBag.h>
 #include <sstream>
 
@@ -19,17 +20,18 @@
 
 using namespace facebook::xplat;
 
+namespace msrn = winrt::Microsoft::ReactNative;
+
 using folly::dynamic;
 using std::string;
 using std::weak_ptr;
-using winrt::Microsoft::ReactNative::IReactPropertyBag;
-using winrt::Microsoft::ReactNative::ReactNonAbiValue;
-using winrt::Microsoft::ReactNative::ReactPropertyBag;
-using winrt::Microsoft::ReactNative::ReactPropertyId;
 using winrt::Windows::Foundation::IInspectable;
 
 namespace {
-constexpr char moduleName[] = "FileReaderModule";
+constexpr char s_moduleName[] = "FileReaderModule";
+constexpr wchar_t s_moduleNameW[] = L"FileReaderModule";
+
+msrn::ReactModuleProvider s_moduleProvider = msrn::MakeTurboModuleProvider<Microsoft::React::FileReaderTurboModule>();
 } // namespace
 
 namespace Microsoft::React {
@@ -37,7 +39,7 @@ namespace Microsoft::React {
 #pragma region FileReaderModule
 
 FileReaderModule::FileReaderModule(weak_ptr<IBlobPersistor> weakBlobPersistor) noexcept
-    : m_weakBlobPersistor{weakBlobPersistor} {}
+    : m_resource{IFileReaderResource::Make(weakBlobPersistor)} {}
 
 FileReaderModule::~FileReaderModule() noexcept /*override*/
 {}
@@ -45,7 +47,7 @@ FileReaderModule::~FileReaderModule() noexcept /*override*/
 #pragma region CxxModule
 
 string FileReaderModule::getName() {
-  return moduleName;
+  return s_moduleName;
 }
 
 std::map<string, dynamic> FileReaderModule::getConstants() {
@@ -61,41 +63,28 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
        /// </param>
        ///
        "readAsDataURL",
-       [blobPersistor = m_weakBlobPersistor.lock()](dynamic args, Callback resolve, Callback reject) {
-         if (!blobPersistor) {
-           return reject({"Could not find Blob persistor"});
-         }
-
+       [resource = m_resource](dynamic args, Callback resolve, Callback reject) {
          auto blob = jsArgAsObject(args, 0);
 
          auto blobId = blob["blobId"].asString();
          auto offset = blob["offset"].asInt();
          auto size = blob["size"].asInt();
 
-         winrt::array_view<uint8_t const> bytes;
-         try {
-           bytes = blobPersistor->ResolveMessage(std::move(blobId), offset, size);
-         } catch (const std::exception &e) {
-           return reject({e.what()});
-         }
-
-         auto result = string{"data:"};
          auto typeItr = blob.find("type");
+         string type{};
          if (typeItr == blob.items().end()) {
-           result += "application/octet-stream";
+           type = "application/octet-stream";
          } else {
-           result += (*typeItr).second.asString();
+           type = (*typeItr).second.asString();
          }
-         result += ";base64,";
-
-         // https://www.boost.org/doc/libs/1_76_0/libs/serialization/doc/dataflow.html
-         using namespace boost::archive::iterators;
-         typedef base64_from_binary<transform_width<const char *, 6, 8>> encode_base64;
-         std::ostringstream oss;
-         std::copy(encode_base64(bytes.cbegin()), encode_base64(bytes.cend()), ostream_iterator<char>(oss));
-         result += oss.str();
 
-         resolve({std::move(result)});
+         resource->ReadAsDataUrl(
+             std::move(blobId),
+             offset,
+             size,
+             std::move(type),
+             [&resolve](string &&message) { resolve({std::move(message)}); },
+             [&reject](string &&message) { reject({std::move(message)}); });
        }},
       {///
        /// <param name="args">
@@ -105,11 +94,7 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
        /// </param>
        ///
        "readAsText",
-       [blobPersistor = m_weakBlobPersistor.lock()](dynamic args, Callback resolve, Callback reject) {
-         if (!blobPersistor) {
-           return reject({"Could not find Blob persistor"});
-         }
-
+       [resource = m_resource](dynamic args, Callback resolve, Callback reject) {
          auto blob = jsArgAsObject(args, 0);
          auto encoding = jsArgAsString(args, 1); // Default: "UTF-8"
 
@@ -117,18 +102,13 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
          auto offset = blob["offset"].asInt();
          auto size = blob["size"].asInt();
 
-         winrt::array_view<uint8_t const> bytes;
-         try {
-           bytes = blobPersistor->ResolveMessage(std::move(blobId), offset, size);
-         } catch (const std::exception &e) {
-           return reject({e.what()});
-         }
-
-         // #9982 - Handle non-UTF8 encodings
-         //         See https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/charset/Charset.html
-         auto result = string{bytes.cbegin(), bytes.cend()};
-
-         resolve({std::move(result)});
+         resource->ReadAsText(
+             std::move(blobId),
+             offset,
+             size,
+             std::move(encoding),
+             [&resolve](string &&message) { resolve({std::move(message)}); },
+             [&reject](string &&message) { reject({std::move(message)}); });
        }}};
 }
 
@@ -136,14 +116,93 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
 
 #pragma endregion FileReaderModule
 
+#pragma region FileReaderTurboModule
+
+void FileReaderTurboModule::Initialize(msrn::ReactContext const &reactContext) noexcept {
+  auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
+  auto props = reactContext.Properties();
+  auto prop = props.Get(propId);
+  m_resource = IFileReaderResource::Make(prop.Value());
+}
+
+///
+/// <param name="data">
+/// Blob object with the following fields:
+/// - blobId
+/// - offset
+/// - size
+/// - type (optional)
+/// </param>
+/// <param name="result">
+/// Either resolves or rejects the current method with a given text message.
+/// </param>
+///
+void FileReaderTurboModule::ReadAsDataUrl(msrn::JSValue &&data, msrn::ReactPromise<msrn::JSValue> &&result) noexcept {
+  auto &blob = data.AsObject();
+  auto blobId = blob["blobId"].AsString();
+  auto offset = blob["offset"].AsInt64();
+  auto size = blob["size"].AsInt64();
+
+  auto typeItr = blob.find("type");
+  string type{};
+  if (typeItr == blob.end()) {
+    type = "application/octet-stream";
+  } else {
+    type = (*typeItr).second.AsString();
+  }
+
+  m_resource->ReadAsDataUrl(
+      std::move(blobId),
+      offset,
+      size,
+      std::move(type),
+      [&result](string &&message) { result.Resolve(std::move(message)); },
+      [&result](string &&message) { result.Reject(winrt::to_hstring(std::move(message)).c_str()); });
+}
+
+///
+/// <param name="data">
+/// Blob object with the following fields:
+/// - blobId
+/// - offset
+/// - size
+/// - type (optional)
+/// </param>
+/// <param name="encoding">
+/// Text encoding to proces data with.
+/// </param>
+/// <param name="result">
+/// Either resolves or rejects the current method with a given text message.
+/// </param>
+///
+void FileReaderTurboModule::ReadAsText(
+    msrn::JSValue &&data,
+    string &&encoding,
+    msrn::ReactPromise<msrn::JSValue> &&result) noexcept {
+  auto &blob = data.AsObject();
+  auto blobId = blob["blobId"].AsString();
+  auto offset = blob["offset"].AsInt64();
+  auto size = blob["size"].AsInt64();
+
+  m_resource->ReadAsText(
+      std::move(blobId),
+      offset,
+      size,
+      std::move(encoding),
+      [&result](string &&message) { result.Resolve(std::move(message)); },
+      [&result](string &&message) { result.Reject(winrt::to_hstring(std::move(message)).c_str()); });
+}
+
+#pragma endregion FileReaderTurboModule
+
 /*extern*/ const char *GetFileReaderModuleName() noexcept {
-  return moduleName;
+  return s_moduleName;
 }
 
 /*extern*/ std::unique_ptr<module::CxxModule> CreateFileReaderModule(
     IInspectable const &inspectableProperties) noexcept {
-  auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
-  auto propBag = ReactPropertyBag{inspectableProperties.try_as<IReactPropertyBag>()};
+  auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
+  auto propBag = msrn::ReactPropertyBag{inspectableProperties.try_as<msrn::IReactPropertyBag>()};
 
   if (auto prop = propBag.Get(propId)) {
     auto weakBlobPersistor = prop.Value();
@@ -154,4 +213,12 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
   return nullptr;
 }
 
+/*extern*/ const wchar_t *GetFileReaderTurboModuleName() noexcept {
+  return s_moduleNameW;
+}
+
+/*extern*/ const msrn::ReactModuleProvider &GetFileReaderModuleProvider() noexcept {
+  return s_moduleProvider;
+}
+
 } // namespace Microsoft::React

package/Shared/Modules/FileReaderModule.h

@@ -3,6 +3,10 @@
 
 #pragma once
 
+#include <NativeFileReaderModuleSpec.g.h>
+
+#include <IFileReaderResource.h>
+#include <NativeModules.h>
 #include "IBlobPersistor.h"
 
 // React Native
@@ -48,7 +52,29 @@ class FileReaderModule : public facebook::xplat::module::CxxModule {
 #pragma endregion CxxModule
 
  private:
-  std::weak_ptr<IBlobPersistor> m_weakBlobPersistor;
+  std::shared_ptr<IFileReaderResource> m_resource;
+};
+
+REACT_MODULE(FileReaderTurboModule, L"FileReaderModule")
+struct FileReaderTurboModule {
+  using ModuleSpec = ReactNativeSpecs::FileReaderModuleSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  REACT_METHOD(ReadAsDataUrl, L"readAsDataURL")
+  void ReadAsDataUrl(
+      winrt::Microsoft::ReactNative::JSValue &&data,
+      winrt::Microsoft::ReactNative::ReactPromise<winrt::Microsoft::ReactNative::JSValue> &&result) noexcept;
+
+  REACT_METHOD(ReadAsText, L"readAsText")
+  void ReadAsText(
+      winrt::Microsoft::ReactNative::JSValue &&data,
+      std::string &&encoding,
+      winrt::Microsoft::ReactNative::ReactPromise<winrt::Microsoft::ReactNative::JSValue> &&result) noexcept;
+
+ private:
+  std::shared_ptr<IFileReaderResource> m_resource;
 };
 
 } // namespace Microsoft::React

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() {
@@ -124,6 +237,8 @@ std::map<string, dynamic> HttpModule::getConstants() {
 
 // clang-format off
 std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods() {
+  // See CxxNativeModule::lazyInit()
+  SetUpHttpResource(m_resource, getInstance(), m_inspectableProperties);
 
   return
   {
@@ -136,12 +251,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
           return;
         }
 
-        auto resource = holder->Module->m_resource;
-        if (!holder->Module->m_isResourceSetup)
-        {
-          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;
@@ -149,12 +259,12 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
           headers.emplace(header.first.getString(), header.second.getString());
         }
 
-        resource->SendRequest(
+        holder->Module->m_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()),
@@ -175,14 +285,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
           return;
         }
 
-        auto resource = holder->Module->m_resource;
-        if (!holder->Module->m_isResourceSetup)
-        {
-          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
-          holder->Module->m_isResourceSetup = true;
-        }
-
-        resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
+        holder->Module->m_resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
       }
     },
     {
@@ -195,14 +298,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
           return;
         }
 
-        auto resource = holder->Module->m_resource;
-        if (!holder->Module->m_isResourceSetup)
-        {
-          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
-          holder->Module->m_isResourceSetup = true;
-        }
-
-        resource->ClearCookies();
+        holder->Module->m_resource->ClearCookies();
       }
     }
   };
@@ -211,8 +307,23 @@ 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*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule(
+    IInspectable const &inspectableProperties) noexcept {
+  return std::make_unique<HttpModule>(inspectableProperties);
+}
+
+/*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>
@@ -52,7 +84,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