expo-dev-menu 2.2.0 → 3.0.0

package/vendored/react-native-reanimated/Common/cpp/SharedItems/ShareableValue.cpp

@@ -1,512 +0,0 @@
-#include <cxxabi.h>
-#include <utility>
-
-#include "DevMenuFrozenObject.h"
-#include "DevMenuMutableValue.h"
-#include "DevMenuMutableValueSetterProxy.h"
-#include "DevMenuRemoteObject.h"
-#include "DevMenuRuntimeDecorator.h"
-#include "DevMenuRuntimeManager.h"
-#include "DevMenuShareableValue.h"
-#include "DevMenuSharedParent.h"
-
-namespace devmenureanimated {
-class ShareableValue;
-const char *HIDDEN_HOST_OBJECT_PROP = "__reanimatedHostObjectRef";
-const char *ALREADY_CONVERTED = "__alreadyConverted";
-const char *CALL_ASYNC = "__callAsync";
-const char *PRIMAL_FUNCTION = "__primalFunction";
-const char *CALLBACK_ERROR_SUFFIX =
-    "\n\nPossible solutions are:\n"
-    "a) If you want to synchronously execute this method, mark it as a Worklet\n"
-    "b) If you want to execute this method on the JS thread, wrap it using runOnJS";
-
-void addHiddenProperty(
-    jsi::Runtime &rt,
-    jsi::Value &&value,
-    const jsi::Object &obj,
-    const char *name) {
-  jsi::Object globalObject = rt.global().getPropertyAsObject(rt, "Object");
-  jsi::Function defineProperty =
-      globalObject.getPropertyAsFunction(rt, "defineProperty");
-  jsi::String internalPropName = jsi::String::createFromUtf8(rt, name);
-  jsi::Object paramForDefineProperty(rt);
-  paramForDefineProperty.setProperty(rt, "enumerable", false);
-  paramForDefineProperty.setProperty(rt, "value", value);
-  defineProperty.call(rt, obj, internalPropName, paramForDefineProperty);
-}
-
-void freeze(jsi::Runtime &rt, const jsi::Object &obj) {
-  jsi::Object globalObject = rt.global().getPropertyAsObject(rt, "Object");
-  jsi::Function freeze = globalObject.getPropertyAsFunction(rt, "freeze");
-  freeze.call(rt, obj);
-}
-
-void ShareableValue::adaptCache(jsi::Runtime &rt, const jsi::Value &value) {
-  // when adapting from host object we can assign cached value immediately such
-  // that we avoid running `toJSValue` in the future when given object is
-  // accessed
-  if (RuntimeDecorator::isWorkletRuntime(rt)) {
-    if (remoteValue.expired()) {
-      remoteValue = getWeakRef(rt);
-    }
-    (*remoteValue.lock()) = jsi::Value(rt, value);
-  } else {
-    hostValue = std::make_unique<jsi::Value>(rt, value);
-  }
-}
-
-void ShareableValue::adapt(
-    jsi::Runtime &rt,
-    const jsi::Value &value,
-    ValueType objectType) {
-  if (value.isObject()) {
-    jsi::Object object = value.asObject(rt);
-    jsi::Value hiddenValue = object.getProperty(rt, HIDDEN_HOST_OBJECT_PROP);
-    if (!(hiddenValue.isUndefined())) {
-      jsi::Object hiddenProperty = hiddenValue.asObject(rt);
-      if (hiddenProperty.isHostObject<FrozenObject>(rt)) {
-        type = ValueType::FrozenObjectType;
-        if (object.hasProperty(rt, "__workletHash") && object.isFunction(rt)) {
-          type = ValueType::WorkletFunctionType;
-        }
-        valueContainer = std::make_unique<FrozenObjectWrapper>(
-            hiddenProperty.getHostObject<FrozenObject>(rt));
-        if (object.hasProperty(rt, ALREADY_CONVERTED)) {
-          adaptCache(rt, value);
-        }
-        return;
-      }
-    }
-  }
-
-  if (objectType == ValueType::MutableValueType) {
-    type = ValueType::MutableValueType;
-    valueContainer =
-        std::make_unique<MutableValueWrapper>(std::make_shared<MutableValue>(
-            rt, value, runtimeManager, runtimeManager->scheduler));
-  } else if (value.isUndefined()) {
-    type = ValueType::UndefinedType;
-  } else if (value.isNull()) {
-    type = ValueType::NullType;
-  } else if (value.isBool()) {
-    type = ValueType::BoolType;
-    valueContainer = std::make_unique<BooleanValueWrapper>(value.getBool());
-  } else if (value.isNumber()) {
-    type = ValueType::NumberType;
-    valueContainer = std::make_unique<NumberValueWrapper>(value.asNumber());
-  } else if (value.isString()) {
-    type = ValueType::StringType;
-    valueContainer =
-        std::make_unique<StringValueWrapper>(value.asString(rt).utf8(rt));
-  } else if (value.isObject()) {
-    auto object = value.asObject(rt);
-    if (object.isFunction(rt)) {
-      if (object.getProperty(rt, "__workletHash").isUndefined()) {
-        // not a worklet, we treat this as a host function
-        type = ValueType::HostFunctionType;
-        containsHostFunction = true;
-
-        // Check if it's a hostFunction wrapper
-        jsi::Value primalFunction = object.getProperty(rt, PRIMAL_FUNCTION);
-        if (!primalFunction.isUndefined()) {
-          jsi::Object handlerAsObject = primalFunction.asObject(rt);
-          std::shared_ptr<HostFunctionHandler> handler =
-              handlerAsObject.getHostObject<HostFunctionHandler>(rt);
-          valueContainer = std::make_unique<HostFunctionWrapper>(handler);
-        } else {
-          valueContainer = std::make_unique<HostFunctionWrapper>(
-              std::make_shared<HostFunctionHandler>(
-                  std::make_shared<jsi::Function>(object.asFunction(rt)), rt));
-        }
-
-      } else {
-        // a worklet
-        type = ValueType::WorkletFunctionType;
-        valueContainer = std::make_unique<FrozenObjectWrapper>(
-            std::make_shared<FrozenObject>(rt, object, runtimeManager));
-        auto &frozenObject = ValueWrapper::asFrozenObject(valueContainer);
-        containsHostFunction |= frozenObject->containsHostFunction;
-        if (RuntimeDecorator::isReactRuntime(rt) && !containsHostFunction) {
-          addHiddenProperty(
-              rt,
-              createHost(rt, frozenObject),
-              object,
-              HIDDEN_HOST_OBJECT_PROP);
-        }
-      }
-    } else if (object.isArray(rt)) {
-      type = ValueType::FrozenArrayType;
-      auto array = object.asArray(rt);
-      valueContainer = std::make_unique<FrozenArrayWrapper>();
-      auto &frozenArray = ValueWrapper::asFrozenArray(valueContainer);
-      for (size_t i = 0, size = array.size(rt); i < size; i++) {
-        auto sv = adapt(rt, array.getValueAtIndex(rt, i), runtimeManager);
-        containsHostFunction |= sv->containsHostFunction;
-        frozenArray.push_back(sv);
-      }
-    } else if (object.isHostObject<MutableValue>(rt)) {
-      type = ValueType::MutableValueType;
-      valueContainer = std::make_unique<MutableValueWrapper>(
-          object.getHostObject<MutableValue>(rt));
-      adaptCache(rt, value);
-    } else if (object.isHostObject<RemoteObject>(rt)) {
-      type = ValueType::RemoteObjectType;
-      valueContainer = std::make_unique<RemoteObjectWrapper>(
-          object.getHostObject<RemoteObject>(rt));
-      adaptCache(rt, value);
-    } else if (objectType == ValueType::RemoteObjectType) {
-      type = ValueType::RemoteObjectType;
-      valueContainer =
-          std::make_unique<RemoteObjectWrapper>(std::make_shared<RemoteObject>(
-              rt, object, runtimeManager, runtimeManager->scheduler));
-    } else {
-      // create frozen object based on a copy of a given object
-      type = ValueType::FrozenObjectType;
-      valueContainer = std::make_unique<FrozenObjectWrapper>(
-          std::make_shared<FrozenObject>(rt, object, runtimeManager));
-      auto &frozenObject = ValueWrapper::asFrozenObject(valueContainer);
-      containsHostFunction |= frozenObject->containsHostFunction;
-      if (RuntimeDecorator::isReactRuntime(rt)) {
-        if (!containsHostFunction) {
-          addHiddenProperty(
-              rt,
-              createHost(rt, frozenObject),
-              object,
-              HIDDEN_HOST_OBJECT_PROP);
-        }
-        freeze(rt, object);
-      }
-    }
-  } else if (value.isSymbol()) {
-    type = ValueType::StringType;
-    valueContainer =
-        std::make_unique<StringValueWrapper>(value.asSymbol(rt).toString(rt));
-  } else {
-    throw "Invalid value type";
-  }
-}
-
-std::shared_ptr<ShareableValue> ShareableValue::adapt(
-    jsi::Runtime &rt,
-    const jsi::Value &value,
-    RuntimeManager *runtimeManager,
-    ValueType valueType) {
-  auto sv = std::shared_ptr<ShareableValue>(
-      new ShareableValue(runtimeManager, runtimeManager->scheduler));
-  sv->adapt(rt, value, valueType);
-  return sv;
-}
-
-jsi::Value ShareableValue::getValue(jsi::Runtime &rt) {
-  // TODO: maybe we can cache toJSValue results on a per-runtime basis, need to
-  // avoid ref loops
-  if (&rt == runtimeManager->runtime.get()) {
-    // Getting value on the same runtime where it was created, prepare
-    // remoteValue
-    if (remoteValue.expired()) {
-      remoteValue = getWeakRef(rt);
-    }
-
-    if (remoteValue.lock()->isUndefined()) {
-      (*remoteValue.lock()) = toJSValue(rt);
-    }
-    return jsi::Value(rt, *remoteValue.lock());
-  } else {
-    // Getting value on a different runtime than where it was created from,
-    // prepare hostValue
-    if (hostValue.get() == nullptr) {
-      hostValue = std::make_unique<jsi::Value>(toJSValue(rt));
-    }
-    return jsi::Value(rt, *hostValue);
-  }
-}
-
-jsi::Object ShareableValue::createHost(
-    jsi::Runtime &rt,
-    std::shared_ptr<jsi::HostObject> host) {
-  return jsi::Object::createFromHostObject(rt, host);
-}
-
-jsi::Value createFrozenWrapper(
-    jsi::Runtime &rt,
-    std::shared_ptr<FrozenObject> frozenObject) {
-  jsi::Object __reanimatedHiddenHost =
-      jsi::Object::createFromHostObject(rt, frozenObject);
-  jsi::Object obj = frozenObject->shallowClone(rt);
-  jsi::Object globalObject = rt.global().getPropertyAsObject(rt, "Object");
-  jsi::Function freeze = globalObject.getPropertyAsFunction(rt, "freeze");
-  if (!frozenObject->containsHostFunction) {
-    addHiddenProperty(
-        rt, std::move(__reanimatedHiddenHost), obj, HIDDEN_HOST_OBJECT_PROP);
-    addHiddenProperty(rt, true, obj, ALREADY_CONVERTED);
-  }
-  return freeze.call(rt, obj);
-}
-
-jsi::Value ShareableValue::toJSValue(jsi::Runtime &rt) {
-  switch (type) {
-    case ValueType::UndefinedType:
-      return jsi::Value::undefined();
-    case ValueType::NullType:
-      return jsi::Value::null();
-    case ValueType::BoolType:
-      return jsi::Value(ValueWrapper::asBoolean(valueContainer));
-    case ValueType::NumberType:
-      return jsi::Value(ValueWrapper::asNumber(valueContainer));
-    case ValueType::StringType: {
-      auto &stringValue = ValueWrapper::asString(valueContainer);
-      return jsi::Value(rt, jsi::String::createFromUtf8(rt, stringValue));
-    }
-    case ValueType::FrozenObjectType: {
-      auto &frozenObject = ValueWrapper::asFrozenObject(valueContainer);
-      return createFrozenWrapper(rt, frozenObject);
-    }
-    case ValueType::FrozenArrayType: {
-      auto &frozenArray = ValueWrapper::asFrozenArray(valueContainer);
-      jsi::Array array(rt, frozenArray.size());
-      for (size_t i = 0; i < frozenArray.size(); i++) {
-        array.setValueAtIndex(rt, i, frozenArray[i]->toJSValue(rt));
-      }
-      return array;
-    }
-    case ValueType::RemoteObjectType: {
-      auto &remoteObject = ValueWrapper::asRemoteObject(valueContainer);
-      if (RuntimeDecorator::isWorkletRuntime(rt)) {
-        remoteObject->maybeInitializeOnWorkletRuntime(rt);
-      }
-      return createHost(rt, remoteObject);
-    }
-    case ValueType::MutableValueType: {
-      auto &mutableObject = ValueWrapper::asMutableValue(valueContainer);
-      return createHost(rt, mutableObject);
-    }
-    case ValueType::HostFunctionType: {
-      auto hostFunctionWrapper =
-          ValueWrapper::asHostFunctionWrapper(valueContainer);
-      auto &hostRuntime = hostFunctionWrapper->value->hostRuntime;
-      if (hostRuntime == &rt) {
-        // function is accessed from the same runtime it was crated, we just
-        // return same function obj
-        return jsi::Value(
-            rt, *hostFunctionWrapper->value->getPureFunction().get());
-      } else {
-        // function is accessed from a different runtime, we wrap function in
-        // host func that'd enqueue call on an appropriate thread
-
-        auto runtimeManager = this->runtimeManager;
-        auto hostFunction = hostFunctionWrapper->value;
-
-        auto warnFunction = [runtimeManager, hostFunction](
-                                jsi::Runtime &rt,
-                                const jsi::Value &thisValue,
-                                const jsi::Value *args,
-                                size_t count) -> jsi::Value {
-          jsi::Value jsThis = rt.global().getProperty(rt, "jsThis");
-          std::string workletLocation = jsThis.asObject(rt)
-                                            .getProperty(rt, "__location")
-                                            .toString(rt)
-                                            .utf8(rt);
-          std::string exceptionMessage = "Tried to synchronously call ";
-          if (hostFunction->functionName.empty()) {
-            exceptionMessage += "anonymous function";
-          } else {
-            exceptionMessage += "function {" + hostFunction->functionName + "}";
-          }
-          exceptionMessage +=
-              " from a different thread.\n\nOccurred in worklet location: ";
-          exceptionMessage += workletLocation;
-          exceptionMessage += CALLBACK_ERROR_SUFFIX;
-          runtimeManager->errorHandler->setError(exceptionMessage);
-          runtimeManager->errorHandler->raise();
-
-          return jsi::Value::undefined();
-        };
-
-        auto clb = [runtimeManager, hostFunction, hostRuntime](
-                       jsi::Runtime &rt,
-                       const jsi::Value &thisValue,
-                       const jsi::Value *args,
-                       size_t count) -> jsi::Value {
-          // TODO: we should find thread based on runtime such that we could
-          // also call UI methods from RN and not only RN methods from UI
-
-          std::vector<std::shared_ptr<ShareableValue>> params;
-          for (int i = 0; i < count; ++i) {
-            params.push_back(
-                ShareableValue::adapt(rt, args[i], runtimeManager));
-          }
-
-          std::function<void()> job = [hostFunction, hostRuntime, params] {
-            jsi::Value *args = new jsi::Value[params.size()];
-            for (int i = 0; i < params.size(); ++i) {
-              args[i] = params[i]->getValue(*hostRuntime);
-            }
-            jsi::Value returnedValue =
-                hostFunction->getPureFunction().get()->call(
-                    *hostRuntime,
-                    static_cast<const jsi::Value *>(args),
-                    static_cast<size_t>(params.size()));
-
-            delete[] args;
-            // ToDo use returned value to return promise
-          };
-
-          runtimeManager->scheduler->scheduleOnJS(job);
-          return jsi::Value::undefined();
-        };
-        jsi::Function wrapperFunction = jsi::Function::createFromHostFunction(
-            rt, jsi::PropNameID::forAscii(rt, "hostFunction"), 0, warnFunction);
-        jsi::Function res = jsi::Function::createFromHostFunction(
-            rt, jsi::PropNameID::forAscii(rt, "hostFunction"), 0, clb);
-        addHiddenProperty(rt, std::move(res), wrapperFunction, CALL_ASYNC);
-        jsi::Object functionHandler =
-            createHost(rt, hostFunctionWrapper->value);
-        addHiddenProperty(
-            rt, std::move(functionHandler), wrapperFunction, PRIMAL_FUNCTION);
-        return wrapperFunction;
-      }
-    }
-    case ValueType::WorkletFunctionType: {
-      auto runtimeManager = this->runtimeManager;
-      auto &frozenObject = ValueWrapper::asFrozenObject(this->valueContainer);
-      if (RuntimeDecorator::isWorkletRuntime(rt)) {
-        // when running on worklet thread we prep a function
-
-        auto jsThis = std::make_shared<jsi::Object>(
-            frozenObject->shallowClone(*runtimeManager->runtime));
-        std::shared_ptr<jsi::Function> funPtr(
-            runtimeManager->workletsCache->getFunction(rt, frozenObject));
-        auto name = funPtr->getProperty(rt, "name").asString(rt).utf8(rt);
-
-        auto clb = [=](jsi::Runtime &rt,
-                       const jsi::Value &thisValue,
-                       const jsi::Value *args,
-                       size_t count) mutable -> jsi::Value {
-          const jsi::String jsThisName =
-              jsi::String::createFromAscii(rt, "jsThis");
-          jsi::Object global = rt.global();
-          jsi::Value oldJSThis = global.getProperty(rt, jsThisName);
-          global.setProperty(rt, jsThisName, *jsThis); // set jsThis
-
-          jsi::Value res = jsi::Value::undefined();
-          try {
-            if (thisValue.isObject()) {
-              res =
-                  funPtr->callWithThis(rt, thisValue.asObject(rt), args, count);
-            } else {
-              res = funPtr->call(rt, args, count);
-            }
-          } catch (std::exception &e) {
-            std::string str = e.what();
-            runtimeManager->errorHandler->setError(str);
-            runtimeManager->errorHandler->raise();
-          } catch (...) {
-            if (demangleExceptionName(
-                    abi::__cxa_current_exception_type()->name()) ==
-                "facebook::jsi::JSError") {
-              throw jsi::JSError(rt, "Javascript worklet error");
-            }
-            // TODO find out a way to get the error's message on hermes
-            jsi::Value location = jsThis->getProperty(rt, "__location");
-            std::string str = "Javascript worklet error";
-            if (location.isString()) {
-              str += "\nIn file: " + location.asString(rt).utf8(rt);
-            }
-            runtimeManager->errorHandler->setError(str);
-            runtimeManager->errorHandler->raise();
-          }
-          global.setProperty(rt, jsThisName, oldJSThis); // clean jsThis
-          return res;
-        };
-        return jsi::Function::createFromHostFunction(
-            rt, jsi::PropNameID::forAscii(rt, name.c_str()), 0, clb);
-      } else {
-        // when run outside of UI thread we enqueue a call on the UI thread
-        auto clb = [=](jsi::Runtime &rt,
-                       const jsi::Value &thisValue,
-                       const jsi::Value *args,
-                       size_t count) -> jsi::Value {
-          // TODO: we should find thread based on runtime such that we could
-          // also call UI methods from RN and not only RN methods from UI
-
-          std::vector<std::shared_ptr<ShareableValue>> params;
-          for (int i = 0; i < count; ++i) {
-            params.push_back(
-                ShareableValue::adapt(rt, args[i], runtimeManager));
-          }
-
-          runtimeManager->scheduler->scheduleOnUI([=] {
-            jsi::Runtime &rt = *runtimeManager->runtime.get();
-            auto jsThis = createFrozenWrapper(rt, frozenObject).getObject(rt);
-            auto code =
-                jsThis.getProperty(rt, "asString").asString(rt).utf8(rt);
-            std::shared_ptr<jsi::Function> funPtr(
-                runtimeManager->workletsCache->getFunction(rt, frozenObject));
-
-            jsi::Value *args = new jsi::Value[params.size()];
-            for (int i = 0; i < params.size(); ++i) {
-              args[i] = params[i]->getValue(rt);
-            }
-
-            jsi::Value returnedValue;
-            const jsi::String jsThisName =
-                jsi::String::createFromAscii(rt, "jsThis");
-            jsi::Object global = rt.global();
-            jsi::Value oldJSThis = global.getProperty(rt, jsThisName);
-            global.setProperty(rt, jsThisName, jsThis); // set jsThis
-            try {
-              returnedValue = funPtr->call(
-                  rt,
-                  static_cast<const jsi::Value *>(args),
-                  static_cast<size_t>(params.size()));
-            } catch (std::exception &e) {
-              std::string str = e.what();
-              runtimeManager->errorHandler->setError(str);
-              runtimeManager->errorHandler->raise();
-            } catch (...) {
-              if (demangleExceptionName(
-                      abi::__cxa_current_exception_type()->name()) ==
-                  "facebook::jsi::JSError") {
-                throw jsi::JSError(rt, "Javascript worklet error");
-              }
-              // TODO find out a way to get the error's message on hermes
-              jsi::Value location = jsThis.getProperty(rt, "__location");
-              std::string str = "Javascript worklet error";
-              if (location.isString()) {
-                str += "\nIn file: " + location.asString(rt).utf8(rt);
-              }
-              runtimeManager->errorHandler->setError(str);
-              runtimeManager->errorHandler->raise();
-            }
-            global.setProperty(rt, jsThisName, oldJSThis); // clean jsThis
-
-            delete[] args;
-            // ToDo use returned value to return promise
-          });
-          return jsi::Value::undefined();
-        };
-        return jsi::Function::createFromHostFunction(
-            rt, jsi::PropNameID::forAscii(rt, "_workletFunction"), 0, clb);
-      }
-    }
-    default: {
-      throw "Unable to find conversion method for this type";
-    }
-  }
-  throw "convert error";
-}
-
-std::string ShareableValue::demangleExceptionName(std::string toDemangle) {
-  int status = 0;
-  char *buff =
-      __cxxabiv1::__cxa_demangle(toDemangle.c_str(), nullptr, nullptr, &status);
-  if (!buff) {
-    return toDemangle;
-  }
-  std::string demangled = buff;
-  std::free(buff);
-  return demangled;
-}
-
-} // namespace devmenureanimated

package/vendored/react-native-reanimated/Common/cpp/SpecTools/DevMenuErrorHandler.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include "DevMenuScheduler.h"
-
-namespace devmenureanimated {
-
-struct ErrorWrapper {
-  std::string message = "";
-  bool handled = true;
-};
-
-class ErrorHandler {
- public:
-  bool raise() {
-    if (getError()->handled) {
-      return false;
-    }
-    this->getScheduler()->scheduleOnUI([this]() mutable { this->raiseSpec(); });
-    return true;
-  }
-  virtual std::shared_ptr<Scheduler> getScheduler() = 0;
-  virtual std::shared_ptr<ErrorWrapper> getError() = 0;
-  virtual void setError(std::string message) = 0;
-  virtual ~ErrorHandler() {}
-
- protected:
-  virtual void raiseSpec() = 0;
-};
-
-} // namespace devmenureanimated

package/vendored/react-native-reanimated/Common/cpp/Tools/DevMenuFeaturesConfig.h

@@ -1,19 +0,0 @@
-#pragma once
-#include <string>
-
-namespace devmenureanimated {
-
-class FeaturesConfig {
- public:
-  static inline bool isLayoutAnimationEnabled() {
-    return _isLayoutAnimationEnabled;
-  }
-  static inline void setLayoutAnimationEnabled(bool isLayoutAnimationEnabled) {
-    _isLayoutAnimationEnabled = isLayoutAnimationEnabled;
-  }
-
- private:
-  static bool _isLayoutAnimationEnabled;
-};
-
-} // namespace devmenureanimated

package/vendored/react-native-reanimated/Common/cpp/Tools/DevMenuJSIStoreValueUser.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <stdio.h>
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <vector>
-#include "DevMenuScheduler.h"
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-class RuntimeManager;
-
-struct StaticStoreUser {
-  std::atomic<int> ctr;
-  std::unordered_map<int, std::vector<std::shared_ptr<jsi::Value>>> store;
-  std::recursive_mutex storeMutex;
-};
-
-class StoreUser {
-  int identifier = 0;
-  std::weak_ptr<Scheduler> scheduler;
-  std::shared_ptr<StaticStoreUser> storeUserData;
-
- public:
-  StoreUser(std::shared_ptr<Scheduler> s, const RuntimeManager &runtimeManager);
-
-  std::weak_ptr<jsi::Value> getWeakRef(jsi::Runtime &rt);
-  void removeRefs();
-
-  virtual ~StoreUser();
-};
-
-} // namespace devmenureanimated

package/vendored/react-native-reanimated/Common/cpp/Tools/DevMenuMapper.h

@@ -1,51 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <stdio.h>
-#include <memory>
-#include <vector>
-#include "DevMenuNativeReanimatedModule.h"
-#include "DevMenuShareableValue.h"
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-class MapperRegistry;
-
-struct ViewDescriptor {
-  int tag;
-  jsi::Value name;
-};
-
-class Mapper : public std::enable_shared_from_this<Mapper> {
-  friend MapperRegistry;
-
- private:
-  unsigned long id;
-  NativeReanimatedModule *module;
-  std::shared_ptr<jsi::Function> mapper;
-  std::vector<std::shared_ptr<MutableValue>> inputs;
-  std::vector<std::shared_ptr<MutableValue>> outputs;
-  bool dirty = true;
-  std::shared_ptr<jsi::Function> userUpdater;
-  UpdaterFunction *updateProps;
-  int optimalizationLvl = 0;
-  std::shared_ptr<ShareableValue> viewDescriptors;
-
- public:
-  Mapper(
-      NativeReanimatedModule *module,
-      unsigned long id,
-      std::shared_ptr<jsi::Function> mapper,
-      std::vector<std::shared_ptr<MutableValue>> inputs,
-      std::vector<std::shared_ptr<MutableValue>> outputs);
-  void execute(jsi::Runtime &rt);
-  void enableFastMode(
-      const int optimalizationLvl,
-      const std::shared_ptr<ShareableValue> &updater,
-      const std::shared_ptr<ShareableValue> &jsViewDescriptors);
-  virtual ~Mapper();
-};
-
-} // namespace devmenureanimated