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

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

@@ -7,215 +7,38 @@
 
 #include "HybridPerpDepthBarsComponent.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::perpdepthbar::views {
 
+  using namespace facebook;
+
   extern const char HybridPerpDepthBarsComponentName[] = "PerpDepthBars";
 
   HybridPerpDepthBarsProps::HybridPerpDepthBarsProps(const react::PropsParserContext& context,
                                                      const HybridPerpDepthBarsProps& sourceProps,
                                                      const react::RawProps& rawProps):
     react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
-    percents([&]() -> CachedProp<std::vector<double>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("percents", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.percents;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::vector<double>>::fromRawValue(*runtime, value, sourceProps.percents);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.percents: ") + exc.what());
-      }
-    }()),
-    rowHeight([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("rowHeight", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.rowHeight;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.rowHeight);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.rowHeight: ") + exc.what());
-      }
-    }()),
-    rowMarginTop([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("rowMarginTop", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.rowMarginTop;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.rowMarginTop);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.rowMarginTop: ") + exc.what());
-      }
-    }()),
-    barInset([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("barInset", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.barInset;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.barInset);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.barInset: ") + exc.what());
-      }
-    }()),
-    color([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("color", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.color;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.color);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.color: ") + exc.what());
-      }
-    }()),
-    origin([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("origin", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.origin;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.origin);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.origin: ") + exc.what());
-      }
-    }()),
-    reducedMotion([&]() -> CachedProp<bool> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("reducedMotion", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.reducedMotion;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.reducedMotion);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.reducedMotion: ") + exc.what());
-      }
-    }()),
-    epoch([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("epoch", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.epoch;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.epoch);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.epoch: ") + exc.what());
-      }
-    }()),
-    prices([&]() -> CachedProp<std::vector<std::string>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("prices", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.prices;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::vector<std::string>>::fromRawValue(*runtime, value, sourceProps.prices);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.prices: ") + exc.what());
-      }
-    }()),
-    sizes([&]() -> CachedProp<std::vector<std::string>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("sizes", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.sizes;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::vector<std::string>>::fromRawValue(*runtime, value, sourceProps.sizes);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.sizes: ") + exc.what());
-      }
-    }()),
-    priceColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("priceColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.priceColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.priceColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.priceColor: ") + exc.what());
-      }
-    }()),
-    sizeColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("sizeColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.sizeColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.sizeColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.sizeColor: ") + exc.what());
-      }
-    }()),
-    priceFontSize([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("priceFontSize", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.priceFontSize;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.priceFontSize);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.priceFontSize: ") + exc.what());
-      }
-    }()),
-    sizeFontSize([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("sizeFontSize", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.sizeFontSize;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.sizeFontSize);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.sizeFontSize: ") + exc.what());
-      }
-    }()),
-    textInset([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("textInset", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.textInset;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.textInset);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.textInset: ") + exc.what());
-      }
-    }()),
-    placeholderText([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("placeholderText", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.placeholderText;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.placeholderText);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.placeholderText: ") + exc.what());
-      }
-    }()),
-    placeholderRows([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("placeholderRows", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.placeholderRows;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.placeholderRows);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.placeholderRows: ") + exc.what());
-      }
-    }()),
-    onRowPress([&]() -> CachedProp<std::optional<std::function<void(double /* rowIndex */)>>> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("onRowPress", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.onRowPress;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::optional<std::function<void(double /* rowIndex */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, PropNameIDCache::get(*runtime, "f")), sourceProps.onRowPress);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpDepthBars.onRowPress: ") + exc.what());
-      }
-    }()),
-    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* 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<HybridPerpDepthBarsSpec>& /* 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("PerpDepthBars.hybridRef: ") + exc.what());
-      }
-    }()) { }
+    percents(nitro::ReactProp<std::vector<double>>::fromRawValue("PerpDepthBars", "percents", rawProps, sourceProps.percents)),
+    rowHeight(nitro::ReactProp<double>::fromRawValue("PerpDepthBars", "rowHeight", rawProps, sourceProps.rowHeight)),
+    rowMarginTop(nitro::ReactProp<double>::fromRawValue("PerpDepthBars", "rowMarginTop", rawProps, sourceProps.rowMarginTop)),
+    barInset(nitro::ReactProp<double>::fromRawValue("PerpDepthBars", "barInset", rawProps, sourceProps.barInset)),
+    color(nitro::ReactProp<std::string>::fromRawValue("PerpDepthBars", "color", rawProps, sourceProps.color)),
+    origin(nitro::ReactProp<std::string>::fromRawValue("PerpDepthBars", "origin", rawProps, sourceProps.origin)),
+    reducedMotion(nitro::ReactProp<bool>::fromRawValue("PerpDepthBars", "reducedMotion", rawProps, sourceProps.reducedMotion)),
+    epoch(nitro::ReactProp<double>::fromRawValue("PerpDepthBars", "epoch", rawProps, sourceProps.epoch)),
+    prices(nitro::ReactProp<std::vector<std::string>>::fromRawValue("PerpDepthBars", "prices", rawProps, sourceProps.prices)),
+    sizes(nitro::ReactProp<std::vector<std::string>>::fromRawValue("PerpDepthBars", "sizes", rawProps, sourceProps.sizes)),
+    priceColor(nitro::ReactProp<std::string>::fromRawValue("PerpDepthBars", "priceColor", rawProps, sourceProps.priceColor)),
+    sizeColor(nitro::ReactProp<std::string>::fromRawValue("PerpDepthBars", "sizeColor", rawProps, sourceProps.sizeColor)),
+    priceFontSize(nitro::ReactProp<double>::fromRawValue("PerpDepthBars", "priceFontSize", rawProps, sourceProps.priceFontSize)),
+    sizeFontSize(nitro::ReactProp<double>::fromRawValue("PerpDepthBars", "sizeFontSize", rawProps, sourceProps.sizeFontSize)),
+    textInset(nitro::ReactProp<double>::fromRawValue("PerpDepthBars", "textInset", rawProps, sourceProps.textInset)),
+    placeholderText(nitro::ReactProp<std::string>::fromRawValue("PerpDepthBars", "placeholderText", rawProps, sourceProps.placeholderText)),
+    placeholderRows(nitro::ReactProp<double>::fromRawValue("PerpDepthBars", "placeholderRows", rawProps, sourceProps.placeholderRows)),
+    onRowPress(nitro::ReactProp<std::optional<std::function<void(double /* rowIndex */)>>>::fromRawValue("PerpDepthBars", "onRowPress", rawProps, sourceProps.onRowPress)),
+    hybridRef(nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* ref */)>>>::fromRawValue("PerpDepthBars", "hybridRef", rawProps, sourceProps.hybridRef)) { }
 
   bool HybridPerpDepthBarsProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
@@ -242,29 +65,4 @@ namespace margelo::nitro::perpdepthbar::views {
     }
   }
 
-  HybridPerpDepthBarsComponentDescriptor::HybridPerpDepthBarsComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
-    : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser()) {}
-
-  std::shared_ptr<const react::Props> HybridPerpDepthBarsComponentDescriptor::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 HybridPerpDepthBarsShadowNode::Props(context, /* & */ rawProps, props);
-  }
-
-#ifdef ANDROID
-  void HybridPerpDepthBarsComponentDescriptor::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<HybridPerpDepthBarsShadowNode&>(shadowNode);
-    const std::shared_ptr<const HybridPerpDepthBarsProps>& constProps = concreteShadowNode.getConcreteSharedProps();
-    const std::shared_ptr<HybridPerpDepthBarsProps>& props = std::const_pointer_cast<HybridPerpDepthBarsProps>(constProps);
-    HybridPerpDepthBarsState state{props};
-    concreteShadowNode.setStateData(std::move(state));
-  }
-#endif
-
 } // namespace margelo::nitro::perpdepthbar::views

package/lib/nitrogen/generated/shared/c++/views/HybridPerpDepthBarsComponent.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 <vector>
 #include <string>
@@ -43,25 +44,71 @@ namespace margelo::nitro::perpdepthbar::views {
                              const react::RawProps& rawProps);
 
   public:
-    CachedProp<std::vector<double>> percents;
-    CachedProp<double> rowHeight;
-    CachedProp<double> rowMarginTop;
-    CachedProp<double> barInset;
-    CachedProp<std::string> color;
-    CachedProp<std::string> origin;
-    CachedProp<bool> reducedMotion;
-    CachedProp<double> epoch;
-    CachedProp<std::vector<std::string>> prices;
-    CachedProp<std::vector<std::string>> sizes;
-    CachedProp<std::string> priceColor;
-    CachedProp<std::string> sizeColor;
-    CachedProp<double> priceFontSize;
-    CachedProp<double> sizeFontSize;
-    CachedProp<double> textInset;
-    CachedProp<std::string> placeholderText;
-    CachedProp<double> placeholderRows;
-    CachedProp<std::optional<std::function<void(double /* rowIndex */)>>> onRowPress;
-    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* ref */)>>> hybridRef;
+    nitro::ReactProp<std::vector<double>> percents;
+    nitro::ReactProp<double> rowHeight;
+    nitro::ReactProp<double> rowMarginTop;
+    nitro::ReactProp<double> barInset;
+    nitro::ReactProp<std::string> color;
+    nitro::ReactProp<std::string> origin;
+    nitro::ReactProp<bool> reducedMotion;
+    nitro::ReactProp<double> epoch;
+    nitro::ReactProp<std::vector<std::string>> prices;
+    nitro::ReactProp<std::vector<std::string>> sizes;
+    nitro::ReactProp<std::string> priceColor;
+    nitro::ReactProp<std::string> sizeColor;
+    nitro::ReactProp<double> priceFontSize;
+    nitro::ReactProp<double> sizeFontSize;
+    nitro::ReactProp<double> textInset;
+    nitro::ReactProp<std::string> placeholderText;
+    nitro::ReactProp<double> placeholderRows;
+    nitro::ReactProp<std::optional<std::function<void(double /* rowIndex */)>>> onRowPress;
+    nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* ref */)>>> hybridRef;
+
+    [[nodiscard]]
+    bool hasSameProps(const HybridPerpDepthBarsProps& other) const noexcept {
+      return percents.hasSameValue(other.percents) &&
+             rowHeight.hasSameValue(other.rowHeight) &&
+             rowMarginTop.hasSameValue(other.rowMarginTop) &&
+             barInset.hasSameValue(other.barInset) &&
+             color.hasSameValue(other.color) &&
+             origin.hasSameValue(other.origin) &&
+             reducedMotion.hasSameValue(other.reducedMotion) &&
+             epoch.hasSameValue(other.epoch) &&
+             prices.hasSameValue(other.prices) &&
+             sizes.hasSameValue(other.sizes) &&
+             priceColor.hasSameValue(other.priceColor) &&
+             sizeColor.hasSameValue(other.sizeColor) &&
+             priceFontSize.hasSameValue(other.priceFontSize) &&
+             sizeFontSize.hasSameValue(other.sizeFontSize) &&
+             textInset.hasSameValue(other.textInset) &&
+             placeholderText.hasSameValue(other.placeholderText) &&
+             placeholderRows.hasSameValue(other.placeholderRows) &&
+             onRowPress.hasSameValue(other.onRowPress) &&
+             hybridRef.hasSameValue(other.hybridRef);
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return percents.isProvided() ||
+             rowHeight.isProvided() ||
+             rowMarginTop.isProvided() ||
+             barInset.isProvided() ||
+             color.isProvided() ||
+             origin.isProvided() ||
+             reducedMotion.isProvided() ||
+             epoch.isProvided() ||
+             prices.isProvided() ||
+             sizes.isProvided() ||
+             priceColor.isProvided() ||
+             sizeColor.isProvided() ||
+             priceFontSize.isProvided() ||
+             sizeFontSize.isProvided() ||
+             textInset.isProvided() ||
+             placeholderText.isProvided() ||
+             placeholderRows.isProvided() ||
+             onRowPress.isProvided() ||
+             hybridRef.isProvided();
+    }
 
   private:
     static bool filterObjectKeys(const std::string& propName);
@@ -70,32 +117,7 @@ namespace margelo::nitro::perpdepthbar::views {
   /**
    * State for the "PerpDepthBars" View.
    */
-  class HybridPerpDepthBarsState final {
-  public:
-    HybridPerpDepthBarsState() = default;
-    explicit HybridPerpDepthBarsState(const std::shared_ptr<HybridPerpDepthBarsProps>& props):
-      _props(props) {}
-
-  public:
-    [[nodiscard]]
-    const std::shared_ptr<HybridPerpDepthBarsProps>& getProps() const {
-      return _props;
-    }
-
-  public:
-#ifdef ANDROID
-  HybridPerpDepthBarsState(const HybridPerpDepthBarsState& /* previousState */, folly::dynamic /* data */) {}
-  folly::dynamic getDynamic() const {
-    throw std::runtime_error("HybridPerpDepthBarsState does not support folly!");
-  }
-  react::MapBuffer getMapBuffer() const {
-    throw std::runtime_error("HybridPerpDepthBarsState does not support MapBuffer!");
-  };
-#endif
-
-  private:
-    std::shared_ptr<HybridPerpDepthBarsProps> _props;
-  };
+  using HybridPerpDepthBarsState = nitro::ViewPropsHolderState<HybridPerpDepthBarsProps>;
 
   /**
    * The Shadow Node for the "PerpDepthBars" View.
@@ -108,21 +130,7 @@ namespace margelo::nitro::perpdepthbar::views {
   /**
    * The Component Descriptor for the "PerpDepthBars" View.
    */
-  class HybridPerpDepthBarsComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridPerpDepthBarsShadowNode> {
-  public:
-    explicit HybridPerpDepthBarsComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
-
-  public:
-    /**
-     * A faster path for cloning props - reuses the caching logic from `HybridPerpDepthBarsProps`.
-     */
-    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 HybridPerpDepthBarsComponentDescriptor = nitro::ViewComponentDescriptor<HybridPerpDepthBarsShadowNode>;
 
   /* The actual view for "PerpDepthBars" needs to be implemented in platform-specific code. */
 

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

@@ -7,115 +7,28 @@
 
 #include "HybridPerpSideRatioComponent.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::perpdepthbar::views {
 
+  using namespace facebook;
+
   extern const char HybridPerpSideRatioComponentName[] = "PerpSideRatio";
 
   HybridPerpSideRatioProps::HybridPerpSideRatioProps(const react::PropsParserContext& context,
                                                      const HybridPerpSideRatioProps& sourceProps,
                                                      const react::RawProps& rawProps):
     react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
-    bidPercentage([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("bidPercentage", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.bidPercentage;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.bidPercentage);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpSideRatio.bidPercentage: ") + exc.what());
-      }
-    }()),
-    askPercentage([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("askPercentage", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.askPercentage;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.askPercentage);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpSideRatio.askPercentage: ") + exc.what());
-      }
-    }()),
-    longColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("longColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.longColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.longColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpSideRatio.longColor: ") + exc.what());
-      }
-    }()),
-    shortColor([&]() -> CachedProp<std::string> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("shortColor", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.shortColor;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<std::string>::fromRawValue(*runtime, value, sourceProps.shortColor);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpSideRatio.shortColor: ") + exc.what());
-      }
-    }()),
-    segmentHeight([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("segmentHeight", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.segmentHeight;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.segmentHeight);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpSideRatio.segmentHeight: ") + exc.what());
-      }
-    }()),
-    cornerRadius([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("cornerRadius", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.cornerRadius;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.cornerRadius);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpSideRatio.cornerRadius: ") + exc.what());
-      }
-    }()),
-    gap([&]() -> CachedProp<double> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("gap", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.gap;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.gap);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpSideRatio.gap: ") + exc.what());
-      }
-    }()),
-    reducedMotion([&]() -> CachedProp<bool> {
-      try {
-        const react::RawValue* rawValue = rawProps.at("reducedMotion", nullptr, nullptr);
-        if (rawValue == nullptr) return sourceProps.reducedMotion;
-        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
-        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.reducedMotion);
-      } catch (const std::exception& exc) {
-        throw std::runtime_error(std::string("PerpSideRatio.reducedMotion: ") + exc.what());
-      }
-    }()),
-    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpSideRatioSpec>& /* 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<HybridPerpSideRatioSpec>& /* 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("PerpSideRatio.hybridRef: ") + exc.what());
-      }
-    }()) { }
+    bidPercentage(nitro::ReactProp<double>::fromRawValue("PerpSideRatio", "bidPercentage", rawProps, sourceProps.bidPercentage)),
+    askPercentage(nitro::ReactProp<double>::fromRawValue("PerpSideRatio", "askPercentage", rawProps, sourceProps.askPercentage)),
+    longColor(nitro::ReactProp<std::string>::fromRawValue("PerpSideRatio", "longColor", rawProps, sourceProps.longColor)),
+    shortColor(nitro::ReactProp<std::string>::fromRawValue("PerpSideRatio", "shortColor", rawProps, sourceProps.shortColor)),
+    segmentHeight(nitro::ReactProp<double>::fromRawValue("PerpSideRatio", "segmentHeight", rawProps, sourceProps.segmentHeight)),
+    cornerRadius(nitro::ReactProp<double>::fromRawValue("PerpSideRatio", "cornerRadius", rawProps, sourceProps.cornerRadius)),
+    gap(nitro::ReactProp<double>::fromRawValue("PerpSideRatio", "gap", rawProps, sourceProps.gap)),
+    reducedMotion(nitro::ReactProp<bool>::fromRawValue("PerpSideRatio", "reducedMotion", rawProps, sourceProps.reducedMotion)),
+    hybridRef(nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpSideRatioSpec>& /* ref */)>>>::fromRawValue("PerpSideRatio", "hybridRef", rawProps, sourceProps.hybridRef)) { }
 
   bool HybridPerpSideRatioProps::filterObjectKeys(const std::string& propName) {
     switch (hashString(propName)) {
@@ -132,29 +45,4 @@ namespace margelo::nitro::perpdepthbar::views {
     }
   }
 
-  HybridPerpSideRatioComponentDescriptor::HybridPerpSideRatioComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
-    : ConcreteComponentDescriptor(parameters,
-                                  react::RawPropsParser()) {}
-
-  std::shared_ptr<const react::Props> HybridPerpSideRatioComponentDescriptor::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 HybridPerpSideRatioShadowNode::Props(context, /* & */ rawProps, props);
-  }
-
-#ifdef ANDROID
-  void HybridPerpSideRatioComponentDescriptor::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<HybridPerpSideRatioShadowNode&>(shadowNode);
-    const std::shared_ptr<const HybridPerpSideRatioProps>& constProps = concreteShadowNode.getConcreteSharedProps();
-    const std::shared_ptr<HybridPerpSideRatioProps>& props = std::const_pointer_cast<HybridPerpSideRatioProps>(constProps);
-    HybridPerpSideRatioState state{props};
-    concreteShadowNode.setStateData(std::move(state));
-  }
-#endif
-
 } // namespace margelo::nitro::perpdepthbar::views