expo-dev-menu 2.1.4 → 3.0.0

package/vendored/react-native-reanimated/Common/cpp/SharedItems/DevMenuValueWrapper.h

@@ -1,158 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <memory>
-#include <string>
-#include <vector>
-#include "DevMenuHostFunctionHandler.h"
-#include "DevMenuJSIStoreValueUser.h"
-#include "DevMenuSharedParent.h"
-#include "DevMenuWorkletsCache.h"
-
-namespace devmenureanimated {
-
-class HostFunctionWrapper;
-class AnimatedSensorModule;
-
-class ValueWrapper {
-  friend AnimatedSensorModule;
-
- public:
-  ValueWrapper() {}
-  explicit ValueWrapper(ValueType _type) : type(_type) {}
-  ValueType getType() const {
-    return type;
-  }
-
-  virtual ~ValueWrapper() {}
-
-  static inline bool asBoolean(
-      const std::unique_ptr<ValueWrapper> &valueContainer);
-  static inline double asNumber(
-      const std::unique_ptr<ValueWrapper> &valueContainer);
-  static inline const std::string &asString(
-      const std::unique_ptr<ValueWrapper> &valueContainer);
-  static inline const std::shared_ptr<HostFunctionHandler> &asHostFunction(
-      const std::unique_ptr<ValueWrapper> &valueContainer);
-  static inline const std::shared_ptr<FrozenObject> &asFrozenObject(
-      const std::unique_ptr<ValueWrapper> &valueContainer);
-  static inline const std::shared_ptr<RemoteObject> &asRemoteObject(
-      const std::unique_ptr<ValueWrapper> &valueContainer);
-  static inline std::vector<std::shared_ptr<ShareableValue>> &asFrozenArray(
-      const std::unique_ptr<ValueWrapper> &valueContainer);
-  static inline const std::shared_ptr<MutableValue> &asMutableValue(
-      const std::unique_ptr<ValueWrapper> &valueContainer);
-
-  static const HostFunctionWrapper *asHostFunctionWrapper(
-      const std::unique_ptr<ValueWrapper> &valueContainer);
-
- protected:
-  ValueType type;
-};
-
-class BooleanValueWrapper : public ValueWrapper {
- public:
-  explicit BooleanValueWrapper(const bool _value)
-      : ValueWrapper(ValueType::BoolType), value(_value) {}
-  bool value;
-};
-
-class NumberValueWrapper : public ValueWrapper {
- public:
-  explicit NumberValueWrapper(const double _value)
-      : ValueWrapper(ValueType::NumberType), value(_value) {}
-  double value;
-};
-
-class StringValueWrapper : public ValueWrapper {
- public:
-  explicit StringValueWrapper(const std::string &_value)
-      : ValueWrapper(ValueType::StringType), value(_value) {}
-  std::string value;
-};
-
-class HostFunctionWrapper : public ValueWrapper {
- public:
-  explicit HostFunctionWrapper(
-      const std::shared_ptr<HostFunctionHandler> &_value)
-      : ValueWrapper(ValueType::HostFunctionType), value(_value) {}
-  std::shared_ptr<HostFunctionHandler> value;
-};
-
-class FrozenObjectWrapper : public ValueWrapper {
- public:
-  explicit FrozenObjectWrapper(const std::shared_ptr<FrozenObject> &_value)
-      : ValueWrapper(ValueType::FrozenObjectType), value(_value) {}
-  std::shared_ptr<FrozenObject> value;
-};
-
-class RemoteObjectWrapper : public ValueWrapper {
- public:
-  explicit RemoteObjectWrapper(const std::shared_ptr<RemoteObject> &_value)
-      : ValueWrapper(ValueType::RemoteObjectType), value(_value) {}
-  std::shared_ptr<RemoteObject> value;
-};
-
-class FrozenArrayWrapper : public ValueWrapper {
- public:
-  FrozenArrayWrapper() : ValueWrapper(ValueType::FrozenArrayType) {}
-  explicit FrozenArrayWrapper(
-      const std::vector<std::shared_ptr<ShareableValue>> &_value)
-      : ValueWrapper(ValueType::FrozenArrayType), value(_value) {}
-  std::vector<std::shared_ptr<ShareableValue>> value;
-};
-
-class MutableValueWrapper : public ValueWrapper {
- public:
-  explicit MutableValueWrapper(const std::shared_ptr<MutableValue> &_value)
-      : ValueWrapper(ValueType::MutableValueType), value(_value) {}
-  std::shared_ptr<MutableValue> value;
-};
-
-inline bool ValueWrapper::asBoolean(
-    const std::unique_ptr<ValueWrapper> &valueContainer) {
-  return static_cast<BooleanValueWrapper *>(valueContainer.get())->value;
-}
-
-inline double ValueWrapper::asNumber(
-    const std::unique_ptr<ValueWrapper> &valueContainer) {
-  return static_cast<NumberValueWrapper *>(valueContainer.get())->value;
-}
-
-inline const std::string &ValueWrapper::asString(
-    const std::unique_ptr<ValueWrapper> &valueContainer) {
-  return static_cast<StringValueWrapper *>(valueContainer.get())->value;
-}
-
-inline const std::shared_ptr<HostFunctionHandler> &ValueWrapper::asHostFunction(
-    const std::unique_ptr<ValueWrapper> &valueContainer) {
-  return static_cast<HostFunctionWrapper *>(valueContainer.get())->value;
-}
-
-inline const std::shared_ptr<FrozenObject> &ValueWrapper::asFrozenObject(
-    const std::unique_ptr<ValueWrapper> &valueContainer) {
-  return static_cast<FrozenObjectWrapper *>(valueContainer.get())->value;
-}
-
-inline const std::shared_ptr<RemoteObject> &ValueWrapper::asRemoteObject(
-    const std::unique_ptr<ValueWrapper> &valueContainer) {
-  return static_cast<RemoteObjectWrapper *>(valueContainer.get())->value;
-}
-
-inline std::vector<std::shared_ptr<ShareableValue>>
-    &ValueWrapper::asFrozenArray(
-        const std::unique_ptr<ValueWrapper> &valueContainer) {
-  return static_cast<FrozenArrayWrapper *>(valueContainer.get())->value;
-}
-
-inline const std::shared_ptr<MutableValue> &ValueWrapper::asMutableValue(
-    const std::unique_ptr<ValueWrapper> &valueContainer) {
-  return static_cast<MutableValueWrapper *>(valueContainer.get())->value;
-}
-
-inline const HostFunctionWrapper *ValueWrapper::asHostFunctionWrapper(
-    const std::unique_ptr<ValueWrapper> &valueContainer) {
-  return static_cast<HostFunctionWrapper *>(valueContainer.get());
-}
-
-} // namespace devmenureanimated

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

@@ -1,35 +0,0 @@
-#include "DevMenuFrozenObject.h"
-#include "DevMenuRuntimeManager.h"
-#include "DevMenuShareableValue.h"
-#include "DevMenuSharedParent.h"
-
-namespace devmenureanimated {
-
-FrozenObject::FrozenObject(
-    jsi::Runtime &rt,
-    const jsi::Object &object,
-    RuntimeManager *runtimeManager) {
-  auto propertyNames = object.getPropertyNames(rt);
-  const size_t count = propertyNames.size(rt);
-  namesOrder.reserve(count);
-  for (size_t i = 0; i < count; i++) {
-    auto propertyName = propertyNames.getValueAtIndex(rt, i).asString(rt);
-    namesOrder.push_back(propertyName.utf8(rt));
-    std::string nameStr = propertyName.utf8(rt);
-    map[nameStr] = ShareableValue::adapt(
-        rt, object.getProperty(rt, propertyName), runtimeManager);
-    this->containsHostFunction |= map[nameStr]->containsHostFunction;
-  }
-}
-
-jsi::Object FrozenObject::shallowClone(jsi::Runtime &rt) {
-  jsi::Object object(rt);
-  for (auto propName : namesOrder) {
-    auto value = map[propName];
-    object.setProperty(
-        rt, jsi::String::createFromUtf8(rt, propName), value->getValue(rt));
-  }
-  return object;
-}
-
-} // namespace devmenureanimated

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

@@ -1,134 +0,0 @@
-#include "DevMenuMutableValue.h"
-#include "DevMenuRuntimeDecorator.h"
-#include "DevMenuRuntimeManager.h"
-#include "DevMenuShareableValue.h"
-#include "DevMenuSharedParent.h"
-
-#include <string>
-
-namespace devmenureanimated {
-
-void MutableValue::setValue(jsi::Runtime &rt, const jsi::Value &newValue) {
-  std::lock_guard<std::mutex> lock(readWriteMutex);
-  value = ShareableValue::adapt(rt, newValue, runtimeManager);
-
-  std::shared_ptr<MutableValue> thiz = shared_from_this();
-  auto notifyListeners = [thiz]() {
-    for (auto listener : thiz->listeners) {
-      listener.second();
-    }
-  };
-  if (RuntimeDecorator::isUIRuntime(rt)) {
-    notifyListeners();
-  } else {
-    runtimeManager->scheduler->scheduleOnUI(
-        [notifyListeners] { notifyListeners(); });
-  }
-}
-
-jsi::Value MutableValue::getValue(jsi::Runtime &rt) {
-  std::lock_guard<std::mutex> lock(readWriteMutex);
-  return value->getValue(rt);
-}
-
-void MutableValue::set(
-    jsi::Runtime &rt,
-    const jsi::PropNameID &name,
-    const jsi::Value &newValue) {
-  auto propName = name.utf8(rt);
-  if (!runtimeManager->valueSetter) {
-    throw jsi::JSError(
-        rt,
-        "Value-Setter is not yet configured! Make sure the core-functions are installed.");
-  }
-
-  if (RuntimeDecorator::isUIRuntime(rt)) {
-    // UI thread
-    if (propName == "value") {
-      auto setterProxy = jsi::Object::createFromHostObject(
-          rt, std::make_shared<MutableValueSetterProxy>(shared_from_this()));
-      runtimeManager->valueSetter->getValue(rt)
-          .asObject(rt)
-          .asFunction(rt)
-          .callWithThis(rt, setterProxy, newValue);
-    } else if (propName == "_animation") {
-      // TODO: assert to allow animation to be set from UI only
-      if (animation.expired()) {
-        animation = getWeakRef(rt);
-      }
-      *animation.lock() = jsi::Value(rt, newValue);
-    } else if (propName == "_value") {
-      auto setter =
-          std::make_shared<MutableValueSetterProxy>(shared_from_this());
-      setter->set(rt, jsi::PropNameID::forAscii(rt, "_value"), newValue);
-    }
-  } else {
-    // React-JS Thread or another threaded Runtime.
-    if (propName == "value") {
-      auto shareable = ShareableValue::adapt(rt, newValue, runtimeManager);
-      runtimeManager->scheduler->scheduleOnUI([this, shareable] {
-        jsi::Runtime &rt = *this->runtimeManager->runtime.get();
-        auto setterProxy = jsi::Object::createFromHostObject(
-            rt, std::make_shared<MutableValueSetterProxy>(shared_from_this()));
-        jsi::Value newValue = shareable->getValue(rt);
-        runtimeManager->valueSetter->getValue(rt)
-            .asObject(rt)
-            .asFunction(rt)
-            .callWithThis(rt, setterProxy, newValue);
-      });
-    }
-  }
-}
-
-jsi::Value MutableValue::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
-  auto propName = name.utf8(rt);
-
-  if (propName == "value") {
-    return getValue(rt);
-  }
-
-  if (RuntimeDecorator::isUIRuntime(rt)) {
-    // _value and _animation should be accessed from UI only
-    if (propName == "_value") {
-      return getValue(rt);
-    } else if (propName == "_animation") {
-      // TODO: assert to allow animation to be read from UI only
-      if (animation.expired()) {
-        animation = getWeakRef(rt);
-      }
-      return jsi::Value(rt, *(animation.lock()));
-    }
-  }
-
-  return jsi::Value::undefined();
-}
-
-std::vector<jsi::PropNameID> MutableValue::getPropertyNames(jsi::Runtime &rt) {
-  std::vector<jsi::PropNameID> result;
-  result.push_back(jsi::PropNameID::forUtf8(rt, std::string("value")));
-  return result;
-}
-
-MutableValue::MutableValue(
-    jsi::Runtime &rt,
-    const jsi::Value &initial,
-    RuntimeManager *runtimeManager,
-    std::shared_ptr<Scheduler> s)
-    : StoreUser(s, *runtimeManager),
-      runtimeManager(runtimeManager),
-      value(ShareableValue::adapt(rt, initial, runtimeManager)) {}
-
-unsigned long int MutableValue::addListener(
-    unsigned long id,
-    std::function<void()> listener) {
-  listeners[id] = listener;
-  return id;
-}
-
-void MutableValue::removeListener(unsigned long listenerId) {
-  if (listeners.count(listenerId) > 0) {
-    listeners.erase(listenerId);
-  }
-}
-
-} // namespace devmenureanimated

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

@@ -1,47 +0,0 @@
-#include "DevMenuMutableValueSetterProxy.h"
-#include <jsi/jsi.h>
-#include "DevMenuMutableValue.h"
-#include "DevMenuSharedParent.h"
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-void MutableValueSetterProxy::set(
-    jsi::Runtime &rt,
-    const jsi::PropNameID &name,
-    const jsi::Value &newValue) {
-  auto propName = name.utf8(rt);
-  if (propName == "_value") {
-    mutableValue->setValue(rt, newValue);
-  } else if (propName == "_animation") {
-    // TODO: assert to allow animation to be set from UI only
-    if (mutableValue->animation.expired()) {
-      mutableValue->animation = mutableValue->getWeakRef(rt);
-    }
-    *mutableValue->animation.lock() = jsi::Value(rt, newValue);
-  } else if (propName == "value") {
-    // you call `this.value` inside of value setter, we should throw
-  }
-}
-
-jsi::Value MutableValueSetterProxy::get(
-    jsi::Runtime &rt,
-    const jsi::PropNameID &name) {
-  auto propName = name.utf8(rt);
-
-  if (propName == "value") {
-    return mutableValue->getValue(rt);
-  } else if (propName == "_value") {
-    return mutableValue->getValue(rt);
-  } else if (propName == "_animation") {
-    if (mutableValue->animation.expired()) {
-      mutableValue->animation = mutableValue->getWeakRef(rt);
-    }
-    return jsi::Value(rt, *mutableValue->animation.lock());
-  }
-
-  return jsi::Value::undefined();
-}
-
-} // namespace devmenureanimated

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

@@ -1,45 +0,0 @@
-#include "DevMenuRemoteObject.h"
-#include <jsi/jsi.h>
-#include "DevMenuRuntimeDecorator.h"
-#include "DevMenuSharedParent.h"
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-void RemoteObject::maybeInitializeOnWorkletRuntime(jsi::Runtime &rt) {
-  if (initializer.get() != nullptr) {
-    backing = getWeakRef(rt);
-    *backing.lock() = initializer->shallowClone(rt);
-    initializer = nullptr;
-  }
-}
-
-jsi::Value RemoteObject::get(jsi::Runtime &rt, const jsi::PropNameID &name) {
-  if (RuntimeDecorator::isWorkletRuntime(rt)) {
-    return backing.lock()->getObject(rt).getProperty(rt, name);
-  }
-  return jsi::Value::undefined();
-}
-
-void RemoteObject::set(
-    jsi::Runtime &rt,
-    const jsi::PropNameID &name,
-    const jsi::Value &value) {
-  if (RuntimeDecorator::isWorkletRuntime(rt)) {
-    backing.lock()->getObject(rt).setProperty(rt, name, value);
-  }
-  // TODO: we should throw if trying to update remote from host runtime
-}
-
-std::vector<jsi::PropNameID> RemoteObject::getPropertyNames(jsi::Runtime &rt) {
-  std::vector<jsi::PropNameID> res;
-  auto propertyNames = backing.lock()->getObject(rt).getPropertyNames(rt);
-  for (size_t i = 0, size = propertyNames.size(rt); i < size; i++) {
-    res.push_back(jsi::PropNameID::forString(
-        rt, propertyNames.getValueAtIndex(rt, i).asString(rt)));
-  }
-  return res;
-}
-
-} // namespace devmenureanimated