@depup/react-native-worklets 0.11.4-depup.0 → 0.12.2-depup.0

package/src/types.ts

@@ -121,18 +121,52 @@ type WorkletRuntimeConfigBase = {
    * by requestAnimationFrame. If not specified, it defaults to 16 ms.
    */
   animationQueuePollingRate?: number;
-  /**
-   * Determines whether to enable the default Event Loop or not. The Event Loop
-   * provides implementations for `setTimeout`, `setImmediate`, `setInterval`,
-   * `requestAnimationFrame`, `queueMicrotask`, `clearTimeout`, `clearInterval`,
-   * `clearImmediate`, and `cancelAnimationFrame` methods. If not specified, it
-   * defaults to `true`.
-   */
-  enableEventLoop?: boolean;
 };
 
 /** Configuration object for creating a worklet runtime. */
 export type WorkletRuntimeConfig = WorkletRuntimeConfigBase &
+  (
+    | {
+        /**
+         * Determines whether to enable the default Event Loop, which provides
+         * `setTimeout`, `setInterval`, `requestAnimationFrame` and other
+         * scheduling APIs. If not specified, it defaults to `true`. Cannot be
+         * enabled when {@link enableLocking} is set to `false`.
+         */
+        enableEventLoop?: boolean;
+        /**
+         * Determines whether access to the underlying JS runtime is
+         * synchronized with a mutex around every JSI operation. If not
+         * specified, it defaults to `true`. Can be disabled only together
+         * with the Event Loop.
+         *
+         * Runtime without locking doesn't receive HMR updates
+         * and new Custom Serializable registrations.
+         *
+         * Disable only when you can guarantee thread safety of all access to the runtime.
+         */
+        enableLocking?: true;
+      }
+    | {
+        /**
+         * The Event Loop cannot be enabled on a runtime with
+         * {@link enableLocking} set to `false`.
+         */
+        enableEventLoop?: false;
+        /**
+         * Determines whether access to the underlying JS runtime is
+         * synchronized with a mutex around every JSI operation. If not
+         * specified, it defaults to `true`. Can be disabled only together
+         * with the Event Loop.
+         *
+         * Runtime without locking doesn't receive HMR updates
+         * and new Custom Serializable registrations.
+         *
+         * Disable only when you can guarantee thread safety of all access to the runtime.
+         */
+        enableLocking: false;
+      }
+  ) &
   (
     | {
         /**

package/Common/cpp/worklets/Registries/EventHandlerRegistry.cpp

@@ -1,95 +0,0 @@
-// EventHandlerRegistry was fully moved to Reanimated.
-// This file is kept only for backwards compatibility with older versions of Reanimated.
-
-#include <worklets/Registries/EventHandlerRegistry.h>
-#include <worklets/Tools/WorkletEventHandler.h>
-
-#include <memory>
-#include <string>
-#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 (const 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 (const 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 (const 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/Common/cpp/worklets/Registries/EventHandlerRegistry.h

@@ -1,44 +0,0 @@
-// EventHandlerRegistry was fully moved to Reanimated.
-// This file is kept only for backwards compatibility with older versions of Reanimated.
-
-#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/Common/cpp/worklets/Tools/WorkletEventHandler.cpp

@@ -1,34 +0,0 @@
-// WorkletEventHandler was fully moved to Reanimated.
-// This file is kept only for backwards compatibility with older versions of Reanimated.
-
-#include <worklets/Tools/WorkletEventHandler.h>
-
-#include <memory>
-#include <string>
-
-namespace worklets {
-
-void WorkletEventHandler::process(
-    const std::shared_ptr<WorkletRuntime> &workletRuntime,
-    const double eventTimestamp,
-    const jsi::Value &eventValue) const {
-  workletRuntime->runSync(handlerFunction_, jsi::Value(eventTimestamp), eventValue);
-}
-
-uint64_t WorkletEventHandler::getHandlerId() const {
-  return handlerId_;
-}
-
-const std::string &WorkletEventHandler::getEventName() const {
-  return eventName_;
-}
-
-uint64_t WorkletEventHandler::getEmitterReactTag() const {
-  return emitterReactTag_;
-}
-
-bool WorkletEventHandler::shouldIgnoreEmitterReactTag() const {
-  return emitterReactTag_ == -1;
-}
-
-} // namespace worklets

package/Common/cpp/worklets/Tools/WorkletEventHandler.h

@@ -1,44 +0,0 @@
-// WorkletEventHandler was fully moved to Reanimated.
-// This file is kept only for backwards compatibility with older versions of Reanimated.
-
-#pragma once
-
-#include <worklets/SharedItems/Serializable.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <string>
-
-using namespace facebook;
-
-namespace worklets {
-
-class WorkletEventHandler {
-  const uint64_t handlerId_;
-  const uint64_t emitterReactTag_;
-  const std::string eventName_;
-  const std::shared_ptr<SerializableWorklet> handlerFunction_;
-
- public:
-  WorkletEventHandler(
-      const uint64_t handlerId,
-      const std::string &eventName,
-      const uint64_t emitterReactTag,
-      const std::shared_ptr<SerializableWorklet> &handlerFunction)
-      : handlerId_(handlerId),
-        emitterReactTag_(emitterReactTag),
-        eventName_(eventName),
-        handlerFunction_(handlerFunction) {}
-  void process(
-      const std::shared_ptr<WorkletRuntime> &workletRuntime,
-      double eventTimestamp,
-      const jsi::Value &eventValue) const;
-  uint64_t getHandlerId() const;
-  const std::string &getEventName() const;
-  uint64_t getEmitterReactTag() const;
-  bool shouldIgnoreEmitterReactTag() const;
-};
-
-} // namespace worklets

package/jest/pluginTestUtils.ts

@@ -1,16 +0,0 @@
-export function countOccurrences(haystack: string, needle: string): number {
-  if (!needle) {
-    return 0;
-  }
-  let count = 0;
-  let from = 0;
-  while (true) {
-    const idx = haystack.indexOf(needle, from);
-    if (idx === -1) {
-      break;
-    }
-    count++;
-    from = idx + needle.length;
-  }
-  return count;
-}