react-native-nitro-modules 0.1.3 → 0.1.4

package/NitroModules.podspec

@@ -28,14 +28,16 @@ Pod::Spec.new do |s|
   ]
   s.public_header_files = [
     # Public C++ headers will be exposed in modulemap (for Swift)
+    "cpp/core/AnyMap.hpp",
     "cpp/core/ArrayBuffer.hpp",
     "cpp/core/HybridObject.hpp",
-    "cpp/core/HybridContext.hpp",
     "cpp/registry/HybridObjectRegistry.hpp",
     "cpp/jsi/JSIConverter.hpp",
     "cpp/threading/Dispatcher.hpp",
     "cpp/utils/NitroHash.hpp",
     "cpp/utils/NitroDefines.hpp",
+    # Public iOS-specific headers that will be exposed in modulemap (for Swift)
+    "ios/core/HybridContext.hpp"
   ]
 
   s.pod_target_xcconfig = {

package/android/src/main/cpp/platform/ThreadUtils.cpp

@@ -9,6 +9,7 @@
 #include <pthread.h>
 #include <sstream>
 #include <string>
+#include <sys/prctl.h>
 #include <thread>
 
 namespace margelo::nitro {
@@ -32,4 +33,8 @@ std::string ThreadUtils::getThreadName() {
   return "Thread #" + threadId;
 }
 
+void ThreadUtils::setThreadName(const std::string& name) {
+  prctl(PR_SET_NAME, name.c_str(), 0, 0, 0);
+}
+
 } // namespace margelo::nitro

package/cpp/core/AnyMap.hpp

@@ -9,6 +9,7 @@
 #include <string>
 #include <unordered_map>
 #include <variant>
+#include <vector>
 
 namespace margelo::nitro {
 
@@ -33,7 +34,7 @@ struct AnyValue : VariantType {
  * 2. Arrays of primitives
  * 3. Objects of primitives
  */
-class AnyMap {
+class AnyMap final {
 public:
   /**
    * Create a new instance of AnyMap.

package/cpp/core/HybridObject.hpp

@@ -5,10 +5,9 @@
 #pragma once
 
 #include "CountTrailingOptionals.hpp"
-#include "HybridContext.hpp"
 #include "JSIConverter.hpp"
-#include "NitroLogger.hpp"
 #include "OwningReference.hpp"
+#include "TypeInfo.hpp"
 #include <functional>
 #include <jsi/jsi.h>
 #include <memory>
@@ -176,10 +175,10 @@ private:
       constexpr size_t maxArgsCount = sizeof...(Args);
       constexpr size_t minArgsCount = maxArgsCount - optionalArgsCount;
       bool isWithinArgsRange = (count >= minArgsCount && count <= maxArgsCount);
-      if (!isWithinArgsRange) {
+      if (!isWithinArgsRange) [[unlikely]] {
         // invalid amount of arguments passed!
         std::string hybridObjectName = derivedInstance->_name;
-        if (minArgsCount == maxArgsCount) {
+        if constexpr (minArgsCount == maxArgsCount) {
           // min and max args length is the same, so we don't have any optional parameters. fixed count
           throw jsi::JSError(runtime, hybridObjectName + "." + name + "(...) expected " + std::to_string(maxArgsCount) +
                                           " arguments, but received " + std::to_string(count) + "!");

package/cpp/jsi/JSIConverter+AnyMap.hpp

@@ -0,0 +1,64 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+struct AnyValue;
+class AnyMap;
+
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+#include "JSIConverter+Variant.hpp"
+
+#include "AnyMap.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// AnyValue <> Record<K, V>
+template <>
+struct JSIConverter<AnyValue> {
+  static inline AnyValue fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+    return JSIConverter<AnyValue::variant>::fromJSI(runtime, arg);
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const AnyValue& value) {
+    return JSIConverter<AnyValue::variant>::toJSI(runtime, value);
+  }
+};
+
+// AnyMap <> Record<K, V>
+template <>
+struct JSIConverter<std::shared_ptr<AnyMap>> {
+  static inline std::shared_ptr<AnyMap> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+    jsi::Object object = arg.asObject(runtime);
+    jsi::Array propNames = object.getPropertyNames(runtime);
+    size_t size = propNames.size(runtime);
+    std::shared_ptr<AnyMap> map = AnyMap::make();
+    for (size_t i = 0; i < size; i++) {
+      jsi::String jsKey = propNames.getValueAtIndex(runtime, i).getString(runtime);
+      jsi::Value jsValue = object.getProperty(runtime, jsKey);
+      map->setAny(jsKey.utf8(runtime), JSIConverter<AnyValue>::fromJSI(runtime, jsValue));
+    }
+    return map;
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::shared_ptr<AnyMap> map) {
+    jsi::Object object(runtime);
+    for (const auto& item : map->getMap()) {
+      jsi::String key = jsi::String::createFromUtf8(runtime, item.first);
+      jsi::Value value = JSIConverter<AnyValue>::toJSI(runtime, item.second);
+      object.setProperty(runtime, std::move(key), std::move(value));
+    }
+    return object;
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+ArrayBuffer.hpp

@@ -0,0 +1,41 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+class ArrayBuffer;
+
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+
+#include "ArrayBuffer.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// MutableBuffer <> ArrayBuffer
+template <>
+struct JSIConverter<std::shared_ptr<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!");
+    }
+    jsi::ArrayBuffer arrayBuffer = object.getArrayBuffer(runtime);
+    return std::make_shared<ArrayBuffer>(arrayBuffer.data(runtime), arrayBuffer.size(runtime), false);
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::shared_ptr<jsi::MutableBuffer> buffer) {
+    return jsi::ArrayBuffer(runtime, buffer);
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Function.hpp

@@ -0,0 +1,124 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// 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>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+
+#include "Dispatcher.hpp"
+#include "FutureType.hpp"
+#include "JSICache.hpp"
+#include <functional>
+#include <future>
+#include <jsi/jsi.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// [](Args...) -> T {} <> (Args...) => T
+template <typename ReturnType, typename... Args>
+struct JSIConverter<std::function<ReturnType(Args...)>> {
+  // std::future<T> -> T
+  using ResultingType = future_type_v<ReturnType>;
+
+  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);
+    jsi::Function function = arg.asObject(runtime).asFunction(runtime);
+    OwningReference<jsi::Function> sharedFunction = cache.makeGlobal(std::move(function));
+
+    std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
+    std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
+
+    // Create a C++ function that can be called by the consumer.
+    // This will call the jsi::Function if it is still alive.
+    return [&runtime, weakDispatcher, sharedFunction = std::move(sharedFunction)](Args... args) -> ReturnType {
+      // Try to get the JS Dispatcher if the Runtime is still alive
+      std::shared_ptr<Dispatcher> dispatcher = weakDispatcher.lock();
+      if (!dispatcher) {
+        if constexpr (std::is_void_v<ResultingType>) {
+          Logger::log("JSIConverter", "Tried calling void(..) function, but the JS Dispatcher has already been deleted by JS!");
+          return;
+        } else {
+          throw std::runtime_error("Cannot call the given Function - the JS Dispatcher has already been destroyed by the JS Runtime!");
+        }
+      }
+
+      if constexpr (std::is_void_v<ResultingType>) {
+        dispatcher->runAsync([&runtime, sharedFunction = std::move(sharedFunction), ... args = std::move(args)]() {
+          callJSFunction(runtime, sharedFunction, args...);
+        });
+      } else {
+        return dispatcher->runAsyncAwaitable<ResultingType>(
+            [&runtime, sharedFunction = std::move(sharedFunction), ... args = std::move(args)]() -> ResultingType {
+              return callJSFunction(runtime, sharedFunction, args...);
+            });
+      }
+    };
+  }
+
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::function<ReturnType(Args...)>&& function) {
+    jsi::HostFunctionType jsFunction = [function = std::move(function)](jsi::Runtime& runtime, const jsi::Value& thisValue,
+                                                                        const jsi::Value* args, size_t count) -> jsi::Value {
+      if (count != sizeof...(Args)) [[unlikely]] {
+        throw jsi::JSError(runtime, "Function expected " + std::to_string(sizeof...(Args)) + " arguments, but received " +
+                                        std::to_string(count) + "!");
+      }
+      return callHybridFunction(function, runtime, args, std::index_sequence_for<Args...>{});
+    };
+    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "hostFunction"), sizeof...(Args), jsFunction);
+  }
+
+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)
+    OwningLock<jsi::Function> lock = function.lock();
+
+    if (!function) {
+      if constexpr (std::is_void_v<ResultingType>) {
+        // runtime has already been deleted. since this returns void, we can just ignore it being deleted.
+        Logger::log("JSIConverter", "Tried calling void(..) function, but it has already been deleted by JS!");
+        return;
+      } else {
+        // runtime has already been deleted, but we are expecting a return value - throw an error in this case.
+        throw std::runtime_error("Cannot call the given Function - the JS Dispatcher has already been destroyed by the JS Runtime!");
+      }
+    }
+
+    if constexpr (std::is_void_v<ResultingType>) {
+      // It returns void. Just call the function
+      function->call(runtime, JSIConverter<std::decay_t<Args>>::toJSI(runtime, args)...);
+    } else {
+      // It returns some kind of value - call the function, and convert the return value.
+      jsi::Value result = function->call(runtime, JSIConverter<std::decay_t<Args>>::toJSI(runtime, args)...);
+      return JSIConverter<ResultingType>::fromJSI(runtime, std::move(result));
+    }
+  }
+
+  template <size_t... Is>
+  static inline jsi::Value callHybridFunction(const std::function<ReturnType(Args...)>& function, jsi::Runtime& runtime,
+                                              const jsi::Value* args, std::index_sequence<Is...>) {
+    if constexpr (std::is_void_v<ReturnType>) {
+      // it is a void function (will return undefined in JS)
+      function(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is])...);
+      return jsi::Value::undefined();
+    } else {
+      // it is a custom type, parse it to a JS value
+      ReturnType result = function(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, args[Is])...);
+      return JSIConverter<ReturnType>::toJSI(runtime, result);
+    }
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+HybridObject.hpp

@@ -0,0 +1,123 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// 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 "IsHostObject.hpp"
+#include "IsNativeState.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 <> {}
+template <typename T>
+struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_host_object_v<T>>> {
+  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.isHostObject<TPointee>(runtime)) [[unlikely]] {
+      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different HostObject<T>!"));
+    }
+#endif
+    return object.asHostObject<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 + ">!");
+    }
+#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_native_state_v<T>>> {
+  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<TPointee>(runtime)) [[unlikely]] {
+      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different NativeState<T>!"));
+    }
+#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 + ">!");
+    }
+#endif
+    jsi::Object object(runtime);
+    object.setNativeState(runtime, arg);
+    return object;
+  }
+
+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 NativeState<" + typeName + ">! " + reason;
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Optional.hpp

@@ -0,0 +1,41 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+
+#include <jsi/jsi.h>
+#include <optional>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::optional<T> <> T | undefined
+template <typename TInner>
+struct JSIConverter<std::optional<TInner>> {
+  static inline std::optional<TInner> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+    if (arg.isUndefined() || arg.isNull()) {
+      return std::nullopt;
+    } else {
+      return JSIConverter<TInner>::fromJSI(runtime, arg);
+    }
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::optional<TInner>& arg) {
+    if (arg == std::nullopt) {
+      return jsi::Value::undefined();
+    } else {
+      return JSIConverter<TInner>::toJSI(runtime, arg.value());
+    }
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -0,0 +1,87 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+class Dispatcher;
+class Promise;
+
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+
+#include "Dispatcher.hpp"
+#include "Promise.hpp"
+#include "ThreadPool.hpp"
+#include "TypeInfo.hpp"
+#include <future>
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::future<T> <> Promise<T>
+template <typename TResult>
+struct JSIConverter<std::future<TResult>> {
+  static inline std::future<TResult> fromJSI(jsi::Runtime&, const jsi::Value&) {
+    throw std::runtime_error("Promise cannot be converted to a native type - it needs to be awaited first!");
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::future<TResult>&& arg) {
+    auto sharedFuture = std::make_shared<std::future<TResult>>(std::move(arg));
+    std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
+    std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
+
+    return Promise::createPromise(runtime, [sharedFuture, weakDispatcher](jsi::Runtime& runtime, std::shared_ptr<Promise> promise) {
+      // Spawn new async thread to synchronously wait for the `future<T>` to complete
+      std::shared_ptr<ThreadPool> pool = ThreadPool::getSharedPool();
+      pool->run([promise, &runtime, weakDispatcher, sharedFuture]() {
+        // synchronously wait until the `future<T>` completes. we are running on a background task here.
+        sharedFuture->wait();
+
+        // the async function completed successfully, get a JS Dispatcher so we can resolve on JS Thread
+        std::shared_ptr<Dispatcher> dispatcher = weakDispatcher.lock();
+        if (!dispatcher) {
+          Logger::log("JSIConverter", "Tried resolving Promise on JS Thread, but the `Dispatcher` has already been destroyed.");
+          return;
+        }
+
+        dispatcher->runAsync([&runtime, promise, sharedFuture]() mutable {
+          try {
+            if constexpr (std::is_void_v<TResult>) {
+              // it's returning void, just return undefined to JS
+              sharedFuture->get();
+              promise->resolve(runtime, jsi::Value::undefined());
+            } else {
+              // it's returning a custom type, convert it to a jsi::Value
+              TResult result = sharedFuture->get();
+              jsi::Value jsResult = JSIConverter<TResult>::toJSI(runtime, result);
+              promise->resolve(runtime, std::move(jsResult));
+            }
+          } catch (const std::exception& exception) {
+            // the async function threw an error, reject the promise on JS Thread
+            std::string what = exception.what();
+            promise->reject(runtime, what);
+          } catch (...) {
+            // the async function threw a non-std error, try getting it
+            std::string name = TypeInfo::getCurrentExceptionName();
+            promise->reject(runtime, "Unknown non-std exception: " + name);
+          }
+
+          // This lambda owns the promise shared pointer, and we need to call its
+          // destructor on the correct thread here - otherwise it might be called
+          // from the waiterThread.
+          promise = nullptr;
+        });
+      });
+    });
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Tuple.hpp

@@ -0,0 +1,60 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+
+#include "TypeInfo.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+#include <tuple>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::tuple<A, B, C> <> [A, B, C]
+template <typename... Types>
+struct JSIConverter<std::tuple<Types...>> {
+  static inline std::tuple<Types...> fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    jsi::Object object = value.asObject(runtime);
+    jsi::Array array = object.asArray(runtime);
+    if (array.size(runtime) != sizeof...(Types)) [[unlikely]] {
+      std::string types = TypeInfo::getFriendlyTypenames<Types...>();
+      throw std::runtime_error("The given JS Array has " + std::to_string(array.size(runtime)) + " items, but std::tuple<" + types +
+                               "> expects " + std::to_string(sizeof...(Types)) + " items.");
+    }
+
+    return copyArrayItemsToTuple(runtime, array, std::index_sequence_for<Types...>{});
+  }
+
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::tuple<Types...>& tuple) {
+    jsi::Array array(runtime, sizeof...(Types));
+    copyTupleItemsToArray(runtime, array, tuple, std::index_sequence_for<Types...>{});
+    return array;
+  }
+
+private:
+  template <std::size_t... Is>
+  static inline std::tuple<Types...> copyArrayItemsToTuple(jsi::Runtime& runtime, const jsi::Array& array, std::index_sequence<Is...>) {
+    return std::make_tuple(JSIConverter<Types>::fromJSI(runtime, array.getValueAtIndex(runtime, Is))...);
+  }
+
+  template <std::size_t... Is>
+  static inline void copyTupleItemsToArray(jsi::Runtime& runtime, jsi::Array& array, const std::tuple<Types...>& tuple,
+                                           std::index_sequence<Is...>) {
+    ((array.setValueAtIndex(runtime, Is,
+                            JSIConverter<std::tuple_element_t<Is, std::tuple<Types...>>>::toJSI(runtime, std::get<Is>(tuple)))),
+     ...);
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+UnorderedMap.hpp

@@ -0,0 +1,50 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+// Forward declare a few of the common types that might have cyclic includes.
+namespace margelo::nitro {
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "JSIConverter.hpp"
+
+#include "AnyMap.hpp"
+#include <jsi/jsi.h>
+#include <unordered_map>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::unordered_map<std::string, T> <> Record<string, T>
+template <typename ValueType>
+struct JSIConverter<std::unordered_map<std::string, ValueType>> {
+  static inline std::unordered_map<std::string, ValueType> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+    jsi::Object object = arg.asObject(runtime);
+    jsi::Array propertyNames = object.getPropertyNames(runtime);
+    size_t length = propertyNames.size(runtime);
+
+    std::unordered_map<std::string, ValueType> map;
+    map.reserve(length);
+    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));
+    }
+    return map;
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::unordered_map<std::string, ValueType>& map) {
+    jsi::Object object(runtime);
+    for (const auto& pair : map) {
+      jsi::Value value = JSIConverter<ValueType>::toJSI(runtime, pair.second);
+      object.setProperty(runtime, pair.first.c_str(), std::move(value));
+    }
+    return object;
+  }
+};
+
+} // namespace margelo::nitro