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

package/.worklets/dummy.md

@@ -0,0 +1 @@
+The purpose of this file is always have `.worklets` directory in the package, as some environments have trouble creating it dynamically.

package/Common/cpp/worklets/AnimationFrameQueue/AnimationFrameBatchinator.cpp

@@ -0,0 +1,64 @@
+#include <jsi/jsi.h>
+#include <worklets/AnimationFrameQueue/AnimationFrameBatchinator.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+void AnimationFrameBatchinator::addToBatch(jsi::Function &&callback) {
+  {
+    std::lock_guard<std::mutex> lock(callbacksMutex_);
+    callbacks_.push_back(std::make_shared<const jsi::Function>(std::move(callback)));
+  }
+  flush();
+}
+
+AnimationFrameBatchinator::JsiRequestAnimationFrame AnimationFrameBatchinator::getJsiRequestAnimationFrame() {
+  return [weakThis = weak_from_this()](facebook::jsi::Runtime &rt, const facebook::jsi::Value &callback) {
+    const auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    strongThis->addToBatch(callback.asObject(rt).asFunction(rt));
+  };
+}
+
+void AnimationFrameBatchinator::flush() {
+  if (flushRequested_.exchange(true)) {
+    return;
+  }
+
+  requestAnimationFrame_([weakThis = weak_from_this()](double timestampMs) {
+    const auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    auto callbacks = strongThis->pullCallbacks();
+    strongThis->flushRequested_ = false;
+
+    auto &uiWorkletRuntime = strongThis->uiWorkletRuntime_;
+    for (const auto &callback : callbacks) {
+      uiWorkletRuntime->runSync(*callback, timestampMs);
+    }
+  });
+}
+
+std::vector<std::shared_ptr<const jsi::Function>> AnimationFrameBatchinator::pullCallbacks() {
+  std::lock_guard<std::mutex> lock(callbacksMutex_);
+  return std::move(callbacks_);
+}
+
+AnimationFrameBatchinator::AnimationFrameBatchinator(
+    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+    RuntimeBindings::RequestAnimationFrame requestAnimationFrame)
+    : uiWorkletRuntime_(uiWorkletRuntime), requestAnimationFrame_(std::move(requestAnimationFrame)) {}
+
+} // namespace worklets

package/Common/cpp/worklets/AnimationFrameQueue/AnimationFrameBatchinator.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace worklets {
+
+class AnimationFrameBatchinator : public std::enable_shared_from_this<AnimationFrameBatchinator> {
+ public:
+  using JsiRequestAnimationFrame = std::function<void(jsi::Runtime &, const jsi::Value &)>;
+
+  void addToBatch(jsi::Function &&callback);
+  JsiRequestAnimationFrame getJsiRequestAnimationFrame();
+
+  AnimationFrameBatchinator(
+      const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+      RuntimeBindings::RequestAnimationFrame requestAnimationFrame);
+
+ private:
+  void flush();
+  std::vector<std::shared_ptr<const jsi::Function>> pullCallbacks();
+
+  std::vector<std::shared_ptr<const jsi::Function>> callbacks_{};
+  std::mutex callbacksMutex_{};
+  std::atomic_bool flushRequested_{};
+  std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;
+  std::function<void(std::function<void(const double)>)> requestAnimationFrame_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Compat/Holders.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+
+namespace worklets {
+
+class WorkletRuntimeHolder : public facebook::jsi::NativeState {
+ public:
+  explicit WorkletRuntimeHolder(const std::shared_ptr<WorkletRuntime> &runtime) : runtime_(runtime) {}
+
+  const std::shared_ptr<WorkletRuntime> runtime_;
+};
+
+class UISchedulerHolder : public facebook::jsi::NativeState {
+ public:
+  explicit UISchedulerHolder(const std::shared_ptr<UIScheduler> &scheduler) : scheduler_(scheduler) {}
+
+  const std::shared_ptr<UIScheduler> scheduler_;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Compat/StableApi.cpp

@@ -0,0 +1,145 @@
+#include <jsi/jsi.h>
+#include <worklets/Compat/Holders.h>
+#include <worklets/Compat/StableApi.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/SerializableRemoteFunction.h>
+#include <worklets/SharedItems/Shareable.h>
+#include <worklets/SharedItems/Synchronizable.h>
+#include <worklets/Tools/JSISerializer.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
+#include <worklets/WorkletRuntime/RuntimeHolder.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+
+namespace worklets {
+
+std::string JSIValueToStdString(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value) {
+  return worklets::stringifyJSIValue(rt, value);
+}
+
+void scheduleOnUI(const std::shared_ptr<UIScheduler> &uiScheduler, const std::function<void()> &job) {
+  uiScheduler->scheduleOnUI(job);
+}
+
+facebook::jsi::Runtime &getJSIRuntimeFromWorkletRuntime(const std::shared_ptr<WorkletRuntime> &workletRuntime) {
+  return workletRuntime->getJSIRuntime();
+}
+
+std::weak_ptr<WorkletRuntime> getWeakRuntimeFromJSIRuntime(jsi::Runtime &rt) {
+  return WorkletRuntime::getWeakRuntimeFromJSIRuntime(rt);
+}
+
+std::shared_ptr<Serializable>
+extractSerializable(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value, const std::string &errorMessage) {
+  return extractSerializableOrThrow(rt, value, errorMessage);
+}
+
+std::shared_ptr<Serializable> extractSerializable(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Value &value,
+    const std::string &errorMessage,
+    const Serializable::ValueType expectedType) {
+  switch (expectedType) {
+    case Serializable::ValueType::WorkletType:
+      return extractSerializableOrThrow<SerializableWorklet>(rt, value, errorMessage);
+    case Serializable::ValueType::UndefinedType:
+      return extractSerializableOrThrow<SerializableScalar>(rt, value, errorMessage);
+    case Serializable::ValueType::NullType:
+      return extractSerializableOrThrow<SerializableScalar>(rt, value, errorMessage);
+    case Serializable::ValueType::BooleanType:
+      return extractSerializableOrThrow<SerializableScalar>(rt, value, errorMessage);
+    case Serializable::ValueType::NumberType:
+      return extractSerializableOrThrow<SerializableScalar>(rt, value, errorMessage);
+    case Serializable::ValueType::BigIntType:
+      return extractSerializableOrThrow<SerializableBigInt>(rt, value, errorMessage);
+    case Serializable::ValueType::StringType:
+      return extractSerializableOrThrow<SerializableString>(rt, value, errorMessage);
+    case Serializable::ValueType::ObjectType:
+      return extractSerializableOrThrow<SerializableObject>(rt, value, errorMessage);
+    case Serializable::ValueType::ArrayType:
+      return extractSerializableOrThrow<SerializableArray>(rt, value, errorMessage);
+    case Serializable::ValueType::MapType:
+      return extractSerializableOrThrow<SerializableMap>(rt, value, errorMessage);
+    case Serializable::ValueType::SetType:
+      return extractSerializableOrThrow<SerializableSet>(rt, value, errorMessage);
+    case Serializable::ValueType::RemoteFunctionType:
+      return extractSerializableOrThrow<SerializableRemoteFunction>(rt, value, errorMessage);
+    case Serializable::ValueType::HandleType:
+      return extractSerializableOrThrow<SerializableInitializer>(rt, value, errorMessage);
+    case Serializable::ValueType::HostObjectType:
+      return extractSerializableOrThrow<SerializableHostObject>(rt, value, errorMessage);
+    case Serializable::ValueType::HostFunctionType:
+      return extractSerializableOrThrow<SerializableHostFunction>(rt, value, errorMessage);
+    case Serializable::ValueType::ArrayBufferType:
+      return extractSerializableOrThrow<SerializableArrayBuffer>(rt, value, errorMessage);
+    case Serializable::ValueType::TurboModuleLikeType:
+      return extractSerializableOrThrow<SerializableTurboModuleLike>(rt, value, errorMessage);
+    case Serializable::ValueType::ImportType:
+      return extractSerializableOrThrow<SerializableImport>(rt, value, errorMessage);
+    case Serializable::ValueType::SynchronizableType:
+      return extractSerializableOrThrow<Synchronizable>(rt, value, errorMessage);
+    case Serializable::ValueType::CustomType:
+      return extractSerializableOrThrow<CustomSerializable>(rt, value, errorMessage);
+    case Serializable::ValueType::SymbolType:
+      throw std::runtime_error("[Worklets] Not implemented.");
+    case Serializable::ValueType::ShareableType:
+      return extractSerializableOrThrow<Shareable>(rt, value, errorMessage);
+    case Serializable::ValueType::ErrorType:
+      return extractSerializableOrThrow<SerializableError>(rt, value, errorMessage);
+    case Serializable::ValueType::RegExpType:
+      return extractSerializableOrThrow<SerializableRegExp>(rt, value, errorMessage);
+    default:
+      throw std::runtime_error("[Worklets] Invalid expected type provided to extractSerializable.");
+  }
+}
+
+void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet) {
+  workletRuntime->runSync(std::static_pointer_cast<SerializableWorklet>(worklet));
+}
+
+void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet,
+    const facebook::jsi::Value &arg0) {
+  workletRuntime->runSync(std::static_pointer_cast<SerializableWorklet>(worklet), arg0);
+}
+
+void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet,
+    const facebook::jsi::Value &arg0,
+    const facebook::jsi::Value &arg1) {
+  workletRuntime->runSync(std::static_pointer_cast<SerializableWorklet>(worklet), arg0, arg1);
+}
+
+void runSyncOnRuntime(const std::shared_ptr<WorkletRuntime> &workletRuntime, const facebook::jsi::Function &function) {
+  workletRuntime->runSync(function);
+}
+
+void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const facebook::jsi::Function &function,
+    const facebook::jsi::Value &arg0) {
+  workletRuntime->runSync(function, arg0);
+}
+
+std::shared_ptr<WorkletRuntime> getWorkletRuntimeFromHolder(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &object) {
+  return object.getNativeState<WorkletRuntimeHolder>(rt)->runtime_;
+}
+
+std::shared_ptr<UIScheduler> getUISchedulerFromHolder(facebook::jsi::Runtime &rt, const facebook::jsi::Object &object) {
+  return object.getNativeState<UISchedulerHolder>(rt)->scheduler_;
+}
+
+void installRequestAnimationFrame(
+    facebook::jsi::Runtime &uiRuntime,
+    const RequestAnimationFrameHostFunction &requestAnimationFrame) {
+  jsi_utils::installJsiFunction(uiRuntime, "__nativeRequestAnimationFrame", requestAnimationFrame);
+}
+
+} // namespace worklets

package/Common/cpp/worklets/Compat/StableApi.h

@@ -0,0 +1,128 @@
+#pragma once
+
+/**
+ * Version of `react-native-worklets` which introduced current stable API.
+ * It can be used by libraries to verify they use a compatible version
+ * of `react-native-worklets` installed when integrating in C++.
+ */
+#define WORKLETS_STABLE_API_VERSION "0.9.0"
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace facebook::jsi {
+class Runtime;
+class Value;
+class Object;
+class Function;
+} // namespace facebook::jsi
+
+namespace worklets {
+
+class WorkletRuntime;
+class UIScheduler;
+
+class Serializable {
+ public:
+  virtual facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) = 0;
+
+  virtual ~Serializable();
+
+  enum class ValueType : std::uint8_t {
+    UndefinedType,
+    NullType,
+    BooleanType,
+    NumberType,
+    BigIntType,
+    StringType,
+    ObjectType,
+    ArrayType,
+    MapType,
+    SetType,
+    WorkletType,
+    RemoteFunctionType,
+    HandleType,
+    HostObjectType,
+    HostFunctionType,
+    ArrayBufferType,
+    TurboModuleLikeType,
+    ImportType,
+    SynchronizableType,
+    CustomType,
+    SymbolType, /* unused */
+    ShareableType,
+    ErrorType,
+    RegExpType,
+  };
+
+  explicit Serializable(ValueType valueType) : valueType_(valueType) {}
+
+  inline ValueType valueType() const {
+    return valueType_;
+  }
+
+  static std::shared_ptr<Serializable> undefined();
+
+ protected:
+  ValueType valueType_;
+};
+
+extern std::shared_ptr<WorkletRuntime> getWorkletRuntimeFromHolder(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &object);
+
+extern std::shared_ptr<UIScheduler> getUISchedulerFromHolder(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Object &object);
+
+extern facebook::jsi::Runtime &getJSIRuntimeFromWorkletRuntime(const std::shared_ptr<WorkletRuntime> &workletRuntime);
+
+extern std::weak_ptr<WorkletRuntime> getWeakRuntimeFromJSIRuntime(facebook::jsi::Runtime &rt);
+
+extern void scheduleOnUI(const std::shared_ptr<UIScheduler> &uiScheduler, const std::function<void()> &job);
+
+extern std::string JSIValueToStdString(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value);
+
+extern std::shared_ptr<Serializable>
+extractSerializable(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value, const std::string &errorMessage);
+
+extern std::shared_ptr<Serializable> extractSerializable(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::Value &value,
+    const std::string &errorMessage,
+    const Serializable::ValueType expectedType);
+
+extern void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet);
+
+extern void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet,
+    const facebook::jsi::Value &arg0);
+
+extern void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::shared_ptr<Serializable> &worklet,
+    const facebook::jsi::Value &arg0,
+    const facebook::jsi::Value &arg1);
+
+extern void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const facebook::jsi::Function &worklet);
+
+extern void runSyncOnRuntime(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const facebook::jsi::Function &worklet,
+    const facebook::jsi::Value &arg0);
+
+using RequestAnimationFrameHostFunction =
+    std::function<void(facebook::jsi::Runtime &rt, const facebook::jsi::Value &callback)>;
+
+extern void installRequestAnimationFrame(
+    facebook::jsi::Runtime &uiRuntime,
+    const RequestAnimationFrameHostFunction &requestAnimationFrame);
+
+} // namespace worklets