react-native-windows 0.72.0 → 0.72.2

package/Shared/Modules/BlobModule.cpp

@@ -3,208 +3,145 @@
 
 #include "BlobModule.h"
 
+#include <CreateModules.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>
 
-// 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::GuidHelper;
 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";
+constexpr wchar_t s_moduleNameW[] = L"BlobModule";
+
+const auto &blobKeys = IBlobResource::FieldNames();
+
+msrn::ReactModuleProvider s_moduleProvider = msrn::MakeTurboModuleProvider<Microsoft::React::BlobTurboModule>();
+
 } // 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();
+}
+
+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));
 }
 
-BlobModule::~BlobModule() noexcept /*override*/ {
-  m_sharedState->Module = nullptr;
+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));
        }}};
 }
 
@@ -212,165 +149,24 @@ 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 {
-  // substr(1, 36) strips curly braces from a GUID.
-  auto blobId = winrt::to_string(winrt::to_hstring(GuidHelper::CreateNewGuid())).substr(1, 36);
-
-  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;
-}
-#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(dynamic &data) /*override*/ {
-  auto itr = data.find(blobKey);
-
-  return itr != data.items().end() && !(*itr).second.empty();
-}
-
-dynamic BlobModuleRequestBodyHandler::ToRequestBody(dynamic &data, string &contentType) /*override*/ {
-  auto type = contentType;
-  if (!data[typeKey].isNull() && !data[typeKey].asString().empty()) {
-    type = data[typeKey].asString();
-  }
-  if (type.empty()) {
-    type = "application/octet-stream";
-  }
-
-  auto blob = data[blobKey];
-  auto blobId = blob[blobIdKey].asString();
-  auto bytes = m_blobPersistor->ResolveMessage(std::move(blobId), blob[offsetKey].asInt(), blob[sizeKey].asInt());
-
-  auto result = dynamic::object();
-  result(typeKey, type);
-  result(sizeKey, bytes.size());
-  result("bytes", dynamic(bytes.cbegin(), bytes.cend()));
-
-  return result;
-}
-
-#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;
-}
-
-dynamic BlobModuleResponseHandler::ToResponseData(vector<uint8_t> &&content) /*override*/ {
-  auto blob = dynamic::object();
-  blob(offsetKey, 0);
-  blob(sizeKey, content.size());
-  blob(blobIdKey, m_blobPersistor->StoreMessage(std::move(content)));
-
-  return blob;
-}
-
-#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;
 }
 
+/*extern*/ const wchar_t *GetBlobTurboModuleName() noexcept {
+  return s_moduleNameW;
+}
+
+/*extern*/ const msrn::ReactModuleProvider &GetBlobModuleProvider() noexcept {
+  return s_moduleProvider;
+}
+
 } // namespace Microsoft::React

package/Shared/Modules/BlobModule.h

@@ -3,10 +3,9 @@
 
 #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>
@@ -15,91 +14,45 @@
 #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;
-
- 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, folly::dynamic &params) override;
-
-  void ProcessMessage(std::vector<uint8_t> &&message, folly::dynamic &params) override;
-
-#pragma endregion IWebSocketModuleContentHandler
-
-  void Register(int64_t socketID) noexcept;
+REACT_MODULE(BlobTurboModule, L"BlobModule")
+struct BlobTurboModule {
+  using ModuleSpec = ReactNativeSpecs::BlobModuleSpec;
 
-  void Unregister(int64_t socketID) noexcept;
-};
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
-class BlobModuleRequestBodyHandler final : public IRequestBodyHandler {
-  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+  REACT_GET_CONSTANTS(GetConstants)
+  ReactNativeSpecs::BlobModuleSpec_Constants GetConstants() noexcept;
 
- public:
-  BlobModuleRequestBodyHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+  REACT_METHOD(AddNetworkingHandler, L"addNetworkingHandler")
+  void AddNetworkingHandler() noexcept;
 
-#pragma region IRequestBodyHandler
+  REACT_METHOD(AddWebSocketHandler, L"addWebSocketHandler")
+  void AddWebSocketHandler(double id) noexcept;
 
-  bool Supports(folly::dynamic &data) override;
+  REACT_METHOD(RemoveWebSocketHandler, L"removeWebSocketHandler")
+  void RemoveWebSocketHandler(double id) noexcept;
 
-  folly::dynamic ToRequestBody(folly::dynamic &data, std::string &contentType) override;
+  REACT_METHOD(SendOverSocket, L"sendOverSocket")
+  void SendOverSocket(winrt::Microsoft::ReactNative::JSValue &&blob, double socketID) noexcept;
 
-#pragma endregion IRequestBodyHandler
-};
+  REACT_METHOD(CreateFromParts, L"createFromParts")
+  void CreateFromParts(std::vector<winrt::Microsoft::ReactNative::JSValue> &&parts, std::string &&withId) noexcept;
 
-class BlobModuleResponseHandler final : public IResponseHandler {
-  std::shared_ptr<IBlobPersistor> m_blobPersistor;
-
- public:
-  BlobModuleResponseHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+  REACT_METHOD(Release, L"release")
+  void Release(std::string &&blobId) noexcept;
 
-#pragma region IResponseHandler
-
-  bool Supports(std::string &responseType) override;
-
-  folly::dynamic 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 {
@@ -114,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>
@@ -142,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/CxxModuleUtilities.cpp

@@ -2,6 +2,10 @@
 // Licensed under the MIT License.
 
 #include "CxxModuleUtilities.h"
+#include <DynamicReader.h>
+#include <DynamicWriter.h>
+
+namespace msrn = winrt::Microsoft::ReactNative;
 
 using facebook::react::Instance;
 using folly::dynamic;
@@ -16,4 +20,32 @@ void SendEvent(weak_ptr<Instance> weakReactInstance, string &&eventName, dynamic
   }
 }
 
+void SendEvent(
+    msrn::ReactContext const &reactContext,
+    std::wstring_view &&eventName,
+    msrn::JSValueObject &&args) noexcept {
+  reactContext.EmitJSEvent(L"RCTDeviceEventEmitter", std::move(eventName), std::move(args));
+}
+
+void SendEvent(
+    msrn::ReactContext const &reactContext,
+    std::wstring_view &&eventName,
+    msrn::JSValueArray &&args) noexcept {
+  reactContext.EmitJSEvent(L"RCTDeviceEventEmitter", std::move(eventName), std::move(args));
+}
+
+msrn::JSValue ToJSValue(dynamic &value) noexcept {
+  auto reader = winrt::make<msrn::DynamicReader>(value);
+  auto result = msrn::JSValue::ReadFrom(reader);
+
+  return result;
+}
+
+dynamic ToDynamic(const msrn::JSValue &value) noexcept {
+  auto argWriter = msrn::MakeJSValueArgWriter(value);
+  auto result = msrn::DynamicWriter::ToDynamic(argWriter)[0];
+
+  return result;
+}
+
 } // namespace Microsoft::React::Modules