react-native-nitro-modules 0.1.4 → 0.1.6

package/cpp/core/ArrayBuffer.hpp

@@ -7,8 +7,10 @@
 
 #pragma once
 
+#include "OwningReference.hpp"
 #include <functional>
 #include <jsi/jsi.h>
+#include <thread>
 
 namespace margelo::nitro {
 
@@ -23,50 +25,76 @@ static DeleteFn defaultDeleteFn = [](uint8_t* buffer) { delete[] buffer; };
  * written to- from both JavaScript and C++.
  * `ArrayBuffer` is not thread-safe and does not lock multi-thread access.
  *
- * Also, if `ArrayBuffer` is coming from JS, it is not safe to keep a strong
- * reference on `ArrayBuffer` as C++ does not own the data (`isOwner() == false`) -
- * it can be deleted at any point without C++ knowing about it.
+ * `ArrayBuffer` can either be a `JSArrayBuffer`, or a `NativeArrayBuffer`.
+ * - `NativeArrayBuffer`: Created from native (C++), and can either own the memory (`isOwner()`), or borrow it.
+ * - `JSArrayBuffer`: Received from JS, and will only be alive for as long as the JS Runtime is actually alive.
  *
- * Only if C++ creates the `ArrayBuffer` a reference to it can be safely
- * kept in memory, as C++ is then the owner of `ArrayBuffer` (`isOwner() == true`).
+ * Also, an `ArrayBuffer` can either own it's memory, or just borrow it's memory.
+ * - Owning = the `ArrayBuffer`'s `data()` is alive as long as the `ArrayBuffer` is alive.
+ *   When this `ArrayBuffer` gets deleted, it will free the memory.
+ * - Borrowed = the `ArrayBuffer`'s `data()` might be deleted at any point from an external source (e.g. the JS garbage collector).
+ *   When this `ArrayBuffer` gets deleted, the memory will not be freed explicitly, as someone else owns it.
  */
 class ArrayBuffer : public jsi::MutableBuffer {
+public:
+  ArrayBuffer() = default;
+  ArrayBuffer(const ArrayBuffer&) = delete;
+  ArrayBuffer(ArrayBuffer&&) = delete;
+  virtual ~ArrayBuffer() = default;
+
+public:
+  /**
+   * Returns whether this `ArrayBuffer` is actually owning the data,
+   * or if it is just borrowed from an external source (either a native
+   * memory that we didn't allocate, or from JS - which can be deleted at any point).
+   */
+  virtual bool isOwner() const noexcept = 0;
+};
+
+/**
+ * Represents an `ArrayBuffer` that is allocated on the native (C++) side.
+ * It can either be "owning" or "borrowing".
+ *
+ * - Owning = the `ArrayBuffer`'s `data()` is alive as long as the `ArrayBuffer` is alive.
+ *   When this `ArrayBuffer` gets deleted, it will free the memory.
+ * - Borrowed = the `ArrayBuffer`'s `data()` might be deleted at any point from an external source (e.g. the JS garbage collector).
+ *   When this `ArrayBuffer` gets deleted, the memory will not be freed explicitly, as someone else owns it.
+ *
+ * It is safe to access `data()` and `size()` from any Thread, but there are no synchronization/mutexes implemented by default.
+ */
+class NativeArrayBuffer : public ArrayBuffer {
 public:
   /**
    * Create a new **owning** `ArrayBuffer`.
    * The `ArrayBuffer` can be kept in memory, as C++ owns the data
    * and will only delete it once this `ArrayBuffer` gets deleted
    */
-  ArrayBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc) : _data(data), _size(size), _deleteFunc(std::move(deleteFunc)) {}
+  NativeArrayBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc)
+      : ArrayBuffer(), _data(data), _size(size), _deleteFunc(std::move(deleteFunc)) {}
   /**
    * Create a new `ArrayBuffer`.
    * If `destroyOnDeletion` is `true`, the `ArrayBuffer` is **owning**, otherwise it is **non-owning**.
    * The `ArrayBuffer` can only be safely kept in memory if it is owning (`isOwning()`).
    */
-  ArrayBuffer(uint8_t* data, size_t size, bool destroyOnDeletion) : _data(data), _size(size) {
+  NativeArrayBuffer(uint8_t* data, size_t size, bool destroyOnDeletion) : ArrayBuffer(), _data(data), _size(size) {
     _deleteFunc = destroyOnDeletion ? defaultDeleteFn : nullptr;
   }
 
-  // ArrayBuffer cannot be copied
-  ArrayBuffer(const ArrayBuffer&) = delete;
-  // ArrayBuffer cannot be moved
-  ArrayBuffer(ArrayBuffer&&) = delete;
-
-  ~ArrayBuffer() {
+  ~NativeArrayBuffer() {
     if (_deleteFunc != nullptr) {
       _deleteFunc(_data);
     }
   }
 
-  uint8_t* data() noexcept override {
+  uint8_t* data() override {
     return _data;
   }
 
-  size_t size() const noexcept override {
+  size_t size() const override {
     return _size;
   }
 
-  bool isOwner() const noexcept {
+  bool isOwner() const noexcept override {
     return _deleteFunc != nullptr;
   }
 
@@ -76,4 +104,68 @@ private:
   DeleteFn _deleteFunc;
 };
 
+/**
+ * Represents a JS-based `ArrayBuffer`.
+ *
+ * While it's underlying data might have been allocated on the native side (`NativeArrayBuffer`),
+ * we only have a JS reference to the `ArrayBuffer` object so it is considered a "borrowed"-resource.
+ *
+ * `data()` and `size()` can only be accessed synchronously on the JS Runtime Thread.
+ * If you want to access it elsewhere, copy the buffer first.
+ *
+ * If the JS ArrayBuffer (or it's JS Runtime) have already been deleted, `data()` returns `nullptr`.
+ */
+class JSArrayBuffer : public ArrayBuffer {
+public:
+  explicit JSArrayBuffer(jsi::Runtime* runtime, OwningReference<jsi::ArrayBuffer> jsReference)
+      : ArrayBuffer(), _runtime(runtime), _jsReference(jsReference), _initialThreadId(std::this_thread::get_id()) {}
+  ~JSArrayBuffer() {}
+
+public:
+  /**
+   * Gets the data this `ArrayBuffer` points to, or `nullptr` if it has already been deleted.
+   */
+  uint8_t* data() override {
+    if (_initialThreadId != std::this_thread::get_id()) [[unlikely]] {
+      throw std::runtime_error("`data()` can only be accessed synchronously on the JS Thread! "
+                               "If you want to access it elsewhere, copy it first.");
+    }
+
+    OwningLock<jsi::ArrayBuffer> lock = _jsReference.lock();
+    if (!_jsReference) [[unlikely]] {
+      // JS Part has been deleted - data is now nullptr.
+      return nullptr;
+    }
+    // JS Part is still alive - we can assume that the jsi::Runtime is safe to access here too.
+    return _jsReference->data(*_runtime);
+  }
+
+  /**
+   * Gets the size of the data this `ArrayBuffer` points to, or `0` if it has already been deleted.
+   */
+  size_t size() const override {
+    if (_initialThreadId != std::this_thread::get_id()) [[unlikely]] {
+      throw std::runtime_error("`size()` can only be accessed synchronously on the JS Thread! "
+                               "If you want to access it elsewhere, copy it first.");
+    }
+
+    OwningLock<jsi::ArrayBuffer> lock = _jsReference.lock();
+    if (!_jsReference) [[unlikely]] {
+      // JS Part has been deleted - size is now 0.
+      return 0;
+    }
+    // JS Part is still alive - we can assume that the jsi::Runtime is safe to access here too.
+    return _jsReference->size(*_runtime);
+  }
+
+  bool isOwner() const noexcept override {
+    return false;
+  }
+
+private:
+  jsi::Runtime* _runtime;
+  OwningReference<jsi::ArrayBuffer> _jsReference;
+  std::thread::id _initialThreadId;
+};
+
 } // namespace margelo::nitro

package/cpp/core/HybridObject.cpp

@@ -99,7 +99,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   }
 
   // 2. There is either no value in cache, or it's already dead. Create a new one
-  auto cache = JSICache<jsi::Object>::getOrCreateCache(runtime);
+  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);
@@ -107,7 +107,7 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   size_t memorySize = getTotalExternalMemorySize();
   object.setExternalMemoryPressure(runtime, memorySize);
   // 5. Make it a global (weak) reference
-  auto global = cache.makeGlobal(std::move(object));
+  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);
@@ -177,12 +177,12 @@ jsi::Value HybridObject::get(facebook::jsi::Runtime& runtime, const facebook::js
     // 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<jsi::Function>::getOrCreateCache(runtime);
+    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(std::move(function));
+    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);

package/cpp/jsi/JSICache.cpp

@@ -0,0 +1,55 @@
+//
+//  JSICache.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.06.24.
+//
+
+#include "JSICache.hpp"
+
+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();
+    if (owning) {
+      // Destroy all functions that we might still have in cache, some callbacks and Promises may now become invalid.
+      owning.destroy();
+    }
+  }
+}
+
+JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
+  auto found = _globalCache.find(&runtime);
+  if (found != _globalCache.end()) {
+    // 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();
+    if (strong) {
+      // It's still alive! Return it
+      return JSICacheReference(strong);
+    }
+    Logger::log(TAG, "JSICache was created, but it is no longer strong!");
+  }
+
+  // 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);
+  // Wrap it in a jsi::Value using NativeState
+  jsi::Object cache(runtime);
+  cache.setNativeState(runtime, nativeState);
+  // Inject it into the jsi::Runtime's global so it's memory is managed by it
+  runtime.global().setProperty(runtime, CACHE_PROP_NAME, std::move(cache));
+  // Add it to our map of caches
+  _globalCache[&runtime] = nativeState;
+  // Return it
+  return JSICacheReference(nativeState);
+}
+
+} // namespace margelo::nitro

package/cpp/jsi/JSICache.hpp

@@ -21,73 +21,23 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-static constexpr auto CACHE_PROP_NAME = "__nitroModulesJSICache";
-
-template <typename T>
-class JSICache;
-
-template <typename T>
-class JSICacheReference final {
-public:
-  JSICacheReference() = delete;
-  JSICacheReference(const JSICacheReference&) = delete;
-  JSICacheReference(JSICacheReference&&) = delete;
-
-  ~JSICacheReference() {
-    _strongCache->_mutex.unlock();
-  }
-
-public:
-  /**
-   Creates a reference to a `jsi::Value` that can be stored in memory and accessed later.
-   The `jsi::Value` will be managed by the `jsi::Runtime`, if the `jsi::Runtime` gets the destroyed,
-   so will the `jsi::Value`.
-
-   To access the `jsi::Value`, try to `.lock()` the `weak_ptr`.
-   If it can be locked, it is still valid, otherwise the Runtime has already been deleted.
-   Do not hold the returned `shared_ptr` in memory, only use it in the calling function's scope.
-   Note: By design, this is not thread-safe, the returned `weak_ptr` must only be locked on the same thread as it was created on.
-   */
-  OwningReference<T> makeGlobal(T&& value) {
-    auto owning = OwningReference<T>(new T(std::move(value)));
-    _strongCache->_cache.push_back(owning.weak());
-    return owning;
-  }
-
-private:
-  explicit JSICacheReference(const std::shared_ptr<JSICache<T>>& cache) : _strongCache(cache) {
-    _strongCache->_mutex.lock();
-  }
-
-private:
-  std::shared_ptr<JSICache<T>> _strongCache;
-
-  friend class JSICache<T>;
-};
+class JSICacheReference;
 
 /**
- * A `JSICache` can safely store `jsi::Pointer` instances (e.g. `jsi::Object` or
+ * A `JSICache` can safely store `jsi::Object` instances (e.g. `jsi::Object` or
  * `jsi::Function`) inside `OwningReference<T>`.
  *
- * `jsi::Pointer`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::Pointer`.
+ * `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`.
+ *
+ * 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,
+ * and `JSICache` will hold any garbage collection calls until the `OwningLock` is destroyed.
  */
-template <typename T = jsi::Pointer>
 class JSICache final : public jsi::NativeState {
 public:
   explicit JSICache(jsi::Runtime* runtime) : _runtime(runtime) {}
-
-  ~JSICache() {
-    std::unique_lock lock(_mutex);
-
-    for (auto& func : _cache) {
-      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();
-      }
-    }
-  }
+  ~JSICache();
 
 public:
   JSICache() = delete;
@@ -102,47 +52,61 @@ public:
    Do not hold the returned `shared_ptr` in memory, only use it in the calling function's scope.
    */
   [[nodiscard]]
-  static JSICacheReference<T> getOrCreateCache(jsi::Runtime& runtime) {
-    auto found = _globalCache.find(&runtime);
-    if (found != _globalCache.end()) {
-      // Fast path: get weak_ptr to JSICache from our global list.
-      std::weak_ptr<JSICache<T>> weak = found->second;
-      std::shared_ptr<JSICache<T>> strong = weak.lock();
-      if (strong) {
-        // It's still alive! Return it
-        return JSICacheReference<T>(strong);
-      }
-    }
-
-    // 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<T>>(&runtime);
-    // Wrap it in a jsi::Value using NativeState
-    jsi::Object cache(runtime);
-    cache.setNativeState(runtime, nativeState);
-    // Inject it into the jsi::Runtime's global so it's memory is managed by it
-    runtime.global().setProperty(runtime, CACHE_PROP_NAME, std::move(cache));
-    // Add it to our map of caches
-    _globalCache[&runtime] = nativeState;
-    // Return it
-    return JSICacheReference<T>(nativeState);
-  }
+  static JSICacheReference getOrCreateCache(jsi::Runtime& runtime);
 
-public:
 private:
-  friend class JSICacheReference<T>;
+  friend class JSICacheReference;
 
 private:
   jsi::Runtime* _runtime;
   std::mutex _mutex;
-  std::vector<BorrowingReference<T>> _cache;
+  std::vector<BorrowingReference<jsi::Object>> _cache;
 
 private:
-  static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache<T>>> _globalCache;
+  static inline std::unordered_map<jsi::Runtime*, std::weak_ptr<JSICache>> _globalCache;
 
 private:
   static constexpr auto TAG = "JSICache";
 };
 
+class JSICacheReference final {
+public:
+  JSICacheReference() = delete;
+  JSICacheReference(const JSICacheReference&) = delete;
+  JSICacheReference(JSICacheReference&&) = delete;
+
+  ~JSICacheReference() {
+    _strongCache->_mutex.unlock();
+  }
+
+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>();
+  }
+
+private:
+  explicit JSICacheReference(const std::shared_ptr<JSICache>& cache) : _strongCache(cache) {
+    _strongCache->_mutex.lock();
+  }
+
+private:
+  std::shared_ptr<JSICache> _strongCache;
+
+  friend class JSICache;
+};
+
 } // namespace margelo::nitro

package/cpp/jsi/JSIConverter+AnyMap.hpp

@@ -13,8 +13,8 @@ template <typename T, typename Enable>
 struct JSIConverter;
 } // namespace margelo::nitro
 
-#include "JSIConverter.hpp"
 #include "JSIConverter+Variant.hpp"
+#include "JSIConverter.hpp"
 
 #include "AnyMap.hpp"
 #include <jsi/jsi.h>

package/cpp/jsi/JSIConverter+ArrayBuffer.hpp

@@ -7,6 +7,7 @@
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
 class ArrayBuffer;
+class JSICache;
 
 template <typename T, typename Enable>
 struct JSIConverter;
@@ -15,25 +16,31 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 
 #include "ArrayBuffer.hpp"
+#include "IsSharedPtrTo.hpp"
+#include "JSICache.hpp"
 #include <jsi/jsi.h>
 #include <memory>
+#include <type_traits>
 
 namespace margelo::nitro {
 
 using namespace facebook;
 
 // MutableBuffer <> ArrayBuffer
-template <>
-struct JSIConverter<std::shared_ptr<jsi::MutableBuffer>> {
+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 (!object.isArrayBuffer(runtime)) [[unlikely]] {
       throw std::runtime_error("Object \"" + arg.toString(runtime).utf8(runtime) + "\" is not an ArrayBuffer!");
     }
-    jsi::ArrayBuffer arrayBuffer = object.getArrayBuffer(runtime);
-    return std::make_shared<ArrayBuffer>(arrayBuffer.data(runtime), arrayBuffer.size(runtime), false);
+
+    JSICacheReference cache = JSICache::getOrCreateCache(runtime);
+    auto owningArrayBuffer = cache.makeGlobal<jsi::ArrayBuffer>(object.getArrayBuffer(runtime));
+
+    return std::make_shared<JSArrayBuffer>(&runtime, owningArrayBuffer);
   }
-  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::shared_ptr<jsi::MutableBuffer> buffer) {
+  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

@@ -6,7 +6,6 @@
 
 // Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
-template <typename T>
 class JSICache;
 
 template <typename T, typename Enable>
@@ -34,9 +33,9 @@ struct JSIConverter<std::function<ReturnType(Args...)>> {
 
   static inline std::function<ReturnType(Args...)> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     // Make function global - it'll be managed by the Runtime's memory, and we only have a weak_ref to it.
-    auto cache = JSICache<jsi::Function>::getOrCreateCache(runtime);
+    auto cache = JSICache::getOrCreateCache(runtime);
     jsi::Function function = arg.asObject(runtime).asFunction(runtime);
-    OwningReference<jsi::Function> sharedFunction = cache.makeGlobal(std::move(function));
+    OwningReference<jsi::Function> sharedFunction = cache.makeGlobal<jsi::Function>(std::move(function));
 
     std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
     std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;

package/cpp/jsi/JSIConverter+HybridObject.hpp

@@ -15,8 +15,7 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 
 #include "HybridObject.hpp"
-#include "IsHostObject.hpp"
-#include "IsNativeState.hpp"
+#include "IsSharedPtrTo.hpp"
 #include "TypeInfo.hpp"
 #include <jsi/jsi.h>
 #include <memory>
@@ -30,7 +29,7 @@ using namespace facebook;
 
 // HybridObject <> {}
 template <typename T>
-struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_host_object_v<T>>> {
+struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::HostObject>>> {
   using TPointee = typename T::element_type;
 
   static inline T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
@@ -45,6 +44,10 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_host_object_v<T>>> {
 #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>!"));
@@ -78,7 +81,7 @@ private:
 
 // NativeState <> {}
 template <typename T>
-struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_native_state_v<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) {
@@ -93,6 +96,10 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_native_state_v<T>>> {
 #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!"));
+    }
     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>!"));

package/cpp/jsi/JSIConverter+Variant.hpp

@@ -13,9 +13,9 @@ template <typename T, typename Enable>
 struct JSIConverter;
 } // namespace margelo::nitro
 
-#include "JSIConverter.hpp"
-#include "JSIConverter+Vector.hpp"
 #include "JSIConverter+UnorderedMap.hpp"
+#include "JSIConverter+Vector.hpp"
+#include "JSIConverter.hpp"
 
 #include "AnyMap.hpp"
 #include "IsInPack.hpp"

package/cpp/jsi/Promise.cpp

@@ -8,9 +8,9 @@ namespace margelo::nitro {
 using namespace facebook;
 
 Promise::Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter) {
-  auto functionCache = JSICache<jsi::Function>::getOrCreateCache(runtime);
-  _resolver = functionCache.makeGlobal(std::move(resolver));
-  _rejecter = functionCache.makeGlobal(std::move(rejecter));
+  auto functionCache = JSICache::getOrCreateCache(runtime);
+  _resolver = functionCache.makeGlobal<jsi::Function>(std::move(resolver));
+  _rejecter = functionCache.makeGlobal<jsi::Function>(std::move(rejecter));
 }
 
 jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
@@ -35,6 +35,8 @@ jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise&& run) {
 }
 
 void Promise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
+  OwningLock<jsi::Function> lock = _resolver.lock();
+
   if (!_resolver) {
     Logger::log(TAG, "Promise resolver function has already been deleted! Ignoring call..");
     return;
@@ -43,6 +45,8 @@ void Promise::resolve(jsi::Runtime& runtime, jsi::Value&& result) {
 }
 
 void Promise::reject(jsi::Runtime& runtime, std::string message) {
+  OwningLock<jsi::Function> lock = _rejecter.lock();
+
   if (!_rejecter) {
     Logger::log(TAG, "Promise rejecter function has already been deleted! Ignoring call..");
     return;

package/cpp/templates/IsSharedPtrTo.hpp

@@ -0,0 +1,28 @@
+//
+//  IsSharedPtrTo.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// Returns whether the given type T is a shared_ptr to type P.
+template <typename T, typename P>
+struct is_shared_ptr_to : std::false_type {};
+
+template <typename T, typename P>
+struct is_shared_ptr_to<std::shared_ptr<T>, P> : std::is_base_of<typename std::remove_cv<typename std::remove_reference<P>::type>::type,
+                                                                 typename std::remove_cv<typename std::remove_reference<T>::type>::type> {};
+
+template <typename T, typename P>
+constexpr bool is_shared_ptr_to_v = is_shared_ptr_to<T, P>::value;
+
+} // namespace margelo::nitro

package/cpp/utils/OwningReference.hpp

@@ -76,12 +76,25 @@ public:
   }
 
 private:
+  // BorrowingReference<T> -> OwningReference<T> Lock-constructor
   OwningReference(const BorrowingReference<T>& ref)
       : _value(ref._value), _isDeleted(ref._isDeleted), _strongRefCount(ref._strongRefCount), _weakRefCount(ref._weakRefCount),
         _mutex(ref._mutex) {
     (*_strongRefCount)++;
   }
 
+private:
+  // OwningReference<C> -> OwningReference<T> Cast-constructor
+  template <typename OldT>
+  OwningReference(T* value, const OwningReference<OldT>& originalRef)
+      : _value(value), _isDeleted(originalRef._isDeleted), _strongRefCount(originalRef._strongRefCount),
+        _weakRefCount(originalRef._weakRefCount), _mutex(originalRef._mutex) {
+    (*_strongRefCount)++;
+  }
+
+  template <typename C>
+  friend class OwningReference;
+
 public:
   ~OwningReference() {
     if (_strongRefCount == nullptr) {
@@ -94,6 +107,15 @@ public:
     maybeDestroy();
   }
 
+public:
+  /**
+   Casts this `OwningReference<T>` to a `OwningReference<C>`.
+   */
+  template <typename C>
+  OwningReference<C> as() {
+    return OwningReference<C>(static_cast<C*>(_value), *this);
+  }
+
 public:
   /**
    Creates an `OwningLock<T>` for the given `OwningReference<T>` to guarantee safe

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/index",
   "module": "lib/index",

package/cpp/templates/IsHostObject.hpp

@@ -1,27 +0,0 @@
-//
-//  BorrowingReference.hpp
-//  NitroModules
-//
-//  Created by Marc Rousavy on 21.06.24.
-//
-
-#pragma once
-
-#include <jsi/jsi.h>
-#include <type_traits>
-
-namespace margelo::nitro {
-
-using namespace facebook;
-
-// Returns whether the given type `T` is a `shared_ptr` to a `HostObject`
-template <typename T>
-struct is_shared_ptr_to_host_object : std::false_type {};
-
-template <typename T>
-struct is_shared_ptr_to_host_object<std::shared_ptr<T>> : std::is_base_of<jsi::HostObject, T> {};
-
-template <typename T>
-inline constexpr bool is_shared_ptr_to_host_object_v = is_shared_ptr_to_host_object<std::remove_reference_t<T>>::value;
-
-} // namespace margelo::nitro

package/cpp/templates/IsNativeState.hpp

@@ -1,27 +0,0 @@
-//
-//  BorrowingReference.hpp
-//  NitroModules
-//
-//  Created by Marc Rousavy on 21.06.24.
-//
-
-#pragma once
-
-#include <jsi/jsi.h>
-#include <type_traits>
-
-namespace margelo::nitro {
-
-using namespace facebook;
-
-// Returns whether the given type `T` is a `shared_ptr` to a `NativeStaet`
-template <typename T>
-struct is_shared_ptr_to_native_state : std::false_type {};
-
-template <typename T>
-struct is_shared_ptr_to_native_state<std::shared_ptr<T>> : std::is_base_of<jsi::NativeState, T> {};
-
-template <typename T>
-inline constexpr bool is_shared_ptr_to_native_state_v = is_shared_ptr_to_native_state<std::remove_reference_t<T>>::value;
-
-} // namespace margelo::nitro