react-native-nitro-modules 0.30.0 → 0.30.2

package/cpp/jsi/{JSIConverter+HybridObject.hpp → JSIConverter+NativeState.hpp}

@@ -1,10 +1,9 @@
 //
-// Created by Marc Rousavy on 21.02.24.
+// Created by Marc Rousavy on 16.10.25.
 //
 
 #pragma once
 
-// Forward declare a few of the common types that might have cyclic includes.
 namespace margelo::nitro {
 class HybridObject;
 } // namespace margelo::nitro
@@ -19,7 +18,7 @@ namespace margelo::nitro {
 
 using namespace facebook;
 
-// HybridObject(NativeState) <> {}
+// NativeState <> {}
 template <typename T>
 struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>> final {
   using TPointee = typename T::element_type;
@@ -35,21 +34,28 @@ struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_v<T, jsi::NativeState>>
       }
     }
 #endif
-    jsi::Object object = arg.asObject(runtime);
 
+    jsi::Object object = arg.asObject(runtime);
 #ifdef NITRO_DEBUG
-    if (!object.hasNativeState<TPointee>(runtime)) [[unlikely]] {
-      if (!object.hasNativeState(runtime)) [[unlikely]] {
-        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It does not have a NativeState!"));
-      } else {
-        std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-        throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It has a different NativeState<T>!"));
-      }
+    if (!object.hasNativeState(runtime)) [[unlikely]] {
+      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It does not have a NativeState!"));
     }
 #endif
+
     std::shared_ptr<jsi::NativeState> nativeState = object.getNativeState(runtime);
-    return std::dynamic_pointer_cast<TPointee>(nativeState);
+    std::shared_ptr<TPointee> result = std::dynamic_pointer_cast<TPointee>(nativeState);
+    if (result == nullptr) [[unlikely]] {
+      std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
+      std::string typeName = TypeInfo::getFriendlyTypename<TPointee>();
+      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "Downcasting failed - It has a different NativeState<T>!\n"
+                                                                                "- Did you accidentally pass a different type?\n"
+                                                                                "- Is react-native-nitro-modules linked multiple times? "
+                                                                                "Ensure you don't have any duplicate symbols for `" +
+                                                                                    typeName + "` in your app's binary."));
+    }
+
+    return result;
   }
 
   static inline jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {

package/cpp/jsi/JSIConverter.hpp

@@ -187,7 +187,7 @@ struct JSIConverter<std::string> final {
 #include "JSIConverter+Exception.hpp"
 #include "JSIConverter+Function.hpp"
 #include "JSIConverter+HostObject.hpp"
-#include "JSIConverter+HybridObject.hpp"
+#include "JSIConverter+NativeState.hpp"
 #include "JSIConverter+Optional.hpp"
 #include "JSIConverter+Promise.hpp"
 #include "JSIConverter+Tuple.hpp"

package/cpp/threading/Dispatcher.cpp

@@ -6,6 +6,7 @@
 //
 
 #include "Dispatcher.hpp"
+#include "JSIConverter.hpp"
 #include "JSIHelpers.hpp"
 #include "NitroDefines.hpp"
 #include "NitroLogger.hpp"
@@ -16,6 +17,10 @@ using namespace facebook;
 
 static constexpr auto GLOBAL_DISPATCHER_HOLDER_NAME = "__nitroDispatcher";
 
+/**
+ * This map is only statically linked once to this library.
+ * If multiple versions of react-native-nitro-modules are linked, there would be multiple maps. We catch that issue later.
+ */
 std::unordered_map<jsi::Runtime * NON_NULL, std::weak_ptr<Dispatcher>> Dispatcher::_globalCache;
 
 void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher) {
@@ -25,9 +30,8 @@ void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shar
   _globalCache[&runtime] = dispatcher;
 
   // Inject the dispatcher into Runtime global (runtime will hold a strong reference)
-  jsi::Object dispatcherHolder(runtime);
-  dispatcherHolder.setNativeState(runtime, dispatcher);
-  runtime.global().setProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME, dispatcherHolder);
+  jsi::Value dispatcherHolder = JSIConverter<std::shared_ptr<Dispatcher>>::toJSI(runtime, dispatcher);
+  runtime.global().setProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME, std::move(dispatcherHolder));
 }
 
 std::shared_ptr<Dispatcher> Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime& runtime) {
@@ -44,24 +48,23 @@ std::shared_ptr<Dispatcher> Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime&
 
   Logger::log(LogLevel::Warning, TAG, "Unknown Runtime (%s), looking for Dispatcher through JSI global lookup...",
               getRuntimeId(runtime).c_str());
+  // 1. Get global.__nitroDispatcher
   jsi::Value dispatcherHolderValue = getRuntimeGlobalDispatcherHolder(runtime);
-  jsi::Object dispatcherHolder = dispatcherHolderValue.getObject(runtime);
-  std::shared_ptr<Dispatcher> dispatcher = dispatcherHolder.getNativeState<Dispatcher>(runtime);
+  // 2. Cast it to the jsi::Object
+  std::shared_ptr<Dispatcher> dispatcher = JSIConverter<std::shared_ptr<Dispatcher>>::fromJSI(runtime, dispatcherHolderValue);
+  // 3. Throw it in our cache and return
   _globalCache[&runtime] = dispatcher;
   return dispatcher;
 }
 
 jsi::Value Dispatcher::getRuntimeGlobalDispatcherHolder(jsi::Runtime& runtime) {
-#ifdef NITRO_DEBUG
   if (!runtime.global().hasProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME)) [[unlikely]] {
-    throw std::runtime_error("Failed to get current Dispatcher - the global Dispatcher "
-                             "holder (`global." +
-                             std::string(GLOBAL_DISPATCHER_HOLDER_NAME) +
-                             "`) "
-                             "does not exist! Was `Dispatcher::installDispatcherIntoRuntime()` called "
-                             "for this `jsi::Runtime`?");
+    throw std::runtime_error("The `jsi::Runtime` \"" + getRuntimeId(runtime) +
+                             "\" does not support Callbacks or Promises because it does not have a `Dispatcher` installed!\n"
+                             "To use Callbacks and Promises follow these steps;\n"
+                             "1. Subclass `Dispatcher` with your implementation of `runAsync`/`runSync` for your Thread.\n"
+                             "2. Call `Dispatcher::installRuntimeGlobalDispatcher(...)` with your `Runtime` and your `Dispatcher`.");
   }
-#endif
   return runtime.global().getProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME);
 }
 

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

package/ios/core/AnyMap.swift

@@ -7,18 +7,16 @@
 
 import Foundation
 
-/**
- * Represents any value representable by the `AnyMap`.
- * Note: Arrays are currently not implemented due to a Swift compiler bug https://github.com/swiftlang/swift/issues/75994
- */
+/// Represents any value representable by the `AnyMap`.
+/// Note: Arrays are currently not implemented due to a Swift compiler bug https://github.com/swiftlang/swift/issues/75994
 public indirect enum AnyValue {
   case null
   case number(Double)
   case bool(Bool)
   case bigint(Int64)
   case string(String)
-  case array(Array<AnyValue>)
-  case object(Dictionary<String, AnyValue>)
+  case array([AnyValue])
+  case object([String: AnyValue])
 
   static func create(_ value: margelo.nitro.AnyValue) -> AnyValue {
     if margelo.nitro.AnyMapUtils.is_AnyValue_null(value) {
@@ -41,10 +39,8 @@ public indirect enum AnyValue {
   }
 }
 
-/**
- * Represents an `AnyMap`- an untyped map instance.
- * See C++ `AnyMap.hpp` for more information.
- */
+/// Represents an `AnyMap`- an untyped map instance.
+/// See C++ `AnyMap.hpp` for more information.
 public final class AnyMap: @unchecked Sendable {
   public let cppPart: margelo.nitro.SharedAnyMap
 
@@ -150,7 +146,7 @@ public final class AnyMap: @unchecked Sendable {
    * If no value exists at the given key, or if it is not a double,
    * this function throws.
    */
-  public func getObject(key: String) -> Dictionary<String, AnyValue> {
+  public func getObject(key: String) -> [String: AnyValue] {
     let value = cppPart.pointee.getObject(std.string(key))
     return value.toSwift()
   }
@@ -202,7 +198,7 @@ public final class AnyMap: @unchecked Sendable {
   /**
    * Set the given key to the given object value.
    */
-  public func setObject(key: String, value: Dictionary<String, AnyValue>) {
+  public func setObject(key: String, value: [String: AnyValue]) {
     cppPart.pointee.setObject(std.string(key), margelo.nitro.AnyObject.create(value))
   }
 
@@ -297,7 +293,7 @@ extension margelo.nitro.AnyValue {
   static func create(_ value: [AnyValue]) -> margelo.nitro.AnyValue {
     return margelo.nitro.AnyMapUtils.create_AnyValue(margelo.nitro.AnyArray.create(value))
   }
-  static func create(_ value: Dictionary<String, AnyValue>) -> margelo.nitro.AnyValue {
+  static func create(_ value: [String: AnyValue]) -> margelo.nitro.AnyValue {
     return margelo.nitro.AnyMapUtils.create_AnyValue(margelo.nitro.AnyObject.create(value))
   }
 }
@@ -335,7 +331,7 @@ extension margelo.nitro.AnyArray {
 // pragma MARK: margelo.nitro.AnyObject extension
 
 extension margelo.nitro.AnyObject {
-  static func create(_ dictionary: Dictionary<String, AnyValue>) -> margelo.nitro.AnyObject {
+  static func create(_ dictionary: [String: AnyValue]) -> margelo.nitro.AnyObject {
     var object = margelo.nitro.AnyObject()
     object.reserve(dictionary.count)
     for (key, value) in dictionary {
@@ -344,9 +340,9 @@ extension margelo.nitro.AnyObject {
     return object
   }
 
-  func toSwift() -> Dictionary<String, AnyValue> {
+  func toSwift() -> [String: AnyValue] {
     let keys = margelo.nitro.AnyMapUtils.getAnyObjectKeys(self)
-    var dictionary = Dictionary<String, AnyValue>(minimumCapacity: keys.size())
+    var dictionary = [String: AnyValue](minimumCapacity: keys.size())
     for key in keys {
       let value = margelo.nitro.AnyMapUtils.getAnyObjectValue(self, key)
       dictionary[String(key)] = AnyValue.create(value)
@@ -355,6 +351,5 @@ extension margelo.nitro.AnyObject {
   }
 }
 
-
 @available(*, deprecated, renamed: "AnyMap")
 public typealias AnyMapHolder = AnyMap

package/ios/core/ArrayBuffer.swift

@@ -7,12 +7,10 @@
 
 import Foundation
 
-/**
- * Holds instances of `std::shared_ptr<ArrayBuffer>`, which can be passed
- * between native and JS **without copy**.
- *
- * See `data`, `size` and `isOwning`.
- */
+/// Holds instances of `std::shared_ptr<ArrayBuffer>`, which can be passed
+/// between native and JS **without copy**.
+///
+/// See `data`, `size` and `isOwning`.
 public typealias ArrayBuffer = margelo.nitro.ArrayBufferHolder
 
 @available(*, deprecated, renamed: "ArrayBuffer")
@@ -20,16 +18,18 @@ public typealias ArrayBufferHolder = ArrayBuffer
 
 // pragma MARK: Wrap
 
-public extension ArrayBuffer {
+extension ArrayBuffer {
   /**
    * Create a new `ArrayBuffer` 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: UnsafeMutablePointer<UInt8>,
-                   size: Int,
-                   onDelete delete: @escaping () -> Void) -> ArrayBuffer {
+  public static func wrap(
+    dataWithoutCopy data: UnsafeMutablePointer<UInt8>,
+    size: Int,
+    onDelete delete: @escaping () -> Void
+  ) -> ArrayBuffer {
     // Convert escaping Swift closure to a `void*`
     let swiftClosure = SwiftClosure(wrappingClosure: delete)
     // Create ArrayBuffer with our wrapped Swift closure to make it callable as a C-function pointer
@@ -42,23 +42,26 @@ public extension ArrayBuffer {
    * 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) -> ArrayBuffer {
-    return ArrayBuffer.wrap(dataWithoutCopy: data.assumingMemoryBound(to: UInt8.self),
-                                  size: size,
-                                  onDelete: delete)
+  public static func wrap(
+    dataWithoutCopy data: UnsafeMutableRawPointer,
+    size: Int,
+    onDelete delete: @escaping () -> Void
+  ) -> ArrayBuffer {
+    return ArrayBuffer.wrap(
+      dataWithoutCopy: data.assumingMemoryBound(to: UInt8.self),
+      size: size,
+      onDelete: delete)
   }
 }
 
 // pragma MARK: Allocate
 
-public extension ArrayBuffer {
+extension ArrayBuffer {
   /**
    * Allocate a new buffer of the given `size`.
    * If `initializeToZero` is `true`, all bytes are set to `0`, otherwise they are left untouched.
    */
-  static func allocate(size: Int, initializeToZero: Bool = false) -> ArrayBuffer {
+  public static func allocate(size: Int, initializeToZero: Bool = false) -> ArrayBuffer {
     let data = UnsafeMutablePointer<UInt8>.allocate(capacity: size)
     if initializeToZero {
       data.initialize(repeating: 0, count: size)
@@ -72,12 +75,14 @@ public extension ArrayBuffer {
 
 // pragma MARK: Copy
 
-public extension ArrayBuffer {
+extension ArrayBuffer {
   /**
    * Copy the given `UnsafeMutablePointer<UInt8>` into a new **owning** `ArrayBuffer`.
    */
-  static func copy(of other: UnsafeMutablePointer<UInt8>,
-                   size: Int) -> ArrayBuffer {
+  public static func copy(
+    of other: UnsafeMutablePointer<UInt8>,
+    size: Int
+  ) -> ArrayBuffer {
     // 1. Create new `UnsafeMutablePointer<UInt8>`
     let copy = UnsafeMutablePointer<UInt8>.allocate(capacity: size)
     // 2. Copy over data
@@ -92,23 +97,26 @@ public extension ArrayBuffer {
   /**
    * Copy the given `UnsafeMutableRawPointer` into a new **owning** `ArrayBuffer`.
    */
-  static func copy(of other: UnsafeMutableRawPointer,
-                   size: Int) -> ArrayBuffer {
-    return ArrayBuffer.copy(of: other.assumingMemoryBound(to: UInt8.self),
-                                  size: size)
+  public static func copy(
+    of other: UnsafeMutableRawPointer,
+    size: Int
+  ) -> ArrayBuffer {
+    return ArrayBuffer.copy(
+      of: other.assumingMemoryBound(to: UInt8.self),
+      size: size)
   }
 
   /**
    * Copy the given `ArrayBuffer` into a new **owning** `ArrayBuffer`.
    */
-  static func copy(of other: ArrayBuffer) -> ArrayBuffer {
+  public static func copy(of other: ArrayBuffer) -> ArrayBuffer {
     return ArrayBuffer.copy(of: other.data, size: other.size)
   }
 
   /**
    * Copy the given `Data` into a new **owning** `ArrayBuffer`.
    */
-  static func copy(data: Data) throws -> ArrayBuffer {
+  public static func copy(data: Data) throws -> ArrayBuffer {
     // 1. Create new `ArrayBuffer` of same size
     let size = data.count
     let arrayBuffer = ArrayBuffer.allocate(size: size)
@@ -123,17 +131,16 @@ public extension ArrayBuffer {
   }
 }
 
-
 // pragma MARK: Data
 
-public extension ArrayBuffer {
+extension ArrayBuffer {
   /**
    * Wrap this `ArrayBuffer` 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 {
+  public func toData(copyIfNeeded: Bool) -> Data {
     let shouldCopy = copyIfNeeded && !self.isOwner
     if shouldCopy {
       // COPY DATA
@@ -143,12 +150,14 @@ public extension ArrayBuffer {
       // 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 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()
+        }))
     }
   }
 }

package/ios/core/HybridObject.swift

@@ -7,9 +7,7 @@
 
 import Foundation
 
-/**
- * A base protocol for all Swift-based Hybrid Objects.
- */
+/// A base protocol for all Swift-based Hybrid Objects.
 public protocol HybridObject: AnyObject {
   /**
    * Get the memory size of the Swift instance (plus any external heap allocations),
@@ -41,9 +39,9 @@ public protocol HybridObject: AnyObject {
   func dispose()
 }
 
-public extension HybridObject {
+extension HybridObject {
   // By default, this returns `0`.
-  var memorySize: Int { return 0 }
+  public var memorySize: Int { return 0 }
   // By default, this does nothing.
-  func dispose() { }
+  public func dispose() {}
 }

package/ios/core/Promise.swift

@@ -7,16 +7,14 @@
 
 import Foundation
 
-/**
- * Represents a Promise that can be passed to JS.
- *
- * Create a new Promise with the following APIs:
- * - `Promise<T>.async { ... }` - Creates a new Promise that runs the given code in a Swift `async`/`await` Task.
- * - `Promise<T>.parallel { ... }` - Creates a new Promise that runs the given code in a parallel `DispatchQueue`.
- * - `Promise<T>.resolved(withResult:)` - Creates a new already resolved Promise.
- * - `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.
- */
+/// Represents a Promise that can be passed to JS.
+///
+/// Create a new Promise with the following APIs:
+/// - `Promise<T>.async { ... }` - Creates a new Promise that runs the given code in a Swift `async`/`await` Task.
+/// - `Promise<T>.parallel { ... }` - Creates a new Promise that runs the given code in a parallel `DispatchQueue`.
+/// - `Promise<T>.resolved(withResult:)` - Creates a new already resolved Promise.
+/// - `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 final class Promise<T>: @unchecked Sendable {
   private enum State {
     case result(T)
@@ -47,7 +45,8 @@ public final class Promise<T>: @unchecked Sendable {
    */
   public func resolve(withResult result: T) {
     guard state == nil else {
-      fatalError("Failed to resolve promise with \(result) - it has already been resolved or rejected!")
+      fatalError(
+        "Failed to resolve promise with \(result) - it has already been resolved or rejected!")
     }
     state = .result(result)
     onResolvedListeners.forEach { listener in listener(result) }
@@ -58,16 +57,15 @@ public final class Promise<T>: @unchecked Sendable {
    */
   public func reject(withError error: Error) {
     guard state == nil else {
-      fatalError("Failed to reject promise with \(error) - it has already been resolved or rejected!")
+      fatalError(
+        "Failed to reject promise with \(error) - it has already been resolved or rejected!")
     }
     state = .error(error)
     onRejectedListeners.forEach { listener in listener(error) }
   }
 }
 
-/**
- * Extensions to easily create new Promises.
- */
+/// Extensions to easily create new Promises.
 extension Promise {
   /**
    * Create a new `Promise<T>` already resolved with the given `T`.
@@ -91,8 +89,10 @@ extension 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`.
    */
-  public static func `async`(_ priority: TaskPriority? = nil,
-                             _ run: @escaping () async throws -> T) -> Promise {
+  public static func `async`(
+    _ priority: TaskPriority? = nil,
+    _ run: sending @escaping @isolated(any) () async throws -> T
+  ) -> Promise {
     let promise = Promise()
     Task(priority: priority) {
       do {
@@ -108,8 +108,10 @@ extension Promise {
   /**
    * Create a new `Promise<T>` that runs the given `run` function on a parallel Thread/`DispatchQueue`.
    */
-  public static func parallel(_ queue: DispatchQueue = .global(),
-                              _ run: @escaping () throws -> T) -> Promise {
+  public static func parallel(
+    _ queue: DispatchQueue = .global(),
+    _ run: @escaping @Sendable () throws -> T
+  ) -> Promise {
     let promise = Promise()
     queue.async {
       do {
@@ -123,9 +125,7 @@ extension Promise {
   }
 }
 
-/**
- * Extensions to support then/catch syntax.
- */
+/// Extensions to support then/catch syntax.
 extension Promise {
   /**
    * Add a continuation listener to this `Promise<T>`.
@@ -162,9 +162,7 @@ extension Promise {
   }
 }
 
-/**
- * Extensions to support await syntax.
- */
+/// Extensions to support await syntax.
 extension Promise {
   /**
    * Asynchronously await the result of the Promise.

package/ios/core/RuntimeError.swift

@@ -7,18 +7,16 @@
 
 import Foundation
 
-/**
- * Represents an error that occured at any point during the application's runtime.
- *
- * Throw this error in Nitro Modules to provide clear and concise error messages to JS.
- */
+/// Represents an error that occured at any point during the application's runtime.
+///
+/// Throw this error in Nitro Modules to provide clear and concise error messages to JS.
 @frozen
 public enum RuntimeError: Error, CustomStringConvertible {
   case error(withMessage: String)
 
   public var description: String {
     switch self {
-      case .error(let message): return message
+    case .error(let message): return message
     }
   }
 
@@ -31,11 +29,11 @@ public enum RuntimeError: Error, CustomStringConvertible {
   }
 }
 
-public extension Error {
+extension Error {
   /**
    * Converts this `Error` to a C++ `std::exception`.
    */
-  func toCpp() -> std.exception_ptr {
+  public func toCpp() -> std.exception_ptr {
     let message = String(describing: self)
     return margelo.nitro.makeException(std.string(message))
   }

package/ios/utils/Date+fromChrono.swift

@@ -7,19 +7,19 @@
 
 import Foundation
 
-public extension Date {
+extension Date {
   /**
    * Create a new `Date` object from the given `std::chrono::system_clock::time_point` value.
    */
-  init(fromChrono date: margelo.nitro.chrono_time) {
+  public init(fromChrono date: margelo.nitro.chrono_time) {
     let millisecondsSinceEpoch = margelo.nitro.millisecondsSinceEpochFromChronoDate(date)
     self = .init(timeIntervalSince1970: millisecondsSinceEpoch / 1_000)
   }
-  
+
   /**
    * Converts this `Date` object to a `std::chrono::system_clock::time_point` value.
    */
-  func toCpp() -> margelo.nitro.chrono_time {
+  public func toCpp() -> margelo.nitro.chrono_time {
     let secondsSinceEpoch = self.timeIntervalSince1970
     let millisecondsSinceEpoch = secondsSinceEpoch * 1_000
     return margelo.nitro.chronoDateFromMillisecondsSinceEpoch(millisecondsSinceEpoch)

package/ios/utils/SwiftClosure.swift

@@ -7,37 +7,33 @@
 
 import Foundation
 
-/**
- * Wraps a Swift closure in a Swift class.
- * This can be used to create unmanaged pointers (`void*`) and
- * passed to C-style function pointers via `void* context` parameters.
- */
-fileprivate final class ClosureWrapper {
+/// Wraps a Swift closure in a Swift class.
+/// This can be used to create unmanaged pointers (`void*`) and
+/// passed to C-style function pointers via `void* context` parameters.
+private final class ClosureWrapper {
   private let closure: () -> Void
-  
+
   init(closure: @escaping () -> Void) {
     self.closure = closure
   }
-  
+
   func invoke() {
     closure()
   }
 }
 
-/**
- * Represents a Swift Closure that can be called from both C++ and Swift.
- */
+/// Represents a Swift Closure that can be called from both C++ and Swift.
 public typealias SwiftClosure = margelo.nitro.SwiftClosure
 
-public extension SwiftClosure {
+extension SwiftClosure {
   /**
    * Create a new `SwiftClosure` wrapping the given Swift closure.
    * This can then be called from both C++ and Swift.
    */
-  init(wrappingClosure closure: @escaping () -> Void) {
+  public init(wrappingClosure closure: @escaping () -> Void) {
     // Wrap closure in void*, and increment it's ref count so it stays alive.
     let context = Unmanaged.passRetained(ClosureWrapper(closure: closure)).toOpaque()
-    
+
     // Create a C-style Function Pointer, which calls the actual Swift closure.
     func call(context: UnsafeMutableRawPointer) {
       // Unwrap context from void* to closure again. We are assuming that it has not been deleted yet.
@@ -45,13 +41,13 @@ public extension SwiftClosure {
       // Call it!
       closure.invoke()
     }
-    
+
     // Create a C-style Function Pointer, which deletes the `ClosureWrapper`.
     func destroy(context: UnsafeMutableRawPointer) {
       // Release the void* holding our `ClosureWrapper`
       Unmanaged<ClosureWrapper>.fromOpaque(context).release()
     }
-    
+
     self.init(context, call, destroy)
   }
 }