react-native-nitro-modules 0.3.0 → 0.4.1

package/NitroModules.podspec

@@ -37,7 +37,8 @@ Pod::Spec.new do |s|
     "cpp/utils/NitroHash.hpp",
     "cpp/utils/NitroDefines.hpp",
     # Public iOS-specific headers that will be exposed in modulemap (for Swift)
-    "ios/core/HybridContext.hpp"
+    "ios/core/ArrayBufferHolder.hpp",
+    "ios/core/HybridContext.hpp",
   ]
 
   s.pod_target_xcconfig = {

package/README.md

@@ -111,67 +111,98 @@ The following C++ / JS types are supported out of the box:
   <tr>
     <th>JS Type</th>
     <th>C++ Type</th>
+    <th>Swift Type</th>
   </tr>
 
   <tr>
     <td><code>number</code></td>
     <td><code>double</code> / <code>int</code> / <code>float</code></td>
+    <td><code>Double</code> / <code>Int</code> / <code>Float</code></td>
   </tr>
   <tr>
     <td><code>boolean</code></td>
     <td><code>bool</code></td>
+    <td><code>Bool</code></td>
   </tr>
   <tr>
     <td><code>string</code></td>
     <td><code>std::string</code></td>
+    <td><code>String</code></td>
   </tr>
   <tr>
     <td><code>bigint</code></td>
     <td><code>int64_t</code> / <code>uint64_t</code></td>
+    <td><code>Int64</code> / <code>UInt64</code></td>
   </tr>
   <tr>
     <td><code>T[]</code></td>
     <td><code>std::vector&lt;T&gt;</code></td>
+    <td><code>[T]</code></td>
   </tr>
   <tr>
     <td><code>[A, B, C, ...]</code></td>
     <td><code>std::tuple&lt;A, B, C, ...&gt;</code></td>
+    <td><code>(A, B, C)</code></td>
   </tr>
   <tr>
     <td><code>A | B | C | ...</code></td>
     <td><code>std::variant&lt;A, B, C, ...&gt;</code></td>
+    <td><code>Variant_A_B_C</code></td>
   </tr>
   <tr>
     <td><code>Record&lt;string, T&gt;</code></td>
     <td><code>std::unordered_map&lt;std::string, T&gt;</code></td>
+    <td><code>Dictionary&lt;String, T&gt;</code></td>
   </tr>
   <tr>
     <td><code>T?</code></td>
     <td><code>std::optional&lt;T&gt;</code></td>
+    <td><code>T?</code></td>
   </tr>
   <tr>
     <td><code>Promise&lt;T&gt;</code></td>
     <td><code>std::future&lt;T&gt;</code></td>
+    <td>❌</td>
   </tr>
   <tr>
     <td><code>(TArgs...) =&gt; void</code></td>
     <td><code>std::function&lt;void (TArgs...)&gt;</code></td>
+    <td><code>@escaping (TArgs...) -&gt; Void</code></td>
   </tr>
   <tr>
     <td><code>(TArgs...) =&gt; TReturn</code></td>
     <td><code>std::function&lt;std::future&lt;TReturn&gt; (TArgs...)&gt;</code></td>
+    <td>❌</td>
   </tr>
   <tr>
     <td><code>{ ... }</code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/AnyMap.hpp">AnyMap</a>&gt;</code></td>
+    <td>❌</td>
   </tr>
   <tr>
     <td><code>ArrayBuffer</code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/ArrayBuffer.hpp">ArrayBuffer</a>&gt;</code></td>
+    <td><code><a href="./ios/core/ArrayBufferHolder.hpp">ArrayBufferHolder</a></code></td>
   </tr>
   <tr>
     <td><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>
+  </tr>
+  <tr>
+    <td>..any <code>interface</code></td>
+    <td><code>T</code></td>
+    <td><code>T</code></td>
+  </tr>
+  <tr>
+    <td>..any <code>enum</code></td>
+    <td><code>T</code></td>
+    <td><code>T</code></td>
+  </tr>
+  <tr>
+    <td>..any <code>union</code></td>
+    <td><code>T</code></td>
+    <td><code>T</code></td>
   </tr>
 </table>
 

package/android/CMakeLists.txt

@@ -5,11 +5,11 @@ set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 20)
 
 # Find all C++ files (shared and platform specifics)
-file(GLOB shared_files
-     "../cpp/**/*.cpp"
+file(GLOB_RECURSE shared_files RELATIVE ${CMAKE_SOURCE_DIR}
+     "../cpp/**.cpp"
 )
-file(GLOB android_files
-     "src/main/cpp/**/*.cpp"
+file(GLOB_RECURSE android_files RELATIVE ${CMAKE_SOURCE_DIR}
+     "src/main/cpp/**.cpp"
 )
 
 # Create library "NitroModules" and add all C++ files to it

package/android/gradle.properties

@@ -2,4 +2,4 @@ Nitro_kotlinVersion=1.7.0
 Nitro_minSdkVersion=21
 Nitro_targetSdkVersion=31
 Nitro_compileSdkVersion=31
-Nitro_ndkversion=21.4.7075529
+Nitro_ndkVersion=21.4.7075529

package/android/src/main/cpp/JNIOnLoad.cpp

@@ -2,16 +2,17 @@
 
 #include "JHybridObjectRegistry.hpp"
 #include "RegisterNativeNitroModules.hpp"
+#include <fbjni/fbjni.h>
 #include <jni.h>
 
 using namespace margelo::nitro;
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-  // 1. Initialize the Nitro JSI Turbo Module
-  RegisterNativeNitroModules::registerNativeNitroModules();
+  return facebook::jni::initialize(vm, [] {
+    // 1. Initialize the Nitro JSI Turbo Module
+    RegisterNativeNitroModules::registerNativeNitroModules();
 
-  // 2. Initialize all Java bindings
-  JHybridObjectRegistry::registerNatives();
-
-  return JNI_VERSION_1_2;
+    // 2. Initialize all Java bindings
+    JHybridObjectRegistry::registerNatives();
+  });
 }

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

@@ -1,6 +1,5 @@
 package com.margelo.nitro
 
-import android.util.Log
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
@@ -47,15 +46,5 @@ abstract class HybridObject {
 
     companion object {
         private const val TAG = "HybridObject"
-        init {
-            try {
-                Log.i(TAG, "Loading NitroModules C++ library...")
-                System.loadLibrary("NitroModules")
-                Log.i(TAG, "Successfully loaded NitroModules C++ library!")
-            } catch (e: Error) {
-                Log.e(TAG, "Failed to load NitroModules C++ library! Is it properly installed and linked?", e)
-                throw e
-            }
-        }
     }
 }

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

@@ -1,30 +1,19 @@
 package com.margelo.nitro;
 
-import android.util.Log;
-
 import java.util.function.Supplier;
 
 /**
  * A registry that holds initializers for HybridObjects.
- * This will be used to initialize them from JS using `NitroModules.get<T>(name)`.
+ * This will be used to initialize them from JS using `NitroModules.createHybridObject<T>(name)`.
  * @noinspection JavaJniMissingFunction
  */
 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.get<T>(name)` - which will call the `constructorFn` here.
+     * JS using `NitroModules.createHybridObject<T>(name)` - which will call the `constructorFn` here.
      */
     public static native void registerHybridObjectConstructor(String hybridObjectName, HybridObjectInitializer initializer);
 
     private static final String TAG = "HybridObjectRegistry";
-    static {
-        Log.i(TAG, "Loading native NitroModules C++ library...");
-        try {
-            System.loadLibrary("NitroModules");
-            Log.i(TAG, "Successfully loaded native NitroModules C++ library!");
-        } catch (Throwable e) {
-            Log.e(TAG, "Failed to load native NitroModules C++ library!", e);
-        }
-    }
 }

package/android/src/main/java/com/margelo/nitro/NitroModulesPackage.java

@@ -1,5 +1,6 @@
 package com.margelo.nitro;
 
+import android.util.Log;
 import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.NativeModule;
@@ -10,6 +11,17 @@ import com.facebook.react.TurboReactPackage;
 import java.util.HashMap;
 
 public class NitroModulesPackage extends TurboReactPackage {
+  private static final String TAG = "NitroModules";
+  static {
+    try {
+      Log.i(TAG, "Loading NitroModules C++ library...");
+      System.loadLibrary("NitroModules");
+      Log.i(TAG, "Successfully loaded NitroModules C++ library!");
+    } catch (Throwable e) {
+      Log.e(TAG, "Failed to load NitroModules C++ library! Is it properly installed and linked?", e);
+      throw e;
+    }
+  }
 
   @Nullable
   @Override

package/cpp/core/AnyMap.hpp

@@ -40,6 +40,12 @@ public:
    * Create a new instance of AnyMap.
    */
   explicit AnyMap() {}
+  /**
+   * Create a new instance of AnyMap with the given amount of spaces pre-allocated.
+   */
+  explicit AnyMap(size_t size) {
+    _map.reserve(size);
+  }
 
 public:
   /**
@@ -48,6 +54,12 @@ public:
   static std::shared_ptr<AnyMap> make() {
     return std::make_shared<AnyMap>();
   }
+  /**
+   * Create a new shared_ptr instance of AnyMap with the given amount of spaces pre-allocated.
+   */
+  static std::shared_ptr<AnyMap> make(size_t size) {
+    return std::make_shared<AnyMap>(size);
+  }
 
 public:
   /**

package/cpp/core/ArrayBuffer.cpp

@@ -0,0 +1,88 @@
+//
+//  ArrayBuffer.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ArrayBuffer.hpp"
+#include "OwningReference.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <thread>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// 1. ArrayBuffer
+
+std::shared_ptr<ArrayBuffer> ArrayBuffer::makeBuffer(uint8_t* data, size_t size, DeleteFn deleteFunc, void* deleteFuncContext) {
+  return std::make_shared<NativeArrayBuffer>(data, size, deleteFunc, deleteFuncContext);
+}
+
+// 2. NativeArrayBuffer
+
+NativeArrayBuffer::NativeArrayBuffer(uint8_t* data, size_t size, DeleteFn deleteFunc, void* deleteFuncContext)
+    : ArrayBuffer(), _data(data), _size(size), _deleteFunc(deleteFunc), _deleteFuncContext(deleteFuncContext) {}
+
+NativeArrayBuffer::~NativeArrayBuffer() {
+  if (_deleteFunc != nullptr) {
+    _deleteFunc(_deleteFuncContext);
+  }
+}
+
+uint8_t* NativeArrayBuffer::data() {
+  return _data;
+}
+
+size_t NativeArrayBuffer::size() const {
+  return _size;
+}
+
+bool NativeArrayBuffer::isOwner() const noexcept {
+  return _deleteFunc != nullptr;
+}
+
+// 3. JSArrayBuffer
+
+JSArrayBuffer::JSArrayBuffer(jsi::Runtime* runtime, OwningReference<jsi::ArrayBuffer> jsReference)
+    : ArrayBuffer(), _runtime(runtime), _jsReference(jsReference), _initialThreadId(std::this_thread::get_id()) {}
+
+JSArrayBuffer::~JSArrayBuffer() {}
+
+uint8_t* JSArrayBuffer::data() {
+  if (_initialThreadId != std::this_thread::get_id()) [[unlikely]] {
+    throw std::runtime_error("`data()` can only be accessed synchronously on the JS Thread! "
+                             "If you want to access it elsewhere, copy it first.");
+  }
+
+  OwningLock<jsi::ArrayBuffer> lock = _jsReference.lock();
+  if (!_jsReference) [[unlikely]] {
+    // JS Part has been deleted - data is now nullptr.
+    return nullptr;
+  }
+  // JS Part is still alive - we can assume that the jsi::Runtime is safe to access here too.
+  return _jsReference->data(*_runtime);
+}
+
+size_t JSArrayBuffer::size() const {
+  if (_initialThreadId != std::this_thread::get_id()) [[unlikely]] {
+    throw std::runtime_error("`size()` can only be accessed synchronously on the JS Thread! "
+                             "If you want to access it elsewhere, copy it first.");
+  }
+
+  OwningLock<jsi::ArrayBuffer> lock = _jsReference.lock();
+  if (!_jsReference) [[unlikely]] {
+    // JS Part has been deleted - size is now 0.
+    return 0;
+  }
+  // JS Part is still alive - we can assume that the jsi::Runtime is safe to access here too.
+  return _jsReference->size(*_runtime);
+}
+
+bool JSArrayBuffer::isOwner() const noexcept {
+  return false;
+}
+
+} // namespace margelo::nitro

package/cpp/core/ArrayBuffer.hpp

@@ -8,7 +8,6 @@
 #pragma once
 
 #include "OwningReference.hpp"
-#include <functional>
 #include <jsi/jsi.h>
 #include <thread>
 
@@ -16,9 +15,7 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-using DeleteFn = std::function<void(uint8_t*)>;
-
-static DeleteFn defaultDeleteFn = [](uint8_t* buffer) { delete[] buffer; };
+using DeleteFn = void (*)(void* context);
 
 /**
  * Represents a raw byte buffer that can be read from-, and
@@ -36,12 +33,6 @@ static DeleteFn defaultDeleteFn = [](uint8_t* buffer) { delete[] buffer; };
  *   When this `ArrayBuffer` gets deleted, the memory will not be freed explicitly, as someone else owns it.
  */
 class ArrayBuffer : public jsi::MutableBuffer {
-public:
-  ArrayBuffer() = default;
-  ArrayBuffer(const ArrayBuffer&) = delete;
-  ArrayBuffer(ArrayBuffer&&) = delete;
-  virtual ~ArrayBuffer() = default;
-
 public:
   /**
    * Returns whether this `ArrayBuffer` is actually owning the data,
@@ -49,6 +40,12 @@ public:
    * memory that we didn't allocate, or from JS - which can be deleted at any point).
    */
   virtual bool isOwner() const noexcept = 0;
+
+  /**
+   * Create a new `NativeArrayBuffer` that wraps the given data (without copy) of the given size,
+   * and calls `deleteFunc` with the given `deleteFuncContext` as a parameter in which `data` should be deleted.
+   */
+  static std::shared_ptr<ArrayBuffer> makeBuffer(uint8_t* data, size_t size, DeleteFn deleteFunc, void* deleteFuncContext);
 };
 
 /**
@@ -62,46 +59,31 @@ public:
  *
  * It is safe to access `data()` and `size()` from any Thread, but there are no synchronization/mutexes implemented by default.
  */
-class NativeArrayBuffer : public ArrayBuffer {
+class NativeArrayBuffer final : public ArrayBuffer {
 public:
   /**
    * Create a new **owning** `ArrayBuffer`.
    * The `ArrayBuffer` can be kept in memory, as C++ owns the data
-   * and will only delete it once this `ArrayBuffer` gets deleted
-   */
-  NativeArrayBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc)
-      : ArrayBuffer(), _data(data), _size(size), _deleteFunc(std::move(deleteFunc)) {}
-  /**
-   * Create a new `ArrayBuffer`.
-   * If `destroyOnDeletion` is `true`, the `ArrayBuffer` is **owning**, otherwise it is **non-owning**.
-   * The `ArrayBuffer` can only be safely kept in memory if it is owning (`isOwning()`).
+   * and will only delete it once this `ArrayBuffer` gets deleted.
+   *
+   * Once this `ArrayBuffer` goes out of scope, `deleteFunc` will be called.
+   * The caller is responsible for deleting the memory (`data` and `deleteFuncContext`) here.
    */
-  NativeArrayBuffer(uint8_t* data, size_t size, bool destroyOnDeletion) : ArrayBuffer(), _data(data), _size(size) {
-    _deleteFunc = destroyOnDeletion ? defaultDeleteFn : nullptr;
-  }
-
-  ~NativeArrayBuffer() {
-    if (_deleteFunc != nullptr) {
-      _deleteFunc(_data);
-    }
-  }
+  NativeArrayBuffer(uint8_t* data, size_t size, DeleteFn deleteFunc, void* deleteFuncContext);
+  ~NativeArrayBuffer();
 
-  uint8_t* data() override {
-    return _data;
-  }
-
-  size_t size() const override {
-    return _size;
-  }
+public:
+  uint8_t* data() override;
+  size_t size() const override;
+  bool isOwner() const noexcept override;
 
-  bool isOwner() const noexcept override {
-    return _deleteFunc != nullptr;
-  }
+  double something();
 
 private:
   uint8_t* _data;
   size_t _size;
   DeleteFn _deleteFunc;
+  void* _deleteFuncContext;
 };
 
 /**
@@ -115,52 +97,24 @@ private:
  *
  * If the JS ArrayBuffer (or it's JS Runtime) have already been deleted, `data()` returns `nullptr`.
  */
-class JSArrayBuffer : public ArrayBuffer {
+class JSArrayBuffer final : public ArrayBuffer {
 public:
-  explicit JSArrayBuffer(jsi::Runtime* runtime, OwningReference<jsi::ArrayBuffer> jsReference)
-      : ArrayBuffer(), _runtime(runtime), _jsReference(jsReference), _initialThreadId(std::this_thread::get_id()) {}
-  ~JSArrayBuffer() {}
+  explicit JSArrayBuffer(jsi::Runtime* runtime, OwningReference<jsi::ArrayBuffer> jsReference);
+  ~JSArrayBuffer();
 
 public:
   /**
    * Gets the data this `ArrayBuffer` points to, or `nullptr` if it has already been deleted.
    */
-  uint8_t* data() override {
-    if (_initialThreadId != std::this_thread::get_id()) [[unlikely]] {
-      throw std::runtime_error("`data()` can only be accessed synchronously on the JS Thread! "
-                               "If you want to access it elsewhere, copy it first.");
-    }
-
-    OwningLock<jsi::ArrayBuffer> lock = _jsReference.lock();
-    if (!_jsReference) [[unlikely]] {
-      // JS Part has been deleted - data is now nullptr.
-      return nullptr;
-    }
-    // JS Part is still alive - we can assume that the jsi::Runtime is safe to access here too.
-    return _jsReference->data(*_runtime);
-  }
-
+  uint8_t* data() override;
   /**
    * Gets the size of the data this `ArrayBuffer` points to, or `0` if it has already been deleted.
    */
-  size_t size() const override {
-    if (_initialThreadId != std::this_thread::get_id()) [[unlikely]] {
-      throw std::runtime_error("`size()` can only be accessed synchronously on the JS Thread! "
-                               "If you want to access it elsewhere, copy it first.");
-    }
-
-    OwningLock<jsi::ArrayBuffer> lock = _jsReference.lock();
-    if (!_jsReference) [[unlikely]] {
-      // JS Part has been deleted - size is now 0.
-      return 0;
-    }
-    // JS Part is still alive - we can assume that the jsi::Runtime is safe to access here too.
-    return _jsReference->size(*_runtime);
-  }
-
-  bool isOwner() const noexcept override {
-    return false;
-  }
+  size_t size() const override;
+  /**
+   * Returns `false` for JS-based ArrayBuffers.
+   */
+  bool isOwner() const noexcept override;
 
 private:
   jsi::Runtime* _runtime;

package/cpp/jsi/JSICache.cpp

@@ -8,8 +8,6 @@
 #include "JSICache.hpp"
 #include "JSIHelpers.hpp"
 
-#define DOUBLE_CHECK_GLOBAL_CACHE 1
-
 namespace margelo::nitro {
 
 static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
@@ -48,7 +46,7 @@ JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
     Logger::log(TAG, "JSICache was created, but it is no longer strong!");
   }
 
-#if DOUBLE_CHECK_GLOBAL_CACHE
+#if DEBUG
   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 + "\")");
   }

package/cpp/jsi/JSIConverter+Promise.hpp

@@ -16,7 +16,7 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 
 #include "Dispatcher.hpp"
-#include "Promise.hpp"
+#include "JSPromise.hpp"
 #include "ThreadPool.hpp"
 #include "TypeInfo.hpp"
 #include <future>
@@ -38,7 +38,7 @@ struct JSIConverter<std::future<TResult>> {
     std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
     std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
 
-    return Promise::createPromise(runtime, [sharedFuture, weakDispatcher](jsi::Runtime& runtime, std::shared_ptr<Promise> promise) {
+    return JSPromise::createPromise(runtime, [sharedFuture, weakDispatcher](jsi::Runtime& runtime, std::shared_ptr<JSPromise> promise) {
       // Spawn new async thread to synchronously wait for the `future<T>` to complete
       std::shared_ptr<ThreadPool> pool = ThreadPool::getSharedPool();
       pool->run([promise, &runtime, weakDispatcher, sharedFuture]() {

package/cpp/jsi/{Promise.cpp → JSPromise.cpp}

@@ -1,4 +1,4 @@
-#include "Promise.hpp"
+#include "JSPromise.hpp"
 #include "JSICache.hpp"
 #include "NitroLogger.hpp"
 #include <jsi/jsi.h>
@@ -7,13 +7,13 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-Promise::Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter) {
+JSPromise::JSPromise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter) {
   auto functionCache = JSICache::getOrCreateCache(runtime);
   _resolver = functionCache.makeShared(std::move(resolver));
   _rejecter = functionCache.makeShared(std::move(rejecter));
 }
 
-jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
+jsi::Value JSPromise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
   // Get Promise ctor from global
   auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
 
@@ -24,7 +24,7 @@ jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
         auto resolver = arguments[0].getObject(runtime).getFunction(runtime);
         auto rejecter = arguments[1].getObject(runtime).getFunction(runtime);
         // Create `Promise` type that wraps the JSI callbacks
-        auto promise = std::make_shared<Promise>(runtime, std::move(resolver), std::move(rejecter));
+        auto promise = std::make_shared<JSPromise>(runtime, std::move(resolver), std::move(rejecter));
         // Call `run` callback
         run(runtime, promise);
 
@@ -34,7 +34,7 @@ jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
   return promiseCtor.callAsConstructor(runtime, promiseCallback);
 }
 
-void Promise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
+void JSPromise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
   OwningLock<jsi::Function> lock = _resolver.lock();
 
   if (!_resolver) {
@@ -44,7 +44,7 @@ void Promise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
   _resolver->call(runtime, std::move(result));
 }
 
-void Promise::reject(jsi::Runtime& runtime, std::string message) {
+void JSPromise::reject(jsi::Runtime& runtime, std::string message) {
   OwningLock<jsi::Function> lock = _rejecter.lock();
 
   if (!_rejecter) {

package/cpp/jsi/{Promise.hpp → JSPromise.hpp}

@@ -1,5 +1,5 @@
 //
-//  Promise.hpp
+//  JSPromise.hpp
 //  react-native-filament
 //
 //  Created by Marc Rousavy on 11.03.24.
@@ -17,14 +17,14 @@ namespace margelo::nitro {
 using namespace facebook;
 
 /**
- Represents a JS Promise.
-
- `Promise` is not thread-safe: It has to be resolved/rejected
- on the same thread and Runtime as it was created on.
+ * Represents a JS Promise.
+ *
+ * `JSPromise` is not thread-safe: It has to be resolved/rejected
+ * on the same thread and Runtime as it was created on.
  */
-class Promise final {
+class JSPromise final {
 public:
-  Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter);
+  JSPromise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter);
 
   /**
    Resolve the Promise with the given `jsi::Value`.
@@ -43,10 +43,10 @@ private:
   static constexpr auto TAG = "Promise";
 
 public:
-  using RunPromise = std::function<void(jsi::Runtime& runtime, std::shared_ptr<Promise> promise)>;
+  using RunPromise = std::function<void(jsi::Runtime& runtime, std::shared_ptr<JSPromise> promise)>;
   /**
-   Create a new Promise using the JS `Promise` constructor and runs the given `run` function.
-   The resulting Promise should be returned to JS so it can be awaited.
+   * Create a new Promise using the JS `Promise` constructor and runs the given `run` function.
+   * The resulting Promise should be returned to JS so it can be awaited.
    */
   static jsi::Value createPromise(jsi::Runtime& runtime, RunPromise&& run);
 };

package/cpp/registry/HybridObjectRegistry.cpp

@@ -15,6 +15,19 @@ std::unordered_map<std::string, HybridObjectRegistry::HybridObjectConstructorFn>
   return _constructorsMap;
 }
 
+bool HybridObjectRegistry::hasHybridObject(const std::string& name) {
+  return getRegistry().contains(name);
+}
+
+std::vector<std::string> HybridObjectRegistry::getAllHybridObjectNames() {
+  std::vector<std::string> keys;
+  keys.reserve(getRegistry().size());
+  for (const auto& entry : getRegistry()) {
+    keys.push_back(entry.first);
+  }
+  return keys;
+}
+
 void HybridObjectRegistry::registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn) {
   Logger::log(TAG, "Registering HybridObject \"%s\"...", hybridObjectName);
   auto& map = HybridObjectRegistry::getRegistry();