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

package/Common/cpp/worklets/Networking/NetworkingInstaller.cpp

@@ -0,0 +1,127 @@
+#include <worklets/Networking/NetworkingInstaller.h>
+#include <worklets/Networking/TextDecoding.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
+
+#include <cmath>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+namespace {
+
+class NetworkingRuntimeGuard : public jsi::HostObject {
+ public:
+  NetworkingRuntimeGuard(std::weak_ptr<Networking> weakNetworking, const RuntimeData::RuntimeId runtimeId)
+      : weakNetworking_(std::move(weakNetworking)), runtimeId_(runtimeId) {}
+
+  ~NetworkingRuntimeGuard() override {
+    if (const auto networking = weakNetworking_.lock()) {
+      networking->abortAllForRuntime(runtimeId_);
+    }
+  }
+
+ private:
+  const std::weak_ptr<Networking> weakNetworking_;
+  const RuntimeData::RuntimeId runtimeId_;
+};
+
+// https://encoding.spec.whatwg.org/#decode - a BOM overrides the declared
+// encoding, so it is sniffed before the label is consulted.
+std::string decodeWithLabel(
+    const std::shared_ptr<Networking> &networking,
+    const uint8_t *data,
+    size_t size,
+    const std::string &label) {
+  if (size >= 2 && data[0] == 0xFE && data[1] == 0xFF) {
+    return text::decodeUtf16(data + 2, size - 2, /*littleEndian*/ false);
+  }
+  if (size >= 2 && data[0] == 0xFF && data[1] == 0xFE) {
+    return text::decodeUtf16(data + 2, size - 2, /*littleEndian*/ true);
+  }
+  if (size >= 3 && data[0] == 0xEF && data[1] == 0xBB && data[2] == 0xBF) {
+    data += 3;
+    size -= 3;
+    return text::decodeUtf8(data, size);
+  }
+  if (text::isUtf8Label(label)) {
+    return text::decodeUtf8(data, size);
+  }
+  if (text::isWindows1252Label(label)) {
+    return text::decodeWindows1252(data, size);
+  }
+  if (auto decoded = networking->decodeTextWithPlatform(data, size, label)) {
+    return text::toValidUtf8(*decoded);
+  }
+  return text::decodeUtf8(data, size);
+}
+
+jsi::Value decodeText(
+    jsi::Runtime &rt,
+    const std::shared_ptr<Networking> &networking,
+    const jsi::Value &bufferValue,
+    const jsi::Value &encodingValue) {
+  auto arrayBuffer = bufferValue.asObject(rt).getArrayBuffer(rt);
+  const auto label = text::normalizeEncodingLabel(encodingValue.isString() ? encodingValue.asString(rt).utf8(rt) : "");
+  return jsi::String::createFromUtf8(
+      rt, decodeWithLabel(networking, arrayBuffer.data(rt), arrayBuffer.size(rt), label));
+}
+
+} // namespace
+
+void NetworkingInstaller::install(
+    jsi::Runtime &rt,
+    const std::shared_ptr<Networking> &networking,
+    const RuntimeData::RuntimeId runtimeId) {
+  const auto weakNetworking = std::weak_ptr<Networking>(networking);
+
+  auto networkingObject = jsi::Object(rt);
+
+  jsi_utils::addMethod<2>(
+      rt,
+      networkingObject,
+      "sendRequest",
+      [weakNetworking](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[2]) -> jsi::Value {
+        const auto networking = weakNetworking.lock();
+        if (!networking) {
+          throw jsi::JSError(rt, "[Worklets] The networking module is no longer available.");
+        }
+        const auto requestId = networking->sendRequest(rt, args[0].asObject(rt), args[1].asObject(rt).asFunction(rt));
+        return {static_cast<double>(requestId)};
+      });
+
+  jsi_utils::addMethod<1>(
+      rt,
+      networkingObject,
+      "abortRequest",
+      [weakNetworking](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[1]) {
+        const auto requestId = args[0].asNumber();
+        if (!std::isfinite(requestId) || requestId < 1 || requestId >= 18446744073709551616.0 ||
+            std::trunc(requestId) != requestId) {
+          return;
+        }
+        if (const auto networking = weakNetworking.lock()) {
+          networking->abortRequest(rt, static_cast<uint64_t>(requestId));
+        }
+      });
+
+  jsi_utils::addMethod<2>(
+      rt,
+      networkingObject,
+      "decodeText",
+      [weakNetworking](jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[2]) -> jsi::Value {
+        const auto networking = weakNetworking.lock();
+        if (!networking) {
+          throw jsi::JSError(rt, "[Worklets] The networking module is no longer available.");
+        }
+        return decodeText(rt, networking, args[0], args[1]);
+      });
+
+  rt.global().setProperty(rt, "__workletsNetworking", networkingObject);
+
+  const auto guard = std::make_shared<NetworkingRuntimeGuard>(weakNetworking, runtimeId);
+  rt.global().setProperty(rt, "__workletsNetworkingGuard", jsi::Object::createFromHostObject(rt, guard));
+}
+
+} // namespace worklets

package/Common/cpp/worklets/Networking/NetworkingInstaller.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Networking/Networking.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+class NetworkingInstaller {
+ public:
+  static void
+  install(jsi::Runtime &rt, const std::shared_ptr<Networking> &networking, RuntimeData::RuntimeId runtimeId);
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Networking/NetworkingTypes.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+enum class RequestError : uint8_t {
+  Network = 0,
+  Timeout = 1,
+  Aborted = 2,
+};
+
+struct RequestConfig {
+  std::string method;
+  std::string url;
+  std::vector<std::pair<std::string, std::string>> headers;
+  std::optional<std::vector<uint8_t>> body;
+  double timeoutMs;
+  bool withCredentials;
+};
+
+struct ResponseInfo {
+  int status;
+  std::string statusText;
+  std::vector<std::pair<std::string, std::string>> headers;
+  std::string url;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Networking/TextDecoding.cpp

@@ -0,0 +1,189 @@
+#include <worklets/Networking/TextDecoding.h>
+
+#include <algorithm>
+#include <cctype>
+
+namespace worklets::text {
+
+namespace {
+
+constexpr uint32_t kReplacementCodePoint = 0xFFFD;
+
+// Code points for bytes 0x80-0x9F, where windows-1252 differs from Latin-1.
+constexpr uint16_t kWindows1252CodePoints[32] = {0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
+                                                 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
+                                                 0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
+                                                 0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178};
+
+void appendUtf8(std::string &result, const uint32_t codePoint) {
+  if (codePoint < 0x80) {
+    result.push_back(static_cast<char>(codePoint));
+  } else if (codePoint < 0x800) {
+    result.push_back(static_cast<char>(0xC0 | (codePoint >> 6)));
+    result.push_back(static_cast<char>(0x80 | (codePoint & 0x3F)));
+  } else if (codePoint < 0x10000) {
+    result.push_back(static_cast<char>(0xE0 | (codePoint >> 12)));
+    result.push_back(static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)));
+    result.push_back(static_cast<char>(0x80 | (codePoint & 0x3F)));
+  } else {
+    result.push_back(static_cast<char>(0xF0 | (codePoint >> 18)));
+    result.push_back(static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F)));
+    result.push_back(static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)));
+    result.push_back(static_cast<char>(0x80 | (codePoint & 0x3F)));
+  }
+}
+
+std::string decodeWindows1252Impl(const uint8_t *data, const size_t size) {
+  std::string result;
+  result.reserve(size);
+  for (size_t i = 0; i < size; i++) {
+    const auto byte = data[i];
+    if (byte >= 0x80 && byte < 0xA0) {
+      appendUtf8(result, kWindows1252CodePoints[byte - 0x80]);
+    } else {
+      appendUtf8(result, byte);
+    }
+  }
+  return result;
+}
+
+// The WHATWG Encoding Standard UTF-8 decoder, emitting U+FFFD for malformed
+// sequences. `jsi::String::createFromUtf8` has undefined behavior for invalid
+// UTF-8, so every byte sequence must pass through here first.
+std::string decodeUtf8Impl(const uint8_t *data, const size_t size) {
+  std::string result;
+  result.reserve(size);
+  uint32_t codePoint = 0;
+  int bytesNeeded = 0;
+  int bytesSeen = 0;
+  uint8_t lowerBoundary = 0x80;
+  uint8_t upperBoundary = 0xBF;
+  size_t index = 0;
+  while (index < size) {
+    const auto byte = data[index];
+    if (bytesNeeded == 0) {
+      index++;
+      if (byte <= 0x7F) {
+        result.push_back(static_cast<char>(byte));
+      } else if (byte >= 0xC2 && byte <= 0xDF) {
+        bytesNeeded = 1;
+        codePoint = byte & 0x1FU;
+      } else if (byte >= 0xE0 && byte <= 0xEF) {
+        lowerBoundary = byte == 0xE0 ? 0xA0 : 0x80;
+        upperBoundary = byte == 0xED ? 0x9F : 0xBF;
+        bytesNeeded = 2;
+        codePoint = byte & 0x0FU;
+      } else if (byte >= 0xF0 && byte <= 0xF4) {
+        lowerBoundary = byte == 0xF0 ? 0x90 : 0x80;
+        upperBoundary = byte == 0xF4 ? 0x8F : 0xBF;
+        bytesNeeded = 3;
+        codePoint = byte & 0x07U;
+      } else {
+        appendUtf8(result, kReplacementCodePoint);
+      }
+      continue;
+    }
+    if (byte < lowerBoundary || byte > upperBoundary) {
+      codePoint = 0;
+      bytesNeeded = 0;
+      bytesSeen = 0;
+      lowerBoundary = 0x80;
+      upperBoundary = 0xBF;
+      appendUtf8(result, kReplacementCodePoint);
+      continue;
+    }
+    lowerBoundary = 0x80;
+    upperBoundary = 0xBF;
+    codePoint = (codePoint << 6U) | (byte & 0x3FU);
+    bytesSeen++;
+    index++;
+    if (bytesSeen == bytesNeeded) {
+      appendUtf8(result, codePoint);
+      codePoint = 0;
+      bytesNeeded = 0;
+      bytesSeen = 0;
+    }
+  }
+  if (bytesNeeded != 0) {
+    appendUtf8(result, kReplacementCodePoint);
+  }
+  return result;
+}
+
+} // namespace
+
+std::string normalizeEncodingLabel(std::string label) {
+  constexpr auto isAsciiWhitespace = [](const unsigned char character) {
+    return character == 0x09 || character == 0x0A || character == 0x0C || character == 0x0D || character == 0x20;
+  };
+  const auto begin = std::find_if_not(label.begin(), label.end(), isAsciiWhitespace);
+  const auto end = std::find_if_not(label.rbegin(), label.rend(), isAsciiWhitespace).base();
+  label = begin < end ? std::string(begin, end) : std::string{};
+  std::transform(label.begin(), label.end(), label.begin(), [](const unsigned char character) {
+    return static_cast<char>(std::tolower(character));
+  });
+  return label;
+}
+
+// https://encoding.spec.whatwg.org/#names-and-labels
+bool isUtf8Label(const std::string &label) {
+  return label.empty() || label == "utf-8" || label == "utf8" || label == "unicode-1-1-utf-8" ||
+      label == "unicode11utf8" || label == "unicode20utf8" || label == "x-unicode20utf8";
+}
+
+// https://encoding.spec.whatwg.org/#names-and-labels
+bool isWindows1252Label(const std::string &label) {
+  return label == "ansi_x3.4-1968" || label == "ascii" || label == "cp1252" || label == "cp819" ||
+      label == "csisolatin1" || label == "ibm819" || label == "iso-8859-1" || label == "iso-ir-100" ||
+      label == "iso8859-1" || label == "iso88591" || label == "iso_8859-1" || label == "iso_8859-1:1987" ||
+      label == "l1" || label == "latin1" || label == "us-ascii" || label == "windows-1252" || label == "x-cp1252";
+}
+
+std::string decodeUtf8(const uint8_t *data, const size_t size) {
+  return decodeUtf8Impl(data, size);
+}
+
+std::string decodeWindows1252(const uint8_t *data, const size_t size) {
+  return decodeWindows1252Impl(data, size);
+}
+
+// https://encoding.spec.whatwg.org/#shared-utf-16-decoder
+std::string decodeUtf16(const uint8_t *data, const size_t size, const bool littleEndian) {
+  std::string result;
+  result.reserve(size);
+  uint32_t leadSurrogate = 0;
+  bool hasLeadSurrogate = false;
+  size_t index = 0;
+  while (index + 1 < size) {
+    const uint32_t unit = littleEndian
+        ? static_cast<uint32_t>(data[index]) | (static_cast<uint32_t>(data[index + 1]) << 8U)
+        : (static_cast<uint32_t>(data[index]) << 8U) | static_cast<uint32_t>(data[index + 1]);
+    index += 2;
+    if (hasLeadSurrogate) {
+      hasLeadSurrogate = false;
+      if (unit >= 0xDC00 && unit <= 0xDFFF) {
+        appendUtf8(result, 0x10000 + ((leadSurrogate - 0xD800) << 10U) + (unit - 0xDC00));
+        continue;
+      }
+      appendUtf8(result, kReplacementCodePoint);
+    }
+    if (unit >= 0xD800 && unit <= 0xDBFF) {
+      leadSurrogate = unit;
+      hasLeadSurrogate = true;
+    } else if (unit >= 0xDC00 && unit <= 0xDFFF) {
+      appendUtf8(result, kReplacementCodePoint);
+    } else {
+      appendUtf8(result, unit);
+    }
+  }
+  if (hasLeadSurrogate || index != size) {
+    appendUtf8(result, kReplacementCodePoint);
+  }
+  return result;
+}
+
+std::string toValidUtf8(const std::string &value) {
+  return decodeUtf8Impl(reinterpret_cast<const uint8_t *>(value.data()), value.size());
+}
+
+} // namespace worklets::text

package/Common/cpp/worklets/Networking/TextDecoding.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace worklets::text {
+
+/**
+ * Decoders for the WHATWG Encoding Standard subset the networking module
+ * handles in C++. Every function returns well-formed UTF-8, so the result is
+ * always safe to hand to `jsi::String::createFromUtf8`, whose behavior is
+ * undefined for invalid UTF-8.
+ */
+
+/** Normalizes an encoding label: trims ASCII whitespace and lowercases. */
+std::string normalizeEncodingLabel(std::string label);
+
+bool isUtf8Label(const std::string &label);
+bool isWindows1252Label(const std::string &label);
+
+std::string decodeUtf8(const uint8_t *data, size_t size);
+std::string decodeUtf16(const uint8_t *data, size_t size, bool littleEndian);
+std::string decodeWindows1252(const uint8_t *data, size_t size);
+
+/** Replaces malformed sequences in an already-UTF-8-ish string with U+FFFD. */
+std::string toValidUtf8(const std::string &value);
+
+} // namespace worklets::text

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

@@ -2,13 +2,41 @@
 
 #include <jsi/jsi.h>
 
+#include <cstdint>
+#include <utility>
+
 namespace worklets {
 
+/**
+ * Identifies the owner of a job, so that a queue shared between several owners
+ * can cancel the jobs of one of them without touching the jobs of the others.
+ *
+ * Worklet Runtimes send their RuntimeId as a token.
+ */
+using AbortToken = uint64_t;
+
+inline constexpr AbortToken defaultToken{0};
+
 class AsyncQueue : public facebook::jsi::NativeState {
  public:
   ~AsyncQueue() override = default;
 
   virtual void push(std::function<void()> &&job) = 0;
+
+  /**
+   * Pushes a job on behalf of the owner the token belongs to. The default
+   * implementation discards the token.
+   */
+  virtual void push(std::function<void()> &&job, AbortToken /* abortToken */) {
+    push(std::move(job));
+  }
+
+  /**
+   * Drops the jobs that are still pending, destroying them on the calling
+   * thread. A queue shared between several owners drops only the jobs pushed
+   * with this token. The default implementation keeps every job.
+   */
+  virtual void abortPending(AbortToken /* abortToken */) {}
 };
 
 } // namespace worklets

package/Common/cpp/worklets/RunLoop/AsyncQueueImpl.cpp

@@ -5,6 +5,7 @@
 #endif // ANDROID
 
 #include <memory>
+#include <queue>
 #include <string>
 #include <thread>
 #include <utility>
@@ -92,6 +93,14 @@ void AsyncQueueImpl::push(std::function<void()> &&job) {
   state_->cv.notify_one();
 }
 
+void AsyncQueueImpl::abortPending(AbortToken /* abortToken */) {
+  std::queue<std::function<void()>> pendingJobs;
+  {
+    std::unique_lock<std::mutex> lock(state_->mutex);
+    std::swap(pendingJobs, state_->queue);
+  }
+}
+
 AsyncQueueUI::AsyncQueueUI(const std::shared_ptr<UIScheduler> &uiScheduler) : uiScheduler_(uiScheduler) {}
 
 void AsyncQueueUI::push(std::function<void()> &&job) {

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

@@ -25,8 +25,12 @@ class AsyncQueueImpl : public AsyncQueue {
 
   ~AsyncQueueImpl() override;
 
+  using AsyncQueue::push;
+
   void push(std::function<void()> &&job) override;
 
+  void abortPending(AbortToken abortToken) override;
+
  private:
   static void runLoop(const std::shared_ptr<AsyncQueueState> &state);
 
@@ -39,6 +43,8 @@ class AsyncQueueUI : public AsyncQueue {
 
   ~AsyncQueueUI() override = default;
 
+  using AsyncQueue::push;
+
   void push(std::function<void()> &&job) override;
 
  private:

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

@@ -1,5 +1,4 @@
 #include <worklets/RunLoop/EventLoop.h>
-#include <worklets/Tools/WorkletsJSIUtils.h>
 
 #include <memory>
 #include <string>
@@ -11,10 +10,12 @@ namespace worklets {
 
 EventLoop::EventLoop(
     const std::string &name,
+    const AbortToken abortToken,
     const std::shared_ptr<jsi::Runtime> &runtime,
     const std::shared_ptr<AsyncQueue> &queue,
     const std::shared_ptr<std::recursive_mutex> &runtimeMutex)
-    : runtime_(runtime),
+    : abortToken_(abortToken),
+      runtime_(runtime),
       queue_(queue),
       runtimeMutex_(runtimeMutex),
       timeoutsQueueState_(std::make_shared<TimeoutsQueueState>()),
@@ -87,14 +88,28 @@ void EventLoop::pushTask(std::function<void(jsi::Runtime &rt)> &&job) {
         if (auto runtime = weakRuntime.lock()) {
           std::unique_lock lock(*runtimeMutex);
           job(*runtime);
-          jsi_utils::drainMicrotasks(*runtime);
+          runtime->drainMicrotasks();
         }
-      });
+      },
+      abortToken_);
+}
+
+void EventLoop::abortPending() {
+  std::vector<Timeout> pendingTimeouts;
+  {
+    std::unique_lock<std::mutex> lock(timeoutsQueueState_->mutex);
+    timeoutsQueueState_->running = false;
+    std::swap(pendingTimeouts, timeoutsQueueState_->queue);
+  }
+  timeoutsQueueState_->cv.notify_all();
 }
 
 void EventLoop::pushTimeout(std::function<void(jsi::Runtime &rt)> &&job, int64_t delay) {
   {
     std::unique_lock<std::mutex> lock(timeoutsQueueState_->mutex);
+    if (!timeoutsQueueState_->running) {
+      return;
+    }
     const auto targetTime = getCurrentTimeInMs() + delay;
     const auto timeout = Timeout{std::move(job), targetTime};
     auto &queue = timeoutsQueueState_->queue;

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

@@ -33,6 +33,7 @@ class EventLoop : public std::enable_shared_from_this<EventLoop> {
  public:
   EventLoop(
       const std::string &name,
+      AbortToken abortToken,
       const std::shared_ptr<jsi::Runtime> &runtime,
       const std::shared_ptr<AsyncQueue> &queue,
       const std::shared_ptr<std::recursive_mutex> &runtimeMutex);
@@ -40,8 +41,10 @@ class EventLoop : public std::enable_shared_from_this<EventLoop> {
   void run();
   void pushTask(std::function<void(jsi::Runtime &rt)> &&job);
   void pushTimeout(std::function<void(jsi::Runtime &rt)> &&job, int64_t delay);
+  void abortPending();
 
  private:
+  const AbortToken abortToken_;
   const std::shared_ptr<jsi::Runtime> runtime_;
   const std::shared_ptr<AsyncQueue> queue_;
   const std::shared_ptr<std::recursive_mutex> runtimeMutex_;

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

@@ -1,7 +1,7 @@
 #include <jsi/jsi.h>
 #include <react/debug/react_native_assert.h>
 #include <worklets/SharedItems/MemoryManager.h>
-#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 namespace worklets {

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

@@ -2,7 +2,8 @@
 
 #include <jsi/jsi.h>
 #include <react/debug/react_native_assert.h>
-#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Serializable/CustomSerializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>

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

@@ -0,0 +1,37 @@
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/Serializable/CustomSerializable.h>
+
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+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());
+  }
+}
+
+jsi::Value makeCustomSerializable(jsi::Runtime &rt, const jsi::Value &data, const int typeId) {
+  auto rawData = extractSerializableOrThrow(rt, data, "[Worklets] Data must be a Serializable object.");
+  auto customSerializable = std::make_shared<CustomSerializable>(rawData, typeId);
+  return SerializableJSRef::newNativeStateObject(rt, customSerializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableWorklet.h>
+
+#include <memory>
+
+namespace worklets {
+
+facebook::jsi::Function getCustomSerializableUnpacker(facebook::jsi::Runtime &rt);
+
+class CustomSerializable : public Serializable {
+ public:
+  CustomSerializable(std::shared_ptr<Serializable> data, const int typeId)
+      : Serializable(ValueType::CustomType), data_(std::move(data)), typeId_(typeId) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ private:
+  const std::shared_ptr<Serializable> data_;
+  const int typeId_;
+};
+
+struct SerializationData {
+  std::shared_ptr<SerializableWorklet> determine;
+  std::shared_ptr<SerializableWorklet> pack;
+  std::shared_ptr<SerializableWorklet> unpack;
+  int typeId;
+};
+
+facebook::jsi::Value makeCustomSerializable(facebook::jsi::Runtime &rt, const facebook::jsi::Value &data, int typeId);
+
+} // namespace worklets