react-native-windows 0.69.0-preview.3 → 0.69.0-preview.4

package/Shared/Networking/WinRTHttpResource.cpp

@@ -4,6 +4,7 @@
 #include "WinRTHttpResource.h"
 
 #include <CppRuntimeOptions.h>
+#include <ReactPropertyBag.h>
 #include <Utils/CppWinrtLessExceptions.h>
 #include <Utils/WinRTConversions.h>
 #include <utilities.h>
@@ -17,10 +18,14 @@
 #include <winrt/Windows.Storage.Streams.h>
 #include <winrt/Windows.Web.Http.Headers.h>
 
+using folly::dynamic;
+
 using std::function;
 using std::scoped_lock;
 using std::shared_ptr;
 using std::string;
+using std::vector;
+using std::weak_ptr;
 
 using winrt::fire_and_forget;
 using winrt::hresult_error;
@@ -45,29 +50,25 @@ namespace Microsoft::React::Networking {
 
 #pragma region WinRTHttpResource
 
-// TODO: Check for multi-thread issues if there are multiple instances.
-/*static*/ int64_t WinRTHttpResource::s_lastRequestId = 0;
-
 WinRTHttpResource::WinRTHttpResource(IHttpClient &&client) noexcept : m_client{std::move(client)} {}
 
-WinRTHttpResource::WinRTHttpResource() noexcept : WinRTHttpResource(winrt::Windows::Web::Http::HttpClient()) {}
+WinRTHttpResource::WinRTHttpResource() noexcept : WinRTHttpResource(winrt::Windows::Web::Http::HttpClient{}) {}
 
 #pragma region IHttpResource
 
 void WinRTHttpResource::SendRequest(
     string &&method,
     string &&url,
+    int64_t requestId,
     Headers &&headers,
-    BodyData &&bodyData,
+    dynamic &&data,
     string &&responseType,
     bool useIncrementalUpdates,
     int64_t timeout,
     bool withCredentials,
     std::function<void(int64_t)> &&callback) noexcept /*override*/ {
-  auto requestId = ++s_lastRequestId;
-
   // Enforce supported args
-  assert(responseType == "text" || responseType == "base64");
+  assert(responseType == "text" || responseType == "base64" | responseType == "blob");
 
   if (callback) {
     callback(requestId);
@@ -82,10 +83,10 @@ void WinRTHttpResource::SendRequest(
     auto concreteArgs = args.as<RequestArgs>();
     concreteArgs->RequestId = requestId;
     concreteArgs->Headers = std::move(headers);
-    concreteArgs->Body = std::move(bodyData);
+    concreteArgs->Data = std::move(data);
     concreteArgs->IncrementalUpdates = useIncrementalUpdates;
     concreteArgs->WithCredentials = withCredentials;
-    concreteArgs->IsText = responseType == "text";
+    concreteArgs->ResponseType = std::move(responseType);
     concreteArgs->Timeout = timeout;
 
     PerformSendRequest(std::move(request), args);
@@ -126,8 +127,8 @@ void WinRTHttpResource::ClearCookies() noexcept /*override*/ {
   // NOT IMPLEMENTED
 }
 
-void WinRTHttpResource::SetOnRequest(function<void(int64_t requestId)> &&handler) noexcept /*override*/ {
-  m_onRequest = std::move(handler);
+void WinRTHttpResource::SetOnRequestSuccess(function<void(int64_t requestId)> &&handler) noexcept /*override*/ {
+  m_onRequestSuccess = std::move(handler);
 }
 
 void WinRTHttpResource::SetOnResponse(function<void(int64_t requestId, Response &&response)> &&handler) noexcept
@@ -140,6 +141,12 @@ void WinRTHttpResource::SetOnData(function<void(int64_t requestId, string &&resp
   m_onData = std::move(handler);
 }
 
+void WinRTHttpResource::SetOnData(function<void(int64_t requestId, dynamic &&responseData)> &&handler) noexcept
+/*override*/
+{
+  m_onDataDynamic = std::move(handler);
+}
+
 void WinRTHttpResource::SetOnError(function<void(int64_t requestId, string &&errorMessage)> &&handler) noexcept
 /*override*/ {
   m_onError = std::move(handler);
@@ -167,6 +174,28 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
   // Ensure background thread
   co_await winrt::resume_background();
 
+  // If URI handler is available, it takes over request processing.
+  if (auto uriHandler = self->m_uriHandler.lock()) {
+    auto uri = winrt::to_string(coRequest.RequestUri().ToString());
+    try {
+      if (uriHandler->Supports(uri, coReqArgs->ResponseType)) {
+        auto blob = uriHandler->Fetch(uri);
+        if (self->m_onDataDynamic && self->m_onRequestSuccess) {
+          self->m_onDataDynamic(coReqArgs->RequestId, std::move(blob));
+          self->m_onRequestSuccess(coReqArgs->RequestId);
+        }
+
+        co_return;
+      }
+    } catch (const hresult_error &e) {
+      if (self->m_onError)
+        co_return self->m_onError(coReqArgs->RequestId, Utilities::HResultToString(e));
+    } catch (const std::exception &e) {
+      if (self->m_onError)
+        co_return self->m_onError(coReqArgs->RequestId, e.what());
+    }
+  }
+
   HttpMediaTypeHeaderValue contentType{nullptr};
   string contentEncoding;
   string contentLength;
@@ -201,20 +230,44 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
   }
 
   IHttpContent content{nullptr};
-  if (BodyData::Type::String == coReqArgs->Body.Type) {
-    content = HttpStringContent{to_hstring(coReqArgs->Body.Data)};
-  } else if (BodyData::Type::Base64 == coReqArgs->Body.Type) {
-    auto buffer = CryptographicBuffer::DecodeFromBase64String(to_hstring(coReqArgs->Body.Data));
-    content = HttpBufferContent{buffer};
-  } else if (BodyData::Type::Uri == coReqArgs->Body.Type) {
-    auto file = co_await StorageFile::GetFileFromApplicationUriAsync(Uri{to_hstring(coReqArgs->Body.Data)});
-    auto stream = co_await file.OpenReadAsync();
-    content = HttpStreamContent{stream};
-  } else if (BodyData::Type::Form == coReqArgs->Body.Type) {
-    // #9535 - HTTP form data support
-  } else {
-    // BodyData::Type::Empty
-    // TODO: Error => unsupported??
+  auto &data = coReqArgs->Data;
+  if (!data.isNull()) {
+    auto bodyHandler = self->m_requestBodyHandler.lock();
+    if (bodyHandler && bodyHandler->Supports(data)) {
+      auto contentTypeString = contentType ? winrt::to_string(contentType.ToString()) : "";
+      dynamic blob;
+      try {
+        blob = bodyHandler->ToRequestBody(data, contentTypeString);
+      } catch (const std::invalid_argument &e) {
+        if (self->m_onError) {
+          self->m_onError(coReqArgs->RequestId, e.what());
+        }
+        co_return;
+      }
+      auto bytes = blob["bytes"];
+      auto byteVector = vector<uint8_t>(bytes.size());
+      for (auto &byte : bytes) {
+        byteVector.push_back(static_cast<uint8_t>(byte.asInt()));
+      }
+      auto view = winrt::array_view<uint8_t>{byteVector};
+      auto buffer = CryptographicBuffer::CreateFromByteArray(view);
+      content = HttpBufferContent{std::move(buffer)};
+    } else if (!data["string"].empty()) {
+      content = HttpStringContent{to_hstring(data["string"].asString())};
+    } else if (!data["base64"].empty()) {
+      auto buffer = CryptographicBuffer::DecodeFromBase64String(to_hstring(data["base64"].asString()));
+      content = HttpBufferContent{std::move(buffer)};
+    } else if (!data["uri"].empty()) {
+      auto file = co_await StorageFile::GetFileFromApplicationUriAsync(Uri{to_hstring(data["uri"].asString())});
+      auto stream = co_await file.OpenReadAsync();
+      content = HttpStreamContent{std::move(stream)};
+    } else if (!data["form"].empty()) {
+      // #9535 - HTTP form data support
+      // winrt::Windows::Web::Http::HttpMultipartFormDataContent()
+    } else {
+      // Assume empty request body.
+      // content = HttpStringContent{L""};
+    }
   }
 
   if (content != nullptr) {
@@ -224,12 +277,13 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
     }
     if (!contentEncoding.empty()) {
       if (!content.Headers().ContentEncoding().TryParseAdd(to_hstring(contentEncoding))) {
-        if (m_onError) {
-          m_onError(coReqArgs->RequestId, "Failed to parse Content-Encoding");
-        }
+        if (self->m_onError)
+          self->m_onError(coReqArgs->RequestId, "Failed to parse Content-Encoding");
+
         co_return;
       }
     }
+
     if (!contentLength.empty()) {
       const auto contentLengthHeader = _atoi64(contentLength.c_str());
       content.Headers().ContentLength(contentLengthHeader);
@@ -255,7 +309,7 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
     auto response = sendRequestOp.GetResults();
     if (response) {
       if (self->m_onResponse) {
-        string url = to_string(response.RequestMessage().RequestUri().AbsoluteUri());
+        auto url = to_string(response.RequestMessage().RequestUri().AbsoluteUri());
 
         // Gather headers for both the response content and the response itself
         // See Invoke-WebRequest PowerShell cmdlet or Chromium response handling
@@ -278,30 +332,54 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
       auto inputStream = co_await response.Content().ReadAsInputStreamAsync();
       auto reader = DataReader{inputStream};
 
-      if (coReqArgs->IsText) {
-        reader.UnicodeEncoding(UnicodeEncoding::Utf8);
-      }
-
       // #9510 - 10mb limit on fetch
       co_await reader.LoadAsync(10 * 1024 * 1024);
-      auto length = reader.UnconsumedBufferLength();
 
-      if (coReqArgs->IsText) {
-        std::vector<uint8_t> data(length);
-        reader.ReadBytes(data);
-        string responseData = string(Common::Utilities::CheckedReinterpretCast<char *>(data.data()), data.size());
+      // Let response handler take over, if set
+      if (auto responseHandler = self->m_responseHandler.lock()) {
+        if (responseHandler->Supports(coReqArgs->ResponseType)) {
+          auto bytes = vector<uint8_t>(reader.UnconsumedBufferLength());
+          reader.ReadBytes(bytes);
+          auto blob = responseHandler->ToResponseData(std::move(bytes));
+
+          if (self->m_onDataDynamic && self->m_onRequestSuccess) {
+            self->m_onDataDynamic(coReqArgs->RequestId, std::move(blob));
+            self->m_onRequestSuccess(coReqArgs->RequestId);
+          }
 
-        if (self->m_onData) {
-          self->m_onData(coReqArgs->RequestId, std::move(responseData));
+          co_return;
         }
-      } else {
-        auto buffer = reader.ReadBuffer(length);
-        auto data = CryptographicBuffer::EncodeToBase64String(buffer);
-        auto responseData = to_string(std::wstring_view(data));
+      }
+
+      auto isText = coReqArgs->ResponseType == "text";
+      if (isText) {
+        reader.UnicodeEncoding(UnicodeEncoding::Utf8);
+      }
 
-        if (self->m_onData) {
-          self->m_onData(coReqArgs->RequestId, std::move(responseData));
+      // #9510 - We currently accumulate all incoming request data in 10MB chunks.
+      uint32_t segmentSize = 10 * 1024 * 1024;
+      string responseData;
+      winrt::Windows::Storage::Streams::IBuffer buffer;
+      uint32_t length;
+      do {
+        co_await reader.LoadAsync(segmentSize);
+        length = reader.UnconsumedBufferLength();
+
+        if (isText) {
+          auto data = std::vector<uint8_t>(length);
+          reader.ReadBytes(data);
+
+          responseData += string(Common::Utilities::CheckedReinterpretCast<char *>(data.data()), data.size());
+        } else {
+          buffer = reader.ReadBuffer(length);
+          auto data = CryptographicBuffer::EncodeToBase64String(buffer);
+
+          responseData += to_string(std::wstring_view(data));
         }
+      } while (length > 0);
+
+      if (self->m_onData) {
+        self->m_onData(coReqArgs->RequestId, std::move(responseData));
       }
     } else {
       if (self->m_onError) {
@@ -323,23 +401,63 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
   }
 
   self->UntrackResponse(coReqArgs->RequestId);
+} // PerformSendRequest
+
+#pragma region IHttpModuleProxy
+
+void WinRTHttpResource::AddUriHandler(shared_ptr<IUriHandler> /*uriHandler*/) noexcept /*override*/
+{
+  // TODO: Implement custom URI handling.
+}
+
+void WinRTHttpResource::AddRequestBodyHandler(shared_ptr<IRequestBodyHandler> requestBodyHandler) noexcept /*override*/
+{
+  m_requestBodyHandler = weak_ptr<IRequestBodyHandler>(requestBodyHandler);
 }
 
+void WinRTHttpResource::AddResponseHandler(shared_ptr<IResponseHandler> responseHandler) noexcept /*override*/
+{
+  m_responseHandler = weak_ptr<IResponseHandler>(responseHandler);
+}
+
+#pragma endregion IHttpModuleProxy
+
 #pragma endregion WinRTHttpResource
 
 #pragma region IHttpResource
 
-/*static*/ shared_ptr<IHttpResource> IHttpResource::Make() noexcept {
+/*static*/ shared_ptr<IHttpResource> IHttpResource::Make(
+    winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept {
+  using namespace winrt::Microsoft::ReactNative;
+  using winrt::Windows::Web::Http::HttpClient;
+
+  shared_ptr<WinRTHttpResource> result;
+
   if (static_cast<OriginPolicy>(GetRuntimeOptionInt("Http.OriginPolicy")) == OriginPolicy::None) {
-    return std::make_shared<WinRTHttpResource>();
+    result = std::make_shared<WinRTHttpResource>();
   } else {
     auto globalOrigin = GetRuntimeOptionString("Http.GlobalOrigin");
     OriginPolicyHttpFilter::SetStaticOrigin(std::move(globalOrigin));
     auto opFilter = winrt::make<OriginPolicyHttpFilter>();
-    auto client = winrt::Windows::Web::Http::HttpClient{opFilter};
+    auto client = HttpClient{opFilter};
 
-    return std::make_shared<WinRTHttpResource>(std::move(client));
+    result = std::make_shared<WinRTHttpResource>(std::move(client));
   }
+
+  // Register resource as HTTP module proxy.
+  if (inspectableProperties) {
+    auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IHttpModuleProxy>>>{L"HttpModule.Proxy"};
+    auto propBag = ReactPropertyBag{inspectableProperties.try_as<IReactPropertyBag>()};
+    auto moduleProxy = weak_ptr<IHttpModuleProxy>{result};
+    propBag.Set(propId, std::move(moduleProxy));
+  }
+
+  return result;
+}
+
+/*static*/ shared_ptr<IHttpResource> IHttpResource::Make() noexcept {
+  auto inspectableProperties = IInspectable{nullptr};
+  return Make(inspectableProperties);
 }
 
 #pragma endregion IHttpResource

package/Shared/Networking/WinRTHttpResource.h

@@ -5,6 +5,7 @@
 
 #include "IHttpResource.h"
 
+#include <Modules/IHttpModuleProxy.h>
 #include "WinRTTypes.h"
 
 // Windows API
@@ -15,18 +16,24 @@
 
 namespace Microsoft::React::Networking {
 
-class WinRTHttpResource : public IHttpResource, public std::enable_shared_from_this<WinRTHttpResource> {
-  static int64_t s_lastRequestId;
-
+class WinRTHttpResource : public IHttpResource,
+                          public IHttpModuleProxy,
+                          public std::enable_shared_from_this<WinRTHttpResource> {
   winrt::Windows::Web::Http::IHttpClient m_client;
   std::mutex m_mutex;
   std::unordered_map<int64_t, ResponseOperation> m_responses;
 
-  std::function<void(int64_t requestId)> m_onRequest;
+  std::function<void(int64_t requestId)> m_onRequestSuccess;
   std::function<void(int64_t requestId, Response &&response)> m_onResponse;
   std::function<void(int64_t requestId, std::string &&responseData)> m_onData;
+  std::function<void(int64_t requestId, folly::dynamic &&responseData)> m_onDataDynamic;
   std::function<void(int64_t requestId, std::string &&errorMessage /*, bool isTimeout*/)> m_onError;
 
+  // Used for IHttpModuleProxy
+  std::weak_ptr<IUriHandler> m_uriHandler;
+  std::weak_ptr<IRequestBodyHandler> m_requestBodyHandler;
+  std::weak_ptr<IResponseHandler> m_responseHandler;
+
   void TrackResponse(int64_t requestId, ResponseOperation response) noexcept;
 
   void UntrackResponse(int64_t requestId) noexcept;
@@ -45,8 +52,9 @@ class WinRTHttpResource : public IHttpResource, public std::enable_shared_from_t
   void SendRequest(
       std::string &&method,
       std::string &&url,
+      int64_t requestId,
       Headers &&headers,
-      BodyData &&bodyData,
+      folly::dynamic &&data,
       std::string &&responseType,
       bool useIncrementalUpdates,
       int64_t timeout,
@@ -55,13 +63,24 @@ class WinRTHttpResource : public IHttpResource, public std::enable_shared_from_t
   void AbortRequest(int64_t requestId) noexcept override;
   void ClearCookies() noexcept override;
 
-#pragma endregion IHttpResource
-
-  void SetOnRequest(std::function<void(int64_t requestId)> &&handler) noexcept override;
+  void SetOnRequestSuccess(std::function<void(int64_t requestId)> &&handler) noexcept override;
   void SetOnResponse(std::function<void(int64_t requestId, Response &&response)> &&handler) noexcept override;
   void SetOnData(std::function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept override;
+  void SetOnData(std::function<void(int64_t requestId, folly::dynamic &&responseData)> &&handler) noexcept override;
   void SetOnError(std::function<void(int64_t requestId, std::string &&errorMessage /*, bool isTimeout*/)>
                       &&handler) noexcept override;
+
+#pragma endregion IHttpResource
+
+#pragma region IHttpModuleProxy
+
+  void AddUriHandler(std::shared_ptr<IUriHandler> uriHandler) noexcept override;
+
+  void AddRequestBodyHandler(std::shared_ptr<IRequestBodyHandler> requestBodyHandler) noexcept override;
+
+  void AddResponseHandler(std::shared_ptr<IResponseHandler> responseHandler) noexcept override;
+
+#pragma endregion IHttpModuleProxy
 };
 
 } // namespace Microsoft::React::Networking

package/Shared/Networking/WinRTTypes.h

@@ -5,6 +5,9 @@
 
 #include "IHttpResource.h"
 
+// Folly
+#include <folly/dynamic.h>
+
 // Windows API
 #include <winrt/Windows.Web.Http.h>
 
@@ -16,10 +19,10 @@ namespace Microsoft::React::Networking {
 struct RequestArgs : public winrt::implements<RequestArgs, winrt::Windows::Foundation::IInspectable> {
   int64_t RequestId;
   IHttpResource::Headers Headers;
-  IHttpResource::BodyData Body;
+  folly::dynamic Data;
   bool IncrementalUpdates;
   bool WithCredentials;
-  bool IsText;
+  std::string ResponseType;
   int64_t Timeout;
 };
 

package/Shared/OInstance.cpp

@@ -67,14 +67,16 @@ using namespace facebook;
 using namespace Microsoft::JSI;
 
 using std::make_shared;
+using winrt::Microsoft::ReactNative::ReactPropertyBagHelper;
 
 namespace Microsoft::React {
 
-/*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule() noexcept {
+/*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule(
+    winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept {
   if (GetRuntimeOptionBool("Http.UseMonolithicModule")) {
     return std::make_unique<NetworkingModule>();
   } else {
-    return std::make_unique<HttpModule>();
+    return std::make_unique<HttpModule>(inspectableProperties);
   }
 }
 
@@ -541,18 +543,21 @@ InstanceImpl::~InstanceImpl() {
 std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules(
     std::shared_ptr<MessageQueueThread> nativeQueue) {
   std::vector<std::unique_ptr<NativeModule>> modules;
+  auto transitionalProps{ReactPropertyBagHelper::CreatePropertyBag()};
 
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
       Microsoft::React::GetHttpModuleName(),
-      [nativeQueue]() -> std::unique_ptr<xplat::module::CxxModule> { return Microsoft::React::CreateHttpModule(); },
+      [nativeQueue, transitionalProps]() -> std::unique_ptr<xplat::module::CxxModule> {
+        return Microsoft::React::CreateHttpModule(transitionalProps);
+      },
       nativeQueue));
 
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
       Microsoft::React::GetWebSocketModuleName(),
-      [nativeQueue]() -> std::unique_ptr<xplat::module::CxxModule> {
-        return Microsoft::React::CreateWebSocketModule();
+      [nativeQueue, transitionalProps]() -> std::unique_ptr<xplat::module::CxxModule> {
+        return Microsoft::React::CreateWebSocketModule(transitionalProps);
       },
       nativeQueue));
 
@@ -614,6 +619,18 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
       []() { return std::make_unique<StatusBarManagerModule>(); },
       nativeQueue));
 
+  modules.push_back(std::make_unique<CxxNativeModule>(
+      m_innerInstance,
+      Microsoft::React::GetBlobModuleName(),
+      [transitionalProps]() { return Microsoft::React::CreateBlobModule(transitionalProps); },
+      nativeQueue));
+
+  modules.push_back(std::make_unique<CxxNativeModule>(
+      m_innerInstance,
+      Microsoft::React::GetFileReaderModuleName(),
+      [transitionalProps]() { return Microsoft::React::CreateFileReaderModule(transitionalProps); },
+      nativeQueue));
+
   return modules;
 }
 

package/Shared/OInstance.h

@@ -5,14 +5,18 @@
 
 #pragma once
 
+#include <ReactPropertyBag.h>
+#include <TurboModuleManager.h>
+#include "InstanceManager.h"
+
+// React Native
+#include <cxxreact/Instance.h>
+
+// Standard Libriary
 #include <memory>
 #include <string>
 #include <vector>
 
-#include <TurboModuleManager.h>
-#include <cxxreact/Instance.h>
-#include "InstanceManager.h"
-
 namespace facebook {
 namespace react {
 

package/Shared/RuntimeOptions.cpp

@@ -94,7 +94,7 @@ void __cdecl MicrosoftReactSetRuntimeOptionString(const char *name, const char *
     g_runtimeOptionStrings.erase(name);
 }
 
-const bool __cdecl MicrosoftReactGetRuntimeOptionBool(const char *name) noexcept {
+bool __cdecl MicrosoftReactGetRuntimeOptionBool(const char *name) noexcept {
   scoped_lock lock{g_runtimeOptionsMutex};
   auto itr = g_runtimeOptionInts.find(name);
   if (itr != g_runtimeOptionInts.end())
@@ -103,7 +103,7 @@ const bool __cdecl MicrosoftReactGetRuntimeOptionBool(const char *name) noexcept
   return false;
 }
 
-const int32_t __cdecl MicrosoftReactGetRuntimeOptionInt(const char *name) noexcept {
+int32_t __cdecl MicrosoftReactGetRuntimeOptionInt(const char *name) noexcept {
   scoped_lock lock{g_runtimeOptionsMutex};
   auto itr = g_runtimeOptionInts.find(name);
   if (itr != g_runtimeOptionInts.end())
@@ -112,7 +112,10 @@ const int32_t __cdecl MicrosoftReactGetRuntimeOptionInt(const char *name) noexce
   return 0;
 }
 
-void MicrosoftReactGetRuntimeOptionString(const char *name, MicrosoftReactGetStringCallback callBack, void *state) {
+void __cdecl MicrosoftReactGetRuntimeOptionString(
+    const char *name,
+    MicrosoftReactGetStringCallback callBack,
+    void *state) {
   scoped_lock lock{g_runtimeOptionsMutex};
   auto itr = g_runtimeOptionStrings.find(name);
   if (itr != g_runtimeOptionStrings.cend()) {

package/Shared/RuntimeOptions.h

@@ -3,6 +3,10 @@
 
 #pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /// <summary>
 /// Sets a global boolean value identified by an arbitrary string.
 /// </summary>
@@ -26,14 +30,14 @@ void __cdecl MicrosoftReactSetRuntimeOptionString(const char *name, const char *
 /// </summary>
 /// <param name="name">Global boolean key</param>
 /// <returns>Value stored for the given key, or false if the entry doesn't exist (default)</returns>
-const bool __cdecl MicrosoftReactGetRuntimeOptionBool(const char *name) noexcept;
+bool __cdecl MicrosoftReactGetRuntimeOptionBool(const char *name) noexcept;
 
 /// <summary>
 /// Retrieves a global boolean value for the given key.
 /// </summary>
 /// <param name="name">Global key</param>
 /// <returns>Value stored for the given key, or 0 if the entry doesn't exist (default)</returns>
-const int32_t __cdecl MicrosoftReactGetRuntimeOptionInt(const char *name) noexcept;
+int32_t __cdecl MicrosoftReactGetRuntimeOptionInt(const char *name) noexcept;
 
 /// <param name="buffer">String contents. nullptr if none found</param>
 /// <param name="length">String length. 0 if none found</param>
@@ -46,4 +50,11 @@ typedef void(__cdecl *MicrosoftReactGetStringCallback)(const char *buffer, size_
 /// <param name="name">Global key</param>
 /// <param name="callBack">Handler used to access the obtained string</param>
 /// <param name="state">Arbitrary data to pass on to or retrieve from callBack</param>
-void MicrosoftReactGetRuntimeOptionString(const char *name, MicrosoftReactGetStringCallback callBack, void *state);
+void __cdecl MicrosoftReactGetRuntimeOptionString(
+    const char *name,
+    MicrosoftReactGetStringCallback callBack,
+    void *state);
+
+#ifdef __cplusplus
+}
+#endif

package/Shared/Shared.vcxitems

@@ -44,7 +44,10 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\AsyncStorageModuleWin32.cpp">
       <ExcludedFromBuild Condition="'$(ApplicationType)' == ''">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="$(MSBuildThisFileDirectory)Modules\BlobModule.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)Modules\CxxModuleUtilities.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\ExceptionsManagerModule.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)Modules\FileReaderModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\HttpModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\I18nModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.cpp" />
@@ -87,6 +90,16 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\NapiJsiV8RuntimeHolder.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\RuntimeHolder.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\ScriptStore.h" />
+    <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" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Modules\IUriHandler.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Modules\IWebSocketModuleContentHandler.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Modules\IWebSocketModuleProxy.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\HttpModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IHttpResource.h" />