react-native-nitro-modules 0.21.0 → 0.22.1

package/NitroModules.podspec

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

package/README.md

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

package/android/CMakeLists.txt

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

package/android/build.gradle

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

package/android/gradle.properties

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

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

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

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

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

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

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

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

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

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

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

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

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

package/cpp/core/ArrayBuffer.cpp

@@ -6,7 +6,7 @@
 //
 
 #include "ArrayBuffer.hpp"
-#include "OwningReference.hpp"
+#include "BorrowingReference.hpp"
 #include <functional>
 #include <jsi/jsi.h>
 #include <thread>
@@ -61,7 +61,7 @@ bool NativeArrayBuffer::isOwner() const noexcept {
 
 // 3. JSArrayBuffer
 
-JSArrayBuffer::JSArrayBuffer(jsi::Runtime* runtime, OwningReference<jsi::ArrayBuffer> jsReference)
+JSArrayBuffer::JSArrayBuffer(jsi::Runtime* runtime, BorrowingReference<jsi::ArrayBuffer> jsReference)
     : ArrayBuffer(), _runtime(runtime), _jsReference(jsReference), _initialThreadId(std::this_thread::get_id()) {}
 
 JSArrayBuffer::~JSArrayBuffer() {}

package/cpp/core/ArrayBuffer.hpp

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "OwningReference.hpp"
+#include "BorrowingReference.hpp"
 #include <jsi/jsi.h>
 #include <thread>
 #include <vector>
@@ -122,7 +122,7 @@ private:
  */
 class JSArrayBuffer final : public ArrayBuffer {
 public:
-  explicit JSArrayBuffer(jsi::Runtime* runtime, OwningReference<jsi::ArrayBuffer> jsReference);
+  explicit JSArrayBuffer(jsi::Runtime* runtime, BorrowingReference<jsi::ArrayBuffer> jsReference);
   ~JSArrayBuffer();
 
 public:
@@ -141,7 +141,7 @@ public:
 
 private:
   jsi::Runtime* _runtime;
-  OwningReference<jsi::ArrayBuffer> _jsReference;
+  BorrowingReference<jsi::ArrayBuffer> _jsReference;
   std::thread::id _initialThreadId;
 };
 

package/cpp/core/HybridFunction.hpp

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

package/cpp/core/HybridObject.cpp

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

package/cpp/core/HybridObject.hpp

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

package/cpp/core/Promise.hpp

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

package/cpp/entrypoint/HybridNitroModulesProxy.cpp

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

package/cpp/entrypoint/HybridNitroModulesProxy.hpp

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

package/cpp/jsi/JSICache.cpp

@@ -14,12 +14,12 @@ namespace margelo::nitro {
 static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
 
 template <typename T>
-inline void destroyReferences(const std::vector<BorrowingReference<T>>& references) {
+inline void destroyReferences(const std::vector<WeakReference<T>>& references) {
   for (auto& func : references) {
-    OwningReference<T> owning = func.lock();
-    if (owning) {
+    BorrowingReference<T> reference = func.lock();
+    if (reference) {
       // Destroy all functions that we might still have in cache, some callbacks and Promises may now become invalid.
-      owning.destroy();
+      reference.destroy();
     }
   }
 }
@@ -28,6 +28,7 @@ JSICache::~JSICache() {
   Logger::log(LogLevel::Info, TAG, "Destroying JSICache...");
   std::unique_lock lock(_mutex);
 
+  destroyReferences(_valueCache);
   destroyReferences(_objectCache);
   destroyReferences(_functionCache);
   destroyReferences(_weakObjectCache);

package/cpp/jsi/JSICache.hpp

@@ -9,7 +9,7 @@
 
 #include "BorrowingReference.hpp"
 #include "NitroLogger.hpp"
-#include "OwningReference.hpp"
+#include "WeakReference.hpp"
 #include <jsi/jsi.h>
 #include <memory>
 #include <mutex>
@@ -24,12 +24,12 @@ class JSICacheReference;
 
 /**
  * A `JSICache` can safely store `jsi::Value` instances (e.g. `jsi::Object` or
- * `jsi::Function`) inside `OwningReference<T>`.
+ * `jsi::Function`) inside `BorrowingReference<T>`.
  *
  * `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::Value>` safely, use `lock()` to get an `OwningLock<jsi::Value>`.
+ * To access a `BorrowingReference<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.
  */
@@ -59,10 +59,11 @@ private:
 
 private:
   std::mutex _mutex;
-  std::vector<BorrowingReference<jsi::Object>> _objectCache;
-  std::vector<BorrowingReference<jsi::Function>> _functionCache;
-  std::vector<BorrowingReference<jsi::WeakObject>> _weakObjectCache;
-  std::vector<BorrowingReference<jsi::ArrayBuffer>> _arrayBufferCache;
+  std::vector<WeakReference<jsi::Value>> _valueCache;
+  std::vector<WeakReference<jsi::Object>> _objectCache;
+  std::vector<WeakReference<jsi::Function>> _functionCache;
+  std::vector<WeakReference<jsi::WeakObject>> _weakObjectCache;
+  std::vector<WeakReference<jsi::ArrayBuffer>> _arrayBufferCache;
 
 private:
   static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache>> _globalCache;
@@ -82,23 +83,28 @@ public:
   }
 
 public:
-  OwningReference<jsi::Object> makeShared(jsi::Object&& value) {
-    OwningReference<jsi::Object> owning(new jsi::Object(std::move(value)));
+  BorrowingReference<jsi::Value> makeShared(jsi::Value&& value) {
+    BorrowingReference<jsi::Value> owning(new jsi::Value(std::move(value)));
+    _strongCache->_valueCache.push_back(owning.weak());
+    return owning;
+  }
+  BorrowingReference<jsi::Object> makeShared(jsi::Object&& value) {
+    BorrowingReference<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)));
+  BorrowingReference<jsi::Function> makeShared(jsi::Function&& value) {
+    BorrowingReference<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)));
+  BorrowingReference<jsi::WeakObject> makeShared(jsi::WeakObject&& value) {
+    BorrowingReference<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)));
+  BorrowingReference<jsi::ArrayBuffer> makeShared(jsi::ArrayBuffer&& value) {
+    BorrowingReference<jsi::ArrayBuffer> owning(new jsi::ArrayBuffer(std::move(value)));
     _strongCache->_arrayBufferCache.push_back(owning.weak());
     return owning;
   }

package/cpp/jsi/JSIConverter+Exception.hpp

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

package/cpp/jsi/JSIConverter+Function.hpp

@@ -34,7 +34,7 @@ struct JSIConverter<std::function<ReturnType(Args...)>> final {
     // 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.makeShared(std::move(function));
+    BorrowingReference<jsi::Function> sharedFunction = cache.makeShared(std::move(function));
 
     std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
     std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
@@ -94,7 +94,8 @@ struct JSIConverter<std::function<ReturnType(Args...)>> final {
   }
 
 private:
-  static inline ResultingType callJSFunction(jsi::Runtime& runtime, const OwningReference<jsi::Function>& function, const Args&... args) {
+  static inline ResultingType callJSFunction(jsi::Runtime& runtime, const BorrowingReference<jsi::Function>& function,
+                                             const Args&... args) {
     if (!function) {
       if constexpr (std::is_void_v<ResultingType>) {
         // runtime has already been deleted. since this returns void, we can just ignore it being deleted.

package/cpp/jsi/JSIConverter+HostObject.hpp

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

package/cpp/jsi/JSIConverter+HybridObject.hpp

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

package/cpp/jsi/JSIConverter+Tuple.hpp

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

package/cpp/jsi/JSIConverter+Variant.hpp

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

package/cpp/jsi/JSIHelpers.hpp

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

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -8,7 +8,7 @@
 #include "HybridObjectPrototype.hpp"
 #include "NitroDefines.hpp"
 #include "NitroLogger.hpp"
-#include "TypeInfo.hpp"
+#include "NitroTypeInfo.hpp"
 
 namespace margelo::nitro {
 
@@ -26,7 +26,7 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
   auto& prototypeCache = _prototypeCache[&runtime];
   auto cachedPrototype = prototypeCache.find(prototype->getNativeInstanceId());
   if (cachedPrototype != prototypeCache.end()) {
-    const OwningReference<jsi::Object>& cachedObject = cachedPrototype->second;
+    const BorrowingReference<jsi::Object>& cachedObject = cachedPrototype->second;
     return jsi::Value(runtime, *cachedObject).getObject(runtime);
   }
 
@@ -68,7 +68,7 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
 
   // 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));
+  BorrowingReference<jsi::Object> cachedObject = jsiCache.makeShared(std::move(object));
   prototypeCache.emplace(prototype->getNativeInstanceId(), cachedObject);
 
   // 7. In DEBUG, add a __type info to the prototype object.

package/cpp/prototype/HybridObjectPrototype.hpp

@@ -7,8 +7,8 @@
 
 #pragma once
 
+#include "BorrowingReference.hpp"
 #include "HybridFunction.hpp"
-#include "OwningReference.hpp"
 #include "Prototype.hpp"
 #include "PrototypeChain.hpp"
 #include <functional>
@@ -46,7 +46,7 @@ public:
 
 private:
   static jsi::Value createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype);
-  using PrototypeCache = std::unordered_map<NativeInstanceId, OwningReference<jsi::Object>>;
+  using PrototypeCache = std::unordered_map<NativeInstanceId, BorrowingReference<jsi::Object>>;
   static std::unordered_map<jsi::Runtime*, PrototypeCache> _prototypeCache;
 
 protected: