expo-dev-menu 2.2.0 → 3.0.0

package/vendored/react-native-reanimated/Common/cpp/Registries/EventHandlerRegistry.cpp

@@ -1,68 +0,0 @@
-#include "DevMenuEventHandlerRegistry.h"
-#include "DevMenuWorkletEventHandler.h"
-
-namespace devmenureanimated {
-
-void EventHandlerRegistry::registerEventHandler(
-    std::shared_ptr<WorkletEventHandler> eventHandler) {
-  const std::lock_guard<std::mutex> lock(instanceMutex);
-  eventMappings[eventHandler->eventName][eventHandler->id] = eventHandler;
-  eventHandlers[eventHandler->id] = eventHandler;
-}
-
-void EventHandlerRegistry::unregisterEventHandler(unsigned long id) {
-  const std::lock_guard<std::mutex> lock(instanceMutex);
-  auto handlerIt = eventHandlers.find(id);
-  if (handlerIt != eventHandlers.end()) {
-    eventMappings[handlerIt->second->eventName].erase(id);
-    if (eventMappings[handlerIt->second->eventName].empty()) {
-      eventMappings.erase(handlerIt->second->eventName);
-    }
-    eventHandlers.erase(handlerIt);
-  }
-}
-
-void EventHandlerRegistry::processEvent(
-    jsi::Runtime &rt,
-    std::string eventName,
-    std::string eventPayload) {
-  std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
-  {
-    const std::lock_guard<std::mutex> lock(instanceMutex);
-    auto handlersIt = eventMappings.find(eventName);
-    if (handlersIt != eventMappings.end()) {
-      for (auto handler : handlersIt->second) {
-        handlersForEvent.push_back(handler.second);
-      }
-    }
-  }
-  // We receive here a JS Map with JSON as a value of NativeMap key
-  // { NativeMap: { "jsonProp": "json value" } }
-  // So we need to extract only JSON part
-  std::string delimimter = "NativeMap:";
-  auto positionToSplit = eventPayload.find(delimimter) + delimimter.size();
-  auto lastBracketCharactedPosition = eventPayload.size() - positionToSplit - 1;
-  auto eventJSON =
-      eventPayload.substr(positionToSplit, lastBracketCharactedPosition);
-
-  if (eventJSON.compare(std::string("null")) == 0) {
-    return;
-  }
-
-  auto eventObject = jsi::Value::createFromJsonUtf8(
-      rt, reinterpret_cast<uint8_t *>(&eventJSON[0]), eventJSON.size());
-
-  eventObject.asObject(rt).setProperty(
-      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
-  for (auto handler : handlersForEvent) {
-    handler->process(rt, eventObject);
-  }
-}
-
-bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(std::string eventName) {
-  const std::lock_guard<std::mutex> lock(instanceMutex);
-  auto it = eventMappings.find(eventName);
-  return (it != eventMappings.end()) && (!(it->second).empty());
-}
-
-} // namespace devmenureanimated

package/vendored/react-native-reanimated/Common/cpp/Registries/MapperRegistry.cpp

@@ -1,147 +0,0 @@
-#include "DevMenuMapperRegistry.h"
-#include "DevMenuMapper.h"
-
-#include <array>
-#include <map>
-#include <set>
-#include <utility>
-
-namespace devmenureanimated {
-
-void MapperRegistry::startMapper(std::shared_ptr<Mapper> mapper) {
-  mappers[mapper->id] = mapper;
-  updatedSinceLastExecute = true;
-}
-
-void MapperRegistry::stopMapper(unsigned long id) {
-  mappers.erase(id);
-  updatedSinceLastExecute = true;
-}
-
-void MapperRegistry::execute(jsi::Runtime &rt) {
-  if (updatedSinceLastExecute) {
-    updateOrder();
-    updatedSinceLastExecute = false;
-  }
-  for (auto &mapper : sortedMappers) {
-    if (mapper->dirty) {
-      mapper->execute(rt);
-    }
-  }
-}
-
-bool MapperRegistry::needRunOnRender() {
-  return updatedSinceLastExecute; // TODO: also run if input nodes are dirty
-}
-
-void MapperRegistry::updateOrder() { // Topological sorting
-  sortedMappers.clear();
-
-  struct NodeID {
-    std::shared_ptr<Mapper> mapper;
-    std::shared_ptr<MutableValue> mutableValue;
-
-    explicit NodeID(std::shared_ptr<Mapper> mapper) {
-      if (mapper == nullptr) {
-        throw std::runtime_error(
-            "Graph couldn't be sorted (Mapper cannot be nullptr)");
-      }
-      this->mapper = mapper;
-    }
-
-    explicit NodeID(std::shared_ptr<MutableValue> mutableValue) {
-      if (mutableValue == nullptr) {
-        throw std::runtime_error(
-            "Graph couldn't be sorted (Mutable cannot be nullptr)");
-      }
-      this->mutableValue = mutableValue;
-    }
-
-    bool isMutable() const {
-      return mutableValue != nullptr;
-    }
-
-    bool operator<(const NodeID &other) const {
-      if (isMutable() != other.isMutable())
-        return isMutable() < other.isMutable();
-
-      if (isMutable()) {
-        return mutableValue < other.mutableValue;
-      }
-
-      return mapper < other.mapper;
-    }
-  };
-
-  std::map<NodeID, int> deg;
-
-  std::map<std::shared_ptr<MutableValue>, std::vector<std::shared_ptr<Mapper>>>
-      mappersThatUseSharedValue;
-
-  std::set<std::pair<int, NodeID>> nodes;
-
-  std::function<void(NodeID)> update = [&](NodeID id) {
-    auto entry = std::make_pair(deg[id], id);
-    if (nodes.find(entry) == nodes.end())
-      return;
-    nodes.erase(entry);
-    entry.first--;
-    deg[id]--;
-    nodes.insert(entry);
-  };
-
-  for (auto &entry : mappers) {
-    auto id = NodeID(entry.second);
-    auto &mapper = entry.second;
-    deg[id] = mapper->inputs.size();
-    nodes.insert(std::make_pair(deg[id], id));
-
-    for (auto sharedValue : mapper->inputs) {
-      auto sharedValueID = NodeID(sharedValue);
-      mappersThatUseSharedValue[sharedValue].push_back(mapper);
-      if (deg.count(sharedValueID) == 0) {
-        deg[sharedValueID] = 0;
-      }
-    }
-
-    for (auto sharedValue : mapper->outputs) {
-      deg[NodeID(sharedValue)]++;
-    }
-  }
-
-  for (auto &entry : deg) {
-    auto id = entry.first;
-    if (id.isMutable()) {
-      nodes.insert(std::make_pair(entry.second, id));
-    }
-  }
-
-  while (nodes.size() > 0 && nodes.begin()->first == 0) {
-    auto entry = *nodes.begin();
-    nodes.erase(entry);
-
-    auto id = entry.second;
-    std::vector<NodeID> toUpdate;
-
-    if (id.isMutable()) {
-      for (auto id : mappersThatUseSharedValue[id.mutableValue]) {
-        toUpdate.push_back(NodeID(id));
-      }
-    } else {
-      for (auto sharedValue : id.mapper->outputs) {
-        toUpdate.push_back(NodeID(sharedValue));
-      }
-
-      sortedMappers.push_back(id.mapper);
-    }
-
-    for (auto &id : toUpdate)
-      update(id);
-  }
-
-  if (nodes.size() > 0) {
-    throw std::runtime_error("Cycle in mappers graph!");
-  }
-}
-
-} // namespace devmenureanimated

package/vendored/react-native-reanimated/Common/cpp/Registries/WorkletsCache.cpp

@@ -1,41 +0,0 @@
-#include "DevMenuWorkletsCache.h"
-#include "DevMenuFrozenObject.h"
-#include "DevMenuShareableValue.h"
-
-#include <string>
-#include <utility>
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-jsi::Value eval(jsi::Runtime &rt, const char *code) {
-  return rt.global().getPropertyAsFunction(rt, "eval").call(rt, code);
-}
-
-jsi::Function function(jsi::Runtime &rt, const std::string &code) {
-  return eval(rt, ("(" + code + ")").c_str()).getObject(rt).getFunction(rt);
-}
-
-std::shared_ptr<jsi::Function> WorkletsCache::getFunction(
-    jsi::Runtime &rt,
-    std::shared_ptr<FrozenObject> frozenObj) {
-  long long workletHash =
-      ValueWrapper::asNumber(frozenObj->map["__workletHash"]->valueContainer);
-  if (worklets.count(workletHash) == 0) {
-    auto codeBuffer = std::make_shared<const jsi::StringBuffer>(
-        "(" +
-        ValueWrapper::asString(frozenObj->map["asString"]->valueContainer) +
-        ")");
-    auto func = rt.evaluateJavaScript(
-                      codeBuffer,
-                      ValueWrapper::asString(
-                          frozenObj->map["__location"]->valueContainer))
-                    .asObject(rt)
-                    .asFunction(rt);
-    worklets[workletHash] = std::make_shared<jsi::Function>(std::move(func));
-  }
-  return worklets[workletHash];
-}
-
-} // namespace devmenureanimated

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

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-#include "DevMenuRuntimeManager.h"
-#include "DevMenuSharedParent.h"
-#include "DevMenuWorkletsCache.h"
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-class FrozenObject : public jsi::HostObject {
-  friend WorkletsCache;
-  friend void extractMutables(
-      jsi::Runtime &rt,
-      std::shared_ptr<ShareableValue> sv,
-      std::vector<std::shared_ptr<MutableValue>> &res);
-
- private:
-  std::unordered_map<std::string, std::shared_ptr<ShareableValue>> map;
-  std::vector<std::string> namesOrder;
-
- public:
-  FrozenObject(
-      jsi::Runtime &rt,
-      const jsi::Object &object,
-      RuntimeManager *runtimeManager);
-  jsi::Object shallowClone(jsi::Runtime &rt);
-  bool containsHostFunction = false;
-};
-
-} // namespace devmenureanimated

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

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <memory>
-#include <string>
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-struct HostFunctionHandler : jsi::HostObject {
-  std::shared_ptr<jsi::Function> pureFunction;
-  std::string functionName;
-  jsi::Runtime *hostRuntime;
-  jsi::HostObject a;
-
-  HostFunctionHandler(std::shared_ptr<jsi::Function> f, jsi::Runtime &rt) {
-    pureFunction = f;
-    functionName = f->getProperty(rt, "name").asString(rt).utf8(rt);
-    hostRuntime = &rt;
-  }
-
-  std::shared_ptr<jsi::Function> getPureFunction() {
-    return pureFunction;
-  }
-};
-
-} // namespace devmenureanimated

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

@@ -1,54 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <vector>
-#include "DevMenuJSIStoreValueUser.h"
-#include "DevMenuLayoutAnimationsProxy.h"
-#include "DevMenuMutableValueSetterProxy.h"
-#include "DevMenuRuntimeManager.h"
-#include "DevMenuSharedParent.h"
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-class MutableValue : public jsi::HostObject,
-                     public std::enable_shared_from_this<MutableValue>,
-                     public StoreUser {
- private:
-  friend MutableValueSetterProxy;
-  friend LayoutAnimationsProxy;
-
- private:
-  RuntimeManager *runtimeManager;
-  std::mutex readWriteMutex;
-  std::shared_ptr<ShareableValue> value;
-  std::weak_ptr<jsi::Value> animation;
-  std::map<unsigned long, std::function<void()>> listeners;
-
- public:
-  void setValue(jsi::Runtime &rt, const jsi::Value &newValue);
-  jsi::Value getValue(jsi::Runtime &rt);
-
- public:
-  MutableValue(
-      jsi::Runtime &rt,
-      const jsi::Value &initial,
-      RuntimeManager *runtimeManager,
-      std::shared_ptr<Scheduler> s);
-
- public:
-  void
-  set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name);
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
-  unsigned long addListener(
-      unsigned long listenerId,
-      std::function<void()> listener);
-  void removeListener(unsigned long listenerId);
-};
-
-} // namespace devmenureanimated

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

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <memory>
-#include <utility>
-#include "DevMenuSharedParent.h"
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-class MutableValueSetterProxy : public jsi::HostObject {
- private:
-  friend MutableValue;
-  std::shared_ptr<MutableValue> mutableValue;
-
- public:
-  explicit MutableValueSetterProxy(std::shared_ptr<MutableValue> mutableValue)
-      : mutableValue(std::move(mutableValue)) {}
-  void
-  set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name);
-};
-
-} // namespace devmenureanimated

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

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include "DevMenuFrozenObject.h"
-#include "DevMenuJSIStoreValueUser.h"
-#include "DevMenuSharedParent.h"
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-class RemoteObject : public jsi::HostObject, public StoreUser {
- private:
-  std::weak_ptr<jsi::Value> backing;
-  std::unique_ptr<FrozenObject> initializer;
-
- public:
-  void maybeInitializeOnWorkletRuntime(jsi::Runtime &rt);
-  RemoteObject(
-      jsi::Runtime &rt,
-      const jsi::Object &object,
-      RuntimeManager *runtimeManager,
-      std::shared_ptr<Scheduler> s)
-      : StoreUser(s, *runtimeManager),
-        initializer(
-            std::make_unique<FrozenObject>(rt, object, runtimeManager)) {}
-  void
-  set(jsi::Runtime &rt, const jsi::PropNameID &name, const jsi::Value &value);
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &name);
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt);
-};
-
-} // namespace devmenureanimated

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

@@ -1,75 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <memory>
-#include "DevMenuErrorHandler.h"
-#include "DevMenuJSIStoreValueUser.h"
-#include "DevMenuRuntimeDecorator.h"
-#include "DevMenuScheduler.h"
-#include "DevMenuShareableValue.h"
-#include "DevMenuWorkletsCache.h"
-
-namespace devmenureanimated {
-
-using namespace facebook;
-
-/**
- A class that manages a jsi::Runtime apart from the React-JS runtime.
- */
-class RuntimeManager {
- public:
-  RuntimeManager(
-      std::shared_ptr<jsi::Runtime> runtime,
-      std::shared_ptr<ErrorHandler> errorHandler,
-      std::shared_ptr<Scheduler> scheduler,
-      RuntimeType runtimeType = RuntimeType::Worklet)
-      : runtime(runtime),
-        errorHandler(errorHandler),
-        scheduler(scheduler),
-        workletsCache(std::make_unique<WorkletsCache>()),
-        storeUserData(std::make_shared<StaticStoreUser>()) {
-    RuntimeDecorator::registerRuntime(this->runtime.get(), runtimeType);
-  }
-
-  virtual ~RuntimeManager() {
-    clearStore();
-  }
-
- public:
-  /**
-   Holds the jsi::Function worklet that is responsible for updating values in
-   JS. Can be null.
-   */
-  std::shared_ptr<ShareableValue> valueSetter;
-  /**
-   Holds the jsi::Runtime this RuntimeManager is managing.
-   */
-  std::shared_ptr<jsi::Runtime> runtime;
-  /**
-   Holds the error handler that will be invoked when any kind of error occurs.
-   */
-  std::shared_ptr<ErrorHandler> errorHandler;
-  /**
-   Holds the Scheduler that is responsible for scheduling work on the UI- or
-   React-JS Thread.
-   */
-  std::shared_ptr<Scheduler> scheduler;
-  /**
-   Holds a list of adapted Worklets which are cached to avoid unneccessary
-   recreation.
-   */
-  std::unique_ptr<WorkletsCache> workletsCache;
-  /**
-   Holds the JSI-Value Store where JSI::Values are cached on a
-   per-RuntimeManager basis.
-   */
-  std::shared_ptr<StaticStoreUser> storeUserData;
-
- private:
-  void clearStore() {
-    const std::lock_guard<std::recursive_mutex> lock(storeUserData->storeMutex);
-    storeUserData->store.clear();
-  }
-};
-
-} // namespace devmenureanimated

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

@@ -1,63 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <unordered_map>
-#include <vector>
-#include "DevMenuAnimatedSensorModule.h"
-#include "DevMenuHostFunctionHandler.h"
-#include "DevMenuJSIStoreValueUser.h"
-#include "DevMenuLayoutAnimationsProxy.h"
-#include "DevMenuRuntimeManager.h"
-#include "DevMenuScheduler.h"
-#include "DevMenuSharedParent.h"
-#include "DevMenuValueWrapper.h"
-#include "DevMenuWorkletsCache.h"
-
-using namespace facebook;
-
-namespace devmenureanimated {
-
-class ShareableValue : public std::enable_shared_from_this<ShareableValue>,
-                       public StoreUser {
-  friend WorkletsCache;
-  friend FrozenObject;
-  friend LayoutAnimationsProxy;
-  friend NativeReanimatedModule;
-  friend AnimatedSensorModule;
-  friend void extractMutables(
-      jsi::Runtime &rt,
-      std::shared_ptr<ShareableValue> sv,
-      std::vector<std::shared_ptr<MutableValue>> &res);
-
- private:
-  RuntimeManager *runtimeManager;
-  std::unique_ptr<ValueWrapper> valueContainer;
-  std::unique_ptr<jsi::Value> hostValue;
-  std::weak_ptr<jsi::Value> remoteValue;
-  bool containsHostFunction = false;
-
-  ShareableValue(RuntimeManager *runtimeManager, std::shared_ptr<Scheduler> s)
-      : StoreUser(s, *runtimeManager), runtimeManager(runtimeManager) {}
-
-  jsi::Value toJSValue(jsi::Runtime &rt);
-  jsi::Object createHost(
-      jsi::Runtime &rt,
-      std::shared_ptr<jsi::HostObject> host);
-  void adapt(jsi::Runtime &rt, const jsi::Value &value, ValueType objectType);
-  void adaptCache(jsi::Runtime &rt, const jsi::Value &value);
-  std::string demangleExceptionName(std::string toDemangle);
-
- public:
-  ValueType type = ValueType::UndefinedType;
-  static std::shared_ptr<ShareableValue> adapt(
-      jsi::Runtime &rt,
-      const jsi::Value &value,
-      RuntimeManager *runtimeManager,
-      ValueType objectType = ValueType::UndefinedType);
-  jsi::Value getValue(jsi::Runtime &rt);
-};
-
-} // namespace devmenureanimated

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

@@ -1,27 +0,0 @@
-#pragma once
-
-namespace devmenureanimated {
-
-enum class ValueType {
-  UndefinedType,
-  NullType,
-  BoolType,
-  NumberType,
-  StringType,
-  RemoteObjectType, // object that can be instantiated on host side and modified
-                    // on the remote (worklet) side
-  MutableValueType, // object with 'value' property that can be updated and read
-                    // from any thread
-  HostFunctionType, // function that will be executed asynchronously on the host
-                    // runtime
-  WorkletFunctionType, // function that gets run on the UI thread
-  FrozenObjectType, // frozen object, can only be set and never modified
-  FrozenArrayType, // frozen array, can only be set and never modified
-};
-
-class ShareableValue;
-class MutableValue;
-class RemoteObject;
-class NativeReanimatedModule;
-
-} // namespace devmenureanimated