@depup/react-native-worklets 0.11.3-depup.0

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

@@ -0,0 +1,75 @@
+#pragma once
+
+#ifndef NDEBUG
+
+#include <react/debug/react_native_assert.h>
+
+#include <cxxabi.h>
+
+#include <atomic>
+#include <cassert>
+#include <cstdlib>
+#include <iostream>
+#include <string>
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif // ANDROID
+
+namespace worklets {
+
+// This is a class that counts how many instances of a different class there
+// are. It is meant only to be used with classes that should only have one
+// instance.
+
+template <class T>
+class SingleInstanceChecker {
+ public:
+  SingleInstanceChecker();
+  ~SingleInstanceChecker();
+
+ private:
+  void assertWithMessage(bool condition, const std::string &message) {
+    if (!condition) {
+#ifdef ANDROID
+      __android_log_print(ANDROID_LOG_WARN, "Worklets", "%s", message.c_str());
+#else
+      std::cerr << "[Worklets] " << message << std::endl;
+#endif
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+      react_native_assert(false && "SingleInstanceChecker failed");
+#endif
+    }
+  }
+
+  // A static field will exist separately for every class template.
+  // This has to be inline for automatic initialization.
+  inline static std::atomic<int> instanceCount_;
+};
+
+template <class T>
+SingleInstanceChecker<T>::SingleInstanceChecker() {
+  int status = 0;
+  char *demangled = __cxxabiv1::__cxa_demangle(typeid(T).name(), nullptr, nullptr, &status);
+  std::string className = (status == 0 && demangled != nullptr) ? demangled : typeid(T).name();
+  std::free(demangled);
+
+  // React Native can spawn up to two instances of a Native Module at the same
+  // time. This happens during a reload when a new instance of React Native is
+  // created while simultaneously the old one is torn down.
+  instanceCount_++;
+  assertWithMessage(
+      instanceCount_ <= 2,
+      "[Worklets] More than two instances of " + className +
+          " present. This may indicate a memory leak due to a retain cycle.");
+}
+
+template <class T>
+SingleInstanceChecker<T>::~SingleInstanceChecker() {
+  instanceCount_--;
+}
+
+} // namespace worklets
+
+#endif // NDEBUG

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

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <utility>
+
+namespace worklets {
+
+//
+// Copyright (c) 2013 Juan Palacios juan.palacios.puyana@gmail.com
+// Subject to the BSD 2-Clause License
+// - see < https://opensource.org/license/bsd-2-clause/ >
+//
+template <typename T>
+class ThreadSafeQueue {
+ public:
+  T pop() {
+    std::unique_lock<std::mutex> mlock(mutex_);
+    while (queue_.empty()) {
+      cond_.wait(mlock);
+    }
+    const auto item = queue_.front();
+    queue_.pop();
+    return item;
+  }
+
+  void push(T &&item) {
+    std::unique_lock<std::mutex> mlock(mutex_);
+    queue_.push(std::move(item));
+    mlock.unlock();
+    cond_.notify_one();
+  }
+
+  bool empty() const {
+    std::unique_lock<std::mutex> mlock(mutex_);
+    const auto res = queue_.empty();
+    mlock.unlock();
+    cond_.notify_one();
+    return res;
+  }
+
+ private:
+  std::queue<T> queue_;
+  mutable std::mutex mutex_;
+  mutable std::condition_variable cond_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/UIScheduler.cpp

@@ -0,0 +1,19 @@
+#include <worklets/Tools/UIScheduler.h>
+
+#include <utility>
+
+namespace worklets {
+
+void UIScheduler::scheduleOnUI(std::function<void()> job) {
+  uiJobs_.push(std::move(job));
+}
+
+void UIScheduler::triggerUI() {
+  scheduledOnUI_ = false;
+  while (!uiJobs_.empty()) {
+    const auto job = uiJobs_.pop();
+    job();
+  }
+}
+
+} // namespace worklets

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

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <worklets/Tools/ThreadSafeQueue.h>
+
+#include <ReactCommon/CallInvoker.h>
+
+#include <atomic>
+
+namespace worklets {
+
+class UIScheduler {
+ public:
+  virtual void scheduleOnUI(std::function<void()> job);
+  virtual void triggerUI();
+  virtual ~UIScheduler() = default;
+
+ protected:
+  std::atomic<bool> scheduledOnUI_{false};
+  ThreadSafeQueue<std::function<void()>> uiJobs_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Tools/VersionUtils.cpp

@@ -0,0 +1,61 @@
+#include <worklets/Tools/VersionUtils.h>
+
+#include <iostream>
+#include <memory>
+#include <regex>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+bool matchVersion(const std::string &version1, const std::string &version2) {
+  std::regex pattern("^(\\d+)\\.(\\d+)\\.\\d+$");
+  std::smatch mv1;
+  std::smatch mv2;
+  if (std::regex_match(version1, mv1, pattern) && std::regex_match(version2, mv2, pattern)) {
+    return mv1[1].str() == mv2[1].str() && mv1[2].str() == mv2[2].str();
+  } else {
+    return version1 == version2;
+  }
+}
+
+void checkJSVersion(
+    jsi::Runtime &runtime,
+    jsi::Value &jsVersionValue,
+    const std::shared_ptr<worklets::JSLogger> &jsLogger,
+    const std::string &cppVersion,
+    const std::string &libraryName,
+    const std::string &docsBaseUrl) {
+  const auto libraryPrefix = std::string("[" + libraryName + "] ");
+
+  if (jsVersionValue.isUndefined()) {
+    jsLogger->warnOnJS(
+        std::string(
+            libraryPrefix +
+            "C++ side failed to resolve JavaScript code "
+            "version\n") +
+        "See " + docsBaseUrl +
+        "/guides/"
+        "troubleshooting#c-side-failed-to-resolve-javascript-code-version` for "
+        "more details.");
+    return;
+  }
+
+  const auto jsVersion = jsVersionValue.asString(runtime).utf8(runtime);
+
+  if (!matchVersion(cppVersion, jsVersion)) {
+    jsLogger->warnOnJS(
+        std::string(
+            libraryPrefix +
+            "Mismatch between C++ code version and "
+            "JavaScript code version (") +
+        cppVersion + " vs. " + jsVersion + " respectively).\n" + "See " + docsBaseUrl +
+        "/guides/"
+        "troubleshooting#mismatch-between-c-code-version-and-javascript-code-"
+        "version` for more details.");
+    return;
+  }
+}
+
+}; // namespace worklets

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <worklets/Tools/JSLogger.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <regex>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+bool matchVersion(const std::string &version1, const std::string &version2);
+
+void checkJSVersion(
+    jsi::Runtime &runtime,
+    jsi::Value &jsVersionValue,
+    const std::shared_ptr<worklets::JSLogger> &jsLogger,
+    const std::string &cppVersion,
+    const std::string &libraryName,
+    const std::string &docsBaseUrl);
+
+}; // namespace worklets

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

@@ -0,0 +1,34 @@
+// 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

@@ -0,0 +1,44 @@
+// 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/Common/cpp/worklets/Tools/WorkletsJSIUtils.cpp

@@ -0,0 +1,30 @@
+#include <worklets/Tools/WorkletsJSIUtils.h>
+
+#include <react/debug/react_native_assert.h>
+
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+using namespace facebook;
+
+namespace worklets::jsi_utils {
+
+jsi::Array convertStringToArray(jsi::Runtime &rt, const std::string &value, const unsigned int expectedSize) {
+  std::vector<float> transformMatrixList;
+  std::istringstream stringStream(value);
+  std::copy(
+      std::istream_iterator<float>(stringStream),
+      std::istream_iterator<float>(),
+      std::back_inserter(transformMatrixList));
+  react_native_assert(
+      transformMatrixList.size() == expectedSize && "Transform matrix list size is different than expected");
+  jsi::Array matrix(rt, expectedSize);
+  for (unsigned int i = 0; i < expectedSize; i++) {
+    matrix.setValueAtIndex(rt, i, transformMatrixList[i]);
+  }
+  return matrix;
+}
+
+} // namespace worklets::jsi_utils

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

@@ -0,0 +1,222 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets::jsi_utils {
+
+// `get` functions take a pointer to `jsi::Value` and
+// call an appropriate method to cast to the native type
+template <typename T>
+inline T get(jsi::Runtime &rt, const jsi::Value *value);
+
+template <>
+inline double get<double>(jsi::Runtime &, const jsi::Value *value) {
+  return value->asNumber();
+}
+
+template <>
+inline int get<int>(jsi::Runtime &, const jsi::Value *value) {
+  return value->asNumber();
+}
+
+template <>
+inline bool get<bool>(jsi::Runtime &, const jsi::Value *value) {
+  if (!value->isBool()) {
+    throw jsi::JSINativeException("[Worklets] Expected a boolean.");
+  }
+  return value->getBool();
+}
+
+template <>
+inline jsi::Object get<jsi::Object>(jsi::Runtime &rt, const jsi::Value *value) {
+  return value->asObject(rt);
+}
+
+template <>
+inline jsi::Value const &get<jsi::Value const &>(jsi::Runtime &, const jsi::Value *value) {
+  return *value;
+}
+
+// `convertArgs` functions take a variadic template parameter of target (C++)
+// argument types `Targs` and a `jsi::Value` array `args`, and converts `args`
+// to a tuple of typed C++ arguments to be passed to the native implementation.
+// This is accomplished by dispatching (at compile time) to the correct
+// implementation based on the first type of `Targs`, using SFINAE to select the
+// correct specialization, and concatenating with the result of recursion on the
+// rest of `Targs`
+
+// BEGIN implementations for `convertArgs` specializations.
+// specialization for empty `Targs` - returns an empty tuple
+template <typename... Args>
+inline std::enable_if_t<(sizeof...(Args) == 0), std::tuple<>> convertArgs(jsi::Runtime &, const jsi::Value *) {
+  return std::make_tuple();
+}
+
+// calls `get<First>` on the first argument to retrieve the native type,
+// then calls recursively on the rest of `args`
+// and returns the concatenation of results
+template <typename T, typename... Rest>
+inline std::tuple<T, Rest...> convertArgs(jsi::Runtime &rt, const jsi::Value *args) {
+  auto arg = std::tuple<T>(get<T>(rt, args));
+  auto rest = convertArgs<Rest...>(rt, std::next(args));
+  return std::tuple_cat(std::move(arg), std::move(rest));
+}
+// END implementations for `convertArgs` specializations.
+
+// returns a tuple with the result of casting `args` to appropriate
+// native C++ types needed to call `function`
+template <typename Ret, typename... Args>
+std::tuple<Args...>
+getArgsForFunction(std::function<Ret(Args...)>, jsi::Runtime &rt, const jsi::Value *args, const size_t count) {
+  react_native_assert(sizeof...(Args) == count && "Argument list has different length than expected");
+  return convertArgs<Args...>(rt, args);
+}
+
+// returns a tuple with the result of casting `args` to appropriate
+// native C++ types needed to call `function`,
+// passing `rt` as the first argument
+template <typename Ret, typename... Args>
+std::tuple<jsi::Runtime &, Args...> getArgsForFunction(
+    const std::function<Ret(jsi::Runtime &, Args...)> &,
+    jsi::Runtime &rt,
+    const jsi::Value *args,
+    const size_t count) {
+  react_native_assert(sizeof...(Args) == count && "Argument list has different length than expected");
+  return std::tuple_cat(std::tie(rt), convertArgs<Args...>(rt, args));
+}
+
+// calls `function` with `args`
+template <typename Ret, typename... Args>
+inline jsi::Value apply(std::function<Ret(Args...)> function, std::tuple<Args...> args) {
+  return std::apply(function, std::move(args));
+}
+
+// calls string-returning `function` with `args`,
+// and returns the string
+template <typename... Args>
+inline jsi::Value apply(jsi::Runtime &rt, std::function<std::string(Args...)> function, std::tuple<Args...> args) {
+  return jsi::String::createFromUtf8(rt, std::apply(function, std::move(args)));
+}
+
+// calls void-returning `function` with `args`,
+// and returns `undefined`
+template <typename... Args>
+inline jsi::Value apply(std::function<void(Args...)> function, std::tuple<Args...> args) {
+  std::apply(function, std::move(args));
+  return jsi::Value::undefined();
+}
+
+// returns a function with JSI calling convention
+// from a native function `function`
+template <typename Fun>
+jsi::HostFunctionType createHostFunction(const Fun &function) {
+  return [function](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, const size_t count) {
+    auto argz = getArgsForFunction(function, rt, args, count);
+    return apply(function, std::move(argz));
+  };
+}
+
+// returns a function with JSI calling convention
+// from a native function `function` returning a string
+template <typename... Args>
+jsi::HostFunctionType createHostFunction(std::function<std::string(Args...)> function) {
+  return [function](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, const size_t count) {
+    auto argz = getArgsForFunction(function, rt, args, count);
+    return apply(rt, function, std::move(argz));
+  };
+}
+
+// used to determine if `function<Ret(Args...)>`
+// takes `Runtime &` as its first argument
+template <typename... Args>
+struct takes_runtime {
+  static constexpr size_t value = 0;
+};
+
+// specialization for `function<Ret(Runtime &, Rest...)`
+template <typename... Rest>
+struct takes_runtime<jsi::Runtime &, Rest...> {
+  static constexpr size_t value = 1;
+};
+
+// creates a JSI compatible function from `function`
+// and installs it as a global function named `name`
+// in the `rt` JS runtime
+template <typename Ret, typename... Args>
+void installJsiFunction(jsi::Runtime &rt, std::string_view name, const std::function<Ret(Args...)> &function) {
+  auto clb = createHostFunction(function);
+  auto argsCount = static_cast<unsigned int>(sizeof...(Args) - takes_runtime<Args...>::value);
+  jsi::Value jsiFunction =
+      jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forAscii(rt, name.data()), argsCount, clb);
+  rt.global().setProperty(rt, name.data(), jsiFunction);
+}
+
+// this should take care of passing types convertible to `function`
+template <typename Fun>
+void installJsiFunction(jsi::Runtime &rt, std::string_view name, Fun function) {
+  installJsiFunction(rt, name, std::function(std::forward<Fun>(function)));
+}
+
+jsi::Array convertStringToArray(jsi::Runtime &rt, const std::string &value, const unsigned int expectedSize);
+
+template <size_t TIndex, size_t TLength>
+  requires(TIndex < TLength)
+constexpr const jsi::Value &at(const jsi::Value (&args)[TLength]) noexcept {
+  return args[TIndex];
+}
+
+template <size_t TLength, typename TFun>
+  requires(TLength > 0) &&
+    std::is_invocable_v<TFun &&, jsi::Runtime &, const jsi::Value &, const jsi::Value (&)[TLength]>
+void addMethod(jsi::Runtime &rt, jsi::Object &obj, const char *name, TFun &&func) {
+  obj.setProperty(
+      rt,
+      name,
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, name),
+          TLength,
+          [func = std::forward<TFun>(func)](
+              jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t) mutable -> jsi::Value {
+            using TReturn =
+                std::invoke_result_t<TFun &, jsi::Runtime &, const jsi::Value &, const jsi::Value(&)[TLength]>;
+            auto &typed = *reinterpret_cast<const jsi::Value(*)[TLength]>(args);
+            if constexpr (std::is_void_v<TReturn>) {
+              func(rt, thisVal, typed);
+              return jsi::Value::undefined();
+            } else {
+              return func(rt, thisVal, typed);
+            }
+          }));
+}
+
+template <size_t TLength, typename TFun>
+  requires(TLength == 0) && std::is_invocable_v<TFun &&, jsi::Runtime &, const jsi::Value &>
+void addMethod(jsi::Runtime &rt, jsi::Object &obj, const char *name, TFun &&func) {
+  obj.setProperty(
+      rt,
+      name,
+      jsi::Function::createFromHostFunction(
+          rt,
+          jsi::PropNameID::forAscii(rt, name),
+          0,
+          [func = std::forward<TFun>(func)](
+              jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *, size_t) mutable -> jsi::Value {
+            using TReturn = std::invoke_result_t<TFun &, jsi::Runtime &, const jsi::Value &>;
+            if constexpr (std::is_void_v<TReturn>) {
+              func(rt, thisVal);
+              return jsi::Value::undefined();
+            } else {
+              return func(rt, thisVal);
+            }
+          }));
+}
+
+} // namespace worklets::jsi_utils