@onekeyfe/react-native-segment-slider 3.0.96 → 3.0.98

package/lib/nitrogen/generated/shared/c++/views/HybridSegmentSliderComponent.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 <functional>
@@ -42,28 +43,80 @@ namespace margelo::nitro::segmentslider::views {
                              const react::RawProps& rawProps);
 
   public:
-    CachedProp<double> defaultValue;
-    CachedProp<double> min;
-    CachedProp<double> max;
-    CachedProp<double> segments;
-    CachedProp<double> sliderHeight;
-    CachedProp<bool> disabled;
-    CachedProp<bool> showBubble;
-    CachedProp<bool> centerOrigin;
-    CachedProp<bool> snapTapToSegment;
-    CachedProp<std::string> fillColor;
-    CachedProp<std::string> trackColor;
-    CachedProp<std::string> thumbColor;
-    CachedProp<std::string> thumbBorderColor;
-    CachedProp<std::string> markActiveColor;
-    CachedProp<std::string> markInactiveColor;
-    CachedProp<std::string> markBorderColor;
-    CachedProp<std::string> bubbleColor;
-    CachedProp<std::string> bubbleTextColor;
-    CachedProp<std::optional<std::function<void(double /* value */)>>> onChange;
-    CachedProp<std::optional<std::function<void()>>> onSlideStart;
-    CachedProp<std::optional<std::function<void()>>> onSlideComplete;
-    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridSegmentSliderSpec>& /* ref */)>>> hybridRef;
+    nitro::ReactProp<double> defaultValue;
+    nitro::ReactProp<double> min;
+    nitro::ReactProp<double> max;
+    nitro::ReactProp<double> segments;
+    nitro::ReactProp<double> sliderHeight;
+    nitro::ReactProp<bool> disabled;
+    nitro::ReactProp<bool> showBubble;
+    nitro::ReactProp<bool> centerOrigin;
+    nitro::ReactProp<bool> snapTapToSegment;
+    nitro::ReactProp<std::string> fillColor;
+    nitro::ReactProp<std::string> trackColor;
+    nitro::ReactProp<std::string> thumbColor;
+    nitro::ReactProp<std::string> thumbBorderColor;
+    nitro::ReactProp<std::string> markActiveColor;
+    nitro::ReactProp<std::string> markInactiveColor;
+    nitro::ReactProp<std::string> markBorderColor;
+    nitro::ReactProp<std::string> bubbleColor;
+    nitro::ReactProp<std::string> bubbleTextColor;
+    nitro::ReactProp<std::optional<std::function<void(double /* value */)>>> onChange;
+    nitro::ReactProp<std::optional<std::function<void()>>> onSlideStart;
+    nitro::ReactProp<std::optional<std::function<void()>>> onSlideComplete;
+    nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridSegmentSliderSpec>& /* ref */)>>> hybridRef;
+
+    [[nodiscard]]
+    bool hasSameProps(const HybridSegmentSliderProps& other) const noexcept {
+      return defaultValue.hasSameValue(other.defaultValue) &&
+             min.hasSameValue(other.min) &&
+             max.hasSameValue(other.max) &&
+             segments.hasSameValue(other.segments) &&
+             sliderHeight.hasSameValue(other.sliderHeight) &&
+             disabled.hasSameValue(other.disabled) &&
+             showBubble.hasSameValue(other.showBubble) &&
+             centerOrigin.hasSameValue(other.centerOrigin) &&
+             snapTapToSegment.hasSameValue(other.snapTapToSegment) &&
+             fillColor.hasSameValue(other.fillColor) &&
+             trackColor.hasSameValue(other.trackColor) &&
+             thumbColor.hasSameValue(other.thumbColor) &&
+             thumbBorderColor.hasSameValue(other.thumbBorderColor) &&
+             markActiveColor.hasSameValue(other.markActiveColor) &&
+             markInactiveColor.hasSameValue(other.markInactiveColor) &&
+             markBorderColor.hasSameValue(other.markBorderColor) &&
+             bubbleColor.hasSameValue(other.bubbleColor) &&
+             bubbleTextColor.hasSameValue(other.bubbleTextColor) &&
+             onChange.hasSameValue(other.onChange) &&
+             onSlideStart.hasSameValue(other.onSlideStart) &&
+             onSlideComplete.hasSameValue(other.onSlideComplete) &&
+             hybridRef.hasSameValue(other.hybridRef);
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return defaultValue.isProvided() ||
+             min.isProvided() ||
+             max.isProvided() ||
+             segments.isProvided() ||
+             sliderHeight.isProvided() ||
+             disabled.isProvided() ||
+             showBubble.isProvided() ||
+             centerOrigin.isProvided() ||
+             snapTapToSegment.isProvided() ||
+             fillColor.isProvided() ||
+             trackColor.isProvided() ||
+             thumbColor.isProvided() ||
+             thumbBorderColor.isProvided() ||
+             markActiveColor.isProvided() ||
+             markInactiveColor.isProvided() ||
+             markBorderColor.isProvided() ||
+             bubbleColor.isProvided() ||
+             bubbleTextColor.isProvided() ||
+             onChange.isProvided() ||
+             onSlideStart.isProvided() ||
+             onSlideComplete.isProvided() ||
+             hybridRef.isProvided();
+    }
 
   private:
     static bool filterObjectKeys(const std::string& propName);
@@ -72,32 +125,7 @@ namespace margelo::nitro::segmentslider::views {
   /**
    * State for the "SegmentSlider" View.
    */
-  class HybridSegmentSliderState final {
-  public:
-    HybridSegmentSliderState() = default;
-    explicit HybridSegmentSliderState(const std::shared_ptr<HybridSegmentSliderProps>& props):
-      _props(props) {}
-
-  public:
-    [[nodiscard]]
-    const std::shared_ptr<HybridSegmentSliderProps>& getProps() const {
-      return _props;
-    }
-
-  public:
-#ifdef ANDROID
-  HybridSegmentSliderState(const HybridSegmentSliderState& /* previousState */, folly::dynamic /* data */) {}
-  folly::dynamic getDynamic() const {
-    throw std::runtime_error("HybridSegmentSliderState does not support folly!");
-  }
-  react::MapBuffer getMapBuffer() const {
-    throw std::runtime_error("HybridSegmentSliderState does not support MapBuffer!");
-  };
-#endif
-
-  private:
-    std::shared_ptr<HybridSegmentSliderProps> _props;
-  };
+  using HybridSegmentSliderState = nitro::ViewPropsHolderState<HybridSegmentSliderProps>;
 
   /**
    * The Shadow Node for the "SegmentSlider" View.
@@ -110,21 +138,7 @@ namespace margelo::nitro::segmentslider::views {
   /**
    * The Component Descriptor for the "SegmentSlider" View.
    */
-  class HybridSegmentSliderComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridSegmentSliderShadowNode> {
-  public:
-    explicit HybridSegmentSliderComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
-
-  public:
-    /**
-     * A faster path for cloning props - reuses the caching logic from `HybridSegmentSliderProps`.
-     */
-    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 HybridSegmentSliderComponentDescriptor = nitro::ViewComponentDescriptor<HybridSegmentSliderShadowNode>;
 
   /* The actual view for "SegmentSlider" needs to be implemented in platform-specific code. */
 

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

@@ -15,121 +15,159 @@ namespace margelo::nitro::segmentslider::views {
 using namespace facebook;
 using ConcreteStateData = react::ConcreteState<HybridSegmentSliderState>;
 
-void JHybridSegmentSliderStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
-                                           jni::alias_ref<JHybridSegmentSliderSpec::JavaPart> javaView,
-                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
-  std::shared_ptr<JHybridSegmentSliderSpec> hybridView = javaView->getJHybridSegmentSliderSpec();
-
+std::shared_ptr<const HybridSegmentSliderProps> JHybridSegmentSliderStateUpdater::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 HybridSegmentSliderState& data = concreteState->getData();
-  const std::shared_ptr<HybridSegmentSliderProps>& props = data.getProps();
+  const std::shared_ptr<const HybridSegmentSliderProps>& props = data.getProps();
   if (props == nullptr) [[unlikely]] {
-    // Props aren't set yet!
     throw std::runtime_error("HybridSegmentSliderState's data doesn't contain any props!");
   }
+  return props;
+}
 
-  // Update all props if they are dirty
-  if (props->defaultValue.isDirty) {
-    hybridView->setDefaultValue(props->defaultValue.value);
-    props->defaultValue.isDirty = false;
-  }
-  if (props->min.isDirty) {
-    hybridView->setMin(props->min.value);
-    props->min.isDirty = false;
-  }
-  if (props->max.isDirty) {
-    hybridView->setMax(props->max.value);
-    props->max.isDirty = false;
-  }
-  if (props->segments.isDirty) {
-    hybridView->setSegments(props->segments.value);
-    props->segments.isDirty = false;
-  }
-  if (props->sliderHeight.isDirty) {
-    hybridView->setSliderHeight(props->sliderHeight.value);
-    props->sliderHeight.isDirty = false;
-  }
-  if (props->disabled.isDirty) {
-    hybridView->setDisabled(props->disabled.value);
-    props->disabled.isDirty = false;
-  }
-  if (props->showBubble.isDirty) {
-    hybridView->setShowBubble(props->showBubble.value);
-    props->showBubble.isDirty = false;
-  }
-  if (props->centerOrigin.isDirty) {
-    hybridView->setCenterOrigin(props->centerOrigin.value);
-    props->centerOrigin.isDirty = false;
-  }
-  if (props->snapTapToSegment.isDirty) {
-    hybridView->setSnapTapToSegment(props->snapTapToSegment.value);
-    props->snapTapToSegment.isDirty = false;
-  }
-  if (props->fillColor.isDirty) {
-    hybridView->setFillColor(props->fillColor.value);
-    props->fillColor.isDirty = false;
-  }
-  if (props->trackColor.isDirty) {
-    hybridView->setTrackColor(props->trackColor.value);
-    props->trackColor.isDirty = false;
-  }
-  if (props->thumbColor.isDirty) {
-    hybridView->setThumbColor(props->thumbColor.value);
-    props->thumbColor.isDirty = false;
-  }
-  if (props->thumbBorderColor.isDirty) {
-    hybridView->setThumbBorderColor(props->thumbBorderColor.value);
-    props->thumbBorderColor.isDirty = false;
-  }
-  if (props->markActiveColor.isDirty) {
-    hybridView->setMarkActiveColor(props->markActiveColor.value);
-    props->markActiveColor.isDirty = false;
-  }
-  if (props->markInactiveColor.isDirty) {
-    hybridView->setMarkInactiveColor(props->markInactiveColor.value);
-    props->markInactiveColor.isDirty = false;
-  }
-  if (props->markBorderColor.isDirty) {
-    hybridView->setMarkBorderColor(props->markBorderColor.value);
-    props->markBorderColor.isDirty = false;
-  }
-  if (props->bubbleColor.isDirty) {
-    hybridView->setBubbleColor(props->bubbleColor.value);
-    props->bubbleColor.isDirty = false;
-  }
-  if (props->bubbleTextColor.isDirty) {
-    hybridView->setBubbleTextColor(props->bubbleTextColor.value);
-    props->bubbleTextColor.isDirty = false;
-  }
-  if (props->onChange.isDirty) {
-    hybridView->setOnChange(props->onChange.value);
-    props->onChange.isDirty = false;
-  }
-  if (props->onSlideStart.isDirty) {
-    hybridView->setOnSlideStart(props->onSlideStart.value);
-    props->onSlideStart.isDirty = false;
+void JHybridSegmentSliderStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridSegmentSliderSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<JHybridSegmentSliderSpec> hybridView = javaView->getJHybridSegmentSliderSpec();
+  std::shared_ptr<const HybridSegmentSliderProps> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const HybridSegmentSliderProps> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
   }
-  if (props->onSlideComplete.isDirty) {
-    hybridView->setOnSlideComplete(props->onSlideComplete.value);
-    props->onSlideComplete.isDirty = false;
+
+  // Update only props that differ from the previous State snapshot.
+  if (oldProps == nullptr
+        ? newProps->defaultValue.isProvided()
+        : !newProps->defaultValue.hasSameValue(oldProps->defaultValue)) {
+    hybridView->setDefaultValue(newProps->defaultValue.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->min.isProvided()
+        : !newProps->min.hasSameValue(oldProps->min)) {
+    hybridView->setMin(newProps->min.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->max.isProvided()
+        : !newProps->max.hasSameValue(oldProps->max)) {
+    hybridView->setMax(newProps->max.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->segments.isProvided()
+        : !newProps->segments.hasSameValue(oldProps->segments)) {
+    hybridView->setSegments(newProps->segments.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->sliderHeight.isProvided()
+        : !newProps->sliderHeight.hasSameValue(oldProps->sliderHeight)) {
+    hybridView->setSliderHeight(newProps->sliderHeight.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->disabled.isProvided()
+        : !newProps->disabled.hasSameValue(oldProps->disabled)) {
+    hybridView->setDisabled(newProps->disabled.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->showBubble.isProvided()
+        : !newProps->showBubble.hasSameValue(oldProps->showBubble)) {
+    hybridView->setShowBubble(newProps->showBubble.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->centerOrigin.isProvided()
+        : !newProps->centerOrigin.hasSameValue(oldProps->centerOrigin)) {
+    hybridView->setCenterOrigin(newProps->centerOrigin.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->snapTapToSegment.isProvided()
+        : !newProps->snapTapToSegment.hasSameValue(oldProps->snapTapToSegment)) {
+    hybridView->setSnapTapToSegment(newProps->snapTapToSegment.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->fillColor.isProvided()
+        : !newProps->fillColor.hasSameValue(oldProps->fillColor)) {
+    hybridView->setFillColor(newProps->fillColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->trackColor.isProvided()
+        : !newProps->trackColor.hasSameValue(oldProps->trackColor)) {
+    hybridView->setTrackColor(newProps->trackColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->thumbColor.isProvided()
+        : !newProps->thumbColor.hasSameValue(oldProps->thumbColor)) {
+    hybridView->setThumbColor(newProps->thumbColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->thumbBorderColor.isProvided()
+        : !newProps->thumbBorderColor.hasSameValue(oldProps->thumbBorderColor)) {
+    hybridView->setThumbBorderColor(newProps->thumbBorderColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->markActiveColor.isProvided()
+        : !newProps->markActiveColor.hasSameValue(oldProps->markActiveColor)) {
+    hybridView->setMarkActiveColor(newProps->markActiveColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->markInactiveColor.isProvided()
+        : !newProps->markInactiveColor.hasSameValue(oldProps->markInactiveColor)) {
+    hybridView->setMarkInactiveColor(newProps->markInactiveColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->markBorderColor.isProvided()
+        : !newProps->markBorderColor.hasSameValue(oldProps->markBorderColor)) {
+    hybridView->setMarkBorderColor(newProps->markBorderColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->bubbleColor.isProvided()
+        : !newProps->bubbleColor.hasSameValue(oldProps->bubbleColor)) {
+    hybridView->setBubbleColor(newProps->bubbleColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->bubbleTextColor.isProvided()
+        : !newProps->bubbleTextColor.hasSameValue(oldProps->bubbleTextColor)) {
+    hybridView->setBubbleTextColor(newProps->bubbleTextColor.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onChange.isProvided()
+        : !newProps->onChange.hasSameValue(oldProps->onChange)) {
+    hybridView->setOnChange(newProps->onChange.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onSlideStart.isProvided()
+        : !newProps->onSlideStart.hasSameValue(oldProps->onSlideStart)) {
+    hybridView->setOnSlideStart(newProps->onSlideStart.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onSlideComplete.isProvided()
+        : !newProps->onSlideComplete.hasSameValue(oldProps->onSlideComplete)) {
+    hybridView->setOnSlideComplete(newProps->onSlideComplete.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/nitrogen/generated/android/c++/views/JHybridSegmentSliderStateUpdater.hpp

@@ -31,7 +31,12 @@ public:
 public:
   static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
                               jni::alias_ref<JHybridSegmentSliderSpec::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 HybridSegmentSliderProps> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
 
 public:
   static void registerNatives() {

package/nitrogen/generated/android/kotlin/com/margelo/nitro/segmentslider/views/HybridSegmentSliderManager.kt

@@ -20,6 +20,14 @@ import com.margelo.nitro.segmentslider.*
  * Represents the React Native `ViewManager` for the "SegmentSlider" Nitro HybridView.
  */
 public class HybridSegmentSliderManager: SimpleViewManager<View>() {
+  /**
+   * Represents the View and its last state snapshot (mutable)
+   */
+  private class HybridViewHolder(
+    val hybridView: HybridSegmentSlider,
+    var lastState: StateWrapper? = null,
+  )
+
   init {
     if (RecyclableView::class.java.isAssignableFrom(HybridSegmentSlider::class.java)) {
       // Enable view recycling
@@ -34,33 +42,41 @@ public class HybridSegmentSliderManager: SimpleViewManager<View>() {
   override fun createViewInstance(reactContext: ThemedReactContext): View {
     val hybridView = HybridSegmentSlider(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()
-    HybridSegmentSliderStateUpdater.updateViewProps(hybridView, stateWrapper)
+    HybridSegmentSliderStateUpdater.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 HybridSegmentSliderManager: SimpleViewManager<View>() {
     }
   }
 
-  private fun getHybridView(view: View): HybridSegmentSlider? {
-    return view.getTag(associated_hybrid_view_tag) as? HybridSegmentSlider
+  private fun getHybridViewHolder(view: View): HybridViewHolder? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridViewHolder
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/segmentslider/views/HybridSegmentSliderStateUpdater.kt

@@ -14,10 +14,10 @@ internal class HybridSegmentSliderStateUpdater {
   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: HybridSegmentSliderSpec, state: StateWrapper)
+    external fun updateViewProps(view: HybridSegmentSliderSpec, newState: StateWrapper, oldState: StateWrapper?)
   }
 }