react-native-nitro-modules 0.18.2 → 0.20.0

package/NitroModules.podspec

@@ -47,6 +47,8 @@ Pod::Spec.new do |s|
     "ios/core/ArrayBufferHolder.hpp",
     "ios/core/AnyMapHolder.hpp",
     "ios/core/HybridContext.hpp",
+    "ios/core/PromiseHolder.hpp",
+    "ios/utils/Result.hpp",
     "ios/utils/RuntimeError.hpp",
     "ios/utils/SwiftClosure.hpp",
   ]

package/README.md

@@ -177,9 +177,9 @@ The following C++ / JS types are supported out of the box:
   </tr>
   <tr>
     <td><code>(T...) =&gt; R</code></td>
-    <td><code>std::function&lt;std::future&lt;R&gt; (T...)&gt;</code></td>
-    <td>❌</td>
-    <td>❌</td>
+    <td><code>std::function&lt;std::shared_ptr&lt;<a href="./cpp/core/Promise.hpp">Promise&lt;R&gt;</a>&gt; (T...)&gt;</code></td>
+    <td><code>(T...) -&gt; <a href="./ios/core/Promise.swift">Promise&lt;T&gt;</a></code></td>
+    <td><code>(T...) -&gt; <a href="./android/src/main/java/com/margelo/nitro/core/Promise.kt">Promise&lt;T&gt;</a></code></td>
   </tr>
   <tr>
     <td><code>Error</code></td>

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

@@ -103,7 +103,8 @@ private:
     } else {
       // Promise is not yet resolved, put the listener in our queue.
       auto sharedCallback = jni::make_global(callback);
-      _onResolvedListeners.emplace_back([=](const auto& result) { sharedCallback->onResolved(result); });
+      _onResolvedListeners.emplace_back(
+          [sharedCallback = std::move(sharedCallback)](const auto& result) { sharedCallback->onResolved(result); });
     }
   }
   void addOnRejectedListenerJava(jni::alias_ref<JOnRejectedCallback> callback) {
@@ -114,7 +115,8 @@ private:
     } else {
       // Promise is not yet rejected, put the listener in our queue.
       auto sharedCallback = jni::make_global(callback);
-      _onRejectedListeners.emplace_back([=](const auto& error) { sharedCallback->onRejected(error); });
+      _onRejectedListeners.emplace_back(
+          [sharedCallback = std::move(sharedCallback)](const auto& error) { sharedCallback->onRejected(error); });
     }
   }
 

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

@@ -15,23 +15,26 @@ namespace margelo::nitro {
 void JHybridObjectRegistry::registerHybridObjectConstructor(jni::alias_ref<jni::JClass> clazz, std::string hybridObjectName,
                                                             jni::alias_ref<JHybridObjectInitializer> constructorFn) {
   auto sharedInitializer = jni::make_global(constructorFn);
-  HybridObjectRegistry::registerHybridObjectConstructor(hybridObjectName, [=]() -> std::shared_ptr<HybridObject> {
-    // 1. Call the Java initializer function
-    jni::local_ref<JHybridObject::javaobject> hybridObject = sharedInitializer->call();
+  HybridObjectRegistry::registerHybridObjectConstructor(
+      hybridObjectName,
+      [sharedInitializer = std::move(sharedInitializer),
+       hybridObjectName = std::move(hybridObjectName)]() -> std::shared_ptr<HybridObject> {
+        // 1. Call the Java initializer function
+        jni::local_ref<JHybridObject::javaobject> hybridObject = sharedInitializer->call();
 #ifdef NITRO_DEBUG
-    if (hybridObject == nullptr) [[unlikely]] {
-      throw std::runtime_error("Failed to create HybridObject \"" + hybridObjectName + "\" - the constructor returned null!");
-    }
+        if (hybridObject == nullptr) [[unlikely]] {
+          throw std::runtime_error("Failed to create HybridObject \"" + hybridObjectName + "\" - the constructor returned null!");
+        }
 #endif
 
-    // 2. Make the resulting HybridObject a global (shared) reference
-    jni::global_ref<JHybridObject::javaobject> globalHybridObject = jni::make_global(hybridObject);
-    // 3. Create a shared_ptr from the JNI global reference
-    std::shared_ptr<JHybridObject> sharedCppPart = JNISharedPtr::make_shared_from_jni<JHybridObject>(globalHybridObject);
-    // 4. Up-cast to a HybridObject (kinda unsafe)
-    std::shared_ptr<HybridObject> cast = std::static_pointer_cast<HybridObject>(sharedCppPart);
-    return cast;
-  });
+        // 2. Make the resulting HybridObject a global (shared) reference
+        jni::global_ref<JHybridObject::javaobject> globalHybridObject = jni::make_global(hybridObject);
+        // 3. Create a shared_ptr from the JNI global reference
+        std::shared_ptr<JHybridObject> sharedCppPart = JNISharedPtr::make_shared_from_jni<JHybridObject>(globalHybridObject);
+        // 4. Up-cast to a HybridObject (kinda unsafe)
+        std::shared_ptr<HybridObject> cast = std::static_pointer_cast<HybridObject>(sharedCppPart);
+        return cast;
+      });
 }
 
 void JHybridObjectRegistry::registerNatives() {

package/android/src/main/cpp/turbomodule/JNitroModules.cpp

@@ -10,8 +10,6 @@
 
 namespace margelo::nitro {
 
-JNitroModules::JNitroModules() = default;
-
 jni::local_ref<JNitroModules::jhybriddata> JNitroModules::initHybrid(jni::alias_ref<JNitroModules::jhybridobject>) {
   return makeCxxInstance();
 }

package/android/src/main/cpp/turbomodule/JNitroModules.hpp

@@ -18,7 +18,7 @@ public:
   static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/NitroModules;";
 
 private:
-  explicit JNitroModules();
+  explicit JNitroModules() = default;
 
 private:
   // JNI Methods

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

@@ -26,7 +26,7 @@ abstract class HybridObject: ExtendableHybridClass {
      * val memorySize: ULong
      *   get() {
      *     val imageSize = this.bitmap.bytesPerRow * this.bitmap.height
-     *     return getSizeOf(this) + imageSize
+     *     return imageSize
      *   }
      * ```
      */

package/cpp/core/AnyMap.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "NitroDefines.hpp"
 #include <map>
 #include <memory>
 #include <string>
@@ -199,6 +200,6 @@ public:
 
 private:
   std::unordered_map<std::string, AnyValue> _map;
-};
+} SWIFT_NONCOPYABLE;
 
 } // namespace margelo::nitro

package/cpp/core/HybridFunction.hpp

@@ -108,6 +108,14 @@ public:
         std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());
         std::string message = exception.what();
         throw jsi::JSError(runtime, funcName + ": " + message);
+#ifdef ANDROID
+        // Workaround for https://github.com/mrousavy/nitro/issues/382
+      } catch (const std::runtime_error& exception) {
+        // Some exception was thrown - add method name information and re-throw as `JSError`.
+        std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());
+        std::string message = exception.what();
+        throw jsi::JSError(runtime, funcName + ": " + message);
+#endif
       } catch (...) {
         // Some unknown exception was thrown - add method name information and re-throw as `JSError`.
         std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());

package/cpp/core/HybridObject.hpp

@@ -38,11 +38,11 @@ public:
   /**
    * HybridObjects cannot be copied.
    */
-  HybridObject(const HybridObject& copy) = default;
+  HybridObject(const HybridObject& copy) = delete;
   /**
    * HybridObjects cannot be moved.
    */
-  HybridObject(HybridObject&& move) = default;
+  HybridObject(HybridObject&& move) = delete;
   /**
    * HybridObjects cannot be default-constructed!
    */

package/cpp/core/Promise.hpp

@@ -28,13 +28,9 @@ public:
 public:
   // Promise cannot be copied.
   Promise(const Promise&) = delete;
-  // Promise can be moved.
-  Promise(Promise&&) = default;
 
 private:
-  Promise() {
-    _mutex = std::make_unique<std::mutex>();
-  }
+  Promise() {}
 
 public:
   /**
@@ -94,7 +90,7 @@ public:
    * Resolves this Promise with the given result, and calls any pending listeners.
    */
   void resolve(TResult&& result) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
 #ifdef NITRO_DEBUG
     assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE);
 #endif
@@ -104,7 +100,7 @@ public:
     }
   }
   void resolve(const TResult& result) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
 #ifdef NITRO_DEBUG
     assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE);
 #endif
@@ -121,7 +117,7 @@ public:
       throw std::runtime_error("Cannot reject Promise with a null exception_ptr!");
     }
 
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
 #ifdef NITRO_DEBUG
     assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT);
 #endif
@@ -137,7 +133,7 @@ public:
    * If the Promise is already resolved, the listener will be immediately called.
    */
   void addOnResolvedListener(OnResolvedFunc&& onResolved) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
     if (std::holds_alternative<TResult>(_state)) {
       // Promise is already resolved! Call the callback immediately
       onResolved(std::get<TResult>(_state));
@@ -147,7 +143,7 @@ public:
     }
   }
   void addOnResolvedListener(const OnResolvedFunc& onResolved) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
     if (std::holds_alternative<TResult>(_state)) {
       // Promise is already resolved! Call the callback immediately
       onResolved(std::get<TResult>(_state));
@@ -156,15 +152,9 @@ public:
       _onResolvedListeners.push_back(onResolved);
     }
   }
+  [[deprecated("Upgrade Nitro to use PromiseHolder<T> instead.")]]
   void addOnResolvedListenerCopy(const std::function<void(TResult)>& onResolved) {
-    std::unique_lock lock(*_mutex);
-    if (std::holds_alternative<TResult>(_state)) {
-      // Promise is already resolved! Call the callback immediately
-      onResolved(std::get<TResult>(_state));
-    } else {
-      // Promise is not yet resolved, put the listener in our queue.
-      _onResolvedListeners.push_back(onResolved);
-    }
+    addOnResolvedListener([=](const TResult& value) { onResolved(value); });
   }
 
   /**
@@ -172,7 +162,7 @@ public:
    * If the Promise is already rejected, the listener will be immediately called.
    */
   void addOnRejectedListener(OnRejectedFunc&& onRejected) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
     if (std::holds_alternative<std::exception_ptr>(_state)) {
       // Promise is already rejected! Call the callback immediately
       onRejected(std::get<std::exception_ptr>(_state));
@@ -182,7 +172,7 @@ public:
     }
   }
   void addOnRejectedListener(const OnRejectedFunc& onRejected) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
     if (std::holds_alternative<std::exception_ptr>(_state)) {
       // Promise is already rejected! Call the callback immediately
       onRejected(std::get<std::exception_ptr>(_state));
@@ -252,7 +242,7 @@ private:
   std::variant<std::monostate, TResult, std::exception_ptr> _state;
   std::vector<OnResolvedFunc> _onResolvedListeners;
   std::vector<OnRejectedFunc> _onRejectedListeners;
-  std::unique_ptr<std::mutex> _mutex;
+  std::mutex _mutex;
 };
 
 // Specialization for void
@@ -264,12 +254,9 @@ public:
 
 public:
   Promise(const Promise&) = delete;
-  Promise(Promise&&) = default;
 
 private:
-  Promise() {
-    _mutex = std::make_unique<std::mutex>();
-  }
+  Promise() {}
 
 public:
   static std::shared_ptr<Promise> create() {
@@ -309,7 +296,7 @@ public:
 
 public:
   void resolve() {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
 #ifdef NITRO_DEBUG
     assertPromiseState(*this, PromiseTask::WANTS_TO_RESOLVE);
 #endif
@@ -323,7 +310,7 @@ public:
       throw std::runtime_error("Cannot reject Promise with a null exception_ptr!");
     }
 
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
 #ifdef NITRO_DEBUG
     assertPromiseState(*this, PromiseTask::WANTS_TO_REJECT);
 #endif
@@ -335,7 +322,7 @@ public:
 
 public:
   void addOnResolvedListener(OnResolvedFunc&& onResolved) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
     if (_isResolved) {
       onResolved();
     } else {
@@ -343,7 +330,7 @@ public:
     }
   }
   void addOnResolvedListener(const OnResolvedFunc& onResolved) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
     if (_isResolved) {
       onResolved();
     } else {
@@ -351,7 +338,7 @@ public:
     }
   }
   void addOnRejectedListener(OnRejectedFunc&& onRejected) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
     if (_error) {
       onRejected(_error);
     } else {
@@ -360,7 +347,7 @@ public:
     }
   }
   void addOnRejectedListener(const OnRejectedFunc& onRejected) {
-    std::unique_lock lock(*_mutex);
+    std::unique_lock lock(_mutex);
     if (_error) {
       onRejected(_error);
     } else {
@@ -400,7 +387,7 @@ public:
   }
 
 private:
-  std::unique_ptr<std::mutex> _mutex;
+  std::mutex _mutex;
   bool _isResolved = false;
   std::exception_ptr _error;
   std::vector<OnResolvedFunc> _onResolvedListeners;

package/cpp/jsi/JSIConverter+Exception.hpp

@@ -39,6 +39,12 @@ struct JSIConverter<std::exception_ptr> final {
     } catch (const std::exception& e) {
       jsi::JSError error(runtime, e.what());
       return jsi::Value(runtime, error.value());
+#ifdef ANDROID
+      // Workaround for https://github.com/mrousavy/nitro/issues/382
+    } catch (const std::runtime_error& e) {
+      jsi::JSError error(runtime, e.what());
+      return jsi::Value(runtime, error.value());
+#endif
     } catch (...) {
       // Some unknown exception was thrown - maybe an Objective-C error?
       std::string errorName = TypeInfo::getCurrentExceptionName();

package/cpp/jsi/JSIConverter+Function.hpp

@@ -15,10 +15,9 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 
 #include "Dispatcher.hpp"
-#include "FutureType.hpp"
 #include "JSICache.hpp"
+#include "PromiseType.hpp"
 #include <functional>
-#include <future>
 #include <jsi/jsi.h>
 
 namespace margelo::nitro {
@@ -28,8 +27,8 @@ using namespace facebook;
 // [](Args...) -> T {} <> (Args...) => T
 template <typename ReturnType, typename... Args>
 struct JSIConverter<std::function<ReturnType(Args...)>> final {
-  // std::future<T> -> T
-  using ResultingType = future_type_v<ReturnType>;
+  // Promise<T> -> T
+  using ResultingType = promise_type_v<ReturnType>;
 
   static inline std::function<ReturnType(Args...)> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
     // Make function global - it'll be managed by the Runtime's memory, and we only have a weak_ref to it.
@@ -42,7 +41,7 @@ struct JSIConverter<std::function<ReturnType(Args...)>> final {
 
     // Create a C++ function that can be called by the consumer.
     // This will call the jsi::Function if it is still alive.
-    return [&runtime, weakDispatcher, sharedFunction = std::move(sharedFunction)](Args... args) -> ReturnType {
+    return [&runtime, weakDispatcher = std::move(weakDispatcher), sharedFunction = std::move(sharedFunction)](Args... args) -> ReturnType {
       // Try to get the JS Dispatcher if the Runtime is still alive
       std::shared_ptr<Dispatcher> dispatcher = weakDispatcher.lock();
       if (!dispatcher) {
@@ -56,26 +55,34 @@ struct JSIConverter<std::function<ReturnType(Args...)>> final {
       }
 
       if constexpr (std::is_void_v<ResultingType>) {
-        dispatcher->runAsync(
-            [&runtime, sharedFunction, ... args = std::move(args)]() { callJSFunction(runtime, sharedFunction, args...); });
-      } else {
-        return dispatcher->runAsyncAwaitable<ResultingType>([&runtime, sharedFunction, ... args = std::move(args)]() -> ResultingType {
-          return callJSFunction(runtime, sharedFunction, args...);
+        dispatcher->runAsync([&runtime, sharedFunction = std::move(sharedFunction), ... args = std::move(args)]() {
+          callJSFunction(runtime, sharedFunction, args...);
         });
+      } else {
+        return dispatcher->runAsyncAwaitable<ResultingType>(
+            [&runtime, sharedFunction = std::move(sharedFunction), ... args = std::move(args)]() -> ResultingType {
+              return callJSFunction(runtime, sharedFunction, args...);
+            });
       }
     };
   }
 
-  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::function<ReturnType(Args...)>& function) {
-    jsi::HostFunctionType jsFunction = [function](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* args,
-                                                  size_t count) -> jsi::Value {
+  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 {
       if (count != sizeof...(Args)) [[unlikely]] {
         throw jsi::JSError(runtime, "Function expected " + std::to_string(sizeof...(Args)) + " arguments, but received " +
                                         std::to_string(count) + "!");
       }
       return callHybridFunction(function, runtime, args, std::index_sequence_for<Args...>{});
     };
-    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "hostFunction"), sizeof...(Args), jsFunction);
+    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "hostFunction"), sizeof...(Args),
+                                                 std::move(jsFunction));
+  }
+
+  static inline jsi::Value toJSI(jsi::Runtime& runtime, const std::function<ReturnType(Args...)>& function) {
+    std::function<ReturnType(Args...)> copy = function;
+    return toJSI(runtime, std::move(copy));
   }
 
   static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {

package/cpp/jsi/JSIConverter+Future.hpp

@@ -26,8 +26,9 @@ using namespace facebook;
 template <typename TResult>
 struct JSIConverter<std::future<TResult>> final {
   [[deprecated("Use JSIConverter<std::shared_ptr<Promise<T>>> instead.")]]
-  static inline std::future<TResult> fromJSI(jsi::Runtime&, const jsi::Value&) {
-    throw std::runtime_error("Promise cannot be converted to a native type - it needs to be awaited first!");
+  static inline std::future<TResult> fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    auto promise = JSIConverter<std::shared_ptr<Promise<TResult>>>::fromJSI(runtime, value);
+    return promise->await();
   }
 
   [[deprecated("Use JSIConverter<std::shared_ptr<Promise<T>>> instead.")]]
@@ -37,8 +38,8 @@ struct JSIConverter<std::future<TResult>> final {
   }
 
   [[deprecated("Use JSIConverter<std::shared_ptr<Promise<T>>> instead.")]]
-  static inline bool canConvert(jsi::Runtime&, const jsi::Value&) {
-    throw std::runtime_error("jsi::Value of type Promise cannot be converted to std::future yet!");
+  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    return JSIConverter<std::shared_ptr<Promise<TResult>>>::canConvert(runtime, value);
   }
 };
 

package/cpp/templates/PromiseType.hpp

@@ -0,0 +1,32 @@
+//
+//  PromiseType.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 09.12.24.
+//
+
+#pragma once
+
+#include "Promise.hpp"
+#include <type_traits>
+
+namespace margelo::nitro {
+
+// Gets the `T` in `Promise<T>`.
+template <typename T>
+struct promise_type {
+  using type = void;
+};
+template <typename T>
+struct promise_type<Promise<T>> {
+  using type = T;
+};
+template <typename T>
+struct promise_type<std::shared_ptr<Promise<T>>> {
+  using type = T;
+};
+
+template <typename T>
+using promise_type_v = typename promise_type<std::remove_reference_t<T>>::type;
+
+} // namespace margelo::nitro

package/cpp/threading/Dispatcher.hpp

@@ -4,8 +4,8 @@
 
 #pragma once
 
+#include "Promise.hpp"
 #include <functional>
-#include <future>
 #include <jsi/jsi.h>
 #include <queue>
 #include <unordered_map>
@@ -42,13 +42,12 @@ public:
 
   /**
    * Run the given function asynchronously on the Thread this Dispatcher is managing,
-   * and return a future that will hold the result of the function.
+   * and return a `Promise<T>` that will hold the result of the function.
    */
   template <typename T>
-  std::future<T> runAsyncAwaitable(std::function<T()>&& function) {
+  std::shared_ptr<Promise<T>> runAsyncAwaitable(std::function<T()>&& function) {
     // 1. Create Promise that can be shared between this and dispatcher thread
-    auto promise = std::make_shared<std::promise<T>>();
-    std::future<T> future = promise->get_future();
+    auto promise = Promise<T>::create();
 
     runAsync([function = std::move(function), promise]() {
       try {
@@ -56,21 +55,21 @@ public:
           // 4. Call the actual function on the new Thread
           function();
           // 5.a. Resolve the Promise if we succeeded
-          promise->set_value();
+          promise->resolve();
         } else {
           // 4. Call the actual function on the new Thread
           T result = function();
           // 5.a. Resolve the Promise if we succeeded
-          promise->set_value(std::move(result));
+          promise->resolve(std::move(result));
         }
       } catch (...) {
         // 5.b. Reject the Promise if the call failed
-        promise->set_exception(std::current_exception());
+        promise->reject(std::current_exception());
       }
     });
 
-    // 3. Return an open future that gets resolved later by the dispatcher Thread
-    return future;
+    // 3. Return an open `Promise<T>` that gets resolved later by the dispatcher Thread
+    return promise;
   }
 
 private:

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.18.2"
+#define NITRO_VERSION "0.20.0"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG
@@ -31,19 +31,6 @@
 #define _CXX_INTEROP_HAS_ATTRIBUTE(x) 0
 #endif
 
-#if _CXX_INTEROP_HAS_ATTRIBUTE(swift_attr)
-// Rename Type for Swift
-#define SWIFT_NAME(_name) __attribute__((swift_name(#_name)))
-// Make Swift type private
-#define SWIFT_PRIVATE __attribute__((swift_private))
-// Make getter + setter a computed property
-#define SWIFT_COMPUTED_PROPERTY __attribute__((swift_attr("import_computed_property")))
-#else
-#define SWIFT_NAME(_name)
-#define SWIFT_PRIVATE
-#define SWIFT_COMPUTED_PROPERTY
-#endif
-
 #if _CXX_INTEROP_HAS_ATTRIBUTE(enum_extensibility)
 // Enum is marked as closed/not extensible
 #define CLOSED_ENUM __attribute__((enum_extensibility(closed)))
@@ -51,4 +38,16 @@
 #define CLOSED_ENUM
 #endif
 
+#if __has_include(<swift/bridging>)
+// Swift's bridging header defines those things
+#include <swift/bridging>
+#define SWIFT_PRIVATE __attribute__((swift_private))
+#else
+// If we don't have Swift bridging header, those macros do nothing
+#define SWIFT_NAME(_name)
+#define SWIFT_PRIVATE
+#define SWIFT_COMPUTED_PROPERTY
+#define SWIFT_NONCOPYABLE
+#endif
+
 #endif /* NitroDefines_h */

package/cpp/utils/TypeInfo.hpp

@@ -48,7 +48,7 @@ public:
 #endif
 
     // Make a few edge-cases nicer.
-    name = replaceRegex(name, R"(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>)", "std::string");
+    name = replaceRegex(name, R"(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> ?>)", "std::string");
     name = replaceRegex(name, R"(std::__1::vector<([^>]+), std::__1::allocator<\1>>)", "std::vector<$1>");
     name = replaceRegex(name, R"(std::__1::map<([^,]+), ([^>]+), std::__1::less<\1>, std::__1::allocator<std::__1::pair<const \1, \2>>>)",
                         "std::map<$1, $2>");

package/ios/core/ArrayBufferHolder.hpp

@@ -8,9 +8,9 @@
 #pragma once
 
 #include "ArrayBuffer.hpp"
+#include "NitroDefines.hpp"
 #include "SwiftClosure.hpp"
 #include <memory>
-#include <swift/bridging>
 
 namespace margelo::nitro {
 

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: ArrayBufferHolder) -> 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)

package/ios/core/HybridContext.hpp

@@ -24,7 +24,8 @@ namespace margelo::nitro {
  * This can be used in remote implementations, e.g. in a Swift implementation
  * to properly (weak-)reference the `HybridObject` instead of re-creating it each time.
  */
-struct HybridContext final {
+struct [[deprecated("Update Nitrogen and re-generate your specs.")]]
+HybridContext final {
 public:
   std::weak_ptr<HybridObject> cppPart;