react-native-windows 0.84.0 → 0.85.0-preview.2

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/ModuleRegistry.cpp

@@ -1,256 +0,0 @@
-/*
- * 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 "ModuleRegistry.h"
-
-#ifndef RCT_REMOVE_LEGACY_ARCH
-
-#include <glog/logging.h>
-#include <reactperflogger/BridgeNativeModulePerfLogger.h>
-#include <utility>
-
-#include "NativeModule.h"
-#include "TraceSection.h"
-
-namespace facebook::react {
-
-namespace {
-
-std::string normalizeName(std::string name) {
-  // TODO mhorowitz #10487027: This is super ugly.  We should just
-  // change iOS to emit normalized names, drop the "RK..." from
-  // names hardcoded in Android, and then delete this and the
-  // similar hacks in js.
-  if (name.compare(0, 3, "RCT") == 0) {
-    return name.substr(3);
-  } else if (name.compare(0, 2, "RK") == 0) {
-    return name.substr(2);
-  }
-  return name;
-}
-
-} // namespace
-
-ModuleRegistry::ModuleRegistry(
-    std::vector<std::unique_ptr<NativeModule>> modules,
-    ModuleNotFoundCallback callback)
-    : modules_{std::move(modules)},
-      moduleNotFoundCallback_{std::move(callback)} {}
-
-void ModuleRegistry::updateModuleNamesFromIndex(size_t index) {
-  for (; index < modules_.size(); index++) {
-    std::string name = normalizeName(modules_[index]->getName());
-    modulesByName_[name] = index;
-  }
-}
-
-void ModuleRegistry::registerModules(
-    std::vector<std::unique_ptr<NativeModule>> modules) {
-  TraceSection s_("ModuleRegistry::registerModules");
-  // Noop if there are no NativeModules to add
-  if (modules.empty()) {
-    return;
-  }
-
-  if (modules_.empty() && unknownModules_.empty()) {
-    modules_ = std::move(modules);
-  } else {
-    size_t modulesSize = modules_.size();
-    size_t addModulesSize = modules.size();
-    bool addToNames = !modulesByName_.empty();
-    modules_.reserve(modulesSize + addModulesSize);
-    std::move(modules.begin(), modules.end(), std::back_inserter(modules_));
-    if (!unknownModules_.empty()) {
-      for (size_t index = modulesSize; index < modulesSize + addModulesSize;
-           index++) {
-        std::string name = normalizeName(modules_[index]->getName());
-        auto it = unknownModules_.find(name);
-        if (it != unknownModules_.end()) {
-          throw std::runtime_error(
-              "module " + name +
-              " was required without being registered and is now being registered.");
-        } else if (addToNames) {
-          modulesByName_[name] = index;
-        }
-      }
-    } else if (addToNames) {
-      updateModuleNamesFromIndex(modulesSize);
-    }
-  }
-}
-
-std::vector<std::string> ModuleRegistry::moduleNames() {
-  TraceSection s_("ModuleRegistry::moduleNames");
-  std::vector<std::string> names;
-  for (size_t i = 0; i < modules_.size(); i++) {
-    std::string name = normalizeName(modules_[i]->getName());
-    modulesByName_[name] = i;
-    names.push_back(std::move(name));
-  }
-  return names;
-}
-
-std::optional<ModuleConfig> ModuleRegistry::getConfig(const std::string& name) {
-  TraceSection s("ModuleRegistry::getConfig", "module", name);
-
-  // Initialize modulesByName_
-  if (modulesByName_.empty() && !modules_.empty()) {
-    moduleNames();
-  }
-
-  auto it = modulesByName_.find(name);
-
-  if (it == modulesByName_.end()) {
-    if (unknownModules_.find(name) != unknownModules_.end()) {
-      BridgeNativeModulePerfLogger::moduleJSRequireBeginningFail(name.c_str());
-      BridgeNativeModulePerfLogger::moduleJSRequireEndingStart(name.c_str());
-      return std::nullopt;
-    }
-
-    if (!moduleNotFoundCallback_) {
-      unknownModules_.insert(name);
-      BridgeNativeModulePerfLogger::moduleJSRequireBeginningFail(name.c_str());
-      BridgeNativeModulePerfLogger::moduleJSRequireEndingStart(name.c_str());
-      return std::nullopt;
-    }
-
-    BridgeNativeModulePerfLogger::moduleJSRequireBeginningEnd(name.c_str());
-
-    bool wasModuleLazilyLoaded = moduleNotFoundCallback_(name);
-    it = modulesByName_.find(name);
-
-    bool wasModuleRegisteredWithRegistry =
-        wasModuleLazilyLoaded && it != modulesByName_.end();
-
-    if (!wasModuleRegisteredWithRegistry) {
-      BridgeNativeModulePerfLogger::moduleJSRequireEndingStart(name.c_str());
-      unknownModules_.insert(name);
-      return std::nullopt;
-    }
-  } else {
-    BridgeNativeModulePerfLogger::moduleJSRequireBeginningEnd(name.c_str());
-  }
-
-  // If we've gotten this far, then we've signaled moduleJSRequireBeginningEnd
-
-  size_t index = it->second;
-
-  CHECK(index < modules_.size());
-  NativeModule* module = modules_[index].get();
-
-  // string name, object constants, array methodNames (methodId is index),
-  // [array promiseMethodIds], [array syncMethodIds]
-  folly::dynamic config = folly::dynamic::array(name);
-
-  {
-    TraceSection s_("ModuleRegistry::getConstants", "module", name);
-    /**
-     * In the case that there are constants, we'll initialize the NativeModule,
-     * and signal moduleJSRequireEndingStart. Otherwise, we'll simply signal the
-     * event. The Module will be initialized when we invoke one of its
-     * NativeModule methods.
-     */
-    config.push_back(module->getConstants());
-  }
-
-  {
-    TraceSection s_("ModuleRegistry::getMethods", "module", name);
-    std::vector<MethodDescriptor> methods = module->getMethods();
-
-    folly::dynamic methodNames = folly::dynamic::array;
-    folly::dynamic promiseMethodIds = folly::dynamic::array;
-    folly::dynamic syncMethodIds = folly::dynamic::array;
-
-    for (auto& descriptor : methods) {
-      // TODO: #10487027 compare tags instead of doing string comparison?
-      methodNames.push_back(std::move(descriptor.name));
-      if (descriptor.type == "promise") {
-        promiseMethodIds.push_back(methodNames.size() - 1);
-      } else if (descriptor.type == "sync") {
-        syncMethodIds.push_back(methodNames.size() - 1);
-      }
-    }
-
-    if (!methodNames.empty()) {
-      config.push_back(std::move(methodNames));
-      if (!promiseMethodIds.empty() || !syncMethodIds.empty()) {
-        config.push_back(std::move(promiseMethodIds));
-        if (!syncMethodIds.empty()) {
-          config.push_back(std::move(syncMethodIds));
-        }
-      }
-    }
-  }
-
-  if (config.size() == 2 && config[1].empty()) {
-    // no constants or methods
-    return std::nullopt;
-  } else {
-    return ModuleConfig{.index = index, .config = std::move(config)};
-  }
-}
-
-std::string ModuleRegistry::getModuleName(unsigned int moduleId) {
-  if (moduleId >= modules_.size()) {
-    throw std::runtime_error(
-        "moduleId " + std::to_string(moduleId) + " out of range [0.." +
-        std::to_string(modules_.size()) + ")");
-  }
-
-  return modules_[moduleId]->getName();
-}
-
-std::string ModuleRegistry::getModuleSyncMethodName(
-    unsigned int moduleId,
-    unsigned int methodId) {
-  if (moduleId >= modules_.size()) {
-    throw std::runtime_error(
-        "moduleId " + std::to_string(moduleId) + " out of range [0.." +
-        std::to_string(modules_.size()) + ")");
-  }
-
-  return modules_[moduleId]->getSyncMethodName(methodId);
-}
-
-void ModuleRegistry::callNativeMethod(
-    unsigned int moduleId,
-    unsigned int methodId,
-    folly::dynamic&& params,
-    int callId) {
-  if (moduleId >= modules_.size()) {
-    throw std::runtime_error(
-        "moduleId " + std::to_string(moduleId) + " out of range [0.." +
-        std::to_string(modules_.size()) + ")");
-  }
-  modules_[moduleId]->invoke(methodId, std::move(params), callId);
-}
-
-MethodCallResult ModuleRegistry::callSerializableNativeHook(
-    unsigned int moduleId,
-    unsigned int methodId,
-    folly::dynamic&& params) {
-  if (moduleId >= modules_.size()) {
-    throw std::runtime_error(
-        "moduleId " + std::to_string(moduleId) + " out of range [0.." +
-        std::to_string(modules_.size()) + ")");
-  }
-  return modules_[moduleId]->callSerializableNativeHook(
-      methodId, std::move(params));
-}
-
-} // namespace facebook::react
-
-#endif // RCT_REMOVE_LEGACY_ARCH
-
-#if _MSC_VER
-#pragma warning(pop)
-#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/NativeToJsBridge.cpp

@@ -1,363 +0,0 @@
-/*
- * 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 "NativeToJsBridge.h"
-
-#ifndef RCT_REMOVE_LEGACY_ARCH
-
-#include <ReactCommon/CallInvoker.h>
-#include <folly/json.h>
-#include <glog/logging.h>
-#include <jsi/jsi.h>
-#include <reactperflogger/BridgeNativeModulePerfLogger.h>
-
-#include "ErrorUtils.h"
-#include "Instance.h"
-#include "JSBigString.h"
-#include "MessageQueueThread.h"
-#include "MethodCall.h"
-#include "ModuleRegistry.h"
-#include "MoveWrapper.h"
-#include "RAMBundleRegistry.h"
-#include "TraceSection.h"
-
-#include <memory>
-#include <utility>
-
-#ifdef WITH_FBSYSTRACE
-#include <fbsystrace.h>
-
-using fbsystrace::FbSystraceAsyncFlow;
-#endif
-
-namespace facebook::react {
-
-// This class manages calls from JS to native code.
-class [[deprecated(
-    "This API will be removed along with the legacy architecture.")]]
-JsToNativeBridge : public react::ExecutorDelegate {
- public:
-  JsToNativeBridge(
-      std::shared_ptr<ModuleRegistry> registry,
-      std::shared_ptr<InstanceCallback> callback)
-      : m_registry(std::move(registry)), m_callback(std::move(callback)) {}
-
-  std::shared_ptr<ModuleRegistry> getModuleRegistry() override {
-    return m_registry;
-  }
-
-  bool isBatchActive() {
-    return m_batchHadNativeModuleOrTurboModuleCalls;
-  }
-
-  void callNativeModules(
-      [[maybe_unused]] JSExecutor& executor,
-      folly::dynamic&& calls,
-      bool isEndOfBatch) override {
-    CHECK(m_registry || calls.empty())
-        << "native module calls cannot be completed with no native modules";
-    m_batchHadNativeModuleOrTurboModuleCalls =
-        m_batchHadNativeModuleOrTurboModuleCalls || !calls.empty();
-
-    std::vector<MethodCall> methodCalls = parseMethodCalls(std::move(calls));
-    BridgeNativeModulePerfLogger::asyncMethodCallBatchPreprocessEnd(
-        (int)methodCalls.size());
-
-    // An exception anywhere in here stops processing of the batch.  This
-    // was the behavior of the Android bridge, and since exception handling
-    // terminates the whole bridge, there's not much point in continuing.
-    for (auto& call : methodCalls) {
-      m_registry->callNativeMethod(
-          call.moduleId, call.methodId, std::move(call.arguments), call.callId);
-    }
-    if (isEndOfBatch) {
-      // onBatchComplete will be called on the native (module) queue, but
-      // decrementPendingJSCalls will be called sync. Be aware that the bridge
-      // may still be processing native calls when the bridge idle signaler
-      // fires.
-      if (m_batchHadNativeModuleOrTurboModuleCalls) {
-        m_callback->onBatchComplete();
-        m_batchHadNativeModuleOrTurboModuleCalls = false;
-      }
-      m_callback->decrementPendingJSCalls();
-    }
-  }
-
-  MethodCallResult callSerializableNativeHook(
-      [[maybe_unused]] JSExecutor& executor,
-      unsigned int moduleId,
-      unsigned int methodId,
-      folly::dynamic&& args) override {
-    return m_registry->callSerializableNativeHook(
-        moduleId, methodId, std::move(args));
-  }
-
-  void recordTurboModuleAsyncMethodCall() noexcept {
-    m_batchHadNativeModuleOrTurboModuleCalls = true;
-  }
-
- private:
-  // These methods are always invoked from an Executor.  The NativeToJsBridge
-  // keeps a reference to the executor, and when destroy() is called, the
-  // executor is destroyed synchronously on its queue.
-  std::shared_ptr<ModuleRegistry> m_registry;
-  std::shared_ptr<InstanceCallback> m_callback;
-  std::atomic<bool> m_batchHadNativeModuleOrTurboModuleCalls{false};
-};
-
-NativeToJsBridge::NativeToJsBridge(
-    JSExecutorFactory* jsExecutorFactory,
-    std::shared_ptr<ModuleRegistry> registry,
-    std::shared_ptr<MessageQueueThread> jsQueue,
-    std::shared_ptr<InstanceCallback> callback)
-    : m_destroyed(std::make_shared<bool>(false)),
-      m_delegate(std::make_shared<JsToNativeBridge>(registry, callback)),
-      m_executor(jsExecutorFactory->createJSExecutor(m_delegate, jsQueue)),
-      m_executorMessageQueueThread(std::move(jsQueue)),
-      m_inspectable(m_executor->isInspectable()) {}
-
-// This must be called on the same thread on which the constructor was called.
-NativeToJsBridge::~NativeToJsBridge() {
-  CHECK(*m_destroyed)
-      << "NativeToJsBridge::destroy() must be called before deallocating the NativeToJsBridge!";
-}
-
-void NativeToJsBridge::initializeRuntime() {
-  runOnExecutorQueue(
-      [](JSExecutor* executor) mutable { executor->initializeRuntime(); });
-}
-
-void NativeToJsBridge::loadBundle(
-    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
-    std::unique_ptr<const JSBigString> startupScript,
-    std::string startupScriptSourceURL) {
-  runOnExecutorQueue(
-      [this,
-       bundleRegistryWrap = makeMoveWrapper(std::move(bundleRegistry)),
-       startupScript = makeMoveWrapper(std::move(startupScript)),
-       startupScriptSourceURL =
-           std::move(startupScriptSourceURL)](JSExecutor* executor) mutable {
-        auto bundleRegistry = bundleRegistryWrap.move();
-        if (bundleRegistry) {
-          executor->setBundleRegistry(std::move(bundleRegistry));
-        }
-        try {
-          executor->loadBundle(
-              std::move(*startupScript), std::move(startupScriptSourceURL));
-        } catch (...) {
-          m_applicationScriptHasFailure = true;
-          throw;
-        }
-      });
-}
-
-void NativeToJsBridge::loadBundleSync(
-    std::unique_ptr<RAMBundleRegistry> bundleRegistry,
-    std::unique_ptr<const JSBigString> startupScript,
-    std::string startupScriptSourceURL) {
-  if (bundleRegistry) {
-    m_executor->setBundleRegistry(std::move(bundleRegistry));
-  }
-  try {
-    m_executor->loadBundle(
-        std::move(startupScript), std::move(startupScriptSourceURL));
-  } catch (...) {
-    m_applicationScriptHasFailure = true;
-    throw;
-  }
-}
-
-void NativeToJsBridge::callFunction(
-    std::string&& module,
-    std::string&& method,
-    folly::dynamic&& arguments) {
-  int systraceCookie = -1;
-#ifdef WITH_FBSYSTRACE
-  systraceCookie = m_systraceCookie++;
-  FbSystraceAsyncFlow::begin(TRACE_TAG_REACT_CXX_BRIDGE, "JSCall", systraceCookie); // [Windows] [issue #14819]
-#endif
-
-  runOnExecutorQueue([this,
-                      module = std::move(module),
-                      method = std::move(method),
-                      arguments = std::move(arguments),
-                      systraceCookie](JSExecutor* executor) {
-    if (m_applicationScriptHasFailure) {
-      LOG(ERROR)
-          << "Attempting to call JS function on a bad application bundle: "
-          << module.c_str() << "." << method.c_str() << "()";
-      throw std::runtime_error(
-          "Attempting to call JS function on a bad application bundle: " +
-          module + "." + method + "()");
-    }
-
-#ifdef WITH_FBSYSTRACE
-    FbSystraceAsyncFlow::end(TRACE_TAG_REACT_CXX_BRIDGE, "JSCall", systraceCookie); // [Windows] [issue #14819]
-    TraceSection s(
-        "NativeToJsBridge::callFunction", "module", module, "method", method);
-#else
-    (void)(systraceCookie);
-#endif
-    // This is safe because we are running on the executor's thread: it won't
-    // destruct until after it's been unregistered (which we check above) and
-    // that will happen on this thread
-    executor->callFunction(module, method, arguments);
-  });
-}
-
-void NativeToJsBridge::invokeCallback(
-    double callbackId,
-    folly::dynamic&& arguments) {
-  int systraceCookie = -1;
-#ifdef WITH_FBSYSTRACE
-  systraceCookie = m_systraceCookie++;
-  FbSystraceAsyncFlow::begin(TRACE_TAG_REACT_CXX_BRIDGE, "<callback>", systraceCookie); // [Windows] [issue #14819]
-#endif
-
-  runOnExecutorQueue(
-      [this, callbackId, arguments = std::move(arguments), systraceCookie](
-          JSExecutor* executor) {
-        if (m_applicationScriptHasFailure) {
-          LOG(ERROR)
-              << "Attempting to call JS callback on a bad application bundle: "
-              << callbackId;
-          throw std::runtime_error(
-              "Attempting to invoke JS callback on a bad application bundle.");
-        }
-#ifdef WITH_FBSYSTRACE
-        FbSystraceAsyncFlow::end(TRACE_TAG_REACT_CXX_BRIDGE, "<callback>", systraceCookie); // [Windows] [issue #14819]
-        TraceSection s("NativeToJsBridge::invokeCallback");
-#else
-        (void)(systraceCookie);
-#endif
-        executor->invokeCallback(callbackId, arguments);
-      });
-}
-
-void NativeToJsBridge::registerBundle(
-    uint32_t bundleId,
-    const std::string& bundlePath) {
-  runOnExecutorQueue([bundleId, bundlePath](JSExecutor* executor) {
-    executor->registerBundle(bundleId, bundlePath);
-  });
-}
-
-void NativeToJsBridge::setGlobalVariable(
-    std::string propName,
-    std::unique_ptr<const JSBigString> jsonValue) {
-  runOnExecutorQueue([propName = std::move(propName),
-                      jsonValue = makeMoveWrapper(std::move(jsonValue))](
-                         JSExecutor* executor) mutable {
-    executor->setGlobalVariable(propName, jsonValue.move());
-  });
-}
-
-void* NativeToJsBridge::getJavaScriptContext() {
-  // TODO(cjhopman): this seems unsafe unless we require that it is only called
-  // on the main js queue.
-  return m_executor->getJavaScriptContext();
-}
-
-bool NativeToJsBridge::isInspectable() {
-  return m_inspectable;
-}
-
-bool NativeToJsBridge::isBatchActive() {
-  return m_delegate->isBatchActive();
-}
-
-void NativeToJsBridge::handleMemoryPressure(int pressureLevel) {
-  runOnExecutorQueue([=](JSExecutor* executor) {
-    executor->handleMemoryPressure(pressureLevel);
-  });
-}
-
-void NativeToJsBridge::destroy() {
-  // All calls made through runOnExecutorQueue have an early exit if
-  // m_destroyed is true. Setting this before the runOnQueueSync will cause
-  // pending work to be cancelled and we won't have to wait for it.
-  *m_destroyed = true;
-  m_executorMessageQueueThread->runOnQueueSync([this] {
-    m_executor->destroy();
-    m_executorMessageQueueThread->quitSynchronous();
-    m_executor = nullptr;
-  });
-}
-
-void NativeToJsBridge::runOnExecutorQueue(
-    std::function<void(JSExecutor*)>&& task) noexcept {
-  if (*m_destroyed) {
-    return;
-  }
-
-  std::shared_ptr<bool> isDestroyed = m_destroyed;
-  m_executorMessageQueueThread->runOnQueue(
-      [this, isDestroyed, task = std::move(task)] {
-        if (*isDestroyed) {
-          return;
-        }
-
-        // The executor is guaranteed to be valid for the duration of the task
-        // because:
-        // 1. the executor is only destroyed after it is unregistered
-        // 2. the executor is unregistered on this queue
-        // 3. we just confirmed that the executor hasn't been unregistered above
-        task(m_executor.get());
-      });
-}
-
-std::shared_ptr<NativeMethodCallInvoker>
-NativeToJsBridge::getDecoratedNativeMethodCallInvoker(
-    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker) const {
-  class NativeMethodCallInvokerImpl : public NativeMethodCallInvoker {
-   private:
-    std::weak_ptr<JsToNativeBridge> m_jsToNativeBridge;
-    std::shared_ptr<NativeMethodCallInvoker> m_nativeInvoker;
-
-   public:
-    NativeMethodCallInvokerImpl(
-        std::weak_ptr<JsToNativeBridge> jsToNativeBridge,
-        std::shared_ptr<NativeMethodCallInvoker> nativeInvoker)
-        : m_jsToNativeBridge(std::move(jsToNativeBridge)),
-          m_nativeInvoker(std::move(nativeInvoker)) {}
-
-    void invokeAsync(
-        const std::string& methodName,
-        NativeMethodCallFunc&& func) noexcept override {
-      if (auto strongJsToNativeBridge = m_jsToNativeBridge.lock()) {
-        strongJsToNativeBridge->recordTurboModuleAsyncMethodCall();
-      }
-      m_nativeInvoker->invokeAsync(methodName, std::move(func));
-    }
-
-    void invokeSync(const std::string& methodName, NativeMethodCallFunc&& func)
-        override {
-      m_nativeInvoker->invokeSync(methodName, std::move(func));
-    }
-  };
-
-  return std::make_shared<NativeMethodCallInvokerImpl>(
-      m_delegate, std::move(nativeMethodCallInvoker));
-}
-
-jsinspector_modern::RuntimeTargetDelegate&
-NativeToJsBridge::getInspectorTargetDelegate() {
-  return m_executor->getRuntimeTargetDelegate();
-}
-
-} // namespace facebook::react
-
-#endif // RCT_REMOVE_LEGACY_ARCH
-
-#if _MSC_VER
-#pragma warning(pop)
-#endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/cxxreact/RAMBundleRegistry.cpp

@@ -1,93 +0,0 @@
-/*
- * 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 "RAMBundleRegistry.h"
-
-#ifndef RCT_REMOVE_LEGACY_ARCH
-
-#include <folly/String.h>
-
-#include <memory>
-
-namespace facebook::react {
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated"
-constexpr uint32_t RAMBundleRegistry::MAIN_BUNDLE_ID;
-#pragma clang diagnostic pop
-
-std::unique_ptr<RAMBundleRegistry> RAMBundleRegistry::singleBundleRegistry(
-    std::unique_ptr<JSModulesUnbundle> mainBundle) {
-  return std::make_unique<RAMBundleRegistry>(std::move(mainBundle));
-}
-
-std::unique_ptr<RAMBundleRegistry> RAMBundleRegistry::multipleBundlesRegistry(
-    std::unique_ptr<JSModulesUnbundle> mainBundle,
-    std::function<std::unique_ptr<JSModulesUnbundle>(std::string)> factory) {
-  return std::make_unique<RAMBundleRegistry>(
-      std::move(mainBundle), std::move(factory));
-}
-
-RAMBundleRegistry::RAMBundleRegistry(
-    std::unique_ptr<JSModulesUnbundle> mainBundle,
-    std::function<std::unique_ptr<JSModulesUnbundle>(std::string)> factory)
-    : m_factory(std::move(factory)) {
-  m_bundles.emplace(MAIN_BUNDLE_ID, std::move(mainBundle));
-}
-
-void RAMBundleRegistry::registerBundle(
-    uint32_t bundleId,
-    std::string bundlePath) {
-  m_bundlePaths.emplace(bundleId, std::move(bundlePath));
-}
-
-JSModulesUnbundle::Module RAMBundleRegistry::getModule(
-    uint32_t bundleId,
-    uint32_t moduleId) {
-  if (m_bundles.find(bundleId) == m_bundles.end()) {
-    if (!m_factory) {
-      throw std::runtime_error(
-          "You need to register factory function in order to "
-          "support multiple RAM bundles.");
-    }
-
-    auto bundlePath = m_bundlePaths.find(bundleId);
-    if (bundlePath == m_bundlePaths.end()) {
-      throw std::runtime_error(
-          "In order to fetch RAM bundle from the registry, its file "
-          "path needs to be registered first.");
-    }
-    m_bundles.emplace(bundleId, m_factory(bundlePath->second));
-  }
-
-  auto module = getBundle(bundleId)->getModule(moduleId);
-  if (bundleId == MAIN_BUNDLE_ID) {
-    return module;
-  }
-
-  return {
-      .name = "seg-" + std::to_string(bundleId) + '_' + module.name,
-      .code = std::move(module.code),
-  };
-}
-
-JSModulesUnbundle* RAMBundleRegistry::getBundle(uint32_t bundleId) const {
-  return m_bundles.at(bundleId).get();
-}
-
-} // namespace facebook::react
-
-#endif // RCT_REMOVE_LEGACY_ARCH
-
-#if _MSC_VER
-#pragma warning(pop)
-#endif