@shamilovtim/react-native-nitro-sse 2.3.0

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

@@ -0,0 +1,161 @@
+///
+/// HybridNitroSseSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNitroSseSpec.hpp"
+
+// Forward declaration of `HybridNitroSseSpec_cxx` to properly resolve imports.
+namespace NitroSse { class HybridNitroSseSpec_cxx; }
+
+// Forward declaration of `SseConfig` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseConfig; }
+// Forward declaration of `HttpMethod` to properly resolve imports.
+namespace margelo::nitro::nitrosse { enum class HttpMethod; }
+// Forward declaration of `SseMockConfig` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseMockConfig; }
+// Forward declaration of `SseMockMode` to properly resolve imports.
+namespace margelo::nitro::nitrosse { enum class SseMockMode; }
+// Forward declaration of `SseMockEvent` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseMockEvent; }
+// Forward declaration of `SseEventType` to properly resolve imports.
+namespace margelo::nitro::nitrosse { enum class SseEventType; }
+// Forward declaration of `SseEvent` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseEvent; }
+// Forward declaration of `SseStats` to properly resolve imports.
+namespace margelo::nitro::nitrosse { struct SseStats; }
+
+#include "SseConfig.hpp"
+#include <string>
+#include "HttpMethod.hpp"
+#include <optional>
+#include <unordered_map>
+#include <NitroModules/Promise.hpp>
+#include <functional>
+#include "SseMockConfig.hpp"
+#include "SseMockMode.hpp"
+#include "SseMockEvent.hpp"
+#include <vector>
+#include "SseEventType.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include "SseEvent.hpp"
+#include "SseStats.hpp"
+
+#include "NitroSse-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitrosse {
+
+  /**
+   * The C++ part of HybridNitroSseSpec_cxx.swift.
+   *
+   * HybridNitroSseSpecSwift (C++) accesses HybridNitroSseSpec_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, HybridNitroSseSpec_cxx can directly inherit from the C++ class HybridNitroSseSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNitroSseSpecSwift: public virtual HybridNitroSseSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNitroSseSpecSwift(const NitroSse::HybridNitroSseSpec_cxx& swiftPart):
+      HybridObject(HybridNitroSseSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroSse::HybridNitroSseSpec_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<HybridNitroSseSpecSwift>(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 void setup(const SseConfig& config, const std::function<void(const std::vector<SseEvent>& /* events */)>& onEvent) override {
+      auto __result = _swiftPart.setup(std::forward<decltype(config)>(config), onEvent);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void start() override {
+      auto __result = _swiftPart.start();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void stop() override {
+      auto __result = _swiftPart.stop();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setLastProcessedId(const std::string& id) override {
+      auto __result = _swiftPart.setLastProcessedId(id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void updateHeaders(const std::unordered_map<std::string, std::string>& headers) override {
+      auto __result = _swiftPart.updateHeaders(headers);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline SseStats getStats() override {
+      auto __result = _swiftPart.getStats();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void flush() override {
+      auto __result = _swiftPart.flush();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void restart() override {
+      auto __result = _swiftPart.restart();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline bool isConnected() override {
+      auto __result = _swiftPart.isConnected();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroSse::HybridNitroSseSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitrosse

package/nitrogen/generated/ios/swift/Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____.swift

@@ -0,0 +1,67 @@
+///
+/// Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____.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 `() -> Promise<Promise<Dictionary<String, String>>>` 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_std__unordered_map_std__string__std__string_____ {
+  public typealias bridge = margelo.nitro.nitrosse.bridge.swift
+
+  private let closure: () -> Promise<Promise<Dictionary<String, String>>>
+
+  public init(_ closure: @escaping () -> Promise<Promise<Dictionary<String, String>>>) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call() -> bridge.std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____ {
+    let __result: Promise<Promise<Dictionary<String, String>>> = self.closure()
+    return { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____ in
+      let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____()
+      let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____(__promise)
+      __result
+        .then({ __result in __promiseHolder.resolve({ () -> bridge.std__shared_ptr_Promise_std__unordered_map_std__string__std__string___ in
+            let __promise = bridge.create_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___()
+            let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___(__promise)
+            __result
+              .then({ __result in __promiseHolder.resolve({ () -> bridge.std__unordered_map_std__string__std__string_ in
+                  var __map = bridge.create_std__unordered_map_std__string__std__string_(__result.count)
+                  for (__k, __v) in __result {
+                    bridge.emplace_std__unordered_map_std__string__std__string_(&__map, std.string(__k), std.string(__v))
+                  }
+                  return __map
+                }()) })
+              .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_std__unordered_map_std__string__std__string_____`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____>`.
+   * 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_std__unordered_map_std__string__std__string_____ {
+    return Unmanaged<Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__unordered_map_std__string__std__string_____>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift

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

package/nitrogen/generated/ios/swift/Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___.swift

@@ -0,0 +1,66 @@
+///
+/// Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___.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<Dictionary<String, String>>) -> 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_std__unordered_map_std__string__std__string___ {
+  public typealias bridge = margelo.nitro.nitrosse.bridge.swift
+
+  private let closure: (_ value: Promise<Dictionary<String, String>>) -> Void
+
+  public init(_ closure: @escaping (_ value: Promise<Dictionary<String, String>>) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__shared_ptr_Promise_std__unordered_map_std__string__std__string___) -> Void {
+    self.closure({ () -> Promise<Dictionary<String, String>> in
+      let __promise = Promise<Dictionary<String, String>>()
+      let __resolver = { (__result: Dictionary<String, String>) in
+        __promise.resolve(withResult: __result)
+      }
+      let __rejecter = { (__error: Error) in
+        __promise.reject(withError: __error)
+      }
+      let __resolverCpp = { () -> bridge.Func_void_std__unordered_map_std__string__std__string_ in
+        let __closureWrapper = Func_void_std__unordered_map_std__string__std__string_(__resolver)
+        return bridge.create_Func_void_std__unordered_map_std__string__std__string_(__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__unordered_map_std__string__std__string___(value)
+      __promiseHolder.addOnResolvedListener(__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_std__unordered_map_std__string__std__string___`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___ {
+    return Unmanaged<Func_void_std__shared_ptr_Promise_std__unordered_map_std__string__std__string___>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__unordered_map_std__string__std__string_.swift

@@ -0,0 +1,54 @@
+///
+/// Func_void_std__unordered_map_std__string__std__string_.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: Dictionary<String, String>) -> 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__unordered_map_std__string__std__string_ {
+  public typealias bridge = margelo.nitro.nitrosse.bridge.swift
+
+  private let closure: (_ value: Dictionary<String, String>) -> Void
+
+  public init(_ closure: @escaping (_ value: Dictionary<String, String>) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__unordered_map_std__string__std__string_) -> Void {
+    self.closure({ () -> Dictionary<String, String> in
+      var __dictionary = Dictionary<String, String>(minimumCapacity: value.size())
+      let __keys = bridge.get_std__unordered_map_std__string__std__string__keys(value)
+      for __key in __keys {
+        let __value = bridge.get_std__unordered_map_std__string__std__string__value(value, __key)
+        __dictionary[String(__key)] = String(__value)
+      }
+      return __dictionary
+    }())
+  }
+
+  /**
+   * 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__unordered_map_std__string__std__string_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__unordered_map_std__string__std__string_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__unordered_map_std__string__std__string_ {
+    return Unmanaged<Func_void_std__unordered_map_std__string__std__string_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__vector_SseEvent_.swift

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

package/nitrogen/generated/ios/swift/HttpMethod.swift

@@ -0,0 +1,40 @@
+///
+/// HttpMethod.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 `HttpMethod`, backed by a C++ enum.
+ */
+public typealias HttpMethod = margelo.nitro.nitrosse.HttpMethod
+
+public extension HttpMethod {
+  /**
+   * Get a HttpMethod for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "get":
+        self = .get
+      case "post":
+        self = .post
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this HttpMethod represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .get:
+        return "get"
+      case .post:
+        return "post"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/HybridNitroSseSpec.swift

@@ -0,0 +1,63 @@
+///
+/// HybridNitroSseSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// See ``HybridNitroSseSpec``
+public protocol HybridNitroSseSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func setup(config: SseConfig, onEvent: @escaping (_ events: [SseEvent]) -> Void) throws -> Void
+  func start() throws -> Void
+  func stop() throws -> Void
+  func setLastProcessedId(id: String) throws -> Void
+  func updateHeaders(headers: Dictionary<String, String>) throws -> Void
+  func getStats() throws -> SseStats
+  func flush() throws -> Void
+  func restart() throws -> Void
+  func isConnected() throws -> Bool
+}
+
+public extension HybridNitroSseSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject NitroSse]"
+  }
+}
+
+/// See ``HybridNitroSseSpec``
+open class HybridNitroSseSpec_base {
+  private weak var cxxWrapper: HybridNitroSseSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridNitroSseSpec_cxx {
+  #if DEBUG
+    guard self is any HybridNitroSseSpec else {
+      fatalError("`self` is not a `HybridNitroSseSpec`! Did you accidentally inherit from `HybridNitroSseSpec_base` instead of `HybridNitroSseSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridNitroSseSpec_cxx(self as! any HybridNitroSseSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the NitroSse HybridObject.
+ * Implement this protocol to create Swift-based instances of NitroSse.
+ * ```swift
+ * class HybridNitroSse : HybridNitroSseSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridNitroSseSpec = HybridNitroSseSpec_protocol & HybridNitroSseSpec_base