react-native-nitro-modules 0.20.1 → 0.21.0

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/utils/NitroDefines.hpp

@@ -9,7 +9,7 @@
 #define NitroDefines_h
 
 // Sets the version of the native Nitro core library
-#define NITRO_VERSION "0.20.1"
+#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: 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)
+    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/PromiseHolder.hpp

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.20.1",
+  "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"
         }
       ]