react-native-nitro-modules 0.1.7 → 0.2.0

package/cpp/jsi/JSICache.cpp

@@ -8,16 +8,16 @@
 #include "JSICache.hpp"
 #include "JSIHelpers.hpp"
 
+#define DOUBLE_CHECK_GLOBAL_CACHE 1
+
 namespace margelo::nitro {
 
 static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
 
-JSICache::~JSICache() {
-  Logger::log(TAG, "Destroying JSICache...");
-  std::unique_lock lock(_mutex);
-
-  for (auto& func : _cache) {
-    OwningReference<jsi::Object> owning = func.lock();
+template <typename T>
+inline void destroyReferences(const std::vector<BorrowingReference<T>>& references) {
+  for (auto& func : references) {
+    OwningReference<T> owning = func.lock();
     if (owning) {
       // Destroy all functions that we might still have in cache, some callbacks and Promises may now become invalid.
       owning.destroy();
@@ -25,9 +25,19 @@ JSICache::~JSICache() {
   }
 }
 
+JSICache::~JSICache() {
+  Logger::log(TAG, "Destroying JSICache...");
+  std::unique_lock lock(_mutex);
+
+  destroyReferences(_objectCache);
+  destroyReferences(_functionCache);
+  destroyReferences(_weakObjectCache);
+  destroyReferences(_arrayBufferCache);
+}
+
 JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
   auto found = _globalCache.find(&runtime);
-  if (found != _globalCache.end()) {
+  if (found != _globalCache.end()) [[likely]] {
     // Fast path: get weak_ptr to JSICache from our global list.
     std::weak_ptr<JSICache> weak = found->second;
     std::shared_ptr<JSICache> strong = weak.lock();
@@ -38,10 +48,16 @@ JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
     Logger::log(TAG, "JSICache was created, but it is no longer strong!");
   }
 
+#if DOUBLE_CHECK_GLOBAL_CACHE
+  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));
   // Create new cache
-  auto nativeState = std::make_shared<JSICache>(&runtime);
+  auto nativeState = std::shared_ptr<JSICache>(new JSICache(&runtime));
   // Wrap it in a jsi::Value using NativeState
   jsi::Object cache(runtime);
   cache.setNativeState(runtime, nativeState);

package/cpp/jsi/JSICache.hpp

@@ -23,19 +23,18 @@ using namespace facebook;
 class JSICacheReference;
 
 /**
- * A `JSICache` can safely store `jsi::Object` instances (e.g. `jsi::Object` or
+ * A `JSICache` can safely store `jsi::Value` instances (e.g. `jsi::Object` or
  * `jsi::Function`) inside `OwningReference<T>`.
  *
- * `jsi::Object`s are managed by a `jsi::Runtime`, and will be deleted if the `jsi::Runtime`
- * is deleted - even if there are still strong references to the `jsi::Object`.
+ * `jsi::Value`s are managed by a `jsi::Runtime`, and will be deleted if the `jsi::Runtime`
+ * is deleted - even if there are still strong references to the `jsi::Value`.
  *
- * To access a `OwningReference<jsi::Object>` safely, use `lock()` to get an `OwningLock<jsi::Object>`.
- * This will allow you to access the `jsi::Object` as long as the `OwningLock` is alive,
+ * To access a `OwningReference<jsi::Value>` safely, use `lock()` to get an `OwningLock<jsi::Value>`.
+ * This will allow you to access the `jsi::Value` as long as the `OwningLock` is alive,
  * and `JSICache` will hold any garbage collection calls until the `OwningLock` is destroyed.
  */
 class JSICache final : public jsi::NativeState {
 public:
-  explicit JSICache(jsi::Runtime* runtime) : _runtime(runtime) {}
   ~JSICache();
 
 public:
@@ -43,6 +42,9 @@ public:
   JSICache(const JSICache&) = delete;
   JSICache(JSICache&&) = delete;
 
+private:
+  explicit JSICache(jsi::Runtime* runtime) : _runtime(runtime) {}
+
 public:
   /**
    Gets or creates a `JSICache` for the given `jsi::Runtime`.
@@ -59,7 +61,10 @@ private:
 private:
   jsi::Runtime* _runtime;
   std::mutex _mutex;
-  std::vector<BorrowingReference<jsi::Object>> _cache;
+  std::vector<BorrowingReference<jsi::Object>> _objectCache;
+  std::vector<BorrowingReference<jsi::Function>> _functionCache;
+  std::vector<BorrowingReference<jsi::WeakObject>> _weakObjectCache;
+  std::vector<BorrowingReference<jsi::ArrayBuffer>> _arrayBufferCache;
 
 private:
   static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache>> _globalCache;
@@ -79,22 +84,25 @@ public:
   }
 
 public:
-  /**
-   * Creates a semi-strong reference to a `jsi::Object` that can be stored in memory and accessed later.
-   *
-   * The returned `OwningReference<T>` keeps the `T` semi-strong, and once it gets deleted, `T` will also be freed.
-   *
-   * Note: The JS Runtime can still delete `T` at any point (e.g. when it gets destroyed or reloaded),
-   * so any operations on `T` should be under an `OwningLock<T>`.
-   *
-   * To get an `OwningLock<T>` (which implies safe access to `T`), call `.locK()` on the `OwningReference<T>`.
-   * This will hold off any JS Runtime GC calls that will destroy `T` for as long as the `OwningLock<T>` is alive.
-   */
-  template <typename T>
-  OwningReference<T> makeGlobal(T&& value) {
-    OwningReference<jsi::Object> owning(new T(std::move(value)));
-    _strongCache->_cache.push_back(owning.weak());
-    return owning.as<T>();
+  OwningReference<jsi::Object> makeShared(jsi::Object&& value) {
+    OwningReference<jsi::Object> owning(new jsi::Object(std::move(value)));
+    _strongCache->_objectCache.push_back(owning.weak());
+    return owning;
+  }
+  OwningReference<jsi::Function> makeShared(jsi::Function&& value) {
+    OwningReference<jsi::Function> owning(new jsi::Function(std::move(value)));
+    _strongCache->_functionCache.push_back(owning.weak());
+    return owning;
+  }
+  OwningReference<jsi::WeakObject> makeShared(jsi::WeakObject&& value) {
+    OwningReference<jsi::WeakObject> owning(new jsi::WeakObject(std::move(value)));
+    _strongCache->_weakObjectCache.push_back(owning.weak());
+    return owning;
+  }
+  OwningReference<jsi::ArrayBuffer> makeShared(jsi::ArrayBuffer&& value) {
+    OwningReference<jsi::ArrayBuffer> owning(new jsi::ArrayBuffer(std::move(value)));
+    _strongCache->_arrayBufferCache.push_back(owning.weak());
+    return owning;
   }
 
 private:

package/cpp/jsi/JSIConverter+ArrayBuffer.hpp

@@ -31,15 +31,19 @@ template <typename T>
 struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::MutableBuffer>>> {
   static inline std::shared_ptr<ArrayBuffer> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     jsi::Object object = arg.asObject(runtime);
+
+#if DEBUG
     if (!object.isArrayBuffer(runtime)) [[unlikely]] {
-      throw std::runtime_error("Object \"" + arg.toString(runtime).utf8(runtime) + "\" is not an ArrayBuffer! "
+      throw std::runtime_error("Object \"" + arg.toString(runtime).utf8(runtime) +
+                               "\" is not an ArrayBuffer! "
                                "Are you maybe passing a TypedArray (e.g. Uint8Array)? Try to pass it's `.buffer` value.");
     }
+#endif
 
     JSICacheReference cache = JSICache::getOrCreateCache(runtime);
-    auto owningArrayBuffer = cache.makeGlobal<jsi::ArrayBuffer>(object.getArrayBuffer(runtime));
+    auto borrowingArrayBuffer = cache.makeShared(object.getArrayBuffer(runtime));
 
-    return std::make_shared<JSArrayBuffer>(&runtime, owningArrayBuffer);
+    return std::make_shared<JSArrayBuffer>(&runtime, borrowingArrayBuffer);
   }
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::shared_ptr<jsi::MutableBuffer>& buffer) {
     return jsi::ArrayBuffer(runtime, buffer);

package/cpp/jsi/JSIConverter+Function.hpp

@@ -35,7 +35,7 @@ struct JSIConverter<std::function<ReturnType(Args...)>> {
     // Make function global - it'll be managed by the Runtime's memory, and we only have a weak_ref to it.
     auto cache = JSICache::getOrCreateCache(runtime);
     jsi::Function function = arg.asObject(runtime).asFunction(runtime);
-    OwningReference<jsi::Function> sharedFunction = cache.makeGlobal<jsi::Function>(std::move(function));
+    OwningReference<jsi::Function> sharedFunction = cache.makeShared(std::move(function));
 
     std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
     std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;

package/cpp/jsi/JSIConverter+HybridObject.hpp

@@ -7,125 +7,64 @@
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
 class HybridObject;
-
-template <typename T, typename Enable>
-struct JSIConverter;
 } // namespace margelo::nitro
 
-#include "JSIConverter.hpp"
-
-#include "HybridObject.hpp"
 #include "IsSharedPtrTo.hpp"
 #include "TypeInfo.hpp"
 #include <jsi/jsi.h>
-#include <memory>
 #include <type_traits>
 
-#define DO_NULL_CHECKS true
-
 namespace margelo::nitro {
 
 using namespace facebook;
 
-// HybridObject <> {}
+// HybridObject(NativeState) <> {}
 template <typename T>
-struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::HostObject>>> {
+struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>> {
   using TPointee = typename T::element_type;
 
   static inline T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
-#if DO_NULL_CHECKS
-    if (arg.isUndefined()) [[unlikely]] {
-      throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
-    }
+#if DEBUG
     if (!arg.isObject()) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
+      if (arg.isUndefined()) [[unlikely]] {
+        throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
+      } else {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
+      }
     }
 #endif
     jsi::Object object = arg.asObject(runtime);
-#if DO_NULL_CHECKS
-    if (!object.isHostObject(runtime)) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not a HostObject!"));
-    }
-    if (!object.isHostObject<TPointee>(runtime)) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different HostObject<T>!"));
+
+#if DEBUG
+    if (!object.hasNativeState<TPointee>(runtime)) [[unlikely]] {
+      if (!object.hasNativeState(runtime)) [[unlikely]] {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It does not have a NativeState!"));
+      } else {
+        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It has a different NativeState<T>!"));
+      }
     }
 #endif
-    return object.asHostObject<TPointee>(runtime);
+    return object.getNativeState<TPointee>(runtime);
   }
 
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
-#if DO_NULL_CHECKS
     if (arg == nullptr) [[unlikely]] {
       std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
-      throw jsi::JSError(runtime, "Cannot convert nullptr to HostObject<" + typeName + ">!");
+      throw jsi::JSError(runtime, "Cannot convert nullptr to NativeState<" + typeName + ">!");
     }
-#endif
+
     if constexpr (std::is_base_of_v<HybridObject, TPointee>) {
       // 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.
-      return jsi::Object::createFromHostObject(runtime, arg);
-    }
-  }
-
-  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
-    if (value.isObject()) {
-      jsi::Object object = value.getObject(runtime);
-      return object.isHostObject<TPointee>(runtime);
-    }
-    return false;
-  }
-
-private:
-  static inline std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
-    std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
-    return "Cannot convert \"" + typeDescription + "\" to HostObject<" + typeName + ">! " + reason;
-  }
-};
-
-// NativeState <> {}
-template <typename T>
-struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>> {
-  using TPointee = typename T::element_type;
-
-  static inline T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
-#if DO_NULL_CHECKS
-    if (arg.isUndefined()) [[unlikely]] {
-      throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
-    }
-    if (!arg.isObject()) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
-    }
-#endif
-    jsi::Object object = arg.asObject(runtime);
-#if DO_NULL_CHECKS
-    if (!object.hasNativeState(runtime)) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not a NativeState!"));
+      // It's any other kind of jsi::HostObject - just create it as normal. This will not have a prototype then!
+      jsi::Object object(runtime);
+      object.setNativeState(runtime, arg);
+      return object;
     }
-    if (!object.hasNativeState<TPointee>(runtime)) [[unlikely]] {
-      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different NativeState<T>!"));
-    }
-#endif
-    return object.getNativeState<TPointee>(runtime);
-  }
-
-  static inline jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
-#if DO_NULL_CHECKS
-    if (arg == nullptr) [[unlikely]] {
-      std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
-      throw jsi::JSError(runtime, "Cannot convert nullptr to NativeState<" + typeName + ">!");
-    }
-#endif
-    jsi::Object object(runtime);
-    object.setNativeState(runtime, arg);
-    return object;
   }
 
   static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {

package/cpp/jsi/Promise.cpp

@@ -9,8 +9,8 @@ using namespace facebook;
 
 Promise::Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter) {
   auto functionCache = JSICache::getOrCreateCache(runtime);
-  _resolver = functionCache.makeGlobal<jsi::Function>(std::move(resolver));
-  _rejecter = functionCache.makeGlobal<jsi::Function>(std::move(rejecter));
+  _resolver = functionCache.makeShared(std::move(resolver));
+  _rejecter = functionCache.makeShared(std::move(rejecter));
 }
 
 jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -0,0 +1,87 @@
+//
+//  HybridObjectPrototype.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#include "HybridObjectPrototype.hpp"
+#include "NitroLogger.hpp"
+
+namespace margelo::nitro {
+
+std::unordered_map<jsi::Runtime*, HybridObjectPrototype::PrototypeCache> HybridObjectPrototype::_prototypeCache;
+
+jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype) {
+  // 0. Check if we're at the highest level of our prototype chain
+  if (prototype == nullptr) {
+    // There is no prototype - we just have an empty Object base - so `Object.create({})`
+    return jsi::Object(runtime);
+  }
+
+  // 1. Try looking for the given prototype in cache.
+  //    If we find it in cache, we can create instances faster and skip creating the prototype from scratch!
+  auto& prototypeCache = _prototypeCache[&runtime];
+  auto cachedPrototype = prototypeCache.find(prototype->getNativeInstanceId());
+  if (cachedPrototype != prototypeCache.end()) {
+    const OwningReference<jsi::Object>& cachedObject = cachedPrototype->second;
+    return jsi::Value(runtime, *cachedObject).getObject(runtime);
+  }
+
+  // 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());
+  jsi::Object objectConstructor = runtime.global().getPropertyAsObject(runtime, "Object");
+  jsi::Function objectCreate = objectConstructor.getPropertyAsFunction(runtime, "create");
+  jsi::Function objectDefineProperty = objectConstructor.getPropertyAsFunction(runtime, "defineProperty");
+
+  // 3. Create an empty JS Object, inheriting from the base prototype (recursively!)
+  jsi::Object object = objectCreate.call(runtime, createPrototype(runtime, prototype->getBase())).getObject(runtime);
+
+  // 4. Add all Hybrid Methods to it
+  for (const auto& method : prototype->getMethods()) {
+    object.setProperty(runtime, method.first.c_str(), method.second.toJSFunction(runtime));
+  }
+
+  // 5. Add all properties (getter + setter) to it using defineProperty
+  for (const auto& getter : prototype->getGetters()) {
+    jsi::Object property(runtime);
+    property.setProperty(runtime, "configurable", false);
+    property.setProperty(runtime, "enumerable", true);
+    property.setProperty(runtime, "get", getter.second.toJSFunction(runtime));
+
+    const auto& setter = prototype->getSetters().find(getter.first);
+    if (setter != prototype->getSetters().end()) {
+      // there also is a setter for this property!
+      property.setProperty(runtime, "set", setter->second.toJSFunction(runtime));
+    }
+
+    property.setProperty(runtime, "name", jsi::String::createFromUtf8(runtime, getter.first.c_str()));
+    objectDefineProperty.call(runtime,
+                              /* obj */ object,
+                              /* propName */ jsi::String::createFromUtf8(runtime, getter.first.c_str()),
+                              /* descriptorObj */ property);
+  }
+
+  // 6. Throw it into our cache so the next lookup can be cached and therefore faster
+  JSICacheReference jsiCache = JSICache::getOrCreateCache(runtime);
+  OwningReference<jsi::Object> cachedObject = jsiCache.makeShared(std::move(object));
+  prototypeCache.emplace(prototype->getNativeInstanceId(), cachedObject);
+
+  // 7. In DEBUG, add a __type info to the prototype object.
+#if DEBUG
+  auto typeName = "Prototype<" + std::string(prototype->getNativeInstanceId().name()) + ">";
+  cachedObject->setProperty(runtime, "__type", jsi::String::createFromUtf8(runtime, typeName));
+#endif
+
+  // 8. Return it!
+  return jsi::Value(runtime, *cachedObject);
+}
+
+jsi::Value HybridObjectPrototype::getPrototype(jsi::Runtime& runtime) {
+  ensureInitialized();
+
+  return createPrototype(runtime, _prototypeChain.getPrototype());
+}
+
+} // namespace margelo::nitro

package/cpp/prototype/HybridObjectPrototype.hpp

@@ -0,0 +1,92 @@
+//
+//  HybridObjectPrototype.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+#include "HybridFunction.hpp"
+#include "OwningReference.hpp"
+#include "Prototype.hpp"
+#include "PrototypeChain.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a Hybrid Object's prototype.
+ * The prototype should be cached per Runtime, and can be assigned to multiple jsi::Objects.
+ * When assigned to a jsi::Object, all methods of this prototype can be called on that jsi::Object,
+ * as long as it has a valid NativeState (`this`).
+ */
+class HybridObjectPrototype {
+private:
+  PrototypeChain _prototypeChain;
+  bool _didLoadMethods = false;
+  static constexpr auto TAG = "HybridObjectPrototype";
+
+public:
+  HybridObjectPrototype() {}
+
+public:
+  /**
+   * Get a fully initialized jsi::Object that represents this prototype to JS.
+   * The result of this value will be cached per Runtime, so it's safe to call this often.
+   */
+  jsi::Value getPrototype(jsi::Runtime& runtime);
+
+private:
+  static jsi::Value createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype);
+  using PrototypeCache = std::unordered_map<NativeInstanceId, OwningReference<jsi::Object>>;
+  static std::unordered_map<jsi::Runtime*, PrototypeCache> _prototypeCache;
+
+protected:
+  /**
+   * Loads all Hybrid Methods that will be initialized in this Prototype.
+   * This will only be called once for the first time the Prototype will be created,
+   * so don't conditionally register methods.
+   */
+  virtual void loadHybridMethods() = 0;
+
+private:
+  /**
+   * Ensures that all Hybrid Methods, Getters and Setters are initialized by calling loadHybridMethods().
+   */
+  inline void ensureInitialized() {
+    if (!_didLoadMethods) [[unlikely]] {
+      // lazy-load all exposed methods
+      loadHybridMethods();
+      _didLoadMethods = true;
+    }
+  }
+
+protected:
+  using RegisterFn = void (*)(Prototype&);
+  /**
+   * Registers the given methods inside the Hybrid Object's prototype.
+   *
+   * For subsequent HybridObjects of the same type, `registerFunc` will not be called again, as the
+   * prototype will already be known and cached.
+   * **Do not conditionally register hybrid methods, getters or setter!**
+   */
+  template <typename Derived>
+  inline void registerHybrids(Derived* thisInstance, RegisterFn registerFunc) {
+    const std::shared_ptr<Prototype>& prototype = _prototypeChain.extendPrototype<Derived>();
+
+    if (!prototype->hasHybrids()) {
+      // The `Prototype` does not have any methods or properties registered yet - so do it now
+      registerFunc(*prototype);
+    }
+  }
+};
+
+} // namespace margelo::nitro