react-native-windows 0.82.1 → 0.83.0-preview.0

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/Instance.cpp

@@ -0,0 +1,381 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+#include "Instance.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#include "ErrorUtils.h"
+#include "JSBigString.h"
+#include "JSBundleType.h"
+#include "JSExecutor.h"
+#include "MessageQueueThread.h"
+#include "MethodCall.h"
+#include "NativeToJsBridge.h"
+#include "RAMBundleRegistry.h"
+#include "RecoverableError.h"
+#include "TraceSection.h"
+
+#include <cxxreact/JSIndexedRAMBundle.h>
+#include <folly/json.h>
+#include <react/debug/react_native_assert.h>
+
+#include <glog/logging.h>
+
+#include <condition_variable>
+#include <exception>
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace facebook::react {
+
+Instance::~Instance() {
+  if (nativeToJsBridge_) {
+    nativeToJsBridge_->destroy();
+  }
+}
+
+void Instance::unregisterFromInspector() {
+  if (inspectorTarget_ != nullptr) {
+    assert(runtimeInspectorTarget_);
+    inspectorTarget_->unregisterRuntime(*runtimeInspectorTarget_);
+    assert(parentInspectorTarget_);
+    parentInspectorTarget_->unregisterInstance(*inspectorTarget_);
+    parentInspectorTarget_ = nullptr;
+    inspectorTarget_ = nullptr;
+  }
+}
+
+void Instance::initializeBridge(
+    std::unique_ptr<InstanceCallback> callback,
+    std::shared_ptr<JSExecutorFactory> jsef,
+    std::shared_ptr<MessageQueueThread> jsQueue,
+    std::shared_ptr<ModuleRegistry> moduleRegistry,
+    jsinspector_modern::HostTarget* parentInspectorTarget) {
+  callback_ = std::move(callback);
+  moduleRegistry_ = std::move(moduleRegistry);
+  parentInspectorTarget_ = parentInspectorTarget;
+
+  jsQueue->runOnQueueSync([this, &jsef, jsQueue]() mutable {
+    nativeToJsBridge_ = std::make_shared<NativeToJsBridge>(
+        jsef.get(), moduleRegistry_, jsQueue, callback_);
+
+    // If a parent inspector HostTarget is provided, perform inspector
+    // initialization synchronously.
+    if (parentInspectorTarget_ != nullptr) {
+      auto inspectorExecutor = parentInspectorTarget_->executorFromThis();
+      std::mutex inspectorInitializedMutex;
+      std::condition_variable inspectorInitializedCv;
+      bool inspectorInitialized = false;
+
+      // Schedule work on the inspector thread. NOTE: We expect this callback
+      // to always execute, given the invariant that `initializeBridge` (this
+      // method) completes before `unregisterFromInspector` is called.
+      // - On iOS, instance creation and invalidation both run on the main
+      //   queue (`RCTCxxBridge::start,invalidate` use `RCTAssertMainQueue`).
+      // - On Android, `ReactContext` must be initialized with a constructed
+      //   `CatalystInstance` (in which `Instance::initializeBridge` has
+      //   completed) before `destroy` can be called.
+      inspectorExecutor([this,
+                         &inspectorInitialized,
+                         &inspectorInitializedMutex,
+                         &inspectorInitializedCv](
+                            jsinspector_modern::HostTarget& hostTarget) {
+        // NOTE: By passing *this, we strongly assume the Instance will still
+        // be alive by the time this executes.
+        // - On iOS, instance creation is done synchronously
+        //   (`RCTCxxBridge::_initializeBridgeLocked`).
+        // - On Android, we explicitly wait for instance creation before
+        //   destruction (`ReactInstanceManager::mReactContextLock`).
+        inspectorTarget_ = &hostTarget.registerInstance(*this);
+        RuntimeExecutor runtimeExecutorIfJsi = getRuntimeExecutor();
+        runtimeInspectorTarget_ = &inspectorTarget_->registerRuntime(
+            nativeToJsBridge_->getInspectorTargetDelegate(),
+            runtimeExecutorIfJsi ? runtimeExecutorIfJsi : [](auto) {});
+
+        // Signal that initialization is complete
+        {
+          std::lock_guard lock(inspectorInitializedMutex);
+          inspectorInitialized = true;
+        }
+        inspectorInitializedCv.notify_one();
+      });
+
+      // Wait for the initialization work to complete
+      {
+        std::unique_lock lock(inspectorInitializedMutex);
+        inspectorInitializedCv.wait(
+            lock, [&inspectorInitialized] { return inspectorInitialized; });
+      }
+    }
+
+    // Initialize the JavaScript runtime after we've initialized the inspector
+    nativeToJsBridge_->initializeRuntime();
+
+    // After NativeToJsBridge is created, the jsi::Runtime should exist. Also,
+    // the JS message queue thread exists. So, it's safe to schedule all queued
+    // up JS calls.
+    jsCallInvoker_->setNativeToJsBridgeAndFlushCalls(nativeToJsBridge_);
+
+    std::scoped_lock lock(m_syncMutex);
+    m_syncReady = true;
+    m_syncCV.notify_all();
+  });
+
+  CHECK(nativeToJsBridge_);
+}
+
+void Instance::loadBundle(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> startupScript,
+    std::string sourceURL) {
+  callback_->incrementPendingJSCalls();
+  TraceSection s("Instance::loadBundle", "sourceURL", sourceURL);
+  nativeToJsBridge_->loadBundle(
+      std::move(bundleRegistry),
+      std::move(startupScript),
+      std::move(sourceURL));
+}
+
+void Instance::loadBundleSync(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> startupScript,
+    std::string sourceURL) {
+  std::unique_lock<std::mutex> lock(m_syncMutex);
+  m_syncCV.wait(lock, [this] { return m_syncReady; });
+
+  TraceSection s("Instance::loadBundleSync", "sourceURL", sourceURL);
+  nativeToJsBridge_->loadBundleSync(
+      std::move(bundleRegistry),
+      std::move(startupScript),
+      std::move(sourceURL));
+}
+
+void Instance::setSourceURL(std::string sourceURL) {
+  callback_->incrementPendingJSCalls();
+  TraceSection s("Instance::setSourceURL", "sourceURL", sourceURL);
+
+  nativeToJsBridge_->loadBundle(nullptr, nullptr, std::move(sourceURL));
+}
+
+void Instance::loadScriptFromString(
+    std::unique_ptr<const JSBigString> string,
+    std::string sourceURL,
+    bool loadSynchronously) {
+  TraceSection s("Instance::loadScriptFromString", "sourceURL", sourceURL);
+  if (loadSynchronously) {
+    loadBundleSync(nullptr, std::move(string), std::move(sourceURL));
+  } else {
+    loadBundle(nullptr, std::move(string), std::move(sourceURL));
+  }
+}
+
+void Instance::loadRAMBundleFromString(
+    std::unique_ptr<const JSBigString> script,
+    const std::string& sourceURL) {
+  auto bundle = std::make_unique<JSIndexedRAMBundle>(std::move(script));
+  auto startupScript = bundle->getStartupCode();
+  auto registry = RAMBundleRegistry::singleBundleRegistry(std::move(bundle));
+  loadRAMBundle(std::move(registry), std::move(startupScript), sourceURL, true);
+}
+
+void Instance::loadRAMBundleFromFile(
+    const std::string& sourcePath,
+    const std::string& sourceURL,
+    bool loadSynchronously) {
+  auto bundle = std::make_unique<JSIndexedRAMBundle>(sourcePath.c_str());
+  auto startupScript = bundle->getStartupCode();
+  auto registry = RAMBundleRegistry::multipleBundlesRegistry(
+      std::move(bundle), JSIndexedRAMBundle::buildFactory());
+  loadRAMBundle(
+      std::move(registry),
+      std::move(startupScript),
+      sourceURL,
+      loadSynchronously);
+}
+
+void Instance::loadRAMBundle(
+    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
+    std::unique_ptr<const JSBigString> startupScript,
+    std::string startupScriptSourceURL,
+    bool loadSynchronously) {
+  if (loadSynchronously) {
+    loadBundleSync(
+        std::move(bundleRegistry),
+        std::move(startupScript),
+        std::move(startupScriptSourceURL));
+  } else {
+    loadBundle(
+        std::move(bundleRegistry),
+        std::move(startupScript),
+        std::move(startupScriptSourceURL));
+  }
+}
+
+void Instance::setGlobalVariable(
+    std::string propName,
+    std::unique_ptr<const JSBigString> jsonValue) {
+  nativeToJsBridge_->setGlobalVariable(
+      std::move(propName), std::move(jsonValue));
+}
+
+void* Instance::getJavaScriptContext() {
+  return nativeToJsBridge_ ? nativeToJsBridge_->getJavaScriptContext()
+                           : nullptr;
+}
+
+bool Instance::isInspectable() {
+  return nativeToJsBridge_ ? nativeToJsBridge_->isInspectable() : false;
+}
+
+bool Instance::isBatchActive() {
+  return nativeToJsBridge_ ? nativeToJsBridge_->isBatchActive() : false;
+}
+
+void Instance::callJSFunction(
+    std::string&& module,
+    std::string&& method,
+    folly::dynamic&& params) {
+  callback_->incrementPendingJSCalls();
+  nativeToJsBridge_->callFunction(
+      std::move(module), std::move(method), std::move(params));
+}
+
+void Instance::callJSCallback(uint64_t callbackId, folly::dynamic&& params) {
+  TraceSection s("Instance::callJSCallback");
+  callback_->incrementPendingJSCalls();
+  nativeToJsBridge_->invokeCallback((double)callbackId, std::move(params));
+}
+
+void Instance::registerBundle(
+    uint32_t bundleId,
+    const std::string& bundlePath) {
+  nativeToJsBridge_->registerBundle(bundleId, bundlePath);
+}
+
+const ModuleRegistry& Instance::getModuleRegistry() const {
+  return *moduleRegistry_;
+}
+
+ModuleRegistry& Instance::getModuleRegistry() {
+  return *moduleRegistry_;
+}
+
+void Instance::handleMemoryPressure(int pressureLevel) {
+  if (nativeToJsBridge_) {
+    // This class resets `nativeToJsBridge_` only in the destructor,
+    // hence a race is not possible there.
+    nativeToJsBridge_->handleMemoryPressure(pressureLevel);
+  }
+}
+
+std::shared_ptr<CallInvoker> Instance::getJSCallInvoker() {
+  return std::static_pointer_cast<CallInvoker>(jsCallInvoker_);
+}
+
+RuntimeExecutor Instance::getRuntimeExecutor() {
+  // HACK: RuntimeExecutor is not compatible with non-JSIExecutor, we return
+  // a null callback, which the caller should handle.
+  if (getJavaScriptContext() == nullptr) {
+    return nullptr;
+  }
+
+  std::weak_ptr<NativeToJsBridge> weakNativeToJsBridge = nativeToJsBridge_;
+  return [weakNativeToJsBridge](
+             std::function<void(jsi::Runtime & runtime)>&& callback) {
+    if (auto strongNativeToJsBridge = weakNativeToJsBridge.lock()) {
+      strongNativeToJsBridge->runOnExecutorQueue(
+          [callback = std::move(callback)](JSExecutor* executor) {
+            // Assumes the underlying executor is a JSIExecutor
+            auto* runtime =
+                static_cast<jsi::Runtime*>(executor->getJavaScriptContext());
+            try {
+              react_native_assert(runtime != nullptr);
+              callback(*runtime);
+              executor->flush();
+            } catch (jsi::JSError& originalError) {
+              handleJSError(*runtime, originalError, true);
+            }
+          });
+    }
+  };
+}
+
+std::shared_ptr<NativeMethodCallInvoker>
+Instance::getDecoratedNativeMethodCallInvoker(
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker) {
+  return nativeToJsBridge_->getDecoratedNativeMethodCallInvoker(
+      nativeMethodCallInvoker);
+}
+
+void Instance::JSCallInvoker::setNativeToJsBridgeAndFlushCalls(
+    std::weak_ptr<NativeToJsBridge> nativeToJsBridge) {
+  std::scoped_lock guard(m_mutex);
+
+  m_shouldBuffer = false;
+  m_nativeToJsBridge = nativeToJsBridge;
+  while (!m_workBuffer.empty()) {
+    scheduleAsync(std::move(m_workBuffer.front()));
+    m_workBuffer.pop_front();
+  }
+}
+
+void Instance::JSCallInvoker::invokeSync(CallFunc&& /*work*/) {
+  // TODO: Replace JS Callinvoker with RuntimeExecutor.
+  throw std::runtime_error(
+      "Synchronous native -> JS calls are currently not supported.");
+}
+
+void Instance::JSCallInvoker::invokeAsync(CallFunc&& work) noexcept {
+  std::scoped_lock guard(m_mutex);
+
+  /**
+   * Why is is necessary to queue up async work?
+   *
+   * 1. TurboModuleManager must be created synchronously after the Instance,
+   *    before we load the source code. This is when the NativeModule system
+   *    is initialized. RCTDevLoadingView shows bundle download progress.
+   * 2. TurboModuleManager requires a JS CallInvoker.
+   * 3. The JS CallInvoker requires the NativeToJsBridge, which is created on
+   *    the JS thread in Instance::initializeBridge.
+   *
+   * Therefore, although we don't call invokeAsync before the JS bundle is
+   * executed, this buffering is implemented anyways to ensure that work
+   * isn't discarded.
+   */
+  if (m_shouldBuffer) {
+    m_workBuffer.push_back(std::move(work));
+    return;
+  }
+
+  scheduleAsync(std::move(work));
+}
+
+void Instance::JSCallInvoker::scheduleAsync(CallFunc&& work) noexcept {
+  if (auto strongNativeToJsBridge = m_nativeToJsBridge.lock()) {
+    strongNativeToJsBridge->runOnExecutorQueue(
+        [work = std::move(work)](JSExecutor* executor) {
+          auto* runtime = (jsi::Runtime*)executor->getJavaScriptContext();
+          work(*runtime);
+          executor->flush();
+        });
+  }
+}
+
+} // namespace facebook::react
+
+#endif // RCT_REMOVE_LEGACY_ARCH
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/JSExecutor.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+#include "JSExecutor.h"
+
+#include "RAMBundleRegistry.h"
+
+#include <jsinspector-modern/ReactCdp.h>
+
+#include <array>
+
+namespace facebook::react {
+
+std::string JSExecutor::getSyntheticBundlePath(
+    uint32_t bundleId,
+    const std::string& bundlePath) {
+#ifndef RCT_REMOVE_LEGACY_ARCH
+  if (bundleId == RAMBundleRegistry::MAIN_BUNDLE_ID) {
+    return bundlePath;
+  }
+#endif // RCT_REMOVE_LEGACY_ARCH
+
+  std::array<char, 32> buffer{};
+  std::snprintf(buffer.data(), buffer.size(), "seg-%u.js", bundleId);
+  return buffer.data();
+}
+
+jsinspector_modern::RuntimeTargetDelegate&
+JSExecutor::getRuntimeTargetDelegate() {
+  if (!runtimeTargetDelegate_) {
+    runtimeTargetDelegate_.emplace(getDescription());
+  }
+  return *runtimeTargetDelegate_;
+}
+
+} // namespace facebook::react
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/JSIndexedRAMBundle.cpp

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+#include "JSIndexedRAMBundle.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#include <glog/logging.h>
+#include <fstream>
+#include <memory>
+#include <sstream>
+
+#include <folly/lang/Bits.h>
+#include <glog/logging.h>
+
+namespace facebook::react {
+
+std::function<std::unique_ptr<JSModulesUnbundle>(std::string)>
+JSIndexedRAMBundle::buildFactory() {
+  return [](const std::string& bundlePath) {
+    return std::make_unique<JSIndexedRAMBundle>(bundlePath.c_str());
+  };
+}
+
+JSIndexedRAMBundle::JSIndexedRAMBundle(const char* sourcePath) {
+  m_bundle = std::make_unique<std::ifstream>(sourcePath, std::ifstream::binary);
+  if (!m_bundle) {
+    throw std::ios_base::failure(
+        std::string("Bundle ") + sourcePath +
+        "cannot be opened: " + std::to_string(m_bundle->rdstate()));
+  }
+  init();
+}
+
+JSIndexedRAMBundle::JSIndexedRAMBundle(
+    std::unique_ptr<const JSBigString> script) {
+  // tmpStream is needed because m_bundle is std::istream type
+  // which has no member 'write'
+  std::unique_ptr<std::stringstream> tmpStream =
+      std::make_unique<std::stringstream>();
+  tmpStream->write(script->c_str(), script->size());
+  m_bundle = std::move(tmpStream);
+  if (!m_bundle) {
+    throw std::ios_base::failure(
+        "Bundle from string cannot be opened: " +
+        std::to_string(m_bundle->rdstate()));
+  }
+  init();
+}
+
+void JSIndexedRAMBundle::init() {
+  // read in magic header, number of entries, and length of the startup section
+  uint32_t header[3];
+  static_assert(
+      sizeof(header) == 12,
+      "header size must exactly match the input file format");
+
+  readBundle(reinterpret_cast<char*>(header), sizeof(header));
+  const size_t numTableEntries = folly::Endian::little(header[1]);
+  const size_t startupCodeSize = folly::Endian::little(header[2]);
+
+  // allocate memory for meta data and lookup table.
+  m_table = ModuleTable(numTableEntries);
+  m_baseOffset = sizeof(header) + m_table.byteLength();
+
+  // read the lookup table from the file
+  readBundle(reinterpret_cast<char*>(m_table.data.get()), m_table.byteLength());
+
+  // read the startup code
+  m_startupCode = std::make_unique<JSBigBufferString>(startupCodeSize - 1);
+
+  readBundle(m_startupCode->data(), startupCodeSize - 1);
+}
+
+JSIndexedRAMBundle::Module JSIndexedRAMBundle::getModule(
+    uint32_t moduleId) const {
+  Module ret;
+  ret.name = std::to_string(moduleId) + ".js";
+  ret.code = getModuleCode(moduleId);
+  return ret;
+}
+
+std::unique_ptr<const JSBigString> JSIndexedRAMBundle::getStartupCode() {
+  CHECK(m_startupCode)
+      << "startup code for a RAM Bundle can only be retrieved once";
+  return std::move(m_startupCode);
+}
+
+std::string JSIndexedRAMBundle::getModuleCode(const uint32_t id) const {
+  const auto moduleData = id < m_table.numEntries ? &m_table.data[id] : nullptr;
+
+  // entries without associated code have offset = 0 and length = 0
+  const uint32_t length =
+      moduleData != nullptr ? folly::Endian::little(moduleData->length) : 0;
+  if (length == 0) {
+    throw std::ios_base::failure(
+        "Error loading module" + std::to_string(id) + "from RAM Bundle");
+  }
+
+  std::string ret(length - 1, '\0');
+  readBundle(
+      &ret.front(),
+      length - 1,
+      m_baseOffset + folly::Endian::little(moduleData->offset));
+  return ret;
+}
+
+void JSIndexedRAMBundle::readBundle(char* buffer, const std::streamsize bytes)
+    const {
+  if (!m_bundle->read(buffer, bytes)) {
+    if ((m_bundle->rdstate() & std::ios::eofbit) != 0) {
+      throw std::ios_base::failure("Unexpected end of RAM Bundle file");
+    }
+    throw std::ios_base::failure(
+        "Error reading RAM Bundle: " + std::to_string(m_bundle->rdstate()));
+  }
+}
+
+void JSIndexedRAMBundle::readBundle(
+    char* buffer,
+    const std::streamsize bytes,
+    const std::ifstream::pos_type position) const {
+  if (!m_bundle->seekg(position)) {
+    throw std::ios_base::failure(
+        "Error reading RAM Bundle: " + std::to_string(m_bundle->rdstate()));
+  }
+  readBundle(buffer, bytes);
+}
+
+} // namespace facebook::react
+
+#endif // RCT_REMOVE_LEGACY_ARCH
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/MethodCall.cpp

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+#include "MethodCall.h"
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+#include <folly/json.h>
+#include <stdexcept>
+
+namespace facebook::react {
+
+#define REQUEST_MODULE_IDS 0
+#define REQUEST_METHOD_IDS 1
+#define REQUEST_PARAMS 2
+#define REQUEST_CALLID 3
+
+static const char* errorPrefix = "Malformed calls from JS: ";
+
+std::vector<MethodCall> parseMethodCalls(folly::dynamic&& jsonData) {
+  if (jsonData.isNull()) {
+    return {};
+  }
+
+  if (!jsonData.isArray()) {
+    throw std::invalid_argument(
+        std::string(errorPrefix) + " input isn't array but " +
+        jsonData.typeName());
+  }
+
+  if (jsonData.size() < REQUEST_PARAMS + 1) {
+    throw std::invalid_argument(
+        std::string(errorPrefix) +
+        "size == " + std::to_string(jsonData.size()));
+  }
+
+  auto& moduleIds = jsonData[REQUEST_MODULE_IDS];
+  auto& methodIds = jsonData[REQUEST_METHOD_IDS];
+  auto& params = jsonData[REQUEST_PARAMS];
+  int callId = -1;
+
+  if (!moduleIds.isArray() || !methodIds.isArray() || !params.isArray()) {
+    throw std::invalid_argument(
+        std::string(errorPrefix) + "not all fields are arrays.\n\n" +
+        folly::toJson(jsonData));
+  }
+
+  if (moduleIds.size() != methodIds.size() ||
+      moduleIds.size() != params.size()) {
+    throw std::invalid_argument(
+        std::string(errorPrefix) + "field sizes are different.\n\n" +
+        folly::toJson(jsonData));
+  }
+
+  if (jsonData.size() > REQUEST_CALLID) {
+    if (!jsonData[REQUEST_CALLID].isNumber()) {
+      throw std::invalid_argument(
+          std::string(errorPrefix) + "invalid callId" +
+          jsonData[REQUEST_CALLID].typeName());
+    }
+    callId = (int)jsonData[REQUEST_CALLID].asInt();
+  }
+
+  std::vector<MethodCall> methodCalls;
+  for (size_t i = 0; i < moduleIds.size(); i++) {
+    if (!params[i].isArray()) {
+      throw std::invalid_argument(
+          std::string(errorPrefix) + "method arguments isn't array but " +
+          params[i].typeName());
+    }
+
+    methodCalls.emplace_back(
+        static_cast<int>(moduleIds[i].asInt()),
+        static_cast<int>(methodIds[i].asInt()),
+        std::move(params[i]),
+        callId);
+
+    // only increment callid if contains valid callid as callid is optional
+    callId += (callId != -1) ? 1 : 0;
+  }
+
+  return methodCalls;
+}
+
+} // namespace facebook::react
+
+#endif // RCT_REMOVE_LEGACY_ARCH
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif