react-native-nitro-modules 0.1.3 → 0.1.5

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

package/cpp/jsi/JSIConverter+Variant.hpp

@@ -0,0 +1,97 @@
+//
+// 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+UnorderedMap.hpp"
+#include "JSIConverter+Vector.hpp"
+#include "JSIConverter.hpp"
+
+#include "AnyMap.hpp"
+#include "IsInPack.hpp"
+#include "TypeInfo.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+#include <variant>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::variant<A, B, C> <> A | B | C
+template <typename... Types>
+struct JSIConverter<std::variant<Types...>> {
+  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<...>!");
+    }
+  }
+
+  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);
+  }
+
+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 + ">!");
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/jsi/JSIConverter+Vector.hpp

@@ -0,0 +1,48 @@
+//
+// 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 <vector>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// std::vector<T> <> T[]
+template <typename ElementType>
+struct JSIConverter<std::vector<ElementType>> {
+  static inline std::vector<ElementType> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+    jsi::Array array = arg.asObject(runtime).asArray(runtime);
+    size_t length = array.size(runtime);
+
+    std::vector<ElementType> vector;
+    vector.reserve(length);
+    for (size_t i = 0; i < length; ++i) {
+      jsi::Value elementValue = array.getValueAtIndex(runtime, i);
+      vector.emplace_back(JSIConverter<ElementType>::fromJSI(runtime, elementValue));
+    }
+    return vector;
+  }
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::vector<ElementType>& vector) {
+    jsi::Array array(runtime, vector.size());
+    for (size_t i = 0; i < vector.size(); i++) {
+      jsi::Value value = JSIConverter<ElementType>::toJSI(runtime, vector[i]);
+      array.setValueAtIndex(runtime, i, std::move(value));
+    }
+    return array;
+  }
+};
+
+} // namespace margelo::nitro