react-native-wgpu 0.1.0 → 0.1.2

package/cpp/dawn/wire/client/webgpu_cpp.h

@@ -25,7 +25,7 @@
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef __EMSCRIPTEN__
-#error "Do not include this header. Emscripten already provides headers needed for WebGPU."
+#error "This header is for native Dawn. Use Dawn's or Emscripten's Emscripten bindings instead."
 #endif
 #ifndef DAWN_WIRE_CLIENT_WEBGPU_CPP_H_
 #define DAWN_WIRE_CLIENT_WEBGPU_CPP_H_
@@ -303,6 +303,8 @@ enum class FeatureName : uint32_t {
     RG11B10UfloatRenderable = WGPUFeatureName_RG11B10UfloatRenderable,
     BGRA8UnormStorage = WGPUFeatureName_BGRA8UnormStorage,
     Float32Filterable = WGPUFeatureName_Float32Filterable,
+    Subgroups = WGPUFeatureName_Subgroups,
+    SubgroupsF16 = WGPUFeatureName_SubgroupsF16,
     DawnInternalUsages = WGPUFeatureName_DawnInternalUsages,
     DawnMultiPlanarFormats = WGPUFeatureName_DawnMultiPlanarFormats,
     DawnNative = WGPUFeatureName_DawnNative,
@@ -1887,6 +1889,7 @@ struct AdapterInfo {
     Bool const compatibilityMode = false;
 
   private:
+    inline void FreeMembers();
     static inline void Reset(AdapterInfo& value);
 };
 
@@ -1911,6 +1914,7 @@ struct AdapterProperties {
     Bool const compatibilityMode = false;
 
   private:
+    inline void FreeMembers();
     static inline void Reset(AdapterProperties& value);
 };
 
@@ -2677,6 +2681,7 @@ struct SharedBufferMemoryEndAccessState {
     uint64_t const * const signaledValues = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(SharedBufferMemoryEndAccessState& value);
 };
 
@@ -2926,6 +2931,7 @@ struct SharedTextureMemoryEndAccessState {
     uint64_t const * const signaledValues = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(SharedTextureMemoryEndAccessState& value);
 };
 
@@ -3045,6 +3051,7 @@ struct SurfaceCapabilities {
     CompositeAlphaMode const * const alphaModes = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(SurfaceCapabilities& value);
 };
 
@@ -3299,6 +3306,7 @@ struct AdapterPropertiesMemoryHeaps : ChainedStructOut {
     MemoryHeapInfo const * const heapInfo = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(AdapterPropertiesMemoryHeaps& value);
 };
 
@@ -3381,6 +3389,7 @@ struct DrmFormatCapabilities : ChainedStructOut {
     DrmFormatProperties const * const properties = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(DrmFormatCapabilities& value);
 };
 
@@ -3716,10 +3725,7 @@ struct DeviceDescriptor : protected detail::DeviceDescriptor {
 // AdapterInfo implementation
 AdapterInfo::AdapterInfo() = default;
 AdapterInfo::~AdapterInfo() {
-    if (this->vendor != nullptr || this->architecture != nullptr || this->device != nullptr || this->description != nullptr) {
-        wgpuDawnWireClientAdapterInfoFreeMembers(
-            *reinterpret_cast<WGPUAdapterInfo*>(this));
-    }
+    FreeMembers();
 }
 
 AdapterInfo::AdapterInfo(AdapterInfo&& rhs)
@@ -3739,7 +3745,7 @@ AdapterInfo& AdapterInfo::operator=(AdapterInfo&& rhs) {
     if (&rhs == this) {
         return *this;
     }
-    this->~AdapterInfo();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->vendor) = std::move(rhs.vendor);
     ::wgpu::detail::AsNonConstReference(this->architecture) = std::move(rhs.architecture);
     ::wgpu::detail::AsNonConstReference(this->device) = std::move(rhs.device);
@@ -3753,7 +3759,14 @@ AdapterInfo& AdapterInfo::operator=(AdapterInfo&& rhs) {
     return *this;
 }
 
-    // static
+void AdapterInfo::FreeMembers() {
+    if (this->vendor != nullptr || this->architecture != nullptr || this->device != nullptr || this->description != nullptr) {
+        wgpuDawnWireClientAdapterInfoFreeMembers(
+            *reinterpret_cast<WGPUAdapterInfo*>(this));
+    }
+}
+
+// static
 void AdapterInfo::Reset(AdapterInfo& value) {
     AdapterInfo defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.vendor) = defaultValue.vendor;
@@ -3797,10 +3810,7 @@ static_assert(offsetof(AdapterInfo, compatibilityMode) == offsetof(WGPUAdapterIn
 // AdapterProperties implementation
 AdapterProperties::AdapterProperties() = default;
 AdapterProperties::~AdapterProperties() {
-    if (this->vendorName != nullptr || this->architecture != nullptr || this->name != nullptr || this->driverDescription != nullptr) {
-        wgpuDawnWireClientAdapterPropertiesFreeMembers(
-            *reinterpret_cast<WGPUAdapterProperties*>(this));
-    }
+    FreeMembers();
 }
 
 AdapterProperties::AdapterProperties(AdapterProperties&& rhs)
@@ -3820,7 +3830,7 @@ AdapterProperties& AdapterProperties::operator=(AdapterProperties&& rhs) {
     if (&rhs == this) {
         return *this;
     }
-    this->~AdapterProperties();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->vendorID) = std::move(rhs.vendorID);
     ::wgpu::detail::AsNonConstReference(this->vendorName) = std::move(rhs.vendorName);
     ::wgpu::detail::AsNonConstReference(this->architecture) = std::move(rhs.architecture);
@@ -3834,7 +3844,14 @@ AdapterProperties& AdapterProperties::operator=(AdapterProperties&& rhs) {
     return *this;
 }
 
-    // static
+void AdapterProperties::FreeMembers() {
+    if (this->vendorName != nullptr || this->architecture != nullptr || this->name != nullptr || this->driverDescription != nullptr) {
+        wgpuDawnWireClientAdapterPropertiesFreeMembers(
+            *reinterpret_cast<WGPUAdapterProperties*>(this));
+    }
+}
+
+// static
 void AdapterProperties::Reset(AdapterProperties& value) {
     AdapterProperties defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.vendorID) = defaultValue.vendorID;
@@ -5246,10 +5263,7 @@ static_assert(offsetof(SharedBufferMemoryDescriptor, label) == offsetof(WGPUShar
 // SharedBufferMemoryEndAccessState implementation
 SharedBufferMemoryEndAccessState::SharedBufferMemoryEndAccessState() = default;
 SharedBufferMemoryEndAccessState::~SharedBufferMemoryEndAccessState() {
-    if (this->fences != nullptr || this->signaledValues != nullptr) {
-        wgpuDawnWireClientSharedBufferMemoryEndAccessStateFreeMembers(
-            *reinterpret_cast<WGPUSharedBufferMemoryEndAccessState*>(this));
-    }
+    FreeMembers();
 }
 
 SharedBufferMemoryEndAccessState::SharedBufferMemoryEndAccessState(SharedBufferMemoryEndAccessState&& rhs)
@@ -5264,7 +5278,7 @@ SharedBufferMemoryEndAccessState& SharedBufferMemoryEndAccessState::operator=(Sh
     if (&rhs == this) {
         return *this;
     }
-    this->~SharedBufferMemoryEndAccessState();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->initialized) = std::move(rhs.initialized);
     ::wgpu::detail::AsNonConstReference(this->fenceCount) = std::move(rhs.fenceCount);
     ::wgpu::detail::AsNonConstReference(this->fences) = std::move(rhs.fences);
@@ -5273,7 +5287,14 @@ SharedBufferMemoryEndAccessState& SharedBufferMemoryEndAccessState::operator=(Sh
     return *this;
 }
 
-    // static
+void SharedBufferMemoryEndAccessState::FreeMembers() {
+    if (this->fences != nullptr || this->signaledValues != nullptr) {
+        wgpuDawnWireClientSharedBufferMemoryEndAccessStateFreeMembers(
+            *reinterpret_cast<WGPUSharedBufferMemoryEndAccessState*>(this));
+    }
+}
+
+// static
 void SharedBufferMemoryEndAccessState::Reset(SharedBufferMemoryEndAccessState& value) {
     SharedBufferMemoryEndAccessState defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.initialized) = defaultValue.initialized;
@@ -5700,10 +5721,7 @@ static_assert(offsetof(SharedTextureMemoryDmaBufPlane, stride) == offsetof(WGPUS
 // SharedTextureMemoryEndAccessState implementation
 SharedTextureMemoryEndAccessState::SharedTextureMemoryEndAccessState() = default;
 SharedTextureMemoryEndAccessState::~SharedTextureMemoryEndAccessState() {
-    if (this->fences != nullptr || this->signaledValues != nullptr) {
-        wgpuDawnWireClientSharedTextureMemoryEndAccessStateFreeMembers(
-            *reinterpret_cast<WGPUSharedTextureMemoryEndAccessState*>(this));
-    }
+    FreeMembers();
 }
 
 SharedTextureMemoryEndAccessState::SharedTextureMemoryEndAccessState(SharedTextureMemoryEndAccessState&& rhs)
@@ -5718,7 +5736,7 @@ SharedTextureMemoryEndAccessState& SharedTextureMemoryEndAccessState::operator=(
     if (&rhs == this) {
         return *this;
     }
-    this->~SharedTextureMemoryEndAccessState();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->initialized) = std::move(rhs.initialized);
     ::wgpu::detail::AsNonConstReference(this->fenceCount) = std::move(rhs.fenceCount);
     ::wgpu::detail::AsNonConstReference(this->fences) = std::move(rhs.fences);
@@ -5727,7 +5745,14 @@ SharedTextureMemoryEndAccessState& SharedTextureMemoryEndAccessState::operator=(
     return *this;
 }
 
-    // static
+void SharedTextureMemoryEndAccessState::FreeMembers() {
+    if (this->fences != nullptr || this->signaledValues != nullptr) {
+        wgpuDawnWireClientSharedTextureMemoryEndAccessStateFreeMembers(
+            *reinterpret_cast<WGPUSharedTextureMemoryEndAccessState*>(this));
+    }
+}
+
+// static
 void SharedTextureMemoryEndAccessState::Reset(SharedTextureMemoryEndAccessState& value) {
     SharedTextureMemoryEndAccessState defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.initialized) = defaultValue.initialized;
@@ -5938,10 +5963,7 @@ static_assert(offsetof(StorageTextureBindingLayout, viewDimension) == offsetof(W
 // SurfaceCapabilities implementation
 SurfaceCapabilities::SurfaceCapabilities() = default;
 SurfaceCapabilities::~SurfaceCapabilities() {
-    if (this->formats != nullptr || this->presentModes != nullptr || this->alphaModes != nullptr) {
-        wgpuDawnWireClientSurfaceCapabilitiesFreeMembers(
-            *reinterpret_cast<WGPUSurfaceCapabilities*>(this));
-    }
+    FreeMembers();
 }
 
 SurfaceCapabilities::SurfaceCapabilities(SurfaceCapabilities&& rhs)
@@ -5959,7 +5981,7 @@ SurfaceCapabilities& SurfaceCapabilities::operator=(SurfaceCapabilities&& rhs) {
     if (&rhs == this) {
         return *this;
     }
-    this->~SurfaceCapabilities();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->usages) = std::move(rhs.usages);
     ::wgpu::detail::AsNonConstReference(this->formatCount) = std::move(rhs.formatCount);
     ::wgpu::detail::AsNonConstReference(this->formats) = std::move(rhs.formats);
@@ -5971,7 +5993,14 @@ SurfaceCapabilities& SurfaceCapabilities::operator=(SurfaceCapabilities&& rhs) {
     return *this;
 }
 
-    // static
+void SurfaceCapabilities::FreeMembers() {
+    if (this->formats != nullptr || this->presentModes != nullptr || this->alphaModes != nullptr) {
+        wgpuDawnWireClientSurfaceCapabilitiesFreeMembers(
+            *reinterpret_cast<WGPUSurfaceCapabilities*>(this));
+    }
+}
+
+// static
 void SurfaceCapabilities::Reset(SurfaceCapabilities& value) {
     SurfaceCapabilities defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.usages) = defaultValue.usages;
@@ -6461,10 +6490,7 @@ AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps(AdapterPropertiesMemo
     heapCount(std::move(init.heapCount)), 
     heapInfo(std::move(init.heapInfo)){}
 AdapterPropertiesMemoryHeaps::~AdapterPropertiesMemoryHeaps() {
-    if (this->heapInfo != nullptr) {
-        wgpuDawnWireClientAdapterPropertiesMemoryHeapsFreeMembers(
-            *reinterpret_cast<WGPUAdapterPropertiesMemoryHeaps*>(this));
-    }
+    FreeMembers();
 }
 
 AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps(AdapterPropertiesMemoryHeaps&& rhs)
@@ -6477,14 +6503,21 @@ AdapterPropertiesMemoryHeaps& AdapterPropertiesMemoryHeaps::operator=(AdapterPro
     if (&rhs == this) {
         return *this;
     }
-    this->~AdapterPropertiesMemoryHeaps();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->heapCount) = std::move(rhs.heapCount);
     ::wgpu::detail::AsNonConstReference(this->heapInfo) = std::move(rhs.heapInfo);
     Reset(rhs);
     return *this;
 }
 
-    // static
+void AdapterPropertiesMemoryHeaps::FreeMembers() {
+    if (this->heapInfo != nullptr) {
+        wgpuDawnWireClientAdapterPropertiesMemoryHeapsFreeMembers(
+            *reinterpret_cast<WGPUAdapterPropertiesMemoryHeaps*>(this));
+    }
+}
+
+// static
 void AdapterPropertiesMemoryHeaps::Reset(AdapterPropertiesMemoryHeaps& value) {
     AdapterPropertiesMemoryHeaps defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.heapCount) = defaultValue.heapCount;
@@ -6631,10 +6664,7 @@ DrmFormatCapabilities::DrmFormatCapabilities(DrmFormatCapabilities::Init&& init)
     propertiesCount(std::move(init.propertiesCount)), 
     properties(std::move(init.properties)){}
 DrmFormatCapabilities::~DrmFormatCapabilities() {
-    if (this->properties != nullptr) {
-        wgpuDawnWireClientDrmFormatCapabilitiesFreeMembers(
-            *reinterpret_cast<WGPUDrmFormatCapabilities*>(this));
-    }
+    FreeMembers();
 }
 
 DrmFormatCapabilities::DrmFormatCapabilities(DrmFormatCapabilities&& rhs)
@@ -6647,14 +6677,21 @@ DrmFormatCapabilities& DrmFormatCapabilities::operator=(DrmFormatCapabilities&&
     if (&rhs == this) {
         return *this;
     }
-    this->~DrmFormatCapabilities();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->propertiesCount) = std::move(rhs.propertiesCount);
     ::wgpu::detail::AsNonConstReference(this->properties) = std::move(rhs.properties);
     Reset(rhs);
     return *this;
 }
 
-    // static
+void DrmFormatCapabilities::FreeMembers() {
+    if (this->properties != nullptr) {
+        wgpuDawnWireClientDrmFormatCapabilitiesFreeMembers(
+            *reinterpret_cast<WGPUDrmFormatCapabilities*>(this));
+    }
+}
+
+// static
 void DrmFormatCapabilities::Reset(DrmFormatCapabilities& value) {
     DrmFormatCapabilities defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.propertiesCount) = defaultValue.propertiesCount;

package/cpp/jsi/RNFHybridObject.cpp

@@ -3,7 +3,7 @@
 //
 #include "RNFHybridObject.h"
 #include "RNFJSIConverter.h"
-#include "Logger.h"
+#include "WGPULogger.h"
 
 #include <vector>
 #include <utility>

package/cpp/jsi/RNFHybridObject.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include "RNFJSIConverter.h"
-#include "Logger.h"
+#include "WGPULogger.h"
 #include "RNFWorkletRuntimeRegistry.h"
 #include <functional>
 #include <jsi/jsi.h>
@@ -74,11 +74,11 @@ private:
   std::unordered_map<std::string, jsi::HostFunctionType> _getters;
   std::unordered_map<std::string, jsi::HostFunctionType> _setters;
   std::unordered_map<jsi::Runtime*, std::unordered_map<std::string, std::shared_ptr<jsi::Function>>> _functionCache;
-  // Store a pointer to the runtime. Needed for checking if the runtime is still active, see WorkletRuntimeRegistry.
-  jsi::Runtime* _creationRuntime = nullptr;
 
 protected:
   const char* _name = TAG;
+  // Store a pointer to the runtime. Needed for checking if the runtime is still active, see WorkletRuntimeRegistry.
+  jsi::Runtime* _creationRuntime = nullptr;
 
 private:
   inline void ensureInitialized(facebook::jsi::Runtime& runtime);
@@ -89,7 +89,7 @@ private:
                                       std::index_sequence<Is...>, size_t count) {
     if constexpr (std::is_same_v<ReturnType, void>) {
       // It's a void method.
-      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is])...);
+      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is], Is >= count)...);
       return jsi::Value::undefined();
     } else {
       // It's returning some C++ type, we need to convert that to a JSI value now.

package/cpp/jsi/RNFJSIConverter.h

@@ -4,12 +4,6 @@
 
 #pragma once
 
-#include "RNFEnumMapper.h"
-#include "RNFHybridObject.h"
-#include "RNFJSIHelper.h"
-#include "RNFPromise.h"
-#include "RNFWorkletRuntimeRegistry.h"
-#include <jsi/jsi.h>
 #include <memory>
 #include <array>
 #include <future>
@@ -18,6 +12,18 @@
 #include <utility>
 #include <type_traits>
 #include <unordered_map>
+#include <limits>
+#include <variant>
+#include <map>
+#include <unordered_set>
+
+#include <jsi/jsi.h>
+
+#include "RNFEnumMapper.h"
+#include "RNFHybridObject.h"
+#include "RNFJSIHelper.h"
+#include "RNFPromise.h"
+#include "RNFWorkletRuntimeRegistry.h"
 
 #if __has_include(<cxxabi.h>)
 #include <cxxabi.h>
@@ -72,26 +78,64 @@ template <> struct JSIConverter<float> {
   }
 };
 
-// uint64_t <> BigInt
-template <> struct JSIConverter<uint64_t> {
-  static double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
-    return arg.asBigInt(runtime).asUint64(runtime);
+template <> struct JSIConverter<std::nullptr_t> {
+  static std::nullptr_t fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+    return nullptr;
   }
-  static jsi::Value toJSI(jsi::Runtime& runtime, uint64_t arg) {
-    return jsi::BigInt::fromUint64(runtime, arg);
+  static jsi::Value toJSI(jsi::Runtime&, std::nullptr_t arg) {
+    return jsi::Value::null();
+  }
+};
+
+template <typename T>
+struct JSIConverter<T, std::enable_if_t<!std::is_same_v<T, uint64_t> && std::is_same_v<T, size_t>>> {
+  static size_t fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+      if (arg.isNumber()) {
+          double value = arg.asNumber();
+          return static_cast<size_t>(value);
+      } else {
+          return arg.asBigInt(runtime).asInt64(runtime);
+      }
+  }
+
+  static jsi::Value toJSI(jsi::Runtime& runtime, size_t arg) {
+    return jsi::Value(static_cast<double>(arg));
   }
 };
 
-// int64_t <> BigInt
-template <> struct JSIConverter<int64_t> {
+// uint32_t <> double
+template <> struct JSIConverter<uint32_t> {
   static double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
-    return arg.asBigInt(runtime).asInt64(runtime);
+      double value = arg.asNumber();
+      return static_cast<uint32_t>(value);
   }
-  static jsi::Value toJSI(jsi::Runtime& runtime, int64_t arg) {
-    return jsi::BigInt::fromInt64(runtime, arg);
+  static jsi::Value toJSI(jsi::Runtime& runtime, uint32_t arg) {
+      return jsi::Value(static_cast<double>(arg));
   }
 };
 
+// uint64_t <> BigInt
+template <> struct JSIConverter<uint64_t> {
+  static uint64_t fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    if (arg.isNumber()) {
+      double value = arg.asNumber();
+      if (value < 0 || value > static_cast<double>(std::numeric_limits<uint64_t>::max())) {
+        throw jsi::JSError(runtime, "Number out of range for uint64_t");
+      }
+      return static_cast<uint64_t>(value);
+    } else {
+      return arg.asBigInt(runtime).getUint64(runtime);
+    }
+  }
+
+  static jsi::Value toJSI(jsi::Runtime& runtime, uint64_t arg) {
+    if (arg <= static_cast<uint64_t>(std::numeric_limits<double>::max())) {
+      return jsi::Value(static_cast<double>(arg));
+    } else {
+      throw jsi::JSError(runtime, "Number too large to be represented as a double");
+    }
+  }
+};
 
 // bool <> boolean
 template <> struct JSIConverter<bool> {
@@ -236,6 +280,33 @@ template <typename ReturnType, typename... Args> struct JSIConverter<std::functi
   }
 };
 
+// std::map<std::string, T> <> Record<string, T>
+template <typename ValueType> struct JSIConverter<std::map<std::string, ValueType>> {
+  static std::map<std::string, ValueType> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+    jsi::Object object = arg.asObject(runtime);
+    jsi::Array propertyNames = object.getPropertyNames(runtime);
+    size_t length = propertyNames.size(runtime);
+
+    std::map<std::string, ValueType> map;
+    for (size_t i = 0; i < length; ++i) {
+      std::string key = propertyNames.getValueAtIndex(runtime, i).asString(runtime).utf8(runtime);
+      jsi::Value value = object.getProperty(runtime, key.c_str());
+      map.emplace(key, JSIConverter<ValueType>::fromJSI(runtime, value, outOfBound));
+    }
+    return map;
+  }
+  static jsi::Value toJSI(jsi::Runtime& runtime, const std::map<std::string, ValueType>& map) {
+    jsi::Object object(runtime);
+    for (const auto& pair : map) {
+      jsi::Value value = JSIConverter<ValueType>::toJSI(runtime, pair.second);
+      jsi::String key = jsi::String::createFromUtf8(runtime, pair.first);
+      object.setProperty(runtime, key, std::move(value));
+    }
+    return object;
+  }
+};
+
+
 // std::vector<T> <> T[]
 template <typename ElementType> struct JSIConverter<std::vector<ElementType>> {
   static std::vector<ElementType> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
@@ -409,4 +480,120 @@ template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_n
   }
 };
 
+
+template <typename O, typename T>
+struct JSIConverter<std::variant<std::vector<T>, std::shared_ptr<O>>> {
+  using Target = std::variant<std::vector<T>, std::shared_ptr<O>>;
+
+  static Target fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                        bool outOfBound) {
+    if (arg.isObject()) {
+      auto object = arg.getObject(runtime);
+      if (object.isArray(runtime)) {
+        return Target(
+            JSIConverter<std::vector<T>>::fromJSI(runtime, arg, outOfBound));
+      }
+      throw std::runtime_error("Invalid variant type expected array");
+    }
+    return Target(
+        JSIConverter<std::shared_ptr<O>>::fromJSI(runtime, arg, outOfBound));
+  }
+
+  static jsi::Value toJSI(jsi::Runtime &, Target arg) {
+    return jsi::Value::null();
+  }
+};
+
+template <typename O>
+struct JSIConverter<std::variant<std::nullptr_t, std::shared_ptr<O>>> {
+  using Target = std::variant<std::nullptr_t, std::shared_ptr<O>>;
+
+  static Target fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                        bool outOfBound) {
+    if (arg.isNull()) {
+      return Target(nullptr);
+    }
+    return Target(
+        JSIConverter<std::shared_ptr<O>>::fromJSI(runtime, arg, outOfBound));
+  }
+
+  static jsi::Value toJSI(jsi::Runtime &runtime, Target arg) {
+    if (std::holds_alternative<std::nullptr_t>(arg)) {
+      return jsi::Value::null();
+    }
+    return JSIConverter<std::shared_ptr<O>>::toJSI(
+        runtime, std::get<std::shared_ptr<O>>(arg));
+  }
+};
+
+template <typename O>
+struct JSIConverter<std::variant<std::nullptr_t, O>,
+                    std::enable_if_t<std::is_enum_v<O>>> {
+  using Target = std::variant<std::nullptr_t, O>;
+
+  static Target fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                        bool outOfBound) {
+    if (arg.isNull()) {
+      return Target(nullptr);
+    } else if (arg.isNumber()) {
+      return Target(static_cast<O>(arg.asNumber()));
+    }
+    return Target(JSIConverter<O>::fromJSI(runtime, arg, outOfBound));
+  }
+
+  static jsi::Value toJSI(jsi::Runtime &runtime, Target arg) {
+    if (std::holds_alternative<std::nullptr_t>(arg)) {
+      return jsi::Value::null();
+    }
+    return JSIConverter<O>::toJSI(runtime, std::get<O>(arg));
+  }
+};
+
+// TODO: careful std::variant<O, std::nullptr_t> doesn't overload
+// std::variant<std::nullptr_t, 0> (order's matter)
+// variant<nullptr_t, numeric>
+template <typename O>
+struct JSIConverter<
+    std::variant<O, std::nullptr_t>,
+    std::enable_if_t<std::is_arithmetic_v<O> || std::is_enum_v<O>>> {
+  using Target = std::variant<O, std::nullptr_t>;
+  static Target fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                        bool outOfBound) {
+    if (arg.isNull()) {
+      return Target(nullptr);
+    }
+    if (arg.isNumber()) {
+      return Target(static_cast<O>(arg.asNumber()));
+    }
+    throw jsi::JSError(runtime, "Expected null or number");
+  }
+
+  static jsi::Value toJSI(jsi::Runtime &runtime, Target arg) {
+    if (std::holds_alternative<std::nullptr_t>(arg)) {
+      return jsi::Value::null();
+    }
+    return jsi::Value(static_cast<double>(std::get<O>(arg)));
+  }
+};
+
+template <>
+struct JSIConverter<std::unordered_set<std::string>> {
+  using Target = std::unordered_set<std::string>;
+  static Target fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                        bool outOfBound) {
+    throw jsi::JSError(runtime, "JSIConverter<std::unordered_set<std::string>>::fromJSI not implemented");
+  }
+
+  static jsi::Value toJSI(jsi::Runtime &runtime, Target arg) {
+    auto setConstructor = runtime.global().getPropertyAsFunction(runtime, "Set");
+    auto set = setConstructor.callAsConstructor(runtime).asObject(runtime);
+    auto add = set.getPropertyAsFunction(runtime, "add");
+    for (const auto& value : arg) {
+     jsi::Value jsiValue = JSIConverter<std::string>::toJSI(runtime, value);
+     add.callWithThis(runtime, set, jsiValue);
+    }
+    return std::move(set);
+  }
+};
+
 } // namespace margelo