@onekeyfe/react-native-perp-depth-bar 3.0.96 → 3.0.98

package/lib/nitrogen/generated/shared/c++/views/HybridPerpSideRatioComponent.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 <memory>
@@ -42,15 +43,41 @@ namespace margelo::nitro::perpdepthbar::views {
                              const react::RawProps& rawProps);
 
   public:
-    CachedProp<double> bidPercentage;
-    CachedProp<double> askPercentage;
-    CachedProp<std::string> longColor;
-    CachedProp<std::string> shortColor;
-    CachedProp<double> segmentHeight;
-    CachedProp<double> cornerRadius;
-    CachedProp<double> gap;
-    CachedProp<bool> reducedMotion;
-    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpSideRatioSpec>& /* ref */)>>> hybridRef;
+    nitro::ReactProp<double> bidPercentage;
+    nitro::ReactProp<double> askPercentage;
+    nitro::ReactProp<std::string> longColor;
+    nitro::ReactProp<std::string> shortColor;
+    nitro::ReactProp<double> segmentHeight;
+    nitro::ReactProp<double> cornerRadius;
+    nitro::ReactProp<double> gap;
+    nitro::ReactProp<bool> reducedMotion;
+    nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpSideRatioSpec>& /* ref */)>>> hybridRef;
+
+    [[nodiscard]]
+    bool hasSameProps(const HybridPerpSideRatioProps& other) const noexcept {
+      return bidPercentage.hasSameValue(other.bidPercentage) &&
+             askPercentage.hasSameValue(other.askPercentage) &&
+             longColor.hasSameValue(other.longColor) &&
+             shortColor.hasSameValue(other.shortColor) &&
+             segmentHeight.hasSameValue(other.segmentHeight) &&
+             cornerRadius.hasSameValue(other.cornerRadius) &&
+             gap.hasSameValue(other.gap) &&
+             reducedMotion.hasSameValue(other.reducedMotion) &&
+             hybridRef.hasSameValue(other.hybridRef);
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return bidPercentage.isProvided() ||
+             askPercentage.isProvided() ||
+             longColor.isProvided() ||
+             shortColor.isProvided() ||
+             segmentHeight.isProvided() ||
+             cornerRadius.isProvided() ||
+             gap.isProvided() ||
+             reducedMotion.isProvided() ||
+             hybridRef.isProvided();
+    }
 
   private:
     static bool filterObjectKeys(const std::string& propName);
@@ -59,32 +86,7 @@ namespace margelo::nitro::perpdepthbar::views {
   /**
    * State for the "PerpSideRatio" View.
    */
-  class HybridPerpSideRatioState final {
-  public:
-    HybridPerpSideRatioState() = default;
-    explicit HybridPerpSideRatioState(const std::shared_ptr<HybridPerpSideRatioProps>& props):
-      _props(props) {}
-
-  public:
-    [[nodiscard]]
-    const std::shared_ptr<HybridPerpSideRatioProps>& getProps() const {
-      return _props;
-    }
-
-  public:
-#ifdef ANDROID
-  HybridPerpSideRatioState(const HybridPerpSideRatioState& /* previousState */, folly::dynamic /* data */) {}
-  folly::dynamic getDynamic() const {
-    throw std::runtime_error("HybridPerpSideRatioState does not support folly!");
-  }
-  react::MapBuffer getMapBuffer() const {
-    throw std::runtime_error("HybridPerpSideRatioState does not support MapBuffer!");
-  };
-#endif
-
-  private:
-    std::shared_ptr<HybridPerpSideRatioProps> _props;
-  };
+  using HybridPerpSideRatioState = nitro::ViewPropsHolderState<HybridPerpSideRatioProps>;
 
   /**
    * The Shadow Node for the "PerpSideRatio" View.
@@ -97,21 +99,7 @@ namespace margelo::nitro::perpdepthbar::views {
   /**
    * The Component Descriptor for the "PerpSideRatio" View.
    */
-  class HybridPerpSideRatioComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridPerpSideRatioShadowNode> {
-  public:
-    explicit HybridPerpSideRatioComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
-
-  public:
-    /**
-     * A faster path for cloning props - reuses the caching logic from `HybridPerpSideRatioProps`.
-     */
-    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 HybridPerpSideRatioComponentDescriptor = nitro::ViewComponentDescriptor<HybridPerpSideRatioShadowNode>;
 
   /* The actual view for "PerpSideRatio" needs to be implemented in platform-specific code. */
 

package/lib/nitrogen/nitrogen/generated/android/c++/views/JHybridPerpDepthBarsStateUpdater.cpp

@@ -15,109 +15,144 @@ namespace margelo::nitro::perpdepthbar::views {
 using namespace facebook;
 using ConcreteStateData = react::ConcreteState<HybridPerpDepthBarsState>;
 
-void JHybridPerpDepthBarsStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                                           jni::alias_ref<JHybridPerpDepthBarsSpec::JavaPart> javaView,
-                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
-  std::shared_ptr<JHybridPerpDepthBarsSpec> hybridView = javaView->getJHybridPerpDepthBarsSpec();
-
+std::shared_ptr<const HybridPerpDepthBarsProps> JHybridPerpDepthBarsStateUpdater::getPropsFromStateWrapper(
+    jni::alias_ref<JStateWrapper::javaobject> stateWrapper) {
+  if (stateWrapper.get() == nullptr) {
+    return nullptr;
+  }
   // Get concrete StateWrapperImpl from passed StateWrapper interface object
-  jobject rawStateWrapper = stateWrapperInterface.get();
-  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
-      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  jobject rawStateWrapper = stateWrapper.get();
+  if (!stateWrapper->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+    throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapperImpl = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+    static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)
+  };
+  std::shared_ptr<const react::State> state = stateWrapperImpl->cthis()->getState();
+  if (state == nullptr) {
+    return nullptr;
   }
-  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::static_pointer_cast<const ConcreteStateData>(state);
   const HybridPerpDepthBarsState& data = concreteState->getData();
-  const std::shared_ptr<HybridPerpDepthBarsProps>& props = data.getProps();
+  const std::shared_ptr<const HybridPerpDepthBarsProps>& props = data.getProps();
   if (props == nullptr) [[unlikely]] {
-    // Props aren't set yet!
     throw std::runtime_error("HybridPerpDepthBarsState's data doesn't contain any props!");
   }
+  return props;
+}
 
-  // Update all props if they are dirty
-  if (props->percents.isDirty) {
-    hybridView->setPercents(props->percents.value);
-    props->percents.isDirty = false;
-  }
-  if (props->rowHeight.isDirty) {
-    hybridView->setRowHeight(props->rowHeight.value);
-    props->rowHeight.isDirty = false;
-  }
-  if (props->rowMarginTop.isDirty) {
-    hybridView->setRowMarginTop(props->rowMarginTop.value);
-    props->rowMarginTop.isDirty = false;
-  }
-  if (props->barInset.isDirty) {
-    hybridView->setBarInset(props->barInset.value);
-    props->barInset.isDirty = false;
-  }
-  if (props->color.isDirty) {
-    hybridView->setColor(props->color.value);
-    props->color.isDirty = false;
-  }
-  if (props->origin.isDirty) {
-    hybridView->setOrigin(props->origin.value);
-    props->origin.isDirty = false;
-  }
-  if (props->reducedMotion.isDirty) {
-    hybridView->setReducedMotion(props->reducedMotion.value);
-    props->reducedMotion.isDirty = false;
-  }
-  if (props->epoch.isDirty) {
-    hybridView->setEpoch(props->epoch.value);
-    props->epoch.isDirty = false;
-  }
-  if (props->prices.isDirty) {
-    hybridView->setPrices(props->prices.value);
-    props->prices.isDirty = false;
-  }
-  if (props->sizes.isDirty) {
-    hybridView->setSizes(props->sizes.value);
-    props->sizes.isDirty = false;
-  }
-  if (props->priceColor.isDirty) {
-    hybridView->setPriceColor(props->priceColor.value);
-    props->priceColor.isDirty = false;
-  }
-  if (props->sizeColor.isDirty) {
-    hybridView->setSizeColor(props->sizeColor.value);
-    props->sizeColor.isDirty = false;
-  }
-  if (props->priceFontSize.isDirty) {
-    hybridView->setPriceFontSize(props->priceFontSize.value);
-    props->priceFontSize.isDirty = false;
-  }
-  if (props->sizeFontSize.isDirty) {
-    hybridView->setSizeFontSize(props->sizeFontSize.value);
-    props->sizeFontSize.isDirty = false;
-  }
-  if (props->textInset.isDirty) {
-    hybridView->setTextInset(props->textInset.value);
-    props->textInset.isDirty = false;
-  }
-  if (props->placeholderText.isDirty) {
-    hybridView->setPlaceholderText(props->placeholderText.value);
-    props->placeholderText.isDirty = false;
-  }
-  if (props->placeholderRows.isDirty) {
-    hybridView->setPlaceholderRows(props->placeholderRows.value);
-    props->placeholderRows.isDirty = false;
+void JHybridPerpDepthBarsStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridPerpDepthBarsSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<JHybridPerpDepthBarsSpec> hybridView = javaView->getJHybridPerpDepthBarsSpec();
+  std::shared_ptr<const HybridPerpDepthBarsProps> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const HybridPerpDepthBarsProps> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
   }
-  if (props->onRowPress.isDirty) {
-    hybridView->setOnRowPress(props->onRowPress.value);
-    props->onRowPress.isDirty = false;
+
+  // Update only props that differ from the previous State snapshot.
+  if (oldProps == nullptr
+        ? newProps->percents.isProvided()
+        : !newProps->percents.hasSameValue(oldProps->percents)) {
+    hybridView->setPercents(newProps->percents.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->rowHeight.isProvided()
+        : !newProps->rowHeight.hasSameValue(oldProps->rowHeight)) {
+    hybridView->setRowHeight(newProps->rowHeight.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->rowMarginTop.isProvided()
+        : !newProps->rowMarginTop.hasSameValue(oldProps->rowMarginTop)) {
+    hybridView->setRowMarginTop(newProps->rowMarginTop.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->barInset.isProvided()
+        : !newProps->barInset.hasSameValue(oldProps->barInset)) {
+    hybridView->setBarInset(newProps->barInset.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->color.isProvided()
+        : !newProps->color.hasSameValue(oldProps->color)) {
+    hybridView->setColor(newProps->color.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->origin.isProvided()
+        : !newProps->origin.hasSameValue(oldProps->origin)) {
+    hybridView->setOrigin(newProps->origin.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->reducedMotion.isProvided()
+        : !newProps->reducedMotion.hasSameValue(oldProps->reducedMotion)) {
+    hybridView->setReducedMotion(newProps->reducedMotion.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->epoch.isProvided()
+        : !newProps->epoch.hasSameValue(oldProps->epoch)) {
+    hybridView->setEpoch(newProps->epoch.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->prices.isProvided()
+        : !newProps->prices.hasSameValue(oldProps->prices)) {
+    hybridView->setPrices(newProps->prices.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->sizes.isProvided()
+        : !newProps->sizes.hasSameValue(oldProps->sizes)) {
+    hybridView->setSizes(newProps->sizes.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->priceColor.isProvided()
+        : !newProps->priceColor.hasSameValue(oldProps->priceColor)) {
+    hybridView->setPriceColor(newProps->priceColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->sizeColor.isProvided()
+        : !newProps->sizeColor.hasSameValue(oldProps->sizeColor)) {
+    hybridView->setSizeColor(newProps->sizeColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->priceFontSize.isProvided()
+        : !newProps->priceFontSize.hasSameValue(oldProps->priceFontSize)) {
+    hybridView->setPriceFontSize(newProps->priceFontSize.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->sizeFontSize.isProvided()
+        : !newProps->sizeFontSize.hasSameValue(oldProps->sizeFontSize)) {
+    hybridView->setSizeFontSize(newProps->sizeFontSize.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->textInset.isProvided()
+        : !newProps->textInset.hasSameValue(oldProps->textInset)) {
+    hybridView->setTextInset(newProps->textInset.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->placeholderText.isProvided()
+        : !newProps->placeholderText.hasSameValue(oldProps->placeholderText)) {
+    hybridView->setPlaceholderText(newProps->placeholderText.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->placeholderRows.isProvided()
+        : !newProps->placeholderRows.hasSameValue(oldProps->placeholderRows)) {
+    hybridView->setPlaceholderRows(newProps->placeholderRows.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onRowPress.isProvided()
+        : !newProps->onRowPress.hasSameValue(oldProps->onRowPress)) {
+    hybridView->setOnRowPress(newProps->onRowPress.get());
   }
 
   // Update hybridRef if it changed
-  if (props->hybridRef.isDirty) {
+  if (oldProps == nullptr
+        ? newProps->hybridRef.isProvided()
+        : !newProps->hybridRef.hasSameValue(oldProps->hybridRef)) {
     // hybridRef changed - call it with new this
-    const auto& maybeFunc = props->hybridRef.value;
+    const auto& maybeFunc = newProps->hybridRef.get();
     if (maybeFunc.has_value()) {
       maybeFunc.value()(hybridView);
     }
-    props->hybridRef.isDirty = false;
   }
 }
 

package/lib/nitrogen/nitrogen/generated/android/c++/views/JHybridPerpDepthBarsStateUpdater.hpp

@@ -31,7 +31,12 @@ public:
 public:
   static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
                               jni::alias_ref<JHybridPerpDepthBarsSpec::JavaPart> view,
-                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+                              jni::alias_ref<JStateWrapper::javaobject> newState,
+                              jni::alias_ref<JStateWrapper::javaobject> oldState);
+
+private:
+  static std::shared_ptr<const HybridPerpDepthBarsProps> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
 
 public:
   static void registerNatives() {

package/lib/nitrogen/nitrogen/generated/android/c++/views/JHybridPerpSideRatioStateUpdater.cpp

@@ -15,69 +15,94 @@ namespace margelo::nitro::perpdepthbar::views {
 using namespace facebook;
 using ConcreteStateData = react::ConcreteState<HybridPerpSideRatioState>;
 
-void JHybridPerpSideRatioStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                                           jni::alias_ref<JHybridPerpSideRatioSpec::JavaPart> javaView,
-                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
-  std::shared_ptr<JHybridPerpSideRatioSpec> hybridView = javaView->getJHybridPerpSideRatioSpec();
-
+std::shared_ptr<const HybridPerpSideRatioProps> JHybridPerpSideRatioStateUpdater::getPropsFromStateWrapper(
+    jni::alias_ref<JStateWrapper::javaobject> stateWrapper) {
+  if (stateWrapper.get() == nullptr) {
+    return nullptr;
+  }
   // Get concrete StateWrapperImpl from passed StateWrapper interface object
-  jobject rawStateWrapper = stateWrapperInterface.get();
-  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
-      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  jobject rawStateWrapper = stateWrapper.get();
+  if (!stateWrapper->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+    throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapperImpl = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+    static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)
+  };
+  std::shared_ptr<const react::State> state = stateWrapperImpl->cthis()->getState();
+  if (state == nullptr) {
+    return nullptr;
   }
-  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::static_pointer_cast<const ConcreteStateData>(state);
   const HybridPerpSideRatioState& data = concreteState->getData();
-  const std::shared_ptr<HybridPerpSideRatioProps>& props = data.getProps();
+  const std::shared_ptr<const HybridPerpSideRatioProps>& props = data.getProps();
   if (props == nullptr) [[unlikely]] {
-    // Props aren't set yet!
     throw std::runtime_error("HybridPerpSideRatioState's data doesn't contain any props!");
   }
+  return props;
+}
+
+void JHybridPerpSideRatioStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridPerpSideRatioSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<JHybridPerpSideRatioSpec> hybridView = javaView->getJHybridPerpSideRatioSpec();
+  std::shared_ptr<const HybridPerpSideRatioProps> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const HybridPerpSideRatioProps> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
+  }
 
-  // Update all props if they are dirty
-  if (props->bidPercentage.isDirty) {
-    hybridView->setBidPercentage(props->bidPercentage.value);
-    props->bidPercentage.isDirty = false;
+  // Update only props that differ from the previous State snapshot.
+  if (oldProps == nullptr
+        ? newProps->bidPercentage.isProvided()
+        : !newProps->bidPercentage.hasSameValue(oldProps->bidPercentage)) {
+    hybridView->setBidPercentage(newProps->bidPercentage.get());
   }
-  if (props->askPercentage.isDirty) {
-    hybridView->setAskPercentage(props->askPercentage.value);
-    props->askPercentage.isDirty = false;
+  if (oldProps == nullptr
+        ? newProps->askPercentage.isProvided()
+        : !newProps->askPercentage.hasSameValue(oldProps->askPercentage)) {
+    hybridView->setAskPercentage(newProps->askPercentage.get());
   }
-  if (props->longColor.isDirty) {
-    hybridView->setLongColor(props->longColor.value);
-    props->longColor.isDirty = false;
+  if (oldProps == nullptr
+        ? newProps->longColor.isProvided()
+        : !newProps->longColor.hasSameValue(oldProps->longColor)) {
+    hybridView->setLongColor(newProps->longColor.get());
   }
-  if (props->shortColor.isDirty) {
-    hybridView->setShortColor(props->shortColor.value);
-    props->shortColor.isDirty = false;
+  if (oldProps == nullptr
+        ? newProps->shortColor.isProvided()
+        : !newProps->shortColor.hasSameValue(oldProps->shortColor)) {
+    hybridView->setShortColor(newProps->shortColor.get());
   }
-  if (props->segmentHeight.isDirty) {
-    hybridView->setSegmentHeight(props->segmentHeight.value);
-    props->segmentHeight.isDirty = false;
+  if (oldProps == nullptr
+        ? newProps->segmentHeight.isProvided()
+        : !newProps->segmentHeight.hasSameValue(oldProps->segmentHeight)) {
+    hybridView->setSegmentHeight(newProps->segmentHeight.get());
   }
-  if (props->cornerRadius.isDirty) {
-    hybridView->setCornerRadius(props->cornerRadius.value);
-    props->cornerRadius.isDirty = false;
+  if (oldProps == nullptr
+        ? newProps->cornerRadius.isProvided()
+        : !newProps->cornerRadius.hasSameValue(oldProps->cornerRadius)) {
+    hybridView->setCornerRadius(newProps->cornerRadius.get());
   }
-  if (props->gap.isDirty) {
-    hybridView->setGap(props->gap.value);
-    props->gap.isDirty = false;
+  if (oldProps == nullptr
+        ? newProps->gap.isProvided()
+        : !newProps->gap.hasSameValue(oldProps->gap)) {
+    hybridView->setGap(newProps->gap.get());
   }
-  if (props->reducedMotion.isDirty) {
-    hybridView->setReducedMotion(props->reducedMotion.value);
-    props->reducedMotion.isDirty = false;
+  if (oldProps == nullptr
+        ? newProps->reducedMotion.isProvided()
+        : !newProps->reducedMotion.hasSameValue(oldProps->reducedMotion)) {
+    hybridView->setReducedMotion(newProps->reducedMotion.get());
   }
 
   // Update hybridRef if it changed
-  if (props->hybridRef.isDirty) {
+  if (oldProps == nullptr
+        ? newProps->hybridRef.isProvided()
+        : !newProps->hybridRef.hasSameValue(oldProps->hybridRef)) {
     // hybridRef changed - call it with new this
-    const auto& maybeFunc = props->hybridRef.value;
+    const auto& maybeFunc = newProps->hybridRef.get();
     if (maybeFunc.has_value()) {
       maybeFunc.value()(hybridView);
     }
-    props->hybridRef.isDirty = false;
   }
 }
 

package/lib/nitrogen/nitrogen/generated/android/c++/views/JHybridPerpSideRatioStateUpdater.hpp

@@ -31,7 +31,12 @@ public:
 public:
   static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
                               jni::alias_ref<JHybridPerpSideRatioSpec::JavaPart> view,
-                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+                              jni::alias_ref<JStateWrapper::javaobject> newState,
+                              jni::alias_ref<JStateWrapper::javaobject> oldState);
+
+private:
+  static std::shared_ptr<const HybridPerpSideRatioProps> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
 
 public:
   static void registerNatives() {

package/lib/nitrogen/nitrogen/generated/android/kotlin/com/margelo/nitro/perpdepthbar/views/HybridPerpDepthBarsManager.kt

@@ -20,6 +20,14 @@ import com.margelo.nitro.perpdepthbar.*
  * Represents the React Native `ViewManager` for the "PerpDepthBars" Nitro HybridView.
  */
 public class HybridPerpDepthBarsManager: SimpleViewManager<View>() {
+  /**
+   * Represents the View and its last state snapshot (mutable)
+   */
+  private class HybridViewHolder(
+    val hybridView: HybridPerpDepthBars,
+    var lastState: StateWrapper? = null,
+  )
+
   init {
     if (RecyclableView::class.java.isAssignableFrom(HybridPerpDepthBars::class.java)) {
       // Enable view recycling
@@ -34,33 +42,41 @@ public class HybridPerpDepthBarsManager: SimpleViewManager<View>() {
   override fun createViewInstance(reactContext: ThemedReactContext): View {
     val hybridView = HybridPerpDepthBars(reactContext)
     val view = hybridView.view
-    view.setTag(associated_hybrid_view_tag, hybridView)
+    view.setTag(associated_hybrid_view_tag, HybridViewHolder(hybridView))
     return view
   }
 
   override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
-    val hybridView = getHybridView(view)
+    val holder = getHybridViewHolder(view)
       ?: throw Error("Couldn't find view $view in local views table!")
+    val hybridView = holder.hybridView
+    val oldState = holder.lastState
+    val newState = stateWrapper
 
     // 1. Update each prop individually
     hybridView.beforeUpdate()
-    HybridPerpDepthBarsStateUpdater.updateViewProps(hybridView, stateWrapper)
+    HybridPerpDepthBarsStateUpdater.updateViewProps(hybridView, newState, oldState)
     hybridView.afterUpdate()
+    holder.lastState = newState
 
     // 2. Continue in base View props
-    return super.updateState(view, props, stateWrapper)
+    return super.updateState(view, props, newState)
   }
 
   override fun onDropViewInstance(view: View) {
-    val hybridView = getHybridView(view)
-    hybridView?.onDropView()
+    val holder = getHybridViewHolder(view)
+    holder?.lastState = null
+    holder?.hybridView?.onDropView()
     return super.onDropViewInstance(view)
   }
 
   protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? {
-    super.prepareToRecycleView(reactContext, view)
-    val hybridView = getHybridView(view)
+    val preparedView = super.prepareToRecycleView(reactContext, view)
+      ?: return null
+    val holder = getHybridViewHolder(preparedView)
       ?: return null
+    val hybridView = holder.hybridView
+    holder.lastState = null
 
     @Suppress("USELESS_IS_CHECK")
     if (hybridView is RecyclableView) {
@@ -74,7 +90,7 @@ public class HybridPerpDepthBarsManager: SimpleViewManager<View>() {
     }
   }
 
-  private fun getHybridView(view: View): HybridPerpDepthBars? {
-    return view.getTag(associated_hybrid_view_tag) as? HybridPerpDepthBars
+  private fun getHybridViewHolder(view: View): HybridViewHolder? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridViewHolder
   }
 }

package/lib/nitrogen/nitrogen/generated/android/kotlin/com/margelo/nitro/perpdepthbar/views/HybridPerpDepthBarsStateUpdater.kt

@@ -14,10 +14,10 @@ internal class HybridPerpDepthBarsStateUpdater {
   companion object {
     /**
      * Updates the props for [view] through C++.
-     * The [state] prop is expected to contain [view]'s props as wrapped Fabric state.
+     * The [newState] prop is expected to contain [view]'s props as wrapped Fabric state.
      */
     @Suppress("KotlinJniMissingFunction")
     @JvmStatic
-    external fun updateViewProps(view: HybridPerpDepthBarsSpec, state: StateWrapper)
+    external fun updateViewProps(view: HybridPerpDepthBarsSpec, newState: StateWrapper, oldState: StateWrapper?)
   }
 }