react-native-nitro-modules 0.1.5 → 0.1.7

package/cpp/core/HybridObject.cpp

@@ -99,7 +99,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   }
 
   // 2. There is either no value in cache, or it's already dead. Create a new one
-  auto cache = JSICache<jsi::Object>::getOrCreateCache(runtime);
+  auto cache = JSICache::getOrCreateCache(runtime);
   // 3. Create a new jsi::Object from this HybridObject/jsi::HostObject
   std::shared_ptr<HybridObject> shared = shared_from_this();
   jsi::Object object = jsi::Object::createFromHostObject(runtime, shared);
@@ -107,7 +107,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   size_t memorySize = getTotalExternalMemorySize();
   object.setExternalMemoryPressure(runtime, memorySize);
   // 5. Make it a global (weak) reference
-  auto global = cache.makeGlobal(std::move(object));
+  auto global = cache.makeGlobal<jsi::Object>(std::move(object));
   _jsObjects[&runtime] = global.weak();
   // 6. Return a jsi::Value copy again to the caller.
   return jsi::Value(runtime, *global);
@@ -177,12 +177,12 @@ jsi::Value HybridObject::get(facebook::jsi::Runtime& runtime, const facebook::js
     // it's a function. we now need to wrap it in a jsi::Function, store it in cache, then return it.
     HybridFunction& hybridFunction = _methods.at(name);
     // get (or create) a runtime-specific function cache
-    auto runtimeCache = JSICache<jsi::Function>::getOrCreateCache(runtime);
+    auto runtimeCache = JSICache::getOrCreateCache(runtime);
     // create the jsi::Function
     jsi::Function function = jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, name),
                                                                    hybridFunction.parameterCount, hybridFunction.function);
     // throw it into the cache for next time
-    OwningReference<jsi::Function> globalFunction = runtimeCache.makeGlobal(std::move(function));
+    OwningReference<jsi::Function> globalFunction = runtimeCache.makeGlobal<jsi::Function>(std::move(function));
     functionCache[name] = globalFunction;
     // copy the reference & return it to JS
     return jsi::Value(runtime, *globalFunction);

package/cpp/jsi/JSICache.cpp

@@ -0,0 +1,56 @@
+//
+//  JSICache.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.06.24.
+//
+
+#include "JSICache.hpp"
+#include "JSIHelpers.hpp"
+
+namespace margelo::nitro {
+
+static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
+
+JSICache::~JSICache() {
+  Logger::log(TAG, "Destroying JSICache...");
+  std::unique_lock lock(_mutex);
+
+  for (auto& func : _cache) {
+    OwningReference<jsi::Object> owning = func.lock();
+    if (owning) {
+      // Destroy all functions that we might still have in cache, some callbacks and Promises may now become invalid.
+      owning.destroy();
+    }
+  }
+}
+
+JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
+  auto found = _globalCache.find(&runtime);
+  if (found != _globalCache.end()) {
+    // Fast path: get weak_ptr to JSICache from our global list.
+    std::weak_ptr<JSICache> weak = found->second;
+    std::shared_ptr<JSICache> strong = weak.lock();
+    if (strong) {
+      // It's still alive! Return it
+      return JSICacheReference(strong);
+    }
+    Logger::log(TAG, "JSICache was created, but it is no longer strong!");
+  }
+
+  // Cache doesn't exist yet.
+  Logger::log(TAG, "Creating new JSICache<T> for runtime %s..", getRuntimeId(runtime));
+  // Create new cache
+  auto nativeState = std::make_shared<JSICache>(&runtime);
+  // Wrap it in a jsi::Value using NativeState
+  jsi::Object cache(runtime);
+  cache.setNativeState(runtime, nativeState);
+  // Inject it into the jsi::Runtime's global so it's memory is managed by it
+  runtime.global().setProperty(runtime, CACHE_PROP_NAME, std::move(cache));
+  // Add it to our map of caches
+  _globalCache[&runtime] = nativeState;
+  // Return it
+  return JSICacheReference(nativeState);
+}
+
+} // namespace margelo::nitro

package/cpp/jsi/JSICache.hpp

@@ -8,7 +8,6 @@
 #pragma once
 
 #include "BorrowingReference.hpp"
-#include "GetRuntimeID.hpp"
 #include "NitroLogger.hpp"
 #include "OwningReference.hpp"
 #include <jsi/jsi.h>
@@ -21,73 +20,23 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
-
-template <typename T>
-class JSICache;
-
-template <typename T>
-class JSICacheReference final {
-public:
-  JSICacheReference() = delete;
-  JSICacheReference(const JSICacheReference&) = delete;
-  JSICacheReference(JSICacheReference&&) = delete;
-
-  ~JSICacheReference() {
-    _strongCache->_mutex.unlock();
-  }
-
-public:
-  /**
-   Creates a reference to a `jsi::Value` that can be stored in memory and accessed later.
-   The `jsi::Value` will be managed by the `jsi::Runtime`, if the `jsi::Runtime` gets the destroyed,
-   so will the `jsi::Value`.
-
-   To access the `jsi::Value`, try to `.lock()` the `weak_ptr`.
-   If it can be locked, it is still valid, otherwise the Runtime has already been deleted.
-   Do not hold the returned `shared_ptr` in memory, only use it in the calling function's scope.
-   Note: By design, this is not thread-safe, the returned `weak_ptr` must only be locked on the same thread as it was created on.
-   */
-  OwningReference<T> makeGlobal(T&& value) {
-    auto owning = OwningReference<T>(new T(std::move(value)));
-    _strongCache->_cache.push_back(owning.weak());
-    return owning;
-  }
-
-private:
-  explicit JSICacheReference(const std::shared_ptr<JSICache<T>>& cache) : _strongCache(cache) {
-    _strongCache->_mutex.lock();
-  }
-
-private:
-  std::shared_ptr<JSICache<T>> _strongCache;
-
-  friend class JSICache<T>;
-};
+class JSICacheReference;
 
 /**
- * A `JSICache` can safely store `jsi::Pointer` instances (e.g. `jsi::Object` or
+ * A `JSICache` can safely store `jsi::Object` instances (e.g. `jsi::Object` or
  * `jsi::Function`) inside `OwningReference<T>`.
  *
- * `jsi::Pointer`s are managed by a `jsi::Runtime`, and will be deleted if the `jsi::Runtime`
- * is deleted - even if there are still strong references to the `jsi::Pointer`.
+ * `jsi::Object`s are managed by a `jsi::Runtime`, and will be deleted if the `jsi::Runtime`
+ * is deleted - even if there are still strong references to the `jsi::Object`.
+ *
+ * To access a `OwningReference<jsi::Object>` safely, use `lock()` to get an `OwningLock<jsi::Object>`.
+ * This will allow you to access the `jsi::Object` as long as the `OwningLock` is alive,
+ * and `JSICache` will hold any garbage collection calls until the `OwningLock` is destroyed.
  */
-template <typename T = jsi::Pointer>
 class JSICache final : public jsi::NativeState {
 public:
   explicit JSICache(jsi::Runtime* runtime) : _runtime(runtime) {}
-
-  ~JSICache() {
-    std::unique_lock lock(_mutex);
-
-    for (auto& func : _cache) {
-      OwningReference<T> owning = func.lock();
-      if (owning) {
-        // Destroy all functions that we might still have in cache, some callbacks and Promises may now become invalid.
-        owning.destroy();
-      }
-    }
-  }
+  ~JSICache();
 
 public:
   JSICache() = delete;
@@ -102,47 +51,61 @@ public:
    Do not hold the returned `shared_ptr` in memory, only use it in the calling function's scope.
    */
   [[nodiscard]]
-  static JSICacheReference<T> getOrCreateCache(jsi::Runtime& runtime) {
-    auto found = _globalCache.find(&runtime);
-    if (found != _globalCache.end()) {
-      // Fast path: get weak_ptr to JSICache from our global list.
-      std::weak_ptr<JSICache<T>> weak = found->second;
-      std::shared_ptr<JSICache<T>> strong = weak.lock();
-      if (strong) {
-        // It's still alive! Return it
-        return JSICacheReference<T>(strong);
-      }
-    }
-
-    // Cache doesn't exist yet.
-    Logger::log(TAG, "Creating new JSICache<T> for runtime %s..", getRuntimeId(runtime));
-    // Create new cache
-    auto nativeState = std::make_shared<JSICache<T>>(&runtime);
-    // Wrap it in a jsi::Value using NativeState
-    jsi::Object cache(runtime);
-    cache.setNativeState(runtime, nativeState);
-    // Inject it into the jsi::Runtime's global so it's memory is managed by it
-    runtime.global().setProperty(runtime, CACHE_PROP_NAME, std::move(cache));
-    // Add it to our map of caches
-    _globalCache[&runtime] = nativeState;
-    // Return it
-    return JSICacheReference<T>(nativeState);
-  }
+  static JSICacheReference getOrCreateCache(jsi::Runtime& runtime);
 
-public:
 private:
-  friend class JSICacheReference<T>;
+  friend class JSICacheReference;
 
 private:
   jsi::Runtime* _runtime;
   std::mutex _mutex;
-  std::vector<BorrowingReference<T>> _cache;
+  std::vector<BorrowingReference<jsi::Object>> _cache;
 
 private:
-  static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache<T>>> _globalCache;
+  static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache>> _globalCache;
 
 private:
   static constexpr auto TAG = "JSICache";
 };
 
+class JSICacheReference final {
+public:
+  JSICacheReference() = delete;
+  JSICacheReference(const JSICacheReference&) = delete;
+  JSICacheReference(JSICacheReference&&) = delete;
+
+  ~JSICacheReference() {
+    _strongCache->_mutex.unlock();
+  }
+
+public:
+  /**
+   * Creates a semi-strong reference to a `jsi::Object` that can be stored in memory and accessed later.
+   *
+   * The returned `OwningReference<T>` keeps the `T` semi-strong, and once it gets deleted, `T` will also be freed.
+   *
+   * Note: The JS Runtime can still delete `T` at any point (e.g. when it gets destroyed or reloaded),
+   * so any operations on `T` should be under an `OwningLock<T>`.
+   *
+   * To get an `OwningLock<T>` (which implies safe access to `T`), call `.locK()` on the `OwningReference<T>`.
+   * This will hold off any JS Runtime GC calls that will destroy `T` for as long as the `OwningLock<T>` is alive.
+   */
+  template <typename T>
+  OwningReference<T> makeGlobal(T&& value) {
+    OwningReference<jsi::Object> owning(new T(std::move(value)));
+    _strongCache->_cache.push_back(owning.weak());
+    return owning.as<T>();
+  }
+
+private:
+  explicit JSICacheReference(const std::shared_ptr<JSICache>& cache) : _strongCache(cache) {
+    _strongCache->_mutex.lock();
+  }
+
+private:
+  std::shared_ptr<JSICache> _strongCache;
+
+  friend class JSICache;
+};
+
 } // namespace margelo::nitro

package/cpp/jsi/JSIConverter+AnyMap.hpp

@@ -17,6 +17,7 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 
 #include "AnyMap.hpp"
+#include "JSIHelpers.hpp"
 #include <jsi/jsi.h>
 #include <memory>
 
@@ -33,6 +34,9 @@ struct JSIConverter<AnyValue> {
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const AnyValue& value) {
     return JSIConverter<AnyValue::variant>::toJSI(runtime, value);
   }
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    return JSIConverter<AnyValue::variant>::canConvert(runtime, value);
+  }
 };
 
 // AnyMap <> Record<K, V>
@@ -59,6 +63,24 @@ struct JSIConverter<std::shared_ptr<AnyMap>> {
     }
     return object;
   }
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isObject()) {
+      return false;
+    }
+    jsi::Object object = value.getObject(runtime);
+    if (!isPlainObject(runtime, object)) {
+      return false;
+    }
+    jsi::Array properties = object.getPropertyNames(runtime);
+    size_t size = properties.size(runtime);
+    for (size_t i = 0; i < size; i++) {
+      bool canConvertProp = JSIConverter<AnyValue>::canConvert(runtime, properties.getValueAtIndex(runtime, i));
+      if (!canConvertProp) {
+        return false;
+      }
+    }
+    return true;
+  }
 };
 
 } // namespace margelo::nitro

package/cpp/jsi/JSIConverter+ArrayBuffer.hpp

@@ -7,9 +7,7 @@
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
 class ArrayBuffer;
-
-template <typename T>
-struct JSICache;
+class JSICache;
 
 template <typename T, typename Enable>
 struct JSIConverter;
@@ -34,17 +32,25 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer
   static inline std::shared_ptr<ArrayBuffer> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     jsi::Object object = arg.asObject(runtime);
     if (!object.isArrayBuffer(runtime)) [[unlikely]] {
-      throw std::runtime_error("Object \"" + arg.toString(runtime).utf8(runtime) + "\" is not an ArrayBuffer!");
+      throw std::runtime_error("Object \"" + arg.toString(runtime).utf8(runtime) + "\" is not an ArrayBuffer! "
+                               "Are you maybe passing a TypedArray (e.g. Uint8Array)? Try to pass it's `.buffer` value.");
     }
 
-    JSICacheReference<jsi::ArrayBuffer> cache = JSICache<jsi::ArrayBuffer>::getOrCreateCache(runtime);
-    auto owningArrayBuffer = cache.makeGlobal(object.getArrayBuffer(runtime));
+    JSICacheReference cache = JSICache::getOrCreateCache(runtime);
+    auto owningArrayBuffer = cache.makeGlobal<jsi::ArrayBuffer>(object.getArrayBuffer(runtime));
 
     return std::make_shared<JSArrayBuffer>(&runtime, owningArrayBuffer);
   }
-  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::shared_ptr<jsi::MutableBuffer> buffer) {
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::shared_ptr<jsi::MutableBuffer>& buffer) {
     return jsi::ArrayBuffer(runtime, buffer);
   }
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isObject()) {
+      jsi::Object object = value.getObject(runtime);
+      return object.isArrayBuffer(runtime);
+    }
+    return false;
+  }
 };
 
 } // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Function.hpp

@@ -6,7 +6,6 @@
 
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
-template <typename T>
 class JSICache;
 
 template <typename T, typename Enable>
@@ -34,9 +33,9 @@ struct JSIConverter<std::function<ReturnType(Args...)>> {
 
   static inline std::function<ReturnType(Args...)> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     // Make function global - it'll be managed by the Runtime's memory, and we only have a weak_ref to it.
-    auto cache = JSICache<jsi::Function>::getOrCreateCache(runtime);
+    auto cache = JSICache::getOrCreateCache(runtime);
     jsi::Function function = arg.asObject(runtime).asFunction(runtime);
-    OwningReference<jsi::Function> sharedFunction = cache.makeGlobal(std::move(function));
+    OwningReference<jsi::Function> sharedFunction = cache.makeGlobal<jsi::Function>(std::move(function));
 
     std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
     std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
@@ -80,6 +79,14 @@ struct JSIConverter<std::function<ReturnType(Args...)>> {
     return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "hostFunction"), sizeof...(Args), jsFunction);
   }
 
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isObject()) {
+      jsi::Object object = value.getObject(runtime);
+      return object.isFunction(runtime);
+    }
+    return false;
+  }
+
 private:
   static inline ResultingType callJSFunction(jsi::Runtime& runtime, const OwningReference<jsi::Function>& function, const Args&... args) {
     // Throw a lock on the OwningReference<T> so we can guarantee safe access (Hermes GC cannot delete it while `lock` is alive)

package/cpp/jsi/JSIConverter+HybridObject.hpp

@@ -72,6 +72,14 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::HostObject>>>
     }
   }
 
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isObject()) {
+      jsi::Object object = value.getObject(runtime);
+      return object.isHostObject<TPointee>(runtime);
+    }
+    return false;
+  }
+
 private:
   static inline std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
     std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
@@ -120,6 +128,14 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>
     return object;
   }
 
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isObject()) {
+      jsi::Object object = value.getObject(runtime);
+      return object.hasNativeState<TPointee>(runtime);
+    }
+    return false;
+  }
+
 private:
   static inline std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
     std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();

package/cpp/jsi/JSIConverter+Optional.hpp

@@ -36,6 +36,15 @@ struct JSIConverter<std::optional<TInner>> {
       return JSIConverter<TInner>::toJSI(runtime, arg.value());
     }
   }
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (value.isUndefined() || value.isNull()) {
+      return true;
+    }
+    if (JSIConverter<TInner>::canConvert(runtime, value)) {
+      return true;
+    }
+    return false;
+  }
 };
 
 } // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -82,6 +82,10 @@ struct JSIConverter<std::future<TResult>> {
       });
     });
   }
+
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    throw std::runtime_error("jsi::Value of type Promise cannot be converted to std::future yet!");
+  }
 };
 
 } // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Tuple.hpp

@@ -42,6 +42,23 @@ struct JSIConverter<std::tuple<Types...>> {
     return array;
   }
 
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isObject()) {
+      return false;
+    }
+    jsi::Object object = value.getObject(runtime);
+    if (!object.isArray(runtime)) {
+      return false;
+    }
+    jsi::Array array = object.getArray(runtime);
+    size_t size = array.size(runtime);
+    if (size != sizeof...(Types)) {
+      return false;
+    }
+
+    return canConvertRecursive<Types...>(runtime, array, 0);
+  }
+
 private:
   template <std::size_t... Is>
   static inline std::tuple<Types...> copyArrayItemsToTuple(jsi::Runtime& runtime, const jsi::Array& array, std::index_sequence<Is...>) {
@@ -55,6 +72,22 @@ private:
                             JSIConverter<std::tuple_element_t<Is, std::tuple<Types...>>>::toJSI(runtime, std::get<Is>(tuple)))),
      ...);
   }
+
+  template <typename T>
+  static bool canConvertElement(jsi::Runtime& runtime, const jsi::Array& array, size_t index) {
+    return JSIConverter<T>::canConvert(runtime, array.getValueAtIndex(runtime, index));
+  }
+
+  template <typename First, typename... Rest>
+  static bool canConvertRecursive(jsi::Runtime& runtime, const jsi::Array& array, size_t index) {
+    if (!canConvertElement<First>(runtime, array, index)) {
+      return false;
+    }
+    if constexpr (sizeof...(Rest) > 0) {
+      return canConvertRecursive<Rest...>(runtime, array, index + 1);
+    }
+    return true;
+  }
 };
 
 } // namespace margelo::nitro

package/cpp/jsi/JSIConverter+UnorderedMap.hpp

@@ -13,6 +13,7 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 
 #include "AnyMap.hpp"
+#include "JSIHelpers.hpp"
 #include <jsi/jsi.h>
 #include <unordered_map>
 
@@ -45,6 +46,25 @@ struct JSIConverter<std::unordered_map<std::string, ValueType>> {
     }
     return object;
   }
+
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isObject()) {
+      return false;
+    }
+    jsi::Object object = value.getObject(runtime);
+    if (!isPlainObject(runtime, object)) {
+      return false;
+    }
+    jsi::Array properties = object.getPropertyNames(runtime);
+    size_t size = properties.size(runtime);
+    for (size_t i = 0; i < size; i++) {
+      bool canConvertProp = JSIConverter<ValueType>::canConvert(runtime, properties.getValueAtIndex(runtime, i));
+      if (!canConvertProp) {
+        return false;
+      }
+    }
+    return true;
+  }
 };
 
 } // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Variant.hpp

@@ -31,66 +31,38 @@ using namespace facebook;
 // std::variant<A, B, C> <> A | B | C
 template <typename... Types>
 struct JSIConverter<std::variant<Types...>> {
+
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    // Check each type in `Types...` to make sure we can convert `jsi::Value` to one of those.
+    return (JSIConverter<Types>::canConvert(runtime, value) || ...);
+  }
+
   static inline std::variant<Types...> fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
-    if (value.isNull()) {
-      if constexpr (is_in_pack_v<std::monostate, Types...>) {
-        return std::monostate();
-      } else {
-        throw typeNotSupportedError("null");
-      }
-    } else if (value.isBool()) {
-      if constexpr (is_in_pack_v<bool, Types...>) {
-        return JSIConverter<bool>::fromJSI(runtime, value);
-      } else {
-        throw typeNotSupportedError("boolean");
-      }
-    } else if (value.isNumber()) {
-      if constexpr (is_in_pack_v<double, Types...>) {
-        return JSIConverter<double>::fromJSI(runtime, value);
-      } else {
-        throw typeNotSupportedError("number");
-      }
-    } else if (value.isString()) {
-      if constexpr (is_in_pack_v<std::string, Types...>) {
-        return JSIConverter<std::string>::fromJSI(runtime, value);
-      } else {
-        throw typeNotSupportedError("string");
-      }
-    } else if (value.isBigInt()) {
-      if constexpr (is_in_pack_v<int64_t, Types...>) {
-        return JSIConverter<int64_t>::fromJSI(runtime, value);
-      } else {
-        throw typeNotSupportedError("bigint");
-      }
-    } else if (value.isObject()) {
-      jsi::Object valueObj = value.getObject(runtime);
-      if (valueObj.isArray(runtime)) {
-        if constexpr (is_in_pack_v<std::vector<AnyValue>, Types...>) {
-          return JSIConverter<std::vector<AnyValue>>::fromJSI(runtime, value);
-        } else {
-          throw typeNotSupportedError("array[]");
-        }
-      } else {
-        if constexpr (is_in_pack_v<std::unordered_map<std::string, AnyValue>, Types...>) {
-          return JSIConverter<std::unordered_map<std::string, AnyValue>>::fromJSI(runtime, value);
-        } else {
-          throw typeNotSupportedError("object{}");
-        }
-      }
-    } else {
-      std::string stringRepresentation = value.toString(runtime).utf8(runtime);
-      throw std::runtime_error("Cannot convert \"" + stringRepresentation + "\" to std::variant<...>!");
-    }
+    return fromJSIRecursive<Types...>(runtime, value);
   }
 
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::variant<Types...>& variant) {
-    return std::visit([&runtime](const auto& val) { return JSIConverter<std::decay_t<decltype(val)>>::toJSI(runtime, val); }, variant);
+    return std::visit(
+        [&runtime](const auto& val) {
+          // Try to convert each type
+          return JSIConverter<std::decay_t<decltype(val)>>::toJSI(runtime, val);
+        },
+        variant);
   }
 
 private:
-  static inline std::runtime_error typeNotSupportedError(const std::string& type) {
-    std::string types = TypeInfo::getFriendlyTypenames<Types...>();
-    return std::runtime_error(type + " is not supported in variant<" + types + ">!");
+  template <typename First, typename... Rest>
+  static inline std::variant<Types...> fromJSIRecursive(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (JSIConverter<First>::canConvert(runtime, value)) {
+      return JSIConverter<First>::fromJSI(runtime, value);
+    }
+    if constexpr (sizeof...(Rest) == 0) {
+      std::string string = value.toString(runtime).utf8(runtime);
+      std::string types = TypeInfo::getFriendlyTypenames<Types...>();
+      throw std::runtime_error("Cannot convert \"" + string + "\" to any type in variant<" + types + ">!");
+    } else {
+      return fromJSIRecursive<Rest...>(runtime, value);
+    }
   }
 };
 

package/cpp/jsi/JSIConverter+Vector.hpp

@@ -43,6 +43,27 @@ struct JSIConverter<std::vector<ElementType>> {
     }
     return array;
   }
+
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    if (!value.isObject()) {
+      return false;
+    }
+    jsi::Object object = value.getObject(runtime);
+    if (!object.isArray(runtime)) {
+      return false;
+    }
+    jsi::Array array = object.getArray(runtime);
+    if (array.size(runtime) == 0) {
+      // it is an empty array, so it _theoretically_ doesn't matter what type it holds. Just say true.
+      return true;
+    }
+    // Check the type of the first element in the array.
+    // Technically the array can also have different types for each item,
+    // and to be absolutely sure that we can convert the entire array, we have to check each item in the array.
+    // But we don't want to do that for performance reasons - let's just assume the user doesn't make this mistake.
+    jsi::Value firstElement = array.getValueAtIndex(runtime, 0);
+    return JSIConverter<ElementType>::canConvert(runtime, firstElement);
+  }
 };
 
 } // namespace margelo::nitro