react-native-push-signal 0.1.4 → 0.1.6

package/nitrogen/generated/ios/PushSignal-Swift-Cxx-Bridge.cpp

@@ -38,31 +38,6 @@ namespace margelo::nitro::pushsignal::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(bool /* result */)>
-  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = PushSignal::Func_void_bool::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
-      swiftClosure.call(result);
-    };
-  }
-  
-  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>
-  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = PushSignal::Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const PushMessage& message) mutable -> std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> {
-      auto __result = swiftClosure.call(message);
-      return __result;
-    };
-  }
-  
-  // pragma MARK: std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>
-  Func_void_std__shared_ptr_Promise_bool__ create_Func_void_std__shared_ptr_Promise_bool__(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = PushSignal::Func_void_std__shared_ptr_Promise_bool__::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<Promise<bool>>& result) mutable -> void {
-      swiftClosure.call(result);
-    };
-  }
-  
   // pragma MARK: std::function<void(const PushMessage& /* message */)>
   Func_void_PushMessage create_Func_void_PushMessage(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = PushSignal::Func_void_PushMessage::fromUnsafe(swiftClosureWrapper);

package/nitrogen/generated/ios/PushSignal-Swift-Cxx-Bridge.hpp

@@ -165,40 +165,6 @@ namespace margelo::nitro::pushsignal::bridge::swift {
     return Func_void_PushCredentials_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<Promise<bool>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<bool>>`.
-   */
-  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
-  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
-    return Promise<bool>::create();
-  }
-  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
-    return PromiseHolder<bool>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(bool /* result */)>
-  /**
-   * Specialized version of `std::function<void(bool)>`.
-   */
-  using Func_void_bool = std::function<void(bool /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(bool / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_bool_Wrapper final {
-  public:
-    explicit Func_void_bool_Wrapper(std::function<void(bool /* result */)>&& func): _function(std::make_unique<std::function<void(bool /* result */)>>(std::move(func))) {}
-    inline void call(bool result) const noexcept {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(bool /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
-    return Func_void_bool_Wrapper(std::move(value));
-  }
-  
   // pragma MARK: std::unordered_map<std::string, std::string>
   /**
    * Specialized version of `std::unordered_map<std::string, std::string>`.
@@ -224,63 +190,6 @@ namespace margelo::nitro::pushsignal::bridge::swift {
     map.emplace(key, value);
   }
   
-  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>
-  /**
-   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage&)>`.
-   */
-  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>;
-  /**
-   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& / * message * /)>`, this can be used from Swift.
-   */
-  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_Wrapper final {
-  public:
-    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>>(std::move(func))) {}
-    inline std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> call(PushMessage message) const noexcept {
-      auto __result = _function->operator()(message);
-      return __result;
-    }
-  private:
-    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage value) noexcept {
-    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>`.
-   */
-  using std__shared_ptr_Promise_std__shared_ptr_Promise_bool____ = std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>;
-  inline std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_bool____() noexcept {
-    return Promise<std::shared_ptr<Promise<bool>>>::create();
-  }
-  inline PromiseHolder<std::shared_ptr<Promise<bool>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_bool____(std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> promise) noexcept {
-    return PromiseHolder<std::shared_ptr<Promise<bool>>>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const std::shared_ptr<Promise<bool>>&)>`.
-   */
-  using Func_void_std__shared_ptr_Promise_bool__ = std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<bool>>& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__shared_ptr_Promise_bool___Wrapper final {
-  public:
-    explicit Func_void_std__shared_ptr_Promise_bool___Wrapper(std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>>(std::move(func))) {}
-    inline void call(std::shared_ptr<Promise<bool>> result) const noexcept {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<bool>>& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__shared_ptr_Promise_bool__ create_Func_void_std__shared_ptr_Promise_bool__(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__shared_ptr_Promise_bool___Wrapper wrap_Func_void_std__shared_ptr_Promise_bool__(Func_void_std__shared_ptr_Promise_bool__ value) noexcept {
-    return Func_void_std__shared_ptr_Promise_bool___Wrapper(std::move(value));
-  }
-  
   // pragma MARK: std::function<void(const PushMessage& /* message */)>
   /**
    * Specialized version of `std::function<void(const PushMessage&)>`.

package/nitrogen/generated/ios/c++/HybridPushSignalSpecSwift.hpp

@@ -100,7 +100,7 @@ namespace margelo::nitro::pushsignal {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline void setOnMessage(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>& callback) override {
+    inline void setOnMessage(const std::function<void(const PushMessage& /* message */)>& callback) override {
       auto __result = _swiftPart.setOnMessage(callback);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/HybridPushSignalSpec.swift

@@ -15,7 +15,7 @@ public protocol HybridPushSignalSpec_protocol: HybridObject {
   // Methods
   func initialize(config: AndroidFirebaseConfig) throws -> Promise<Void>
   func getCredentials() throws -> Promise<PushCredentials>
-  func setOnMessage(callback: @escaping (_ message: PushMessage) -> Promise<Promise<Bool>>) throws -> Void
+  func setOnMessage(callback: @escaping (_ message: PushMessage) -> Void) throws -> Void
   func setOnNotificationPress(callback: @escaping (_ message: PushMessage) -> Void) throws -> Void
 }
 

package/nitrogen/generated/ios/swift/HybridPushSignalSpec_cxx.swift

@@ -163,33 +163,12 @@ open class HybridPushSignalSpec_cxx {
   }
   
   @inline(__always)
-  public final func setOnMessage(callback: bridge.Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage) -> bridge.Result_void_ {
+  public final func setOnMessage(callback: bridge.Func_void_PushMessage) -> bridge.Result_void_ {
     do {
-      try self.__implementation.setOnMessage(callback: { () -> (PushMessage) -> Promise<Promise<Bool>> in
-        let __wrappedFunction = bridge.wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage(callback)
-        return { (__message: PushMessage) -> Promise<Promise<Bool>> in
-          let __result = __wrappedFunction.call(__message)
-          return { () -> Promise<Promise<Bool>> in
-            let __promise = Promise<Promise<Bool>>()
-            let __resolver = { (__result: Promise<Bool>) in
-              __promise.resolve(withResult: __result)
-            }
-            let __rejecter = { (__error: Error) in
-              __promise.reject(withError: __error)
-            }
-            let __resolverCpp = { () -> bridge.Func_void_std__shared_ptr_Promise_bool__ in
-              let __closureWrapper = Func_void_std__shared_ptr_Promise_bool__(__resolver)
-              return bridge.create_Func_void_std__shared_ptr_Promise_bool__(__closureWrapper.toUnsafe())
-            }()
-            let __rejecterCpp = { () -> bridge.Func_void_std__exception_ptr in
-              let __closureWrapper = Func_void_std__exception_ptr(__rejecter)
-              return bridge.create_Func_void_std__exception_ptr(__closureWrapper.toUnsafe())
-            }()
-            let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_bool____(__result)
-            __promiseHolder.addOnResolvedListener(__resolverCpp)
-            __promiseHolder.addOnRejectedListener(__rejecterCpp)
-            return __promise
-          }()
+      try self.__implementation.setOnMessage(callback: { () -> (PushMessage) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_PushMessage(callback)
+        return { (__message: PushMessage) -> Void in
+          __wrappedFunction.call(__message)
         }
       }())
       return bridge.create_Result_void_()

package/nitrogen/generated/shared/c++/HybridPushSignalSpec.hpp

@@ -59,7 +59,7 @@ namespace margelo::nitro::pushsignal {
       // Methods
       virtual std::shared_ptr<Promise<void>> initialize(const AndroidFirebaseConfig& config) = 0;
       virtual std::shared_ptr<Promise<PushCredentials>> getCredentials() = 0;
-      virtual void setOnMessage(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>& callback) = 0;
+      virtual void setOnMessage(const std::function<void(const PushMessage& /* message */)>& callback) = 0;
       virtual void setOnNotificationPress(const std::function<void(const PushMessage& /* message */)>& callback) = 0;
 
     protected:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-push-signal",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Push",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/PushSignal.nitro.ts

@@ -19,7 +19,7 @@ export interface PushMessage {
 
 export type OnMessageListener = (
   message: PushMessage
-) => boolean | void | Promise<boolean | void>;
+) => void | Promise<void>;
 
 export interface AndroidFirebaseConfig {
   project_id?: string;
@@ -34,6 +34,6 @@ export interface PushSignal extends HybridObject<{
 }> {
   initialize(config: AndroidFirebaseConfig): Promise<void>;
   getCredentials(): Promise<PushCredentials>;
-  setOnMessage(callback: (message: PushMessage) => Promise<boolean>): void;
+  setOnMessage(callback: (message: PushMessage) => void): void;
   setOnNotificationPress(callback: (message: PushMessage) => void): void;
 }

package/src/pushSignal.native.tsx

@@ -21,19 +21,14 @@ function bindNativeCallbacks() {
 
   nativeCallbacksBound = true;
 
-  PushSignalHybridObject.setOnMessage(async (message) => {
-    const listeners = [...messageListeners];
-    const results = await Promise.all(
-      listeners.map(async (listener) => {
-        try {
-          return await listener(message);
-        } catch {
-          return false;
-        }
-      })
-    );
-
-    return results.some((result) => result === true);
+  PushSignalHybridObject.setOnMessage((message) => {
+    for (const listener of [...messageListeners]) {
+      try {
+        void listener(message);
+      } catch {
+        // Ignore listener failures so one bad subscriber cannot break delivery.
+      }
+    }
   });
 
   PushSignalHybridObject.setOnNotificationPress((message) => {

package/nitrogen/generated/android/c++/JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage.hpp

@@ -1,128 +0,0 @@
-///
-/// JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage.hpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include <functional>
-
-#include <NitroModules/Promise.hpp>
-#include "PushMessage.hpp"
-#include <functional>
-#include <NitroModules/JNICallable.hpp>
-#include <NitroModules/JPromise.hpp>
-#include "JPushMessage.hpp"
-#include <string>
-#include <optional>
-#include <unordered_map>
-
-namespace margelo::nitro::pushsignal {
-
-  using namespace facebook;
-
-  /**
-   * Represents the Java/Kotlin callback `(message: PushMessage) -> Promise<Promise<Boolean>>`.
-   * This can be passed around between C++ and Java/Kotlin.
-   */
-  struct JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage: public jni::JavaClass<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage> {
-  public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/pushsignal/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage;";
-
-  public:
-    /**
-     * Invokes the function this `JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage` instance holds through JNI.
-     */
-    std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> invoke(const PushMessage& message) const {
-      static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPushMessage> /* message */)>("invoke");
-      auto __result = method(self(), JPushMessage::fromCpp(message));
-      return [&]() {
-        auto __promise = Promise<std::shared_ptr<Promise<bool>>>::create();
-        __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
-          auto __result = jni::static_ref_cast<JPromise::javaobject>(__boxedResult);
-          __promise->resolve([&]() {
-            auto __promise = Promise<bool>::create();
-            __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
-              auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
-              __promise->resolve(static_cast<bool>(__result->value()));
-            });
-            __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
-              jni::JniException __jniError(__throwable);
-              __promise->reject(std::make_exception_ptr(__jniError));
-            });
-            return __promise;
-          }());
-        });
-        __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
-          jni::JniException __jniError(__throwable);
-          __promise->reject(std::make_exception_ptr(__jniError));
-        });
-        return __promise;
-      }();
-    }
-  };
-
-  /**
-   * An implementation of Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage that is backed by a C++ implementation (using `std::function<...>`)
-   */
-  class JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx final: public jni::HybridClass<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx, JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage> {
-  public:
-    static jni::local_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage::javaobject> fromCpp(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>& func) {
-      return JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx::newObjectCxxArgs(func);
-    }
-
-  public:
-    /**
-     * Invokes the C++ `std::function<...>` this `JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx` instance holds.
-     */
-    jni::local_ref<JPromise::javaobject> invoke_cxx(jni::alias_ref<JPushMessage> message) {
-      std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>> __result = _func(message->toCpp());
-      return [&]() {
-        jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
-        jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
-        __result->addOnResolvedListener([=](const std::shared_ptr<Promise<bool>>& __result) {
-          __promise->cthis()->resolve([&]() {
-            jni::local_ref<JPromise::javaobject> __localPromise = JPromise::create();
-            jni::global_ref<JPromise::javaobject> __promise = jni::make_global(__localPromise);
-            __result->addOnResolvedListener([=](const bool& __result) {
-              __promise->cthis()->resolve(jni::JBoolean::valueOf(__result));
-            });
-            __result->addOnRejectedListener([=](const std::exception_ptr& __error) {
-              auto __jniError = jni::getJavaExceptionForCppException(__error);
-              __promise->cthis()->reject(__jniError);
-            });
-            return __localPromise;
-          }());
-        });
-        __result->addOnRejectedListener([=](const std::exception_ptr& __error) {
-          auto __jniError = jni::getJavaExceptionForCppException(__error);
-          __promise->cthis()->reject(__jniError);
-        });
-        return __localPromise;
-      }();
-    }
-
-  public:
-    [[nodiscard]]
-    inline const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>& getFunction() const {
-      return _func;
-    }
-
-  public:
-    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/pushsignal/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx;";
-    static void registerNatives() {
-      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx::invoke_cxx)});
-    }
-
-  private:
-    explicit JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)>& func): _func(func) { }
-
-  private:
-    friend HybridBase;
-    std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>(const PushMessage& /* message */)> _func;
-  };
-
-} // namespace margelo::nitro::pushsignal

package/nitrogen/generated/android/kotlin/com/margelo/nitro/pushsignal/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage.kt

@@ -1,78 +0,0 @@
-///
-/// Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage.kt
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-package com.margelo.nitro.pushsignal
-
-import androidx.annotation.Keep
-import com.facebook.jni.HybridData
-import com.facebook.proguard.annotations.DoNotStrip
-import com.margelo.nitro.core.Promise
-
-/**
- * Represents the JavaScript callback `(message: struct) => std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>`.
- * This can be either implemented in C++ (in which case it might be a callback coming from JS),
- * or in Kotlin/Java (in which case it is a native callback).
- */
-@DoNotStrip
-@Keep
-@Suppress("ClassName", "RedundantUnitReturnType")
-fun interface Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage: (PushMessage) -> Promise<Promise<Boolean>> {
-  /**
-   * Call the given JS callback.
-   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
-   */
-  @DoNotStrip
-  @Keep
-  override fun invoke(message: PushMessage): Promise<Promise<Boolean>>
-}
-
-/**
- * Represents the JavaScript callback `(message: struct) => std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>`.
- * This is implemented in C++, via a `std::function<...>`.
- * The callback might be coming from JS.
- */
-@DoNotStrip
-@Keep
-@Suppress(
-  "KotlinJniMissingFunction", "unused",
-  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
-  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
-)
-class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_cxx: Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage {
-  @DoNotStrip
-  @Keep
-  private val mHybridData: HybridData
-
-  @DoNotStrip
-  @Keep
-  private constructor(hybridData: HybridData) {
-    mHybridData = hybridData
-  }
-
-  @DoNotStrip
-  @Keep
-  override fun invoke(message: PushMessage): Promise<Promise<Boolean>>
-    = invoke_cxx(message)
-
-  private external fun invoke_cxx(message: PushMessage): Promise<Promise<Boolean>>
-}
-
-/**
- * Represents the JavaScript callback `(message: struct) => std::shared_ptr<Promise<std::shared_ptr<Promise<bool>>>>`.
- * This is implemented in Java/Kotlin, via a `(PushMessage) -> Promise<Promise<Boolean>>`.
- * The callback is always coming from native.
- */
-@DoNotStrip
-@Keep
-@Suppress("ClassName", "RedundantUnitReturnType", "unused")
-class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage_java(private val function: (PushMessage) -> Promise<Promise<Boolean>>): Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage {
-  @DoNotStrip
-  @Keep
-  override fun invoke(message: PushMessage): Promise<Promise<Boolean>> {
-    return this.function(message)
-  }
-}

package/nitrogen/generated/ios/swift/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage.swift

@@ -1,61 +0,0 @@
-///
-/// Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage.swift
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-import NitroModules
-
-/**
- * Wraps a Swift `(_ message: PushMessage) -> Promise<Promise<Bool>>` as a class.
- * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
- */
-public final class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage {
-  public typealias bridge = margelo.nitro.pushsignal.bridge.swift
-
-  private let closure: (_ message: PushMessage) -> Promise<Promise<Bool>>
-
-  public init(_ closure: @escaping (_ message: PushMessage) -> Promise<Promise<Bool>>) {
-    self.closure = closure
-  }
-
-  @inline(__always)
-  public func call(message: PushMessage) -> bridge.std__shared_ptr_Promise_std__shared_ptr_Promise_bool____ {
-    let __result: Promise<Promise<Bool>> = self.closure(message)
-    return { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_Promise_bool____ in
-      let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_Promise_bool____()
-      let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_bool____(__promise)
-      __result
-        .then({ __result in __promiseHolder.resolve({ () -> bridge.std__shared_ptr_Promise_bool__ in
-            let __promise = bridge.create_std__shared_ptr_Promise_bool__()
-            let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
-            __result
-              .then({ __result in __promiseHolder.resolve(__result) })
-              .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
-            return __promise
-          }()) })
-        .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
-      return __promise
-    }()
-  }
-
-  /**
-   * Casts this instance to a retained unsafe raw pointer.
-   * This acquires one additional strong reference on the object!
-   */
-  @inline(__always)
-  public func toUnsafe() -> UnsafeMutableRawPointer {
-    return Unmanaged.passRetained(self).toOpaque()
-  }
-
-  /**
-   * Casts an unsafe pointer to a `Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage>`.
-   * This removes one strong reference from the object!
-   */
-  @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage {
-    return Unmanaged<Func_std__shared_ptr_Promise_std__shared_ptr_Promise_bool_____PushMessage>.fromOpaque(pointer).takeRetainedValue()
-  }
-}

package/nitrogen/generated/ios/swift/Func_void_bool.swift

@@ -1,46 +0,0 @@
-///
-/// Func_void_bool.swift
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-import NitroModules
-
-/**
- * Wraps a Swift `(_ value: Bool) -> Void` as a class.
- * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
- */
-public final class Func_void_bool {
-  public typealias bridge = margelo.nitro.pushsignal.bridge.swift
-
-  private let closure: (_ value: Bool) -> Void
-
-  public init(_ closure: @escaping (_ value: Bool) -> Void) {
-    self.closure = closure
-  }
-
-  @inline(__always)
-  public func call(value: Bool) -> Void {
-    self.closure(value)
-  }
-
-  /**
-   * Casts this instance to a retained unsafe raw pointer.
-   * This acquires one additional strong reference on the object!
-   */
-  @inline(__always)
-  public func toUnsafe() -> UnsafeMutableRawPointer {
-    return Unmanaged.passRetained(self).toOpaque()
-  }
-
-  /**
-   * Casts an unsafe pointer to a `Func_void_bool`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_bool>`.
-   * This removes one strong reference from the object!
-   */
-  @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_bool {
-    return Unmanaged<Func_void_bool>.fromOpaque(pointer).takeRetainedValue()
-  }
-}

package/nitrogen/generated/ios/swift/Func_void_std__shared_ptr_Promise_bool__.swift

@@ -1,66 +0,0 @@
-///
-/// Func_void_std__shared_ptr_Promise_bool__.swift
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-import NitroModules
-
-/**
- * Wraps a Swift `(_ value: Promise<Bool>) -> Void` as a class.
- * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
- */
-public final class Func_void_std__shared_ptr_Promise_bool__ {
-  public typealias bridge = margelo.nitro.pushsignal.bridge.swift
-
-  private let closure: (_ value: Promise<Bool>) -> Void
-
-  public init(_ closure: @escaping (_ value: Promise<Bool>) -> Void) {
-    self.closure = closure
-  }
-
-  @inline(__always)
-  public func call(value: bridge.std__shared_ptr_Promise_bool__) -> Void {
-    self.closure({ () -> Promise<Bool> in
-      let __promise = Promise<Bool>()
-      let __resolver = { (__result: Bool) in
-        __promise.resolve(withResult: __result)
-      }
-      let __rejecter = { (__error: Error) in
-        __promise.reject(withError: __error)
-      }
-      let __resolverCpp = { () -> bridge.Func_void_bool in
-        let __closureWrapper = Func_void_bool(__resolver)
-        return bridge.create_Func_void_bool(__closureWrapper.toUnsafe())
-      }()
-      let __rejecterCpp = { () -> bridge.Func_void_std__exception_ptr in
-        let __closureWrapper = Func_void_std__exception_ptr(__rejecter)
-        return bridge.create_Func_void_std__exception_ptr(__closureWrapper.toUnsafe())
-      }()
-      let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(value)
-      __promiseHolder.addOnResolvedListenerCopy(__resolverCpp)
-      __promiseHolder.addOnRejectedListener(__rejecterCpp)
-      return __promise
-    }())
-  }
-
-  /**
-   * Casts this instance to a retained unsafe raw pointer.
-   * This acquires one additional strong reference on the object!
-   */
-  @inline(__always)
-  public func toUnsafe() -> UnsafeMutableRawPointer {
-    return Unmanaged.passRetained(self).toOpaque()
-  }
-
-  /**
-   * Casts an unsafe pointer to a `Func_void_std__shared_ptr_Promise_bool__`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__shared_ptr_Promise_bool__>`.
-   * This removes one strong reference from the object!
-   */
-  @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__shared_ptr_Promise_bool__ {
-    return Unmanaged<Func_void_std__shared_ptr_Promise_bool__>.fromOpaque(pointer).takeRetainedValue()
-  }
-}