react-native-nitro-modules 0.5.0 → 0.7.0

package/cpp/core/HybridObject.cpp

@@ -49,8 +49,8 @@ HybridObject::HybridObject(const char* name) : HybridObjectPrototype(), _name(na
   _instanceId = getId(name);
   uint32_t alive = incrementAliveInstancesAndGet(_name);
   uint32_t totalObjects = getTotalAliveInstances();
-  Logger::log(TAG, "(MEMORY) ✅ Creating %s (#%i)... (Total %s(s): %i | Total HybridObjects: %i)", _name, _instanceId, _name, alive,
-              totalObjects);
+  Logger::log(LogLevel::Info, TAG, "(MEMORY) ✅ Creating %s (#%i)... (Total %s(s): %i | Total HybridObjects: %i)", _name, _instanceId,
+              _name, alive, totalObjects);
 #endif
 }
 
@@ -58,8 +58,8 @@ HybridObject::~HybridObject() {
 #if LOG_MEMORY_ALLOCATIONS
   uint32_t alive = decrementAliveInstancesAndGet(_name);
   uint32_t totalObjects = getTotalAliveInstances();
-  Logger::log(TAG, "(MEMORY) ❌ Deleting %s (#%i)... (Total %s(s): %i | Total HybridObjects: %i) ", _name, _instanceId, _name, alive,
-              totalObjects);
+  Logger::log(LogLevel::Info, TAG, "(MEMORY) ❌ Deleting %s (#%i)... (Total %s(s): %i | Total HybridObjects: %i) ", _name, _instanceId,
+              _name, alive, totalObjects);
 #endif
 }
 
@@ -75,11 +75,22 @@ bool HybridObject::equals(std::shared_ptr<HybridObject> other) {
   return this == other.get();
 }
 
+jsi::Value HybridObject::disposeRaw(jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) {
+  // 1. Dispose any resources - this might be overridden by child classes to perform manual cleanup.
+  dispose();
+  // 2. Remove the NativeState from `this`
+  jsi::Object thisObject = thisArg.asObject(runtime);
+  thisObject.setNativeState(runtime, nullptr);
+
+  return jsi::Value::undefined();
+}
+
 void HybridObject::loadHybridMethods() {
   registerHybrids(this, [](Prototype& prototype) {
     prototype.registerHybridGetter("name", &HybridObject::getName);
-    prototype.registerHybridMethod("toString", &HybridObject::toString);
     prototype.registerHybridMethod("equals", &HybridObject::equals);
+    prototype.registerHybridMethod("toString", &HybridObject::toString);
+    prototype.registerRawHybridMethod("dispose", 0, &HybridObject::disposeRaw);
   });
 }
 
@@ -112,7 +123,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   // 6. Set memory size so Hermes GC knows about actual memory
   object.setExternalMemoryPressure(runtime, getExternalMemorySize());
 
-#if DEBUG
+#ifndef NDEBUG
   // 7. Assign a private __type property for debugging - this will be used so users know it's not just an empty object.
   object.setProperty(runtime, "__type", jsi::String::createFromUtf8(runtime, "NativeState<" + std::string(_name) + ">"));
 #endif

package/cpp/core/HybridObject.hpp

@@ -23,7 +23,7 @@ using namespace facebook;
  *
  * The new class can then be passed to JS using the `JSIConverter<HybridObject>`.
  */
-class HybridObject : public jsi::NativeState, public HybridObjectPrototype, public std::enable_shared_from_this<HybridObject> {
+class HybridObject : public virtual jsi::NativeState, public HybridObjectPrototype, public std::enable_shared_from_this<HybridObject> {
 public:
   /**
    * Create a new instance of a `HybridObject`.
@@ -38,11 +38,17 @@ public:
   /**
    * HybridObjects cannot be copied.
    */
-  HybridObject(const HybridObject& copy) = delete;
+  HybridObject(const HybridObject& copy) = default;
   /**
    * HybridObjects cannot be moved.
    */
-  HybridObject(HybridObject&& move) = delete;
+  HybridObject(HybridObject&& move) = default;
+  /**
+   * HybridObjects cannot be default-constructed!
+   */
+  HybridObject() {
+    throw std::runtime_error("Cannot default-construct HybridObject!");
+  }
 
 public:
   /**
@@ -60,7 +66,7 @@ public:
    */
   template <typename Derived>
   std::shared_ptr<Derived> shared() {
-    return std::static_pointer_cast<Derived>(shared_from_this());
+    return std::dynamic_pointer_cast<Derived>(shared_from_this());
   }
 
 public:
@@ -68,10 +74,6 @@ public:
    * Get the HybridObject's name
    */
   std::string getName();
-  /**
-   * Get a string representation of this HostObject, useful for logging or debugging.
-   */
-  virtual std::string toString();
   /**
    * Compare this HybridObject for reference equality to the other HybridObject.
    *
@@ -79,6 +81,28 @@ public:
    * they might still be the same `HybridObject` - in this case `equals(other)` will return true.
    */
   bool equals(std::shared_ptr<HybridObject> other);
+  /**
+   * Get a string representation of this `HybridObject` - useful for logging or debugging.
+   */
+  virtual std::string toString();
+  /**
+   * Eagerly- (and manually-) dispose all native resources this `HybridObject` holds.
+   * This method can only be manually called from JS using `dispose()`.
+   *
+   * If this method is never manually called, a `HybridObject` is expected to disposes it's
+   * resources as usual via the object's destructor (`~HybridObject()`, `deinit` or `finalize()`).
+   *
+   * By default, this method does nothing. It can be overridden to perform actual disposing/cleanup
+   * if required.
+   */
+  virtual void dispose() {}
+
+private:
+  /**
+   * The actual `dispose()` function from JS.
+   * This needs to be a raw JSI function as we remove the NativeState here.
+   */
+  jsi::Value disposeRaw(jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count);
 
 protected:
   /**

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!");
@@ -68,8 +69,8 @@ struct JSIConverter<std::function<ReturnType(Args...)>> {
   }
 
   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 {
+    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.
@@ -123,7 +124,7 @@ private:
     } 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);
+      return JSIConverter<ReturnType>::toJSI(runtime, std::forward<ReturnType>(result));
     }
   }
 };

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

@@ -30,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!");
   }
@@ -49,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;
         }
 
@@ -62,7 +63,7 @@ struct JSIConverter<std::future<TResult>> {
             } 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);
+              jsi::Value jsResult = JSIConverter<TResult>::toJSI(runtime, std::forward<TResult>(result));
               promise->resolve(runtime, std::move(jsResult));
             }
           } catch (const std::exception& exception) {
@@ -84,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