react-native-nitro-modules 0.4.1 → 0.6.0

package/cpp/jsi/JSICache.cpp

@@ -24,7 +24,7 @@ inline void destroyReferences(const std::vector<BorrowingReference<T>>& referenc
 }
 
 JSICache::~JSICache() {
-  Logger::log(TAG, "Destroying JSICache...");
+  Logger::log(LogLevel::Info, TAG, "Destroying JSICache...");
   std::unique_lock lock(_mutex);
 
   destroyReferences(_objectCache);
@@ -43,19 +43,19 @@ JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
       // It's still alive! Return it
       return JSICacheReference(strong);
     }
-    Logger::log(TAG, "JSICache was created, but it is no longer strong!");
+    Logger::log(LogLevel::Warning, TAG, "JSICache was created, but it is no longer strong!");
   }
 
-#if DEBUG
+#ifndef NDEBUG
   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));
+  Logger::log(LogLevel::Info, TAG, "Creating new JSICache<T> for runtime %s..", getRuntimeId(runtime).c_str());
   // Create new cache
-  auto nativeState = std::shared_ptr<JSICache>(new JSICache(&runtime));
+  auto nativeState = std::shared_ptr<JSICache>(new JSICache());
   // Wrap it in a jsi::Value using NativeState
   jsi::Object cache(runtime);
   cache.setNativeState(runtime, nativeState);

package/cpp/jsi/JSICache.hpp

@@ -38,12 +38,11 @@ public:
   ~JSICache();
 
 public:
-  JSICache() = delete;
   JSICache(const JSICache&) = delete;
   JSICache(JSICache&&) = delete;
 
 private:
-  explicit JSICache(jsi::Runtime* runtime) : _runtime(runtime) {}
+  JSICache() = default;
 
 public:
   /**
@@ -59,7 +58,6 @@ private:
   friend class JSICacheReference;
 
 private:
-  jsi::Runtime* _runtime;
   std::mutex _mutex;
   std::vector<BorrowingReference<jsi::Object>> _objectCache;
   std::vector<BorrowingReference<jsi::Function>> _functionCache;

package/cpp/jsi/JSIConverter+AnyMap.hpp

@@ -27,7 +27,7 @@ using namespace facebook;
 
 // AnyValue <> Record<K, V>
 template <>
-struct JSIConverter<AnyValue> {
+struct JSIConverter<AnyValue> final {
   static inline AnyValue fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     return JSIConverter<AnyValue::variant>::fromJSI(runtime, arg);
   }
@@ -41,7 +41,7 @@ struct JSIConverter<AnyValue> {
 
 // AnyMap <> Record<K, V>
 template <>
-struct JSIConverter<std::shared_ptr<AnyMap>> {
+struct JSIConverter<std::shared_ptr<AnyMap>> final {
   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);

package/cpp/jsi/JSIConverter+ArrayBuffer.hpp

@@ -28,11 +28,11 @@ using namespace facebook;
 
 // MutableBuffer <> ArrayBuffer
 template <typename T>
-struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer>>> {
+struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer>>> final {
   static inline std::shared_ptr<ArrayBuffer> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     jsi::Object object = arg.asObject(runtime);
 
-#if DEBUG
+#ifndef NDEBUG
     if (!object.isArrayBuffer(runtime)) [[unlikely]] {
       throw std::runtime_error("Object \"" + arg.toString(runtime).utf8(runtime) +
                                "\" is not an ArrayBuffer! "

package/cpp/jsi/JSIConverter+Function.hpp

@@ -27,7 +27,7 @@ using namespace facebook;
 
 // [](Args...) -> T {} <> (Args...) => T
 template <typename ReturnType, typename... Args>
-struct JSIConverter<std::function<ReturnType(Args...)>> {
+struct JSIConverter<std::function<ReturnType(Args...)>> final {
   // std::future<T> -> T
   using ResultingType = future_type_v<ReturnType>;
 
@@ -47,7 +47,8 @@ struct JSIConverter<std::function<ReturnType(Args...)>> {
       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!");
+          Logger::log(LogLevel::Error, "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!");
@@ -67,9 +68,9 @@ struct JSIConverter<std::function<ReturnType(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 {
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::function<ReturnType(Args...)>& function) {
+    jsi::HostFunctionType jsFunction = [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) + "!");
@@ -95,7 +96,7 @@ private:
     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!");
+        Logger::log(LogLevel::Error, "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.

package/cpp/jsi/JSIConverter+HybridObject.hpp

@@ -20,11 +20,11 @@ using namespace facebook;
 
 // HybridObject(NativeState) <> {}
 template <typename T>
-struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>> {
+struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>> final {
   using TPointee = typename T::element_type;
 
   static inline T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
-#if DEBUG
+#ifndef NDEBUG
     if (!arg.isObject()) [[unlikely]] {
       if (arg.isUndefined()) [[unlikely]] {
         throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
@@ -36,7 +36,7 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>
 #endif
     jsi::Object object = arg.asObject(runtime);
 
-#if DEBUG
+#ifndef NDEBUG
     if (!object.hasNativeState<TPointee>(runtime)) [[unlikely]] {
       if (!object.hasNativeState(runtime)) [[unlikely]] {
         std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
@@ -47,7 +47,8 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>
       }
     }
 #endif
-    return object.getNativeState<TPointee>(runtime);
+    std::shared_ptr<jsi::NativeState> nativeState = object.getNativeState(runtime);
+    return std::dynamic_pointer_cast<TPointee>(nativeState);
   }
 
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
@@ -60,7 +61,7 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>
       // 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. This will not have a prototype then!
+      // It's any other kind of jsi::NativeState - just create it as normal. This will not have a prototype then!
       jsi::Object object(runtime);
       object.setNativeState(runtime, arg);
       return object;

package/cpp/jsi/JSIConverter+Optional.hpp

@@ -21,7 +21,7 @@ using namespace facebook;
 
 // std::optional<T> <> T | undefined
 template <typename TInner>
-struct JSIConverter<std::optional<TInner>> {
+struct JSIConverter<std::optional<TInner>> final {
   static inline std::optional<TInner> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     if (arg.isUndefined() || arg.isNull()) {
       return std::nullopt;

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -7,7 +7,8 @@
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
 class Dispatcher;
-class Promise;
+
+class JSPromise;
 
 template <typename T, typename Enable>
 struct JSIConverter;
@@ -29,7 +30,7 @@ using namespace facebook;
 
 // std::future<T> <> Promise<T>
 template <typename TResult>
-struct JSIConverter<std::future<TResult>> {
+struct JSIConverter<std::future<TResult>> final {
   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!");
   }
@@ -48,7 +49,8 @@ struct JSIConverter<std::future<TResult>> {
         // 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.");
+          Logger::log(LogLevel::Error, "JSIConverter",
+                      "Tried resolving Promise on JS Thread, but the `Dispatcher` has already been destroyed!");
           return;
         }
 
@@ -83,7 +85,7 @@ struct JSIConverter<std::future<TResult>> {
     });
   }
 
-  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+  static inline bool canConvert(jsi::Runtime&, const jsi::Value&) {
     throw std::runtime_error("jsi::Value of type Promise cannot be converted to std::future yet!");
   }
 };

package/cpp/jsi/JSIConverter+Tuple.hpp

@@ -23,7 +23,7 @@ using namespace facebook;
 
 // std::tuple<A, B, C> <> [A, B, C]
 template <typename... Types>
-struct JSIConverter<std::tuple<Types...>> {
+struct JSIConverter<std::tuple<Types...>> final {
   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);

package/cpp/jsi/JSIConverter+UnorderedMap.hpp

@@ -23,7 +23,7 @@ using namespace facebook;
 
 // std::unordered_map<std::string, T> <> Record<string, T>
 template <typename ValueType>
-struct JSIConverter<std::unordered_map<std::string, ValueType>> {
+struct JSIConverter<std::unordered_map<std::string, ValueType>> final {
   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);

package/cpp/jsi/JSIConverter+Variant.hpp

@@ -18,7 +18,6 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 
 #include "AnyMap.hpp"
-#include "IsInPack.hpp"
 #include "TypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <memory>
@@ -30,8 +29,7 @@ using namespace facebook;
 
 // std::variant<A, B, C> <> A | B | C
 template <typename... Types>
-struct JSIConverter<std::variant<Types...>> {
-
+struct JSIConverter<std::variant<Types...>> final {
   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) || ...);

package/cpp/jsi/JSIConverter+Vector.hpp

@@ -22,7 +22,7 @@ using namespace facebook;
 
 // std::vector<T> <> T[]
 template <typename ElementType>
-struct JSIConverter<std::vector<ElementType>> {
+struct JSIConverter<std::vector<ElementType>> final {
   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);

package/cpp/jsi/JSIConverter.hpp

@@ -22,7 +22,7 @@ using namespace facebook;
  * The JSIConverter<T> class can convert any type from and to a jsi::Value.
  * It uses templates to statically create fromJSI/toJSI methods, and will throw compile-time errors
  * if a given type is not convertable.
- * Value types, custom types (HostObjects), and even functions with any number of arguments/types are supported.
+ * Value types, custom types (HybridObject), and even functions with any number of arguments/types are supported.
  * This type can be extended by just creating a new template for JSIConverter in a header.
  */
 template <typename T, typename Enable = void>
@@ -61,7 +61,7 @@ private:
 
 // int <> number
 template <>
-struct JSIConverter<int> {
+struct JSIConverter<int> final {
   static inline int fromJSI(jsi::Runtime&, const jsi::Value& arg) {
     return static_cast<int>(arg.asNumber());
   }
@@ -75,11 +75,11 @@ struct JSIConverter<int> {
 
 // std::monostate <> null
 template <>
-struct JSIConverter<std::monostate> {
-  static inline std::monostate fromJSI(jsi::Runtime&, const jsi::Value& arg) {
+struct JSIConverter<std::monostate> final {
+  static inline std::monostate fromJSI(jsi::Runtime&, const jsi::Value&) {
     return std::monostate();
   }
-  static inline jsi::Value toJSI(jsi::Runtime&, std::monostate arg) {
+  static inline jsi::Value toJSI(jsi::Runtime&, std::monostate) {
     return jsi::Value::null();
   }
   static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
@@ -89,7 +89,7 @@ struct JSIConverter<std::monostate> {
 
 // double <> number
 template <>
-struct JSIConverter<double> {
+struct JSIConverter<double> final {
   static inline double fromJSI(jsi::Runtime&, const jsi::Value& arg) {
     return arg.asNumber();
   }
@@ -103,7 +103,7 @@ struct JSIConverter<double> {
 
 // float <> number
 template <>
-struct JSIConverter<float> {
+struct JSIConverter<float> final {
   static inline float fromJSI(jsi::Runtime&, const jsi::Value& arg) {
     return static_cast<float>(arg.asNumber());
   }
@@ -117,7 +117,7 @@ struct JSIConverter<float> {
 
 // int64_t <> BigInt
 template <>
-struct JSIConverter<int64_t> {
+struct JSIConverter<int64_t> final {
   static inline double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     return arg.asBigInt(runtime).asInt64(runtime);
   }
@@ -135,7 +135,7 @@ struct JSIConverter<int64_t> {
 
 // uint64_t <> BigInt
 template <>
-struct JSIConverter<uint64_t> {
+struct JSIConverter<uint64_t> final {
   static inline double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     return arg.asBigInt(runtime).asUint64(runtime);
   }
@@ -153,7 +153,7 @@ struct JSIConverter<uint64_t> {
 
 // bool <> boolean
 template <>
-struct JSIConverter<bool> {
+struct JSIConverter<bool> final {
   static inline bool fromJSI(jsi::Runtime&, const jsi::Value& arg) {
     return arg.asBool();
   }
@@ -167,7 +167,7 @@ struct JSIConverter<bool> {
 
 // std::string <> string
 template <>
-struct JSIConverter<std::string> {
+struct JSIConverter<std::string> final {
   static inline std::string fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     return arg.asString(runtime).utf8(runtime);
   }

package/cpp/jsi/JSPromise.cpp

@@ -38,7 +38,7 @@ void JSPromise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
   OwningLock<jsi::Function> lock = _resolver.lock();
 
   if (!_resolver) {
-    Logger::log(TAG, "Promise resolver function has already been deleted! Ignoring call..");
+    Logger::log(LogLevel::Error, TAG, "Promise resolver function has already been deleted! Ignoring call..");
     return;
   }
   _resolver->call(runtime, std::move(result));
@@ -48,7 +48,7 @@ void JSPromise::reject(jsi::Runtime& runtime, std::string message) {
   OwningLock<jsi::Function> lock = _rejecter.lock();
 
   if (!_rejecter) {
-    Logger::log(TAG, "Promise rejecter function has already been deleted! Ignoring call..");
+    Logger::log(LogLevel::Error, TAG, "Promise rejecter function has already been deleted! Ignoring call..");
     return;
   }
   jsi::JSError error(runtime, message);

package/cpp/platform/NitroLogger.hpp

@@ -0,0 +1,67 @@
+//
+// Created by Marc Rousavy on 05.03.24.
+//
+
+#pragma once
+
+#include <cstdarg>
+#include <cstdio>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+enum class LogLevel { Debug, Info, Warning, Error };
+
+class Logger final {
+private:
+  Logger() = delete;
+
+public:
+  template <typename... Args>
+  static void log(LogLevel level, const char* tag, const char* format, Args... args) {
+#ifndef NDEBUG
+    // 1. Make sure args can be passed to sprintf(..)
+    static_assert(all_are_trivially_copyable<Args...>(), "All arguments passed to Logger::log(..) must be trivially copyable! "
+                                                         "Did you try to pass a complex type, like std::string?");
+
+    // 2. Format all arguments in the message
+    std::string message = formatString(format, args...);
+
+    // 3. Call the platform specific log function
+    nativeLog(level, tag, message);
+#endif
+  }
+
+  static void nativeLog(LogLevel level, const char* tag, const std::string& string);
+
+private:
+  template <typename... Args>
+  static std::string formatString(const char* format, Args... args) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wformat-security"
+    int size = snprintf(nullptr, 0, format, args...) + 1; // Extra space for '\0'
+    if (size <= 0) {
+      return "Error during formatting.";
+    }
+    std::unique_ptr<char[]> buf(new char[size]);
+    snprintf(buf.get(), size, format, args...);
+    return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
+#pragma clang diagnostic pop
+  }
+
+  // Overloaded functions to convert std::string to C-style string
+  template <typename T>
+  static constexpr bool is_trivially_copyable() {
+    return std::is_trivially_copyable<T>::value;
+  }
+
+  template <typename... Args>
+  static constexpr bool all_are_trivially_copyable() {
+    return (is_trivially_copyable<Args>() && ...);
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -30,7 +30,7 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
 
   // 2. We didn't find the given prototype in cache (either it's a new prototype, or a new runtime),
   //    so we need to create it. First, we need some helper methods from JS
-  Logger::log(TAG, "Creating new JS prototype for C++ instance type \"%s\"...", prototype->getNativeInstanceId().name());
+  Logger::log(LogLevel::Info, TAG, "Creating new JS prototype for C++ instance type \"%s\"...", prototype->getNativeInstanceId().name());
   jsi::Object objectConstructor = runtime.global().getPropertyAsObject(runtime, "Object");
   jsi::Function objectCreate = objectConstructor.getPropertyAsFunction(runtime, "create");
   jsi::Function objectDefineProperty = objectConstructor.getPropertyAsFunction(runtime, "defineProperty");
@@ -69,7 +69,7 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
   prototypeCache.emplace(prototype->getNativeInstanceId(), cachedObject);
 
   // 7. In DEBUG, add a __type info to the prototype object.
-#if DEBUG
+#ifndef NDEBUG
   auto typeName = "Prototype<" + std::string(prototype->getNativeInstanceId().name()) + ">";
   cachedObject->setProperty(runtime, "__type", jsi::String::createFromUtf8(runtime, typeName));
 #endif

package/cpp/prototype/Prototype.hpp

@@ -38,8 +38,8 @@ using NativeInstanceId = std::type_index;
  */
 struct Prototype final {
 private:
-  std::shared_ptr<Prototype> _base = nullptr;
   NativeInstanceId _instanceTypeId;
+  std::shared_ptr<Prototype> _base = nullptr;
   std::unordered_map<std::string, HybridFunction> _methods;
   std::unordered_map<std::string, HybridFunction> _getters;
   std::unordered_map<std::string, HybridFunction> _setters;
@@ -102,25 +102,6 @@ public:
   }
 
 public:
-  /**
-   * Registers the given C++ method as a Hybrid Method that can be called from JS, through the object's Prototype.
-   * Example:
-   * ```cpp
-   * registerHybridMethod("sayHello", &MyObject::sayHello);
-   * ```
-   */
-  template <typename Derived, typename ReturnType, typename... Args>
-  inline void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...)) {
-    if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
-    }
-    if (_methods.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
-    }
-
-    _methods.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionType::METHOD));
-  }
-
   /**
    * Registers the given C++ method as a property getter that can be called from JS, through the object's Prototype.
    * Example:
@@ -137,7 +118,7 @@ public:
       throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a method with that name already exists!");
     }
 
-    _getters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionType::GETTER));
+    _getters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionKind::GETTER));
   }
 
   /**
@@ -156,7 +137,47 @@ public:
       throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a method with that name already exists!");
     }
 
-    _setters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionType::SETTER));
+    _setters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionKind::SETTER));
+  }
+
+  /**
+   * Registers the given C++ method as a Hybrid Method that can be called from JS, through the object's Prototype.
+   * Example:
+   * ```cpp
+   * registerHybridMethod("sayHello", &MyObject::sayHello);
+   * ```
+   */
+  template <typename Derived, typename ReturnType, typename... Args>
+  inline void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...)) {
+    if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _methods.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionKind::METHOD));
+  }
+
+  /**
+   * Registers the given raw JSI C++ method as a Hybrid Method that can be called from JS, through the object's Prototype.
+   * Example:
+   * ```cpp
+   * registerRawHybridMethod("sayHello", &MyObject::sayHello);
+   * ```
+   */
+  template <typename Derived>
+  inline void registerRawHybridMethod(std::string name, size_t expectedArgumentsCount,
+                                      jsi::Value (Derived::*method)(jsi::Runtime& runtime, const jsi::Value& thisArg,
+                                                                    const jsi::Value* args, size_t count)) {
+    if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _methods.emplace(name, HybridFunction::createRawHybridFunction(name, expectedArgumentsCount, method));
   }
 };
 

package/cpp/registry/HybridObjectRegistry.cpp

@@ -29,9 +29,9 @@ std::vector<std::string> HybridObjectRegistry::getAllHybridObjectNames() {
 }
 
 void HybridObjectRegistry::registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn) {
-  Logger::log(TAG, "Registering HybridObject \"%s\"...", hybridObjectName);
+  Logger::log(LogLevel::Info, TAG, "Registering HybridObject \"%s\"...", hybridObjectName.c_str());
   auto& map = HybridObjectRegistry::getRegistry();
-#if DEBUG
+#ifndef NDEBUG
   if (map.contains(hybridObjectName)) [[unlikely]] {
     auto message =
         "HybridObject \"" + std::string(hybridObjectName) +
@@ -43,7 +43,7 @@ void HybridObjectRegistry::registerHybridObjectConstructor(const std::string& hy
   }
 #endif
   map.insert({hybridObjectName, std::move(constructorFn)});
-  Logger::log(TAG, "Successfully registered HybridObject \"%s\"!", hybridObjectName);
+  Logger::log(LogLevel::Info, TAG, "Successfully registered HybridObject \"%s\"!", hybridObjectName.c_str());
 }
 
 std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(const std::string& hybridObjectName) {
@@ -57,7 +57,7 @@ std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(const std
   }
   std::shared_ptr<HybridObject> instance = fn->second();
 
-#if DEBUG
+#ifndef NDEBUG
   if (instance == nullptr) [[unlikely]] {
     throw std::runtime_error("Failed to create HybridObject \"" + hybridObjectName +
                              "\" - "

package/cpp/threading/Dispatcher.cpp

@@ -11,7 +11,7 @@ static constexpr auto GLOBAL_DISPATCHER_HOLDER_NAME = "__nitroDispatcher";
 std::unordered_map<jsi::Runtime*, std::weak_ptr<Dispatcher>> Dispatcher::_globalCache;
 
 void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher) {
-  Logger::log(TAG, "Installing global Dispatcher Holder into Runtime \"%s\"...", getRuntimeId(runtime));
+  Logger::log(LogLevel::Info, TAG, "Installing global Dispatcher Holder into Runtime \"%s\"...", getRuntimeId(runtime).c_str());
 
   // Store a weak reference in global cache
   _globalCache[&runtime] = std::weak_ptr(dispatcher);
@@ -33,14 +33,15 @@ std::shared_ptr<Dispatcher> Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime&
     }
   }
 
-  Logger::log(TAG, "Unknown Runtime (%s), looking for Dispatcher through JSI global lookup...", getRuntimeId(runtime));
+  Logger::log(LogLevel::Warning, TAG, "Unknown Runtime (%s), looking for Dispatcher through JSI global lookup...",
+              getRuntimeId(runtime).c_str());
   jsi::Value dispatcherHolderValue = getRuntimeGlobalDispatcherHolder(runtime);
   jsi::Object dispatcherHolder = dispatcherHolderValue.getObject(runtime);
   return dispatcherHolder.getNativeState<Dispatcher>(runtime);
 }
 
 jsi::Value Dispatcher::getRuntimeGlobalDispatcherHolder(jsi::Runtime& runtime) {
-#if DEBUG
+#ifndef NDEBUG
   if (!runtime.global().hasProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME)) {
     throw std::runtime_error("Failed to get current Dispatcher - the global Dispatcher "
                              "holder (global." +

package/cpp/threading/ThreadPool.cpp

@@ -12,7 +12,7 @@
 namespace margelo::nitro {
 
 ThreadPool::ThreadPool(const char* name, size_t numThreads) : _isAlive(true), _name(name) {
-  Logger::log(TAG, "Creating ThreadPool \"%s\" with %i threads...", name, numThreads);
+  Logger::log(LogLevel::Info, TAG, "Creating ThreadPool \"%s\" with %i threads...", name, numThreads);
 
   for (size_t i = 0; i < numThreads; ++i) {
     std::string threadName = std::string(name) + "-" + std::to_string(i + 1);
@@ -56,7 +56,7 @@ void ThreadPool::run(std::function<void()>&& task) {
 }
 
 ThreadPool::~ThreadPool() {
-  Logger::log(TAG, "Destroying ThreadPool \"%s\"...", _name);
+  Logger::log(LogLevel::Info, TAG, "Destroying ThreadPool \"%s\"...", _name);
 
   {
     // Lock and set `_isAlive` to false.