@onekeyfe/react-native-segment-slider 3.0.40

package/lib/nitrogen/nitrogen/generated/android/c++/JHybridSegmentSliderSpec.cpp

@@ -0,0 +1,265 @@
+///
+/// JHybridSegmentSliderSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridSegmentSliderSpec.hpp"
+
+
+
+#include <string>
+#include <functional>
+#include <optional>
+#include "JFunc_void_double.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void.hpp"
+
+namespace margelo::nitro::segmentslider {
+
+  jni::local_ref<JHybridSegmentSliderSpec::jhybriddata> JHybridSegmentSliderSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridSegmentSliderSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridSegmentSliderSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridSegmentSliderSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridSegmentSliderSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridSegmentSliderSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  double JHybridSegmentSliderSpec::getValue() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getValue");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setValue(double value) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* value */)>("setValue");
+    method(_javaPart, value);
+  }
+  double JHybridSegmentSliderSpec::getMin() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getMin");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setMin(double min) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* min */)>("setMin");
+    method(_javaPart, min);
+  }
+  double JHybridSegmentSliderSpec::getMax() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getMax");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setMax(double max) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* max */)>("setMax");
+    method(_javaPart, max);
+  }
+  double JHybridSegmentSliderSpec::getSegments() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getSegments");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setSegments(double segments) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* segments */)>("setSegments");
+    method(_javaPart, segments);
+  }
+  double JHybridSegmentSliderSpec::getSliderHeight() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getSliderHeight");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setSliderHeight(double sliderHeight) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* sliderHeight */)>("setSliderHeight");
+    method(_javaPart, sliderHeight);
+  }
+  bool JHybridSegmentSliderSpec::getDisabled() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getDisabled");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridSegmentSliderSpec::setDisabled(bool disabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* disabled */)>("setDisabled");
+    method(_javaPart, disabled);
+  }
+  bool JHybridSegmentSliderSpec::getShowBubble() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getShowBubble");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridSegmentSliderSpec::setShowBubble(bool showBubble) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* showBubble */)>("setShowBubble");
+    method(_javaPart, showBubble);
+  }
+  bool JHybridSegmentSliderSpec::getCenterOrigin() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getCenterOrigin");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridSegmentSliderSpec::setCenterOrigin(bool centerOrigin) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* centerOrigin */)>("setCenterOrigin");
+    method(_javaPart, centerOrigin);
+  }
+  double JHybridSegmentSliderSpec::getEpoch() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getEpoch");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setEpoch(double epoch) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* epoch */)>("setEpoch");
+    method(_javaPart, epoch);
+  }
+  std::string JHybridSegmentSliderSpec::getFillColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getFillColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setFillColor(const std::string& fillColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* fillColor */)>("setFillColor");
+    method(_javaPart, jni::make_jstring(fillColor));
+  }
+  std::string JHybridSegmentSliderSpec::getTrackColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getTrackColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setTrackColor(const std::string& trackColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* trackColor */)>("setTrackColor");
+    method(_javaPart, jni::make_jstring(trackColor));
+  }
+  std::string JHybridSegmentSliderSpec::getThumbColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getThumbColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setThumbColor(const std::string& thumbColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* thumbColor */)>("setThumbColor");
+    method(_javaPart, jni::make_jstring(thumbColor));
+  }
+  std::string JHybridSegmentSliderSpec::getThumbBorderColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getThumbBorderColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setThumbBorderColor(const std::string& thumbBorderColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* thumbBorderColor */)>("setThumbBorderColor");
+    method(_javaPart, jni::make_jstring(thumbBorderColor));
+  }
+  std::string JHybridSegmentSliderSpec::getMarkActiveColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getMarkActiveColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setMarkActiveColor(const std::string& markActiveColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* markActiveColor */)>("setMarkActiveColor");
+    method(_javaPart, jni::make_jstring(markActiveColor));
+  }
+  std::string JHybridSegmentSliderSpec::getMarkInactiveColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getMarkInactiveColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setMarkInactiveColor(const std::string& markInactiveColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* markInactiveColor */)>("setMarkInactiveColor");
+    method(_javaPart, jni::make_jstring(markInactiveColor));
+  }
+  std::string JHybridSegmentSliderSpec::getMarkBorderColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getMarkBorderColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setMarkBorderColor(const std::string& markBorderColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* markBorderColor */)>("setMarkBorderColor");
+    method(_javaPart, jni::make_jstring(markBorderColor));
+  }
+  std::string JHybridSegmentSliderSpec::getBubbleColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getBubbleColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setBubbleColor(const std::string& bubbleColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* bubbleColor */)>("setBubbleColor");
+    method(_javaPart, jni::make_jstring(bubbleColor));
+  }
+  std::string JHybridSegmentSliderSpec::getBubbleTextColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getBubbleTextColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setBubbleTextColor(const std::string& bubbleTextColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* bubbleTextColor */)>("setBubbleTextColor");
+    method(_javaPart, jni::make_jstring(bubbleTextColor));
+  }
+  std::optional<std::function<void(double /* value */)>> JHybridSegmentSliderSpec::getOnChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double::javaobject>()>("getOnChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(double /* value */)> {
+      if (__result->isInstanceOf(JFunc_void_double_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_double_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_double, void(double)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridSegmentSliderSpec::setOnChange(const std::optional<std::function<void(double /* value */)>>& onChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double::javaobject> /* onChange */)>("setOnChange_cxx");
+    method(_javaPart, onChange.has_value() ? JFunc_void_double_cxx::fromCpp(onChange.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridSegmentSliderSpec::getOnSlideStart() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnSlideStart_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 JHybridSegmentSliderSpec::setOnSlideStart(const std::optional<std::function<void()>>& onSlideStart) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onSlideStart */)>("setOnSlideStart_cxx");
+    method(_javaPart, onSlideStart.has_value() ? JFunc_void_cxx::fromCpp(onSlideStart.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridSegmentSliderSpec::getOnSlideComplete() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnSlideComplete_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 JHybridSegmentSliderSpec::setOnSlideComplete(const std::optional<std::function<void()>>& onSlideComplete) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onSlideComplete */)>("setOnSlideComplete_cxx");
+    method(_javaPart, onSlideComplete.has_value() ? JFunc_void_cxx::fromCpp(onSlideComplete.value()) : nullptr);
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::segmentslider

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

@@ -0,0 +1,106 @@
+///
+/// HybridSegmentSliderSpec.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 "HybridSegmentSliderSpec.hpp"
+
+
+
+
+namespace margelo::nitro::segmentslider {
+
+  using namespace facebook;
+
+  class JHybridSegmentSliderSpec: public jni::HybridClass<JHybridSegmentSliderSpec, JHybridObject>,
+                                  public virtual HybridSegmentSliderSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/segmentslider/HybridSegmentSliderSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridSegmentSliderSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridSegmentSliderSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridSegmentSliderSpec() 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<JHybridSegmentSliderSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    double getValue() override;
+    void setValue(double value) override;
+    double getMin() override;
+    void setMin(double min) override;
+    double getMax() override;
+    void setMax(double max) override;
+    double getSegments() override;
+    void setSegments(double segments) override;
+    double getSliderHeight() override;
+    void setSliderHeight(double sliderHeight) override;
+    bool getDisabled() override;
+    void setDisabled(bool disabled) override;
+    bool getShowBubble() override;
+    void setShowBubble(bool showBubble) override;
+    bool getCenterOrigin() override;
+    void setCenterOrigin(bool centerOrigin) override;
+    double getEpoch() override;
+    void setEpoch(double epoch) override;
+    std::string getFillColor() override;
+    void setFillColor(const std::string& fillColor) override;
+    std::string getTrackColor() override;
+    void setTrackColor(const std::string& trackColor) override;
+    std::string getThumbColor() override;
+    void setThumbColor(const std::string& thumbColor) override;
+    std::string getThumbBorderColor() override;
+    void setThumbBorderColor(const std::string& thumbBorderColor) override;
+    std::string getMarkActiveColor() override;
+    void setMarkActiveColor(const std::string& markActiveColor) override;
+    std::string getMarkInactiveColor() override;
+    void setMarkInactiveColor(const std::string& markInactiveColor) override;
+    std::string getMarkBorderColor() override;
+    void setMarkBorderColor(const std::string& markBorderColor) override;
+    std::string getBubbleColor() override;
+    void setBubbleColor(const std::string& bubbleColor) override;
+    std::string getBubbleTextColor() override;
+    void setBubbleTextColor(const std::string& bubbleTextColor) override;
+    std::optional<std::function<void(double /* value */)>> getOnChange() override;
+    void setOnChange(const std::optional<std::function<void(double /* value */)>>& onChange) override;
+    std::optional<std::function<void()>> getOnSlideStart() override;
+    void setOnSlideStart(const std::optional<std::function<void()>>& onSlideStart) override;
+    std::optional<std::function<void()>> getOnSlideComplete() override;
+    void setOnSlideComplete(const std::optional<std::function<void()>>& onSlideComplete) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridSegmentSliderSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::segmentslider

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

@@ -0,0 +1,136 @@
+///
+/// JHybridSegmentSliderStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridSegmentSliderStateUpdater.hpp"
+#include "views/HybridSegmentSliderComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+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::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  JHybridSegmentSliderSpec* 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 HybridSegmentSliderState& data = concreteState->getData();
+  const std::optional<HybridSegmentSliderProps>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridSegmentSliderState's data doesn't contain any props!");
+  }
+  const HybridSegmentSliderProps& props = maybeProps.value();
+  if (props.value.isDirty) {
+    view->setValue(props.value.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.min.isDirty) {
+    view->setMin(props.min.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.max.isDirty) {
+    view->setMax(props.max.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.segments.isDirty) {
+    view->setSegments(props.segments.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.sliderHeight.isDirty) {
+    view->setSliderHeight(props.sliderHeight.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.disabled.isDirty) {
+    view->setDisabled(props.disabled.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.showBubble.isDirty) {
+    view->setShowBubble(props.showBubble.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.centerOrigin.isDirty) {
+    view->setCenterOrigin(props.centerOrigin.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.epoch.isDirty) {
+    view->setEpoch(props.epoch.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.fillColor.isDirty) {
+    view->setFillColor(props.fillColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.trackColor.isDirty) {
+    view->setTrackColor(props.trackColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.thumbColor.isDirty) {
+    view->setThumbColor(props.thumbColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.thumbBorderColor.isDirty) {
+    view->setThumbBorderColor(props.thumbBorderColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.markActiveColor.isDirty) {
+    view->setMarkActiveColor(props.markActiveColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.markInactiveColor.isDirty) {
+    view->setMarkInactiveColor(props.markInactiveColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.markBorderColor.isDirty) {
+    view->setMarkBorderColor(props.markBorderColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.bubbleColor.isDirty) {
+    view->setBubbleColor(props.bubbleColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.bubbleTextColor.isDirty) {
+    view->setBubbleTextColor(props.bubbleTextColor.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onChange.isDirty) {
+    view->setOnChange(props.onChange.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onSlideStart.isDirty) {
+    view->setOnSlideStart(props.onSlideStart.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.onSlideComplete.isDirty) {
+    view->setOnSlideComplete(props.onSlideComplete.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<JHybridSegmentSliderSpec> shared = javaView->cthis()->shared_cast<JHybridSegmentSliderSpec>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace margelo::nitro::segmentslider::views

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

@@ -0,0 +1,49 @@
+///
+/// JHybridSegmentSliderStateUpdater.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 segmentslider 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 "JHybridSegmentSliderSpec.hpp"
+#include "views/HybridSegmentSliderComponent.hpp"
+
+namespace margelo::nitro::segmentslider::views {
+
+using namespace facebook;
+
+class JHybridSegmentSliderStateUpdater: public jni::JavaClass<JHybridSegmentSliderStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/segmentslider/views/HybridSegmentSliderStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridSegmentSliderSpec::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridSegmentSliderStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridSegmentSliderComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::segmentslider::views

package/lib/nitrogen/nitrogen/generated/android/kotlin/com/margelo/nitro/segmentslider/Func_void.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.segmentslider
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `() => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void: () -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(): Unit
+}
+
+/**
+ * Represents the JavaScript callback `() => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_cxx: Func_void {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(): Unit
+    = invoke_cxx()
+
+  @FastNative
+  private external fun invoke_cxx(): Unit
+}
+
+/**
+ * Represents the JavaScript callback `() => void`.
+ * This is implemented in Java/Kotlin, via a `() -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_java(private val function: () -> Unit): Func_void {
+  @DoNotStrip
+  @Keep
+  override fun invoke(): Unit {
+    return this.function()
+  }
+}