react-native-nitro-modules 0.20.0 → 0.20.1

package/android/src/main/cpp/core/JArrayBuffer.hpp

@@ -38,8 +38,7 @@ public:
   /**
    * Create a new `JArrayBuffer` that wraps the given `ByteBuffer` from Java.
    */
-  static jni::local_ref<JArrayBuffer::jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis,
-                                                              jni::alias_ref<jni::JByteBuffer> buffer) {
+  static jni::local_ref<JArrayBuffer::jhybriddata> initHybrid(jni::alias_ref<jhybridobject>, jni::alias_ref<jni::JByteBuffer> buffer) {
     return makeCxxInstance(buffer);
   }
 

package/android/src/main/cpp/core/JPromise.hpp

@@ -56,6 +56,16 @@ public:
     return newObjectCxxArgs();
   }
 
+public:
+  ~JPromise() override {
+    if (_result == nullptr && _error == nullptr) [[unlikely]] {
+      jni::ThreadScope::WithClassLoader([&]() {
+        std::runtime_error error("Timeouted: JPromise was destroyed!");
+        this->reject(jni::getJavaExceptionForCppException(std::make_exception_ptr(error)));
+      });
+    }
+  }
+
 public:
   void resolve(jni::alias_ref<jni::JObject> result) {
     std::unique_lock lock(_mutex);

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

@@ -12,7 +12,7 @@
 
 namespace margelo::nitro {
 
-void JHybridObjectRegistry::registerHybridObjectConstructor(jni::alias_ref<jni::JClass> clazz, std::string hybridObjectName,
+void JHybridObjectRegistry::registerHybridObjectConstructor(jni::alias_ref<jni::JClass>, std::string hybridObjectName,
                                                             jni::alias_ref<JHybridObjectInitializer> constructorFn) {
   auto sharedInitializer = jni::make_global(constructorFn);
   HybridObjectRegistry::registerHybridObjectConstructor(

package/android/src/main/cpp/utils/JNISharedPtr.hpp

@@ -15,7 +15,7 @@ template <typename T>
 struct GlobalRefDeleter {
   explicit GlobalRefDeleter(jni::global_ref<typename T::javaobject> ref) : _ref(ref) {}
 
-  void operator()(T* ptr) {
+  void operator()(T* /* cthis */) {
     if (_ref) {
       _ref.release();
     }

package/cpp/core/BoxedHybridObject.cpp

@@ -19,8 +19,9 @@ jsi::Value BoxedHybridObject::get(jsi::Runtime& runtime, const jsi::PropNameID&
   if (name == "unbox") {
     return jsi::Function::createFromHostFunction(
         runtime, jsi::PropNameID::forUtf8(runtime, "unbox"), 0,
-        [hybridObject = _hybridObject](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args,
-                                       size_t count) -> jsi::Value { return hybridObject->toObject(runtime); });
+        [hybridObject = _hybridObject](jsi::Runtime& runtime, const jsi::Value&, const jsi::Value*, size_t) -> jsi::Value {
+          return hybridObject->toObject(runtime);
+        });
   }
 
   return jsi::Value::undefined();

package/cpp/core/HybridObject.cpp

@@ -23,7 +23,7 @@ bool HybridObject::equals(std::shared_ptr<HybridObject> other) {
   return this == other.get();
 }
 
-jsi::Value HybridObject::disposeRaw(jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) {
+jsi::Value HybridObject::disposeRaw(jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value*, size_t) {
   // 1. Dispose any resources - this might be overridden by child classes to perform manual cleanup.
   dispose();
   // 2. Remove the NativeState from `this`

package/cpp/core/Promise.hpp

@@ -32,6 +32,14 @@ public:
 private:
   Promise() {}
 
+public:
+  ~Promise() {
+    if (isPending()) [[unlikely]] {
+      auto message = std::string("Timeouted: Promise<") + TypeInfo::getFriendlyTypename<TResult>() + "> was destroyed!";
+      reject(std::make_exception_ptr(std::runtime_error(message)));
+    }
+  }
+
 public:
   /**
    * Creates a new pending Promise that has to be resolved
@@ -258,6 +266,14 @@ public:
 private:
   Promise() {}
 
+public:
+  ~Promise() {
+    if (isPending()) [[unlikely]] {
+      std::runtime_error error("Timeouted: Promise<void> was destroyed!");
+      reject(std::make_exception_ptr(std::move(error)));
+    }
+  }
+
 public:
   static std::shared_ptr<Promise> create() {
     return std::shared_ptr<Promise>(new Promise());

package/cpp/jsi/JSIConverter+Function.hpp

@@ -68,8 +68,8 @@ struct JSIConverter<std::function<ReturnType(Args...)>> final {
   }
 
   static inline jsi::Value toJSI(jsi::Runtime& runtime, std::function<ReturnType(Args...)>&& function) {
-    jsi::HostFunctionType jsFunction = [function = std::move(function)](jsi::Runtime& runtime, const jsi::Value& thisValue,
-                                                                        const jsi::Value* args, size_t count) -> jsi::Value {
+    jsi::HostFunctionType jsFunction = [function = std::move(function)](jsi::Runtime& runtime, const jsi::Value&, const jsi::Value* args,
+                                                                        size_t count) -> jsi::Value {
       if (count != sizeof...(Args)) [[unlikely]] {
         throw jsi::JSError(runtime, "Function expected " + std::to_string(sizeof...(Args)) + " arguments, but received " +
                                         std::to_string(count) + "!");
@@ -95,9 +95,6 @@ struct JSIConverter<std::function<ReturnType(Args...)>> final {
 
 private:
   static inline ResultingType callJSFunction(jsi::Runtime& runtime, const OwningReference<jsi::Function>& function, const Args&... args) {
-    // Throw a lock on the OwningReference<T> so we can guarantee safe access (Hermes GC cannot delete it while `lock` is alive)
-    OwningLock<jsi::Function> lock = function.lock();
-
     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+Promise.hpp

@@ -52,8 +52,8 @@ struct JSIConverter<std::shared_ptr<Promise<TResult>>> final {
     if (promise->isPending()) {
       // Get Promise ctor from global
       jsi::Function promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
-      jsi::HostFunctionType executor = [promise](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
-                                                 size_t count) -> jsi::Value {
+      jsi::HostFunctionType executor = [promise](jsi::Runtime& runtime, const jsi::Value&, const jsi::Value* arguments,
+                                                 size_t) -> jsi::Value {
         // Add resolver listener
         if constexpr (std::is_void_v<TResult>) {
           // It's resolving to void.

package/cpp/prototype/HybridObjectPrototype.hpp

@@ -79,7 +79,7 @@ protected:
    * **Do not conditionally register hybrid methods, getters or setter!**
    */
   template <typename Derived>
-  inline void registerHybrids(Derived* thisInstance, RegisterFn registerFunc) {
+  inline void registerHybrids(Derived* /* this */, RegisterFn registerFunc) {
     const std::shared_ptr<Prototype>& prototype = _prototypeChain.extendPrototype<Derived>();
 
     if (!prototype->hasHybrids()) {

package/cpp/threading/Dispatcher.cpp

@@ -1,3 +1,10 @@
+//
+//  Dispatcher.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
 #include "Dispatcher.hpp"
 #include "JSIHelpers.hpp"
 #include "NitroDefines.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.20.0"
+#define NITRO_VERSION "0.20.1"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG

package/ios/core/ArrayBufferHolder.swift

@@ -50,7 +50,7 @@ public extension ArrayBufferHolder {
   /**
    * Copy the given `ArrayBufferHolder` into a new **owning** `ArrayBufferHolder`.
    */
-  static func copy(of other: borrowing ArrayBufferHolder) -> ArrayBufferHolder {
+  static func copy(of other: ArrayBufferHolder) -> ArrayBufferHolder {
     let data = UnsafeMutablePointer<UInt8>.allocate(capacity: other.size)
     let pointer = other.data.assumingMemoryBound(to: UInt8.self)
     data.initialize(from: pointer, count: other.size)

package/ios/core/Promise.swift

@@ -37,7 +37,8 @@ public final class Promise<T> {
 
   deinit {
     if state == nil {
-      print("⚠️ Promise<\(String(describing: T.self))> got destroyed, but was never resolved or rejected! It is probably left hanging in JS now.")
+      let message = "Timeouted: Promise<\(String(describing: T.self))> was destroyed!"
+      reject(withError: RuntimeError.error(withMessage: message))
     }
   }
 

package/ios/core/RuntimeError.swift

@@ -26,7 +26,7 @@ public enum RuntimeError: Error, CustomStringConvertible {
    * Creates a new `RuntimeError` from the given C++ `std::exception`.
    */
   public static func from(cppError: std.exception_ptr) -> RuntimeError {
-    let message = margelo.nitro.get_exception_message(cppError)
+    let message = margelo.nitro.getExceptionMessage(cppError)
     return .error(withMessage: String(message))
   }
 }
@@ -37,6 +37,6 @@ public extension Error {
    */
   func toCpp() -> std.exception_ptr {
     let message = String(describing: self)
-    return margelo.nitro.make_exception(std.string(message))
+    return margelo.nitro.makeException(std.string(message))
   }
 }

package/ios/utils/RuntimeError.hpp

@@ -13,11 +13,11 @@
 
 namespace margelo::nitro {
 
-static inline std::exception_ptr make_exception(const std::string& message) {
+static inline std::exception_ptr makeException(const std::string& message) {
   return std::make_exception_ptr(std::runtime_error(message));
 }
 
-static inline std::string get_exception_message(const std::exception_ptr& exception) {
+static inline std::string getExceptionMessage(const std::exception_ptr& exception) {
   if (exception == nullptr) [[unlikely]] {
     throw std::runtime_error("Cannot get error message of an empty exception_ptr!");
   }

package/package.json

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