react-native-nitro-modules 0.20.1 → 0.22.0

package/NitroModules.podspec

@@ -43,6 +43,7 @@ Pod::Spec.new do |s|
     "cpp/threading/Dispatcher.hpp",
     "cpp/utils/NitroHash.hpp",
     "cpp/utils/NitroDefines.hpp",
+    "cpp/views/CachedProp.hpp",
     # Public iOS-specific headers that will be exposed in modulemap (for Swift)
     "ios/core/ArrayBufferHolder.hpp",
     "ios/core/AnyMapHolder.hpp",
@@ -60,11 +61,13 @@ Pod::Spec.new do |s|
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",
-    # C++ compiler flags, mainly for folly.
+    # C++ compiler flags, mainly for RN version and folly.
     "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
   }
 
+  # Nitro depends on JSI.
   s.dependency 'React-jsi'
+  # For React Native, we implement nitro::Dispatcher using react::CallInvoker
   s.dependency 'React-callinvoker'
   install_modules_dependencies(s)
 end

package/README.md

@@ -208,7 +208,7 @@ The following C++ / JS types are supported out of the box:
   <tr>
     <td>..any <code><a href="./src/HybridObject.ts">HybridObject</a></code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/HybridObject.hpp">HybridObject</a>&gt;</code></td>
-    <td><code><a href="./ios/core/HybridObjectSpec.swift">HybridObjectSpec</a></code></td>
+    <td><code><a href="./ios/core/HybridObject.swift">HybridObject</a></code></td>
     <td><code><a href="./android/src/main/java/com/margelo/nitro/core/HybridObject.kt">HybridObject</a></code></td>
   </tr>
   <tr>

package/android/CMakeLists.txt

@@ -32,6 +32,7 @@ include_directories(
   ../cpp/threading
   ../cpp/turbomodule
   ../cpp/utils
+  ../cpp/views
   # Android-specific C++ includes
   src/main/cpp/core
   src/main/cpp/registry

package/android/build.gradle

@@ -1,3 +1,5 @@
+import groovy.json.JsonSlurper
+
 buildscript {
   repositories {
     google()
@@ -5,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.7.3"
+    classpath "com.android.tools.build:gradle:8.8.0"
   }
 }
 
@@ -154,7 +156,7 @@ if (isNewArchitectureEnabled()) {
   }
 }
 
-task prepareHeaders(type: Copy) {
+tasks.register('prepareHeaders', Copy) {
   from fileTree('./src/main/cpp').filter { it.isFile() }
   from fileTree('../cpp/').filter { it.isFile() }
   include "*.hpp"

package/android/gradle.properties

@@ -1,5 +1,5 @@
-Nitro_kotlinVersion=1.9.24
+Nitro_kotlinVersion=2.0.21
 Nitro_minSdkVersion=23
 Nitro_targetSdkVersion=34
 Nitro_compileSdkVersion=34
-Nitro_ndkVersion=26.1.10909125
+Nitro_ndkVersion=27.1.12297006

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

@@ -17,12 +17,12 @@ namespace margelo::nitro {
 std::string ThreadUtils::getThreadName() {
 #ifdef HAVE_ANDROID_PTHREAD_SETNAME_NP
   // Try using pthread APIs
-  pthread_t this_thread = pthread_self();
-  char thread_name[16]; // Thread name length limit in Android is 16 characters
+  pthread_t thisThread = pthread_self();
+  char threadName[16]; // Thread name length limit in Android is 16 characters
 
-  int result = pthread_getname_np(this_thread, thread_name, sizeof(thread_name));
+  int result = pthread_getname_np(thisThread, threadName, sizeof(threadName));
   if (result == 0) {
-    return std::string(thread_name);
+    return std::string(threadName);
   }
 #endif
 

package/android/src/main/cpp/registry/JHybridObjectRegistry.hpp

@@ -20,6 +20,8 @@ public:
   static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/HybridObjectRegistry;";
 
 public:
+  [[deprecated("HybridObjects should be registered from C++ instead. Either autolink them using `nitro.json`, "
+               "or add them manually in the C++ HybridObjectRegistry.")]]
   static void registerHybridObjectConstructor(jni::alias_ref<jni::JClass> clazz, std::string hybridObjectName,
                                               jni::alias_ref<JHybridObjectInitializer> constructorFn);
 

package/android/src/main/java/com/margelo/nitro/core/ArrayBuffer.kt

@@ -107,19 +107,40 @@ class ArrayBuffer {
         /**
          * Copy the given `ArrayBuffer` into a new **owning** `ArrayBuffer`.
          */
-        fun copyOf(other: ArrayBuffer): ArrayBuffer {
-            // 1. Create a new buffer with the same size as the other
-            val newBuffer = ByteBuffer.allocateDirect(other.size)
-            // 2. Prepare the source buffer
-            val originalBuffer = other.getBuffer(false)
-            originalBuffer.rewind()
+        fun copy(other: ArrayBuffer): ArrayBuffer {
+            val byteBuffer = other.getBuffer(false)
+            return copy(byteBuffer)
+        }
+
+        /**
+         * Copy the given `ByteBuffer` into a new **owning** `ArrayBuffer`.
+         */
+        fun copy(byteBuffer: ByteBuffer): ArrayBuffer {
+            // 1. Find out size
+            byteBuffer.rewind()
+            val size = byteBuffer.remaining()
+            // 2. Create a new buffer with the same size as the other
+            val newBuffer = ByteBuffer.allocateDirect(size)
             // 3. Copy over the source buffer into the new buffer
-            newBuffer.put(originalBuffer)
+            newBuffer.put(byteBuffer)
             // 4. Rewind both buffers again to index 0
             newBuffer.rewind()
-            originalBuffer.rewind()
+            byteBuffer.rewind()
             // 5. Create a new `ArrayBuffer`
             return ArrayBuffer(newBuffer)
         }
+
+        /**
+         * Wrap the given `ByteBuffer` in a new **owning** `ArrayBuffer`.
+         */
+        fun wrap(byteBuffer: ByteBuffer): ArrayBuffer {
+            byteBuffer.rewind()
+            return ArrayBuffer(byteBuffer)
+        }
+
+        @Deprecated("Use copy(...) instead", level = DeprecationLevel.WARNING)
+        fun copyOf(other: ArrayBuffer): ArrayBuffer {
+            return copy(other)
+        }
     }
 }

package/android/src/main/java/com/margelo/nitro/core/HybridObject.kt

@@ -4,16 +4,12 @@ import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 
-interface ExtendableHybridClass {
-    fun updateNative(hybridData: HybridData)
-}
-
 /**
  * A base class for all Kotlin-based HybridObjects.
  */
 @Keep
 @DoNotStrip
-abstract class HybridObject: ExtendableHybridClass {
+abstract class HybridObject {
     /**
      * Get the memory size of the Kotlin instance (plus any external heap allocations),
      * in bytes.
@@ -23,7 +19,7 @@ abstract class HybridObject: ExtendableHybridClass {
      *
      * @example
      * ```kotlin
-     * val memorySize: ULong
+     * override val memorySize: ULong
      *   get() {
      *     val imageSize = this.bitmap.bytesPerRow * this.bitmap.height
      *     return imageSize
@@ -32,7 +28,8 @@ abstract class HybridObject: ExtendableHybridClass {
      */
     @get:DoNotStrip
     @get:Keep
-    abstract val memorySize: Long
+    open val memorySize: Long
+        get() = 0L
 
     /**
      * Holds the native C++ instance.
@@ -42,10 +39,14 @@ abstract class HybridObject: ExtendableHybridClass {
     private var mHybridData: HybridData? = null
 
     /**
-     * Must be called in the constructor of a subclass of `HybridObject`, to initialize the C++
-     * `JHybridObject` with a subclass of it.
+     * If `HybridObject` is subclassed, the sub-class needs to create it's own `HybridData`
+     * with a C++ `jni::HybridClass` representing the subclass directly.
+     * Then, that `HybridData` must be passed upwards to `HybridObject` using `updateNative(..)`.
+     *
+     * This must happen for each sub/base class in the whole inheritance chain to ensure
+     * overrides and type-erasure works as expected.
      */
-    override fun updateNative(hybridData: HybridData) {
+    protected open fun updateNative(hybridData: HybridData) {
         mHybridData = hybridData
     }
 }

package/android/src/main/java/com/margelo/nitro/core/HybridObjectInitializer.java

@@ -4,8 +4,12 @@ import androidx.annotation.Keep;
 
 import com.facebook.proguard.annotations.DoNotStrip;
 
+/**
+ * @deprecated HybridObjects should be registered from C++ instead. Either autolink them using `nitro.json`, or add them manually in the C++ `HybridObjectRegistry`.
+ */
 @Keep
 @DoNotStrip
+@Deprecated(forRemoval = true)
 public interface HybridObjectInitializer {
     @Keep
     @DoNotStrip

package/android/src/main/java/com/margelo/nitro/core/HybridObjectRegistry.java

@@ -20,6 +20,8 @@ public class HybridObjectRegistry {
      * Registers the given HybridObject in the `HybridObjectRegistry`.
      * It will be uniquely identified via it's `hybridObjectName`, and can be initialized from
      * JS using `NitroModules.createHybridObject<T>(name)` - which will call the `constructorFn` here.
+     * @deprecated HybridObjects should be registered from C++ instead. Either autolink them using `nitro.json`, or add them manually in the C++ `HybridObjectRegistry`.
      */
+    @Deprecated(forRemoval = true)
     public static native void registerHybridObjectConstructor(String hybridObjectName, HybridObjectInitializer initializer);
 }

package/android/src/main/java/com/margelo/nitro/views/HybridView.kt

@@ -0,0 +1,23 @@
+package com.margelo.nitro.views
+
+import android.view.View
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A base class for all Kotlin-based Hybrid Views.
+ */
+@Keep
+@DoNotStrip
+abstract class HybridView: HybridObject() {
+    /**
+     * Get the `UIView` this HybridView is holding.
+     *
+     * This value should not change during the lifetime of this `HybridView`.
+     */
+    @get:DoNotStrip
+    @get:Keep
+    abstract val view: View
+}

package/cpp/core/ArrayBuffer.cpp

@@ -17,10 +17,25 @@ using namespace facebook;
 
 // 1. ArrayBuffer
 
-std::shared_ptr<ArrayBuffer> ArrayBuffer::makeBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc) {
+std::shared_ptr<ArrayBuffer> ArrayBuffer::wrap(uint8_t* data, size_t size, DeleteFn&& deleteFunc) {
   return std::make_shared<NativeArrayBuffer>(data, size, std::move(deleteFunc));
 }
 
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(uint8_t* data, size_t size) {
+  uint8_t* copy = new uint8_t[size];
+  std::memcpy(copy, data, size);
+  return ArrayBuffer::wrap(copy, size, [=]() { delete[] copy; });
+}
+
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(std::vector<uint8_t>& data) {
+  return ArrayBuffer::copy(data.data(), data.size());
+}
+
+std::shared_ptr<ArrayBuffer> ArrayBuffer::allocate(size_t size) {
+  uint8_t* data = new uint8_t[size];
+  return ArrayBuffer::wrap(data, size, [=]() { delete[] data; });
+}
+
 // 2. NativeArrayBuffer
 
 NativeArrayBuffer::NativeArrayBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc)

package/cpp/core/ArrayBuffer.hpp

@@ -10,6 +10,7 @@
 #include "OwningReference.hpp"
 #include <jsi/jsi.h>
 #include <thread>
+#include <vector>
 
 namespace margelo::nitro {
 
@@ -52,7 +53,25 @@ public:
    * Create a new `NativeArrayBuffer` that wraps the given data (without copy) of the given size,
    * and calls `deleteFunc` in which `data` should be deleted.
    */
-  static std::shared_ptr<ArrayBuffer> makeBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc);
+  static std::shared_ptr<ArrayBuffer> wrap(uint8_t* data, size_t size, DeleteFn&& deleteFunc);
+  /**
+   * Create a new `NativeArrayBuffer` that copies the given data of the given size
+   * into a newly allocated buffer.
+   */
+  static std::shared_ptr<ArrayBuffer> copy(uint8_t* data, size_t size);
+  /**
+   * Create a new `NativeArrayBuffer` that copies the given `std::vector`.
+   */
+  static std::shared_ptr<ArrayBuffer> copy(std::vector<uint8_t>& data);
+  /**
+   * Create a new `NativeArrayBuffer` that allocates a new buffer of the given size.
+   */
+  static std::shared_ptr<ArrayBuffer> allocate(size_t size);
+
+  [[deprecated("Use wrapBuffer(...) instead.")]]
+  static std::shared_ptr<ArrayBuffer> makeBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc) {
+    return ArrayBuffer::wrap(data, size, std::move(deleteFunc));
+  }
 };
 
 /**

package/cpp/core/HybridFunction.hpp

@@ -15,7 +15,7 @@ struct JSIConverter;
 #include "CountTrailingOptionals.hpp"
 #include "JSIConverter.hpp"
 #include "NitroDefines.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <exception>
 #include <functional>
 #include <jsi/jsi.h>

package/cpp/core/HybridObject.cpp

@@ -9,7 +9,6 @@
 namespace margelo::nitro {
 
 HybridObject::HybridObject(const char* name) : HybridObjectPrototype(), _name(name) {}
-HybridObject::~HybridObject() {}
 
 std::string HybridObject::toString() {
   return "[HybridObject " + std::string(_name) + "]";
@@ -19,7 +18,7 @@ std::string HybridObject::getName() {
   return _name;
 }
 
-bool HybridObject::equals(std::shared_ptr<HybridObject> other) {
+bool HybridObject::equals(const std::shared_ptr<HybridObject>& other) {
   return this == other.get();
 }
 
@@ -48,10 +47,12 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   if (cachedObject != _objectCache.end()) {
     // 1.1. We have a WeakObject, try to see if it is still alive
     OwningLock<jsi::WeakObject> lock = cachedObject->second.lock();
-    jsi::Value object = cachedObject->second->lock(runtime);
-    if (!object.isUndefined()) {
-      // 1.2. It is still alive - we can use it instead of creating a new one!
-      return object;
+    jsi::Value value = cachedObject->second->lock(runtime);
+    if (!value.isUndefined()) {
+      // 1.2. It is still alive - we can use it instead of creating a new one! But first, let's update memory-size
+      value.getObject(runtime).setExternalMemoryPressure(runtime, getExternalMemorySize());
+      // 1.3. Return it now
+      return value;
     }
   }
 

package/cpp/core/HybridObject.hpp

@@ -34,7 +34,7 @@ public:
    * Called when no more references to the given `HybridObject` exist in both C++ and JS.
    * JS might keep references for longer, as it is a garbage collected language.
    */
-  virtual ~HybridObject();
+  ~HybridObject() override = default;
   /**
    * HybridObjects cannot be copied.
    */
@@ -80,7 +80,7 @@ public:
    * While two `jsi::Object`s of the same `HybridObject` might not be equal when compared with `==`,
    * they might still be the same `HybridObject` - in this case `equals(other)` will return true.
    */
-  bool equals(std::shared_ptr<HybridObject> other);
+  bool equals(const std::shared_ptr<HybridObject>& other);
   /**
    * Get a string representation of this `HybridObject` - useful for logging or debugging.
    */

package/cpp/core/Promise.hpp

@@ -6,8 +6,8 @@
 
 #include "AssertPromiseState.hpp"
 #include "NitroDefines.hpp"
+#include "NitroTypeInfo.hpp"
 #include "ThreadPool.hpp"
-#include "TypeInfo.hpp"
 #include <exception>
 #include <future>
 #include <jsi/jsi.h>

package/cpp/entrypoint/HybridNitroModulesProxy.cpp

@@ -7,6 +7,7 @@
 
 #include "HybridNitroModulesProxy.hpp"
 #include "HybridObjectRegistry.hpp"
+#include "JSIConverter.hpp"
 #include "NitroDefines.hpp"
 
 namespace margelo::nitro {
@@ -20,6 +21,7 @@ void HybridNitroModulesProxy::loadHybridMethods() {
     prototype.registerHybridMethod("getAllHybridObjectNames", &HybridNitroModulesProxy::getAllHybridObjectNames);
 
     prototype.registerHybridMethod("box", &HybridNitroModulesProxy::box);
+    prototype.registerHybridMethod("updateMemorySize", &HybridNitroModulesProxy::updateMemorySize);
 
     prototype.registerRawHybridMethod("hasNativeState", 1, &HybridNitroModulesProxy::hasNativeState);
 
@@ -53,6 +55,12 @@ jsi::Value HybridNitroModulesProxy::hasNativeState(jsi::Runtime& runtime, const
   return args[0].getObject(runtime).hasNativeState(runtime);
 }
 
+std::shared_ptr<HybridObject> HybridNitroModulesProxy::updateMemorySize(const std::shared_ptr<HybridObject>& hybridObject) {
+  // If a hybridObject goes from Native -> JS, it will update it's memory size internally (in `HybridObject::toObject(..)`).
+  // This is all that function does.
+  return hybridObject;
+}
+
 // Build Info
 std::string HybridNitroModulesProxy::getBuildType() {
 #ifdef NITRO_DEBUG

package/cpp/entrypoint/HybridNitroModulesProxy.hpp

@@ -37,6 +37,7 @@ public:
 
   // Helpers
   std::shared_ptr<BoxedHybridObject> box(const std::shared_ptr<HybridObject>& hybridObject);
+  std::shared_ptr<HybridObject> updateMemorySize(const std::shared_ptr<HybridObject>& hybridObject);
   jsi::Value hasNativeState(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* args, size_t size);
 
   // Build Info

package/cpp/jsi/JSICache.cpp

@@ -28,6 +28,7 @@ JSICache::~JSICache() {
   Logger::log(LogLevel::Info, TAG, "Destroying JSICache...");
   std::unique_lock lock(_mutex);
 
+  destroyReferences(_valueCache);
   destroyReferences(_objectCache);
   destroyReferences(_functionCache);
   destroyReferences(_weakObjectCache);

package/cpp/jsi/JSICache.hpp

@@ -59,6 +59,7 @@ private:
 
 private:
   std::mutex _mutex;
+  std::vector<BorrowingReference<jsi::Value>> _valueCache;
   std::vector<BorrowingReference<jsi::Object>> _objectCache;
   std::vector<BorrowingReference<jsi::Function>> _functionCache;
   std::vector<BorrowingReference<jsi::WeakObject>> _weakObjectCache;
@@ -82,6 +83,11 @@ public:
   }
 
 public:
+  OwningReference<jsi::Value> makeShared(jsi::Value&& value) {
+    OwningReference<jsi::Value> owning(new jsi::Value(std::move(value)));
+    _strongCache->_valueCache.push_back(owning.weak());
+    return owning;
+  }
   OwningReference<jsi::Object> makeShared(jsi::Object&& value) {
     OwningReference<jsi::Object> owning(new jsi::Object(std::move(value)));
     _strongCache->_objectCache.push_back(owning.weak());

package/cpp/jsi/JSIConverter+Exception.hpp

@@ -12,7 +12,7 @@ struct JSIConverter;
 
 #include "JSIConverter.hpp"
 
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <exception>
 #include <jsi/jsi.h>
 

package/cpp/jsi/JSIConverter+HostObject.hpp

@@ -6,7 +6,7 @@
 
 #include "IsSharedPtrTo.hpp"
 #include "NitroDefines.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <type_traits>
 

package/cpp/jsi/JSIConverter+HybridObject.hpp

@@ -11,7 +11,7 @@ class HybridObject;
 
 #include "IsSharedPtrTo.hpp"
 #include "NitroDefines.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <type_traits>
 

package/cpp/jsi/JSIConverter+Tuple.hpp

@@ -12,7 +12,7 @@ struct JSIConverter;
 
 #include "JSIConverter.hpp"
 
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <memory>
 #include <tuple>

package/cpp/jsi/JSIConverter+Variant.hpp

@@ -18,7 +18,7 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 
 #include "AnyMap.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <memory>
 #include <variant>

package/cpp/jsi/JSIHelpers.hpp

@@ -46,7 +46,7 @@ static inline bool isPlainObject(jsi::Runtime& runtime, const jsi::Object& objec
  */
 static inline std::string getRuntimeId(jsi::Runtime& runtime) {
   std::string threadName = ThreadUtils::getThreadName();
-  return runtime.description() + std::string(" (") + threadName + std::string(")");
+  return runtime.description() + " (" + threadName + ")";
 }
 
 } // namespace margelo::nitro

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -8,7 +8,7 @@
 #include "HybridObjectPrototype.hpp"
 #include "NitroDefines.hpp"
 #include "NitroLogger.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 
 namespace margelo::nitro {
 

package/cpp/registry/HybridObjectRegistry.cpp

@@ -8,6 +8,7 @@
 #include "HybridObjectRegistry.hpp"
 #include "NitroDefines.hpp"
 #include "NitroLogger.hpp"
+#include <numeric>
 
 namespace margelo::nitro {
 
@@ -29,17 +30,25 @@ std::vector<std::string> HybridObjectRegistry::getAllHybridObjectNames() {
   return keys;
 }
 
+std::string HybridObjectRegistry::getAllRegisteredHybridObjectNamesToString() {
+  std::vector<std::string> names = getAllHybridObjectNames();
+  return std::accumulate(std::next(names.begin()), names.end(), names[0], [](std::string a, std::string b) { return a + ", " + b; });
+}
+
 void HybridObjectRegistry::registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn) {
   Logger::log(LogLevel::Info, TAG, "Registering HybridObject \"%s\"...", hybridObjectName.c_str());
   auto& map = HybridObjectRegistry::getRegistry();
 #ifdef NITRO_DEBUG
   if (map.contains(hybridObjectName)) [[unlikely]] {
+    auto allObjectNames = getAllRegisteredHybridObjectNamesToString();
     auto message =
-        "HybridObject \"" + std::string(hybridObjectName) +
+        "HybridObject \"" + hybridObjectName +
         "\" has already been "
         "registered in the Nitro Modules HybridObjectRegistry! Suggestions:\n"
         "- If you just installed another library, maybe both libraries are using the same name?\n"
-        "- If you just registered your own HybridObject, maybe you accidentally called `registerHybridObjectConstructor(...)` twice?";
+        "- If you just registered your own HybridObject, maybe you accidentally called `registerHybridObjectConstructor(...)` twice?\n"
+        "- All registered HybridObjects: [" +
+        allObjectNames + "]";
     throw std::runtime_error(message);
   }
 #endif
@@ -57,16 +66,20 @@ std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(const std
   auto& map = HybridObjectRegistry::getRegistry();
   auto fn = map.find(hybridObjectName);
   if (fn == map.end()) [[unlikely]] {
-    auto message = "Cannot create an instance of HybridObject \"" + std::string(hybridObjectName) +
-                   "\" - It has not yet been registered in the Nitro Modules HybridObjectRegistry! Suggestions:\n"
-                   "- If you use Nitrogen, make sure your `nitro.json` contains `" +
-                   std::string(hybridObjectName) +
-                   "` on this platform.\n"
-                   "- If you use Nitrogen, make sure your library (*Package.java)/app (MainApplication.java) calls "
-                   "`System.loadLibrary(\"$$androidCxxLibName$$\")` somewhere on app-startup.\n"
-                   "- If you use Nitrogen, make sure your cpp-adapter.cpp calls `margelo::nitro::$$cxxNamespace$$::initialize(vm)`.\n"
-                   "- If you use Nitrogen, inspect the generated `$$androidCxxLibName$$OnLoad.cpp` file.\n"
-                   "- If you don't use Nitrogen, make sure you called `HybridObjectRegistry.registerHybridObject(...)`.";
+    auto allObjectNames = getAllRegisteredHybridObjectNamesToString();
+    auto message =
+        "Cannot create an instance of HybridObject \"" + hybridObjectName +
+        "\" - It has not yet been registered in the Nitro Modules HybridObjectRegistry! Suggestions:\n"
+        "- If you use Nitrogen, make sure your `nitro.json` contains `" +
+        hybridObjectName +
+        "` on this platform.\n"
+        "- If you use Nitrogen, make sure your library (*Package.java)/app (MainApplication.java) calls "
+        "`$$androidCxxLibName$$OnLoad.initializeNative()` somewhere on app-startup.\n"
+        "- If you use Nitrogen, make sure your `cpp-adapter.cpp`/`OnLoad.cpp` calls `margelo::nitro::$$cxxNamespace$$::initialize(vm)`.\n"
+        "- If you use Nitrogen, inspect the generated `$$androidCxxLibName$$OnLoad.cpp` file.\n"
+        "- If you don't use Nitrogen, make sure you called `HybridObjectRegistry.registerHybridObject(...)`."
+        "- All registered HybridObjects: [" +
+        allObjectNames + "]";
     throw std::runtime_error(message);
   }
   std::shared_ptr<HybridObject> instance = fn->second();

package/cpp/registry/HybridObjectRegistry.hpp

@@ -44,6 +44,7 @@ public:
 
 private:
   static std::unordered_map<std::string, HybridObjectConstructorFn>& getRegistry();
+  static std::string getAllRegisteredHybridObjectNamesToString();
 
 private:
   static constexpr auto TAG = "HybridObjectRegistry";

package/cpp/utils/AssertPromiseState.hpp

@@ -12,8 +12,8 @@ template <typename TResult>
 class Promise;
 } // namespace margelo::nitro
 
+#include "NitroTypeInfo.hpp"
 #include "Promise.hpp"
-#include "TypeInfo.hpp"
 #include <exception>
 #include <string>
 

package/cpp/utils/BorrowingReference.hpp

@@ -32,8 +32,10 @@ public:
   BorrowingReference(const BorrowingReference& ref)
       : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
         _mutex(ref._mutex) {
-    // increment ref count after copy
-    (*_weakRefCount)++;
+    if (_weakRefCount != nullptr) {
+      // increment ref count after copy
+      (*_weakRefCount)++;
+    }
   }
 
   BorrowingReference(BorrowingReference&& ref)