@react-native-ohos/react-native-reanimated 3.18.2-rc.2 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/PropsRegistry.cpp

@@ -1,68 +0,0 @@
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/Fabric/PropsRegistry.h>
-
-namespace reanimated {
-
-std::lock_guard<std::mutex> PropsRegistry::createLock() const {
-  return std::lock_guard<std::mutex>(mutex_);
-}
-
-void PropsRegistry::update(
-    const ShadowNode::Shared &shadowNode,
-    folly::dynamic &&props) {
-  const auto tag = shadowNode->getTag();
-  const auto it = map_.find(tag);
-  if (it == map_.cend()) {
-    // we need to store ShadowNode because `ShadowNode::getFamily`
-    // returns `ShadowNodeFamily const &` which is non-owning
-    map_[tag] = std::make_pair(shadowNode, props);
-  } else {
-    // no need to update `.first` because ShadowNode's family never changes
-    // merge new props with old props
-    it->second.second.update(props);
-  }
-}
-
-void PropsRegistry::for_each(std::function<void(
-                                 const ShadowNodeFamily &family,
-                                 const folly::dynamic &props)> callback) const {
-  for (const auto &[_, value] : map_) {
-    callback(value.first->getFamily(), value.second);
-  }
-}
-
-void PropsRegistry::markNodeAsRemovable(const ShadowNode::Shared &shadowNode) {
-  removableShadowNodes_[shadowNode->getTag()] = shadowNode;
-}
-
-void PropsRegistry::unmarkNodeAsRemovable(Tag viewTag) {
-  removableShadowNodes_.erase(viewTag);
-}
-
-void PropsRegistry::handleNodeRemovals(const RootShadowNode &rootShadowNode) {
-  for (auto it = removableShadowNodes_.begin();
-       it != removableShadowNodes_.end();) {
-    const auto &shadowNode = it->second;
-    const auto &family = shadowNode->getFamily();
-    const auto &ancestors = family.getAncestors(rootShadowNode);
-
-    // Skip if the node hasn't been removed
-    if (!ancestors.empty()) {
-      ++it;
-      continue;
-    }
-
-    const auto tag = shadowNode->getTag();
-    map_.erase(tag);
-    it = removableShadowNodes_.erase(it);
-  }
-}
-
-void PropsRegistry::remove(const Tag tag) {
-  map_.erase(tag);
-}
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/PropsRegistry.h

@@ -1,68 +0,0 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <react/renderer/components/root/RootShadowNode.h>
-#include <react/renderer/core/ShadowNode.h>
-
-#include <unordered_map>
-#include <utility>
-
-using namespace facebook;
-using namespace react;
-
-namespace reanimated {
-
-class PropsRegistry {
- public:
-  std::lock_guard<std::mutex> createLock() const;
-  // returns a lock you need to hold when calling any of the methods below
-
-  void update(const ShadowNode::Shared &shadowNode, folly::dynamic &&props);
-
-  void for_each(std::function<void(
-                    const ShadowNodeFamily &family,
-                    const folly::dynamic &props)> callback) const;
-
-  void remove(const Tag tag);
-
-  void pauseReanimatedCommits() {
-    isPaused_ = true;
-  }
-
-  bool shouldReanimatedSkipCommit() {
-    return isPaused_;
-  }
-
-  void unpauseReanimatedCommits() {
-    isPaused_ = false;
-  }
-
-  void pleaseCommitAfterPause() {
-    shouldCommitAfterPause_ = true;
-  }
-
-  bool shouldCommitAfterPause() {
-    return shouldCommitAfterPause_.exchange(false);
-  }
-
-  bool isEmpty() {
-    return map_.empty();
-  }
-
-  void markNodeAsRemovable(const ShadowNode::Shared &shadowNode);
-  void unmarkNodeAsRemovable(Tag viewTag);
-  void handleNodeRemovals(const RootShadowNode &rootShadowNode);
-
- private:
-  std::unordered_map<Tag, std::pair<ShadowNode::Shared, folly::dynamic>> map_;
-  std::unordered_map<Tag, ShadowNode::Shared> removableShadowNodes_;
-
-  mutable std::mutex mutex_; // Protects `map_`.
-
-  std::atomic<bool> isPaused_;
-  std::atomic<bool> shouldCommitAfterPause_;
-};
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy.h

@@ -1,147 +0,0 @@
-#pragma once
-#ifdef RCT_NEW_ARCH_ENABLED
-
-#include <reanimated/Fabric/PropsRegistry.h>
-#include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
-#include <reanimated/LayoutAnimations/LayoutAnimationsUtils.h>
-
-#include <worklets/Tools/UIScheduler.h>
-
-#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
-#include <react/renderer/mounting/MountingOverrideDelegate.h>
-#include <react/renderer/mounting/ShadowView.h>
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-namespace reanimated {
-
-class ReanimatedModuleProxy;
-
-using namespace facebook;
-
-struct LayoutAnimation {
-#if REACT_NATIVE_MINOR_VERSION >= 78
-  std::shared_ptr<ShadowView> finalView, currentView;
-  Tag parentTag;
-#else
-  std::shared_ptr<ShadowView> finalView, currentView, parentView;
-#endif // REACT_NATIVE_MINOR_VERSION >= 78
-  std::optional<double> opacity;
-  int count = 1;
-  LayoutAnimation &operator=(const LayoutAnimation &other) = default;
-};
-
-struct LayoutAnimationsProxy
-    : public MountingOverrideDelegate,
-      public std::enable_shared_from_this<LayoutAnimationsProxy> {
-  mutable std::unordered_map<Tag, std::shared_ptr<Node>> nodeForTag_;
-  mutable std::unordered_map<Tag, LayoutAnimation> layoutAnimations_;
-  mutable std::recursive_mutex mutex;
-  mutable SurfaceManager surfaceManager;
-  mutable std::unordered_set<std::shared_ptr<MutationNode>> deadNodes;
-  mutable std::unordered_map<Tag, int> leastRemoved;
-  std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
-  ContextContainer::Shared contextContainer_;
-  SharedComponentDescriptorRegistry componentDescriptorRegistry_;
-  jsi::Runtime &uiRuntime_;
-  const std::shared_ptr<UIScheduler> uiScheduler_;
-  LayoutAnimationsProxy(
-      std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager,
-      SharedComponentDescriptorRegistry componentDescriptorRegistry,
-      ContextContainer::Shared contextContainer,
-      jsi::Runtime &uiRuntime,
-      const std::shared_ptr<UIScheduler> uiScheduler)
-      : layoutAnimationsManager_(layoutAnimationsManager),
-        contextContainer_(contextContainer),
-        componentDescriptorRegistry_(componentDescriptorRegistry),
-        uiRuntime_(uiRuntime),
-        uiScheduler_(uiScheduler) {}
-
-  void startEnteringAnimation(const int tag, ShadowViewMutation &mutation)
-      const;
-  void startExitingAnimation(const int tag, ShadowViewMutation &mutation) const;
-  void startLayoutAnimation(const int tag, const ShadowViewMutation &mutation)
-      const;
-
-  void transferConfigFromNativeID(const std::string nativeId, const int tag)
-      const;
-  std::optional<SurfaceId> progressLayoutAnimation(
-      int tag,
-      const jsi::Object &newStyle);
-  std::optional<SurfaceId> endLayoutAnimation(int tag, bool shouldRemove);
-  void maybeCancelAnimation(const int tag) const;
-
-  void parseRemoveMutations(
-      std::unordered_map<Tag, ShadowView> &movedViews,
-      ShadowViewMutationList &mutations,
-      std::vector<std::shared_ptr<MutationNode>> &roots) const;
-  void handleRemovals(
-      ShadowViewMutationList &filteredMutations,
-      std::vector<std::shared_ptr<MutationNode>> &roots) const;
-
-  void handleUpdatesAndEnterings(
-      ShadowViewMutationList &filteredMutations,
-      const std::unordered_map<Tag, ShadowView> &movedViews,
-      ShadowViewMutationList &mutations,
-      const PropsParserContext &propsParserContext,
-      SurfaceId surfaceId) const;
-  void addOngoingAnimations(
-      SurfaceId surfaceId,
-      ShadowViewMutationList &mutations) const;
-  void updateOngoingAnimationTarget(
-      const int tag,
-      const ShadowViewMutation &mutation) const;
-  std::shared_ptr<ShadowView> cloneViewWithoutOpacity(
-      facebook::react::ShadowViewMutation &mutation,
-      const PropsParserContext &propsParserContext) const;
-  void maybeRestoreOpacity(
-      LayoutAnimation &layoutAnimation,
-      const jsi::Object &newStyle) const;
-  void maybeUpdateWindowDimensions(
-      facebook::react::ShadowViewMutation &mutation,
-      SurfaceId surfaceId) const;
-  void createLayoutAnimation(
-      const ShadowViewMutation &mutation,
-      ShadowView &oldView,
-      const SurfaceId &surfaceId,
-      const int tag) const;
-
-  void updateIndexForMutation(ShadowViewMutation &mutation) const;
-
-  void removeRecursively(
-      std::shared_ptr<MutationNode> node,
-      ShadowViewMutationList &mutations) const;
-  bool startAnimationsRecursively(
-      std::shared_ptr<MutationNode> node,
-      const bool shouldRemoveSubviewsWithoutAnimations,
-      const bool shouldAnimate,
-      const bool isScreenPop,
-      ShadowViewMutationList &mutations) const;
-  void endAnimationsRecursively(
-      std::shared_ptr<MutationNode> node,
-      ShadowViewMutationList &mutations) const;
-  void maybeDropAncestors(
-      std::shared_ptr<Node> node,
-      std::shared_ptr<MutationNode> child,
-      ShadowViewMutationList &cleanupMutations) const;
-
-  const ComponentDescriptor &getComponentDescriptorForShadowView(
-      const ShadowView &shadowView) const;
-
-  // MountingOverrideDelegate
-
-  bool shouldOverridePullTransaction() const override;
-  std::optional<MountingTransaction> pullTransaction(
-      SurfaceId surfaceId,
-      MountingTransaction::Number number,
-      const TransactionTelemetry &telemetry,
-      ShadowViewMutationList mutations) const override;
-};
-
-} // namespace reanimated
-
-#endif // RCT_NEW_ARCH_ENABLED

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/CollectionUtils.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#include <algorithm>
-
-namespace reanimated {
-namespace collection {
-
-template <class CollectionType, class ValueType>
-inline bool contains(const CollectionType &collection, const ValueType &value) {
-  return collection.find(value) != collection.end();
-}
-
-} // namespace collection
-} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/FeaturesConfig.cpp

@@ -1,5 +0,0 @@
-#include <reanimated/Tools/FeaturesConfig.h>
-
-namespace reanimated {
-bool FeaturesConfig::_isLayoutAnimationEnabled = false;
-}

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Tools/FeaturesConfig.h

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

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.cpp

@@ -1,47 +0,0 @@
-#include <string>
-
-#ifdef RCT_NEW_ARCH_ENABLED
-#include <react/renderer/uimanager/UIManagerBinding.h>
-#include <react/renderer/uimanager/primitives.h>
-#endif // RCT_NEW_ARCH_ENABLED
-
-#include <worklets/NativeModules/WorkletsModuleProxy.h>
-#include <worklets/SharedItems/Shareables.h>
-#include <worklets/Tools/Defs.h>
-
-#ifdef __ANDROID__
-#include <fbjni/fbjni.h>
-#endif // __ANDROID__
-
-#include <jsi/jsi.h>
-
-using namespace facebook;
-
-namespace worklets {
-
-WorkletsModuleProxy::WorkletsModuleProxy(
-    const std::string &valueUnpackerCode,
-    const std::shared_ptr<MessageQueueThread> &jsQueue,
-    const std::shared_ptr<CallInvoker> &jsCallInvoker,
-    const std::shared_ptr<JSScheduler> &jsScheduler,
-    const std::shared_ptr<UIScheduler> &uiScheduler)
-    : WorkletsModuleProxySpec(jsCallInvoker),
-      valueUnpackerCode_(valueUnpackerCode),
-      jsQueue_(jsQueue),
-      jsScheduler_(jsScheduler),
-      uiScheduler_(uiScheduler) {}
-
-WorkletsModuleProxy::~WorkletsModuleProxy() {}
-
-jsi::Value WorkletsModuleProxy::makeShareableClone(
-    jsi::Runtime &rt,
-    const jsi::Value &value,
-    const jsi::Value &shouldRetainRemote,
-    const jsi::Value &nativeStateSource) {
-  // TODO: It might be a good idea to rename one of these methods to avoid
-  // confusion.
-  return worklets::makeShareableClone(
-      rt, value, shouldRetainRemote, nativeStateSource);
-}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.h

@@ -1,59 +0,0 @@
-#pragma once
-
-#include <cxxreact/MessageQueueThread.h>
-#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
-#include <worklets/Tools/JSScheduler.h>
-#include <worklets/Tools/SingleInstanceChecker.h>
-#include <worklets/Tools/UIScheduler.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-#include <memory>
-#include <string>
-
-namespace worklets {
-
-class WorkletsModuleProxy
-    : public WorkletsModuleProxySpec,
-      public std::enable_shared_from_this<WorkletsModuleProxy> {
- public:
-  explicit WorkletsModuleProxy(
-      const std::string &valueUnpackerCode,
-      const std::shared_ptr<MessageQueueThread> &jsQueue,
-      const std::shared_ptr<CallInvoker> &jsCallInvoker,
-      const std::shared_ptr<JSScheduler> &jsScheduler,
-      const std::shared_ptr<UIScheduler> &uiScheduler);
-
-  ~WorkletsModuleProxy();
-
-  jsi::Value makeShareableClone(
-      jsi::Runtime &rt,
-      const jsi::Value &value,
-      const jsi::Value &shouldRetainRemote,
-      const jsi::Value &nativeStateSource) override;
-
-  [[nodiscard]] inline std::string getValueUnpackerCode() const {
-    return valueUnpackerCode_;
-  }
-
-  [[nodiscard]] inline std::shared_ptr<MessageQueueThread> getJSQueue() const {
-    return jsQueue_;
-  }
-
-  [[nodiscard]] inline std::shared_ptr<JSScheduler> getJSScheduler() const {
-    return jsScheduler_;
-  }
-
-  [[nodiscard]] inline std::shared_ptr<UIScheduler> getUIScheduler() const {
-    return uiScheduler_;
-  }
-
- private:
-  const std::string valueUnpackerCode_;
-  const std::shared_ptr<MessageQueueThread> jsQueue_;
-  const std::shared_ptr<JSScheduler> jsScheduler_;
-  const std::shared_ptr<UIScheduler> uiScheduler_;
-#ifndef NDEBUG
-  SingleInstanceChecker<WorkletsModuleProxy> singleInstanceChecker_;
-#endif // NDEBUG
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxySpec.cpp

@@ -1,27 +0,0 @@
-#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
-
-#include <utility>
-
-#define WORKLETS_SPEC_PREFIX(FN_NAME) \
-  __hostFunction_WorkletsModuleProxySpec_##FN_NAME
-
-namespace worklets {
-
-static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableClone)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
-      ->makeShareableClone(
-          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
-}
-
-WorkletsModuleProxySpec::WorkletsModuleProxySpec(
-    const std::shared_ptr<CallInvoker> jsInvoker)
-    : TurboModule("NativeWorklets", jsInvoker) {
-  methodMap_["makeShareableClone"] =
-      MethodMetadata{2, WORKLETS_SPEC_PREFIX(makeShareableClone)};
-}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/NativeModules/WorkletsModuleProxySpec.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <ReactCommon/CallInvoker.h>
-#include <ReactCommon/TurboModule.h>
-#include <memory>
-
-using namespace facebook;
-using namespace react;
-
-namespace worklets {
-
-class JSI_EXPORT WorkletsModuleProxySpec : public TurboModule {
- protected:
-  explicit WorkletsModuleProxySpec(
-      const std::shared_ptr<CallInvoker> jsInvoker);
-
- public:
-  virtual jsi::Value makeShareableClone(
-      jsi::Runtime &rt,
-      const jsi::Value &value,
-      const jsi::Value &shouldRetainRemote,
-      const jsi::Value &nativeStateSource) = 0;
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Registries/EventHandlerRegistry.cpp

@@ -1,94 +0,0 @@
-#include <worklets/Registries/EventHandlerRegistry.h>
-#include <worklets/Tools/WorkletEventHandler.h>
-
-#include <utility>
-#include <vector>
-
-namespace worklets {
-
-void EventHandlerRegistry::registerEventHandler(
-    const std::shared_ptr<WorkletEventHandler> &eventHandler) {
-  const std::lock_guard<std::mutex> lock(instanceMutex);
-  const auto &eventName = eventHandler->getEventName();
-  auto handlerId = eventHandler->getHandlerId();
-
-  if (eventHandler->shouldIgnoreEmitterReactTag()) {
-    eventMappingsWithoutTag[eventName][handlerId] = eventHandler;
-  } else {
-    const auto emitterReactTag = eventHandler->getEmitterReactTag();
-    const auto eventHash = std::make_pair(emitterReactTag, eventName);
-    eventMappingsWithTag[eventHash][handlerId] = eventHandler;
-  }
-  eventHandlers[handlerId] = eventHandler;
-}
-
-void EventHandlerRegistry::unregisterEventHandler(const uint64_t id) {
-  const std::lock_guard<std::mutex> lock(instanceMutex);
-  auto handlerIt = eventHandlers.find(id);
-  if (handlerIt != eventHandlers.end()) {
-    const auto &eventHandler = handlerIt->second;
-    const auto &eventName = eventHandler->getEventName();
-
-    if (eventHandler->shouldIgnoreEmitterReactTag()) {
-      const auto eventMappingIt = eventMappingsWithoutTag.find(eventName);
-      auto &handlersMap = eventMappingIt->second;
-      handlersMap.erase(id);
-      if (handlersMap.empty()) {
-        eventMappingsWithoutTag.erase(eventMappingIt);
-      }
-    } else {
-      const auto emitterReactTag = eventHandler->getEmitterReactTag();
-      const auto eventHash = std::make_pair(emitterReactTag, eventName);
-      const auto eventMappingIt = eventMappingsWithTag.find(eventHash);
-      auto &handlersMap = eventMappingIt->second;
-      handlersMap.erase(id);
-      if (handlersMap.empty()) {
-        eventMappingsWithTag.erase(eventMappingIt);
-      }
-    }
-    eventHandlers.erase(handlerIt);
-  }
-}
-
-void EventHandlerRegistry::processEvent(
-    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
-    const double eventTimestamp,
-    const std::string &eventName,
-    const int emitterReactTag,
-    const jsi::Value &eventPayload) {
-  std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
-  {
-    const std::lock_guard<std::mutex> lock(instanceMutex);
-    auto handlersIt = eventMappingsWithoutTag.find(eventName);
-    if (handlersIt != eventMappingsWithoutTag.end()) {
-      for (auto handler : handlersIt->second) {
-        handlersForEvent.push_back(handler.second);
-      }
-    }
-    const auto eventHash = std::make_pair(emitterReactTag, eventName);
-    auto handlersWithTagIt = eventMappingsWithTag.find(eventHash);
-    if (handlersWithTagIt != eventMappingsWithTag.end()) {
-      for (auto handler : handlersWithTagIt->second) {
-        handlersForEvent.push_back(handler.second);
-      }
-    }
-  }
-
-  jsi::Runtime &rt = uiWorkletRuntime->getJSIRuntime();
-  eventPayload.asObject(rt).setProperty(
-      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
-  for (auto handler : handlersForEvent) {
-    handler->process(uiWorkletRuntime, eventTimestamp, eventPayload);
-  }
-}
-
-bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(
-    const std::string &eventName,
-    const int emitterReactTag) {
-  const std::lock_guard<std::mutex> lock(instanceMutex);
-  const auto eventHash = std::make_pair(emitterReactTag, eventName);
-  auto it = eventMappingsWithTag.find(eventHash);
-  return it != eventMappingsWithTag.end() && !it->second.empty();
-}
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Registries/EventHandlerRegistry.h

@@ -1,49 +0,0 @@
-#pragma once
-
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-
-#include <jsi/jsi.h>
-
-#include <map>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <unordered_map>
-#include <utility>
-
-using namespace facebook;
-
-namespace worklets {
-
-class WorkletEventHandler;
-
-class EventHandlerRegistry {
-  std::map<
-      std::pair<int, std::string>,
-      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
-      eventMappingsWithTag;
-  std::map<
-      std::string,
-      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
-      eventMappingsWithoutTag;
-  std::map<uint64_t, std::shared_ptr<WorkletEventHandler>> eventHandlers;
-  std::mutex instanceMutex;
-
- public:
-  void registerEventHandler(
-      const std::shared_ptr<WorkletEventHandler> &eventHandler);
-  void unregisterEventHandler(const uint64_t id);
-
-  void processEvent(
-      const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
-      const double eventTimestamp,
-      const std::string &eventName,
-      const int emitterReactTag,
-      const jsi::Value &eventPayload);
-
-  bool isAnyHandlerWaitingForEvent(
-      const std::string &eventName,
-      const int emitterReactTag);
-};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Registries/WorkletRuntimeRegistry.cpp

@@ -1,8 +0,0 @@
-#include <worklets/Registries/WorkletRuntimeRegistry.h>
-
-namespace worklets {
-
-std::set<jsi::Runtime *> WorkletRuntimeRegistry::registry_{};
-std::mutex WorkletRuntimeRegistry::mutex_{};
-
-} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/Registries/WorkletRuntimeRegistry.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <mutex>
-#include <set>
-
-using namespace facebook;
-
-namespace worklets {
-
-class WorkletRuntimeRegistry {
- private:
-  static std::set<jsi::Runtime *> registry_;
-  static std::mutex mutex_; // Protects `registry_`.
-
-  WorkletRuntimeRegistry() {} // private ctor
-
-  static void registerRuntime(jsi::Runtime &runtime) {
-    std::lock_guard<std::mutex> lock(mutex_);
-    registry_.insert(&runtime);
-  }
-
-  static void unregisterRuntime(jsi::Runtime &runtime) {
-    std::lock_guard<std::mutex> lock(mutex_);
-    registry_.erase(&runtime);
-  }
-
-  friend class WorkletRuntimeCollector;
-
- public:
-  static bool isRuntimeAlive(jsi::Runtime *runtime) {
-    assert(runtime != nullptr);
-    std::lock_guard<std::mutex> lock(mutex_);
-    return registry_.find(runtime) != registry_.end();
-  }
-};
-
-} // namespace worklets