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

package/Common/cpp/worklets/RunLoop/EventLoop.cpp

@@ -0,0 +1,103 @@
+#include <worklets/RunLoop/EventLoop.h>
+
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+EventLoop::EventLoop(
+    const std::string &name,
+    const std::shared_ptr<jsi::Runtime> &runtime,
+    const std::shared_ptr<AsyncQueue> &queue)
+    : runtime_(runtime), queue_(queue), timeoutsQueueState_(std::make_shared<TimeoutsQueueState>()), name_(name) {}
+
+EventLoop::~EventLoop() {
+  {
+    std::unique_lock<std::mutex> lock(timeoutsQueueState_->mutex);
+    timeoutsQueueState_->running = false;
+    timeoutsQueueState_->queue = {};
+  }
+  timeoutsQueueState_->cv.notify_all();
+}
+
+void EventLoop::run() {
+  const auto threadName = name_ + "(timeout)";
+  auto thread = std::thread([threadName, state = timeoutsQueueState_, weakThis = weak_from_this()] {
+#if __APPLE__
+    pthread_setname_np(threadName.c_str());
+#endif
+    while (state->running) {
+      std::unique_lock<std::mutex> lock(state->mutex);
+
+      if (state->queue.empty()) {
+        state->cv.wait(lock);
+      } else {
+        const auto &nextTimeout = state->queue[0];
+        const auto timeToWait = nextTimeout.targetTime - getCurrentTimeInMs();
+        state->cv.wait_for(lock, std::chrono::milliseconds(timeToWait));
+      }
+
+      // Early return if the Event Loop got destroyed already.
+      if (!state->running) {
+        return;
+      }
+
+      const auto currentTime = getCurrentTimeInMs();
+      std::vector<std::function<void(jsi::Runtime & rt)>> jobs;
+      auto &timeouts = state->queue;
+      timeouts.erase(
+          std::remove_if(
+              timeouts.begin(),
+              timeouts.end(),
+              [currentTime, &jobs](const Timeout &timeout) {
+                if (currentTime >= timeout.targetTime) {
+                  jobs.emplace_back(timeout.callback);
+                  return true;
+                }
+                return false;
+              }),
+          timeouts.end());
+      lock.unlock();
+
+      if (auto strongThis = weakThis.lock()) {
+        for (auto &job : jobs) {
+          strongThis->pushTask(std::move(job));
+        }
+      }
+    }
+  });
+#ifdef ANDROID
+  pthread_setname_np(thread.native_handle(), threadName.c_str());
+#endif
+  thread.detach();
+}
+
+void EventLoop::pushTask(std::function<void(jsi::Runtime &rt)> &&job) {
+  queue_->push([weakRuntime = std::weak_ptr<jsi::Runtime>{runtime_}, job = std::move(job)] {
+    if (auto runtime = weakRuntime.lock()) {
+      job(*runtime);
+    }
+  });
+}
+
+void EventLoop::pushTimeout(std::function<void(jsi::Runtime &rt)> &&job, int64_t delay) {
+  {
+    std::unique_lock<std::mutex> lock(timeoutsQueueState_->mutex);
+    const auto targetTime = getCurrentTimeInMs() + delay;
+    const auto timeout = Timeout{std::move(job), targetTime};
+    auto &queue = timeoutsQueueState_->queue;
+    auto it = std::upper_bound(queue.begin(), queue.end(), timeout);
+    queue.insert(it, timeout);
+  }
+  timeoutsQueueState_->cv.notify_one();
+}
+
+int64_t EventLoop::getCurrentTimeInMs() {
+  const auto currentTime = std::chrono::system_clock::now().time_since_epoch();
+  return std::chrono::duration_cast<std::chrono::milliseconds>(currentTime).count();
+}
+
+} // namespace worklets

package/Common/cpp/worklets/RunLoop/EventLoop.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/RunLoop/AsyncQueue.h>
+
+#include <atomic>
+#include <condition_variable>
+#include <memory>
+#include <queue>
+#include <string>
+#include <vector>
+
+using namespace facebook;
+
+namespace worklets {
+
+struct Timeout {
+  std::function<void(jsi::Runtime &rt)> callback;
+  int64_t targetTime;
+  bool operator<(const Timeout &v) const {
+    return targetTime < v.targetTime;
+  }
+};
+
+struct TimeoutsQueueState {
+  std::atomic_bool running{true};
+  std::mutex mutex;
+  std::condition_variable cv;
+  std::vector<Timeout> queue;
+};
+
+class EventLoop : public std::enable_shared_from_this<EventLoop> {
+ public:
+  EventLoop(
+      const std::string &name,
+      const std::shared_ptr<jsi::Runtime> &runtime,
+      const std::shared_ptr<AsyncQueue> &queue);
+  ~EventLoop();
+  void run();
+  void pushTask(std::function<void(jsi::Runtime &rt)> &&job);
+  void pushTimeout(std::function<void(jsi::Runtime &rt)> &&job, int64_t delay);
+
+ private:
+  const std::shared_ptr<jsi::Runtime> runtime_;
+  const std::shared_ptr<AsyncQueue> queue_;
+  const std::shared_ptr<TimeoutsQueueState> timeoutsQueueState_;
+  const std::string name_;
+
+  static int64_t getCurrentTimeInMs();
+};
+
+} // namespace worklets

package/Common/cpp/worklets/SharedItems/MemoryManager.cpp

@@ -0,0 +1,60 @@
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/MemoryManager.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+namespace worklets {
+void MemoryManager::loadAllCustomSerializables(const std::shared_ptr<WorkletRuntime> &runtime) {
+  std::lock_guard lock(customSerializationDataMutex_);
+  runtime->executeSync([&](jsi::Runtime &rt) -> jsi::Value {
+    const auto registry = getCustomSerializationRegistry(rt);
+    for (const auto &data : customSerializationData_) {
+      loadCustomSerializable(rt, registry, data);
+    }
+    return jsi::Value::undefined();
+  });
+}
+
+void MemoryManager::loadCustomSerializable(
+    const std::shared_ptr<WorkletRuntime> &runtime,
+    const SerializationData &data) {
+  std::lock_guard lock(customSerializationDataMutex_);
+  runtime->executeSync([this, data](jsi::Runtime &rt) -> jsi::Value {
+    const auto registry = getCustomSerializationRegistry(rt);
+    loadCustomSerializable(rt, registry, data);
+    return jsi::Value::undefined();
+  });
+}
+
+void MemoryManager::loadCustomSerializable(
+    jsi::Runtime &runtime,
+    const jsi::Array &registry,
+    const SerializationData &data) {
+  react_native_assert(
+      registry.length(runtime) == data.typeId &&
+      ("Custom serializable type ID must match registry length. Expected typeId: " + std::to_string(data.typeId) +
+       ", got registry length: " + std::to_string(registry.length(runtime)) +
+       ". Custom serializables must be registered in the same order across all runtimes.")
+          .c_str());
+
+  const auto item = jsi::Object(runtime);
+  item.setProperty(runtime, "determine", data.determine->toJSValue(runtime));
+  item.setProperty(runtime, "pack", data.pack->toJSValue(runtime));
+  item.setProperty(runtime, "unpack", data.unpack->toJSValue(runtime));
+  item.setProperty(runtime, "typeId", data.typeId);
+
+  registry.getPropertyAsFunction(runtime, "push").callWithThis(runtime, registry, item);
+}
+
+void MemoryManager::registerCustomSerializable(const SerializationData &data) {
+  std::lock_guard lock(customSerializationDataMutex_);
+  customSerializationData_.emplace_back(data);
+}
+
+jsi::Array MemoryManager::getCustomSerializationRegistry(jsi::Runtime &rt) {
+  const auto data = rt.global().getProperty(rt, "__customSerializationRegistry");
+  return data.asObject(rt).asArray(rt);
+}
+
+} // namespace worklets

package/Common/cpp/worklets/SharedItems/MemoryManager.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace worklets {
+class MemoryManager {
+ public:
+  void loadAllCustomSerializables(const std::shared_ptr<WorkletRuntime> &workletRuntime);
+
+  void loadCustomSerializable(const std::shared_ptr<WorkletRuntime> &workletRuntime, const SerializationData &data);
+
+  void registerCustomSerializable(const SerializationData &data);
+
+ private:
+  static jsi::Array getCustomSerializationRegistry(jsi::Runtime &rt);
+
+  void loadCustomSerializable(jsi::Runtime &runtime, const jsi::Array &registry, const SerializationData &data);
+
+  std::mutex customSerializationDataMutex_;
+  std::vector<SerializationData> customSerializationData_;
+};
+} // namespace worklets

package/Common/cpp/worklets/SharedItems/Serializable.cpp

@@ -0,0 +1,373 @@
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/SerializableFactory.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+namespace {
+
+jsi::Function getValueUnpacker(jsi::Runtime &rt) {
+  auto valueUnpacker = rt.global().getProperty(rt, "__valueUnpacker");
+  react_native_assert(valueUnpacker.isObject() && "valueUnpacker not found");
+  return valueUnpacker.asObject(rt).asFunction(rt);
+}
+
+} // namespace
+
+jsi::Value makeSerializableClone(
+    jsi::Runtime &rt,
+    const jsi::Value &value,
+    const jsi::Value &shouldRetainRemote,
+    const jsi::Value &nativeStateSource) {
+  std::shared_ptr<Serializable> serializable;
+  if (value.isObject()) {
+    auto object = value.asObject(rt);
+    if (!object.getProperty(rt, "__workletHash").isUndefined()) {
+      // We pass `false` because this function is invoked only
+      // by `makeSerializableCloneOnUIRecursive` which doesn't
+      // make Retaining Serializables.
+      return makeSerializableWorklet(rt, object, false);
+    } else if (!object.getProperty(rt, "__init").isUndefined()) {
+      return makeSerializableInitializer(rt, object);
+    } else if (object.isFunction(rt)) {
+      auto fun = object.asFunction(rt);
+      if (fun.isHostFunction(rt)) {
+        auto name = fun.getProperty(rt, "name").asString(rt).utf8(rt);
+        return makeSerializableHostFunction(
+            rt, fun.getHostFunction(rt), name, fun.getProperty(rt, "length").asNumber());
+      } else {
+        throw std::runtime_error(
+            "[Worklets] Cloning remote functions from Worklet Runtimes is only available in Bundle Mode.");
+      }
+    } else if (object.isArray(rt)) {
+      if (shouldRetainRemote.isBool() && shouldRetainRemote.getBool()) {
+        serializable = std::make_shared<RetainingSerializable<SerializableArray>>(rt, object.asArray(rt));
+      } else {
+        serializable = std::make_shared<SerializableArray>(rt, object.asArray(rt));
+      }
+    } else if (object.isArrayBuffer(rt)) {
+      serializable = std::make_shared<SerializableArrayBuffer>(rt, object.getArrayBuffer(rt));
+    } else if (object.isHostObject(rt)) {
+      if (object.isHostObject<SerializableJSRef>(rt)) {
+        return object;
+      }
+      serializable = std::make_shared<SerializableHostObject>(rt, object.getHostObject(rt));
+    } else {
+      if (shouldRetainRemote.isBool() && shouldRetainRemote.getBool()) {
+        serializable = std::make_shared<RetainingSerializable<SerializableObject>>(rt, object, nativeStateSource);
+      } else {
+        serializable = std::make_shared<SerializableObject>(rt, object, nativeStateSource);
+      }
+    }
+  } else if (value.isString()) {
+    serializable = std::make_shared<SerializableString>(value.asString(rt).utf8(rt));
+  } else if (value.isUndefined()) {
+    serializable = std::make_shared<SerializableScalar>();
+  } else if (value.isNull()) {
+    serializable = std::make_shared<SerializableScalar>(nullptr);
+  } else if (value.isBool()) {
+    serializable = std::make_shared<SerializableScalar>(value.getBool());
+  } else if (value.isNumber()) {
+    serializable = std::make_shared<SerializableScalar>(value.getNumber());
+  } else if (value.isBigInt()) {
+    serializable = std::make_shared<SerializableBigInt>(rt, value.getBigInt(rt));
+  } else if (value.isSymbol()) {
+    // TODO: this is only a placeholder implementation, here we replace symbols
+    // with strings in order to make certain objects to be captured. There isn't
+    // yet any use-case for using symbols on the UI runtime so it is fine to keep
+    // it like this for now.
+    serializable = std::make_shared<SerializableString>(value.getSymbol(rt).toString(rt));
+  } else {
+    throw std::runtime_error("[Worklets] Attempted to convert an unsupported value type.");
+  }
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+std::shared_ptr<Serializable> extractSerializableOrThrow(
+    jsi::Runtime &rt,
+    const jsi::Value &maybeSerializableValue,
+    const std::string &errorMessage) {
+  if (maybeSerializableValue.isObject()) {
+    auto object = maybeSerializableValue.getObject(rt);
+    return extractSerializableOrThrow(rt, object, errorMessage);
+  } else if (maybeSerializableValue.isUndefined()) {
+    return Serializable::undefined();
+  }
+  throw std::runtime_error(errorMessage);
+}
+
+std::shared_ptr<Serializable> extractSerializableOrThrow(
+    jsi::Runtime &rt,
+    const jsi::Object &maybeSerializableValue,
+    const std::string &errorMessage) {
+  if (maybeSerializableValue.hasNativeState(rt)) {
+    auto nativeState = maybeSerializableValue.getNativeState(rt);
+    return std::dynamic_pointer_cast<SerializableJSRef>(nativeState)->value();
+  }
+  throw std::runtime_error(errorMessage);
+}
+
+Serializable::~Serializable() = default;
+
+std::shared_ptr<Serializable> Serializable::undefined() {
+  static auto undefined = std::make_shared<SerializableScalar>();
+  return undefined;
+}
+
+SerializableJSRef::~SerializableJSRef() = default;
+
+SerializableArray::SerializableArray(jsi::Runtime &rt, const jsi::Array &array) : Serializable(ValueType::ArrayType) {
+  auto size = array.size(rt);
+  data_.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    data_.push_back(extractSerializableOrThrow(rt, array.getValueAtIndex(rt, i)));
+  }
+}
+
+jsi::Value SerializableArray::toJSValue(jsi::Runtime &rt) {
+  auto size = data_.size();
+  auto ary = jsi::Array(rt, size);
+  for (size_t i = 0; i < size; i++) {
+    ary.setValueAtIndex(rt, i, data_[i]->toJSValue(rt));
+  }
+  return ary;
+}
+
+jsi::Value SerializableArrayBuffer::toJSValue(jsi::Runtime &rt) {
+  auto size = static_cast<int>(data_.size());
+  auto arrayBuffer =
+      rt.global().getPropertyAsFunction(rt, "ArrayBuffer").callAsConstructor(rt, size).getObject(rt).getArrayBuffer(rt);
+  memcpy(arrayBuffer.data(rt), data_.data(), size);
+  if (!metadata_.has_value()) {
+    return arrayBuffer;
+  }
+
+  auto constructor = rt.global().getPropertyAsFunction(rt, metadata_->typeName.c_str());
+  return constructor.callAsConstructor(
+      rt, arrayBuffer, static_cast<double>(metadata_->byteOffset), static_cast<double>(metadata_->length));
+}
+
+SerializableObject::SerializableObject(jsi::Runtime &rt, const jsi::Object &object)
+    : Serializable(ValueType::ObjectType) {
+  auto propertyNames = object.getPropertyNames(rt);
+  auto size = propertyNames.size(rt);
+  data_.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    auto key = propertyNames.getValueAtIndex(rt, i).asString(rt);
+    auto value = extractSerializableOrThrow(rt, object.getProperty(rt, key));
+    data_.emplace_back(key.utf8(rt), value);
+  }
+  if (object.hasNativeState(rt)) {
+    nativeState_ = object.getNativeState(rt);
+  }
+}
+
+SerializableObject::SerializableObject(jsi::Runtime &rt, const jsi::Object &object, const jsi::Value &nativeStateSource)
+    : SerializableObject(rt, object) {
+  if (nativeStateSource.isObject() && nativeStateSource.asObject(rt).hasNativeState(rt)) {
+    nativeState_ = nativeStateSource.asObject(rt).getNativeState(rt);
+  }
+}
+
+jsi::Value SerializableObject::toJSValue(jsi::Runtime &rt) {
+  auto obj = jsi::Object(rt);
+  for (const auto &i : data_) {
+    obj.setProperty(rt, jsi::String::createFromUtf8(rt, i.first), i.second->toJSValue(rt));
+  }
+  if (nativeState_ != nullptr) {
+    obj.setNativeState(rt, nativeState_);
+  }
+  return obj;
+}
+
+SerializableMap::SerializableMap(jsi::Runtime &rt, const jsi::Array &keys, const jsi::Array &values)
+    : Serializable(ValueType::MapType) {
+  auto size = keys.size(rt);
+  react_native_assert(size == values.size(rt) && "Keys and values arrays must have the same size.");
+  data_.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    auto key = extractSerializableOrThrow(rt, keys.getValueAtIndex(rt, i));
+    auto value = extractSerializableOrThrow(rt, values.getValueAtIndex(rt, i));
+    data_.emplace_back(key, value);
+  }
+}
+
+jsi::Value SerializableMap::toJSValue(jsi::Runtime &rt) {
+  const auto keyValues = jsi::Array(rt, data_.size());
+  for (size_t i = 0, size = data_.size(); i < size; i++) {
+    const auto pair = jsi::Array(rt, 2);
+    pair.setValueAtIndex(rt, 0, data_[i].first->toJSValue(rt));
+    pair.setValueAtIndex(rt, 1, data_[i].second->toJSValue(rt));
+    keyValues.setValueAtIndex(rt, i, std::move(pair));
+  }
+
+  const auto &global = rt.global();
+  auto map = global.getPropertyAsFunction(rt, "Map").callAsConstructor(rt, std::move(keyValues));
+
+  return map;
+}
+
+SerializableSet::SerializableSet(jsi::Runtime &rt, const jsi::Array &values) : Serializable(ValueType::SetType) {
+  auto size = values.size(rt);
+  data_.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    data_.push_back(extractSerializableOrThrow(rt, values.getValueAtIndex(rt, i)));
+  }
+}
+
+jsi::Value SerializableSet::toJSValue(jsi::Runtime &rt) {
+  const auto values = jsi::Array(rt, data_.size());
+  for (size_t i = 0, size = data_.size(); i < size; i++) {
+    values.setValueAtIndex(rt, i, data_[i]->toJSValue(rt));
+  }
+
+  const auto &global = rt.global();
+  auto set = global.getPropertyAsFunction(rt, "Set").callAsConstructor(rt, std::move(values));
+
+  return set;
+}
+
+jsi::Value SerializableRegExp::toJSValue(jsi::Runtime &rt) {
+  return rt.global()
+      .getPropertyAsFunction(rt, "RegExp")
+      .callAsConstructor(rt, jsi::String::createFromUtf8(rt, pattern_), jsi::String::createFromUtf8(rt, flags_));
+}
+
+jsi::Value SerializableError::toJSValue(jsi::Runtime &rt) {
+  auto error = rt.global()
+                   .getPropertyAsFunction(rt, "Error")
+                   .callAsConstructor(rt, jsi::String::createFromUtf8(rt, message_))
+                   .getObject(rt);
+
+  error.setProperty(rt, "name", jsi::String::createFromUtf8(rt, name_));
+
+  if (stack_.has_value()) {
+    error.setProperty(rt, "stack", jsi::String::createFromUtf8(rt, stack_.value()));
+  } else {
+    error.setProperty(rt, "stack", jsi::String::createFromUtf8(rt, ""));
+  }
+
+  return error;
+}
+
+jsi::Value SerializableHostObject::toJSValue(jsi::Runtime &rt) {
+  return jsi::Object::createFromHostObject(rt, hostObject_);
+}
+
+jsi::Value SerializableHostFunction::toJSValue(jsi::Runtime &rt) {
+  return jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forUtf8(rt, name_), paramCount_, hostFunction_);
+}
+
+jsi::Value SerializableWorklet::toJSValue(jsi::Runtime &rt) {
+  react_native_assert(
+      std::any_of(data_.cbegin(), data_.cend(), [](const auto &item) { return item.first == "__workletHash"; }) &&
+      "SerializableWorklet doesn't have `__workletHash` property");
+  jsi::Value obj = SerializableObject::toJSValue(rt);
+  return getValueUnpacker(rt).call(rt, obj, jsi::String::createFromAscii(rt, "Worklet"));
+}
+
+jsi::Value SerializableImport::toJSValue(jsi::Runtime &rt) {
+  /**
+   * The only way to obtain a module in runtime is to use the Metro's require
+   * method implementation, which is injected into the global object as `__r`.
+   */
+  const auto metroRequire = rt.global().getProperty(rt, "__r");
+  if (metroRequire.isUndefined()) {
+    return jsi::Value::undefined();
+  }
+
+  const auto imported = jsi::String::createFromUtf8(rt, imported_);
+  return metroRequire.asObject(rt).asFunction(rt).call(rt, source_).asObject(rt).getProperty(rt, imported);
+}
+
+jsi::Value SerializableInitializer::toJSValue(jsi::Runtime &rt) {
+  if (remoteValue_ == nullptr) {
+    auto initObj = initializer_->toJSValue(rt);
+    auto value = std::make_unique<jsi::Value>(
+        getValueUnpacker(rt).call(rt, initObj, jsi::String::createFromAscii(rt, "Handle")));
+
+    // We are locking the initialization here since the thread that is
+    // initializing can be preempted on runtime lock. E.g.
+    // UI thread can be preempted on initialization of a shared value and then
+    // JS thread can try to access the shared value, locking the whole runtime.
+    // If we put the lock on `getValueUnpacker` part (basically any part that
+    // requires runtime) we would get a deadlock since UI thread would never
+    // release it.
+    std::unique_lock<std::mutex> lock(initializationMutex_);
+    if (remoteValue_ == nullptr) {
+      remoteValue_ = std::move(value);
+      remoteRuntime_ = &rt;
+    }
+  }
+  if (&rt == remoteRuntime_) {
+    return jsi::Value(rt, *remoteValue_);
+  }
+  auto initObj = initializer_->toJSValue(rt);
+  return getValueUnpacker(rt).call(rt, initObj, jsi::String::createFromAscii(rt, "Handle"));
+}
+
+jsi::Value SerializableString::toJSValue(jsi::Runtime &rt) {
+  return jsi::String::createFromUtf8(rt, data_);
+}
+
+jsi::Value SerializableBigInt::toJSValue(jsi::Runtime &rt) {
+  if (fastValue_.has_value()) {
+    return jsi::BigInt::fromInt64(rt, fastValue_.value());
+  } else {
+    return rt.global().getPropertyAsFunction(rt, "BigInt").call(rt, jsi::String::createFromUtf8(rt, slowValue_));
+  }
+}
+
+jsi::Value SerializableScalar::toJSValue(jsi::Runtime &) {
+  switch (valueType_) {
+    case Serializable::ValueType::UndefinedType:
+      return jsi::Value();
+    case Serializable::ValueType::NullType:
+      return jsi::Value(nullptr);
+    case Serializable::ValueType::BooleanType:
+      return jsi::Value(data_.boolean);
+    case Serializable::ValueType::NumberType:
+      return jsi::Value(data_.number);
+    default:
+      throw std::runtime_error("[Worklets] Attempted to convert object that's not of a scalar type.");
+  }
+}
+
+jsi::Value SerializableTurboModuleLike::toJSValue(jsi::Runtime &rt) {
+  auto obj = properties_->toJSValue(rt).asObject(rt);
+  const auto prototype = proto_->toJSValue(rt);
+  rt.global().getPropertyAsObject(rt, "Object").getPropertyAsFunction(rt, "setPrototypeOf").call(rt, obj, prototype);
+
+  return obj;
+}
+
+jsi::Function getCustomSerializableUnpacker(jsi::Runtime &rt) {
+  auto customSerializableUnpacker = rt.global().getProperty(rt, "__customSerializableUnpacker");
+  react_native_assert(customSerializableUnpacker.isObject() && "customSerializableUnpacker not found");
+  return customSerializableUnpacker.asObject(rt).asFunction(rt);
+}
+
+jsi::Value CustomSerializable::toJSValue(jsi::Runtime &rt) {
+  try {
+    auto unpack = getCustomSerializableUnpacker(rt);
+    auto data = data_->toJSValue(rt);
+
+    return unpack.call(rt, data, jsi::Value(typeId_));
+  } catch (jsi::JSError &e) {
+    throw std::runtime_error(
+        std::string("[Worklets] Failed to deserialize CustomSerializable. Reason: ") + e.getMessage());
+  }
+}
+
+} // namespace worklets