react-native-windows 0.0.0-canary.672 → 0.0.0-canary.673

package/Microsoft.ReactNative.Managed/packages.lock.json

@@ -24,6 +24,15 @@
           "Microsoft.SourceLink.Common": "1.0.0"
         }
       },
+      "NETStandard.Library": {
+        "type": "Direct",
+        "requested": "[2.0.3, )",
+        "resolved": "2.0.3",
+        "contentHash": "st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "1.1.0"
+        }
+      },
       "Microsoft.Build.Tasks.Git": {
         "type": "Transitive",
         "resolved": "1.0.0",
@@ -53,21 +62,13 @@
       "Microsoft.NETCore.Platforms": {
         "type": "Transitive",
         "resolved": "2.1.0",
-        "contentHash": "GmkKfoyerqmsHMn7OZj0AKpcBabD+GaafqphvX2Mw406IwiJRy1pKcKqdCfKJfYmkRyJ6+e+RaUylgdJoDa1jQ=="
+        "contentHash": "ok+RPAtESz/9MUXeIEz6Lv5XAGQsaNmEYXMsgVALj4D7kqC8gveKWXWXbufLySR2fWrwZf8smyN5RmHu0e4BHA=="
       },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
         "resolved": "1.0.0",
         "contentHash": "G8DuQY8/DK5NN+3jm5wcMcd9QYD90UV7MiLmdljSJixi3U/vNaeBKmmXUqI4DJCOeWizIUEh4ALhSt58mR+5eg=="
       },
-      "NETStandard.Library": {
-        "type": "Transitive",
-        "resolved": "2.0.3",
-        "contentHash": "548M6mnBSJWxsIlkQHfbzoYxpiYFXZZSL00p4GHYv8PkiqFBnnT68mW5mGEsA/ch9fDO9GkPgkFQpWiXZN7mAQ==",
-        "dependencies": {
-          "Microsoft.NETCore.Platforms": "1.1.0"
-        }
-      },
       "runtime.win10-arm.Microsoft.Net.Native.Compiler": {
         "type": "Transitive",
         "resolved": "2.2.7-rel-27913-00",

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.0.0-canary.672</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.0.0-canary.673</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>0</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>true</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>11b038f411acd9f1eb37a371830132f06eae3267</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>1a52d0a11b43fda3a8a72dac3b6e03349a77c01d</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/IFileReaderResource.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include <Modules/IBlobPersistor.h>
+#include "IBlobPersistor.h"
 
 // Standard Library
 #include <functional>

package/Shared/Modules/BlobModule.cpp

@@ -4,210 +4,139 @@
 #include "BlobModule.h"
 
 #include <Modules/CxxModuleUtilities.h>
-#include <Modules/IHttpModuleProxy.h>
-#include <Modules/IWebSocketModuleProxy.h>
-#include <ReactPropertyBag.h>
-#include <unicode.h>
 
 // React Native
 #include <cxxreact/JsArgumentHelpers.h>
 
-// Boost Libraries
-#include <boost/uuid/uuid_io.hpp>
-
-// Windows API
-#include <winrt/Windows.Foundation.h>
-#include <winrt/Windows.Security.Cryptography.h>
-
-// Standard Library
-#include <chrono>
-#include <filesystem>
-#include <fstream>
-
 using namespace facebook::xplat;
 
 using folly::dynamic;
-using std::scoped_lock;
-using std::shared_ptr;
+using Microsoft::React::Networking::IBlobResource;
 using std::string;
 using std::vector;
-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;
-using winrt::Windows::Foundation::Uri;
-using winrt::Windows::Security::Cryptography::CryptographicBuffer;
 
-namespace fs = std::filesystem;
 namespace msrn = winrt::Microsoft::ReactNative;
 
 namespace {
-constexpr char moduleName[] = "BlobModule";
-constexpr char blobKey[] = "blob";
-constexpr char blobIdKey[] = "blobId";
-constexpr char offsetKey[] = "offset";
-constexpr char sizeKey[] = "size";
-constexpr char typeKey[] = "type";
-constexpr char dataKey[] = "data";
+constexpr char s_moduleName[] = "BlobModule";
+
+const auto &blobKeys = IBlobResource::FieldNames();
 } // namespace
 
 namespace Microsoft::React {
 
-#pragma region BlobModule
+#pragma region BlobTurboModule
 
-BlobModule::BlobModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept
-    : m_sharedState{std::make_shared<SharedState>()},
-      m_blobPersistor{std::make_shared<MemoryBlobPersistor>()},
-      m_contentHandler{std::make_shared<BlobWebSocketModuleContentHandler>(m_blobPersistor)},
-      m_requestBodyHandler{std::make_shared<BlobModuleRequestBodyHandler>(m_blobPersistor)},
-      m_responseHandler{std::make_shared<BlobModuleResponseHandler>(m_blobPersistor)},
-      m_inspectableProperties{inspectableProperties} {
-  auto propBag = ReactPropertyBag{m_inspectableProperties.try_as<IReactPropertyBag>()};
-
-  auto contentHandlerPropId =
-      ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleContentHandler>>>{L"BlobModule.ContentHandler"};
-  auto contentHandler = weak_ptr<IWebSocketModuleContentHandler>{m_contentHandler};
-  propBag.Set(contentHandlerPropId, std::move(contentHandler));
-
-  auto blobPersistorPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
-  auto blobPersistor = weak_ptr<IBlobPersistor>{m_blobPersistor};
-  propBag.Set(blobPersistorPropId, std::move(blobPersistor));
-
-  m_sharedState->Module = this;
+void BlobTurboModule::Initialize(msrn::ReactContext const &reactContext) noexcept {
+  m_resource = IBlobResource::Make(reactContext.Properties().Handle());
+  m_resource->Callbacks().OnError = [&reactContext](string &&errorText) {
+    Modules::SendEvent(reactContext, L"blobFailed", {errorText});
+  };
+}
+
+ReactNativeSpecs::BlobModuleSpec_Constants BlobTurboModule::GetConstants() noexcept {
+  ReactNativeSpecs::BlobModuleSpec_Constants result;
+  result.BLOB_URI_SCHEME = blobKeys.Blob;
+  result.BLOB_URI_HOST = {};
+
+  return result;
+}
+
+void BlobTurboModule::AddNetworkingHandler() noexcept {
+  m_resource->AddNetworkingHandler();
 }
 
-BlobModule::~BlobModule() noexcept /*override*/ {
-  m_sharedState->Module = nullptr;
+void BlobTurboModule::AddWebSocketHandler(double id) noexcept {
+  m_resource->AddWebSocketHandler(static_cast<int64_t>(id));
 }
 
+void BlobTurboModule::RemoveWebSocketHandler(double id) noexcept {
+  m_resource->RemoveWebSocketHandler(static_cast<int64_t>(id));
+}
+
+void BlobTurboModule::SendOverSocket(msrn::JSValue &&blob, double socketID) noexcept {
+  m_resource->SendOverSocket(
+      blob[blobKeys.BlobId].AsString(),
+      blob[blobKeys.Offset].AsInt64(),
+      blob[blobKeys.Size].AsInt64(),
+      static_cast<int64_t>(socketID));
+}
+
+void BlobTurboModule::CreateFromParts(vector<msrn::JSValue> &&parts, string &&withId) noexcept {
+  m_resource->CreateFromParts(std::move(parts), std::move(withId));
+}
+
+void BlobTurboModule::Release(string &&blobId) noexcept {
+  m_resource->Release(std::move(blobId));
+}
+
+#pragma endregion BlobTurboModule
+
+#pragma region BlobModule
+
+BlobModule::BlobModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept
+    : m_resource{IBlobResource::Make(inspectableProperties)} {}
+
 #pragma region CxxModule
 
 string BlobModule::getName() {
-  return moduleName;
+  return s_moduleName;
 }
 
 std::map<string, dynamic> BlobModule::getConstants() {
-  return {{"BLOB_URI_SCHEME", blobKey}, {"BLOB_URI_HOST", {}}};
+  return {{"BLOB_URI_SCHEME", blobKeys.Blob}, {"BLOB_URI_HOST", {}}};
 }
 
 vector<module::CxxModule::Method> BlobModule::getMethods() {
+  // See CxxNativeModule::lazyInit()
+  m_resource->Callbacks().OnError = [weakInstance = getInstance()](string &&errorText) {
+    Modules::SendEvent(weakInstance, "blobFailed", std::move(errorText));
+  };
+
   return {
-      {"addNetworkingHandler",
-       [propBag = ReactPropertyBag{m_inspectableProperties.try_as<IReactPropertyBag>()},
-        requestBodyHandler = m_requestBodyHandler,
-        responseHandler = m_responseHandler](dynamic args) {
-         auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IHttpModuleProxy>>>{L"HttpModule.Proxy"};
-
-         if (auto prop = propBag.Get(propId)) {
-           if (auto httpHandler = prop.Value().lock()) {
-             httpHandler->AddRequestBodyHandler(requestBodyHandler);
-             httpHandler->AddResponseHandler(responseHandler);
-           }
-         }
-         // TODO: else emit error?
-       }},
+      {"addNetworkingHandler", [resource = m_resource](dynamic /*args*/) { resource->AddNetworkingHandler(); }},
 
       {"addWebSocketHandler",
-       [contentHandler = m_contentHandler](dynamic args) {
+       [resource = m_resource](dynamic args) {
          auto id = jsArgAsInt(args, 0);
 
-         contentHandler->Register(id);
+         resource->AddWebSocketHandler(id);
        }},
 
       {"removeWebSocketHandler",
-       [contentHandler = m_contentHandler](dynamic args) {
+       [resource = m_resource](dynamic args) {
          auto id = jsArgAsInt(args, 0);
 
-         contentHandler->Unregister(id);
+         resource->RemoveWebSocketHandler(id);
        }},
 
       {"sendOverSocket",
-       [weakState = weak_ptr<SharedState>(m_sharedState),
-        persistor = m_blobPersistor,
-        propBag = ReactPropertyBag{m_inspectableProperties.try_as<IReactPropertyBag>()}](dynamic args) {
-         auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{L"WebSocketModule.Proxy"};
-         shared_ptr<IWebSocketModuleProxy> wsProxy;
-         if (auto prop = propBag.Get(propId)) {
-           wsProxy = prop.Value().lock();
-         }
-         if (!wsProxy) {
-           return;
-         }
-
+       [resource = m_resource](dynamic args) {
          auto blob = jsArgAsObject(args, 0);
-         auto blobId = blob[blobIdKey].getString();
-         auto offset = blob[offsetKey].getInt();
-         auto size = blob[sizeKey].getInt();
-         auto socketID = jsArgAsInt(args, 1);
-
-         winrt::array_view<uint8_t const> data;
-         try {
-           data = persistor->ResolveMessage(std::move(blobId), offset, size);
-         } catch (const std::exception &e) {
-           if (auto sharedState = weakState.lock()) {
-             Modules::SendEvent(sharedState->Module->getInstance(), "blobFailed", e.what());
-           }
-           return;
-         }
-
-         auto buffer = CryptographicBuffer::CreateFromByteArray(data);
-         auto winrtString = CryptographicBuffer::EncodeToBase64String(std::move(buffer));
-         auto base64String = Common::Unicode::Utf16ToUtf8(std::move(winrtString));
-
-         wsProxy->SendBinary(std::move(base64String), socketID);
+         auto blobId = blob[blobKeys.BlobId].getString();
+         auto offset = blob[blobKeys.Offset].getInt();
+         auto size = blob[blobKeys.Size].getInt();
+         auto socketId = jsArgAsInt(args, 1);
+
+         resource->SendOverSocket(std::move(blobId), offset, size, socketId);
        }},
 
       {"createFromParts",
-       // As of React Native 0.67, instance is set AFTER CxxModule::getMethods() is invoked.
-       // Use getInstance() directly once
-       // https://github.com/facebook/react-native/commit/1d45b20b6c6ba66df0485cdb9be36463d96cf182 becomes available.
-       [persistor = m_blobPersistor, weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) {
-         auto parts = jsArgAsArray(args, 0); // Array<Object>
+       [resource = m_resource](dynamic args) {
+         auto dynamicParts = jsArgAsArray(args, 0); // Array<Object>
+         auto parts = Modules::ToJSValue(dynamicParts);
          auto blobId = jsArgAsString(args, 1);
-         vector<uint8_t> buffer{};
-
-         for (const auto &part : parts) {
-           auto type = part[typeKey].asString();
-           if (blobKey == type) {
-             auto blob = part[dataKey];
-             winrt::array_view<uint8_t const> bufferPart;
-             try {
-               bufferPart = persistor->ResolveMessage(
-                   blob[blobIdKey].asString(), blob[offsetKey].asInt(), blob[sizeKey].asInt());
-             } catch (const std::exception &e) {
-               if (auto sharedState = weakState.lock()) {
-                 Modules::SendEvent(sharedState->Module->getInstance(), "blobFailed", e.what());
-               }
-               return;
-             }
-
-             buffer.reserve(buffer.size() + bufferPart.size());
-             buffer.insert(buffer.end(), bufferPart.begin(), bufferPart.end());
-           } else if ("string" == type) {
-             auto data = part[dataKey].asString();
-
-             buffer.reserve(buffer.size() + data.size());
-             buffer.insert(buffer.end(), data.begin(), data.end());
-           } else {
-             if (auto state = weakState.lock()) {
-               auto message = "Invalid type for blob: " + type;
-               Modules::SendEvent(state->Module->getInstance(), "blobFailed", std::move(message));
-             }
-             return;
-           }
-         }
-
-         persistor->StoreMessage(std::move(buffer), std::move(blobId));
+
+         resource->CreateFromParts(parts.MoveArray(), std::move(blobId));
        }},
 
       {"release",
-       [persistor = m_blobPersistor](dynamic args) // blobId: string
+       [resource = m_resource](dynamic args) // blobId: string
        {
          auto blobId = jsArgAsString(args, 0);
 
-         persistor->RemoveMessage(std::move(blobId));
+         resource->Release(std::move(blobId));
        }}};
 }
 
@@ -215,173 +144,13 @@ vector<module::CxxModule::Method> BlobModule::getMethods() {
 
 #pragma endregion BlobModule
 
-#pragma region MemoryBlobPersistor
-
-#pragma region IBlobPersistor
-
-winrt::array_view<uint8_t const> MemoryBlobPersistor::ResolveMessage(string &&blobId, int64_t offset, int64_t size) {
-  if (size < 1)
-    return {};
-
-  scoped_lock lock{m_mutex};
-
-  auto dataItr = m_blobs.find(std::move(blobId));
-  // Not found.
-  if (dataItr == m_blobs.cend())
-    throw std::invalid_argument("Blob object not found");
-
-  auto &bytes = (*dataItr).second;
-  auto endBound = static_cast<size_t>(offset + size);
-  // Out of bounds.
-  if (endBound > bytes.size() || offset >= static_cast<int64_t>(bytes.size()) || offset < 0)
-    throw std::out_of_range("Offset or size out of range");
-
-  return winrt::array_view<uint8_t const>(bytes.data() + offset, bytes.data() + endBound);
-}
-
-void MemoryBlobPersistor::RemoveMessage(string &&blobId) noexcept {
-  scoped_lock lock{m_mutex};
-
-  m_blobs.erase(std::move(blobId));
-}
-
-void MemoryBlobPersistor::StoreMessage(vector<uint8_t> &&message, string &&blobId) noexcept {
-  scoped_lock lock{m_mutex};
-
-  m_blobs.insert_or_assign(std::move(blobId), std::move(message));
-}
-
-string MemoryBlobPersistor::StoreMessage(vector<uint8_t> &&message) noexcept {
-  auto blobId = boost::uuids::to_string(m_guidGenerator());
-
-  scoped_lock lock{m_mutex};
-  m_blobs.insert_or_assign(blobId, std::move(message));
-
-  return blobId;
-}
-
-#pragma endregion IBlobPersistor
-
-#pragma endregion MemoryBlobPersistor
-
-#pragma region BlobWebSocketModuleContentHandler
-
-BlobWebSocketModuleContentHandler::BlobWebSocketModuleContentHandler(shared_ptr<IBlobPersistor> blobPersistor) noexcept
-    : m_blobPersistor{blobPersistor} {}
-
-#pragma region IWebSocketModuleContentHandler
-
-void BlobWebSocketModuleContentHandler::ProcessMessage(string &&message, dynamic &params) /*override*/ {
-  params[dataKey] = std::move(message);
-}
-
-void BlobWebSocketModuleContentHandler::ProcessMessage(vector<uint8_t> &&message, dynamic &params) /*override*/ {
-  auto blob = dynamic::object();
-  blob(offsetKey, 0);
-  blob(sizeKey, message.size());
-  blob(blobIdKey, m_blobPersistor->StoreMessage(std::move(message)));
-
-  params[dataKey] = std::move(blob);
-  params[typeKey] = blobKey;
-}
-
-void BlobWebSocketModuleContentHandler::ProcessMessage(
-    string &&message,
-    msrn::JSValueObject &params) noexcept /*override*/
-{
-  params[dataKey] = std::move(message);
-}
-
-void BlobWebSocketModuleContentHandler::ProcessMessage(
-    vector<uint8_t> &&message,
-    msrn::JSValueObject &params) noexcept /*override*/
-{
-  auto blob = msrn::JSValueObject{
-      {offsetKey, 0}, {sizeKey, message.size()}, {blobIdKey, m_blobPersistor->StoreMessage(std::move(message))}};
-
-  params[dataKey] = std::move(blob);
-  params[typeKey] = blobKey;
-}
-
-#pragma endregion IWebSocketModuleContentHandler
-
-void BlobWebSocketModuleContentHandler::Register(int64_t socketID) noexcept {
-  scoped_lock lock{m_mutex};
-  m_socketIds.insert(socketID);
-}
-
-void BlobWebSocketModuleContentHandler::Unregister(int64_t socketID) noexcept {
-  scoped_lock lock{m_mutex};
-
-  auto itr = m_socketIds.find(socketID);
-  if (itr != m_socketIds.end())
-    m_socketIds.erase(itr);
-}
-
-#pragma endregion BlobWebSocketModuleContentHandler
-
-#pragma region BlobModuleRequestBodyHandler
-
-BlobModuleRequestBodyHandler::BlobModuleRequestBodyHandler(shared_ptr<IBlobPersistor> blobPersistor) noexcept
-    : m_blobPersistor{blobPersistor} {}
-
-#pragma region IRequestBodyHandler
-
-bool BlobModuleRequestBodyHandler::Supports(msrn::JSValueObject &data) /*override*/ {
-  auto itr = data.find(blobKey);
-
-  return itr != data.cend() && !(*itr).second.AsString().empty();
-}
-
-msrn::JSValueObject BlobModuleRequestBodyHandler::ToRequestBody(
-    msrn::JSValueObject &data,
-    string &contentType) /*override*/ {
-  auto type = contentType;
-  auto itr = data.find(typeKey);
-  if (itr != data.cend() && !(*itr).second.AsString().empty()) {
-    type = (*itr).second.AsString();
-  }
-  if (type.empty()) {
-    type = "application/octet-stream";
-  }
-
-  auto &blob = data[blobKey].AsObject();
-  auto blobId = blob[blobIdKey].AsString();
-  auto bytes = m_blobPersistor->ResolveMessage(std::move(blobId), blob[offsetKey].AsInt64(), blob[sizeKey].AsInt64());
-
-  return {{typeKey, type}, {sizeKey, bytes.size()}, {"bytes", msrn::JSValueArray(bytes.cbegin(), bytes.cend())}};
-}
-
-#pragma endregion IRequestBodyHandler
-
-#pragma endregion BlobModuleRequestBodyHandler
-
-#pragma region BlobModuleResponseHandler
-
-BlobModuleResponseHandler::BlobModuleResponseHandler(shared_ptr<IBlobPersistor> blobPersistor) noexcept
-    : m_blobPersistor{blobPersistor} {}
-
-#pragma region IResponseHandler
-
-bool BlobModuleResponseHandler::Supports(string &responseType) /*override*/ {
-  return blobKey == responseType;
-}
-
-msrn::JSValueObject BlobModuleResponseHandler::ToResponseData(vector<uint8_t> &&content) /*override*/ {
-  return {{offsetKey, 0}, {sizeKey, content.size()}, {blobIdKey, m_blobPersistor->StoreMessage(std::move(content))}};
-}
-
-#pragma endregion IResponseHandler
-
-#pragma endregion BlobModuleResponseHandler
-
 /*extern*/ const char *GetBlobModuleName() noexcept {
-  return moduleName;
+  return s_moduleName;
 }
 
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateBlobModule(
     IInspectable const &inspectableProperties) noexcept {
-  if (auto properties = inspectableProperties.try_as<IReactPropertyBag>())
+  if (auto properties = inspectableProperties.try_as<msrn::IReactPropertyBag>())
     return std::make_unique<BlobModule>(properties);
 
   return nullptr;

package/Shared/Modules/BlobModule.h

@@ -3,114 +3,56 @@
 
 #pragma once
 
-#include <Modules/IBlobPersistor.h>
-#include <Modules/IRequestBodyHandler.h>
-#include <Modules/IResponseHandler.h>
-#include <Modules/IWebSocketModuleContentHandler.h>
+#include <NativeBlobModuleSpec.g.h>
+
+#include <Networking/IBlobResource.h>
 
 // React Native
 #include <cxxreact/CxxModule.h>
 
-// Boost Libraries
-#include <boost/uuid/uuid_generators.hpp>
-
 // Windows API
 #include <winrt/base.h>
 
 // Standard Library
-#include <mutex>
 #include <string>
-#include <unordered_map>
-#include <unordered_set>
 #include <vector>
 
 namespace Microsoft::React {
 
-class MemoryBlobPersistor final : public IBlobPersistor {
-  std::unordered_map<std::string, std::vector<uint8_t>> m_blobs;
-  std::mutex m_mutex;
-  boost::uuids::random_generator m_guidGenerator;
-
- public:
-#pragma region IBlobPersistor
-
-  winrt::array_view<uint8_t const> ResolveMessage(std::string &&blobId, int64_t offset, int64_t size) override;
+REACT_MODULE(BlobTurboModule, L"BlobModule")
+struct BlobTurboModule {
+  using ModuleSpec = ReactNativeSpecs::BlobModuleSpec;
 
-  void RemoveMessage(std::string &&blobId) noexcept override;
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
-  void StoreMessage(std::vector<uint8_t> &&message, std::string &&blobId) noexcept override;
+  REACT_GET_CONSTANTS(GetConstants)
+  ReactNativeSpecs::BlobModuleSpec_Constants GetConstants() noexcept;
 
-  std::string StoreMessage(std::vector<uint8_t> &&message) noexcept override;
-
-#pragma endregion IBlobPersistor
-};
-
-class BlobWebSocketModuleContentHandler final : public IWebSocketModuleContentHandler {
-  std::unordered_set<int64_t> m_socketIds;
-  std::mutex m_mutex;
-  std::shared_ptr<IBlobPersistor> m_blobPersistor;
-
- public:
-  BlobWebSocketModuleContentHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+  REACT_METHOD(AddNetworkingHandler, L"addNetworkingHandler")
+  void AddNetworkingHandler() noexcept;
 
-#pragma region IWebSocketModuleContentHandler
+  REACT_METHOD(AddWebSocketHandler, L"addWebSocketHandler")
+  void AddWebSocketHandler(double id) noexcept;
 
-  void ProcessMessage(std::string &&message, folly::dynamic &params) override;
+  REACT_METHOD(RemoveWebSocketHandler, L"removeWebSocketHandler")
+  void RemoveWebSocketHandler(double id) noexcept;
 
-  void ProcessMessage(std::vector<uint8_t> &&message, folly::dynamic &params) override;
-
-  void ProcessMessage(std::string &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept override;
-
-  void ProcessMessage(std::vector<uint8_t> &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept
-      override;
-
-#pragma endregion IWebSocketModuleContentHandler
-
-  void Register(int64_t socketID) noexcept;
-
-  void Unregister(int64_t socketID) noexcept;
-};
-
-class BlobModuleRequestBodyHandler final : public IRequestBodyHandler {
-  std::shared_ptr<IBlobPersistor> m_blobPersistor;
-
- public:
-  BlobModuleRequestBodyHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+  REACT_METHOD(SendOverSocket, L"sendOverSocket")
+  void SendOverSocket(winrt::Microsoft::ReactNative::JSValue &&blob, double socketID) noexcept;
 
-#pragma region IRequestBodyHandler
+  REACT_METHOD(CreateFromParts, L"createFromParts")
+  void CreateFromParts(std::vector<winrt::Microsoft::ReactNative::JSValue> &&parts, std::string &&withId) noexcept;
 
-  bool Supports(winrt::Microsoft::ReactNative::JSValueObject &data) override;
+  REACT_METHOD(Release, L"release")
+  void Release(std::string &&blobId) noexcept;
 
-  winrt::Microsoft::ReactNative::JSValueObject ToRequestBody(
-      winrt::Microsoft::ReactNative::JSValueObject &data,
-      std::string &contentType) override;
-
-#pragma endregion IRequestBodyHandler
-};
-
-class BlobModuleResponseHandler final : public IResponseHandler {
-  std::shared_ptr<IBlobPersistor> m_blobPersistor;
-
- public:
-  BlobModuleResponseHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
-
-#pragma region IResponseHandler
-
-  bool Supports(std::string &responseType) override;
-
-  winrt::Microsoft::ReactNative::JSValueObject ToResponseData(std::vector<uint8_t> &&content) override;
-
-#pragma endregion IResponseHandler
+ private:
+  std::shared_ptr<Networking::IBlobResource> m_resource;
 };
 
 class BlobModule : public facebook::xplat::module::CxxModule {
-  std::shared_ptr<MemoryBlobPersistor> m_blobPersistor;
-  std::shared_ptr<BlobWebSocketModuleContentHandler> m_contentHandler;
-  std::shared_ptr<BlobModuleRequestBodyHandler> m_requestBodyHandler;
-  std::shared_ptr<BlobModuleResponseHandler> m_responseHandler;
-
-  // Property bag high level reference.
-  winrt::Windows::Foundation::IInspectable m_inspectableProperties;
+  std::shared_ptr<Networking::IBlobResource> m_resource;
 
  public:
   enum class MethodId {
@@ -125,15 +67,6 @@ class BlobModule : public facebook::xplat::module::CxxModule {
 
   BlobModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept;
 
-  ~BlobModule() noexcept override;
-
-  struct SharedState {
-    /// <summary>
-    /// Keeps a raw reference to the module object to lazily retrieve the React Instance as needed.
-    /// </summary>
-    CxxModule *Module{nullptr};
-  };
-
 #pragma region CxxModule
 
   /// <summary>
@@ -153,12 +86,6 @@ class BlobModule : public facebook::xplat::module::CxxModule {
   std::vector<Method> getMethods() override;
 
 #pragma endregion CxxModule
-
- private:
-  /// <summary>
-  /// Keeps members that can be accessed threads other than this module's owner accessible.
-  /// </summary>
-  std::shared_ptr<SharedState> m_sharedState;
 };
 
 } // namespace Microsoft::React

package/Shared/Modules/IWebSocketModuleContentHandler.h

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

package/Shared/Modules/WebSocketModule.cpp

@@ -112,7 +112,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"};
@@ -134,7 +134,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();

package/Shared/Networking/DefaultBlobResource.cpp

@@ -0,0 +1,323 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "DefaultBlobResource.h"
+
+#include <Modules/IHttpModuleProxy.h>
+#include <Modules/IWebSocketModuleProxy.h>
+
+// Boost Libraries
+#include <boost/uuid/uuid_io.hpp>
+
+// Windows API
+#include <winrt/Windows.Security.Cryptography.h>
+
+using std::scoped_lock;
+using std::shared_ptr;
+using std::string;
+using std::vector;
+using std::weak_ptr;
+using winrt::array_view;
+using winrt::Windows::Security::Cryptography::CryptographicBuffer;
+
+namespace msrn = winrt::Microsoft::ReactNative;
+
+namespace {
+
+constexpr Microsoft::React::Networking::IBlobResource::BlobFieldNames
+    blobKeys{"blob", "blobId", "offset", "size", "type", "data"};
+
+} // namespace
+
+namespace Microsoft::React::Networking {
+
+#pragma region DefaultBlobResource
+
+DefaultBlobResource::DefaultBlobResource(
+    shared_ptr<MemoryBlobPersistor> blobPersistor,
+    shared_ptr<BlobWebSocketModuleContentHandler> contentHandler,
+    shared_ptr<BlobModuleRequestBodyHandler> requestBodyHandler,
+    shared_ptr<BlobModuleResponseHandler> responseHandler,
+    msrn::ReactPropertyBag propertyBag)
+    : m_blobPersistor{blobPersistor},
+      m_contentHandler{contentHandler},
+      m_requestBodyHandler{requestBodyHandler},
+      m_responseHandler{responseHandler},
+      m_propertyBag{propertyBag} {}
+
+#pragma region IBlobResource
+
+/*static*/ const IBlobResource::BlobFieldNames &IBlobResource::FieldNames() noexcept {
+  return blobKeys;
+}
+
+/*static*/ shared_ptr<IBlobResource> IBlobResource::Make(
+    winrt::Windows::Foundation::IInspectable const &inspectableProperties) {
+  using namespace msrn;
+
+  auto propBag = ReactPropertyBag{inspectableProperties.try_as<IReactPropertyBag>()};
+
+  auto blobPersistor = std::make_shared<MemoryBlobPersistor>();
+  auto contentHandler = std::make_shared<BlobWebSocketModuleContentHandler>(blobPersistor);
+  auto requestBodyHanlder = std::make_shared<BlobModuleRequestBodyHandler>(blobPersistor);
+  auto responseHandler = std::make_shared<BlobModuleResponseHandler>(blobPersistor);
+
+  auto contentHandlerPropId =
+      ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleContentHandler>>>{L"BlobModule.ContentHandler"};
+  propBag.Set(contentHandlerPropId, weak_ptr<IWebSocketModuleContentHandler>{contentHandler});
+
+  auto blobPersistorPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
+  ;
+  propBag.Set(blobPersistorPropId, weak_ptr<IBlobPersistor>{blobPersistor});
+
+  auto result = std::make_shared<DefaultBlobResource>(
+      blobPersistor, contentHandler, requestBodyHanlder, responseHandler, propBag);
+
+  return result;
+}
+
+void DefaultBlobResource::SendOverSocket(string &&blobId, int64_t offset, int64_t size, int64_t socketId) noexcept
+/*override*/ {
+  auto propId =
+      msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{L"WebSocketModule.Proxy"};
+  shared_ptr<IWebSocketModuleProxy> wsProxy;
+  if (auto prop = m_propertyBag.Get(propId)) {
+    wsProxy = prop.Value().lock();
+  }
+  if (!wsProxy) {
+    return;
+  }
+
+  array_view<uint8_t const> data;
+  try {
+    data = m_blobPersistor->ResolveMessage(std::move(blobId), offset, size);
+  } catch (const std::exception &e) {
+    return m_callbacks.OnError(e.what());
+  }
+
+  auto buffer = CryptographicBuffer::CreateFromByteArray(data);
+  auto base64Hstring = CryptographicBuffer::EncodeToBase64String(std::move(buffer));
+  auto base64String = winrt::to_string(base64Hstring);
+
+  wsProxy->SendBinary(std::move(base64String), socketId);
+}
+
+void DefaultBlobResource::CreateFromParts(msrn::JSValueArray &&parts, string &&blobId) noexcept /*override*/ {
+  vector<uint8_t> buffer{};
+
+  for (const auto &partItem : parts) {
+    auto &part = partItem.AsObject();
+    auto type = part.at(blobKeys.Type).AsString();
+    if (blobKeys.Blob == type) {
+      auto &blob = part.at(blobKeys.Data).AsObject();
+      array_view<uint8_t const> bufferPart;
+      try {
+        bufferPart = m_blobPersistor->ResolveMessage(
+            blob.at(blobKeys.BlobId).AsString(), blob.at(blobKeys.Offset).AsInt64(), blob.at(blobKeys.Size).AsInt64());
+      } catch (const std::exception &e) {
+        return m_callbacks.OnError(e.what());
+      }
+
+      buffer.reserve(buffer.size() + bufferPart.size());
+      buffer.insert(buffer.end(), bufferPart.begin(), bufferPart.end());
+    } else if ("string" == type) {
+      auto data = part.at(blobKeys.Data).AsString();
+
+      buffer.reserve(buffer.size() + data.size());
+      buffer.insert(buffer.end(), data.begin(), data.end());
+    } else {
+      return m_callbacks.OnError("Invalid type for blob: " + type);
+    }
+  }
+
+  m_blobPersistor->StoreMessage(std::move(buffer), std::move(blobId));
+}
+
+void DefaultBlobResource::Release(string &&blobId) noexcept /*override*/ {
+  m_blobPersistor->RemoveMessage(std::move(blobId));
+}
+
+void DefaultBlobResource::AddNetworkingHandler() noexcept /*override*/ {
+  auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IHttpModuleProxy>>>{L"HttpModule.Proxy"};
+
+  if (auto prop = m_propertyBag.Get(propId)) {
+    if (auto httpHandler = prop.Value().lock()) {
+      httpHandler->AddRequestBodyHandler(m_requestBodyHandler);
+      httpHandler->AddResponseHandler(m_responseHandler);
+    }
+  }
+  // TODO: else emit error?
+}
+
+void DefaultBlobResource::AddWebSocketHandler(int64_t id) noexcept /*override*/ {
+  m_contentHandler->Register(id);
+}
+
+void DefaultBlobResource::RemoveWebSocketHandler(int64_t id) noexcept /*override*/ {
+  m_contentHandler->Unregister(id);
+}
+
+IBlobResource::BlobCallbacks &DefaultBlobResource::Callbacks() noexcept /*override*/ {
+  return m_callbacks;
+}
+
+#pragma endregion IBlobResource
+
+#pragma endregion DefaultBlobResource
+
+#pragma region MemoryBlobPersistor
+
+#pragma region IBlobPersistor
+
+array_view<uint8_t const> MemoryBlobPersistor::ResolveMessage(string &&blobId, int64_t offset, int64_t size) {
+  if (size < 1)
+    return {};
+
+  scoped_lock lock{m_mutex};
+
+  auto dataItr = m_blobs.find(std::move(blobId));
+  // Not found.
+  if (dataItr == m_blobs.cend())
+    throw std::invalid_argument("Blob object not found");
+
+  auto &bytes = (*dataItr).second;
+  auto endBound = static_cast<size_t>(offset + size);
+  // Out of bounds.
+  if (endBound > bytes.size() || offset >= static_cast<int64_t>(bytes.size()) || offset < 0)
+    throw std::out_of_range("Offset or size out of range");
+
+  return array_view<uint8_t const>(bytes.data() + offset, bytes.data() + endBound);
+}
+
+void MemoryBlobPersistor::RemoveMessage(string &&blobId) noexcept {
+  scoped_lock lock{m_mutex};
+
+  m_blobs.erase(std::move(blobId));
+}
+
+void MemoryBlobPersistor::StoreMessage(vector<uint8_t> &&message, string &&blobId) noexcept {
+  scoped_lock lock{m_mutex};
+
+  m_blobs.insert_or_assign(std::move(blobId), std::move(message));
+}
+
+string MemoryBlobPersistor::StoreMessage(vector<uint8_t> &&message) noexcept {
+  auto blobId = boost::uuids::to_string(m_guidGenerator());
+
+  scoped_lock lock{m_mutex};
+  m_blobs.insert_or_assign(blobId, std::move(message));
+
+  return blobId;
+}
+
+#pragma endregion IBlobPersistor
+
+#pragma endregion MemoryBlobPersistor
+
+#pragma region BlobWebSocketModuleContentHandler
+
+BlobWebSocketModuleContentHandler::BlobWebSocketModuleContentHandler(shared_ptr<IBlobPersistor> blobPersistor) noexcept
+    : m_blobPersistor{blobPersistor} {}
+
+#pragma region IWebSocketModuleContentHandler
+
+void BlobWebSocketModuleContentHandler::ProcessMessage(
+    string &&message,
+    msrn::JSValueObject &params) noexcept /*override*/
+{
+  params[blobKeys.Data] = std::move(message);
+}
+
+void BlobWebSocketModuleContentHandler::ProcessMessage(
+    vector<uint8_t> &&message,
+    msrn::JSValueObject &params) noexcept /*override*/
+{
+  auto blob = msrn::JSValueObject{
+      {blobKeys.Offset, 0},
+      {blobKeys.Size, message.size()},
+      {blobKeys.BlobId, m_blobPersistor->StoreMessage(std::move(message))}};
+
+  params[blobKeys.Data] = std::move(blob);
+  params[blobKeys.Type] = blobKeys.Blob;
+}
+
+#pragma endregion IWebSocketModuleContentHandler
+
+void BlobWebSocketModuleContentHandler::Register(int64_t socketID) noexcept {
+  scoped_lock lock{m_mutex};
+  m_socketIds.insert(socketID);
+}
+
+void BlobWebSocketModuleContentHandler::Unregister(int64_t socketID) noexcept {
+  scoped_lock lock{m_mutex};
+
+  auto itr = m_socketIds.find(socketID);
+  if (itr != m_socketIds.end())
+    m_socketIds.erase(itr);
+}
+
+#pragma endregion BlobWebSocketModuleContentHandler
+
+#pragma region BlobModuleRequestBodyHandler
+
+BlobModuleRequestBodyHandler::BlobModuleRequestBodyHandler(shared_ptr<IBlobPersistor> blobPersistor) noexcept
+    : m_blobPersistor{blobPersistor} {}
+
+#pragma region IRequestBodyHandler
+
+bool BlobModuleRequestBodyHandler::Supports(msrn::JSValueObject &data) /*override*/ {
+  auto itr = data.find(blobKeys.Blob);
+
+  return itr != data.cend() && !(*itr).second.AsString().empty();
+}
+
+msrn::JSValueObject BlobModuleRequestBodyHandler::ToRequestBody(
+    msrn::JSValueObject &data,
+    string &contentType) /*override*/ {
+  auto type = contentType;
+  auto itr = data.find(blobKeys.Type);
+  if (itr != data.cend() && !(*itr).second.AsString().empty()) {
+    type = (*itr).second.AsString();
+  }
+  if (type.empty()) {
+    type = "application/octet-stream";
+  }
+
+  auto &blob = data[blobKeys.Blob].AsObject();
+  auto blobId = blob[blobKeys.BlobId].AsString();
+  auto bytes = m_blobPersistor->ResolveMessage(
+      std::move(blobId), blob[blobKeys.Offset].AsInt64(), blob[blobKeys.Size].AsInt64());
+
+  return {
+      {blobKeys.Type, type},
+      {blobKeys.Size, bytes.size()},
+      {"bytes", msrn::JSValueArray(bytes.cbegin(), bytes.cend())}};
+}
+
+#pragma endregion IRequestBodyHandler
+
+#pragma endregion BlobModuleRequestBodyHandler
+
+#pragma region BlobModuleResponseHandler
+
+BlobModuleResponseHandler::BlobModuleResponseHandler(shared_ptr<IBlobPersistor> blobPersistor) noexcept
+    : m_blobPersistor{blobPersistor} {}
+
+#pragma region IResponseHandler
+
+bool BlobModuleResponseHandler::Supports(string &responseType) /*override*/ {
+  return blobKeys.Blob == responseType;
+}
+
+msrn::JSValueObject BlobModuleResponseHandler::ToResponseData(vector<uint8_t> &&content) /*override*/ {
+  return {
+      {blobKeys.Offset, 0},
+      {blobKeys.Size, content.size()},
+      {blobKeys.BlobId, m_blobPersistor->StoreMessage(std::move(content))}};
+}
+
+#pragma endregion IResponseHandler
+
+#pragma endregion BlobModuleResponseHandler
+
+} // namespace Microsoft::React::Networking

package/Shared/Networking/DefaultBlobResource.h

@@ -0,0 +1,133 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IBlobResource.h"
+
+#include <IBlobPersistor.h>
+#include <Modules/IRequestBodyHandler.h>
+#include <Modules/IResponseHandler.h>
+#include <Modules/IWebSocketModuleContentHandler.h>
+
+// React Native Windows
+#include <ReactPropertyBag.h>
+
+// Boost Libraries
+#include <boost/uuid/uuid_generators.hpp>
+
+// Standard Library
+#include <mutex>
+#include <unordered_set>
+
+namespace Microsoft::React::Networking {
+
+class MemoryBlobPersistor final : public IBlobPersistor {
+  std::unordered_map<std::string, std::vector<uint8_t>> m_blobs;
+  std::mutex m_mutex;
+  boost::uuids::random_generator m_guidGenerator;
+
+ public:
+#pragma region IBlobPersistor
+
+  winrt::array_view<uint8_t const> ResolveMessage(std::string &&blobId, int64_t offset, int64_t size) override;
+
+  void RemoveMessage(std::string &&blobId) noexcept override;
+
+  void StoreMessage(std::vector<uint8_t> &&message, std::string &&blobId) noexcept override;
+
+  std::string StoreMessage(std::vector<uint8_t> &&message) noexcept override;
+
+#pragma endregion IBlobPersistor
+};
+
+class BlobWebSocketModuleContentHandler final : public IWebSocketModuleContentHandler {
+  std::unordered_set<int64_t> m_socketIds;
+  std::mutex m_mutex;
+  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+
+ public:
+  BlobWebSocketModuleContentHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+
+#pragma region IWebSocketModuleContentHandler
+
+  void ProcessMessage(std::string &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept override;
+
+  void ProcessMessage(std::vector<uint8_t> &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept
+      override;
+
+#pragma endregion IWebSocketModuleContentHandler
+
+  void Register(int64_t socketID) noexcept;
+
+  void Unregister(int64_t socketID) noexcept;
+};
+
+class BlobModuleRequestBodyHandler final : public IRequestBodyHandler {
+  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+
+ public:
+  BlobModuleRequestBodyHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+
+#pragma region IRequestBodyHandler
+
+  bool Supports(winrt::Microsoft::ReactNative::JSValueObject &data) override;
+
+  winrt::Microsoft::ReactNative::JSValueObject ToRequestBody(
+      winrt::Microsoft::ReactNative::JSValueObject &data,
+      std::string &contentType) override;
+
+#pragma endregion IRequestBodyHandler
+};
+
+class BlobModuleResponseHandler final : public IResponseHandler {
+  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+
+ public:
+  BlobModuleResponseHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+
+#pragma region IResponseHandler
+
+  bool Supports(std::string &responseType) override;
+
+  winrt::Microsoft::ReactNative::JSValueObject ToResponseData(std::vector<uint8_t> &&content) override;
+
+#pragma endregion IResponseHandler
+};
+
+class DefaultBlobResource : public IBlobResource, public std::enable_shared_from_this<DefaultBlobResource> {
+  std::shared_ptr<MemoryBlobPersistor> m_blobPersistor;
+  std::shared_ptr<BlobWebSocketModuleContentHandler> m_contentHandler;
+  std::shared_ptr<BlobModuleRequestBodyHandler> m_requestBodyHandler;
+  std::shared_ptr<BlobModuleResponseHandler> m_responseHandler;
+  winrt::Microsoft::ReactNative::ReactPropertyBag m_propertyBag;
+  BlobCallbacks m_callbacks;
+
+ public:
+  DefaultBlobResource(
+      std::shared_ptr<MemoryBlobPersistor> blobPersistor,
+      std::shared_ptr<BlobWebSocketModuleContentHandler> contentHandler,
+      std::shared_ptr<BlobModuleRequestBodyHandler> requestBodyHandler,
+      std::shared_ptr<BlobModuleResponseHandler> responseHandler,
+      winrt::Microsoft::ReactNative::ReactPropertyBag propertyBag);
+
+#pragma region IBlobResource
+
+  void SendOverSocket(std::string &&blobId, int64_t offset, int64_t size, int64_t socketId) noexcept override;
+
+  void CreateFromParts(winrt::Microsoft::ReactNative::JSValueArray &&parts, std::string &&blobId) noexcept override;
+
+  void Release(std::string &&blobId) noexcept override;
+
+  void AddNetworkingHandler() noexcept override;
+
+  void AddWebSocketHandler(int64_t id) noexcept override;
+
+  void RemoveWebSocketHandler(int64_t id) noexcept override;
+
+  BlobCallbacks &Callbacks() noexcept override;
+
+#pragma endregion IBlobResource
+};
+
+} // namespace Microsoft::React::Networking

package/Shared/Networking/IBlobResource.h

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <IBlobPersistor.h>
+
+// React Native Windows
+#include <JSValue.h>
+
+// Windows API
+#include <winrt/Windows.Foundation.h>
+
+// Standard Library
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace Microsoft::React::Networking {
+
+struct IBlobResource {
+  struct BlobCallbacks {
+    std::function<void(std::string &&errorText)> OnError;
+  };
+
+  struct BlobFieldNames {
+    const char *Blob;
+    const char *BlobId;
+    const char *Offset;
+    const char *Size;
+    const char *Type;
+    const char *Data;
+  };
+
+  static std::shared_ptr<IBlobResource> Make(winrt::Windows::Foundation::IInspectable const &inspectableProperties);
+
+  static const BlobFieldNames &FieldNames() noexcept;
+
+  virtual ~IBlobResource() noexcept {}
+
+  virtual void SendOverSocket(std::string &&blobId, int64_t offset, int64_t size, int64_t socketId) noexcept = 0;
+
+  virtual void CreateFromParts(winrt::Microsoft::ReactNative::JSValueArray &&parts, std::string &&blobId) noexcept = 0;
+
+  virtual void Release(std::string &&blobId) noexcept = 0;
+
+  virtual void AddNetworkingHandler() noexcept = 0;
+
+  virtual void AddWebSocketHandler(int64_t id) noexcept = 0;
+
+  virtual void RemoveWebSocketHandler(int64_t id) noexcept = 0;
+
+  virtual BlobCallbacks &Callbacks() noexcept = 0;
+};
+
+} // namespace Microsoft::React::Networking

package/Shared/Shared.vcxitems

@@ -199,6 +199,7 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\SourceCodeModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\StatusBarManagerModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\WebSocketModule.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)Networking\DefaultBlobResource.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Networking\OriginPolicyHttpFilter.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Networking\RedirectHttpFilter.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Networking\WinRTHttpResource.cpp" />
@@ -307,6 +308,7 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)BaseFileReaderResource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)CppRuntimeOptions.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)HermesSamplingProfiler.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)IBlobPersistor.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)IFileReaderResource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\ByteArrayBuffer.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\ChakraApi.h" />
@@ -319,7 +321,6 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\BlobModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\CxxModuleUtilities.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\FileReaderModule.h" />
-    <ClInclude Include="$(MSBuildThisFileDirectory)Modules\IBlobPersistor.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\IHttpModuleProxy.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\IRequestBodyHandler.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\IResponseHandler.h" />
@@ -329,6 +330,8 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\HttpModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\WebSocketTurboModule.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Networking\DefaultBlobResource.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IBlobResource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IHttpResource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IRedirectEventSource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IWebSocketResource.h" />

package/Shared/Shared.vcxitems.filters

@@ -271,6 +271,9 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)JSI\V8RuntimeHolder.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)SafeLoadLibrary.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Hasher.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)Networking\DefaultBlobResource.cpp">
+      <Filter>Source Files\Networking</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Source Files">
@@ -597,9 +600,6 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\IResponseHandler.h">
       <Filter>Header Files\Modules</Filter>
     </ClInclude>
-    <ClInclude Include="$(MSBuildThisFileDirectory)Modules\IBlobPersistor.h">
-      <Filter>Header Files\Modules</Filter>
-    </ClInclude>
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\CxxModuleUtilities.h">
       <Filter>Header Files\Modules</Filter>
     </ClInclude>
@@ -738,6 +738,15 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\WebSocketTurboModule.h">
       <Filter>Header Files\Modules</Filter>
     </ClInclude>
+    <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IBlobResource.h">
+      <Filter>Header Files\Networking</Filter>
+    </ClInclude>
+    <ClInclude Include="$(MSBuildThisFileDirectory)Networking\DefaultBlobResource.h">
+      <Filter>Header Files\Networking</Filter>
+    </ClInclude>
+    <ClInclude Include="$(MSBuildThisFileDirectory)IBlobPersistor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="$(MSBuildThisFileDirectory)tracing\rnw.wprp">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.0.0-canary.672",
+  "version": "0.0.0-canary.673",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
     "@react-native-community/cli": "12.0.0-alpha.3",
     "@react-native-community/cli-platform-android": "12.0.0-alpha.3",
     "@react-native-community/cli-platform-ios": "12.0.0-alpha.3",
-    "@react-native-windows/cli": "0.0.0-canary.175",
+    "@react-native-windows/cli": "0.0.0-canary.176",
     "@react-native/assets": "1.0.0",
     "@react-native/assets-registry": "0.73.0-nightly-20230606-396cdac62",
     "@react-native/codegen": "0.73.0-nightly-20230615-2ae163a7e",
@@ -62,7 +62,7 @@
     "yargs": "^17.6.2"
   },
   "devDependencies": {
-    "@react-native-windows/codegen": "0.0.0-canary.62",
+    "@react-native-windows/codegen": "0.0.0-canary.63",
     "@rnw-scripts/babel-react-native-config": "0.0.0",
     "@rnw-scripts/eslint-config": "1.2.1",
     "@rnw-scripts/jest-out-of-tree-snapshot-resolver": "^1.1.4",