react-native-nitro-ali-push 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,217 @@
+///
+/// HybridAliPushPluginSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridAliPushPluginSpec.hpp"
+
+// Forward declaration of `HybridAliPushPluginSpec_cxx` to properly resolve imports.
+namespace NitroAliPush { class HybridAliPushPluginSpec_cxx; }
+
+// Forward declaration of `AliPushMessage` to properly resolve imports.
+namespace margelo::nitro::alipush { struct AliPushMessage; }
+// Forward declaration of `AliPushMessageType` to properly resolve imports.
+namespace margelo::nitro::alipush { enum class AliPushMessageType; }
+// Forward declaration of `AliPushAppState` to properly resolve imports.
+namespace margelo::nitro::alipush { enum class AliPushAppState; }
+
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include <vector>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <optional>
+#include "AliPushMessage.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include "AliPushMessageType.hpp"
+#include "AliPushAppState.hpp"
+#include <functional>
+
+#include "NitroAliPush-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::alipush {
+
+  /**
+   * The C++ part of HybridAliPushPluginSpec_cxx.swift.
+   *
+   * HybridAliPushPluginSpecSwift (C++) accesses HybridAliPushPluginSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridAliPushPluginSpec_cxx can directly inherit from the C++ class HybridAliPushPluginSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridAliPushPluginSpecSwift: public virtual HybridAliPushPluginSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridAliPushPluginSpecSwift(const NitroAliPush::HybridAliPushPluginSpec_cxx& swiftPart):
+      HybridObject(HybridAliPushPluginSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAliPush::HybridAliPushPluginSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridAliPushPluginSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<void>> initPush(const std::string& appKey, const std::string& appSecret) override {
+      auto __result = _swiftPart.initPush(appKey, appSecret);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> getDeviceId() override {
+      auto __result = _swiftPart.getDeviceId();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> bindAccount(const std::string& account) override {
+      auto __result = _swiftPart.bindAccount(account);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> unbindAccount() override {
+      auto __result = _swiftPart.unbindAccount();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> bindTag(double target, const std::vector<std::string>& tags, const std::optional<std::variant<nitro::NullType, std::string>>& alias) override {
+      auto __result = _swiftPart.bindTag(std::forward<decltype(target)>(target), tags, alias);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> unbindTag(double target, const std::vector<std::string>& tags, const std::optional<std::variant<nitro::NullType, std::string>>& alias) override {
+      auto __result = _swiftPart.unbindTag(std::forward<decltype(target)>(target), tags, alias);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> listTags(double target) override {
+      auto __result = _swiftPart.listTags(std::forward<decltype(target)>(target));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> addAlias(const std::string& alias) override {
+      auto __result = _swiftPart.addAlias(alias);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> removeAlias(const std::string& alias) override {
+      auto __result = _swiftPart.removeAlias(alias);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::string>> listAliases() override {
+      auto __result = _swiftPart.listAliases();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> setApplicationIconBadgeNumber(double badge) override {
+      auto __result = _swiftPart.setApplicationIconBadgeNumber(std::forward<decltype(badge)>(badge));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<double>> getApplicationIconBadgeNumber() override {
+      auto __result = _swiftPart.getApplicationIconBadgeNumber();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::variant<nitro::NullType, AliPushMessage>>> getInitialMessage() override {
+      auto __result = _swiftPart.getInitialMessage();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<bool>> getAuthorizationStatus() override {
+      auto __result = _swiftPart.getAuthorizationStatus();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> syncBadgeNum(double badge) override {
+      auto __result = _swiftPart.syncBadgeNum(std::forward<decltype(badge)>(badge));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::function<void()> addListener(const std::function<void(const AliPushMessage& /* message */)>& listener) override {
+      auto __result = _swiftPart.addListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroAliPush::HybridAliPushPluginSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::alipush

package/nitrogen/generated/ios/swift/AliPushAppState.swift

@@ -0,0 +1,44 @@
+///
+/// AliPushAppState.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `AliPushAppState`, backed by a C++ enum.
+ */
+public typealias AliPushAppState = margelo.nitro.alipush.AliPushAppState
+
+public extension AliPushAppState {
+  /**
+   * Get a AliPushAppState for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "active":
+        self = .active
+      case "inactive":
+        self = .inactive
+      case "background":
+        self = .background
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AliPushAppState represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .active:
+        return "active"
+      case .inactive:
+        return "inactive"
+      case .background:
+        return "background"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/AliPushMessage.swift

@@ -0,0 +1,191 @@
+///
+/// AliPushMessage.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `AliPushMessage`, backed by a C++ struct.
+ */
+public typealias AliPushMessage = margelo.nitro.alipush.AliPushMessage
+
+public extension AliPushMessage {
+  private typealias bridge = margelo.nitro.alipush.bridge.swift
+
+  /**
+   * Create a new instance of `AliPushMessage`.
+   */
+  init(title: String?, subtitle: String?, body: String?, badge: Double?, extras: AnyMap?, type: AliPushMessageType?, actionIdentifier: String?, appState: AliPushAppState?, date: Variant_Double_String?) {
+    self.init({ () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = title {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = subtitle {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = body {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = badge {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__shared_ptr_AnyMap__ in
+      if let __unwrappedValue = extras {
+        return bridge.create_std__optional_std__shared_ptr_AnyMap__(__unwrappedValue.cppPart)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_AliPushMessageType_ in
+      if let __unwrappedValue = type {
+        return bridge.create_std__optional_AliPushMessageType_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = actionIdentifier {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_AliPushAppState_ in
+      if let __unwrappedValue = appState {
+        return bridge.create_std__optional_AliPushAppState_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__variant_double__std__string__ in
+      if let __unwrappedValue = date {
+        return bridge.create_std__optional_std__variant_double__std__string__({ () -> bridge.std__variant_double__std__string_ in
+          switch __unwrappedValue {
+            case .first(let __value):
+              return bridge.create_std__variant_double__std__string_(__value)
+            case .second(let __value):
+              return bridge.create_std__variant_double__std__string_(std.string(__value))
+          }
+        }().variant)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var title: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__title) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__title)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var subtitle: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__subtitle) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__subtitle)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var body: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__body) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__body)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var badge: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__badge) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__badge)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var extras: AnyMap? {
+    return { () -> AnyMap? in
+      if bridge.has_value_std__optional_std__shared_ptr_AnyMap__(self.__extras) {
+        let __unwrapped = bridge.get_std__optional_std__shared_ptr_AnyMap__(self.__extras)
+        return AnyMap(withCppPart: __unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var type: AliPushMessageType? {
+    return self.__type.value
+  }
+  
+  @inline(__always)
+  var actionIdentifier: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__actionIdentifier) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__actionIdentifier)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var appState: AliPushAppState? {
+    return self.__appState.value
+  }
+  
+  @inline(__always)
+  var date: Variant_Double_String? {
+    return { () -> Variant_Double_String? in
+      if bridge.has_value_std__optional_std__variant_double__std__string__(self.__date) {
+        let __unwrapped = bridge.get_std__optional_std__variant_double__std__string__(self.__date)
+        return { () -> Variant_Double_String in
+          let __variant = bridge.std__variant_double__std__string_(__unwrapped)
+          switch __variant.index() {
+            case 0:
+              let __actual = __variant.get_0()
+              return .first(__actual)
+            case 1:
+              let __actual = __variant.get_1()
+              return .second(String(__actual))
+            default:
+              fatalError("Variant can never have index \(__variant.index())!")
+          }
+        }()
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/ios/swift/AliPushMessageType.swift

@@ -0,0 +1,40 @@
+///
+/// AliPushMessageType.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `AliPushMessageType`, backed by a C++ enum.
+ */
+public typealias AliPushMessageType = margelo.nitro.alipush.AliPushMessageType
+
+public extension AliPushMessageType {
+  /**
+   * Get a AliPushMessageType for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "notification":
+        self = .notification
+      case "message":
+        self = .message
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AliPushMessageType represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .notification:
+        return "notification"
+      case .message:
+        return "message"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Func_void.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void.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 `() -> 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 {
+  public typealias bridge = margelo.nitro.alipush.bridge.swift
+
+  private let closure: () -> Void
+
+  public init(_ closure: @escaping () -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call() -> Void {
+    self.closure()
+  }
+
+  /**
+   * 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`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void {
+    return Unmanaged<Func_void>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_AliPushMessage.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_AliPushMessage.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: AliPushMessage) -> 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_AliPushMessage {
+  public typealias bridge = margelo.nitro.alipush.bridge.swift
+
+  private let closure: (_ message: AliPushMessage) -> Void
+
+  public init(_ closure: @escaping (_ message: AliPushMessage) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(message: AliPushMessage) -> Void {
+    self.closure(message)
+  }
+
+  /**
+   * 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_AliPushMessage`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_AliPushMessage>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_AliPushMessage {
+    return Unmanaged<Func_void_AliPushMessage>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

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

@@ -0,0 +1,46 @@
+///
+/// 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.alipush.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_double.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_double.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: Double) -> 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_double {
+  public typealias bridge = margelo.nitro.alipush.bridge.swift
+
+  private let closure: (_ value: Double) -> Void
+
+  public init(_ closure: @escaping (_ value: Double) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: Double) -> 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_double`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_double>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_double {
+    return Unmanaged<Func_void_double>.fromOpaque(pointer).takeRetainedValue()
+  }
+}