react-native-nitro-modules 0.0.6 → 0.0.8

package/cpp/jsi/JSICache.hpp

@@ -23,9 +23,11 @@ using namespace facebook;
 
 static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
 
-template <typename T> class JSICache;
+template <typename T>
+class JSICache;
 
-template <typename T> class JSICacheReference final {
+template <typename T>
+class JSICacheReference final {
 public:
   JSICacheReference() = delete;
   JSICacheReference(const JSICacheReference&) = delete;
@@ -70,7 +72,8 @@ private:
  * `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`.
  */
-template <typename T = jsi::Pointer> class JSICache final : public jsi::NativeState {
+template <typename T = jsi::Pointer>
+class JSICache final : public jsi::NativeState {
 public:
   explicit JSICache(jsi::Runtime* runtime) : _runtime(runtime) {}
 

package/cpp/jsi/JSIConverter.hpp

@@ -11,7 +11,11 @@ class HybridObject;
 #include "AnyMap.hpp"
 #include "ArrayBuffer.hpp"
 #include "Dispatcher.hpp"
+#include "FutureType.hpp"
 #include "HybridObject.hpp"
+#include "IsHostObject.hpp"
+#include "IsInPack.hpp"
+#include "IsNativeState.hpp"
 #include "JSICache.hpp"
 #include "NitroHash.hpp"
 #include "Promise.hpp"
@@ -40,7 +44,8 @@ namespace margelo::nitro {
 using namespace facebook;
 
 // Unknown type (error)
-template <typename ArgType, typename Enable = void> struct JSIConverter final {
+template <typename ArgType, typename Enable = void>
+struct JSIConverter final {
   JSIConverter() = delete;
 
   static inline ArgType fromJSI(jsi::Runtime&, const jsi::Value&) {
@@ -53,11 +58,13 @@ template <typename ArgType, typename Enable = void> struct JSIConverter final {
   }
 
 private:
-  template <typename> struct always_false : std::false_type {};
+  template <typename>
+  struct always_false : std::false_type {};
 };
 
 // int <> number
-template <> struct JSIConverter<int> {
+template <>
+struct JSIConverter<int> {
   static inline int fromJSI(jsi::Runtime&, const jsi::Value& arg) {
     return static_cast<int>(arg.asNumber());
   }
@@ -67,7 +74,8 @@ template <> struct JSIConverter<int> {
 };
 
 // std::monostate <> null
-template <> struct JSIConverter<std::monostate> {
+template <>
+struct JSIConverter<std::monostate> {
   static inline std::monostate fromJSI(jsi::Runtime&, const jsi::Value& arg) {
     return std::monostate();
   }
@@ -77,7 +85,8 @@ template <> struct JSIConverter<std::monostate> {
 };
 
 // double <> number
-template <> struct JSIConverter<double> {
+template <>
+struct JSIConverter<double> {
   static inline double fromJSI(jsi::Runtime&, const jsi::Value& arg) {
     return arg.asNumber();
   }
@@ -87,7 +96,8 @@ template <> struct JSIConverter<double> {
 };
 
 // float <> number
-template <> struct JSIConverter<float> {
+template <>
+struct JSIConverter<float> {
   static inline float fromJSI(jsi::Runtime&, const jsi::Value& arg) {
     return static_cast<float>(arg.asNumber());
   }
@@ -97,7 +107,8 @@ template <> struct JSIConverter<float> {
 };
 
 // int64_t <> BigInt
-template <> struct JSIConverter<int64_t> {
+template <>
+struct JSIConverter<int64_t> {
   static inline double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     return arg.asBigInt(runtime).asInt64(runtime);
   }
@@ -107,7 +118,8 @@ template <> struct JSIConverter<int64_t> {
 };
 
 // uint64_t <> BigInt
-template <> struct JSIConverter<uint64_t> {
+template <>
+struct JSIConverter<uint64_t> {
   static inline double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     return arg.asBigInt(runtime).asUint64(runtime);
   }
@@ -117,7 +129,8 @@ template <> struct JSIConverter<uint64_t> {
 };
 
 // bool <> boolean
-template <> struct JSIConverter<bool> {
+template <>
+struct JSIConverter<bool> {
   static inline bool fromJSI(jsi::Runtime&, const jsi::Value& arg) {
     return arg.asBool();
   }
@@ -127,7 +140,8 @@ template <> struct JSIConverter<bool> {
 };
 
 // std::string <> string
-template <> struct JSIConverter<std::string> {
+template <>
+struct JSIConverter<std::string> {
   static inline std::string fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     return arg.asString(runtime).utf8(runtime);
   }
@@ -137,7 +151,8 @@ template <> struct JSIConverter<std::string> {
 };
 
 // std::optional<T> <> T | undefined
-template <typename TInner> struct JSIConverter<std::optional<TInner>> {
+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;
@@ -155,7 +170,8 @@ template <typename TInner> struct JSIConverter<std::optional<TInner>> {
 };
 
 // std::future<T> <> Promise<T>
-template <typename TResult> struct JSIConverter<std::future<TResult>> {
+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!");
   }
@@ -210,18 +226,11 @@ template <typename TResult> struct JSIConverter<std::future<TResult>> {
   }
 };
 
-template <typename T> struct future_traits {
-  using type = void;
-};
-template <typename T> struct future_traits<std::future<T>> {
-  using type = T;
-};
-template <typename T> using future_traits_t = typename future_traits<std::remove_reference_t<T>>::type;
-
 // [](Args...) -> T {} <> (Args...) => T
-template <typename ReturnType, typename... Args> struct JSIConverter<std::function<ReturnType(Args...)>> {
+template <typename ReturnType, typename... Args>
+struct JSIConverter<std::function<ReturnType(Args...)>> {
   // std::future<T> -> T
-  using ResultingType = future_traits_t<ReturnType>;
+  using ResultingType = future_type_v<ReturnType>;
 
   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)
@@ -311,7 +320,8 @@ template <typename ReturnType, typename... Args> struct JSIConverter<std::functi
 };
 
 // std::vector<T> <> T[]
-template <typename ElementType> struct JSIConverter<std::vector<ElementType>> {
+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);
@@ -335,7 +345,8 @@ template <typename ElementType> struct JSIConverter<std::vector<ElementType>> {
 };
 
 // std::unordered_map<std::string, T> <> Record<string, T>
-template <typename ValueType> struct JSIConverter<std::unordered_map<std::string, ValueType>> {
+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);
@@ -360,7 +371,9 @@ template <typename ValueType> struct JSIConverter<std::unordered_map<std::string
   }
 };
 
-template <typename... Types> struct JSIConverter<std::tuple<Types...>> {
+// 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);
@@ -394,12 +407,9 @@ private:
   }
 };
 
-// Helper struct to check if a type is present in a parameter pack
-template <typename T, typename... Types> struct is_in_pack : std::disjunction<std::is_same<T, Types>...> {};
-template <typename T, typename... Types> inline constexpr bool is_in_pack_v = is_in_pack<T, Types...>::value;
-
 // std::variant<A, B, C> <> A | B | C
-template <typename... Types> struct JSIConverter<std::variant<Types...>> {
+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...>) {
@@ -464,7 +474,8 @@ private:
 };
 
 // AnyValue <> Record<K, V>
-template <> struct JSIConverter<AnyValue> {
+template <>
+struct JSIConverter<AnyValue> {
   static inline AnyValue fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     return JSIConverter<AnyValue::variant>::fromJSI(runtime, arg);
   }
@@ -474,7 +485,8 @@ template <> struct JSIConverter<AnyValue> {
 };
 
 // AnyMap <> Record<K, V>
-template <> struct JSIConverter<std::shared_ptr<AnyMap>> {
+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);
@@ -499,7 +511,8 @@ template <> struct JSIConverter<std::shared_ptr<AnyMap>> {
 };
 
 // MutableBuffer <> ArrayBuffer
-template <> struct JSIConverter<std::shared_ptr<jsi::MutableBuffer>> {
+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]] {
@@ -514,9 +527,8 @@ template <> struct JSIConverter<std::shared_ptr<jsi::MutableBuffer>> {
 };
 
 // HybridObject <> {}
-template <typename T> struct is_shared_ptr_to_host_object : std::false_type {};
-template <typename T> struct is_shared_ptr_to_host_object<std::shared_ptr<T>> : std::is_base_of<jsi::HostObject, T> {};
-template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_host_object<T>::value>> {
+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) {
@@ -563,9 +575,8 @@ private:
 };
 
 // NativeState <> {}
-template <typename T> struct is_shared_ptr_to_native_state : std::false_type {};
-template <typename T> struct is_shared_ptr_to_native_state<std::shared_ptr<T>> : std::is_base_of<jsi::NativeState, T> {};
-template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_native_state<T>::value>> {
+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) {

package/cpp/templates/CountTrailingOptionals.hpp

@@ -0,0 +1,64 @@
+//
+//  CountTrailingOptionals.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <optional>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+// Helper template to check if a type is std::optional
+template <typename T>
+struct is_optional : std::false_type {};
+
+template <typename T>
+struct is_optional<std::optional<T>> : std::true_type {};
+
+// Helper template to count trailing optionals
+template <int N = 0, typename... Args>
+struct count_trailing_optionals;
+
+template <>
+struct count_trailing_optionals<> {
+  static constexpr int value = 0;
+};
+
+template <int N, typename Current, typename... Rest>
+struct count_trailing_optionals<N, Current, Rest...> {
+  static constexpr int count_trailing_optionals_impl() {
+    constexpr bool isOptional = is_optional<std::remove_cvref_t<Current>>::value;
+    if constexpr (sizeof...(Rest) == 0) {
+      // end of parameter pack!
+      if constexpr (isOptional) {
+        // last item is an optional, finally return the final number incremented by one.
+        return N + 1;
+      } else {
+        // last item is not an optional, so there are 0 trailing optionals.
+        return 0;
+      }
+    } else {
+      // recursively look into next T, either bump N by one or reset it to 0 if it's not an optional.
+      constexpr int newValue = isOptional ? N + 1 : 0;
+      return count_trailing_optionals<newValue, Rest...>::count_trailing_optionals_impl();
+    }
+  }
+
+  static constexpr int value = count_trailing_optionals_impl();
+};
+
+// Main template to count trailing optionals in Args... pack
+template <typename... Args>
+struct trailing_optionals_count {
+  static constexpr int value = count_trailing_optionals<0, Args...>::value;
+};
+
+// Helper alias
+template <typename... Args>
+constexpr int trailing_optionals_count_v = trailing_optionals_count<std::remove_cvref_t<Args>...>::value;
+
+} // namespace margelo::nitro

package/cpp/templates/FutureType.hpp

@@ -0,0 +1,28 @@
+//
+//  BorrowingReference.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <future>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+// Gets the `T` in `std::future<T>`.
+template <typename T>
+struct future_type {
+  using type = void;
+};
+template <typename T>
+struct future_type<std::future<T>> {
+  using type = T;
+};
+
+template <typename T>
+using future_type_v = typename future_type<std::remove_reference_t<T>>::type;
+
+} // namespace margelo::nitro

package/cpp/templates/IsHostObject.hpp

@@ -0,0 +1,27 @@
+//
+//  BorrowingReference.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// Returns whether the given type `T` is a `shared_ptr` to a `HostObject`
+template <typename T>
+struct is_shared_ptr_to_host_object : std::false_type {};
+
+template <typename T>
+struct is_shared_ptr_to_host_object<std::shared_ptr<T>> : std::is_base_of<jsi::HostObject, T> {};
+
+template <typename T>
+inline constexpr bool is_shared_ptr_to_host_object_v = is_shared_ptr_to_host_object<std::remove_reference_t<T>>::value;
+
+} // namespace margelo::nitro

package/cpp/templates/IsInPack.hpp

@@ -0,0 +1,21 @@
+//
+//  BorrowingReference.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <type_traits>
+
+namespace margelo::nitro {
+
+// Returns whether the given type `T` is inside `Types...`
+template <typename T, typename... Types>
+struct is_in_pack : std::disjunction<std::is_same<T, Types>...> {};
+
+template <typename T, typename... Types>
+inline constexpr bool is_in_pack_v = is_in_pack<T, Types...>::value;
+
+} // namespace margelo::nitro

package/cpp/templates/IsNativeState.hpp

@@ -0,0 +1,27 @@
+//
+//  BorrowingReference.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// Returns whether the given type `T` is a `shared_ptr` to a `NativeStaet`
+template <typename T>
+struct is_shared_ptr_to_native_state : std::false_type {};
+
+template <typename T>
+struct is_shared_ptr_to_native_state<std::shared_ptr<T>> : std::is_base_of<jsi::NativeState, T> {};
+
+template <typename T>
+inline constexpr bool is_shared_ptr_to_native_state_v = is_shared_ptr_to_native_state<std::remove_reference_t<T>>::value;
+
+} // namespace margelo::nitro

package/cpp/threading/Dispatcher.hpp

@@ -44,7 +44,8 @@ public:
    * Run the given function asynchronously on the Thread this Dispatcher is managing,
    * and return a future that will hold the result of the function.
    */
-  template <typename T> std::future<T> runAsyncAwaitable(std::function<T()>&& function) {
+  template <typename T>
+  std::future<T> runAsyncAwaitable(std::function<T()>&& function) {
     // 1. Create Promise that can be shared between this and dispatcher thread
     auto promise = std::make_shared<std::promise<T>>();
     std::future<T> future = promise->get_future();

package/cpp/utils/BorrowingReference+Owning.hpp

@@ -11,7 +11,8 @@
 
 namespace margelo::nitro {
 
-template <typename T> BorrowingReference<T>::BorrowingReference(const OwningReference<T>& ref) {
+template <typename T>
+BorrowingReference<T>::BorrowingReference(const OwningReference<T>& ref) {
   _value = ref._value;
   _isDeleted = ref._isDeleted;
   _strongRefCount = ref._strongRefCount;
@@ -20,7 +21,8 @@ template <typename T> BorrowingReference<T>::BorrowingReference(const OwningRefe
   (*_weakRefCount)++;
 }
 
-template <typename T> OwningReference<T> BorrowingReference<T>::lock() {
+template <typename T>
+OwningReference<T> BorrowingReference<T>::lock() {
   std::unique_lock lock(*_mutex);
 
   if (*_isDeleted) {

package/cpp/utils/BorrowingReference.hpp

@@ -7,20 +7,22 @@
 
 #pragma once
 
+#include <atomic>
 #include <cstddef>
 #include <mutex>
-#include <atomic>
 
 namespace margelo::nitro {
 
 // forward-declaration to avoid duplicate symbols
-template <typename T> class OwningReference;
+template <typename T>
+class OwningReference;
 
 /**
  A `BorrowingReference<T>` is a weak reference to a pointer created by `OwningReference<T>`.
  It can be locked to gain a strong `OwningReference<T>` again if it has not been deleted yet.
  */
-template <typename T> class BorrowingReference final {
+template <typename T>
+class BorrowingReference final {
 private:
   explicit BorrowingReference(const OwningReference<T>& ref);
 

package/cpp/utils/NitroHash.hpp

@@ -35,7 +35,8 @@ constexpr uint64_t hashString(const char* str, size_t length) {
  *
  * String length is known at compile time.
  */
-template <size_t N> constexpr uint64_t hashString(const char (&str)[N]) {
+template <size_t N>
+constexpr uint64_t hashString(const char (&str)[N]) {
   return hashString(str, N - 1); // N includes the null terminator, so subtract 1
 }
 

package/cpp/utils/NitroLogger.hpp

@@ -17,13 +17,15 @@ private:
   Logger() = delete;
 
 public:
-  template <typename... Args> static void log(const char* tag, const char* message, Args&&... args) {
+  template <typename... Args>
+  static void log(const char* tag, const char* message, Args&&... args) {
     std::string formattedMessage = format(message, std::forward<Args>(args)...);
     std::cout << "[Nitro." << tag << "] " << formattedMessage << std::endl;
   }
 
 private:
-  template <typename... Args> static inline std::string format(const char* formatString, Args&&... args) {
+  template <typename... Args>
+  static inline std::string format(const char* formatString, Args&&... args) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wformat-security"
     int size_s = std::snprintf(nullptr, 0, formatString, toCString(args)...) + 1; // Extra space for '\0'
@@ -47,7 +49,8 @@ private:
     return s;
   }
   // When the user passes any other type, just return that directly.
-  template <typename T> static inline T toCString(T value) {
+  template <typename T>
+  static inline T toCString(T value) {
     return value;
   }
 };

package/cpp/utils/OwningLock.hpp

@@ -8,7 +8,8 @@
 #pragma once
 
 namespace margelo::nitro {
-template <typename T> class OwningReference;
+template <typename T>
+class OwningReference;
 }
 
 #include "OwningReference.hpp"
@@ -29,7 +30,8 @@ namespace margelo::nitro {
  *
  * To create an `OwningLock<T>`, simply call `lock()` on an `OwningReference<T>`.
  */
-template <typename T> class OwningLock final {
+template <typename T>
+class OwningLock final {
 public:
   ~OwningLock() {
     _reference._mutex->unlock();

package/cpp/utils/OwningReference.hpp

@@ -9,9 +9,9 @@
 
 #include "BorrowingReference.hpp"
 #include "OwningLock.hpp"
+#include <atomic>
 #include <cstddef>
 #include <mutex>
-#include <atomic>
 
 namespace margelo::nitro {
 
@@ -24,7 +24,8 @@ namespace margelo::nitro {
  An `OwningReference<T>` can be weakified, which gives the user a `BorrowingReference<T>`.
  A `BorrowingReference<T>` can be locked to get an `OwningReference<T>` again, assuming it has not been deleted yet.
  */
-template <typename T> class OwningReference final {
+template <typename T>
+class OwningReference final {
 public:
   using Pointee = T;
 
@@ -32,8 +33,8 @@ public:
   OwningReference() : _value(nullptr), _isDeleted(nullptr), _strongRefCount(nullptr), _weakRefCount(nullptr), _mutex(nullptr) {}
 
   explicit OwningReference(T* value)
-      : _value(value), _isDeleted(new bool(false)), _strongRefCount(new std::atomic_size_t(1)), _weakRefCount(new std::atomic_size_t(0)), _mutex(new std::mutex()) {
-  }
+      : _value(value), _isDeleted(new bool(false)), _strongRefCount(new std::atomic_size_t(1)), _weakRefCount(new std::atomic_size_t(0)),
+        _mutex(new std::mutex()) {}
 
   OwningReference(const OwningReference& ref)
       : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),

package/cpp/utils/TypeInfo.hpp

@@ -41,7 +41,8 @@ public:
   /**
    * Get a friendly name of the type `T` (if possible, demangled)
    */
-  template <typename T> static inline std::string getFriendlyTypename() {
+  template <typename T>
+  static inline std::string getFriendlyTypename() {
     std::string name = typeid(T).name();
 #if __has_include(<cxxabi.h>)
     int status = 0;
@@ -70,7 +71,8 @@ public:
     return name;
   }
 
-  template <typename... Types> static inline std::string getFriendlyTypenames() {
+  template <typename... Types>
+  static inline std::string getFriendlyTypenames() {
     std::ostringstream stream;
     ((stream << TypeInfo::getFriendlyTypename<Types>() << ", "), ...);
     std::string string = stream.str();