react-native-nitro-modules 0.18.2 → 0.20.0

package/ios/core/HybridObjectSpec.swift

@@ -11,17 +11,6 @@ import Foundation
  * A base protocol for all Swift-based Hybrid Objects.
  */
 public protocol HybridObjectSpec: AnyObject {
-  /**
-   * Holds the C++ HybridObject and it's context.
-   * Use the default initializer in your implementation, C++ will set and get this value.
-   *
-   * @example
-   * ```swift
-   * var hybridContext = margelo.nitro.HybridContext()
-   * ```
-   */
-  var hybridContext: margelo.nitro.HybridContext { get set }
-
   /**
    * Get the memory size of the Swift instance (plus any external heap allocations),
    * in bytes.
@@ -33,7 +22,7 @@ public protocol HybridObjectSpec: AnyObject {
    * ```swift
    * var memorySize: Int {
    *   let imageSize = self.uiImage.bytesPerRow * self.uiImage.height
-   *   return getSizeOf(self) + imageSize
+   *   return imageSize
    * }
    * ```
    */
@@ -41,12 +30,8 @@ public protocol HybridObjectSpec: AnyObject {
 }
 
 public extension HybridObjectSpec {
-  /**
-   * Get the memory size of the given instance.
-   * This only accounts for stack allocated member variables,
-   * not for externally allocated heap allocations like images or buffers.
-   */
+  @available(*, deprecated, message: "getSizeOf(...) will now be default-computed. Please remove getSizeOf() from your code.")
   func getSizeOf<T: AnyObject>(_ instance: T) -> Int {
-    return malloc_size(Unmanaged.passUnretained(instance).toOpaque())
+    return 0
   }
 }

package/ios/core/Promise.swift

@@ -17,16 +17,16 @@ import Foundation
  * - `Promise<T>.rejected(withError:)` - Creates a new already rejected Promise.
  * - `Promise<T>()` - Creates a new Promise with fully manual control over the `resolve(..)`/`reject(..)` functions.
  */
-public class Promise<T> {
+public final class Promise<T> {
   private enum State {
     case result(T)
     case error(Error)
   }
-  
+
   private var state: State?
   private var onResolvedListeners: [(T) -> Void] = []
   private var onRejectedListeners: [(Error) -> Void] = []
-  
+
   /**
    * Create a new pending Promise.
    * It can (and must) be resolved **or** rejected later.
@@ -34,13 +34,13 @@ public class Promise<T> {
   public init() {
     state = nil
   }
-  
+
   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.")
     }
   }
-  
+
   /**
    * Resolves this `Promise<T>` with the given `T` and notifies all listeners.
    */
@@ -51,7 +51,7 @@ public class Promise<T> {
     state = .result(result)
     onResolvedListeners.forEach { listener in listener(result) }
   }
-  
+
   /**
    * Rejects this `Promise<T>` with the given `Error` and notifies all listeners.
    */
@@ -76,7 +76,7 @@ extension Promise {
     promise.state = .result(result)
     return promise
   }
-  
+
   /**
    * Create a new `Promise<T>` already rejected with the given `Error`.
    */
@@ -85,7 +85,7 @@ extension Promise {
     promise.state = .error(error)
     return promise
   }
-  
+
   /**
    * Create a new `Promise<T>` that runs the given `async` code in a `Task`.
    * This does not necessarily run the code in a different Thread, but supports Swift's `async`/`await`.
@@ -103,7 +103,7 @@ extension Promise {
     }
     return promise
   }
-  
+
   /**
    * Create a new `Promise<T>` that runs the given `run` function on a parallel Thread/`DispatchQueue`.
    */
@@ -142,7 +142,7 @@ extension Promise {
     }
     return self
   }
-  
+
   /**
    * Add an error continuation listener to this `Promise<T>`.
    * Once the `Promise<T>` rejects, the `onRejectedListener` will be called with the error.

package/ios/core/PromiseHolder.hpp

@@ -0,0 +1,93 @@
+//
+//  ArrayBufferHolder.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.08.24.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+#include "Promise.hpp"
+#include <exception>
+#include <memory>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Holds instances of `std::shared_ptr<Promise<T>>`.
+ * The reason this exists is for performance optimizations, as well as easier listeners for Swift.
+ */
+template <typename T>
+class PromiseHolder final {
+public:
+  PromiseHolder(const std::shared_ptr<Promise<T>>& promise) : _promise(promise) {}
+  PromiseHolder(std::shared_ptr<Promise<T>>&& promise) : _promise(std::move(promise)) {}
+
+public:
+  static PromiseHolder<T> create() {
+    return PromiseHolder<T>(Promise<T>::create());
+  }
+
+public:
+  void resolve(T value) const {
+    _promise->resolve(std::move(value));
+  }
+
+  void reject(const std::exception_ptr& exception) const {
+    _promise->reject(exception);
+  }
+
+public:
+  void addOnResolvedListener(std::function<void(const T&)> onResolved) const {
+    _promise->addOnResolvedListener([onResolved = std::move(onResolved)](const T& result) { onResolved(result); });
+  }
+  void addOnResolvedListenerCopy(std::function<void(T)> onResolved) const {
+    _promise->addOnResolvedListener([onResolved = std::move(onResolved)](const T& result) { onResolved(result); });
+  }
+
+  void addOnRejectedListener(std::function<void(const std::exception_ptr&)> onRejected) const {
+    _promise->addOnRejectedListener([onRejected = std::move(onRejected)](const std::exception_ptr& error) { onRejected(error); });
+  }
+
+private:
+  std::shared_ptr<Promise<T>> _promise;
+};
+
+template <>
+class PromiseHolder<void> final {
+public:
+  PromiseHolder(const std::shared_ptr<Promise<void>>& promise) : _promise(promise) {}
+  PromiseHolder(std::shared_ptr<Promise<void>>&& promise) : _promise(std::move(promise)) {}
+
+public:
+  static PromiseHolder<void> create() {
+    return PromiseHolder<void>(Promise<void>::create());
+  }
+
+public:
+  void resolve() const {
+    _promise->resolve();
+  }
+
+  void reject(const std::exception_ptr& exception) const {
+    _promise->reject(exception);
+  }
+
+public:
+  void addOnResolvedListener(std::function<void()> onResolved) const {
+    _promise->addOnResolvedListener([onResolved = std::move(onResolved)]() { onResolved(); });
+  }
+
+  void addOnRejectedListener(std::function<void(const std::exception_ptr&)> onRejected) const {
+    _promise->addOnRejectedListener([onRejected = std::move(onRejected)](const std::exception_ptr& error) { onRejected(error); });
+  }
+
+private:
+  std::shared_ptr<Promise<void>> _promise;
+};
+
+} // namespace margelo::nitro

package/ios/utils/MemoryHelper.swift

@@ -0,0 +1,21 @@
+//
+//  MemoryHelper.swift
+//  NitroModules
+//
+//  Created by Marc Rousavy on 17.12.2024.
+//
+
+import Foundation
+
+public final class MemoryHelper {
+  /**
+   * Get the amount of memory that was allocated using a `malloc`-like allocator
+   * for the given instance, in bytes.
+   * When allocating resources differently (e.g. GPU buffers, or `UIImage`) you
+   * should add their byte sizes to the result of this function to get an object's
+   * total memory footprint.
+   */
+  public static func getSizeOf(_ instance: AnyObject) -> Int {
+    return malloc_size(Unmanaged.passUnretained(instance).toOpaque())
+  }
+}

package/ios/utils/Result.hpp

@@ -0,0 +1,193 @@
+#pragma once
+
+#include <exception>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+namespace margelo::nitro {
+
+// TODO: Remove this whole Result wrapping system once Swift errors can be caught in C++.
+//       See https://github.com/swiftlang/swift/issues/75290
+
+/**
+ * Represents a Result from a function. It's either a value (`T`), or an error (`std::exception_ptr`).
+ */
+template <typename T>
+class Result {
+public:
+  // Constructors
+  Result(const Result& other) : _hasError(other._hasError) {
+    if (_hasError) {
+      new (&_error) std::exception_ptr(other._error);
+    } else {
+      new (&_storage) T(other.value());
+    }
+  }
+
+  Result(Result&& other) noexcept(std::is_nothrow_move_constructible<T>::value) : _hasError(other._hasError) {
+    if (_hasError) {
+      new (&_error) std::exception_ptr(std::move(other._error));
+    } else {
+      new (&_storage) T(std::move(other.value()));
+    }
+  }
+
+  ~Result() {
+    destroy();
+  }
+
+  Result& operator=(const Result& other) {
+    if (this == &other)
+      return *this;
+    destroy();
+    _hasError = other._hasError;
+    if (_hasError) {
+      new (&_error) std::exception_ptr(other._error);
+    } else {
+      new (&_storage) T(other.value());
+    }
+    return *this;
+  }
+
+  Result& operator=(Result&& other) noexcept(std::is_nothrow_move_constructible<T>::value) {
+    if (this == &other)
+      return *this;
+    destroy();
+    _hasError = other._hasError;
+    if (_hasError) {
+      new (&_error) std::exception_ptr(std::move(other._error));
+    } else {
+      new (&_storage) T(std::move(other.value()));
+    }
+    return *this;
+  }
+
+  // Static factories
+  static Result withValue(const T& value) {
+    return Result(value);
+  }
+
+  static Result withValue(T&& value) {
+    return Result(std::move(value));
+  }
+
+  static Result withError(std::exception_ptr eptr) {
+    return Result(eptr);
+  }
+
+  // Accessors
+  bool hasValue() const noexcept {
+    return !_hasError;
+  }
+
+  bool hasError() const noexcept {
+    return _hasError;
+  }
+
+  const T& value() const {
+    assert(!_hasError && "Result<T> does not hold a value!");
+    return *reinterpret_cast<const T*>(&_storage);
+  }
+
+  T& value() {
+    assert(!_hasError && "Result<T> does not hold a value!");
+    return *reinterpret_cast<T*>(&_storage);
+  }
+
+  std::exception_ptr error() const {
+    assert(_hasError && "Result<T> does not hold an error!");
+    return _error;
+  }
+
+private:
+  // Private constructors
+  explicit Result(const T& value) : _hasError(false) {
+    new (&_storage) T(value);
+  }
+
+  explicit Result(T&& value) : _hasError(false) {
+    new (&_storage) T(std::move(value));
+  }
+
+  explicit Result(std::exception_ptr eptr) : _hasError(true) {
+    new (&_error) std::exception_ptr(eptr);
+  }
+
+  void destroy() {
+    if (_hasError) {
+      reinterpret_cast<std::exception_ptr*>(&_error)->~exception_ptr();
+    } else {
+      reinterpret_cast<T*>(&_storage)->~T();
+    }
+  }
+
+private:
+  bool _hasError;
+  union {
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type _storage;
+    std::exception_ptr _error;
+  };
+};
+
+// Specialization for void
+template <>
+class Result<void> {
+public:
+  // Constructors
+  Result(const Result& other) : _hasError(other._hasError), _error(other._error) {}
+
+  Result(Result&& other) noexcept : _hasError(other._hasError), _error(std::move(other._error)) {}
+
+  Result& operator=(const Result& other) {
+    if (this == &other)
+      return *this;
+    _hasError = other._hasError;
+    if (_hasError) {
+      _error = other._error;
+    }
+    return *this;
+  }
+
+  Result& operator=(Result&& other) noexcept {
+    if (this == &other)
+      return *this;
+    _hasError = other._hasError;
+    if (_hasError) {
+      _error = std::move(other._error);
+    }
+    return *this;
+  }
+
+  // Static factories
+  static Result withValue() {
+    return Result();
+  }
+
+  static Result withError(std::exception_ptr eptr) {
+    return Result(eptr);
+  }
+
+  bool hasValue() const noexcept {
+    return !_hasError;
+  }
+
+  bool hasError() const noexcept {
+    return _hasError;
+  }
+
+  std::exception_ptr error() const {
+    assert(_hasError && "Result<void> does not hold an error!");
+    return _error;
+  }
+
+private:
+  explicit Result() : _hasError(false), _error(nullptr) {}
+  explicit Result(std::exception_ptr error) : _hasError(true), _error(error) {}
+
+private:
+  bool _hasError;
+  std::exception_ptr _error;
+};
+
+} // namespace margelo::nitro

package/ios/utils/SwiftClosure.hpp

@@ -21,14 +21,14 @@ namespace margelo::nitro {
  */
 struct SwiftClosure final {
 public:
-  using CallFn = void(void*);
-  using DeleteFn = void(void*);
+  using CallFn = void(void* _Nonnull);
+  using DeleteFn = void(void* _Nonnull);
 
 private:
   std::function<void()> _function;
 
 public:
-  explicit SwiftClosure(void* context, CallFn* call, DeleteFn* destroy) {
+  explicit SwiftClosure(void* _Nonnull context, CallFn* _Nonnull call, DeleteFn* _Nonnull destroy) {
     // Create a std::shared_ptr of the `void* context` which calls `destroy`
     // once no references of it exist anymore.
     // Since the std::function captures this std::shared_ptr, it can now be
@@ -37,7 +37,7 @@ public:
     std::shared_ptr<void> sharedContext(context, destroy);
     // Create a std::function that captures `sharedContext`.
     // Once it gets destroyed, `destroy()` gets called.
-    _function = [sharedContext, call]() {
+    _function = [sharedContext = std::move(sharedContext), call]() {
       // Call the actual Swift closure.
       call(sharedContext.get());
     };

package/ios/utils/SwiftClosure.swift

@@ -39,16 +39,15 @@ public extension SwiftClosure {
     let context = Unmanaged.passRetained(ClosureWrapper(closure: closure)).toOpaque()
     
     // Create a C-style Function Pointer, which calls the actual Swift closure.
-    let call: @convention(c) (UnsafeMutableRawPointer?) -> Void = { context in
+    func call(context: UnsafeMutableRawPointer) {
       // Unwrap context from void* to closure again. We are assuming that it has not been deleted yet.
-      let closure = Unmanaged<ClosureWrapper>.fromOpaque(context!).takeUnretainedValue()
+      let closure = Unmanaged<ClosureWrapper>.fromOpaque(context).takeUnretainedValue()
       // Call it!
       closure.invoke()
     }
     
     // Create a C-style Function Pointer, which deletes the `ClosureWrapper`.
-    let destroy: @convention(c) (UnsafeMutableRawPointer?) -> Void = { context in
-      guard let context else { return }
+    func destroy(context: UnsafeMutableRawPointer) {
       // Release the void* holding our `ClosureWrapper`
       Unmanaged<ClosureWrapper>.fromOpaque(context).release()
     }

package/lib/commonjs/Constructor.js

@@ -10,7 +10,7 @@ const cache = new Map();
 /**
  * Get a constructor function for the given `HybridObject` {@linkcode T}.
  * @param name The name of the `HybridObject` under which it was registered at.
- * @returns An instance of {@linkcode T}
+ * @returns A constructor that creates instances of {@linkcode T}
  * @example
  * ```ts
  * export const HybridImage = getHybridObjectConstructor<Image>('Image')

package/lib/module/Constructor.js

@@ -6,7 +6,7 @@ const cache = new Map();
 /**
  * Get a constructor function for the given `HybridObject` {@linkcode T}.
  * @param name The name of the `HybridObject` under which it was registered at.
- * @returns An instance of {@linkcode T}
+ * @returns A constructor that creates instances of {@linkcode T}
  * @example
  * ```ts
  * export const HybridImage = getHybridObjectConstructor<Image>('Image')