@onekeyfe/react-native-chart-webview 3.0.39

package/nitrogen/generated/ios/swift/HybridChartWebviewSpec.swift

@@ -0,0 +1,68 @@
+///
+/// HybridChartWebviewSpec.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 ``HybridChartWebviewSpec``
+public protocol HybridChartWebviewSpec_protocol: HybridObject, HybridView {
+  // Properties
+  var uri: String? { get set }
+  var localBundle: String? { get set }
+  var entry: String? { get set }
+  var paramsJson: String? { get set }
+  var bridgeScript: String? { get set }
+  var reuseKey: String? { get set }
+  var pooled: Bool? { get set }
+  var active: Bool? { get set }
+  var onMessage: ((_ message: String) -> Void)? { get set }
+  var onLoadEnd: (() -> Void)? { get set }
+  var onError: ((_ message: String) -> Void)? { get set }
+
+  // Methods
+  func postMessage(message: String) throws -> Void
+  func reload() throws -> Void
+  func clearSnapshot() throws -> Void
+}
+
+public extension HybridChartWebviewSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject ChartWebview]"
+  }
+}
+
+/// See ``HybridChartWebviewSpec``
+open class HybridChartWebviewSpec_base {
+  private weak var cxxWrapper: HybridChartWebviewSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridChartWebviewSpec_cxx {
+  #if DEBUG
+    guard self is HybridChartWebviewSpec else {
+      fatalError("`self` is not a `HybridChartWebviewSpec`! Did you accidentally inherit from `HybridChartWebviewSpec_base` instead of `HybridChartWebviewSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridChartWebviewSpec_cxx(self as! HybridChartWebviewSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the ChartWebview HybridObject.
+ * Implement this protocol to create Swift-based instances of ChartWebview.
+ * ```swift
+ * class HybridChartWebview : HybridChartWebviewSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridChartWebviewSpec = HybridChartWebviewSpec_protocol & HybridChartWebviewSpec_base

package/nitrogen/generated/ios/swift/HybridChartWebviewSpec_cxx.swift

@@ -0,0 +1,450 @@
+///
+/// HybridChartWebviewSpec_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 HybridChartWebviewSpec 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 HybridChartWebviewSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::chartwebview::bridge::swift`)
+   * from `ChartWebview-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.chartwebview.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridChartWebviewSpec` Swift protocol.
+   */
+  private var __implementation: any HybridChartWebviewSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridChartWebviewSpec_
+
+  /**
+   * Create a new `HybridChartWebviewSpec_cxx` that wraps the given `HybridChartWebviewSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridChartWebviewSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridChartWebviewSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridChartWebviewSpec() -> any HybridChartWebviewSpec {
+    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 `HybridChartWebviewSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridChartWebviewSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridChartWebviewSpec_cxx {
+    return Unmanaged<HybridChartWebviewSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridChartWebviewSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridChartWebviewSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridChartWebviewSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridChartWebviewSpec_(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 uri: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.uri {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.uri = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var localBundle: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.localBundle {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.localBundle = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var entry: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.entry {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.entry = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var paramsJson: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.paramsJson {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.paramsJson = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var bridgeScript: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.bridgeScript {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.bridgeScript = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var reuseKey: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.reuseKey {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.reuseKey = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var pooled: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.pooled {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.pooled = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var active: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.active {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.active = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onMessage: bridge.std__optional_std__function_void_const_std__string_____message______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_std__string_____message______ in
+        if let __unwrappedValue = self.__implementation.onMessage {
+          return bridge.create_std__optional_std__function_void_const_std__string_____message______({ () -> bridge.Func_void_std__string in
+            let __closureWrapper = Func_void_std__string(__unwrappedValue)
+            return bridge.create_Func_void_std__string(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onMessage = { () -> ((_ message: String) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_std__string_____message______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_std__string_____message______(newValue)
+          return { () -> (String) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_std__string(__unwrapped)
+            return { (__message: String) -> Void in
+              __wrappedFunction.call(std.string(__message))
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onLoadEnd: bridge.std__optional_std__function_void____ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void____ in
+        if let __unwrappedValue = self.__implementation.onLoadEnd {
+          return bridge.create_std__optional_std__function_void____({ () -> bridge.Func_void in
+            let __closureWrapper = Func_void(__unwrappedValue)
+            return bridge.create_Func_void(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onLoadEnd = { () -> (() -> Void)? in
+        if bridge.has_value_std__optional_std__function_void____(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void____(newValue)
+          return { () -> () -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void(__unwrapped)
+            return { () -> Void in
+              __wrappedFunction.call()
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var onError: bridge.std__optional_std__function_void_const_std__string_____message______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_const_std__string_____message______ in
+        if let __unwrappedValue = self.__implementation.onError {
+          return bridge.create_std__optional_std__function_void_const_std__string_____message______({ () -> bridge.Func_void_std__string in
+            let __closureWrapper = Func_void_std__string(__unwrappedValue)
+            return bridge.create_Func_void_std__string(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onError = { () -> ((_ message: String) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_const_std__string_____message______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_const_std__string_____message______(newValue)
+          return { () -> (String) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_std__string(__unwrapped)
+            return { (__message: String) -> Void in
+              __wrappedFunction.call(std.string(__message))
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+
+  // Methods
+  @inline(__always)
+  public final func postMessage(message: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.postMessage(message: String(message))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func reload() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.reload()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func clearSnapshot() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.clearSnapshot()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
+  }
+  
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+}

package/nitrogen/generated/shared/c++/HybridChartWebviewSpec.cpp

@@ -0,0 +1,45 @@
+///
+/// HybridChartWebviewSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridChartWebviewSpec.hpp"
+
+namespace margelo::nitro::chartwebview {
+
+  void HybridChartWebviewSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("uri", &HybridChartWebviewSpec::getUri);
+      prototype.registerHybridSetter("uri", &HybridChartWebviewSpec::setUri);
+      prototype.registerHybridGetter("localBundle", &HybridChartWebviewSpec::getLocalBundle);
+      prototype.registerHybridSetter("localBundle", &HybridChartWebviewSpec::setLocalBundle);
+      prototype.registerHybridGetter("entry", &HybridChartWebviewSpec::getEntry);
+      prototype.registerHybridSetter("entry", &HybridChartWebviewSpec::setEntry);
+      prototype.registerHybridGetter("paramsJson", &HybridChartWebviewSpec::getParamsJson);
+      prototype.registerHybridSetter("paramsJson", &HybridChartWebviewSpec::setParamsJson);
+      prototype.registerHybridGetter("bridgeScript", &HybridChartWebviewSpec::getBridgeScript);
+      prototype.registerHybridSetter("bridgeScript", &HybridChartWebviewSpec::setBridgeScript);
+      prototype.registerHybridGetter("reuseKey", &HybridChartWebviewSpec::getReuseKey);
+      prototype.registerHybridSetter("reuseKey", &HybridChartWebviewSpec::setReuseKey);
+      prototype.registerHybridGetter("pooled", &HybridChartWebviewSpec::getPooled);
+      prototype.registerHybridSetter("pooled", &HybridChartWebviewSpec::setPooled);
+      prototype.registerHybridGetter("active", &HybridChartWebviewSpec::getActive);
+      prototype.registerHybridSetter("active", &HybridChartWebviewSpec::setActive);
+      prototype.registerHybridGetter("onMessage", &HybridChartWebviewSpec::getOnMessage);
+      prototype.registerHybridSetter("onMessage", &HybridChartWebviewSpec::setOnMessage);
+      prototype.registerHybridGetter("onLoadEnd", &HybridChartWebviewSpec::getOnLoadEnd);
+      prototype.registerHybridSetter("onLoadEnd", &HybridChartWebviewSpec::setOnLoadEnd);
+      prototype.registerHybridGetter("onError", &HybridChartWebviewSpec::getOnError);
+      prototype.registerHybridSetter("onError", &HybridChartWebviewSpec::setOnError);
+      prototype.registerHybridMethod("postMessage", &HybridChartWebviewSpec::postMessage);
+      prototype.registerHybridMethod("reload", &HybridChartWebviewSpec::reload);
+      prototype.registerHybridMethod("clearSnapshot", &HybridChartWebviewSpec::clearSnapshot);
+    });
+  }
+
+} // namespace margelo::nitro::chartwebview

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

@@ -0,0 +1,87 @@
+///
+/// HybridChartWebviewSpec.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 <string>
+#include <optional>
+#include <functional>
+
+namespace margelo::nitro::chartwebview {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ChartWebview`
+   * Inherit this class to create instances of `HybridChartWebviewSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridChartWebview: public HybridChartWebviewSpec {
+   * public:
+   *   HybridChartWebview(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridChartWebviewSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridChartWebviewSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridChartWebviewSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<std::string> getUri() = 0;
+      virtual void setUri(const std::optional<std::string>& uri) = 0;
+      virtual std::optional<std::string> getLocalBundle() = 0;
+      virtual void setLocalBundle(const std::optional<std::string>& localBundle) = 0;
+      virtual std::optional<std::string> getEntry() = 0;
+      virtual void setEntry(const std::optional<std::string>& entry) = 0;
+      virtual std::optional<std::string> getParamsJson() = 0;
+      virtual void setParamsJson(const std::optional<std::string>& paramsJson) = 0;
+      virtual std::optional<std::string> getBridgeScript() = 0;
+      virtual void setBridgeScript(const std::optional<std::string>& bridgeScript) = 0;
+      virtual std::optional<std::string> getReuseKey() = 0;
+      virtual void setReuseKey(const std::optional<std::string>& reuseKey) = 0;
+      virtual std::optional<bool> getPooled() = 0;
+      virtual void setPooled(std::optional<bool> pooled) = 0;
+      virtual std::optional<bool> getActive() = 0;
+      virtual void setActive(std::optional<bool> active) = 0;
+      virtual std::optional<std::function<void(const std::string& /* message */)>> getOnMessage() = 0;
+      virtual void setOnMessage(const std::optional<std::function<void(const std::string& /* message */)>>& onMessage) = 0;
+      virtual std::optional<std::function<void()>> getOnLoadEnd() = 0;
+      virtual void setOnLoadEnd(const std::optional<std::function<void()>>& onLoadEnd) = 0;
+      virtual std::optional<std::function<void(const std::string& /* message */)>> getOnError() = 0;
+      virtual void setOnError(const std::optional<std::function<void(const std::string& /* message */)>>& onError) = 0;
+
+    public:
+      // Methods
+      virtual void postMessage(const std::string& message) = 0;
+      virtual void reload() = 0;
+      virtual void clearSnapshot() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ChartWebview";
+  };
+
+} // namespace margelo::nitro::chartwebview