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

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

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <string>
+
+namespace worklets {
+
+class SerializableHostFunction : public Serializable {
+ public:
+  SerializableHostFunction(
+      const facebook::jsi::HostFunctionType &function,
+      const std::string &name,
+      unsigned int paramCount)
+      : Serializable(ValueType::HostFunctionType), hostFunction_(function), name_(name), paramCount_(paramCount) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  const facebook::jsi::HostFunctionType hostFunction_;
+  const std::string name_;
+  const unsigned int paramCount_;
+};
+
+facebook::jsi::Value makeSerializableHostFunction(
+    facebook::jsi::Runtime &rt,
+    const facebook::jsi::HostFunctionType &function,
+    const std::string &name,
+    unsigned int paramCount);
+
+} // namespace worklets

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

@@ -0,0 +1,19 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableHostObject.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+jsi::Value SerializableHostObject::toJSValue(jsi::Runtime &rt) {
+  return jsi::Object::createFromHostObject(rt, hostObject_);
+}
+
+jsi::Value makeSerializableHostObject(jsi::Runtime &rt, const std::shared_ptr<jsi::HostObject> &value) {
+  const auto serializable = std::make_shared<SerializableHostObject>(rt, value);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <memory>
+
+namespace worklets {
+
+class SerializableHostObject : public Serializable {
+ public:
+  SerializableHostObject(facebook::jsi::Runtime &, const std::shared_ptr<facebook::jsi::HostObject> &hostObject)
+      : Serializable(ValueType::HostObjectType), hostObject_(hostObject) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  const std::shared_ptr<facebook::jsi::HostObject> hostObject_;
+};
+
+facebook::jsi::Value makeSerializableHostObject(
+    facebook::jsi::Runtime &rt,
+    const std::shared_ptr<facebook::jsi::HostObject> &value);
+
+} // namespace worklets

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

@@ -0,0 +1,29 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableImport.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+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 makeSerializableImport(jsi::Runtime &rt, const double source, const jsi::String &imported) {
+  auto serializable = std::make_shared<SerializableImport>(rt, source, imported);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <string>
+
+namespace worklets {
+
+class SerializableImport : public Serializable {
+ public:
+  SerializableImport(facebook::jsi::Runtime &rt, const double source, const facebook::jsi::String &imported)
+      : Serializable(ValueType::ImportType), source_(source), imported_(imported.utf8(rt)) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  const double source_;
+  const std::string imported_;
+};
+
+facebook::jsi::Value
+makeSerializableImport(facebook::jsi::Runtime &rt, double source, const facebook::jsi::String &imported);
+
+} // namespace worklets

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

@@ -0,0 +1,44 @@
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+#include <worklets/SharedItems/Serializable/SerializableMap.h>
+
+#include <memory>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+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;
+}
+
+jsi::Value makeSerializableMap(jsi::Runtime &rt, const jsi::Array &keys, const jsi::Array &values) {
+  auto serializable = std::make_shared<SerializableMap>(rt, keys, values);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+class SerializableMap : public Serializable {
+ public:
+  SerializableMap(facebook::jsi::Runtime &rt, const facebook::jsi::Array &keys, const facebook::jsi::Array &values);
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  std::vector<std::pair<std::shared_ptr<Serializable>, std::shared_ptr<Serializable>>> data_;
+};
+
+facebook::jsi::Value
+makeSerializableMap(facebook::jsi::Runtime &rt, const facebook::jsi::Array &keys, const facebook::jsi::Array &values);
+
+} // namespace worklets

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

@@ -0,0 +1,80 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/RetainingSerializable.h>
+#include <worklets/SharedItems/Serializable/SerializableObject.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+namespace {
+
+void defineOwnDataProperty(jsi::Runtime &rt, const jsi::Object &target, const std::string &key, jsi::Value value) {
+  jsi::Object descriptor(rt);
+  descriptor.setProperty(rt, "configurable", true);
+  descriptor.setProperty(rt, "enumerable", true);
+  descriptor.setProperty(rt, "writable", true);
+  descriptor.setProperty(rt, "value", std::move(value));
+
+  const auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
+  const auto defineProperty = objectCtor.getPropertyAsFunction(rt, "defineProperty");
+  defineProperty.call(rt, jsi::Value(rt, target), jsi::String::createFromUtf8(rt, key), std::move(descriptor));
+}
+
+} // namespace
+
+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_) {
+    if (i.first == "__proto__") [[unlikely]] {
+      defineOwnDataProperty(rt, obj, i.first, i.second->toJSValue(rt));
+    } else {
+      obj.setProperty(rt, jsi::String::createFromUtf8(rt, i.first), i.second->toJSValue(rt));
+    }
+  }
+  if (nativeState_ != nullptr) {
+    obj.setNativeState(rt, nativeState_);
+  }
+  return obj;
+}
+
+jsi::Value makeSerializableObject(
+    jsi::Runtime &rt,
+    jsi::Object object,
+    bool shouldRetainRemote,
+    const jsi::Value &nativeStateSource) {
+  std::shared_ptr<Serializable> serializable;
+  if (shouldRetainRemote) {
+    serializable = std::make_shared<RetainingSerializable<SerializableObject>>(rt, object, nativeStateSource);
+  } else {
+    serializable = std::make_shared<SerializableObject>(rt, object, nativeStateSource);
+  }
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+class SerializableObject : public Serializable {
+ public:
+  SerializableObject(facebook::jsi::Runtime &rt, const facebook::jsi::Object &object);
+
+  SerializableObject(
+      facebook::jsi::Runtime &rt,
+      const facebook::jsi::Object &object,
+      const facebook::jsi::Value &nativeStateSource);
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  std::vector<std::pair<std::string, std::shared_ptr<Serializable>>> data_;
+  std::shared_ptr<facebook::jsi::NativeState> nativeState_;
+};
+
+facebook::jsi::Value makeSerializableObject(
+    facebook::jsi::Runtime &rt,
+    facebook::jsi::Object object,
+    bool shouldRetainRemote,
+    const facebook::jsi::Value &nativeStateSource);
+
+} // namespace worklets

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

@@ -0,0 +1,22 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableRegExp.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+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 makeSerializableRegExp(jsi::Runtime &rt, const std::string &pattern, const std::string &flags) {
+  auto serializable = std::make_shared<SerializableRegExp>(pattern, flags);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <string>
+
+namespace worklets {
+
+class SerializableRegExp : public Serializable {
+ public:
+  SerializableRegExp(const std::string &pattern, const std::string &flags)
+      : Serializable(ValueType::RegExpType), pattern_(pattern), flags_(flags) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  const std::string pattern_;
+  const std::string flags_;
+};
+
+facebook::jsi::Value
+makeSerializableRegExp(facebook::jsi::Runtime &rt, const std::string &pattern, const std::string &flags);
+
+} // namespace worklets

package/Common/cpp/worklets/SharedItems/{SerializableRemoteFunction.cpp → Serializable/SerializableRemoteFunction.cpp}

@@ -1,7 +1,7 @@
 #include <jsi/jsi.h>
 #include <react/debug/react_native_assert.h>
-#include <worklets/SharedItems/Serializable.h>
-#include <worklets/SharedItems/SerializableRemoteFunction.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+#include <worklets/SharedItems/Serializable/SerializableRemoteFunction.h>
 #include <worklets/WorkletRuntime/RuntimeManager.h>
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
@@ -68,4 +68,32 @@ void SerializableRemoteFunction::resolveOrRejectPromise(
   }
 }
 
+jsi::Value makeRNRuntimeSerializableRemoteFunction(
+    jsi::Runtime &rnRuntime,
+    const std::string &name,
+    const jsi::Function &function,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus) {
+  auto serializable = std::make_shared<SerializableRemoteFunction>(
+      rnRuntime,
+      name,
+      jsi::Value(rnRuntime, function).getObject(rnRuntime).getFunction(rnRuntime),
+      jsScheduler,
+      rnRuntimeStatus);
+  return SerializableJSRef::newNativeStateObject(rnRuntime, serializable);
+}
+
+jsi::Value makeWorkletRuntimeSerializableRemoteFunction(
+    jsi::Runtime &workletRuntime,
+    const std::string &name,
+    const jsi::Function &function,
+    RuntimeData::RuntimeId hostRuntimeId) {
+  auto serializable = std::make_shared<SerializableRemoteFunction>(
+      workletRuntime,
+      name,
+      jsi::Value(workletRuntime, function).getObject(workletRuntime).getFunction(workletRuntime),
+      hostRuntimeId);
+  return SerializableJSRef::newNativeStateObject(workletRuntime, serializable);
+}
+
 } // namespace worklets

package/Common/cpp/worklets/SharedItems/{SerializableRemoteFunction.h → Serializable/SerializableRemoteFunction.h}

@@ -1,9 +1,10 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <worklets/SharedItems/Serializable.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
 #include <worklets/Tools/JSScheduler.h>
 #include <worklets/Tools/RNRuntimeStatus.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
 
 #include <memory>
 #include <string>
@@ -17,29 +18,29 @@ class SerializableRemoteFunction : public Serializable,
  public:
   /** Creates RN Runtime Remote Function. */
   SerializableRemoteFunction(
-      jsi::Runtime &rnRuntime,
+      facebook::jsi::Runtime &rnRuntime,
       const std::string &name,
-      jsi::Function &&function,
+      facebook::jsi::Function &&function,
       const std::shared_ptr<JSScheduler> &jsScheduler,
       const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus)
       : Serializable(ValueType::RemoteFunctionType),
         hostRuntime_(&rnRuntime),
         hostRuntimeId_(RuntimeData::rnRuntimeId),
-        function_(std::make_unique<jsi::Value>(rnRuntime, std::move(function))),
+        function_(std::make_unique<facebook::jsi::Value>(rnRuntime, std::move(function))),
         name_(name),
         jsScheduler_(jsScheduler),
         rnRuntimeStatus_(rnRuntimeStatus) {}
 
   /** Creates Worklet Runtime Remote Function. */
   SerializableRemoteFunction(
-      jsi::Runtime &workletRuntime,
+      facebook::jsi::Runtime &workletRuntime,
       const std::string &name,
-      jsi::Function &&function,
+      facebook::jsi::Function &&function,
       RuntimeData::RuntimeId hostRuntimeId)
       : Serializable(ValueType::RemoteFunctionType),
         hostRuntime_(&workletRuntime),
         hostRuntimeId_(hostRuntimeId),
-        function_(std::make_unique<jsi::Value>(workletRuntime, std::move(function))),
+        function_(std::make_unique<facebook::jsi::Value>(workletRuntime, std::move(function))),
         name_(name),
         jsScheduler_(nullptr),
         rnRuntimeStatus_(nullptr) {}
@@ -53,7 +54,7 @@ class SerializableRemoteFunction : public Serializable,
       const std::shared_ptr<Serializable> &resolveValue,
       const std::shared_ptr<RuntimeManager> &runtimeManager);
 
-  jsi::Value toJSValue(jsi::Runtime &rt) override;
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
 
   [[nodiscard]] bool isHostedOnRNRuntime() const noexcept {
     return hostRuntimeId_ == RuntimeData::rnRuntimeId;
@@ -64,12 +65,25 @@ class SerializableRemoteFunction : public Serializable,
   }
 
  private:
-  jsi::Runtime *hostRuntime_;
+  facebook::jsi::Runtime *hostRuntime_;
   const RuntimeData::RuntimeId hostRuntimeId_;
-  std::unique_ptr<jsi::Value> function_;
+  std::unique_ptr<facebook::jsi::Value> function_;
   const std::string name_;
   const std::shared_ptr<JSScheduler> jsScheduler_;
   const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
 };
 
+facebook::jsi::Value makeRNRuntimeSerializableRemoteFunction(
+    facebook::jsi::Runtime &rnRuntime,
+    const std::string &name,
+    const facebook::jsi::Function &function,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus);
+
+facebook::jsi::Value makeWorkletRuntimeSerializableRemoteFunction(
+    facebook::jsi::Runtime &workletRuntime,
+    const std::string &name,
+    const facebook::jsi::Function &function,
+    RuntimeData::RuntimeId hostRuntimeId);
+
 } // namespace worklets

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

@@ -0,0 +1,46 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableScalar.h>
+
+#include <memory>
+#include <stdexcept>
+
+using namespace facebook;
+
+namespace worklets {
+
+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 makeSerializableNumber(jsi::Runtime &rt, double number) {
+  const auto serializable = std::make_shared<SerializableScalar>(number);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+jsi::Value makeSerializableBoolean(jsi::Runtime &rt, bool boolean) {
+  const auto serializable = std::make_shared<SerializableScalar>(boolean);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+jsi::Value makeSerializableUndefined(jsi::Runtime &rt) {
+  const auto serializable = std::make_shared<SerializableScalar>();
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+jsi::Value makeSerializableNull(jsi::Runtime &rt) {
+  const auto serializable = std::make_shared<SerializableScalar>(nullptr);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <cstddef>
+
+namespace worklets {
+
+class SerializableScalar : public Serializable {
+ public:
+  explicit SerializableScalar(double number) : Serializable(ValueType::NumberType) {
+    data_.number = number;
+  }
+  explicit SerializableScalar(bool boolean) : Serializable(ValueType::BooleanType) {
+    data_.boolean = boolean;
+  }
+  SerializableScalar() : Serializable(ValueType::UndefinedType) {}
+  explicit SerializableScalar(std::nullptr_t) : Serializable(ValueType::NullType) {}
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &) override;
+
+ protected:
+  union Data {
+    bool boolean;
+    double number;
+  };
+
+ private:
+  Data data_;
+};
+
+facebook::jsi::Value makeSerializableNumber(facebook::jsi::Runtime &rt, double number);
+
+facebook::jsi::Value makeSerializableBoolean(facebook::jsi::Runtime &rt, bool boolean);
+
+facebook::jsi::Value makeSerializableUndefined(facebook::jsi::Runtime &rt);
+
+facebook::jsi::Value makeSerializableNull(facebook::jsi::Runtime &rt);
+
+} // namespace worklets

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

@@ -0,0 +1,36 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableSet.h>
+
+#include <memory>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+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 makeSerializableSet(jsi::Runtime &rt, const jsi::Array &values) {
+  auto serializable = std::make_shared<SerializableSet>(rt, values);
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/Serializable.h>
+
+#include <memory>
+#include <vector>
+
+namespace worklets {
+
+class SerializableSet : public Serializable {
+ public:
+  SerializableSet(facebook::jsi::Runtime &rt, const facebook::jsi::Array &values);
+
+  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
+
+ protected:
+  std::vector<std::shared_ptr<Serializable>> data_;
+};
+
+facebook::jsi::Value makeSerializableSet(facebook::jsi::Runtime &rt, const facebook::jsi::Array &values);
+
+} // namespace worklets

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

@@ -0,0 +1,19 @@
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Serializable/SerializableString.h>
+
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+jsi::Value SerializableString::toJSValue(jsi::Runtime &rt) {
+  return jsi::String::createFromUtf8(rt, data_);
+}
+
+jsi::Value makeSerializableString(jsi::Runtime &rt, const jsi::String &string) {
+  const auto serializable = std::make_shared<SerializableString>(string.utf8(rt));
+  return SerializableJSRef::newNativeStateObject(rt, serializable);
+}
+
+} // namespace worklets