react-native-nitro-modules 0.20.0 → 0.21.0

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/android/src/main/java/com/margelo/nitro/core/ArrayBuffer.kt

@@ -107,19 +107,40 @@ class ArrayBuffer {
         /**
          * Copy the given `ArrayBuffer` into a new **owning** `ArrayBuffer`.
          */
-        fun copyOf(other: ArrayBuffer): ArrayBuffer {
-            // 1. Create a new buffer with the same size as the other
-            val newBuffer = ByteBuffer.allocateDirect(other.size)
-            // 2. Prepare the source buffer
-            val originalBuffer = other.getBuffer(false)
-            originalBuffer.rewind()
+        fun copy(other: ArrayBuffer): ArrayBuffer {
+            val byteBuffer = other.getBuffer(false)
+            return copy(byteBuffer)
+        }
+
+        /**
+         * Copy the given `ByteBuffer` into a new **owning** `ArrayBuffer`.
+         */
+        fun copy(byteBuffer: ByteBuffer): ArrayBuffer {
+            // 1. Find out size
+            byteBuffer.rewind()
+            val size = byteBuffer.remaining()
+            // 2. Create a new buffer with the same size as the other
+            val newBuffer = ByteBuffer.allocateDirect(size)
             // 3. Copy over the source buffer into the new buffer
-            newBuffer.put(originalBuffer)
+            newBuffer.put(byteBuffer)
             // 4. Rewind both buffers again to index 0
             newBuffer.rewind()
-            originalBuffer.rewind()
+            byteBuffer.rewind()
             // 5. Create a new `ArrayBuffer`
             return ArrayBuffer(newBuffer)
         }
+
+        /**
+         * Wrap the given `ByteBuffer` in a new **owning** `ArrayBuffer`.
+         */
+        fun wrap(byteBuffer: ByteBuffer): ArrayBuffer {
+            byteBuffer.rewind()
+            return ArrayBuffer(byteBuffer)
+        }
+
+        @Deprecated("Use copy(...) instead", level = DeprecationLevel.WARNING)
+        fun copyOf(other: ArrayBuffer): ArrayBuffer {
+            return copy(other)
+        }
     }
 }

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

@@ -23,7 +23,7 @@ abstract class HybridObject: ExtendableHybridClass {
      *
      * @example
      * ```kotlin
-     * val memorySize: ULong
+     * override val memorySize: ULong
      *   get() {
      *     val imageSize = this.bitmap.bytesPerRow * this.bitmap.height
      *     return imageSize

package/cpp/core/ArrayBuffer.cpp

@@ -17,10 +17,25 @@ using namespace facebook;
 
 // 1. ArrayBuffer
 
-std::shared_ptr<ArrayBuffer> ArrayBuffer::makeBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc) {
+std::shared_ptr<ArrayBuffer> ArrayBuffer::wrap(uint8_t* data, size_t size, DeleteFn&& deleteFunc) {
   return std::make_shared<NativeArrayBuffer>(data, size, std::move(deleteFunc));
 }
 
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(uint8_t* data, size_t size) {
+  uint8_t* copy = new uint8_t[size];
+  std::memcpy(copy, data, size);
+  return ArrayBuffer::wrap(copy, size, [=]() { delete[] copy; });
+}
+
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(std::vector<uint8_t>& data) {
+  return ArrayBuffer::copy(data.data(), data.size());
+}
+
+std::shared_ptr<ArrayBuffer> ArrayBuffer::allocate(size_t size) {
+  uint8_t* data = new uint8_t[size];
+  return ArrayBuffer::wrap(data, size, [=]() { delete[] data; });
+}
+
 // 2. NativeArrayBuffer
 
 NativeArrayBuffer::NativeArrayBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc)

package/cpp/core/ArrayBuffer.hpp

@@ -10,6 +10,7 @@
 #include "OwningReference.hpp"
 #include <jsi/jsi.h>
 #include <thread>
+#include <vector>
 
 namespace margelo::nitro {
 
@@ -52,7 +53,25 @@ public:
    * Create a new `NativeArrayBuffer` that wraps the given data (without copy) of the given size,
    * and calls `deleteFunc` in which `data` should be deleted.
    */
-  static std::shared_ptr<ArrayBuffer> makeBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc);
+  static std::shared_ptr<ArrayBuffer> wrap(uint8_t* data, size_t size, DeleteFn&& deleteFunc);
+  /**
+   * Create a new `NativeArrayBuffer` that copies the given data of the given size
+   * into a newly allocated buffer.
+   */
+  static std::shared_ptr<ArrayBuffer> copy(uint8_t* data, size_t size);
+  /**
+   * Create a new `NativeArrayBuffer` that copies the given `std::vector`.
+   */
+  static std::shared_ptr<ArrayBuffer> copy(std::vector<uint8_t>& data);
+  /**
+   * Create a new `NativeArrayBuffer` that allocates a new buffer of the given size.
+   */
+  static std::shared_ptr<ArrayBuffer> allocate(size_t size);
+
+  [[deprecated("Use wrapBuffer(...) instead.")]]
+  static std::shared_ptr<ArrayBuffer> makeBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc) {
+    return ArrayBuffer::wrap(data, size, std::move(deleteFunc));
+  }
 };
 
 /**

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.21.0"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG

package/ios/core/ArrayBufferHolder.hpp

@@ -35,9 +35,9 @@ public:
    * Once the `ArrayBuffer` is no longer in use, the given `deleteFunc` will be called with the given `deleteFuncContext`
    * as an argument. The caller is responsible for deleting `data` once this is called.
    */
-  static ArrayBufferHolder makeBuffer(uint8_t* _Nonnull data, size_t size, SwiftClosure destroy) {
+  static ArrayBufferHolder wrap(uint8_t* _Nonnull data, size_t size, SwiftClosure destroy) {
     std::function<void()> deleteFunc = destroy.getFunction();
-    auto arrayBuffer = ArrayBuffer::makeBuffer(data, size, std::move(deleteFunc));
+    auto arrayBuffer = ArrayBuffer::wrap(data, size, std::move(deleteFunc));
     return ArrayBufferHolder(arrayBuffer);
   }
 
@@ -45,7 +45,7 @@ public:
   /**
    * Gets the raw bytes the underlying `ArrayBuffer` points to.
    */
-  void* _Nonnull getData() const SWIFT_COMPUTED_PROPERTY {
+  uint8_t* _Nonnull getData() const SWIFT_COMPUTED_PROPERTY {
     return _arrayBuffer->data();
   }
   /**

package/ios/core/ArrayBufferHolder.swift

@@ -15,6 +15,8 @@ import Foundation
  */
 public typealias ArrayBufferHolder = margelo.nitro.ArrayBufferHolder
 
+// pragma MARK: Wrap
+
 public extension ArrayBufferHolder {
   /**
    * Create a new `ArrayBufferHolder` that wraps the given `data` of the given `size`
@@ -28,9 +30,27 @@ public extension ArrayBufferHolder {
     // Convert escaping Swift closure to a `void*`
     let swiftClosure = SwiftClosure(wrappingClosure: delete)
     // Create ArrayBufferHolder with our wrapped Swift closure to make it callable as a C-function pointer
-    return ArrayBufferHolder.makeBuffer(data, size, swiftClosure)
+    return ArrayBufferHolder.wrap(data, size, swiftClosure)
   }
 
+  /**
+   * Create a new `ArrayBufferHolder` that wraps the given `data` of the given `size`
+   * without performing a copy.
+   * When the `ArrayBuffer` is no longer used, `onDelete` will be called, in which
+   * you as a caller are responsible for deleting `data`.
+   */
+  static func wrap(dataWithoutCopy data: UnsafeMutableRawPointer,
+                   size: Int,
+                   onDelete delete: @escaping () -> Void) -> ArrayBufferHolder {
+    return ArrayBufferHolder.wrap(dataWithoutCopy: data.assumingMemoryBound(to: UInt8.self),
+                                  size: size,
+                                  onDelete: delete)
+  }
+}
+
+// pragma MARK: Allocate
+
+public extension ArrayBufferHolder {
   /**
    * Allocate a new buffer of the given `size`.
    * If `initializeToZero` is `true`, all bytes are set to `0`, otherwise they are left untouched.
@@ -40,24 +60,92 @@ public extension ArrayBufferHolder {
     if initializeToZero {
       data.initialize(repeating: 0, count: size)
     }
-
     let deleteFunc = SwiftClosure {
       data.deallocate()
     }
-    return ArrayBufferHolder.makeBuffer(data, size, deleteFunc)
+    return ArrayBufferHolder.wrap(data, size, deleteFunc)
+  }
+}
+
+// pragma MARK: Copy
+
+public extension ArrayBufferHolder {
+  /**
+   * Copy the given `UnsafeMutablePointer<UInt8>` into a new **owning** `ArrayBufferHolder`.
+   */
+  static func copy(of other: UnsafeMutablePointer<UInt8>,
+                   size: Int) -> ArrayBufferHolder {
+    // 1. Create new `UnsafeMutablePointer<UInt8>`
+    let copy = UnsafeMutablePointer<UInt8>.allocate(capacity: size)
+    // 2. Copy over data
+    copy.initialize(from: other, count: size)
+    // 3. Create memory safe destroyer
+    let deleteFunc = SwiftClosure {
+      copy.deallocate()
+    }
+    return ArrayBufferHolder.wrap(copy, size, deleteFunc)
+  }
+
+  /**
+   * Copy the given `UnsafeMutableRawPointer` into a new **owning** `ArrayBufferHolder`.
+   */
+  static func copy(of other: UnsafeMutableRawPointer,
+                   size: Int) -> ArrayBufferHolder {
+    return ArrayBufferHolder.copy(of: other.assumingMemoryBound(to: UInt8.self),
+                                  size: size)
   }
 
   /**
    * Copy the given `ArrayBufferHolder` into a new **owning** `ArrayBufferHolder`.
    */
-  static func copy(of other: borrowing 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)
+  static func copy(of other: ArrayBufferHolder) -> ArrayBufferHolder {
+    return ArrayBufferHolder.copy(of: other.data, size: other.size)
+  }
 
-    let deleteFunc = SwiftClosure {
-      data.deallocate()
+  /**
+   * Copy the given `Data` into a new **owning** `ArrayBufferHolder`.
+   */
+  static func copy(data: Data) throws -> ArrayBufferHolder {
+    // 1. Create new `ArrayBuffer` of same size
+    let size = data.count
+    let arrayBuffer = ArrayBufferHolder.allocate(size: size)
+    // 2. Copy all bytes from `Data` into our new `ArrayBuffer`
+    try data.withUnsafeBytes { rawPointer in
+      guard let baseAddress = rawPointer.baseAddress else {
+        throw RuntimeError.error(withMessage: "Cannot get baseAddress of Data!")
+      }
+      memcpy(arrayBuffer.data, baseAddress, size)
+    }
+    return arrayBuffer
+  }
+}
+
+
+// pragma MARK: Data
+
+public extension ArrayBufferHolder {
+  /**
+   * Wrap this `ArrayBufferHolder` in a `Data` instance, without performing a copy.
+   * - `copyIfNeeded`: If this `ArrayBuffer` is **non-owning**, the foreign
+   *                   data may needs to be copied to be safely used outside of the scope of the caller function.
+   *                   This flag controls that.
+   */
+  func toData(copyIfNeeded: Bool) -> Data {
+    let shouldCopy = copyIfNeeded && !self.isOwner
+    if shouldCopy {
+      // COPY DATA
+      return Data.init(bytes: self.data, count: self.size)
+    } else {
+      // WRAP DATA
+      // 1. Get the std::shared_ptr<ArrayBuffer>
+      var sharedPointer = self.getArrayBuffer()
+      // 2. Create a Data object WRAPPING our pointer
+      return Data(bytesNoCopy: self.data, count: self.size, deallocator: .custom({ buffer, size in
+        // 3. Capture the std::shared_ptr<ArrayBuffer> in the deallocator lambda so it stays alive.
+        //    As soon as this lambda gets called, the `sharedPointer` gets deleted causing the
+        //    underlying `ArrayBuffer` to be freed.
+        sharedPointer.reset()
+      }))
     }
-    return ArrayBufferHolder.makeBuffer(data, other.size, deleteFunc)
   }
 }

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/PromiseHolder.hpp

@@ -1,5 +1,5 @@
 //
-//  ArrayBufferHolder.hpp
+//  PromiseHolder.hpp
 //  react-native-nitro
 //
 //  Created by Marc Rousavy on 14.08.24.

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.21.0",
   "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",
@@ -117,7 +117,6 @@
       [
         "typescript",
         {
-          "tsc": "../../node_modules/.bin/tsc",
           "project": "tsconfig.build.json"
         }
       ]