✨ feat: Nitro 20

Author: baronha

example/package.json

@@ -31,7 +31,7 @@
     "@react-native/typescript-config": "0.75.2",
     "@types/react": "~18.2.45",
     "react-native-builder-bob": "^0.30.0",
-    "react-native-nitro-modules": "0.18.2",
+    "react-native-nitro-modules": "0.20.0",
     "typescript": "^5.1.3"
   },
   "private": true

example/yarn.lock

@@ -5414,10 +5414,10 @@ react-native-builder-bob@^0.30.0:
     which "^2.0.2"
     yargs "^17.5.1"
 
-react-native-nitro-modules@0.18.2:
-  version "0.18.2"
-  resolved "https://registry.yarnpkg.com/react-native-nitro-modules/-/react-native-nitro-modules-0.18.2.tgz#f1172f90ecaded0e4b3306f6e7be4b54a24b310e"
-  integrity sha512-eHsq1cRfm/Bz1Nq7KctTqxAqhzVSNo0WGX281xARZh+vOq8633Qxn1NHRZ5/Rno2Bla6HOXlUW6RoW0wKM/7kg==
+react-native-nitro-modules@0.20.0:
+  version "0.20.0"
+  resolved "https://registry.yarnpkg.com/react-native-nitro-modules/-/react-native-nitro-modules-0.20.0.tgz#3c659d4c8cbc8038b1bf35af6475e77023e70ffa"
+  integrity sha512-u41SaGdQ/EQFuRLFPRQ+cbEemzsARmkElXErwZlXJhr2KYmVwQMrIYGe69NuMSyvHlw3JTl09SNugt3PXa2vEQ==
 
 react-native@0.76.5:
   version "0.76.5"

nitrogen/generated/android/c++/JFunc_void_CameraResult.hpp

@@ -34,7 +34,7 @@ namespace margelo::nitro::multipleimagepicker {
 
   public:
     void call(jni::alias_ref<JCameraResult> result) {
-      return _func(result->toCpp());
+      _func(result->toCpp());
     }
 
   public:

nitrogen/generated/android/c++/JFunc_void_CropResult.hpp

@@ -31,7 +31,7 @@ namespace margelo::nitro::multipleimagepicker {
 
   public:
     void call(jni::alias_ref<JCropResult> result) {
-      return _func(result->toCpp());
+      _func(result->toCpp());
     }
 
   public:

nitrogen/generated/android/c++/JFunc_void_double.hpp

@@ -28,7 +28,7 @@ namespace margelo::nitro::multipleimagepicker {
 
   public:
     void call(double reject) {
-      return _func(reject);
+      _func(reject);
     }
 
   public:

nitrogen/generated/android/c++/JFunc_void_std__vector_Result_.hpp

@@ -35,16 +35,16 @@ namespace margelo::nitro::multipleimagepicker {
 
   public:
     void call(jni::alias_ref<jni::JArrayClass<JResult>> result) {
-      return _func([&]() {
-        size_t __size = result->size();
-        std::vector<Result> __vector;
-        __vector.reserve(__size);
-        for (size_t __i = 0; __i < __size; __i++) {
-          auto __element = result->getElement(__i);
-          __vector.push_back(__element->toCpp());
-        }
-        return __vector;
-      }());
+      _func([&]() {
+              size_t __size = result->size();
+              std::vector<Result> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = result->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
     }
 
   public:

nitrogen/generated/ios/MultipleImagePicker-Swift-Cxx-Bridge.cpp

@@ -10,14 +10,45 @@
 // Include C++ implementation defined types
 #include "HybridMultipleImagePickerSpecSwift.hpp"
 #include "MultipleImagePicker-Swift-Cxx-Umbrella.hpp"
-#include <NitroModules/HybridContext.hpp>
 
 namespace margelo::nitro::multipleimagepicker::bridge::swift {
 
+  // pragma MARK: std::function<void(const std::vector<Result>& /* result */)>
+  Func_void_std__vector_Result_ create_Func_void_std__vector_Result_(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = MultipleImagePicker::Func_void_std__vector_Result_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::vector<Result>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(double /* reject */)>
+  Func_void_double create_Func_void_double(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = MultipleImagePicker::Func_void_double::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](double reject) mutable -> void {
+      swiftClosure.call(reject);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const CropResult& /* result */)>
+  Func_void_CropResult create_Func_void_CropResult(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = MultipleImagePicker::Func_void_CropResult::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const CropResult& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const CameraResult& /* result */)>
+  Func_void_CameraResult create_Func_void_CameraResult(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = MultipleImagePicker::Func_void_CameraResult::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const CameraResult& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpec>
   std::shared_ptr<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpec> create_std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_(void* _Nonnull swiftUnsafePointer) {
-    MultipleImagePicker::HybridMultipleImagePickerSpecCxx swiftPart = MultipleImagePicker::HybridMultipleImagePickerSpecCxxUnsafe::fromUnsafe(swiftUnsafePointer);
-    return HybridContext::getOrCreate<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpecSwift>(swiftPart);
+    MultipleImagePicker::HybridMultipleImagePickerSpec_cxx swiftPart = MultipleImagePicker::HybridMultipleImagePickerSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpecSwift>(swiftPart);
   }
   void* _Nonnull get_std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_(std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_ cppType) {
     std::shared_ptr<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpecSwift>(cppType);
@@ -26,8 +57,8 @@ namespace margelo::nitro::multipleimagepicker::bridge::swift {
       throw std::runtime_error("Class \"HybridMultipleImagePickerSpec\" is not implemented in Swift!");
     }
   #endif
-    MultipleImagePicker::HybridMultipleImagePickerSpecCxx swiftPart = swiftWrapper->getSwiftPart();
-    return MultipleImagePicker::HybridMultipleImagePickerSpecCxxUnsafe::toUnsafe(swiftPart);
+    MultipleImagePicker::HybridMultipleImagePickerSpec_cxx swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
   }
 
 } // namespace margelo::nitro::multipleimagepicker::bridge::swift

nitrogen/generated/ios/MultipleImagePicker-Swift-Cxx-Bridge.hpp

@@ -32,8 +32,8 @@ namespace margelo::nitro::multipleimagepicker { struct Result; }
 namespace margelo::nitro::multipleimagepicker { struct Text; }
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridMultipleImagePickerSpecCxx` to properly resolve imports.
-namespace MultipleImagePicker { class HybridMultipleImagePickerSpecCxx; }
+// Forward declaration of `HybridMultipleImagePickerSpec_cxx` to properly resolve imports.
+namespace MultipleImagePicker { class HybridMultipleImagePickerSpec_cxx; }
 
 // Include C++ defined types
 #include "CameraDevice.hpp"
@@ -47,6 +47,8 @@ namespace MultipleImagePicker { class HybridMultipleImagePickerSpecCxx; }
 #include "Result.hpp"
 #include "ResultType.hpp"
 #include "Text.hpp"
+#include <NitroModules/Result.hpp>
+#include <exception>
 #include <functional>
 #include <memory>
 #include <optional>
@@ -163,22 +165,16 @@ namespace margelo::nitro::multipleimagepicker::bridge::swift {
    */
   class Func_void_std__vector_Result__Wrapper final {
   public:
-    explicit Func_void_std__vector_Result__Wrapper(const std::function<void(const std::vector<Result>& /* result */)>& func): _function(func) {}
-    explicit Func_void_std__vector_Result__Wrapper(std::function<void(const std::vector<Result>& /* result */)>&& func): _function(std::move(func)) {}
+    explicit Func_void_std__vector_Result__Wrapper(std::function<void(const std::vector<Result>& /* result */)>&& func): _function(std::make_shared<std::function<void(const std::vector<Result>& /* result */)>>(std::move(func))) {}
     inline void call(std::vector<Result> result) const {
-      _function(result);
+      _function->operator()(result);
     }
   private:
-    std::function<void(const std::vector<Result>& /* result */)> _function;
+    std::shared_ptr<std::function<void(const std::vector<Result>& /* result */)>> _function;
   };
-  inline Func_void_std__vector_Result_ create_Func_void_std__vector_Result_(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */, std::vector<Result>), void(* _Nonnull destroy)(void* _Nonnull)) {
-    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
-    return Func_void_std__vector_Result_([sharedClosureHolder, call](const std::vector<Result>& result) -> void {
-      call(sharedClosureHolder.get(), result);
-    });
-  }
-  inline std::shared_ptr<Func_void_std__vector_Result__Wrapper> share_Func_void_std__vector_Result_(const Func_void_std__vector_Result_& value) {
-    return std::make_shared<Func_void_std__vector_Result__Wrapper>(value);
+  Func_void_std__vector_Result_ create_Func_void_std__vector_Result_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_Result__Wrapper wrap_Func_void_std__vector_Result_(Func_void_std__vector_Result_ value) {
+    return Func_void_std__vector_Result__Wrapper(std::move(value));
   }
 
   // pragma MARK: std::function<void(double /* reject */)>
@@ -191,22 +187,16 @@ namespace margelo::nitro::multipleimagepicker::bridge::swift {
    */
   class Func_void_double_Wrapper final {
   public:
-    explicit Func_void_double_Wrapper(const std::function<void(double /* reject */)>& func): _function(func) {}
-    explicit Func_void_double_Wrapper(std::function<void(double /* reject */)>&& func): _function(std::move(func)) {}
+    explicit Func_void_double_Wrapper(std::function<void(double /* reject */)>&& func): _function(std::make_shared<std::function<void(double /* reject */)>>(std::move(func))) {}
     inline void call(double reject) const {
-      _function(reject);
+      _function->operator()(reject);
     }
   private:
-    std::function<void(double /* reject */)> _function;
+    std::shared_ptr<std::function<void(double /* reject */)>> _function;
   };
-  inline Func_void_double create_Func_void_double(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */, double), void(* _Nonnull destroy)(void* _Nonnull)) {
-    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
-    return Func_void_double([sharedClosureHolder, call](double reject) -> void {
-      call(sharedClosureHolder.get(), reject);
-    });
-  }
-  inline std::shared_ptr<Func_void_double_Wrapper> share_Func_void_double(const Func_void_double& value) {
-    return std::make_shared<Func_void_double_Wrapper>(value);
+  Func_void_double create_Func_void_double(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) {
+    return Func_void_double_Wrapper(std::move(value));
   }
 
   // pragma MARK: std::function<void(const CropResult& /* result */)>
@@ -219,22 +209,16 @@ namespace margelo::nitro::multipleimagepicker::bridge::swift {
    */
   class Func_void_CropResult_Wrapper final {
   public:
-    explicit Func_void_CropResult_Wrapper(const std::function<void(const CropResult& /* result */)>& func): _function(func) {}
-    explicit Func_void_CropResult_Wrapper(std::function<void(const CropResult& /* result */)>&& func): _function(std::move(func)) {}
+    explicit Func_void_CropResult_Wrapper(std::function<void(const CropResult& /* result */)>&& func): _function(std::make_shared<std::function<void(const CropResult& /* result */)>>(std::move(func))) {}
     inline void call(CropResult result) const {
-      _function(result);
+      _function->operator()(result);
     }
   private:
-    std::function<void(const CropResult& /* result */)> _function;
+    std::shared_ptr<std::function<void(const CropResult& /* result */)>> _function;
   };
-  inline Func_void_CropResult create_Func_void_CropResult(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */, CropResult), void(* _Nonnull destroy)(void* _Nonnull)) {
-    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
-    return Func_void_CropResult([sharedClosureHolder, call](const CropResult& result) -> void {
-      call(sharedClosureHolder.get(), result);
-    });
-  }
-  inline std::shared_ptr<Func_void_CropResult_Wrapper> share_Func_void_CropResult(const Func_void_CropResult& value) {
-    return std::make_shared<Func_void_CropResult_Wrapper>(value);
+  Func_void_CropResult create_Func_void_CropResult(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_CropResult_Wrapper wrap_Func_void_CropResult(Func_void_CropResult value) {
+    return Func_void_CropResult_Wrapper(std::move(value));
   }
 
   // pragma MARK: std::vector<MediaPreview>
@@ -258,22 +242,16 @@ namespace margelo::nitro::multipleimagepicker::bridge::swift {
    */
   class Func_void_CameraResult_Wrapper final {
   public:
-    explicit Func_void_CameraResult_Wrapper(const std::function<void(const CameraResult& /* result */)>& func): _function(func) {}
-    explicit Func_void_CameraResult_Wrapper(std::function<void(const CameraResult& /* result */)>&& func): _function(std::move(func)) {}
+    explicit Func_void_CameraResult_Wrapper(std::function<void(const CameraResult& /* result */)>&& func): _function(std::make_shared<std::function<void(const CameraResult& /* result */)>>(std::move(func))) {}
     inline void call(CameraResult result) const {
-      _function(result);
+      _function->operator()(result);
     }
   private:
-    std::function<void(const CameraResult& /* result */)> _function;
+    std::shared_ptr<std::function<void(const CameraResult& /* result */)>> _function;
   };
-  inline Func_void_CameraResult create_Func_void_CameraResult(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */, CameraResult), void(* _Nonnull destroy)(void* _Nonnull)) {
-    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
-    return Func_void_CameraResult([sharedClosureHolder, call](const CameraResult& result) -> void {
-      call(sharedClosureHolder.get(), result);
-    });
-  }
-  inline std::shared_ptr<Func_void_CameraResult_Wrapper> share_Func_void_CameraResult(const Func_void_CameraResult& value) {
-    return std::make_shared<Func_void_CameraResult_Wrapper>(value);
+  Func_void_CameraResult create_Func_void_CameraResult(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_CameraResult_Wrapper wrap_Func_void_CameraResult(Func_void_CameraResult value) {
+    return Func_void_CameraResult_Wrapper(std::move(value));
   }
 
   // pragma MARK: std::shared_ptr<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpec>
@@ -283,5 +261,18 @@ namespace margelo::nitro::multipleimagepicker::bridge::swift {
   using std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_ = std::shared_ptr<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpec>;
   std::shared_ptr<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpec> create_std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_(void* _Nonnull swiftUnsafePointer);
   void* _Nonnull get_std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_(std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpec>
+  using std__weak_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_ = std::weak_ptr<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpec>;
+  inline std__weak_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_ weakify_std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_(const std::shared_ptr<margelo::nitro::multipleimagepicker::HybridMultipleImagePickerSpec>& strong) { return strong; }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) {
+    return Result<void>::withError(error);
+  }
 
 } // namespace margelo::nitro::multipleimagepicker::bridge::swift

nitrogen/generated/ios/MultipleImagePicker-Swift-Cxx-Umbrella.hpp

@@ -73,6 +73,8 @@ namespace margelo::nitro::multipleimagepicker { enum class Theme; }
 #include "SelectMode.hpp"
 #include "Text.hpp"
 #include "Theme.hpp"
+#include <NitroModules/Result.hpp>
+#include <exception>
 #include <functional>
 #include <memory>
 #include <optional>
@@ -89,8 +91,8 @@ namespace margelo::nitro::multipleimagepicker { enum class Theme; }
 #include <NitroModules/RuntimeError.hpp>
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridMultipleImagePickerSpecCxx` to properly resolve imports.
-namespace MultipleImagePicker { class HybridMultipleImagePickerSpecCxx; }
+// Forward declaration of `HybridMultipleImagePickerSpec_cxx` to properly resolve imports.
+namespace MultipleImagePicker { class HybridMultipleImagePickerSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("MultipleImagePicker-Swift.h")

nitrogen/generated/ios/MultipleImagePickerAutolinking.swift

@@ -10,17 +10,16 @@ public final class MultipleImagePickerAutolinking {
 
   /**
    * Creates an instance of a Swift class that implements `HybridMultipleImagePickerSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridMultipleImagePickerSpecCxx`)
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridMultipleImagePickerSpec_cxx`)
    *
    * This is generated by Nitrogen and will initialize the class specified
    * in the `"autolinking"` property of `nitro.json` (in this case, `HybridMultipleImagePicker`).
    */
   public static func createMultipleImagePicker() -> bridge.std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_ {
     let hybridObject = HybridMultipleImagePicker()
     return { () -> bridge.std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_ in
-      let __cxxWrapped = HybridMultipleImagePickerSpecCxx(hybridObject)
-      let __pointer = HybridMultipleImagePickerSpecCxxUnsafe.toUnsafe(__cxxWrapped)
-      return bridge.create_std__shared_ptr_margelo__nitro__multipleimagepicker__HybridMultipleImagePickerSpec_(__pointer)
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
     }()
   }
 }