react-native-windows 0.70.6 → 0.70.8

package/Microsoft.ReactNative/Base/CoreNativeModules.cpp

@@ -20,21 +20,6 @@
 
 namespace Microsoft::ReactNative {
 
-using winrt::Microsoft::ReactNative::ReactPropertyBag;
-
-namespace {
-
-using winrt::Microsoft::ReactNative::ReactPropertyId;
-
-ReactPropertyId<bool> HttpUseMonolithicModuleProperty() noexcept {
-  static ReactPropertyId<bool> propId{
-      L"ReactNative.Http"
-      L"UseMonolithicModule"};
-  return propId;
-}
-
-} // namespace
-
 std::vector<facebook::react::NativeModuleDescription> GetCoreModules(
     const std::shared_ptr<facebook::react::MessageQueueThread> &batchingUIMessageQueue,
     const std::shared_ptr<facebook::react::MessageQueueThread>
@@ -48,17 +33,15 @@ std::vector<facebook::react::NativeModuleDescription> GetCoreModules(
       [props = context->Properties()]() { return Microsoft::React::CreateHttpModule(props); },
       jsMessageQueue);
 
-  if (!ReactPropertyBag(context->Properties()).Get(HttpUseMonolithicModuleProperty())) {
-    modules.emplace_back(
-        Microsoft::React::GetBlobModuleName(),
-        [props = context->Properties()]() { return Microsoft::React::CreateBlobModule(props); },
-        batchingUIMessageQueue);
+  modules.emplace_back(
+      Microsoft::React::GetBlobModuleName(),
+      [props = context->Properties()]() { return Microsoft::React::CreateBlobModule(props); },
+      batchingUIMessageQueue);
 
-    modules.emplace_back(
-        Microsoft::React::GetFileReaderModuleName(),
-        [props = context->Properties()]() { return Microsoft::React::CreateFileReaderModule(props); },
-        batchingUIMessageQueue);
-  }
+  modules.emplace_back(
+      Microsoft::React::GetFileReaderModuleName(),
+      [props = context->Properties()]() { return Microsoft::React::CreateFileReaderModule(props); },
+      batchingUIMessageQueue);
 
   modules.emplace_back(
       "Timing",

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,10 +10,10 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.70.6</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.70.8</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>70</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>6</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>8</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
   </PropertyGroup>
 </Project>

package/Shared/Modules/HttpModule.cpp

@@ -33,8 +33,10 @@ constexpr char moduleName[] = "Networking";
 // React event names
 constexpr char completedResponse[] = "didCompleteNetworkResponse";
 constexpr char receivedResponse[] = "didReceiveNetworkResponse";
-constexpr char receivedData[] = "didReceiveNetworkData";
+constexpr char sentData[] = "didSendNetworkData";
+constexpr char receivedIncrementalData[] = "didReceiveNetworkIncrementalData";
 constexpr char receivedDataProgress[] = "didReceiveNetworkDataProgress";
+constexpr char receivedData[] = "didReceiveNetworkData";
 
 static void SetUpHttpResource(
     shared_ptr<IHttpResource> resource,
@@ -60,9 +62,6 @@ static void SetUpHttpResource(
 
   resource->SetOnData([weakReactInstance](int64_t requestId, string &&responseData) {
     SendEvent(weakReactInstance, receivedData, dynamic::array(requestId, std::move(responseData)));
-
-    // TODO: Move into separate method IF not executed right after onData()
-    SendEvent(weakReactInstance, completedResponse, dynamic::array(requestId));
   });
 
   // Explicitly declaring function type to avoid type inference ambiguity.
@@ -72,6 +71,22 @@ static void SetUpHttpResource(
   };
   resource->SetOnData(std::move(onDataDynamic));
 
+  resource->SetOnIncrementalData(
+      [weakReactInstance](int64_t requestId, string &&responseData, int64_t progress, int64_t total) {
+        SendEvent(
+            weakReactInstance,
+            receivedIncrementalData,
+            dynamic::array(requestId, std::move(responseData), progress, total));
+      });
+
+  resource->SetOnDataProgress([weakReactInstance](int64_t requestId, int64_t progress, int64_t total) {
+    SendEvent(weakReactInstance, receivedDataProgress, dynamic::array(requestId, progress, total));
+  });
+
+  resource->SetOnResponseComplete([weakReactInstance](int64_t requestId) {
+    SendEvent(weakReactInstance, completedResponse, dynamic::array(requestId));
+  });
+
   resource->SetOnError([weakReactInstance](int64_t requestId, string &&message, bool isTimeout) {
     dynamic args = dynamic::array(requestId, std::move(message));
     if (isTimeout) {

package/Shared/Networking/IHttpResource.h

@@ -91,10 +91,136 @@ struct IHttpResource {
 
   virtual void ClearCookies() noexcept = 0;
 
+  /// <summary>
+  /// Sets a function to be invoked when a request has been successfully responded.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  /// </param>
   virtual void SetOnRequestSuccess(std::function<void(int64_t requestId)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when a response arrives and its headers are received.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="response">
+  ///   Object containing basic response data
+  ///   </param>
+  /// </param>
   virtual void SetOnResponse(std::function<void(int64_t requestId, Response &&response)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when response content data has been received.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="responseData">
+  ///   Response content payload (plain text or Base64-encoded)
+  ///   </param>
+  /// </param>
   virtual void SetOnData(std::function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when response content data has been received.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="responseData">
+  ///   Structured response content payload (i.e. Blob data)
+  ///   </param>
+  /// </param>
   virtual void SetOnData(std::function<void(int64_t requestId, folly::dynamic &&responseData)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when a response content increment has been received.
+  /// </summary>
+  /// <remarks>
+  /// The handler set by this method will only be called if the request sets the incremental updates flag.
+  /// The handler is also mutually exclusive with those set by `SetOnData`, which are used for one pass, non-incremental
+  /// updates.
+  /// </remarks>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="responseData">
+  ///   Partial response content data increment (non-accumulative)
+  ///   </param>
+  ///   <param name="progress">
+  ///   Number of bytes received so far
+  ///   </param>
+  ///   <param name="total">
+  ///   Number of total bytes to receive
+  ///   </param>
+  /// </param>
+  virtual void SetOnIncrementalData(
+      std::function<void(int64_t requestId, std::string &&responseData, int64_t progress, int64_t total)>
+          &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when response content download progress is reported.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="progress">
+  ///   Number of bytes received so far
+  ///   </param>
+  ///   <param name="total">
+  ///   Number of total bytes to receive
+  ///   </param>
+  /// </param>
+  virtual void SetOnDataProgress(
+      std::function<void(int64_t requestId, int64_t progress, int64_t total)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when a response has been fully handled (either succeeded or failed).
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  /// </param>
+  virtual void SetOnResponseComplete(std::function<void(int64_t requestId)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when an error condition is found.
+  /// </summary>
+  /// <remarks>
+  /// The handler's purpose is not to report any given HTTP error status (i.e. 403, 501).
+  /// It is meant to report application errors when executing HTTP requests.
+  /// </remarks>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  /// </param>
   virtual void SetOnError(
       std::function<void(int64_t requestId, std::string &&errorMessage, bool isTimeout)> &&handler) noexcept = 0;
 };

package/Shared/Networking/WinRTHttpResource.cpp

@@ -51,8 +51,51 @@ using winrt::Windows::Web::Http::IHttpClient;
 using winrt::Windows::Web::Http::IHttpContent;
 using winrt::Windows::Web::Http::Headers::HttpMediaTypeHeaderValue;
 
+namespace {
+
+constexpr uint32_t operator""_KiB(unsigned long long int x) {
+  return static_cast<uint32_t>(1024 * x);
+}
+
+constexpr uint32_t operator""_MiB(unsigned long long int x) {
+  return static_cast<uint32_t>(1024_KiB * x);
+}
+
+constexpr char responseTypeText[] = "text";
+constexpr char responseTypeBase64[] = "base64";
+constexpr char responseTypeBlob[] = "blob";
+
+} // namespace
 namespace Microsoft::React::Networking {
 
+// May throw winrt::hresult_error
+void AttachMultipartHeaders(IHttpContent content, const dynamic &headers) {
+  HttpMediaTypeHeaderValue contentType{nullptr};
+
+  // Headers are generally case-insensitive
+  // https://www.ietf.org/rfc/rfc2616.txt section 4.2
+  // TODO: Consolidate with PerformRequest's header parsing.
+  for (auto &header : headers.items()) {
+    auto &name = header.first.getString();
+    auto &value = header.second.getString();
+
+    if (boost::iequals(name.c_str(), "Content-Type")) {
+      contentType = HttpMediaTypeHeaderValue::Parse(to_hstring(value));
+    } else if (boost::iequals(name.c_str(), "Authorization")) {
+      bool success = content.Headers().TryAppendWithoutValidation(to_hstring(name), to_hstring(value));
+      if (!success) {
+        throw hresult_error{E_INVALIDARG, L"Failed to append Authorization"};
+      }
+    } else {
+      content.Headers().Append(to_hstring(name), to_hstring(value));
+    }
+  }
+
+  if (contentType) {
+    content.Headers().ContentType(contentType);
+  }
+}
+
 #pragma region WinRTHttpResource
 
 WinRTHttpResource::WinRTHttpResource(IHttpClient &&client) noexcept : m_client{std::move(client)} {}
@@ -81,20 +124,23 @@ IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
   // Headers are generally case-insensitive
   // https://www.ietf.org/rfc/rfc2616.txt section 4.2
   for (auto &header : reqArgs->Headers) {
-    if (boost::iequals(header.first.c_str(), "Content-Type")) {
-      bool success = HttpMediaTypeHeaderValue::TryParse(to_hstring(header.second), contentType);
+    auto &name = header.first;
+    auto &value = header.second;
+
+    if (boost::iequals(name.c_str(), "Content-Type")) {
+      bool success = HttpMediaTypeHeaderValue::TryParse(to_hstring(value), contentType);
       if (!success) {
         if (self->m_onError) {
           self->m_onError(reqArgs->RequestId, "Failed to parse Content-Type", false);
         }
         co_return nullptr;
       }
-    } else if (boost::iequals(header.first.c_str(), "Content-Encoding")) {
-      contentEncoding = header.second;
-    } else if (boost::iequals(header.first.c_str(), "Content-Length")) {
-      contentLength = header.second;
-    } else if (boost::iequals(header.first.c_str(), "Authorization")) {
-      bool success = request.Headers().TryAppendWithoutValidation(to_hstring(header.first), to_hstring(header.second));
+    } else if (boost::iequals(name.c_str(), "Content-Encoding")) {
+      contentEncoding = value;
+    } else if (boost::iequals(name.c_str(), "Content-Length")) {
+      contentLength = value;
+    } else if (boost::iequals(name.c_str(), "Authorization")) {
+      bool success = request.Headers().TryAppendWithoutValidation(to_hstring(name), to_hstring(value));
       if (!success) {
         if (self->m_onError) {
           self->m_onError(reqArgs->RequestId, "Failed to append Authorization", false);
@@ -103,7 +149,7 @@ IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
       }
     } else {
       try {
-        request.Headers().Append(to_hstring(header.first), to_hstring(header.second));
+        request.Headers().Append(to_hstring(name), to_hstring(value));
       } catch (hresult_error const &e) {
         if (self->m_onError) {
           self->m_onError(reqArgs->RequestId, Utilities::HResultToString(e), false);
@@ -146,9 +192,31 @@ IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
       auto file = co_await StorageFile::GetFileFromApplicationUriAsync(Uri{to_hstring(data["uri"].asString())});
       auto stream = co_await file.OpenReadAsync();
       content = HttpStreamContent{std::move(stream)};
-    } else if (!data["form"].empty()) {
-      // #9535 - HTTP form data support
-      // winrt::Windows::Web::Http::HttpMultipartFormDataContent()
+    } else if (!data["formData"].empty()) {
+      winrt::Windows::Web::Http::HttpMultipartFormDataContent multiPartContent;
+      auto formData = data["formData"];
+
+      // #6046 -  Overwriting WinRT's HttpMultipartFormDataContent implicit Content-Type clears the generated boundary
+      contentType = nullptr;
+
+      for (auto &formDataPart : formData) {
+        IHttpContent formContent{nullptr};
+        if (!formDataPart["string"].isNull()) {
+          formContent = HttpStringContent{to_hstring(formDataPart["string"].asString())};
+        } else if (!formDataPart["uri"].empty()) {
+          auto filePath = to_hstring(formDataPart["uri"].asString());
+          auto file = co_await StorageFile::GetFileFromPathAsync(filePath);
+          auto stream = co_await file.OpenReadAsync();
+          formContent = HttpStreamContent{stream};
+        }
+
+        if (formContent) {
+          AttachMultipartHeaders(formContent, formDataPart["headers"]);
+          multiPartContent.Add(formContent, to_hstring(formDataPart["fieldName"].asString()));
+        }
+      } // foreach form data part
+
+      content = multiPartContent;
     }
   }
 
@@ -205,7 +273,7 @@ void WinRTHttpResource::SendRequest(
     bool withCredentials,
     std::function<void(int64_t)> &&callback) noexcept /*override*/ {
   // Enforce supported args
-  assert(responseType == "text" || responseType == "base64" || responseType == "blob");
+  assert(responseType == responseTypeText || responseType == responseTypeBase64 || responseType == responseTypeBlob);
 
   if (callback) {
     callback(requestId);
@@ -283,6 +351,22 @@ void WinRTHttpResource::SetOnData(function<void(int64_t requestId, dynamic &&res
   m_onDataDynamic = std::move(handler);
 }
 
+void WinRTHttpResource::SetOnIncrementalData(
+    function<void(int64_t requestId, string &&responseData, int64_t progress, int64_t total)> &&handler) noexcept
+/*override*/ {
+  m_onIncrementalData = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnDataProgress(
+    function<void(int64_t requestId, int64_t progress, int64_t total)> &&handler) noexcept
+/*override*/ {
+  m_onDataProgress = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnResponseComplete(function<void(int64_t requestId)> &&handler) noexcept /*override*/ {
+  m_onComplete = std::move(handler);
+}
+
 void WinRTHttpResource::SetOnError(
     function<void(int64_t requestId, string &&errorMessage, bool isTimeout)> &&handler) noexcept
 /*override*/ {
@@ -316,11 +400,18 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
   auto props = winrt::multi_threaded_map<winrt::hstring, IInspectable>();
   props.Insert(L"RequestArgs", coArgs);
 
-  auto coRequest = co_await CreateRequest(std::move(coMethod), std::move(coUri), props);
-  if (!coRequest) {
-    co_return;
+  auto coRequestOp = CreateRequest(std::move(coMethod), std::move(coUri), props);
+  co_await lessthrow_await_adapter<IAsyncOperation<HttpRequestMessage>>{coRequestOp};
+  auto coRequestOpHR = coRequestOp.ErrorCode();
+  if (coRequestOpHR < 0) {
+    if (self->m_onError) {
+      self->m_onError(reqArgs->RequestId, Utilities::HResultToString(std::move(coRequestOpHR)), false);
+    }
+    co_return self->UntrackResponse(reqArgs->RequestId);
   }
 
+  auto coRequest = coRequestOp.GetResults();
+
   // If URI handler is available, it takes over request processing.
   if (auto uriHandler = self->m_uriHandler.lock()) {
     auto uri = winrt::to_string(coRequest.RequestUri().ToString());
@@ -332,6 +423,10 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
           self->m_onRequestSuccess(reqArgs->RequestId);
         }
 
+        if (self->m_onComplete) {
+          self->m_onComplete(reqArgs->RequestId);
+        }
+
         co_return;
       }
     } catch (const hresult_error &e) {
@@ -345,6 +440,9 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
 
   try {
     auto sendRequestOp = self->m_client.SendRequestAsync(coRequest);
+
+    auto isText = reqArgs->ResponseType == responseTypeText;
+
     self->TrackResponse(reqArgs->RequestId, sendRequestOp);
 
     if (reqArgs->Timeout > 0) {
@@ -411,55 +509,86 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
       auto inputStream = co_await response.Content().ReadAsInputStreamAsync();
       auto reader = DataReader{inputStream};
 
-      // #9510 - 10mb limit on fetch
-      co_await reader.LoadAsync(10 * 1024 * 1024);
+      // Accumulate all incoming request data in 8MB chunks
+      // Note, the minimum apparent valid chunk size is 128 KB
+      // Apple's implementation appears to grab 5-8 KB chunks
+      const uint32_t segmentSize = reqArgs->IncrementalUpdates ? 128_KiB : 8_MiB;
 
       // Let response handler take over, if set
       if (auto responseHandler = self->m_responseHandler.lock()) {
         if (responseHandler->Supports(reqArgs->ResponseType)) {
-          auto bytes = vector<uint8_t>(reader.UnconsumedBufferLength());
-          reader.ReadBytes(bytes);
-          auto blob = responseHandler->ToResponseData(std::move(bytes));
+          vector<uint8_t> responseData{};
+          while (auto loaded = co_await reader.LoadAsync(segmentSize)) {
+            auto length = reader.UnconsumedBufferLength();
+            auto data = vector<uint8_t>(length);
+            reader.ReadBytes(data);
+
+            responseData.insert(responseData.cend(), data.cbegin(), data.cend());
+          }
+
+          auto blob = responseHandler->ToResponseData(std::move(responseData));
 
           if (self->m_onDataDynamic && self->m_onRequestSuccess) {
             self->m_onDataDynamic(reqArgs->RequestId, std::move(blob));
             self->m_onRequestSuccess(reqArgs->RequestId);
           }
 
+          if (self->m_onComplete) {
+            self->m_onComplete(reqArgs->RequestId);
+          }
           co_return;
         }
       }
 
-      auto isText = reqArgs->ResponseType == "text";
       if (isText) {
         reader.UnicodeEncoding(UnicodeEncoding::Utf8);
       }
 
-      // #9510 - We currently accumulate all incoming request data in 10MB chunks.
-      uint32_t segmentSize = 10 * 1024 * 1024;
+      int64_t receivedBytes = 0;
       string responseData;
       winrt::Windows::Storage::Streams::IBuffer buffer;
-      uint32_t length;
-      do {
-        co_await reader.LoadAsync(segmentSize);
-        length = reader.UnconsumedBufferLength();
+      while (auto loaded = co_await reader.LoadAsync(segmentSize)) {
+        auto length = reader.UnconsumedBufferLength();
+        receivedBytes += length;
 
         if (isText) {
-          auto data = std::vector<uint8_t>(length);
+          auto data = vector<uint8_t>(length);
           reader.ReadBytes(data);
 
-          responseData += string(Common::Utilities::CheckedReinterpretCast<char *>(data.data()), data.size());
+          auto incrementData = string(Common::Utilities::CheckedReinterpretCast<char *>(data.data()), data.size());
+          // #9534 - Send incremental updates.
+          // See https://github.com/facebook/react-native/blob/v0.70.6/Libraries/Network/RCTNetworking.mm#L561
+          if (reqArgs->IncrementalUpdates) {
+            responseData = std::move(incrementData);
+
+            if (self->m_onIncrementalData) {
+              // For total, see #10849
+              self->m_onIncrementalData(reqArgs->RequestId, std::move(responseData), receivedBytes, 0 /*total*/);
+            }
+          } else {
+            responseData += std::move(incrementData);
+          }
         } else {
           buffer = reader.ReadBuffer(length);
           auto data = CryptographicBuffer::EncodeToBase64String(buffer);
 
           responseData += winrt::to_string(std::wstring_view(data));
+
+          if (self->m_onDataProgress) {
+            // For total, see #10849
+            self->m_onDataProgress(reqArgs->RequestId, receivedBytes, 0 /*total*/);
+          }
         }
-      } while (length > 0);
+      }
 
-      if (self->m_onData) {
+      // If dealing with text-incremental response data, use m_onIncrementalData instead
+      if (self->m_onData && !(reqArgs->IncrementalUpdates && isText)) {
         self->m_onData(reqArgs->RequestId, std::move(responseData));
       }
+
+      if (self->m_onComplete) {
+        self->m_onComplete(reqArgs->RequestId);
+      }
     } else {
       if (self->m_onError) {
         self->m_onError(reqArgs->RequestId, response == nullptr ? "request failed" : "No response content", false);

package/Shared/Networking/WinRTHttpResource.h

@@ -30,6 +30,10 @@ class WinRTHttpResource : public IHttpResource,
   std::function<void(int64_t requestId, std::string &&responseData)> m_onData;
   std::function<void(int64_t requestId, folly::dynamic &&responseData)> m_onDataDynamic;
   std::function<void(int64_t requestId, std::string &&errorMessage, bool isTimeout)> m_onError;
+  std::function<void(int64_t requestId, std::string &&responseData, int64_t progress, int64_t total)>
+      m_onIncrementalData;
+  std::function<void(int64_t requestId, int64_t progress, int64_t total)> m_onDataProgress;
+  std::function<void(int64_t requestId)> m_onComplete;
 
   // Used for IHttpModuleProxy
   std::weak_ptr<IUriHandler> m_uriHandler;
@@ -80,6 +84,12 @@ class WinRTHttpResource : public IHttpResource,
   void SetOnResponse(std::function<void(int64_t requestId, Response &&response)> &&handler) noexcept override;
   void SetOnData(std::function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept override;
   void SetOnData(std::function<void(int64_t requestId, folly::dynamic &&responseData)> &&handler) noexcept override;
+  void SetOnIncrementalData(
+      std::function<void(int64_t requestId, std::string &&responseData, int64_t progress, int64_t total)>
+          &&handler) noexcept override;
+  void SetOnDataProgress(
+      std::function<void(int64_t requestId, int64_t progress, int64_t total)> &&handler) noexcept override;
+  void SetOnResponseComplete(std::function<void(int64_t requestId)> &&handler) noexcept override;
   void SetOnError(
       std::function<void(int64_t requestId, std::string &&errorMessage, bool isTimeout)> &&handler) noexcept override;
 

package/Shared/OInstance.cpp

@@ -27,7 +27,6 @@
 
 #include <Modules/ExceptionsManagerModule.h>
 #include <Modules/HttpModule.h>
-#include <Modules/NetworkingModule.h>
 #include <Modules/PlatformConstantsModule.h>
 #include <Modules/SourceCodeModule.h>
 #include <Modules/StatusBarManagerModule.h>
@@ -73,11 +72,7 @@ namespace Microsoft::React {
 
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule(
     winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept {
-  if (GetRuntimeOptionBool("Http.UseMonolithicModule")) {
-    return std::make_unique<NetworkingModule>();
-  } else {
-    return std::make_unique<HttpModule>(inspectableProperties);
-  }
+  return std::make_unique<HttpModule>(inspectableProperties);
 }
 
 } // namespace Microsoft::React
@@ -641,8 +636,7 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
   // If this code is enabled, we will have unused module instances.
   // Also, MSRN has a different property bag mechanism incompatible with this method's transitionalProps variable.
 #if (defined(_MSC_VER) && !defined(WINRT))
-  if (Microsoft::React::GetRuntimeOptionBool("Blob.EnableModule") &&
-      !Microsoft::React::GetRuntimeOptionBool("Http.UseMonolithicModule")) {
+  if (Microsoft::React::GetRuntimeOptionBool("Blob.EnableModule")) {
     modules.push_back(std::make_unique<CxxNativeModule>(
         m_innerInstance,
         Microsoft::React::GetBlobModuleName(),

package/Shared/Shared.vcxitems

@@ -50,7 +50,9 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\FileReaderModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\HttpModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\I18nModule.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.cpp">
+      <ExcludedFromBuild>true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\PlatformConstantsModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\SourceCodeModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\StatusBarManagerModule.cpp" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.70.6",
+  "version": "0.70.8",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
     "@react-native-community/cli": "^9.0.0",
     "@react-native-community/cli-platform-android": "^9.0.0",
     "@react-native-community/cli-platform-ios": "^9.0.0",
-    "@react-native-windows/cli": "0.70.1",
+    "@react-native-windows/cli": "0.70.2",
     "@react-native-windows/virtualized-list": "0.70.0",
     "@react-native/assets": "1.0.0",
     "@react-native/normalize-color": "2.0.0",