react-nitro-renderer 0.0.0-stage → 0.0.1-alpha.7

package/nitrogen/generated/apple/swift/HybridWindowSceneSpec.swift

@@ -0,0 +1,65 @@
+///
+/// HybridWindowSceneSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+public import NitroModules
+
+/// See ``HybridWindowSceneSpec``
+public protocol HybridWindowSceneSpec_protocol: HybridWindowSceneSpec_base, HybridObject, WindowScene {
+  // Constructor
+
+
+  // Properties
+  var windows: [(any HybridWindowSpec)] { get }
+
+  // Methods
+
+
+  // Static Properties
+
+
+  // Static Methods
+
+}
+
+public extension HybridWindowSceneSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject WindowScene]"
+  }
+}
+
+/// See ``HybridWindowSceneSpec``
+open class HybridWindowSceneSpec_base {
+  private weak var cxxWrapper: HybridWindowSceneSpec_cxx? = nil
+  public init() throws {
+  }
+  public final func getCxxWrapper() -> HybridWindowSceneSpec_cxx {
+  #if DEBUG
+    guard self is any HybridWindowSceneSpec else {
+      fatalError("`self` is not a `HybridWindowSceneSpec`! Did you accidentally inherit from `HybridWindowSceneSpec_base` instead of `HybridWindowSceneSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridWindowSceneSpec_cxx(self as! any HybridWindowSceneSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the WindowScene HybridObject.
+ * Implement this protocol to create Swift-based instances of WindowScene.
+ * ```swift
+ * class HybridWindowScene : HybridWindowSceneSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridWindowSceneSpec = HybridWindowSceneSpec_protocol & HybridWindowSceneSpec_base

package/nitrogen/generated/apple/swift/HybridWindowSceneSpec_cxx.swift

@@ -0,0 +1,136 @@
+///
+/// HybridWindowSceneSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+internal import NitroModules
+internal import CxxStdlib
+internal import ReactNitroRendererAppleCxx
+
+/**
+ * A class implementation that bridges HybridWindowSceneSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ */
+@_expose(Cxx)
+public final class HybridWindowSceneSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::renderer::swift_bridge`)
+   * from `ReactNitroRendererAppleCxx/ReactNitroRendererAppleCxx.h`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.renderer.swift_bridge
+
+  /**
+   * Holds the Swift implementation of `HybridWindowSceneSpec`.
+   */
+  private let __implementation: HybridWindowScene
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_ = .init()
+
+  /**
+   * Create a new `HybridWindowSceneSpec_cxx` that wraps the given `HybridWindowSceneSpec`.
+   */
+  public init(_ implementation: any HybridWindowSceneSpec) {
+    guard let implementation = implementation as? HybridWindowScene else {
+      preconditionFailure("WindowScene selects HybridWindowScene as its Swift implementation. Every instance must inherit HybridWindowScene.")
+    }
+    self.__implementation = implementation
+
+  }
+
+  /**
+   * Get the actual `HybridWindowSceneSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridWindowSceneSpec() -> any HybridWindowSceneSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridWindowSceneSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridWindowSceneSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(pointer: UnsafeMutableRawPointer) -> HybridWindowSceneSpec_cxx {
+    return Unmanaged<HybridWindowSceneSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * This handle keeps the original native object alive.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_ {
+    let cached = __cxxPart.lock()
+    if cached.use_count() > 0 {
+      return cached
+    }
+    let value = bridge.create_std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_(self.toUnsafe())
+    __cxxPart = bridge.weakify_std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_(value)
+    return value
+  }
+
+
+
+  // A static borrowing accessor lets C++ pass a const reference without copying it.
+  // TODO: Remove this adapter and call the instance method directly once
+  // https://github.com/swiftlang/swift/pull/92862 is merged and supported by our Swift toolchain.
+  @_spi(NitroCxx)
+  public static func getCxxPart(_ value: borrowing HybridWindowSceneSpec_cxx) -> bridge.std__shared_ptr_margelo__nitro__renderer__HybridWindowSceneSpec_ {
+    return value.getCxxPart()
+  }
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(__implementation) + __implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridWindowSceneSpec_cxx) -> Bool {
+    return __implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    __implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return __implementation.toString()
+  }
+
+  // Properties
+
+  public final func getWindows() -> [HybridWindowSpec_cxx] {
+    let value = __implementation.windows
+    return value.map { $0.getCxxWrapper() }
+  }
+
+  // Methods
+}

package/nitrogen/generated/apple/swift/HybridWindowSpec.swift

@@ -0,0 +1,65 @@
+///
+/// HybridWindowSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+public import NitroModules
+
+/// See ``HybridWindowSpec``
+public protocol HybridWindowSpec_protocol: HybridWindowSpec_base, HybridObject, Window {
+  // Constructor
+  init(scene: (any HybridWindowSceneSpec), rootViewController: (any HybridViewControllerSpec)) throws
+
+  // Properties
+  var screen: (any HybridScreenSpec) { get }
+
+  // Methods
+  func makeKeyAndVisible() throws -> Void
+
+  // Static Properties
+
+
+  // Static Methods
+
+}
+
+public extension HybridWindowSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject Window]"
+  }
+}
+
+/// See ``HybridWindowSpec``
+open class HybridWindowSpec_base {
+  private weak var cxxWrapper: HybridWindowSpec_cxx? = nil
+  public init() throws {
+  }
+  public final func getCxxWrapper() -> HybridWindowSpec_cxx {
+  #if DEBUG
+    guard self is any HybridWindowSpec else {
+      fatalError("`self` is not a `HybridWindowSpec`! Did you accidentally inherit from `HybridWindowSpec_base` instead of `HybridWindowSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridWindowSpec_cxx(self as! any HybridWindowSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the Window HybridObject.
+ * Implement this protocol to create Swift-based instances of Window.
+ * ```swift
+ * class HybridWindow : HybridWindowSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridWindowSpec = HybridWindowSpec_protocol & HybridWindowSpec_base

package/nitrogen/generated/apple/swift/HybridWindowSpec_cxx.swift

@@ -0,0 +1,156 @@
+///
+/// HybridWindowSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+internal import NitroModules
+internal import CxxStdlib
+internal import ReactNitroRendererAppleCxx
+
+/**
+ * A class implementation that bridges HybridWindowSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ */
+@_expose(Cxx)
+public final class HybridWindowSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::renderer::swift_bridge`)
+   * from `ReactNitroRendererAppleCxx/ReactNitroRendererAppleCxx.h`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.renderer.swift_bridge
+
+  /**
+   * Holds the Swift implementation of `HybridWindowSpec`.
+   */
+  private let __implementation: HybridWindow
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_margelo__nitro__renderer__HybridWindowSpec_ = .init()
+
+  /**
+   * Create a new `HybridWindowSpec_cxx` that wraps the given `HybridWindowSpec`.
+   */
+  public init(_ implementation: any HybridWindowSpec) {
+    guard let implementation = implementation as? HybridWindow else {
+      preconditionFailure("Window selects HybridWindow as its Swift implementation. Every instance must inherit HybridWindow.")
+    }
+    self.__implementation = implementation
+
+  }
+
+  /**
+   * Get the actual `HybridWindowSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridWindowSpec() -> any HybridWindowSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridWindowSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridWindowSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(pointer: UnsafeMutableRawPointer) -> HybridWindowSpec_cxx {
+    return Unmanaged<HybridWindowSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * This handle keeps the original native object alive.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_ {
+    let cached = __cxxPart.lock()
+    if cached.use_count() > 0 {
+      return cached
+    }
+    let value = bridge.create_std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_(self.toUnsafe())
+    __cxxPart = bridge.weakify_std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_(value)
+    return value
+  }
+
+
+
+  // A static borrowing accessor lets C++ pass a const reference without copying it.
+  // TODO: Remove this adapter and call the instance method directly once
+  // https://github.com/swiftlang/swift/pull/92862 is merged and supported by our Swift toolchain.
+  @_spi(NitroCxx)
+  public static func getCxxPart(_ value: borrowing HybridWindowSpec_cxx) -> bridge.std__shared_ptr_margelo__nitro__renderer__HybridWindowSpec_ {
+    return value.getCxxPart()
+  }
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(__implementation) + __implementation.memorySize
+  }
+
+  /**
+   * Compares this object with the given [other] object for reference equality.
+   */
+  @inline(__always)
+  public func equals(other: HybridWindowSpec_cxx) -> Bool {
+    return __implementation === other.__implementation
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    __implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return __implementation.toString()
+  }
+
+  // Properties
+
+  public final func getScreen() -> HybridScreenSpec_cxx {
+    let value = __implementation.screen
+    return value.getCxxWrapper()
+  }
+
+  // Methods
+
+  public final func makeKeyAndVisible() -> bridge.Result_void {
+    do {
+      try __implementation.makeKeyAndVisible()
+      return bridge.Result_void.withValue()
+    } catch {
+      return bridge.Result_void.withError(error.toCpp())
+    }
+  }
+
+  // Constructor
+
+  public class func constructor(scene: HybridWindowSceneSpec_cxx, rootViewController: HybridViewControllerSpec_cxx) -> bridge.Result_void_ {
+    do {
+      let value = try HybridWindow(scene: scene.getHybridWindowSceneSpec(), rootViewController: rootViewController.getHybridViewControllerSpec())
+      return bridge.Result_void_.withValue(value.getCxxWrapper().toUnsafe())
+    } catch {
+      return bridge.Result_void_.withError(error.toCpp())
+    }
+  }
+}

package/nitrogen/generated/apple/swift/ListenerSubscription.swift

@@ -0,0 +1,29 @@
+///
+/// ListenerSubscription.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+public import NitroModules
+internal import ReactNitroRendererAppleCxx
+internal import CxxStdlib
+
+@_expose(Cxx)
+public struct ListenerSubscription: Sendable {
+  public let remove: any Callback<(), Void>
+
+  public init(remove: any Callback<(), Void>) {
+    self.remove = remove
+  }
+
+  @_spi(NitroCxx)
+  public static func init_cxx(_ remove: UnsafeRawPointer) -> Self {
+    return Self(remove: remove.load(as: margelo.nitro.renderer.swift_bridge.Callback_void.self))
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getRemove_cxx(_ __outResult: UnsafeMutableRawPointer) -> Void {
+    __outResult.initializeMemory(as: margelo.nitro.renderer.swift_bridge.Callback_void.self, repeating: self.remove.toCpp(), count: 1)
+  }
+}

package/nitrogen/generated/apple/swift/ModifierKey.swift

@@ -0,0 +1,64 @@
+///
+/// ModifierKey.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+
+
+/**
+ * Represents the JS union `ModifierKey`.
+ */
+@_expose(Cxx)
+public enum ModifierKey: Int32, CaseIterable, Sendable, CustomStringConvertible {
+  case `command` = 0
+  case `alternate` = 1
+  case `control` = 2
+  case `shift` = 3
+
+  public static func fromRawValue(_ value: Int32) -> Self {
+    return Self(rawValue: value)!
+  }
+}
+
+public extension ModifierKey {
+  /**
+   * Get a ModifierKey for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "command":
+        self = .command
+      case "alternate":
+        self = .alternate
+      case "control":
+        self = .control
+      case "shift":
+        self = .shift
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this ModifierKey represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .command:
+        return "command"
+      case .alternate:
+        return "alternate"
+      case .control:
+        return "control"
+      case .shift:
+        return "shift"
+    }
+  }
+
+  var description: String {
+    return stringValue
+  }
+}

package/nitrogen/generated/apple/swift/Point.swift

@@ -0,0 +1,35 @@
+///
+/// Point.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+internal import NitroModules
+internal import CxxStdlib
+
+@_expose(Cxx)
+public struct Point: Equatable, Hashable, Sendable {
+  public let x: Double
+  public let y: Double
+
+  public init(x: Double, y: Double) {
+    self.x = x
+    self.y = y
+  }
+
+  @_spi(NitroCxx)
+  public static func init_cxx(_ x: Double, _ y: Double) -> Self {
+    return Self(x: x, y: y)
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getX_cxx() -> Double {
+    return self.x
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getY_cxx() -> Double {
+    return self.y
+  }
+}

package/nitrogen/generated/apple/swift/Point3D.swift

@@ -0,0 +1,42 @@
+///
+/// Point3D.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+internal import NitroModules
+internal import CxxStdlib
+
+@_expose(Cxx)
+public struct Point3D: Equatable, Hashable, Sendable {
+  public let x: Double
+  public let y: Double
+  public let z: Double
+
+  public init(x: Double, y: Double, z: Double) {
+    self.x = x
+    self.y = y
+    self.z = z
+  }
+
+  @_spi(NitroCxx)
+  public static func init_cxx(_ x: Double, _ y: Double, _ z: Double) -> Self {
+    return Self(x: x, y: y, z: z)
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getX_cxx() -> Double {
+    return self.x
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getY_cxx() -> Double {
+    return self.y
+  }
+
+  @_spi(NitroCxx)
+  public borrowing func getZ_cxx() -> Double {
+    return self.z
+  }
+}

package/nitrogen/generated/apple/swift/Promise___ReactNitroRenderer__HybridWindowSpec_cxx.swift

@@ -0,0 +1,102 @@
+///
+/// Promise___ReactNitroRenderer__HybridWindowSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+public import NitroModules
+internal import CxxStdlib
+public import Dispatch
+internal import ReactNitroRendererAppleCxx
+
+public typealias Promise___ReactNitroRenderer__HybridWindowSpec_cxx = margelo.nitro.renderer.swift_bridge.Promise___ReactNitroRenderer__HybridWindowSpec_cxx
+
+extension Promise___ReactNitroRenderer__HybridWindowSpec_cxx {
+  public typealias T = (any HybridWindowSpec)
+  private typealias bridge = margelo.nitro.renderer.swift_bridge
+
+  public func __nitroResolve(result: (any HybridWindowSpec)) {
+    withUnsafePointer(to: result.getCxxWrapper()) { (pointer: UnsafePointer<HybridWindowSpec_cxx>) -> Void in
+      bridge.resolve_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(self, pointer)
+    }
+  }
+  public func __nitroReject(error: any Error) {
+    bridge.reject_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(self, error.toCpp())
+  }
+
+  public func __nitroAddOnResolvedListener(_ listener: @escaping @Sendable ((any HybridWindowSpec)) -> Void) {
+    bridge.listen_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(self, .init { (value: UnsafeRawPointer!) -> Void in
+      listener(value.load(as: HybridWindowSpec_cxx.self).getHybridWindowSpec())
+    })
+  }
+  public func __nitroAddOnRejectedListener(_ listener: @escaping @Sendable (any Error) -> Void) {
+    bridge.listenRejected_Promise___ReactNitroRenderer__HybridWindowSpec_cxx(self, .init { (exceptionPtr: std.exception_ptr) -> Void in
+      listener(RuntimeError.from(cppError: exceptionPtr))
+    })
+  }
+}
+
+extension Promise<(any HybridWindowSpec)> where Self == Promise___ReactNitroRenderer__HybridWindowSpec_cxx {
+  public static func pending() -> Self {
+    return margelo.nitro.renderer.swift_bridge.create_Promise___ReactNitroRenderer__HybridWindowSpec_cxx()
+  }
+
+  public static func resolved(with result: (any HybridWindowSpec)) -> Self {
+    let promise = Promise___ReactNitroRenderer__HybridWindowSpec_cxx.pending()
+    promise.resolve(result: result)
+    return promise
+  }
+  public static func rejected(with error: any Error) -> Self {
+    let promise = Promise___ReactNitroRenderer__HybridWindowSpec_cxx.pending()
+    promise.reject(error: error)
+    return promise
+  }
+
+  public static func `async`(
+    _ priority: TaskPriority? = nil,
+    _ run: sending @escaping @isolated(any) () async throws -> sending (any HybridWindowSpec)
+  ) -> Self {
+    let promise = Promise___ReactNitroRenderer__HybridWindowSpec_cxx.pending()
+    Task(priority: priority) { () async -> Void in
+      do {
+        promise.resolve(result: try await run())
+      } catch {
+        promise.reject(error: error)
+      }
+    }
+    return promise
+  }
+
+  public static func parallel(
+    _ queue: DispatchQueue = .global(),
+    _ run: @escaping @Sendable () throws -> (any HybridWindowSpec)
+  ) -> Self {
+    let promise = Promise___ReactNitroRenderer__HybridWindowSpec_cxx.pending()
+    queue.async { () -> Void in
+      do {
+        promise.resolve(result: try run())
+      } catch {
+        promise.reject(error: error)
+      }
+    }
+    return promise
+  }
+}
+
+extension Promise<(any HybridWindowSpec)> {
+  func toCpp() -> Promise___ReactNitroRenderer__HybridWindowSpec_cxx {
+    if let self = self as? Promise___ReactNitroRenderer__HybridWindowSpec_cxx {
+      return self
+    } else {
+      let promise = Promise___ReactNitroRenderer__HybridWindowSpec_cxx.pending()
+      self.addOnResolvedListener { (result: (any HybridWindowSpec)) -> Void in
+        promise.resolve(result: result)
+      }
+      self.addOnRejectedListener { (error: any Error) -> Void in
+        promise.reject(error: error)
+      }
+      return promise
+    }
+  }
+}