@onekeyfe/react-native-chart-webview 3.0.96 → 3.0.99

package/lib/nitrogen/nitrogen/generated/ios/c++/views/HybridChartWebviewComponent.mm

@@ -37,6 +37,7 @@ using namespace margelo::nitro::chartwebview::views;
 
 @implementation HybridChartWebviewComponent {
   std::shared_ptr<HybridChartWebviewSpecSwift> _hybridView;
+  BOOL _didDropView;
 }
 
 + (void) load {
@@ -50,6 +51,7 @@ using namespace margelo::nitro::chartwebview::views;
 
 - (instancetype) init {
   if (self = [super init]) {
+    _props = HybridChartWebviewShadowNode::defaultSharedProps();
     std::shared_ptr<HybridChartWebviewSpec> hybridView = ChartWebview::ChartWebviewAutolinking::createChartWebview();
     _hybridView = std::dynamic_pointer_cast<HybridChartWebviewSpecSwift>(hybridView);
     [self updateView];
@@ -69,95 +71,127 @@ using namespace margelo::nitro::chartwebview::views;
   [self setContentView:view];
 }
 
+- (void) notifyOnDropView {
+  // A recycled component can later be invalidated. Notify only once per mount.
+  if (_didDropView) {
+    return;
+  }
+  ChartWebview::HybridChartWebviewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.onDropView();
+  _didDropView = YES;
+}
+
 - (void) updateProps:(const std::shared_ptr<const react::Props>&)props
             oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // A props update marks a newly mounted or still-active component.
+  _didDropView = NO;
+
   // 1. Downcast props
-  const auto& newViewPropsConst = *std::static_pointer_cast<HybridChartWebviewProps const>(props);
-  auto& newViewProps = const_cast<HybridChartWebviewProps&>(newViewPropsConst);
+  const auto& newViewProps = *std::static_pointer_cast<const HybridChartWebviewProps>(props);
+  const auto* oldViewProps = static_cast<const HybridChartWebviewProps*>(oldProps.get());
   ChartWebview::HybridChartWebviewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
 
-  // 2. Update each prop individually
-  swiftPart.beforeUpdate();
-
-  // uri: optional
-  if (newViewProps.uri.isDirty) {
-    swiftPart.setUri(newViewProps.uri.value);
-    newViewProps.uri.isDirty = false;
-  }
-  // localBundle: optional
-  if (newViewProps.localBundle.isDirty) {
-    swiftPart.setLocalBundle(newViewProps.localBundle.value);
-    newViewProps.localBundle.isDirty = false;
-  }
-  // entry: optional
-  if (newViewProps.entry.isDirty) {
-    swiftPart.setEntry(newViewProps.entry.value);
-    newViewProps.entry.isDirty = false;
-  }
-  // paramsJson: optional
-  if (newViewProps.paramsJson.isDirty) {
-    swiftPart.setParamsJson(newViewProps.paramsJson.value);
-    newViewProps.paramsJson.isDirty = false;
-  }
-  // assetHost: optional
-  if (newViewProps.assetHost.isDirty) {
-    swiftPart.setAssetHost(newViewProps.assetHost.value);
-    newViewProps.assetHost.isDirty = false;
-  }
-  // bridgeScript: optional
-  if (newViewProps.bridgeScript.isDirty) {
-    swiftPart.setBridgeScript(newViewProps.bridgeScript.value);
-    newViewProps.bridgeScript.isDirty = false;
-  }
-  // reuseKey: optional
-  if (newViewProps.reuseKey.isDirty) {
-    swiftPart.setReuseKey(newViewProps.reuseKey.value);
-    newViewProps.reuseKey.isDirty = false;
-  }
-  // pooled: optional
-  if (newViewProps.pooled.isDirty) {
-    swiftPart.setPooled(newViewProps.pooled.value);
-    newViewProps.pooled.isDirty = false;
-  }
-  // active: optional
-  if (newViewProps.active.isDirty) {
-    swiftPart.setActive(newViewProps.active.value);
-    newViewProps.active.isDirty = false;
-  }
-  // webviewDebuggingEnabled: optional
-  if (newViewProps.webviewDebuggingEnabled.isDirty) {
-    swiftPart.setWebviewDebuggingEnabled(newViewProps.webviewDebuggingEnabled.value);
-    newViewProps.webviewDebuggingEnabled.isDirty = false;
-  }
-  // onMessage: optional
-  if (newViewProps.onMessage.isDirty) {
-    swiftPart.setOnMessage(newViewProps.onMessage.value);
-    newViewProps.onMessage.isDirty = false;
-  }
-  // onLoadEnd: optional
-  if (newViewProps.onLoadEnd.isDirty) {
-    swiftPart.setOnLoadEnd(newViewProps.onLoadEnd.value);
-    newViewProps.onLoadEnd.isDirty = false;
-  }
-  // onError: optional
-  if (newViewProps.onError.isDirty) {
-    swiftPart.setOnError(newViewProps.onError.value);
-    newViewProps.onError.isDirty = false;
-  }
-
-  swiftPart.afterUpdate();
+  // 2. Update only props that differ from the previous Props snapshot.
+  const bool hasTransactionPropChanges = oldViewProps == nullptr
+      ? newViewProps.hasAnyProvidedProps()
+      : !newViewProps.hasSameProps(*oldViewProps);
+  if (hasTransactionPropChanges) {
+    swiftPart.beforeUpdate();
+
+    // uri: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.uri.isProvided()
+          : !newViewProps.uri.hasSameValue(oldViewProps->uri)) {
+      swiftPart.setUri(newViewProps.uri.get());
+    }
+    // localBundle: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.localBundle.isProvided()
+          : !newViewProps.localBundle.hasSameValue(oldViewProps->localBundle)) {
+      swiftPart.setLocalBundle(newViewProps.localBundle.get());
+    }
+    // entry: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.entry.isProvided()
+          : !newViewProps.entry.hasSameValue(oldViewProps->entry)) {
+      swiftPart.setEntry(newViewProps.entry.get());
+    }
+    // paramsJson: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.paramsJson.isProvided()
+          : !newViewProps.paramsJson.hasSameValue(oldViewProps->paramsJson)) {
+      swiftPart.setParamsJson(newViewProps.paramsJson.get());
+    }
+    // assetHost: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.assetHost.isProvided()
+          : !newViewProps.assetHost.hasSameValue(oldViewProps->assetHost)) {
+      swiftPart.setAssetHost(newViewProps.assetHost.get());
+    }
+    // bridgeScript: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.bridgeScript.isProvided()
+          : !newViewProps.bridgeScript.hasSameValue(oldViewProps->bridgeScript)) {
+      swiftPart.setBridgeScript(newViewProps.bridgeScript.get());
+    }
+    // reuseKey: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.reuseKey.isProvided()
+          : !newViewProps.reuseKey.hasSameValue(oldViewProps->reuseKey)) {
+      swiftPart.setReuseKey(newViewProps.reuseKey.get());
+    }
+    // pooled: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.pooled.isProvided()
+          : !newViewProps.pooled.hasSameValue(oldViewProps->pooled)) {
+      swiftPart.setPooled(newViewProps.pooled.get());
+    }
+    // active: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.active.isProvided()
+          : !newViewProps.active.hasSameValue(oldViewProps->active)) {
+      swiftPart.setActive(newViewProps.active.get());
+    }
+    // webviewDebuggingEnabled: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.webviewDebuggingEnabled.isProvided()
+          : !newViewProps.webviewDebuggingEnabled.hasSameValue(oldViewProps->webviewDebuggingEnabled)) {
+      swiftPart.setWebviewDebuggingEnabled(newViewProps.webviewDebuggingEnabled.get());
+    }
+    // onMessage: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.onMessage.isProvided()
+          : !newViewProps.onMessage.hasSameValue(oldViewProps->onMessage)) {
+      swiftPart.setOnMessage(newViewProps.onMessage.get());
+    }
+    // onLoadEnd: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.onLoadEnd.isProvided()
+          : !newViewProps.onLoadEnd.hasSameValue(oldViewProps->onLoadEnd)) {
+      swiftPart.setOnLoadEnd(newViewProps.onLoadEnd.get());
+    }
+    // onError: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.onError.isProvided()
+          : !newViewProps.onError.hasSameValue(oldViewProps->onError)) {
+      swiftPart.setOnError(newViewProps.onError.get());
+    }
 
-  // 3. Update hybridRef if it changed
-  if (newViewProps.hybridRef.isDirty) {
-    // hybridRef changed - call it with new this
-    const auto& maybeFunc = newViewProps.hybridRef.value;
-    if (maybeFunc.has_value()) {
-      maybeFunc.value()(_hybridView);
+    // Update hybridRef if it changed
+    if (oldViewProps == nullptr
+          ? newViewProps.hybridRef.isProvided()
+          : !newViewProps.hybridRef.hasSameValue(oldViewProps->hybridRef)) {
+      // hybridRef changed - call it with new this
+      const auto& maybeFunc = newViewProps.hybridRef.get();
+      if (maybeFunc.has_value()) {
+        maybeFunc.value()(_hybridView);
+      }
     }
-    newViewProps.hybridRef.isDirty = false;
+
+    swiftPart.afterUpdate();
   }
 
-  // 4. Continue in base class
+  // 3. Continue in base class
   [super updateProps:props oldProps:oldProps];
 }
 
@@ -166,6 +200,7 @@ using namespace margelo::nitro::chartwebview::views;
 }
 
 - (void)prepareForRecycle {
+  [self notifyOnDropView];
   [super prepareForRecycle];
   ChartWebview::HybridChartWebviewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
   swiftPart.maybePrepareForRecycle();
@@ -173,8 +208,7 @@ using namespace margelo::nitro::chartwebview::views;
 
 #ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
 - (void)invalidate {
-  ChartWebview::HybridChartWebviewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
-  swiftPart.onDropView();
+  [self notifyOnDropView];
   [super invalidate];
 }
 #endif

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

@@ -7,165 +7,33 @@
 
 #include "HybridChartWebviewComponent.hpp"
 
-#include <string>
-#include <exception>
-#include <utility>
-#include <NitroModules/NitroDefines.hpp>
-#include <NitroModules/JSIConverter.hpp>
-#include <NitroModules/PropNameIDCache.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>
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/ReactProp.hpp>
 
 namespace margelo::nitro::chartwebview::views {
 
+  using namespace facebook;
+
   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());
-      }
-    }()),
-    assetHost([&]() -> CachedProp<std::optional<std::string>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("assetHost", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.assetHost;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.assetHost);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("ChartWebview.assetHost: ") + 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());
-      }
-    }()),
-    webviewDebuggingEnabled([&]() -> CachedProp<std::optional<bool>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("webviewDebuggingEnabled", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.webviewDebuggingEnabled;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.webviewDebuggingEnabled);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("ChartWebview.webviewDebuggingEnabled: ") + 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, PropNameIDCache::get(*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, PropNameIDCache::get(*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, PropNameIDCache::get(*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, PropNameIDCache::get(*runtime, "f")), sourceProps.hybridRef);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("ChartWebview.hybridRef: ") + exc.what());
-      }
-    }()) { }
+    uri(nitro::ReactProp<std::optional<std::string>>::fromRawValue("ChartWebview", "uri", rawProps, sourceProps.uri)),
+    localBundle(nitro::ReactProp<std::optional<std::string>>::fromRawValue("ChartWebview", "localBundle", rawProps, sourceProps.localBundle)),
+    entry(nitro::ReactProp<std::optional<std::string>>::fromRawValue("ChartWebview", "entry", rawProps, sourceProps.entry)),
+    paramsJson(nitro::ReactProp<std::optional<std::string>>::fromRawValue("ChartWebview", "paramsJson", rawProps, sourceProps.paramsJson)),
+    assetHost(nitro::ReactProp<std::optional<std::string>>::fromRawValue("ChartWebview", "assetHost", rawProps, sourceProps.assetHost)),
+    bridgeScript(nitro::ReactProp<std::optional<std::string>>::fromRawValue("ChartWebview", "bridgeScript", rawProps, sourceProps.bridgeScript)),
+    reuseKey(nitro::ReactProp<std::optional<std::string>>::fromRawValue("ChartWebview", "reuseKey", rawProps, sourceProps.reuseKey)),
+    pooled(nitro::ReactProp<std::optional<bool>>::fromRawValue("ChartWebview", "pooled", rawProps, sourceProps.pooled)),
+    active(nitro::ReactProp<std::optional<bool>>::fromRawValue("ChartWebview", "active", rawProps, sourceProps.active)),
+    webviewDebuggingEnabled(nitro::ReactProp<std::optional<bool>>::fromRawValue("ChartWebview", "webviewDebuggingEnabled", rawProps, sourceProps.webviewDebuggingEnabled)),
+    onMessage(nitro::ReactProp<std::optional<std::function<void(const std::string& /* message */)>>>::fromRawValue("ChartWebview", "onMessage", rawProps, sourceProps.onMessage)),
+    onLoadEnd(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("ChartWebview", "onLoadEnd", rawProps, sourceProps.onLoadEnd)),
+    onError(nitro::ReactProp<std::optional<std::function<void(const std::string& /* message */)>>>::fromRawValue("ChartWebview", "onError", rawProps, sourceProps.onError)),
+    hybridRef(nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridChartWebviewSpec>& /* ref */)>>>::fromRawValue("ChartWebview", "hybridRef", rawProps, sourceProps.hybridRef)) { }
 
   bool HybridChartWebviewProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
@@ -187,29 +55,4 @@ namespace margelo::nitro::chartwebview::views {
     }
   }
 
-  HybridChartWebviewComponentDescriptor::HybridChartWebviewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
-    : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser()) {}
-
-  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 = static_cast<HybridChartWebviewShadowNode&>(shadowNode);
-    const std::shared_ptr<const HybridChartWebviewProps>& constProps = concreteShadowNode.getConcreteSharedProps();
-    const std::shared_ptr<HybridChartWebviewProps>& props = std::const_pointer_cast<HybridChartWebviewProps>(constProps);
-    HybridChartWebviewState state{props};
-    concreteShadowNode.setStateData(std::move(state));
-  }
-#endif
-
 } // namespace margelo::nitro::chartwebview::views

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

@@ -7,14 +7,15 @@
 
 #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 <NitroModules/ReactProp.hpp>
+#include <NitroModules/ViewComponentDescriptor.hpp>
+#include <NitroModules/ViewPropsHolderState.hpp>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+
+#include <string>
 
 #include <string>
 #include <optional>
@@ -42,20 +43,56 @@ namespace margelo::nitro::chartwebview::views {
                             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>> assetHost;
-    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<bool>> webviewDebuggingEnabled;
-    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;
+    nitro::ReactProp<std::optional<std::string>> uri;
+    nitro::ReactProp<std::optional<std::string>> localBundle;
+    nitro::ReactProp<std::optional<std::string>> entry;
+    nitro::ReactProp<std::optional<std::string>> paramsJson;
+    nitro::ReactProp<std::optional<std::string>> assetHost;
+    nitro::ReactProp<std::optional<std::string>> bridgeScript;
+    nitro::ReactProp<std::optional<std::string>> reuseKey;
+    nitro::ReactProp<std::optional<bool>> pooled;
+    nitro::ReactProp<std::optional<bool>> active;
+    nitro::ReactProp<std::optional<bool>> webviewDebuggingEnabled;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* message */)>>> onMessage;
+    nitro::ReactProp<std::optional<std::function<void()>>> onLoadEnd;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* message */)>>> onError;
+    nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridChartWebviewSpec>& /* ref */)>>> hybridRef;
+
+    [[nodiscard]]
+    bool hasSameProps(const HybridChartWebviewProps& other) const noexcept {
+      return uri.hasSameValue(other.uri) &&
+             localBundle.hasSameValue(other.localBundle) &&
+             entry.hasSameValue(other.entry) &&
+             paramsJson.hasSameValue(other.paramsJson) &&
+             assetHost.hasSameValue(other.assetHost) &&
+             bridgeScript.hasSameValue(other.bridgeScript) &&
+             reuseKey.hasSameValue(other.reuseKey) &&
+             pooled.hasSameValue(other.pooled) &&
+             active.hasSameValue(other.active) &&
+             webviewDebuggingEnabled.hasSameValue(other.webviewDebuggingEnabled) &&
+             onMessage.hasSameValue(other.onMessage) &&
+             onLoadEnd.hasSameValue(other.onLoadEnd) &&
+             onError.hasSameValue(other.onError) &&
+             hybridRef.hasSameValue(other.hybridRef);
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return uri.isProvided() ||
+             localBundle.isProvided() ||
+             entry.isProvided() ||
+             paramsJson.isProvided() ||
+             assetHost.isProvided() ||
+             bridgeScript.isProvided() ||
+             reuseKey.isProvided() ||
+             pooled.isProvided() ||
+             active.isProvided() ||
+             webviewDebuggingEnabled.isProvided() ||
+             onMessage.isProvided() ||
+             onLoadEnd.isProvided() ||
+             onError.isProvided() ||
+             hybridRef.isProvided();
+    }
 
   private:
     static bool filterObjectKeys(const std::string& propName);
@@ -64,32 +101,7 @@ namespace margelo::nitro::chartwebview::views {
   /**
    * State for the "ChartWebview" View.
    */
-  class HybridChartWebviewState final {
-  public:
-    HybridChartWebviewState() = default;
-    explicit HybridChartWebviewState(const std::shared_ptr<HybridChartWebviewProps>& props):
-      _props(props) {}
-
-  public:
-    [[nodiscard]]
-    const std::shared_ptr<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::shared_ptr<HybridChartWebviewProps> _props;
-  };
+  using HybridChartWebviewState = nitro::ViewPropsHolderState<HybridChartWebviewProps>;
 
   /**
    * The Shadow Node for the "ChartWebview" View.
@@ -102,21 +114,7 @@ namespace margelo::nitro::chartwebview::views {
   /**
    * The Component Descriptor for the "ChartWebview" View.
    */
-  class HybridChartWebviewComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridChartWebviewShadowNode> {
-  public:
-    explicit 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
-  };
+  using HybridChartWebviewComponentDescriptor = nitro::ViewComponentDescriptor<HybridChartWebviewShadowNode>;
 
   /* The actual view for "ChartWebview" needs to be implemented in platform-specific code. */