react-native-nitro-modules 0.1.7 → 0.3.0

package/README.md

@@ -72,10 +72,14 @@ public:
 
 public:
   void loadHybridMethods() override {
+    // Call base method to make sure we properly inherit `toString()` and `equals()`
+    HybridObject::loadHybridMethods();
     // Register all methods that need to be exposed to JS
-    registerHybridGetter("number", &MyHybridObject::getNumber, this);
-    registerHybridSetter("number", &MyHybridObject::setNumber, this);
-    registerHybridMethod("add", &MyHybridObject::add, this);
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("number", &MyHybridObject::getNumber);
+      prototype.registerHybridSetter("number", &MyHybridObject::setNumber);
+      prototype.registerHybridMethod("add", &MyHybridObject::add);
+    });
   }
 
 private:
@@ -149,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>
@@ -170,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>
@@ -195,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

@@ -25,6 +25,7 @@ include_directories(
   ../cpp/jsi
   ../cpp/platform
   ../cpp/registry
+  ../cpp/prototype
   ../cpp/test-object
   ../cpp/templates
   ../cpp/threading

package/cpp/core/HybridFunction.hpp

@@ -0,0 +1,167 @@
+//
+//  HybridFunction.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+namespace margelo::nitro {
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "CountTrailingOptionals.hpp"
+#include "JSIConverter.hpp"
+#include "TypeInfo.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents the type of a function - it can be either a normal function ("METHOD"),
+ * or a property ("GETTER" + "SETTER")
+ */
+enum class FunctionType { METHOD, GETTER, SETTER };
+
+/**
+ * Represents a Hybrid Function.
+ */
+class HybridFunction final {
+private:
+  std::string _name;
+  size_t _paramCount;
+  jsi::HostFunctionType _function;
+
+public:
+  // getters
+  inline const std::string& getName() const {
+    return _name;
+  }
+  inline size_t getParamCount() const {
+    return _paramCount;
+  }
+  inline const jsi::HostFunctionType& getHostFunction() const {
+    return _function;
+  }
+
+public:
+  // functions
+  inline jsi::Function toJSFunction(jsi::Runtime& runtime) const {
+    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, _name), _paramCount, _function);
+  }
+
+private:
+  HybridFunction(jsi::HostFunctionType&& function, size_t paramCount, const std::string& name)
+      : _function(std::move(function)), _paramCount(paramCount), _name(name) {}
+
+public:
+  /**
+   * Create a new `HybridFunction` that can be called from JS.
+   * This performs proper JSI -> C++ conversion using `JSIConverter<T>`,
+   * and assumes that the object this is called on has a proper `this` configured.
+   * The object's `this` needs to be a `NativeState`.
+   */
+  template <typename Derived, typename ReturnType, typename... Args>
+  static inline HybridFunction createHybridFunction(const std::string& name, ReturnType (Derived::*method)(Args...), FunctionType type) {
+    jsi::HostFunctionType hostFunction = [name, method, type](/* JS Runtime */ jsi::Runtime& runtime,
+                                                              /* HybridObject */ const jsi::Value& thisValue,
+                                                              /* JS arguments */ const jsi::Value* args,
+                                                              /* argument size */ size_t count) -> jsi::Value {
+    // 1. Get actual `HybridObject` instance from `thisValue` (it's stored as `NativeState`)
+#if DEBUG
+      if (!thisValue.isObject()) [[unlikely]] {
+        throw jsi::JSError(runtime, "Cannot call hybrid function " + name + "(...) - `this` is not bound!");
+      }
+#endif
+      jsi::Object thisObject = thisValue.getObject(runtime);
+
+#if DEBUG
+      if (!thisObject.hasNativeState<Derived>(runtime)) [[unlikely]] {
+        if (thisObject.hasNativeState(runtime)) {
+          throw jsi::JSError(runtime, "Cannot call hybrid function " + name + "(...) - `this` has a NativeState, but it's the wrong type!");
+        } else {
+          throw jsi::JSError(runtime, "Cannot call hybrid function " + name + "(...) - `this` does not have a NativeState!");
+        }
+      }
+#endif
+      std::shared_ptr<Derived> hybridInstance = thisObject.getNativeState<Derived>(runtime);
+
+      // 2. Make sure the given arguments match, either with a static size, or with potentially optional arguments size.
+      constexpr size_t optionalArgsCount = trailing_optionals_count_v<Args...>;
+      constexpr size_t maxArgsCount = sizeof...(Args);
+      constexpr size_t minArgsCount = maxArgsCount - optionalArgsCount;
+      bool isWithinArgsRange = (count >= minArgsCount && count <= maxArgsCount);
+      if (!isWithinArgsRange) [[unlikely]] {
+        // invalid amount of arguments passed!
+        std::string hybridObjectName = hybridInstance->getName();
+        if constexpr (minArgsCount == maxArgsCount) {
+          // min and max args length is the same, so we don't have any optional parameters. fixed count
+          throw jsi::JSError(runtime, hybridObjectName + "." + name + "(...) expected " + std::to_string(maxArgsCount) +
+                                          " arguments, but received " + std::to_string(count) + "!");
+        } else {
+          // min and max args length are different, so we have optional parameters - variable length arguments.
+          throw jsi::JSError(runtime, hybridObjectName + "." + name + "(...) expected between " + std::to_string(minArgsCount) + " and " +
+                                          std::to_string(maxArgsCount) + " arguments, but received " + std::to_string(count) + "!");
+        }
+      }
+
+      // 3. Actually call method - either raw JSI method, or by going through `JSIConverter<T>` first.
+      try {
+        if constexpr (std::is_same_v<ReturnType, jsi::Value>) {
+          // If the return type is a jsi::Value, we assume the user wants full JSI code control.
+          // The signature must be identical to jsi::HostFunction (jsi::Runtime&, jsi::Value& this, ...)
+          return (hybridInstance->*method)(runtime, thisValue, args, count);
+        } else {
+          // Call the actual method with JSI values as arguments and return a JSI value again.
+          // Internally, this method converts the JSI values to C++ values.
+          return callMethod(hybridInstance.get(), method, runtime, args, count, std::index_sequence_for<Args...>{});
+        }
+      } catch (const std::exception& exception) {
+        // Some exception was thrown - add method name information and re-throw as `JSError`.
+        std::string hybridObjectName = hybridInstance->getName();
+        std::string message = exception.what();
+        std::string suffix = type == FunctionType::METHOD ? "(...)" : "";
+        throw jsi::JSError(runtime, hybridObjectName + "." + name + suffix + ": " + message);
+      } catch (...) {
+        // Some unknown exception was thrown - add method name information and re-throw as `JSError`.
+        std::string hybridObjectName = hybridInstance->getName();
+        std::string errorName = TypeInfo::getCurrentExceptionName();
+        std::string suffix = type == FunctionType::METHOD ? "(...)" : "";
+        throw jsi::JSError(runtime, hybridObjectName + "." + name + suffix + " threw an unknown " + errorName + " error.");
+      }
+    };
+
+    return HybridFunction(std::move(hostFunction), sizeof...(Args), name);
+  }
+
+private:
+  /**
+   * Calls the given method on the given instance with the given `jsi::Value` arguments by converting them to the desired target types.
+   * The given method's return value will be converted to a `jsi::Value` again.
+   */
+  template <typename Derived, typename ReturnType, typename... Args, size_t... Is>
+  static inline jsi::Value callMethod(Derived* obj, ReturnType (Derived::*method)(Args...), jsi::Runtime& runtime, const jsi::Value* args,
+                                      size_t argsSize, std::index_sequence<Is...>) {
+    jsi::Value defaultValue;
+
+    if constexpr (std::is_void_v<ReturnType>) {
+      // It's a void method.
+      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, Is < argsSize ? args[Is] : defaultValue)...);
+      return jsi::Value::undefined();
+    } else {
+      // It's returning some C++ type, we need to convert that to a JSI value now.
+      ReturnType result = (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, Is < argsSize ? args[Is] : defaultValue)...);
+      return JSIConverter<std::decay_t<ReturnType>>::toJSI(runtime, std::move(result));
+    }
+  }
+};
+
+} // namespace margelo::nitro

package/cpp/core/HybridObject.cpp

@@ -3,11 +3,10 @@
 //
 
 #include "HybridObject.hpp"
-#include "HybridContext.hpp"
 #include "JSIConverter.hpp"
 #include "NitroLogger.hpp"
 
-#define LOG_MEMORY_ALLOCATIONS true
+#define LOG_MEMORY_ALLOCATIONS false
 
 namespace margelo::nitro {
 
@@ -45,7 +44,7 @@ static int getId(const char* name) {
 }
 #endif
 
-HybridObject::HybridObject(const char* name) : _name(name), _mutex(std::make_unique<std::mutex>()) {
+HybridObject::HybridObject(const char* name) : HybridObjectPrototype(), _name(name) {
 #if LOG_MEMORY_ALLOCATIONS
   _instanceId = getId(name);
   uint32_t alive = incrementAliveInstancesAndGet(_name);
@@ -62,55 +61,6 @@ HybridObject::~HybridObject() {
   Logger::log(TAG, "(MEMORY) ❌ Deleting %s (#%i)... (Total %s(s): %i | Total HybridObjects: %i) ", _name, _instanceId, _name, alive,
               totalObjects);
 #endif
-  _functionCache.clear();
-}
-
-size_t HybridObject::getTotalExternalMemorySize() noexcept {
-  static constexpr int STRING_KEY_AVERAGE_SIZE = 32; // good average for string keys
-  static constexpr int CACHED_SIZE = STRING_KEY_AVERAGE_SIZE + sizeof(jsi::Function);
-  static constexpr int METHOD_SIZE = STRING_KEY_AVERAGE_SIZE + sizeof(HybridFunction);
-  static constexpr int GETTER_SIZE = STRING_KEY_AVERAGE_SIZE + sizeof(jsi::HostFunctionType);
-  static constexpr int SETTER_SIZE = STRING_KEY_AVERAGE_SIZE + sizeof(jsi::HostFunctionType);
-
-  size_t cachedFunctions = 0;
-  for (const auto& cache : _functionCache) {
-    cachedFunctions += cache.second.size();
-  }
-
-  size_t externalSize = getExternalMemorySize();
-  return (_getters.size() * GETTER_SIZE) + (_setters.size() * SETTER_SIZE) + (_methods.size() * METHOD_SIZE) +
-         (cachedFunctions * CACHED_SIZE) + sizeof(std::mutex) + externalSize;
-}
-
-jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
-  // 1. Try to find existing jsi::Object from cache
-  auto found = _jsObjects.find(&runtime);
-  if (found != _jsObjects.end()) {
-    // 1.1 We found an object in cache, let's see if it's still alive..
-    BorrowingReference<jsi::Object> weak = found->second;
-    OwningReference<jsi::Object> strong = weak.lock();
-    if (strong) {
-      // 1.2. It is alive (strong) - update memory size and return to JS!
-      size_t memorySize = getTotalExternalMemorySize();
-      strong->setExternalMemoryPressure(runtime, memorySize);
-      // 1.3. It is alive (strong) - copy the JSI Pointer into a new jsi::Value, and return to JS
-      return jsi::Value(runtime, *strong);
-    }
-  }
-
-  // 2. There is either no value in cache, or it's already dead. Create a new one
-  auto cache = JSICache::getOrCreateCache(runtime);
-  // 3. Create a new jsi::Object from this HybridObject/jsi::HostObject
-  std::shared_ptr<HybridObject> shared = shared_from_this();
-  jsi::Object object = jsi::Object::createFromHostObject(runtime, shared);
-  // 4. HybridObjects expose their external memory size, so inform JS GC about it!
-  size_t memorySize = getTotalExternalMemorySize();
-  object.setExternalMemoryPressure(runtime, memorySize);
-  // 5. Make it a global (weak) reference
-  auto global = cache.makeGlobal<jsi::Object>(std::move(object));
-  _jsObjects[&runtime] = global.weak();
-  // 6. Return a jsi::Value copy again to the caller.
-  return jsi::Value(runtime, *global);
 }
 
 std::string HybridObject::toString() {
@@ -126,95 +76,53 @@ bool HybridObject::equals(std::shared_ptr<HybridObject> other) {
 }
 
 void HybridObject::loadHybridMethods() {
-  registerHybridGetter("name", &HybridObject::getName, this);
-  registerHybridMethod("toString", &HybridObject::toString, this);
-  registerHybridMethod("equals", &HybridObject::equals, this);
+  registerHybrids(this, [](Prototype& prototype) {
+    prototype.registerHybridGetter("name", &HybridObject::getName);
+    prototype.registerHybridMethod("toString", &HybridObject::toString);
+    prototype.registerHybridMethod("equals", &HybridObject::equals);
+  });
 }
 
-std::vector<jsi::PropNameID> HybridObject::getPropertyNames(facebook::jsi::Runtime& runtime) {
-  std::unique_lock lock(*_mutex);
-  ensureInitialized(runtime);
-
-  std::vector<jsi::PropNameID> result;
-  size_t totalSize = _methods.size() + _getters.size() + _setters.size() + 1;
-  result.reserve(totalSize);
-
-  for (const auto& item : _methods) {
-    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
-  }
-  for (const auto& item : _getters) {
-    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
-  }
-  for (const auto& item : _setters) {
-    result.push_back(jsi::PropNameID::forUtf8(runtime, item.first));
-  }
-  return result;
-}
-
-jsi::Value HybridObject::get(facebook::jsi::Runtime& runtime, const facebook::jsi::PropNameID& propName) {
-  std::unique_lock lock(*_mutex);
-  ensureInitialized(runtime);
-
-  std::string name = propName.utf8(runtime);
-
-  auto& functionCache = _functionCache[&runtime];
-
-  if (functionCache.contains(name)) [[likely]] {
-    // cache hit - let's see if the function is still alive..
-    OwningReference<jsi::Function> function = functionCache[name];
-    if (function) [[likely]] {
-      // function is still alive, we can use it.
-      return jsi::Value(runtime, *function);
+jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
+  // 1. Check if we have a jsi::WeakObject in cache that we can use to avoid re-creating the object each time
+  auto cachedObject = _objectCache.find(&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;
     }
   }
 
-  if (_getters.contains(name)) {
-    // it's a property getter. call it directly
-    return _getters[name](runtime, jsi::Value::undefined(), nullptr, 0);
-  }
+  // 2. Get the object's base prototype (global & shared)
+  jsi::Value prototype = getPrototype(runtime);
 
-  if (_methods.contains(name)) {
-    // it's a function. we now need to wrap it in a jsi::Function, store it in cache, then return it.
-    HybridFunction& hybridFunction = _methods.at(name);
-    // get (or create) a runtime-specific function cache
-    auto runtimeCache = JSICache::getOrCreateCache(runtime);
-    // create the jsi::Function
-    jsi::Function function = jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, name),
-                                                                   hybridFunction.parameterCount, hybridFunction.function);
-    // throw it into the cache for next time
-    OwningReference<jsi::Function> globalFunction = runtimeCache.makeGlobal<jsi::Function>(std::move(function));
-    functionCache[name] = globalFunction;
-    // copy the reference & return it to JS
-    return jsi::Value(runtime, *globalFunction);
-  }
+  // 3. Get the global JS Object.create(...) constructor so we can create an object from the given prototype
+  jsi::Object objectConstructor = runtime.global().getPropertyAsObject(runtime, "Object");
+  jsi::Function create = objectConstructor.getPropertyAsFunction(runtime, "create");
 
-  // this property does not exist. Return undefined
-  return jsi::Value::undefined();
-}
+  // 4. Create the object using Object.create(...)
+  jsi::Object object = create.call(runtime, prototype).asObject(runtime);
 
-void HybridObject::set(facebook::jsi::Runtime& runtime, const facebook::jsi::PropNameID& propName, const facebook::jsi::Value& value) {
-  std::unique_lock lock(*_mutex);
-  ensureInitialized(runtime);
+  // 5. Assign NativeState to the object so the prototype can resolve the native methods
+  object.setNativeState(runtime, shared_from_this());
 
-  std::string name = propName.utf8(runtime);
+  // 6. Set memory size so Hermes GC knows about actual memory
+  object.setExternalMemoryPressure(runtime, getExternalMemorySize());
 
-  if (_setters.contains(name)) {
-    // Call setter
-    _setters[name](runtime, jsi::Value::undefined(), &value, 1);
-    return;
-  }
+#if DEBUG
+  // 7. Assign a private __type property for debugging - this will be used so users know it's not just an empty object.
+  object.setProperty(runtime, "__type", jsi::String::createFromUtf8(runtime, "NativeState<" + std::string(_name) + ">"));
+#endif
 
-  // this property does not exist, and cannot be set. Throw and error!
-  throw std::runtime_error("Cannot set property \"" + name + "\" - " + std::string(_name) + " does not have a setter for \"" + name +
-                           "\"!");
-}
+  // 8. Throw a jsi::WeakObject pointing to our object into cache so subsequent calls can use it from cache
+  JSICacheReference cache = JSICache::getOrCreateCache(runtime);
+  _objectCache.emplace(&runtime, cache.makeShared(jsi::WeakObject(runtime, object)));
 
-void HybridObject::ensureInitialized(facebook::jsi::Runtime& runtime) {
-  if (!_didLoadMethods) [[unlikely]] {
-    // lazy-load all exposed methods
-    loadHybridMethods();
-    _didLoadMethods = true;
-  }
+  // 9. Return it!
+  return object;
 }
 
 } // namespace margelo::nitro

package/cpp/core/HybridObject.hpp

@@ -4,21 +4,14 @@
 
 #pragma once
 
-#include "CountTrailingOptionals.hpp"
-#include "JSIConverter.hpp"
-#include "OwningReference.hpp"
-#include "TypeInfo.hpp"
-#include <functional>
+#include "HybridObjectPrototype.hpp"
+
 #include <jsi/jsi.h>
 #include <memory>
-#include <mutex>
 #include <type_traits>
-#include <unordered_map>
 
 namespace margelo::nitro {
 
-enum class MethodType { METHOD, GETTER, SETTER };
-
 using namespace facebook;
 
 /**
@@ -30,13 +23,7 @@ using namespace facebook;
  *
  * The new class can then be passed to JS using the `JSIConverter<HybridObject>`.
  */
-class HybridObject : public jsi::HostObject, public std::enable_shared_from_this<HybridObject> {
-public:
-  struct HybridFunction {
-    jsi::HostFunctionType function;
-    size_t parameterCount;
-  };
-
+class HybridObject : public jsi::NativeState, public HybridObjectPrototype, public std::enable_shared_from_this<HybridObject> {
 public:
   /**
    * Create a new instance of a `HybridObject`.
@@ -58,9 +45,13 @@ public:
   HybridObject(HybridObject&& move) = delete;
 
 public:
-  void set(jsi::Runtime&, const jsi::PropNameID& name, const jsi::Value& value) override;
-  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override;
+  /**
+   * Return the `jsi::Object` that holds this `HybridObject`. (boxed in a `jsi::Value`)
+   * This properly assigns (or creates) the base prototype for this type,
+   * and assigns it's NativeState.
+   * Additionally, this sets the external memory pressure for proper GC memory management.
+   */
+  jsi::Value toObject(jsi::Runtime& runtime);
 
 public:
   /**
@@ -72,22 +63,6 @@ public:
     return std::static_pointer_cast<Derived>(shared_from_this());
   }
 
-public:
-  /**
-   * Get the total size of any external (heap) allocations this `HybridObject` (or
-   * a subclass of it) has made.
-   * This includes any base allocations (such as function cache), as well as
-   * overridden extra memory size.
-   */
-  size_t getTotalExternalMemorySize() noexcept;
-
-  /**
-   * Return the `jsi::Object` that holds this `HybridObject` (boxed in a `jsi::Value`)
-   * Compared to other `jsi::HostObject`s, the `HybridObject` actually
-   * caches the created `jsi::Object` instances for safer memory management.
-   */
-  jsi::Value toObject(jsi::Runtime& runtime);
-
 public:
   /**
    * Get the HybridObject's name
@@ -128,128 +103,17 @@ protected:
    *
    * void User::loadHybridMethods() {
    *   HybridObject::loadHybridMethods();
-   *   registerHybridMethod("getAge", &User::getAge, this);
+   *   registerHybridMethod("getAge", &User::getAge);
    * }
    * ```
    */
-  virtual void loadHybridMethods();
+  virtual void loadHybridMethods() override;
 
 private:
   static constexpr auto TAG = "HybridObject";
   const char* _name = TAG;
   int _instanceId = 1;
-  bool _didLoadMethods = false;
-  std::unique_ptr<std::mutex> _mutex;
-  std::unordered_map<std::string, HybridFunction> _methods;
-  std::unordered_map<std::string, jsi::HostFunctionType> _getters;
-  std::unordered_map<std::string, jsi::HostFunctionType> _setters;
-  std::unordered_map<jsi::Runtime*, std::unordered_map<std::string, OwningReference<jsi::Function>>> _functionCache;
-  std::unordered_map<jsi::Runtime*, BorrowingReference<jsi::Object>> _jsObjects;
-
-private:
-  inline void ensureInitialized(jsi::Runtime& runtime);
-
-private:
-  template <typename Derived, typename ReturnType, typename... Args, size_t... Is>
-  static inline jsi::Value callMethod(Derived* obj, ReturnType (Derived::*method)(Args...), jsi::Runtime& runtime, const jsi::Value* args,
-                                      size_t argsSize, std::index_sequence<Is...>) {
-    jsi::Value defaultValue;
-
-    if constexpr (std::is_void_v<ReturnType>) {
-      // It's a void method.
-      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, Is < argsSize ? args[Is] : defaultValue)...);
-      return jsi::Value::undefined();
-    } else {
-      // It's returning some C++ type, we need to convert that to a JSI value now.
-      ReturnType result = (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, Is < argsSize ? args[Is] : defaultValue)...);
-      return JSIConverter<std::decay_t<ReturnType>>::toJSI(runtime, std::move(result));
-    }
-  }
-
-  template <typename Derived, typename ReturnType, typename... Args>
-  static inline jsi::HostFunctionType createHybridMethod(std::string name, ReturnType (Derived::*method)(Args...), Derived* derivedInstance,
-                                                         MethodType type) {
-    return [name, derivedInstance, method, type](jsi::Runtime& runtime, const jsi::Value& thisVal, const jsi::Value* args,
-                                                 size_t count) -> jsi::Value {
-      constexpr size_t optionalArgsCount = trailing_optionals_count_v<Args...>;
-      constexpr size_t maxArgsCount = sizeof...(Args);
-      constexpr size_t minArgsCount = maxArgsCount - optionalArgsCount;
-      bool isWithinArgsRange = (count >= minArgsCount && count <= maxArgsCount);
-      if (!isWithinArgsRange) [[unlikely]] {
-        // invalid amount of arguments passed!
-        std::string hybridObjectName = derivedInstance->_name;
-        if constexpr (minArgsCount == maxArgsCount) {
-          // min and max args length is the same, so we don't have any optional parameters. fixed count
-          throw jsi::JSError(runtime, hybridObjectName + "." + name + "(...) expected " + std::to_string(maxArgsCount) +
-                                          " arguments, but received " + std::to_string(count) + "!");
-        } else {
-          // min and max args length are different, so we have optional parameters - variable length arguments.
-          throw jsi::JSError(runtime, hybridObjectName + "." + name + "(...) expected between " + std::to_string(minArgsCount) + " and " +
-                                          std::to_string(maxArgsCount) + " arguments, but received " + std::to_string(count) + "!");
-        }
-      }
-
-      try {
-        if constexpr (std::is_same_v<ReturnType, jsi::Value>) {
-          // If the return type is a jsi::Value, we assume the user wants full JSI code control.
-          // The signature must be identical to jsi::HostFunction (jsi::Runtime&, jsi::Value& this, ...)
-          return (derivedInstance->*method)(runtime, thisVal, args, count);
-        } else {
-          // Call the actual method with JSI values as arguments and return a JSI value again.
-          // Internally, this method converts the JSI values to C++ values.
-          return callMethod(derivedInstance, method, runtime, args, count, std::index_sequence_for<Args...>{});
-        }
-      } catch (const std::exception& exception) {
-        std::string hybridObjectName = derivedInstance->_name;
-        std::string message = exception.what();
-        std::string suffix = type == MethodType::METHOD ? "(...)" : "";
-        throw jsi::JSError(runtime, hybridObjectName + "." + name + suffix + ": " + message);
-      } catch (...) {
-        std::string hybridObjectName = derivedInstance->_name;
-        std::string errorName = TypeInfo::getCurrentExceptionName();
-        std::string suffix = type == MethodType::METHOD ? "(...)" : "";
-        throw jsi::JSError(runtime, hybridObjectName + "." + name + suffix + " threw an unknown " + errorName + " error.");
-      }
-    };
-  }
-
-protected:
-  template <typename Derived, typename ReturnType, typename... Args>
-  inline void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...), Derived* derivedInstance) {
-    if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
-    }
-    if (_methods.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
-    }
-
-    _methods[name] = HybridFunction{.function = createHybridMethod(name, method, derivedInstance, MethodType::METHOD),
-                                    .parameterCount = sizeof...(Args)};
-  }
-
-  template <typename Derived, typename ReturnType>
-  inline void registerHybridGetter(std::string name, ReturnType (Derived::*method)(), Derived* derivedInstance) {
-    if (_getters.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a getter with that name already exists!");
-    }
-    if (_methods.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a method with that name already exists!");
-    }
-
-    _getters[name] = createHybridMethod(name, method, derivedInstance, MethodType::GETTER);
-  }
-
-  template <typename Derived, typename ValueType>
-  inline void registerHybridSetter(std::string name, void (Derived::*method)(ValueType), Derived* derivedInstance) {
-    if (_setters.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a setter with that name already exists!");
-    }
-    if (_methods.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a method with that name already exists!");
-    }
-
-    _setters[name] = createHybridMethod(name, method, derivedInstance, MethodType::SETTER);
-  }
+  std::unordered_map<jsi::Runtime*, OwningReference<jsi::WeakObject>> _objectCache;
 };
 
 } // namespace margelo::nitro