@onekeyfe/react-native-chart-webview 3.0.39

package/lib/nitrogen/generated/shared/c++/views/HybridChartWebviewComponent.cpp

@@ -0,0 +1,207 @@
+///
+/// HybridChartWebviewComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridChartWebviewComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.hpp>
+#include <react/renderer/core/RawValue.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+namespace margelo::nitro::chartwebview::views {
+
+  extern const char HybridChartWebviewComponentName[] = "ChartWebview";
+
+  HybridChartWebviewProps::HybridChartWebviewProps(const react::PropsParserContext& context,
+                                                   const HybridChartWebviewProps& sourceProps,
+                                                   const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    uri([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("uri", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.uri;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.uri);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.uri: ") + exc.what());
+      }
+    }()),
+    localBundle([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("localBundle", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.localBundle;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.localBundle);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.localBundle: ") + exc.what());
+      }
+    }()),
+    entry([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("entry", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.entry;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.entry);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.entry: ") + exc.what());
+      }
+    }()),
+    paramsJson([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("paramsJson", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.paramsJson;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.paramsJson);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.paramsJson: ") + exc.what());
+      }
+    }()),
+    bridgeScript([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("bridgeScript", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.bridgeScript;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.bridgeScript);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.bridgeScript: ") + exc.what());
+      }
+    }()),
+    reuseKey([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("reuseKey", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.reuseKey;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.reuseKey);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.reuseKey: ") + exc.what());
+      }
+    }()),
+    pooled([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("pooled", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.pooled;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.pooled);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.pooled: ") + exc.what());
+      }
+    }()),
+    active([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("active", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.active;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.active);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.active: ") + exc.what());
+      }
+    }()),
+    onMessage([&]() -> CachedProp<std::optional<std::function<void(const std::string& /* message */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onMessage", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onMessage;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::string& /* message */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onMessage);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.onMessage: ") + exc.what());
+      }
+    }()),
+    onLoadEnd([&]() -> CachedProp<std::optional<std::function<void()>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onLoadEnd", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onLoadEnd;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void()>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onLoadEnd);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.onLoadEnd: ") + exc.what());
+      }
+    }()),
+    onError([&]() -> CachedProp<std::optional<std::function<void(const std::string& /* message */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("onError", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.onError;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::string& /* message */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.onError);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.onError: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridChartWebviewSpec>& /* ref */)>>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("hybridRef", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.hybridRef;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridChartWebviewSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("ChartWebview.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridChartWebviewProps::HybridChartWebviewProps(const HybridChartWebviewProps& other):
+    react::ViewProps(),
+    uri(other.uri),
+    localBundle(other.localBundle),
+    entry(other.entry),
+    paramsJson(other.paramsJson),
+    bridgeScript(other.bridgeScript),
+    reuseKey(other.reuseKey),
+    pooled(other.pooled),
+    active(other.active),
+    onMessage(other.onMessage),
+    onLoadEnd(other.onLoadEnd),
+    onError(other.onError),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridChartWebviewProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("uri"): return true;
+      case hashString("localBundle"): return true;
+      case hashString("entry"): return true;
+      case hashString("paramsJson"): return true;
+      case hashString("bridgeScript"): return true;
+      case hashString("reuseKey"): return true;
+      case hashString("pooled"): return true;
+      case hashString("active"): return true;
+      case hashString("onMessage"): return true;
+      case hashString("onLoadEnd"): return true;
+      case hashString("onError"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridChartWebviewComponentDescriptor::HybridChartWebviewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridChartWebviewComponentDescriptor::cloneProps(const react::PropsParserContext& context,
+                                                                                        const std::shared_ptr<const react::Props>& props,
+                                                                                        react::RawProps rawProps) const {
+    // 1. Prepare raw props parser
+    rawProps.parse(rawPropsParser_);
+    // 2. Copy props with Nitro's cached copy constructor
+    return HybridChartWebviewShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridChartWebviewComponentDescriptor::adopt(react::ShadowNode& shadowNode) const {
+    // This is called immediately after `ShadowNode` is created, cloned or in progress.
+    // On Android, we need to wrap props in our state, which gets routed through Java and later unwrapped in JNI/C++.
+    auto& concreteShadowNode = dynamic_cast<HybridChartWebviewShadowNode&>(shadowNode);
+    const HybridChartWebviewProps& props = concreteShadowNode.getConcreteProps();
+    HybridChartWebviewState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::chartwebview::views

package/lib/nitrogen/generated/shared/c++/views/HybridChartWebviewComponent.hpp

@@ -0,0 +1,118 @@
+///
+/// HybridChartWebviewComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <optional>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/CachedProp.hpp>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <string>
+#include <optional>
+#include <functional>
+#include <memory>
+#include "HybridChartWebviewSpec.hpp"
+
+namespace margelo::nitro::chartwebview::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridChartWebviewComponentName[];
+
+  /**
+   * Props for the "ChartWebview" View.
+   */
+  class HybridChartWebviewProps final: public react::ViewProps {
+  public:
+    HybridChartWebviewProps() = default;
+    HybridChartWebviewProps(const HybridChartWebviewProps&);
+    HybridChartWebviewProps(const react::PropsParserContext& context,
+                            const HybridChartWebviewProps& sourceProps,
+                            const react::RawProps& rawProps);
+
+  public:
+    CachedProp<std::optional<std::string>> uri;
+    CachedProp<std::optional<std::string>> localBundle;
+    CachedProp<std::optional<std::string>> entry;
+    CachedProp<std::optional<std::string>> paramsJson;
+    CachedProp<std::optional<std::string>> bridgeScript;
+    CachedProp<std::optional<std::string>> reuseKey;
+    CachedProp<std::optional<bool>> pooled;
+    CachedProp<std::optional<bool>> active;
+    CachedProp<std::optional<std::function<void(const std::string& /* message */)>>> onMessage;
+    CachedProp<std::optional<std::function<void()>>> onLoadEnd;
+    CachedProp<std::optional<std::function<void(const std::string& /* message */)>>> onError;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridChartWebviewSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "ChartWebview" View.
+   */
+  class HybridChartWebviewState final {
+  public:
+    HybridChartWebviewState() = default;
+
+  public:
+    void setProps(const HybridChartWebviewProps& props) { _props.emplace(props); }
+    const std::optional<HybridChartWebviewProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridChartWebviewState(const HybridChartWebviewState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridChartWebviewState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridChartWebviewState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridChartWebviewProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "ChartWebview" View.
+   */
+  using HybridChartWebviewShadowNode = react::ConcreteViewShadowNode<HybridChartWebviewComponentName /* "HybridChartWebview" */,
+                                                                     HybridChartWebviewProps /* custom props */,
+                                                                     react::ViewEventEmitter /* default */,
+                                                                     HybridChartWebviewState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "ChartWebview" View.
+   */
+  class HybridChartWebviewComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridChartWebviewShadowNode> {
+  public:
+    HybridChartWebviewComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridChartWebviewProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "ChartWebview" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::chartwebview::views

package/lib/nitrogen/generated/shared/json/ChartWebviewConfig.json

@@ -0,0 +1,20 @@
+{
+  "uiViewClassName": "ChartWebview",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "uri": true,
+    "localBundle": true,
+    "entry": true,
+    "paramsJson": true,
+    "bridgeScript": true,
+    "reuseKey": true,
+    "pooled": true,
+    "active": true,
+    "onMessage": true,
+    "onLoadEnd": true,
+    "onError": true,
+    "hybridRef": true
+  }
+}

package/lib/nitrogen/nitrogen/generated/android/c++/JFunc_void.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::chartwebview {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/chartwebview/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/chartwebview/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::chartwebview

package/lib/nitrogen/nitrogen/generated/android/c++/JFunc_void_std__string.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__string.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::chartwebview {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(message: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/chartwebview/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& message) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */)>("invoke");
+      method(self(), jni::make_jstring(message));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* message */)>& func) {
+      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> message) {
+      _func(message->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* message */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/chartwebview/Func_void_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* message */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* message */)> _func;
+  };
+
+} // namespace margelo::nitro::chartwebview