@onekeyfe/react-native-perp-depth-bar 3.0.39

package/lib/nitrogen/generated/ios/swift/HybridPerpDepthBarsSpec_cxx.swift

@@ -0,0 +1,223 @@
+///
+/// HybridPerpDepthBarsSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridPerpDepthBarsSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridPerpDepthBarsSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::perpdepthbar::bridge::swift`)
+   * from `PerpDepthBar-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.perpdepthbar.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridPerpDepthBarsSpec` Swift protocol.
+   */
+  private var __implementation: any HybridPerpDepthBarsSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridPerpDepthBarsSpec_
+
+  /**
+   * Create a new `HybridPerpDepthBarsSpec_cxx` that wraps the given `HybridPerpDepthBarsSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridPerpDepthBarsSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridPerpDepthBarsSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridPerpDepthBarsSpec() -> any HybridPerpDepthBarsSpec {
+    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 `HybridPerpDepthBarsSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridPerpDepthBarsSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridPerpDepthBarsSpec_cxx {
+    return Unmanaged<HybridPerpDepthBarsSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridPerpDepthBarsSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridPerpDepthBarsSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridPerpDepthBarsSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridPerpDepthBarsSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * 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(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  public final var percents: bridge.std__vector_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__vector_double_ in
+        var __vector = bridge.create_std__vector_double_(self.__implementation.percents.count)
+        for __item in self.__implementation.percents {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.percents = newValue.map({ __item in __item })
+    }
+  }
+  
+  public final var rowHeight: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.rowHeight
+    }
+    @inline(__always)
+    set {
+      self.__implementation.rowHeight = newValue
+    }
+  }
+  
+  public final var rowMarginTop: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.rowMarginTop
+    }
+    @inline(__always)
+    set {
+      self.__implementation.rowMarginTop = newValue
+    }
+  }
+  
+  public final var barInset: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.barInset
+    }
+    @inline(__always)
+    set {
+      self.__implementation.barInset = newValue
+    }
+  }
+  
+  public final var color: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.color)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.color = String(newValue)
+    }
+  }
+  
+  public final var origin: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.origin)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.origin = String(newValue)
+    }
+  }
+  
+  public final var reducedMotion: Bool {
+    @inline(__always)
+    get {
+      return self.__implementation.reducedMotion
+    }
+    @inline(__always)
+    set {
+      self.__implementation.reducedMotion = newValue
+    }
+  }
+  
+  public final var epoch: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.epoch
+    }
+    @inline(__always)
+    set {
+      self.__implementation.epoch = newValue
+    }
+  }
+
+  // Methods
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
+  }
+  
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+}

package/lib/nitrogen/generated/ios/swift/HybridPerpSideRatioSpec.swift

@@ -0,0 +1,63 @@
+///
+/// HybridPerpSideRatioSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/// See ``HybridPerpSideRatioSpec``
+public protocol HybridPerpSideRatioSpec_protocol: HybridObject, HybridView {
+  // Properties
+  var bidPercentage: Double { get set }
+  var askPercentage: Double { get set }
+  var longColor: String { get set }
+  var shortColor: String { get set }
+  var segmentHeight: Double { get set }
+  var cornerRadius: Double { get set }
+  var gap: Double { get set }
+  var reducedMotion: Bool { get set }
+
+  // Methods
+  
+}
+
+public extension HybridPerpSideRatioSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject PerpSideRatio]"
+  }
+}
+
+/// See ``HybridPerpSideRatioSpec``
+open class HybridPerpSideRatioSpec_base {
+  private weak var cxxWrapper: HybridPerpSideRatioSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridPerpSideRatioSpec_cxx {
+  #if DEBUG
+    guard self is HybridPerpSideRatioSpec else {
+      fatalError("`self` is not a `HybridPerpSideRatioSpec`! Did you accidentally inherit from `HybridPerpSideRatioSpec_base` instead of `HybridPerpSideRatioSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridPerpSideRatioSpec_cxx(self as! HybridPerpSideRatioSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the PerpSideRatio HybridObject.
+ * Implement this protocol to create Swift-based instances of PerpSideRatio.
+ * ```swift
+ * class HybridPerpSideRatio : HybridPerpSideRatioSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridPerpSideRatioSpec = HybridPerpSideRatioSpec_protocol & HybridPerpSideRatioSpec_base

package/lib/nitrogen/generated/ios/swift/HybridPerpSideRatioSpec_cxx.swift

@@ -0,0 +1,217 @@
+///
+/// HybridPerpSideRatioSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridPerpSideRatioSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridPerpSideRatioSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::perpdepthbar::bridge::swift`)
+   * from `PerpDepthBar-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.perpdepthbar.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridPerpSideRatioSpec` Swift protocol.
+   */
+  private var __implementation: any HybridPerpSideRatioSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridPerpSideRatioSpec_
+
+  /**
+   * Create a new `HybridPerpSideRatioSpec_cxx` that wraps the given `HybridPerpSideRatioSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridPerpSideRatioSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridPerpSideRatioSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridPerpSideRatioSpec() -> any HybridPerpSideRatioSpec {
+    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 `HybridPerpSideRatioSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridPerpSideRatioSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridPerpSideRatioSpec_cxx {
+    return Unmanaged<HybridPerpSideRatioSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridPerpSideRatioSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridPerpSideRatioSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridPerpSideRatioSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridPerpSideRatioSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * 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(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  public final var bidPercentage: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.bidPercentage
+    }
+    @inline(__always)
+    set {
+      self.__implementation.bidPercentage = newValue
+    }
+  }
+  
+  public final var askPercentage: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.askPercentage
+    }
+    @inline(__always)
+    set {
+      self.__implementation.askPercentage = newValue
+    }
+  }
+  
+  public final var longColor: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.longColor)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.longColor = String(newValue)
+    }
+  }
+  
+  public final var shortColor: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.shortColor)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.shortColor = String(newValue)
+    }
+  }
+  
+  public final var segmentHeight: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.segmentHeight
+    }
+    @inline(__always)
+    set {
+      self.__implementation.segmentHeight = newValue
+    }
+  }
+  
+  public final var cornerRadius: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.cornerRadius
+    }
+    @inline(__always)
+    set {
+      self.__implementation.cornerRadius = newValue
+    }
+  }
+  
+  public final var gap: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.gap
+    }
+    @inline(__always)
+    set {
+      self.__implementation.gap = newValue
+    }
+  }
+  
+  public final var reducedMotion: Bool {
+    @inline(__always)
+    get {
+      return self.__implementation.reducedMotion
+    }
+    @inline(__always)
+    set {
+      self.__implementation.reducedMotion = newValue
+    }
+  }
+
+  // Methods
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
+  }
+  
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+}

package/lib/nitrogen/generated/shared/c++/HybridPerpDepthBarsSpec.cpp

@@ -0,0 +1,36 @@
+///
+/// HybridPerpDepthBarsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridPerpDepthBarsSpec.hpp"
+
+namespace margelo::nitro::perpdepthbar {
+
+  void HybridPerpDepthBarsSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("percents", &HybridPerpDepthBarsSpec::getPercents);
+      prototype.registerHybridSetter("percents", &HybridPerpDepthBarsSpec::setPercents);
+      prototype.registerHybridGetter("rowHeight", &HybridPerpDepthBarsSpec::getRowHeight);
+      prototype.registerHybridSetter("rowHeight", &HybridPerpDepthBarsSpec::setRowHeight);
+      prototype.registerHybridGetter("rowMarginTop", &HybridPerpDepthBarsSpec::getRowMarginTop);
+      prototype.registerHybridSetter("rowMarginTop", &HybridPerpDepthBarsSpec::setRowMarginTop);
+      prototype.registerHybridGetter("barInset", &HybridPerpDepthBarsSpec::getBarInset);
+      prototype.registerHybridSetter("barInset", &HybridPerpDepthBarsSpec::setBarInset);
+      prototype.registerHybridGetter("color", &HybridPerpDepthBarsSpec::getColor);
+      prototype.registerHybridSetter("color", &HybridPerpDepthBarsSpec::setColor);
+      prototype.registerHybridGetter("origin", &HybridPerpDepthBarsSpec::getOrigin);
+      prototype.registerHybridSetter("origin", &HybridPerpDepthBarsSpec::setOrigin);
+      prototype.registerHybridGetter("reducedMotion", &HybridPerpDepthBarsSpec::getReducedMotion);
+      prototype.registerHybridSetter("reducedMotion", &HybridPerpDepthBarsSpec::setReducedMotion);
+      prototype.registerHybridGetter("epoch", &HybridPerpDepthBarsSpec::getEpoch);
+      prototype.registerHybridSetter("epoch", &HybridPerpDepthBarsSpec::setEpoch);
+    });
+  }
+
+} // namespace margelo::nitro::perpdepthbar

package/lib/nitrogen/generated/shared/c++/HybridPerpDepthBarsSpec.hpp

@@ -0,0 +1,78 @@
+///
+/// HybridPerpDepthBarsSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <vector>
+#include <string>
+
+namespace margelo::nitro::perpdepthbar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `PerpDepthBars`
+   * Inherit this class to create instances of `HybridPerpDepthBarsSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPerpDepthBars: public HybridPerpDepthBarsSpec {
+   * public:
+   *   HybridPerpDepthBars(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPerpDepthBarsSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPerpDepthBarsSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPerpDepthBarsSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::vector<double> getPercents() = 0;
+      virtual void setPercents(const std::vector<double>& percents) = 0;
+      virtual double getRowHeight() = 0;
+      virtual void setRowHeight(double rowHeight) = 0;
+      virtual double getRowMarginTop() = 0;
+      virtual void setRowMarginTop(double rowMarginTop) = 0;
+      virtual double getBarInset() = 0;
+      virtual void setBarInset(double barInset) = 0;
+      virtual std::string getColor() = 0;
+      virtual void setColor(const std::string& color) = 0;
+      virtual std::string getOrigin() = 0;
+      virtual void setOrigin(const std::string& origin) = 0;
+      virtual bool getReducedMotion() = 0;
+      virtual void setReducedMotion(bool reducedMotion) = 0;
+      virtual double getEpoch() = 0;
+      virtual void setEpoch(double epoch) = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "PerpDepthBars";
+  };
+
+} // namespace margelo::nitro::perpdepthbar

package/lib/nitrogen/generated/shared/c++/HybridPerpSideRatioSpec.cpp

@@ -0,0 +1,36 @@
+///
+/// HybridPerpSideRatioSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridPerpSideRatioSpec.hpp"
+
+namespace margelo::nitro::perpdepthbar {
+
+  void HybridPerpSideRatioSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("bidPercentage", &HybridPerpSideRatioSpec::getBidPercentage);
+      prototype.registerHybridSetter("bidPercentage", &HybridPerpSideRatioSpec::setBidPercentage);
+      prototype.registerHybridGetter("askPercentage", &HybridPerpSideRatioSpec::getAskPercentage);
+      prototype.registerHybridSetter("askPercentage", &HybridPerpSideRatioSpec::setAskPercentage);
+      prototype.registerHybridGetter("longColor", &HybridPerpSideRatioSpec::getLongColor);
+      prototype.registerHybridSetter("longColor", &HybridPerpSideRatioSpec::setLongColor);
+      prototype.registerHybridGetter("shortColor", &HybridPerpSideRatioSpec::getShortColor);
+      prototype.registerHybridSetter("shortColor", &HybridPerpSideRatioSpec::setShortColor);
+      prototype.registerHybridGetter("segmentHeight", &HybridPerpSideRatioSpec::getSegmentHeight);
+      prototype.registerHybridSetter("segmentHeight", &HybridPerpSideRatioSpec::setSegmentHeight);
+      prototype.registerHybridGetter("cornerRadius", &HybridPerpSideRatioSpec::getCornerRadius);
+      prototype.registerHybridSetter("cornerRadius", &HybridPerpSideRatioSpec::setCornerRadius);
+      prototype.registerHybridGetter("gap", &HybridPerpSideRatioSpec::getGap);
+      prototype.registerHybridSetter("gap", &HybridPerpSideRatioSpec::setGap);
+      prototype.registerHybridGetter("reducedMotion", &HybridPerpSideRatioSpec::getReducedMotion);
+      prototype.registerHybridSetter("reducedMotion", &HybridPerpSideRatioSpec::setReducedMotion);
+    });
+  }
+
+} // namespace margelo::nitro::perpdepthbar