react-native-windows 0.69.0-preview.2 → 0.69.0-preview.5

package/Shared/InspectorPackagerConnection.cpp

@@ -86,8 +86,8 @@ struct InspectorProtocol {
     for (const facebook::react::InspectorPage2 &page : pages) {
       folly::dynamic pageDyn = folly::dynamic::object;
       pageDyn["id"] = page.id;
-      pageDyn["title"] = std::string(page.title->c_str());
-      pageDyn["vm"] = std::string(page.vm->c_str());
+      pageDyn["title"] = std::string(page.title);
+      pageDyn["vm"] = std::string(page.vm);
 
       pageDyn["isLastBundleDownloadSuccess"] = bundleStatus.m_isLastDownloadSucess;
       pageDyn["bundleUpdateTimestamp"] = bundleStatus.m_updateTimestamp;
@@ -105,8 +105,8 @@ struct InspectorProtocol {
       const facebook::react::InspectorPage2 page = pages->getPage(p);
       folly::dynamic pageDyn = folly::dynamic::object;
       pageDyn["id"] = page.id;
-      pageDyn["title"] = page.title->c_str();
-      pageDyn["vm"] = page.vm->c_str();
+      pageDyn["title"] = page.title;
+      pageDyn["vm"] = page.vm;
 
       pageDyn["isLastBundleDownloadSuccess"] = bundleStatus.m_isLastDownloadSucess;
       pageDyn["bundleUpdateTimestamp"] = bundleStatus.m_updateTimestamp;
@@ -155,11 +155,10 @@ void RemoteConnection::onDisconnect() {
 RemoteConnection2::RemoteConnection2(int64_t pageId, const InspectorPackagerConnection &packagerConnection)
     : m_packagerConnection(packagerConnection), m_pageId(pageId) {}
 
-void RemoteConnection2::onMessage(std::unique_ptr<facebook::react::IHermesString> message) {
-  std::string msg(message->c_str());
+void RemoteConnection2::onMessage(std::string message) {
   folly::dynamic response = InspectorProtocol::constructResponseForPackager(
       InspectorProtocol::EventType::WrappedEvent,
-      InspectorProtocol::constructVMResponsePayloadForPackager(m_pageId, std::move(msg)));
+      InspectorProtocol::constructVMResponsePayloadForPackager(m_pageId, std::move(message)));
   std::string responsestr = folly::toJson(response);
   m_packagerConnection.sendMessageToPackager(std::move(responsestr));
 }

package/Shared/InspectorPackagerConnection.h

@@ -61,7 +61,7 @@ class RemoteConnection final : public facebook::react::IRemoteConnection {
 class RemoteConnection2 final : public facebook::react::IRemoteConnection2 {
  public:
   RemoteConnection2(int64_t pageId, const InspectorPackagerConnection &packagerConnection);
-  void onMessage(std::unique_ptr<facebook::react::IHermesString> message) override;
+  void onMessage(std::string message) override;
   void onDisconnect() override;
 
  private:

package/Shared/JSI/ChakraRuntime.cpp

@@ -311,6 +311,11 @@ facebook::jsi::PropNameID ChakraRuntime::createPropNameIDFromString(const facebo
   return MakePointer<facebook::jsi::PropNameID>(propertyId);
 }
 
+facebook::jsi::PropNameID ChakraRuntime::createPropNameIDFromSymbol(const facebook::jsi::Symbol &sym) {
+  const JsPropertyIdRef propSym = GetPropertyIdFromSymbol(GetJsRef(sym));
+  return MakePointer<facebook::jsi::PropNameID>(propSym);
+}
+
 std::string ChakraRuntime::utf8(const facebook::jsi::PropNameID &id) {
   return Common::Unicode::Utf16ToUtf8(GetPropertyNameFromId(GetJsRef(id)));
 }

package/Shared/JSI/ChakraRuntime.h

@@ -63,6 +63,7 @@ class ChakraRuntime : public facebook::jsi::Runtime, public ChakraApi, ChakraApi
   facebook::jsi::PropNameID createPropNameIDFromAscii(const char *str, size_t length) override;
   facebook::jsi::PropNameID createPropNameIDFromUtf8(const uint8_t *utf8, size_t length) override;
   facebook::jsi::PropNameID createPropNameIDFromString(const facebook::jsi::String &str) override;
+  facebook::jsi::PropNameID createPropNameIDFromSymbol(const facebook::jsi::Symbol &sym) override;
   std::string utf8(const facebook::jsi::PropNameID &id) override;
   bool compare(const facebook::jsi::PropNameID &lhs, const facebook::jsi::PropNameID &rhs) override;
 

package/Shared/JSI/NapiJsiV8RuntimeHolder.cpp

@@ -77,17 +77,20 @@ NapiJsiV8RuntimeHolder::NapiJsiV8RuntimeHolder(
       m_preparedScriptStore{std::move(preparedScriptStore)} {}
 
 void NapiJsiV8RuntimeHolder::InitRuntime() noexcept {
-  napi_env env{};
   napi_ext_env_settings settings{};
   settings.this_size = sizeof(settings);
-  settings.flags.enable_gc_api = true;
   if (m_debuggerPort > 0)
     settings.inspector_port = m_debuggerPort;
 
   settings.flags.enable_inspector = m_useDirectDebugger;
   settings.flags.wait_for_debugger = m_debuggerBreakOnNextLine;
+  //  TODO: args.debuggerRuntimeName = debuggerRuntimeName_;
   settings.foreground_scheduler = &NapiJsiV8RuntimeHolder::ScheduleTaskCallback;
 
+  napi_ext_script_cache scriptCache = InitScriptCache(std::move(m_preparedScriptStore));
+  settings.script_cache = &scriptCache;
+
+  napi_env env{};
   napi_ext_create_env(&settings, &env);
   // Associate environment to holder.
   napi_set_instance_data(env, this, nullptr /*finalize_cb*/, nullptr /*finalize_hint*/);
@@ -96,6 +99,73 @@ void NapiJsiV8RuntimeHolder::InitRuntime() noexcept {
   m_ownThreadId = std::this_thread::get_id();
 }
 
+struct NodeApiJsiBuffer : facebook::jsi::Buffer {
+  static std::shared_ptr<const facebook::jsi::Buffer> CreateJsiBuffer(const napi_ext_buffer *buffer) {
+    if (buffer && buffer->data) {
+      return std::shared_ptr<const facebook::jsi::Buffer>(new NodeApiJsiBuffer(buffer));
+    } else {
+      return {};
+    }
+  }
+
+  NodeApiJsiBuffer(const napi_ext_buffer *buffer) noexcept : buffer_(*buffer) {}
+
+  ~NodeApiJsiBuffer() override {
+    if (buffer_.buffer_object.finalize_cb) {
+      buffer_.buffer_object.finalize_cb(nullptr, buffer_.buffer_object.data, buffer_.buffer_object.finalize_hint);
+    }
+  }
+
+  const uint8_t *data() const override {
+    return buffer_.data;
+  }
+
+  size_t size() const override {
+    return buffer_.byte_size;
+  }
+
+ private:
+  napi_ext_buffer buffer_;
+};
+
+napi_ext_script_cache NapiJsiV8RuntimeHolder::InitScriptCache(
+    unique_ptr<PreparedScriptStore> &&preparedScriptStore) noexcept {
+  napi_ext_script_cache scriptCache{};
+  scriptCache.cache_object = NativeObjectWrapper<unique_ptr<PreparedScriptStore>>::Wrap(std::move(preparedScriptStore));
+  scriptCache.load_cached_script = [](napi_env env,
+                                      napi_ext_script_cache *script_cache,
+                                      napi_ext_cached_script_metadata *script_metadata,
+                                      napi_ext_buffer *result) -> napi_status {
+    PreparedScriptStore *scriptStore = reinterpret_cast<PreparedScriptStore *>(script_cache->cache_object.data);
+    std::shared_ptr<const facebook::jsi::Buffer> buffer = scriptStore->tryGetPreparedScript(
+        ScriptSignature{script_metadata->source_url, script_metadata->source_hash},
+        JSRuntimeSignature{script_metadata->runtime_name, script_metadata->runtime_version},
+        script_metadata->tag);
+    if (buffer) {
+      result->buffer_object = NativeObjectWrapper<std::shared_ptr<const facebook::jsi::Buffer>>::Wrap(
+          std::shared_ptr<const facebook::jsi::Buffer>{buffer});
+      result->data = buffer->data();
+      result->byte_size = buffer->size();
+    } else {
+      *result = napi_ext_buffer{};
+    }
+    return napi_ok;
+  };
+  scriptCache.store_cached_script = [](napi_env env,
+                                       napi_ext_script_cache *script_cache,
+                                       napi_ext_cached_script_metadata *script_metadata,
+                                       const napi_ext_buffer *buffer) -> napi_status {
+    PreparedScriptStore *scriptStore = reinterpret_cast<PreparedScriptStore *>(script_cache->cache_object.data);
+    scriptStore->persistPreparedScript(
+        NodeApiJsiBuffer::CreateJsiBuffer(buffer),
+        ScriptSignature{script_metadata->source_url, script_metadata->source_hash},
+        JSRuntimeSignature{script_metadata->runtime_name, script_metadata->runtime_version},
+        script_metadata->tag);
+    return napi_ok;
+  };
+  return scriptCache;
+}
+
 #pragma region Microsoft::JSI::RuntimeHolderLazyInit
 
 facebook::react::JSIEngineOverride NapiJsiV8RuntimeHolder::getRuntimeType() noexcept {

package/Shared/JSI/NapiJsiV8RuntimeHolder.h

@@ -31,6 +31,8 @@ class NapiJsiV8RuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
       void *finalizeHint);
 
   void InitRuntime() noexcept;
+  napi_ext_script_cache InitScriptCache(
+      std::unique_ptr<facebook::jsi::PreparedScriptStore> &&preparedScriptStore) noexcept;
 
   std::shared_ptr<facebook::jsi::Runtime> m_runtime;
   std::shared_ptr<facebook::react::MessageQueueThread> m_jsQueue;

package/Shared/Modules/BlobModule.cpp

@@ -0,0 +1,376 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#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>
+
+// 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 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 {
+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";
+} // namespace
+
+namespace Microsoft::React {
+
+#pragma region BlobModule
+
+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;
+}
+
+BlobModule::~BlobModule() noexcept /*override*/ {
+  m_sharedState->Module = nullptr;
+}
+
+#pragma region CxxModule
+
+string BlobModule::getName() {
+  return moduleName;
+}
+
+std::map<string, dynamic> BlobModule::getConstants() {
+  return {{"BLOB_URI_SCHEME", blobKey}, {"BLOB_URI_HOST", {}}};
+}
+
+vector<module::CxxModule::Method> BlobModule::getMethods() {
+  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?
+       }},
+
+      {"addWebSocketHandler",
+       [contentHandler = m_contentHandler](dynamic args) {
+         auto id = jsArgAsInt(args, 0);
+
+         contentHandler->Register(id);
+       }},
+
+      {"removeWebSocketHandler",
+       [contentHandler = m_contentHandler](dynamic args) {
+         auto id = jsArgAsInt(args, 0);
+
+         contentHandler->Unregister(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;
+         }
+
+         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> 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);
+       }},
+
+      {"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>
+         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> 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));
+       }},
+
+      {"release",
+       [persistor = m_blobPersistor](dynamic args) // blobId: string
+       {
+         auto blobId = jsArgAsString(args, 0);
+
+         persistor->RemoveMessage(std::move(blobId));
+       }}};
+}
+
+#pragma endregion CxxModule
+
+#pragma endregion BlobModule
+
+#pragma region MemoryBlobPersistor
+
+#pragma region IBlobPersistor
+
+winrt::array_view<uint8_t> 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>(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;
+}
+
+/*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateBlobModule(
+    IInspectable const &inspectableProperties) noexcept {
+  if (auto properties = inspectableProperties.try_as<IReactPropertyBag>())
+    return std::make_unique<BlobModule>(properties);
+
+  return nullptr;
+}
+
+} // namespace Microsoft::React