react-native-nitro-modules 0.22.0 → 0.23.0

package/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.8.0"
+    classpath "com.android.tools.build:gradle:8.8.1"
   }
 }
 

package/android/gradle.properties

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

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

@@ -20,4 +20,15 @@ abstract class HybridView: HybridObject() {
     @get:DoNotStrip
     @get:Keep
     abstract val view: View
+
+    /**
+     * Called right before updating props.
+     * React props are updated in a single batch/transaction.
+     */
+    open fun beforeUpdate() { /* noop */ }
+    /**
+     * Called right after updating props.
+     * React props are updated in a single batch/transaction.
+     */
+    open fun afterUpdate() { /* noop */ }
 }

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

@@ -109,12 +109,15 @@ public:
         std::string message = exception.what();
         throw jsi::JSError(runtime, funcName + ": " + message);
 #ifdef ANDROID
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wexceptions"
         // Workaround for https://github.com/mrousavy/nitro/issues/382
       } catch (const std::runtime_error& exception) {
         // Some exception was thrown - add method name information and re-throw as `JSError`.
         std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());
         std::string message = exception.what();
         throw jsi::JSError(runtime, funcName + ": " + message);
+#pragma clang diagnostic pop
 #endif
       } catch (...) {
         // Some unknown exception was thrown - add method name information and re-throw as `JSError`.

package/cpp/core/HybridObject.hpp

@@ -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

@@ -30,7 +30,7 @@ public:
   Promise(const Promise&) = delete;
 
 private:
-  Promise() {}
+  Promise() = default;
 
 public:
   ~Promise() {
@@ -264,13 +264,13 @@ public:
   Promise(const Promise&) = delete;
 
 private:
-  Promise() {}
+  Promise() = default;
 
 public:
   ~Promise() {
     if (isPending()) [[unlikely]] {
       std::runtime_error error("Timeouted: Promise<void> was destroyed!");
-      reject(std::make_exception_ptr(std::move(error)));
+      reject(std::make_exception_ptr(error));
     }
   }
 

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();
     }
   }
 }

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,11 +59,11 @@ private:
 
 private:
   std::mutex _mutex;
-  std::vector<BorrowingReference<jsi::Value>> _valueCache;
-  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;
@@ -83,28 +83,28 @@ public:
   }
 
 public:
-  OwningReference<jsi::Value> makeShared(jsi::Value&& value) {
-    OwningReference<jsi::Value> owning(new jsi::Value(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;
   }
-  OwningReference<jsi::Object> makeShared(jsi::Object&& value) {
-    OwningReference<jsi::Object> owning(new jsi::Object(std::move(value)));
+  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+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/prototype/HybridObjectPrototype.cpp

@@ -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:

package/cpp/registry/HybridObjectRegistry.cpp

@@ -32,6 +32,9 @@ std::vector<std::string> HybridObjectRegistry::getAllHybridObjectNames() {
 
 std::string HybridObjectRegistry::getAllRegisteredHybridObjectNamesToString() {
   std::vector<std::string> names = getAllHybridObjectNames();
+  if (names.empty()) {
+    return "";
+  }
   return std::accumulate(std::next(names.begin()), names.end(), names[0], [](std::string a, std::string b) { return a + ", " + b; });
 }
 

package/cpp/utils/BorrowingReference.hpp

@@ -1,119 +1,226 @@
 //
 //  BorrowingReference.hpp
-//  NitroModules
+//  react-native-nitro
 //
-//  Created by Marc Rousavy on 21.06.24.
+//  Created by Marc Rousavy on 23.06.24.
 //
 
 #pragma once
 
+#include "NitroDefines.hpp"
+#include "OwningLock.hpp"
+#include "ReferenceState.hpp"
+#include "WeakReference.hpp"
 #include <atomic>
 #include <cstddef>
 #include <mutex>
 
 namespace margelo::nitro {
 
-// forward-declaration to avoid duplicate symbols
-template <typename T>
-class OwningReference;
-
 /**
- A `BorrowingReference<T>` is a weak reference to a pointer created by `OwningReference<T>`.
- It can be locked to gain a strong `OwningReference<T>` again if it has not been deleted yet.
+ An `BorrowingReference<T>` is a smart-pointer that holds a strong reference to a pointer.
+ You can have multiple `BorrowingReference<T>` instances point to the same pointer, as they internally keep a ref-count.
+ As opposed to a `shared_ptr<T>`, an `BorrowingReference<T>` can also be imperatively manually deleted, even if there
+ are multiple strong references still holding onto the pointer.
+ This is useful in cases where the `BorrowingReference` might keep a reference alive, but an external value holder
+ is actually responsible for truly deleting the underlying value - like a `jsi::Runtime` for a `jsi::Value`.
+
+ An `BorrowingReference<T>` can be weakified, which gives the user a `WeakReference<T>`.
+ A `WeakReference<T>` can be locked to get an `BorrowingReference<T>` again, assuming it has not been deleted yet.
+
+ A `BorrowingReference<T>` can also be locked using `lock()`, which gives the user an `OwningLock<T>`.
+ Only an `OwningLock<T>` guarantees safe access to the underlying value reference, as any external value holders
+ that might try to delete the value will have to wait until the lock is freed again.
  */
 template <typename T>
 class BorrowingReference final {
-private:
-  explicit BorrowingReference(const OwningReference<T>& ref);
-
 public:
-  BorrowingReference() : _value(nullptr), _isDeleted(nullptr), _strongRefCount(nullptr), _weakRefCount(nullptr), _mutex(nullptr) {}
+  BorrowingReference() : _value(nullptr), _state(nullptr) {}
 
-  BorrowingReference(const BorrowingReference& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
-    if (_weakRefCount != nullptr) {
+  explicit BorrowingReference(T* value) : _value(value), _state(new ReferenceState()) {}
+
+  BorrowingReference(const BorrowingReference& ref) : _value(ref._value), _state(ref._state) {
+    if (_state != nullptr) {
       // increment ref count after copy
-      (*_weakRefCount)++;
+      _state->strongRefCount++;
     }
   }
 
-  BorrowingReference(BorrowingReference&& ref)
-      : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
-        _mutex(ref._mutex) {
+  BorrowingReference(BorrowingReference&& ref) : _value(ref._value), _state(ref._state) {
     ref._value = nullptr;
-    ref._isDeleted = nullptr;
-    ref._strongRefCount = nullptr;
-    ref._weakRefCount = nullptr;
+    ref._state = nullptr;
   }
 
   BorrowingReference& operator=(const BorrowingReference& ref) {
     if (this == &ref)
       return *this;
 
-    if (_weakRefCount != nullptr) {
+    if (_state != nullptr) {
       // destroy previous pointer
-      (*_weakRefCount)--;
-      maybeDestroy();
+      bool shouldDestroy = _state->decrementStrongRefCount();
+      if (shouldDestroy) {
+        forceDestroyValue();
+      }
+      maybeDestroyState();
     }
 
     _value = ref._value;
-    _isDeleted = ref._isDeleted;
-    _strongRefCount = ref._strongRefCount;
-    _weakRefCount = ref._weakRefCount;
-    _mutex = ref._mutex;
-    if (_weakRefCount != nullptr) {
+    _state = ref._state;
+    if (_state != nullptr) {
       // increment new pointer
-      (*_weakRefCount)++;
+      _state->strongRefCount++;
     }
 
     return *this;
   }
 
+private:
+  // WeakReference<T> -> BorrowingReference<T> Lock-constructor
+  BorrowingReference(const WeakReference<T>& ref) : _value(ref._value), _state(ref._state) {
+    _state->strongRefCount++;
+  }
+
+private:
+  // BorrowingReference<C> -> BorrowingReference<T> Cast-constructor
+  template <typename OldT>
+  BorrowingReference(T* value, const BorrowingReference<OldT>& originalRef) : _value(value), _state(originalRef._state) {
+    _state->strongRefCount++;
+  }
+
+  template <typename C>
+  friend class BorrowingReference;
+
+public:
   ~BorrowingReference() {
-    if (_weakRefCount == nullptr) {
+    if (_state == nullptr) {
       // we are just a dangling nullptr.
       return;
     }
 
-    (*_weakRefCount)--;
-    maybeDestroy();
+    // decrement strong ref count on destroy
+    bool shouldDestroy = _state->decrementStrongRefCount();
+    if (shouldDestroy) {
+      forceDestroyValue();
+    }
+    maybeDestroyState();
+  }
+
+public:
+  /**
+   Casts this `BorrowingReference<T>` to a `BorrowingReference<C>`.
+   */
+  template <typename C>
+  BorrowingReference<C> as() {
+    return BorrowingReference<C>(static_cast<C*>(_value), *this);
+  }
+
+public:
+  /**
+   Creates an `OwningLock<T>` for the given `BorrowingReference<T>` to guarantee safe
+   safe access to `BorrowingReference<T>`.
+   Other threads (e.g. the Hermes garbage collector) cannot delete the `BorrowingReference<T>`
+   as long as the `OwningLock<T>` is still alive.
+   */
+  [[nodiscard]]
+  OwningLock<T> lock() const {
+    return OwningLock<T>(*this);
+  }
+
+  /**
+   Get whether the `BorrowingReference<T>` is still pointing to a valid value, or not.
+   */
+  inline bool hasValue() const {
+    return _value != nullptr && !_state->isDeleted;
   }
 
   /**
-   Try to lock the borrowing reference to an owning reference, or `nullptr` if it has already been deleted.
+   Get a borrowing (or "weak") reference to this owning reference
    */
   [[nodiscard]]
-  OwningReference<T> lock() const;
+  WeakReference<T> weak() const {
+    return WeakReference(*this);
+  }
+
+  /**
+   Delete and destroy the value this BorrowingReference is pointing to.
+   This can even be called if there are still multiple strong references to the value.
+
+   This will block as long as one or more `OwningLock<T>`s of this `BorrowingReference<T>` are still alive.
+   */
+  void destroy() {
+    std::unique_lock lock(_state->mutex);
+
+    forceDestroyValue();
+  }
 
 public:
-  friend class OwningReference<T>;
+  explicit inline operator bool() const {
+    return hasValue();
+  }
 
-private:
-  void maybeDestroy() {
-    _mutex->lock();
+  inline T& operator*() const {
+#ifdef NITRO_DEBUG
+    if (!hasValue()) [[unlikely]] {
+      throw std::runtime_error("Tried to dereference (*) nullptr BorrowingReference<T>!");
+    }
+#endif
+    return *_value;
+  }
+
+  inline T* operator->() const {
+#ifdef NITRO_DEBUG
+    if (!hasValue()) [[unlikely]] {
+      throw std::runtime_error("Tried to dereference (->) nullptr BorrowingReference<T>!");
+    }
+#endif
+    return _value;
+  }
+
+  inline bool operator==(T* other) const {
+    return _value == other;
+  }
+
+  inline bool operator!=(T* other) const {
+    return _value != other;
+  }
+
+  inline bool operator==(const BorrowingReference<T>& other) const {
+    return _value == other._value;
+  }
+
+  inline bool operator!=(const BorrowingReference<T>& other) const {
+    return _value != other._value;
+  }
 
-    if (*_strongRefCount == 0 && *_weakRefCount == 0) {
+private:
+  void maybeDestroyState() {
+    if (_state->strongRefCount == 0 && _state->weakRefCount == 0) {
       // free the full memory if there are no more references at all
-      if (!(*_isDeleted)) {
-        delete _value;
-      }
-      delete _isDeleted;
-      delete _strongRefCount;
-      delete _weakRefCount;
-      _mutex->unlock();
+      delete _state;
+      _state = nullptr;
       return;
     }
+  }
 
-    _mutex->unlock();
+  void forceDestroyValue() {
+    if (_state->isDeleted) [[unlikely]] {
+      // it has already been destroyed.
+      return;
+    }
+    delete _value;
+    _value = nullptr;
+    _state->isDeleted = true;
   }
 
+public:
+  friend class WeakReference<T>;
+  friend class OwningLock<T>;
+
 private:
   T* _value;
-  bool* _isDeleted;
-  std::atomic_size_t* _strongRefCount;
-  std::atomic_size_t* _weakRefCount;
-  std::recursive_mutex* _mutex;
+  ReferenceState* _state;
 };
 
 } // namespace margelo::nitro
+
+#include "WeakReference+Owning.hpp"

package/cpp/utils/NitroDefines.hpp

@@ -9,7 +9,7 @@
 #define NitroDefines_h
 
 // Sets the version of the native Nitro core library
-#define NITRO_VERSION "0.22.0"
+#define NITRO_VERSION "0.23.0"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG
@@ -52,14 +52,4 @@
 #define SWIFT_NONCOPYABLE
 #endif
 
-// React Native Support
-#if __has_include(<cxxreact/ReactNativeVersion.h>)
-#include <cxxreact/ReactNativeVersion.h>
-#endif
-#ifndef REACT_NATIVE_VERSION_MINOR
-#define REACT_NATIVE_VERSION_MAJOR 0
-#define REACT_NATIVE_VERSION_MINOR 0
-#define REACT_NATIVE_VERSION_PATCH 0
-#endif
-
 #endif /* NitroDefines_h */

package/cpp/utils/OwningLock.hpp

@@ -9,10 +9,10 @@
 
 namespace margelo::nitro {
 template <typename T>
-class OwningReference;
+class BorrowingReference;
 }
 
-#include "OwningReference.hpp"
+#include "BorrowingReference.hpp"
 #include <cstddef>
 #include <mutex>
 
@@ -20,21 +20,26 @@ namespace margelo::nitro {
 
 /**
  * An `OwningLock<T>` is a RAII instance that locks the given caller thread guaranteed safe access
- * to a `OwningReference<T>`.
- * The `OwningReference<T>` cannot be deleted while an `OwningLock<T>` of it is alive.
+ * to a `BorrowingReference<T>`.
+ * The `BorrowingReference<T>` cannot be deleted while an `OwningLock<T>` of it is alive.
  *
  * This is useful in JSI, because Hermes runs garbage collection on a separate Thread,
- * and the separate Thread can delete an `OwningReference<T>` while it's still in use.
+ * and the separate Thread can delete an `BorrowingReference<T>` while it's still in use.
  * The `OwningLock<T>` prevents exactly this problem by blocking the GC destructor until
  * the `OwningLock<T>` is released.
  *
- * To create an `OwningLock<T>`, simply call `lock()` on an `OwningReference<T>`.
+ * To create an `OwningLock<T>`, simply call `lock()` on an `BorrowingReference<T>`.
  */
 template <typename T>
 class OwningLock final {
+private:
+  explicit OwningLock(const BorrowingReference<T>& reference) : _reference(reference) {
+    _reference._state->mutex.lock();
+  }
+
 public:
   ~OwningLock() {
-    _reference._mutex->unlock();
+    _reference._state->mutex.unlock();
   }
 
   OwningLock() = delete;
@@ -42,15 +47,10 @@ public:
   OwningLock(OwningLock&&) = delete;
 
 private:
-  explicit OwningLock(const OwningReference<T>& reference) : _reference(reference) {
-    _reference._mutex->lock();
-  }
-
-private:
-  OwningReference<T> _reference;
+  BorrowingReference<T> _reference;
 
 private:
-  friend class OwningReference<T>;
+  friend class BorrowingReference<T>;
 };
 
 } // namespace margelo::nitro