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

package/nitrogen/generated/ios/c++/views/HybridSegmentSliderComponent.mm

@@ -37,6 +37,7 @@ using namespace margelo::nitro::segmentslider::views;
 
 @implementation HybridSegmentSliderComponent {
   std::shared_ptr<HybridSegmentSliderSpecSwift> _hybridView;
+  BOOL _didDropView;
 }
 
 + (void) load {
@@ -50,6 +51,7 @@ using namespace margelo::nitro::segmentslider::views;
 
 - (instancetype) init {
   if (self = [super init]) {
+    _props = HybridSegmentSliderShadowNode::defaultSharedProps();
     std::shared_ptr<HybridSegmentSliderSpec> hybridView = SegmentSlider::SegmentSliderAutolinking::createSegmentSlider();
     _hybridView = std::dynamic_pointer_cast<HybridSegmentSliderSpecSwift>(hybridView);
     [self updateView];
@@ -69,135 +71,175 @@ using namespace margelo::nitro::segmentslider::views;
   [self setContentView:view];
 }
 
+- (void) notifyOnDropView {
+  // A recycled component can later be invalidated. Notify only once per mount.
+  if (_didDropView) {
+    return;
+  }
+  SegmentSlider::HybridSegmentSliderSpec_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<HybridSegmentSliderProps const>(props);
-  auto& newViewProps = const_cast<HybridSegmentSliderProps&>(newViewPropsConst);
+  const auto& newViewProps = *std::static_pointer_cast<const HybridSegmentSliderProps>(props);
+  const auto* oldViewProps = static_cast<const HybridSegmentSliderProps*>(oldProps.get());
   SegmentSlider::HybridSegmentSliderSpec_cxx& swiftPart = _hybridView->getSwiftPart();
 
-  // 2. Update each prop individually
-  swiftPart.beforeUpdate();
-
-  // defaultValue: number
-  if (newViewProps.defaultValue.isDirty) {
-    swiftPart.setDefaultValue(newViewProps.defaultValue.value);
-    newViewProps.defaultValue.isDirty = false;
-  }
-  // min: number
-  if (newViewProps.min.isDirty) {
-    swiftPart.setMin(newViewProps.min.value);
-    newViewProps.min.isDirty = false;
-  }
-  // max: number
-  if (newViewProps.max.isDirty) {
-    swiftPart.setMax(newViewProps.max.value);
-    newViewProps.max.isDirty = false;
-  }
-  // segments: number
-  if (newViewProps.segments.isDirty) {
-    swiftPart.setSegments(newViewProps.segments.value);
-    newViewProps.segments.isDirty = false;
-  }
-  // sliderHeight: number
-  if (newViewProps.sliderHeight.isDirty) {
-    swiftPart.setSliderHeight(newViewProps.sliderHeight.value);
-    newViewProps.sliderHeight.isDirty = false;
-  }
-  // disabled: boolean
-  if (newViewProps.disabled.isDirty) {
-    swiftPart.setDisabled(newViewProps.disabled.value);
-    newViewProps.disabled.isDirty = false;
-  }
-  // showBubble: boolean
-  if (newViewProps.showBubble.isDirty) {
-    swiftPart.setShowBubble(newViewProps.showBubble.value);
-    newViewProps.showBubble.isDirty = false;
-  }
-  // centerOrigin: boolean
-  if (newViewProps.centerOrigin.isDirty) {
-    swiftPart.setCenterOrigin(newViewProps.centerOrigin.value);
-    newViewProps.centerOrigin.isDirty = false;
-  }
-  // snapTapToSegment: boolean
-  if (newViewProps.snapTapToSegment.isDirty) {
-    swiftPart.setSnapTapToSegment(newViewProps.snapTapToSegment.value);
-    newViewProps.snapTapToSegment.isDirty = false;
-  }
-  // fillColor: string
-  if (newViewProps.fillColor.isDirty) {
-    swiftPart.setFillColor(newViewProps.fillColor.value);
-    newViewProps.fillColor.isDirty = false;
-  }
-  // trackColor: string
-  if (newViewProps.trackColor.isDirty) {
-    swiftPart.setTrackColor(newViewProps.trackColor.value);
-    newViewProps.trackColor.isDirty = false;
-  }
-  // thumbColor: string
-  if (newViewProps.thumbColor.isDirty) {
-    swiftPart.setThumbColor(newViewProps.thumbColor.value);
-    newViewProps.thumbColor.isDirty = false;
-  }
-  // thumbBorderColor: string
-  if (newViewProps.thumbBorderColor.isDirty) {
-    swiftPart.setThumbBorderColor(newViewProps.thumbBorderColor.value);
-    newViewProps.thumbBorderColor.isDirty = false;
-  }
-  // markActiveColor: string
-  if (newViewProps.markActiveColor.isDirty) {
-    swiftPart.setMarkActiveColor(newViewProps.markActiveColor.value);
-    newViewProps.markActiveColor.isDirty = false;
-  }
-  // markInactiveColor: string
-  if (newViewProps.markInactiveColor.isDirty) {
-    swiftPart.setMarkInactiveColor(newViewProps.markInactiveColor.value);
-    newViewProps.markInactiveColor.isDirty = false;
-  }
-  // markBorderColor: string
-  if (newViewProps.markBorderColor.isDirty) {
-    swiftPart.setMarkBorderColor(newViewProps.markBorderColor.value);
-    newViewProps.markBorderColor.isDirty = false;
-  }
-  // bubbleColor: string
-  if (newViewProps.bubbleColor.isDirty) {
-    swiftPart.setBubbleColor(newViewProps.bubbleColor.value);
-    newViewProps.bubbleColor.isDirty = false;
-  }
-  // bubbleTextColor: string
-  if (newViewProps.bubbleTextColor.isDirty) {
-    swiftPart.setBubbleTextColor(newViewProps.bubbleTextColor.value);
-    newViewProps.bubbleTextColor.isDirty = false;
-  }
-  // onChange: optional
-  if (newViewProps.onChange.isDirty) {
-    swiftPart.setOnChange(newViewProps.onChange.value);
-    newViewProps.onChange.isDirty = false;
-  }
-  // onSlideStart: optional
-  if (newViewProps.onSlideStart.isDirty) {
-    swiftPart.setOnSlideStart(newViewProps.onSlideStart.value);
-    newViewProps.onSlideStart.isDirty = false;
-  }
-  // onSlideComplete: optional
-  if (newViewProps.onSlideComplete.isDirty) {
-    swiftPart.setOnSlideComplete(newViewProps.onSlideComplete.value);
-    newViewProps.onSlideComplete.isDirty = false;
-  }
+  // 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();
 
-  swiftPart.afterUpdate();
+    // defaultValue: number
+    if (oldViewProps == nullptr
+          ? newViewProps.defaultValue.isProvided()
+          : !newViewProps.defaultValue.hasSameValue(oldViewProps->defaultValue)) {
+      swiftPart.setDefaultValue(newViewProps.defaultValue.get());
+    }
+    // min: number
+    if (oldViewProps == nullptr
+          ? newViewProps.min.isProvided()
+          : !newViewProps.min.hasSameValue(oldViewProps->min)) {
+      swiftPart.setMin(newViewProps.min.get());
+    }
+    // max: number
+    if (oldViewProps == nullptr
+          ? newViewProps.max.isProvided()
+          : !newViewProps.max.hasSameValue(oldViewProps->max)) {
+      swiftPart.setMax(newViewProps.max.get());
+    }
+    // segments: number
+    if (oldViewProps == nullptr
+          ? newViewProps.segments.isProvided()
+          : !newViewProps.segments.hasSameValue(oldViewProps->segments)) {
+      swiftPart.setSegments(newViewProps.segments.get());
+    }
+    // sliderHeight: number
+    if (oldViewProps == nullptr
+          ? newViewProps.sliderHeight.isProvided()
+          : !newViewProps.sliderHeight.hasSameValue(oldViewProps->sliderHeight)) {
+      swiftPart.setSliderHeight(newViewProps.sliderHeight.get());
+    }
+    // disabled: boolean
+    if (oldViewProps == nullptr
+          ? newViewProps.disabled.isProvided()
+          : !newViewProps.disabled.hasSameValue(oldViewProps->disabled)) {
+      swiftPart.setDisabled(newViewProps.disabled.get());
+    }
+    // showBubble: boolean
+    if (oldViewProps == nullptr
+          ? newViewProps.showBubble.isProvided()
+          : !newViewProps.showBubble.hasSameValue(oldViewProps->showBubble)) {
+      swiftPart.setShowBubble(newViewProps.showBubble.get());
+    }
+    // centerOrigin: boolean
+    if (oldViewProps == nullptr
+          ? newViewProps.centerOrigin.isProvided()
+          : !newViewProps.centerOrigin.hasSameValue(oldViewProps->centerOrigin)) {
+      swiftPart.setCenterOrigin(newViewProps.centerOrigin.get());
+    }
+    // snapTapToSegment: boolean
+    if (oldViewProps == nullptr
+          ? newViewProps.snapTapToSegment.isProvided()
+          : !newViewProps.snapTapToSegment.hasSameValue(oldViewProps->snapTapToSegment)) {
+      swiftPart.setSnapTapToSegment(newViewProps.snapTapToSegment.get());
+    }
+    // fillColor: string
+    if (oldViewProps == nullptr
+          ? newViewProps.fillColor.isProvided()
+          : !newViewProps.fillColor.hasSameValue(oldViewProps->fillColor)) {
+      swiftPart.setFillColor(newViewProps.fillColor.get());
+    }
+    // trackColor: string
+    if (oldViewProps == nullptr
+          ? newViewProps.trackColor.isProvided()
+          : !newViewProps.trackColor.hasSameValue(oldViewProps->trackColor)) {
+      swiftPart.setTrackColor(newViewProps.trackColor.get());
+    }
+    // thumbColor: string
+    if (oldViewProps == nullptr
+          ? newViewProps.thumbColor.isProvided()
+          : !newViewProps.thumbColor.hasSameValue(oldViewProps->thumbColor)) {
+      swiftPart.setThumbColor(newViewProps.thumbColor.get());
+    }
+    // thumbBorderColor: string
+    if (oldViewProps == nullptr
+          ? newViewProps.thumbBorderColor.isProvided()
+          : !newViewProps.thumbBorderColor.hasSameValue(oldViewProps->thumbBorderColor)) {
+      swiftPart.setThumbBorderColor(newViewProps.thumbBorderColor.get());
+    }
+    // markActiveColor: string
+    if (oldViewProps == nullptr
+          ? newViewProps.markActiveColor.isProvided()
+          : !newViewProps.markActiveColor.hasSameValue(oldViewProps->markActiveColor)) {
+      swiftPart.setMarkActiveColor(newViewProps.markActiveColor.get());
+    }
+    // markInactiveColor: string
+    if (oldViewProps == nullptr
+          ? newViewProps.markInactiveColor.isProvided()
+          : !newViewProps.markInactiveColor.hasSameValue(oldViewProps->markInactiveColor)) {
+      swiftPart.setMarkInactiveColor(newViewProps.markInactiveColor.get());
+    }
+    // markBorderColor: string
+    if (oldViewProps == nullptr
+          ? newViewProps.markBorderColor.isProvided()
+          : !newViewProps.markBorderColor.hasSameValue(oldViewProps->markBorderColor)) {
+      swiftPart.setMarkBorderColor(newViewProps.markBorderColor.get());
+    }
+    // bubbleColor: string
+    if (oldViewProps == nullptr
+          ? newViewProps.bubbleColor.isProvided()
+          : !newViewProps.bubbleColor.hasSameValue(oldViewProps->bubbleColor)) {
+      swiftPart.setBubbleColor(newViewProps.bubbleColor.get());
+    }
+    // bubbleTextColor: string
+    if (oldViewProps == nullptr
+          ? newViewProps.bubbleTextColor.isProvided()
+          : !newViewProps.bubbleTextColor.hasSameValue(oldViewProps->bubbleTextColor)) {
+      swiftPart.setBubbleTextColor(newViewProps.bubbleTextColor.get());
+    }
+    // onChange: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.onChange.isProvided()
+          : !newViewProps.onChange.hasSameValue(oldViewProps->onChange)) {
+      swiftPart.setOnChange(newViewProps.onChange.get());
+    }
+    // onSlideStart: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.onSlideStart.isProvided()
+          : !newViewProps.onSlideStart.hasSameValue(oldViewProps->onSlideStart)) {
+      swiftPart.setOnSlideStart(newViewProps.onSlideStart.get());
+    }
+    // onSlideComplete: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.onSlideComplete.isProvided()
+          : !newViewProps.onSlideComplete.hasSameValue(oldViewProps->onSlideComplete)) {
+      swiftPart.setOnSlideComplete(newViewProps.onSlideComplete.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];
 }
 
@@ -206,6 +248,7 @@ using namespace margelo::nitro::segmentslider::views;
 }
 
 - (void)prepareForRecycle {
+  [self notifyOnDropView];
   [super prepareForRecycle];
   SegmentSlider::HybridSegmentSliderSpec_cxx& swiftPart = _hybridView->getSwiftPart();
   swiftPart.maybePrepareForRecycle();
@@ -213,8 +256,7 @@ using namespace margelo::nitro::segmentslider::views;
 
 #ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
 - (void)invalidate {
-  SegmentSlider::HybridSegmentSliderSpec_cxx& swiftPart = _hybridView->getSwiftPart();
-  swiftPart.onDropView();
+  [self notifyOnDropView];
   [super invalidate];
 }
 #endif

package/nitrogen/generated/shared/c++/views/HybridSegmentSliderComponent.cpp

@@ -7,245 +7,41 @@
 
 #include "HybridSegmentSliderComponent.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::segmentslider::views {
 
+  using namespace facebook;
+
   extern const char HybridSegmentSliderComponentName[] = "SegmentSlider";
 
   HybridSegmentSliderProps::HybridSegmentSliderProps(const react::PropsParserContext& context,
                                                      const HybridSegmentSliderProps& sourceProps,
                                                      const react::RawProps& rawProps):
     react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
-    defaultValue([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("defaultValue", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.defaultValue;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.defaultValue);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.defaultValue: ") + exc.what());
-      }
-    }()),
-    min([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("min", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.min;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.min);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.min: ") + exc.what());
-      }
-    }()),
-    max([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("max", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.max;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.max);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.max: ") + exc.what());
-      }
-    }()),
-    segments([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("segments", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.segments;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.segments);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.segments: ") + exc.what());
-      }
-    }()),
-    sliderHeight([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("sliderHeight", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.sliderHeight;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.sliderHeight);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.sliderHeight: ") + exc.what());
-      }
-    }()),
-    disabled([&]() -> CachedProp<bool> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("disabled", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.disabled;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.disabled);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.disabled: ") + exc.what());
-      }
-    }()),
-    showBubble([&]() -> CachedProp<bool> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("showBubble", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.showBubble;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.showBubble);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.showBubble: ") + exc.what());
-      }
-    }()),
-    centerOrigin([&]() -> CachedProp<bool> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("centerOrigin", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.centerOrigin;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.centerOrigin);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.centerOrigin: ") + exc.what());
-      }
-    }()),
-    snapTapToSegment([&]() -> CachedProp<bool> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("snapTapToSegment", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.snapTapToSegment;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.snapTapToSegment);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.snapTapToSegment: ") + exc.what());
-      }
-    }()),
-    fillColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("fillColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.fillColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.fillColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.fillColor: ") + exc.what());
-      }
-    }()),
-    trackColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("trackColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.trackColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.trackColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.trackColor: ") + exc.what());
-      }
-    }()),
-    thumbColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("thumbColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.thumbColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.thumbColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.thumbColor: ") + exc.what());
-      }
-    }()),
-    thumbBorderColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("thumbBorderColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.thumbBorderColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.thumbBorderColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.thumbBorderColor: ") + exc.what());
-      }
-    }()),
-    markActiveColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("markActiveColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.markActiveColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.markActiveColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.markActiveColor: ") + exc.what());
-      }
-    }()),
-    markInactiveColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("markInactiveColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.markInactiveColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.markInactiveColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.markInactiveColor: ") + exc.what());
-      }
-    }()),
-    markBorderColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("markBorderColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.markBorderColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.markBorderColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.markBorderColor: ") + exc.what());
-      }
-    }()),
-    bubbleColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("bubbleColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.bubbleColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.bubbleColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.bubbleColor: ") + exc.what());
-      }
-    }()),
-    bubbleTextColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("bubbleTextColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.bubbleTextColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.bubbleTextColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.bubbleTextColor: ") + exc.what());
-      }
-    }()),
-    onChange([&]() -> CachedProp<std::optional<std::function<void(double /* value */)>>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("onChange", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.onChange;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<std::function<void(double /* value */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")), sourceProps.onChange);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.onChange: ") + exc.what());
-      }
-    }()),
-    onSlideStart([&]() -> CachedProp<std::optional<std::function<void()>>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("onSlideStart", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.onSlideStart;
-        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.onSlideStart);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.onSlideStart: ") + exc.what());
-      }
-    }()),
-    onSlideComplete([&]() -> CachedProp<std::optional<std::function<void()>>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("onSlideComplete", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.onSlideComplete;
-        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.onSlideComplete);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("SegmentSlider.onSlideComplete: ") + exc.what());
-      }
-    }()),
-    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridSegmentSliderSpec>& /* 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<HybridSegmentSliderSpec>& /* 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("SegmentSlider.hybridRef: ") + exc.what());
-      }
-    }()) { }
+    defaultValue(nitro::ReactProp<double>::fromRawValue("SegmentSlider", "defaultValue", rawProps, sourceProps.defaultValue)),
+    min(nitro::ReactProp<double>::fromRawValue("SegmentSlider", "min", rawProps, sourceProps.min)),
+    max(nitro::ReactProp<double>::fromRawValue("SegmentSlider", "max", rawProps, sourceProps.max)),
+    segments(nitro::ReactProp<double>::fromRawValue("SegmentSlider", "segments", rawProps, sourceProps.segments)),
+    sliderHeight(nitro::ReactProp<double>::fromRawValue("SegmentSlider", "sliderHeight", rawProps, sourceProps.sliderHeight)),
+    disabled(nitro::ReactProp<bool>::fromRawValue("SegmentSlider", "disabled", rawProps, sourceProps.disabled)),
+    showBubble(nitro::ReactProp<bool>::fromRawValue("SegmentSlider", "showBubble", rawProps, sourceProps.showBubble)),
+    centerOrigin(nitro::ReactProp<bool>::fromRawValue("SegmentSlider", "centerOrigin", rawProps, sourceProps.centerOrigin)),
+    snapTapToSegment(nitro::ReactProp<bool>::fromRawValue("SegmentSlider", "snapTapToSegment", rawProps, sourceProps.snapTapToSegment)),
+    fillColor(nitro::ReactProp<std::string>::fromRawValue("SegmentSlider", "fillColor", rawProps, sourceProps.fillColor)),
+    trackColor(nitro::ReactProp<std::string>::fromRawValue("SegmentSlider", "trackColor", rawProps, sourceProps.trackColor)),
+    thumbColor(nitro::ReactProp<std::string>::fromRawValue("SegmentSlider", "thumbColor", rawProps, sourceProps.thumbColor)),
+    thumbBorderColor(nitro::ReactProp<std::string>::fromRawValue("SegmentSlider", "thumbBorderColor", rawProps, sourceProps.thumbBorderColor)),
+    markActiveColor(nitro::ReactProp<std::string>::fromRawValue("SegmentSlider", "markActiveColor", rawProps, sourceProps.markActiveColor)),
+    markInactiveColor(nitro::ReactProp<std::string>::fromRawValue("SegmentSlider", "markInactiveColor", rawProps, sourceProps.markInactiveColor)),
+    markBorderColor(nitro::ReactProp<std::string>::fromRawValue("SegmentSlider", "markBorderColor", rawProps, sourceProps.markBorderColor)),
+    bubbleColor(nitro::ReactProp<std::string>::fromRawValue("SegmentSlider", "bubbleColor", rawProps, sourceProps.bubbleColor)),
+    bubbleTextColor(nitro::ReactProp<std::string>::fromRawValue("SegmentSlider", "bubbleTextColor", rawProps, sourceProps.bubbleTextColor)),
+    onChange(nitro::ReactProp<std::optional<std::function<void(double /* value */)>>>::fromRawValue("SegmentSlider", "onChange", rawProps, sourceProps.onChange)),
+    onSlideStart(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("SegmentSlider", "onSlideStart", rawProps, sourceProps.onSlideStart)),
+    onSlideComplete(nitro::ReactProp<std::optional<std::function<void()>>>::fromRawValue("SegmentSlider", "onSlideComplete", rawProps, sourceProps.onSlideComplete)),
+    hybridRef(nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridSegmentSliderSpec>& /* ref */)>>>::fromRawValue("SegmentSlider", "hybridRef", rawProps, sourceProps.hybridRef)) { }
 
   bool HybridSegmentSliderProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
@@ -275,29 +71,4 @@ namespace margelo::nitro::segmentslider::views {
     }
   }
 
-  HybridSegmentSliderComponentDescriptor::HybridSegmentSliderComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
-    : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser()) {}
-
-  std::shared_ptr<const react::Props> HybridSegmentSliderComponentDescriptor::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 HybridSegmentSliderShadowNode::Props(context, /* & */ rawProps, props);
-  }
-
-#ifdef ANDROID
-  void HybridSegmentSliderComponentDescriptor::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<HybridSegmentSliderShadowNode&>(shadowNode);
-    const std::shared_ptr<const HybridSegmentSliderProps>& constProps = concreteShadowNode.getConcreteSharedProps();
-    const std::shared_ptr<HybridSegmentSliderProps>& props = std::const_pointer_cast<HybridSegmentSliderProps>(constProps);
-    HybridSegmentSliderState state{props};
-    concreteShadowNode.setStateData(std::move(state));
-  }
-#endif
-
 } // namespace margelo::nitro::segmentslider::views