react-native-nitro-modules 0.1.6 → 0.2.0

package/cpp/jsi/JSICache.cpp

@@ -6,17 +6,18 @@
 //
 
 #include "JSICache.hpp"
+#include "JSIHelpers.hpp"
+
+#define DOUBLE_CHECK_GLOBAL_CACHE 1
 
 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();
+template <typename T>
+inline void destroyReferences(const std::vector<BorrowingReference<T>>& references) {
+  for (auto& func : references) {
+    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();
@@ -24,9 +25,19 @@ JSICache::~JSICache() {
   }
 }
 
+JSICache::~JSICache() {
+  Logger::log(TAG, "Destroying JSICache...");
+  std::unique_lock lock(_mutex);
+
+  destroyReferences(_objectCache);
+  destroyReferences(_functionCache);
+  destroyReferences(_weakObjectCache);
+  destroyReferences(_arrayBufferCache);
+}
+
 JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
   auto found = _globalCache.find(&runtime);
-  if (found != _globalCache.end()) {
+  if (found != _globalCache.end()) [[likely]] {
     // 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();
@@ -37,10 +48,16 @@ JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
     Logger::log(TAG, "JSICache was created, but it is no longer strong!");
   }
 
+#if DOUBLE_CHECK_GLOBAL_CACHE
+  if (runtime.global().hasProperty(runtime, CACHE_PROP_NAME)) [[unlikely]] {
+    throw std::runtime_error("The Runtime \"" + getRuntimeId(runtime) + "\" already has a global cache! (\"" + CACHE_PROP_NAME + "\")");
+  }
+#endif
+
   // 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);
+  auto nativeState = std::shared_ptr<JSICache>(new JSICache(&runtime));
   // Wrap it in a jsi::Value using NativeState
   jsi::Object cache(runtime);
   cache.setNativeState(runtime, nativeState);

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>
@@ -24,19 +23,18 @@ using namespace facebook;
 class JSICacheReference;
 
 /**
- * A `JSICache` can safely store `jsi::Object` instances (e.g. `jsi::Object` or
+ * A `JSICache` can safely store `jsi::Value` instances (e.g. `jsi::Object` or
  * `jsi::Function`) inside `OwningReference<T>`.
  *
- * `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`.
+ * `jsi::Value`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::Value`.
  *
- * 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,
+ * To access a `OwningReference<jsi::Value>` safely, use `lock()` to get an `OwningLock<jsi::Value>`.
+ * This will allow you to access the `jsi::Value` as long as the `OwningLock` is alive,
  * and `JSICache` will hold any garbage collection calls until the `OwningLock` is destroyed.
  */
 class JSICache final : public jsi::NativeState {
 public:
-  explicit JSICache(jsi::Runtime* runtime) : _runtime(runtime) {}
   ~JSICache();
 
 public:
@@ -44,6 +42,9 @@ public:
   JSICache(const JSICache&) = delete;
   JSICache(JSICache&&) = delete;
 
+private:
+  explicit JSICache(jsi::Runtime* runtime) : _runtime(runtime) {}
+
 public:
   /**
    Gets or creates a `JSICache` for the given `jsi::Runtime`.
@@ -60,7 +61,10 @@ private:
 private:
   jsi::Runtime* _runtime;
   std::mutex _mutex;
-  std::vector<BorrowingReference<jsi::Object>> _cache;
+  std::vector<BorrowingReference<jsi::Object>> _objectCache;
+  std::vector<BorrowingReference<jsi::Function>> _functionCache;
+  std::vector<BorrowingReference<jsi::WeakObject>> _weakObjectCache;
+  std::vector<BorrowingReference<jsi::ArrayBuffer>> _arrayBufferCache;
 
 private:
   static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache>> _globalCache;
@@ -80,22 +84,25 @@ public:
   }
 
 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>();
+  OwningReference<jsi::Object> makeShared(jsi::Object&& value) {
+    OwningReference<jsi::Object> owning(new jsi::Object(std::move(value)));
+    _strongCache->_objectCache.push_back(owning.weak());
+    return owning;
+  }
+  OwningReference<jsi::Function> makeShared(jsi::Function&& value) {
+    OwningReference<jsi::Function> owning(new jsi::Function(std::move(value)));
+    _strongCache->_functionCache.push_back(owning.weak());
+    return owning;
+  }
+  OwningReference<jsi::WeakObject> makeShared(jsi::WeakObject&& value) {
+    OwningReference<jsi::WeakObject> owning(new jsi::WeakObject(std::move(value)));
+    _strongCache->_weakObjectCache.push_back(owning.weak());
+    return owning;
+  }
+  OwningReference<jsi::ArrayBuffer> makeShared(jsi::ArrayBuffer&& value) {
+    OwningReference<jsi::ArrayBuffer> owning(new jsi::ArrayBuffer(std::move(value)));
+    _strongCache->_arrayBufferCache.push_back(owning.weak());
+    return owning;
   }
 
 private:

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

@@ -31,18 +31,30 @@ template <typename T>
 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 DEBUG
     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.");
     }
+#endif
 
     JSICacheReference cache = JSICache::getOrCreateCache(runtime);
-    auto owningArrayBuffer = cache.makeGlobal<jsi::ArrayBuffer>(object.getArrayBuffer(runtime));
+    auto borrowingArrayBuffer = cache.makeShared(object.getArrayBuffer(runtime));
 
-    return std::make_shared<JSArrayBuffer>(&runtime, owningArrayBuffer);
+    return std::make_shared<JSArrayBuffer>(&runtime, borrowingArrayBuffer);
   }
   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

@@ -35,7 +35,7 @@ struct JSIConverter<std::function<ReturnType(Args...)>> {
     // Make function global - it'll be managed by the Runtime's memory, and we only have a weak_ref to it.
     auto cache = JSICache::getOrCreateCache(runtime);
     jsi::Function function = arg.asObject(runtime).asFunction(runtime);
-    OwningReference<jsi::Function> sharedFunction = cache.makeGlobal<jsi::Function>(std::move(function));
+    OwningReference<jsi::Function> sharedFunction = cache.makeShared(std::move(function));
 
     std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
     std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
@@ -79,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

@@ -7,117 +7,72 @@
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
 class HybridObject;
-
-template <typename T, typename Enable>
-struct JSIConverter;
 } // namespace margelo::nitro
 
-#include "JSIConverter.hpp"
-
-#include "HybridObject.hpp"
 #include "IsSharedPtrTo.hpp"
 #include "TypeInfo.hpp"
 #include <jsi/jsi.h>
-#include <memory>
 #include <type_traits>
 
-#define DO_NULL_CHECKS true
-
 namespace margelo::nitro {
 
 using namespace facebook;
 
-// HybridObject <> {}
+// HybridObject(NativeState) <> {}
 template <typename T>
-struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::HostObject>>> {
+struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>> {
   using TPointee = typename T::element_type;
 
   static inline T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
-#if DO_NULL_CHECKS
-    if (arg.isUndefined()) [[unlikely]] {
-      throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
-    }
+#if DEBUG
     if (!arg.isObject()) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
+      if (arg.isUndefined()) [[unlikely]] {
+        throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
+      } else {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
+      }
     }
 #endif
     jsi::Object object = arg.asObject(runtime);
-#if DO_NULL_CHECKS
-    if (!object.isHostObject(runtime)) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not a HostObject!"));
-    }
-    if (!object.isHostObject<TPointee>(runtime)) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different HostObject<T>!"));
+
+#if DEBUG
+    if (!object.hasNativeState<TPointee>(runtime)) [[unlikely]] {
+      if (!object.hasNativeState(runtime)) [[unlikely]] {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It does not have a NativeState!"));
+      } else {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It has a different NativeState<T>!"));
+      }
     }
 #endif
-    return object.asHostObject<TPointee>(runtime);
+    return object.getNativeState<TPointee>(runtime);
   }
 
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
-#if DO_NULL_CHECKS
     if (arg == nullptr) [[unlikely]] {
       std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
-      throw jsi::JSError(runtime, "Cannot convert nullptr to HostObject<" + typeName + ">!");
+      throw jsi::JSError(runtime, "Cannot convert nullptr to NativeState<" + typeName + ">!");
     }
-#endif
+
     if constexpr (std::is_base_of_v<HybridObject, TPointee>) {
       // It's a HybridObject - use it's internal constructor which caches jsi::Objects for proper memory management!
       return arg->toObject(runtime);
     } else {
-      // It's any other kind of jsi::HostObject - just create it as normal.
-      return jsi::Object::createFromHostObject(runtime, arg);
-    }
-  }
-
-private:
-  static inline std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
-    std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
-    return "Cannot convert \"" + typeDescription + "\" to HostObject<" + typeName + ">! " + reason;
-  }
-};
-
-// NativeState <> {}
-template <typename T>
-struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>> {
-  using TPointee = typename T::element_type;
-
-  static inline T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
-#if DO_NULL_CHECKS
-    if (arg.isUndefined()) [[unlikely]] {
-      throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
-    }
-    if (!arg.isObject()) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
-    }
-#endif
-    jsi::Object object = arg.asObject(runtime);
-#if DO_NULL_CHECKS
-    if (!object.hasNativeState(runtime)) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not a NativeState!"));
-    }
-    if (!object.hasNativeState<TPointee>(runtime)) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different NativeState<T>!"));
+      // It's any other kind of jsi::HostObject - just create it as normal. This will not have a prototype then!
+      jsi::Object object(runtime);
+      object.setNativeState(runtime, arg);
+      return object;
     }
-#endif
-    return object.getNativeState<TPointee>(runtime);
   }
 
-  static inline jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
-#if DO_NULL_CHECKS
-    if (arg == nullptr) [[unlikely]] {
-      std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
-      throw jsi::JSError(runtime, "Cannot convert nullptr to NativeState<" + typeName + ">!");
+  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);
     }
-#endif
-    jsi::Object object(runtime);
-    object.setNativeState(runtime, arg);
-    return object;
+    return false;
   }
 
 private:

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