@onekeyfe/react-native-chart-webview 3.0.39

package/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/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

package/nitrogen/generated/android/c++/JHybridChartWebviewSpec.cpp

@@ -0,0 +1,186 @@
+///
+/// JHybridChartWebviewSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridChartWebviewSpec.hpp"
+
+
+
+#include <string>
+#include <optional>
+#include <functional>
+#include "JFunc_void_std__string.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void.hpp"
+
+namespace margelo::nitro::chartwebview {
+
+  jni::local_ref<JHybridChartWebviewSpec::jhybriddata> JHybridChartWebviewSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridChartWebviewSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridChartWebviewSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridChartWebviewSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridChartWebviewSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridChartWebviewSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<std::string> JHybridChartWebviewSpec::getUri() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getUri");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setUri(const std::optional<std::string>& uri) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* uri */)>("setUri");
+    method(_javaPart, uri.has_value() ? jni::make_jstring(uri.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridChartWebviewSpec::getLocalBundle() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getLocalBundle");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setLocalBundle(const std::optional<std::string>& localBundle) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* localBundle */)>("setLocalBundle");
+    method(_javaPart, localBundle.has_value() ? jni::make_jstring(localBundle.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridChartWebviewSpec::getEntry() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getEntry");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setEntry(const std::optional<std::string>& entry) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* entry */)>("setEntry");
+    method(_javaPart, entry.has_value() ? jni::make_jstring(entry.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridChartWebviewSpec::getParamsJson() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getParamsJson");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setParamsJson(const std::optional<std::string>& paramsJson) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* paramsJson */)>("setParamsJson");
+    method(_javaPart, paramsJson.has_value() ? jni::make_jstring(paramsJson.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridChartWebviewSpec::getBridgeScript() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getBridgeScript");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setBridgeScript(const std::optional<std::string>& bridgeScript) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* bridgeScript */)>("setBridgeScript");
+    method(_javaPart, bridgeScript.has_value() ? jni::make_jstring(bridgeScript.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridChartWebviewSpec::getReuseKey() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getReuseKey");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setReuseKey(const std::optional<std::string>& reuseKey) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* reuseKey */)>("setReuseKey");
+    method(_javaPart, reuseKey.has_value() ? jni::make_jstring(reuseKey.value()) : nullptr);
+  }
+  std::optional<bool> JHybridChartWebviewSpec::getPooled() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getPooled");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setPooled(std::optional<bool> pooled) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* pooled */)>("setPooled");
+    method(_javaPart, pooled.has_value() ? jni::JBoolean::valueOf(pooled.value()) : nullptr);
+  }
+  std::optional<bool> JHybridChartWebviewSpec::getActive() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getActive");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setActive(std::optional<bool> active) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* active */)>("setActive");
+    method(_javaPart, active.has_value() ? jni::JBoolean::valueOf(active.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* message */)>> JHybridChartWebviewSpec::getOnMessage() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnMessage_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* message */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setOnMessage(const std::optional<std::function<void(const std::string& /* message */)>>& onMessage) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onMessage */)>("setOnMessage_cxx");
+    method(_javaPart, onMessage.has_value() ? JFunc_void_std__string_cxx::fromCpp(onMessage.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridChartWebviewSpec::getOnLoadEnd() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnLoadEnd_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setOnLoadEnd(const std::optional<std::function<void()>>& onLoadEnd) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onLoadEnd */)>("setOnLoadEnd_cxx");
+    method(_javaPart, onLoadEnd.has_value() ? JFunc_void_cxx::fromCpp(onLoadEnd.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* message */)>> JHybridChartWebviewSpec::getOnError() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnError_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* message */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridChartWebviewSpec::setOnError(const std::optional<std::function<void(const std::string& /* message */)>>& onError) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onError */)>("setOnError_cxx");
+    method(_javaPart, onError.has_value() ? JFunc_void_std__string_cxx::fromCpp(onError.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridChartWebviewSpec::postMessage(const std::string& message) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */)>("postMessage");
+    method(_javaPart, jni::make_jstring(message));
+  }
+  void JHybridChartWebviewSpec::reload() {
+    static const auto method = javaClassStatic()->getMethod<void()>("reload");
+    method(_javaPart);
+  }
+  void JHybridChartWebviewSpec::clearSnapshot() {
+    static const auto method = javaClassStatic()->getMethod<void()>("clearSnapshot");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::chartwebview

package/nitrogen/generated/android/c++/JHybridChartWebviewSpec.hpp

@@ -0,0 +1,88 @@
+///
+/// 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
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridChartWebviewSpec.hpp"
+
+
+
+
+namespace margelo::nitro::chartwebview {
+
+  using namespace facebook;
+
+  class JHybridChartWebviewSpec: public jni::HybridClass<JHybridChartWebviewSpec, JHybridObject>,
+                                 public virtual HybridChartWebviewSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/chartwebview/HybridChartWebviewSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridChartWebviewSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridChartWebviewSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridChartWebviewSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridChartWebviewSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::string> getUri() override;
+    void setUri(const std::optional<std::string>& uri) override;
+    std::optional<std::string> getLocalBundle() override;
+    void setLocalBundle(const std::optional<std::string>& localBundle) override;
+    std::optional<std::string> getEntry() override;
+    void setEntry(const std::optional<std::string>& entry) override;
+    std::optional<std::string> getParamsJson() override;
+    void setParamsJson(const std::optional<std::string>& paramsJson) override;
+    std::optional<std::string> getBridgeScript() override;
+    void setBridgeScript(const std::optional<std::string>& bridgeScript) override;
+    std::optional<std::string> getReuseKey() override;
+    void setReuseKey(const std::optional<std::string>& reuseKey) override;
+    std::optional<bool> getPooled() override;
+    void setPooled(std::optional<bool> pooled) override;
+    std::optional<bool> getActive() override;
+    void setActive(std::optional<bool> active) override;
+    std::optional<std::function<void(const std::string& /* message */)>> getOnMessage() override;
+    void setOnMessage(const std::optional<std::function<void(const std::string& /* message */)>>& onMessage) override;
+    std::optional<std::function<void()>> getOnLoadEnd() override;
+    void setOnLoadEnd(const std::optional<std::function<void()>>& onLoadEnd) override;
+    std::optional<std::function<void(const std::string& /* message */)>> getOnError() override;
+    void setOnError(const std::optional<std::function<void(const std::string& /* message */)>>& onError) override;
+
+  public:
+    // Methods
+    void postMessage(const std::string& message) override;
+    void reload() override;
+    void clearSnapshot() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridChartWebviewSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::chartwebview

package/nitrogen/generated/android/c++/views/JHybridChartWebviewStateUpdater.cpp

@@ -0,0 +1,96 @@
+///
+/// JHybridChartWebviewStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridChartWebviewStateUpdater.hpp"
+#include "views/HybridChartWebviewComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::chartwebview::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridChartWebviewState>;
+
+void JHybridChartWebviewStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridChartWebviewSpec::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  JHybridChartWebviewSpec* view = javaView->cthis();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::dynamic_pointer_cast<const ConcreteStateData>(state);
+  const HybridChartWebviewState& data = concreteState->getData();
+  const std::optional<HybridChartWebviewProps>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridChartWebviewState's data doesn't contain any props!");
+  }
+  const HybridChartWebviewProps& props = maybeProps.value();
+  if (props.uri.isDirty) {
+    view->setUri(props.uri.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.localBundle.isDirty) {
+    view->setLocalBundle(props.localBundle.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.entry.isDirty) {
+    view->setEntry(props.entry.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.paramsJson.isDirty) {
+    view->setParamsJson(props.paramsJson.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.bridgeScript.isDirty) {
+    view->setBridgeScript(props.bridgeScript.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.reuseKey.isDirty) {
+    view->setReuseKey(props.reuseKey.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.pooled.isDirty) {
+    view->setPooled(props.pooled.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.active.isDirty) {
+    view->setActive(props.active.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onMessage.isDirty) {
+    view->setOnMessage(props.onMessage.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onLoadEnd.isDirty) {
+    view->setOnLoadEnd(props.onLoadEnd.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onError.isDirty) {
+    view->setOnError(props.onError.value);
+    // TODO: Set isDirty = false
+  }
+
+  // Update hybridRef if it changed
+  if (props.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      std::shared_ptr<JHybridChartWebviewSpec> shared = javaView->cthis()->shared_cast<JHybridChartWebviewSpec>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace margelo::nitro::chartwebview::views

package/nitrogen/generated/android/c++/views/JHybridChartWebviewStateUpdater.hpp

@@ -0,0 +1,49 @@
+///
+/// JHybridChartWebviewStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error chartwebview was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridChartWebviewSpec.hpp"
+#include "views/HybridChartWebviewComponent.hpp"
+
+namespace margelo::nitro::chartwebview::views {
+
+using namespace facebook;
+
+class JHybridChartWebviewStateUpdater: public jni::JavaClass<JHybridChartWebviewStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/chartwebview/views/HybridChartWebviewStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridChartWebviewSpec::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridChartWebviewStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridChartWebviewComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::chartwebview::views

package/nitrogen/generated/android/chartwebview+autolinking.cmake

@@ -0,0 +1,83 @@
+#
+# chartwebview+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © 2026 Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/chartwebview+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_CHARTWEBVIEW_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  chartwebview PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/chartwebviewOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridChartWebviewSpec.cpp
+  ../nitrogen/generated/shared/c++/views/HybridChartWebviewComponent.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridChartWebviewSpec.cpp
+  ../nitrogen/generated/android/c++/views/JHybridChartWebviewStateUpdater.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  chartwebview PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        chartwebview
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        chartwebview
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        chartwebview
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()