react-native-nitro-modules 0.2.0 → 0.4.0

package/README.md

@@ -153,6 +153,10 @@ The following C++ / JS types are supported out of the box:
     <td><code>Promise&lt;T&gt;</code></td>
     <td><code>std::future&lt;T&gt;</code></td>
   </tr>
+  <tr>
+    <td><code>(TArgs...) =&gt; void</code></td>
+    <td><code>std::function&lt;void (TArgs...)&gt;</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>
@@ -174,7 +178,7 @@ The following C++ / JS types are supported out of the box:
 
 Since the `JSIConverter<T>` is just a template, you can extend it with any other custom types by overloading the interface.
 
-For example, to add support for an enum, overload `JSIConverter<YourEnum>`:
+For example, to add support for an enum, overload `JSIConverter<MyEnum>`:
 
 ```cpp
 #include <NitroModules/JSIConverter.hpp>
@@ -199,7 +203,9 @@ namespace margelo::nitro {
 }
 ```
 
-..and on the JS side, you can implicitly cast the `number` to an enum as well:
+Once the `JSIConverter<T>` for `MyEnum` is defined, you can use the type `MyEnum` in C++ methods, getters and setters of `HybridObject`s.
+
+And on the JS side, you can simply treat the returned `number` (int) as a `MyEnum`:
 
 ```js
 enum MyEnum {

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/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/HybridObject.cpp

@@ -3,7 +3,6 @@
 //
 
 #include "HybridObject.hpp"
-#include "HybridContext.hpp"
 #include "JSIConverter.hpp"
 #include "NitroLogger.hpp"
 

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,9 +15,23 @@ std::unordered_map<std::string, HybridObjectRegistry::HybridObjectConstructorFn>
   return _constructorsMap;
 }
 
-void HybridObjectRegistry::registerHybridObjectConstructor(std::string hybridObjectName, HybridObjectConstructorFn&& constructorFn) {
+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();
+#if DEBUG
   if (map.contains(hybridObjectName)) [[unlikely]] {
     auto message =
         "HybridObject \"" + std::string(hybridObjectName) +
@@ -27,11 +41,12 @@ void HybridObjectRegistry::registerHybridObjectConstructor(std::string hybridObj
         "- If you just registered your own HybridObject, maybe you accidentally called `registerHybridObjectConstructor(...)` twice?";
     throw std::runtime_error(message);
   }
+#endif
   map.insert({hybridObjectName, std::move(constructorFn)});
   Logger::log(TAG, "Successfully registered HybridObject \"%s\"!", hybridObjectName);
 }
 
-std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(std::string hybridObjectName) {
+std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(const std::string& hybridObjectName) {
   auto& map = HybridObjectRegistry::getRegistry();
   auto fn = map.find(hybridObjectName);
   if (fn == map.end()) [[unlikely]] {
@@ -43,6 +58,11 @@ std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(std::stri
   std::shared_ptr<HybridObject> instance = fn->second();
 
 #if DEBUG
+  if (instance == nullptr) [[unlikely]] {
+    throw std::runtime_error("Failed to create HybridObject \"" + hybridObjectName +
+                             "\" - "
+                             "The constructor returned a nullptr!");
+  }
   if (instance->getName() != hybridObjectName) [[unlikely]] {
     throw std::runtime_error("HybridObject's name (\"" + instance->getName() +
                              "\") does not match"

package/cpp/registry/HybridObjectRegistry.hpp

@@ -15,7 +15,7 @@ namespace margelo::nitro {
 
 /**
  * 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)`.
  */
 class HybridObjectRegistry {
 public:
@@ -28,11 +28,13 @@ public:
   /**
    * 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.
    */
-  static void registerHybridObjectConstructor(std::string hybridObjectName, HybridObjectConstructorFn&& constructorFn);
+  static void registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn);
 
-  static std::shared_ptr<HybridObject> createHybridObject(std::string hybridObjectName);
+  static std::shared_ptr<HybridObject> createHybridObject(const std::string& hybridObjectName);
+  static bool hasHybridObject(const std::string& hybridObjectName);
+  static std::vector<std::string> getAllHybridObjectNames();
 
 private:
   static std::unordered_map<std::string, HybridObjectConstructorFn>& getRegistry();

package/cpp/turbomodule/NativeNitroModules.cpp

@@ -32,12 +32,14 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   }
   if (name == "createHybridObject") {
     return jsi::Function::createFromHostFunction(
-        runtime, jsi::PropNameID::forUtf8(runtime, "install"), 2,
+        runtime, jsi::PropNameID::forUtf8(runtime, "createHybridObject"), 2,
         [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-          if (count != 1 && count != 2) {
+#if DEBUG
+          if (count != 1 && count != 2) [[unlikely]] {
             throw jsi::JSError(runtime, "NitroModules.createHybridObject(..) expects 1 or 2 arguments, but " + std::to_string(count) +
                                             " were supplied!");
           }
+#endif
           jsi::String objectName = args[0].asString(runtime);
           std::optional<jsi::Object> optionalArgs = std::nullopt;
           if (count > 1) {
@@ -47,6 +49,25 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
           return createHybridObject(runtime, objectName, optionalArgs);
         });
   }
+  if (name == "hasHybridObject") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "hasHybridObject"), 1,
+        [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+#if DEBUG
+          if (count != 1) [[unlikely]] {
+            throw jsi::JSError(runtime,
+                               "NitroModules.hasHybridObject(..) expects 1 argument (name), but received " + std::to_string(count) + "!");
+          }
+#endif
+          jsi::String objectName = args[0].asString(runtime);
+          return hasHybridObject(runtime, objectName);
+        });
+  }
+  if (name == "getAllHybridObjectNames") {
+    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "getAllHybridObjectNames"), 0,
+                                                 [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args,
+                                                     size_t count) -> jsi::Value { return getAllHybridObjectNames(runtime); });
+  }
 
   return jsi::Value::undefined();
 }
@@ -66,4 +87,19 @@ jsi::Value NativeNitroModules::createHybridObject(jsi::Runtime& runtime, const j
   return hybridObject->toObject(runtime);
 }
 
+jsi::Value NativeNitroModules::hasHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName) {
+  std::string name = hybridObjectName.utf8(runtime);
+  bool exists = HybridObjectRegistry::hasHybridObject(name);
+  return exists;
+}
+
+jsi::Value NativeNitroModules::getAllHybridObjectNames(jsi::Runtime& runtime) {
+  std::vector<std::string> keys = HybridObjectRegistry::getAllHybridObjectNames();
+  jsi::Array array(runtime, keys.size());
+  for (size_t i = 0; i < keys.size(); i++) {
+    array.setValueAtIndex(runtime, i, jsi::String::createFromUtf8(runtime, keys[i]));
+  }
+  return array;
+}
+
 } // namespace facebook::react

package/cpp/turbomodule/NativeNitroModules.hpp

@@ -24,6 +24,8 @@ public:
 
   void install(jsi::Runtime& runtime);
   jsi::Value createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName, const std::optional<jsi::Object>& args);
+  jsi::Value hasHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName);
+  jsi::Value getAllHybridObjectNames(jsi::Runtime& runtime);
 
 public:
   constexpr static auto kModuleName = "NitroModulesCxx";

package/cpp/utils/NitroDefines.hpp

@@ -18,8 +18,14 @@
 #if _CXX_INTEROP_HAS_ATTRIBUTE(swift_attr)
 // Rename Type for Swift
 #define SWIFT_NAME(_name) __attribute__((swift_name(#_name)))
+// Make Swift type private
+#define SWIFT_PRIVATE __attribute__((swift_private))
+// Make getter + setter a computed property
+#define SWIFT_COMPUTED_PROPERTY __attribute__((swift_attr("import_computed_property")))
 #else
 #define SWIFT_NAME(_name)
+#define SWIFT_PRIVATE
+#define SWIFT_COMPUTED_PROPERTY
 #endif
 
 #if _CXX_INTEROP_HAS_ATTRIBUTE(enum_extensibility)

package/ios/core/Promise.cpp

@@ -0,0 +1,10 @@
+//
+//  Promise.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 11.08.24.
+//
+
+#include "Promise.hpp"
+
+namespace margelo::nitro {} // namespace margelo::nitro

package/ios/core/Promise.hpp

@@ -0,0 +1,43 @@
+//
+//  Promise.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 11.08.24.
+//
+
+#pragma once
+
+#include <future>
+#include <memory>
+#include <string>
+
+namespace margelo::nitro {
+
+class Promise {
+public:
+  Promise(const Promise&) = delete;
+  Promise(Promise&&) = delete;
+
+public:
+  void reject(const std::string& message) {
+    // TODO: reject()
+  }
+
+  void resolve(int result) {
+    // TODO: resolve()
+  }
+
+private:
+  explicit Promise() {
+    // TODO: Init? From Future?
+  }
+
+public:
+  static std::shared_ptr<Promise> run(void (*run)(std::shared_ptr<Promise> promise)) {
+    auto promise = std::shared_ptr<Promise>(new Promise());
+    run(promise);
+    return promise;
+  }
+};
+
+} // namespace margelo::nitro

package/ios/platform/ThreadUtils.cpp

@@ -7,6 +7,7 @@
 
 #include "ThreadUtils.hpp"
 #include <pthread.h>
+#include <sstream>>
 #include <thread>
 
 namespace margelo::nitro {

package/lib/HybridObject.d.ts

@@ -1,19 +1,25 @@
 /**
  * Describes the languages this component will be implemented in.
+ *
+ * By default, everything has a C++ base, and can optionally be bridged down
+ * to platform-specific languages like Swift or Kotlin
  */
 export interface PlatformSpec {
     ios?: 'swift' | 'c++';
     android?: 'kotlin' | 'c++';
 }
 /**
- * Represents a Nitro `HybridObject` which is implemented natively in either C++,
- * or Swift/Kotlin.
+ * Represents a Nitro `HybridObject` which is implemented in a native language like
+ * C++, Swift or Kotlin.
+ * Every Nitro `HybridObject` has a C++ base, and can optionally be bridged down to Swift or Kotlin.
  *
  * `HybridObject`s use the Nitro Tunnel for efficient, low-overhead JS <-> Native communication.
  *
  * All `HybridObject`s are implemented using `NativeState`, and inherit their properties
  * and methods from their prototype, so the actual JS object is empty.
  *
+ * @type Platforms: The type of platforms this HybridObject will be implemented in. By default, it is
+ * a C++ `HybridObject`.
  * @example
  * ```ts
  * interface Photo extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {
@@ -24,7 +30,7 @@ export interface PlatformSpec {
  * }
  * ```
  */
-export interface HybridObject<Spec extends PlatformSpec> {
+export interface HybridObject<Platforms extends PlatformSpec = {}> {
     /**
      * Holds a type-name describing the native `HybridObject` instance.
      *
@@ -33,8 +39,8 @@ export interface HybridObject<Spec extends PlatformSpec> {
      *
      * Nitro prototypes also have a `__type`.
      *
-     * For actual HybridObject instances, this is `NativeState<...>`, for
-     * prototypes this is `Prototype<...>`.
+     * - For actual HybridObject instances, this is `NativeState<...>`
+     * - For prototypes this is `Prototype<...>`.
      *
      * @internal
      * @private
@@ -48,7 +54,7 @@ export interface HybridObject<Spec extends PlatformSpec> {
     /**
      * Returns a string representation of the given `HybridObject`.
      *
-     * Unless overridden by the `HybridObject`, this will return a list of all properties.
+     * Unless overridden by the `HybridObject`, this will return the name of the object.
      *
      * @example
      * ```ts
@@ -72,5 +78,5 @@ export interface HybridObject<Spec extends PlatformSpec> {
      * console.log(hybridA.equals(hybridB)) // true
      * ```
      */
-    equals(other: HybridObject<Spec>): boolean;
+    equals(other: HybridObject<Platforms>): boolean;
 }

package/lib/NativeNitroModules.d.ts

@@ -3,6 +3,8 @@ import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
 export interface Spec extends TurboModule {
     install(): void;
     createHybridObject(name: string, args?: UnsafeObject): UnsafeObject;
+    hasHybridObject(name: string): boolean;
+    getAllHybridObjectNames(): string[];
 }
 export declare function getNativeNitroModules(): Spec;
 declare global {

package/lib/NitroModules.d.ts

@@ -13,5 +13,13 @@ export declare const NitroModules: {
      * @returns An instance of {@linkcode T}
      * @throws an Error if {@linkcode T} has not been registered under the name {@linkcode name}.
      */
-    get<T extends HybridObject<any>>(name: string): T;
+    createHybridObject<T extends HybridObject<any>>(name: string): T;
+    /**
+     * Get a list of all registered Hybrid Objects.
+     */
+    getAllHybridObjectNames(): string[];
+    /**
+     * Returns whether a HybridObject under the given {@linkcode name} is registered, or not.
+     */
+    hasHybridObject(name: string): boolean;
 };

package/lib/NitroModules.js

@@ -13,9 +13,23 @@ export const NitroModules = {
      * @returns An instance of {@linkcode T}
      * @throws an Error if {@linkcode T} has not been registered under the name {@linkcode name}.
      */
-    get(name) {
+    createHybridObject(name) {
         const nitro = getNativeNitroModules();
         const instance = nitro.createHybridObject(name);
         return instance;
     },
+    /**
+     * Get a list of all registered Hybrid Objects.
+     */
+    getAllHybridObjectNames() {
+        const nitro = getNativeNitroModules();
+        return nitro.getAllHybridObjectNames();
+    },
+    /**
+     * Returns whether a HybridObject under the given {@linkcode name} is registered, or not.
+     */
+    hasHybridObject(name) {
+        const nitro = getNativeNitroModules();
+        return nitro.hasHybridObject(name);
+    },
 };