@onekeyfe/react-native-perp-depth-bar 3.0.39

package/lib/nitrogen/generated/shared/c++/HybridPerpSideRatioSpec.hpp

@@ -0,0 +1,77 @@
+///
+/// HybridPerpSideRatioSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::perpdepthbar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `PerpSideRatio`
+   * Inherit this class to create instances of `HybridPerpSideRatioSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPerpSideRatio: public HybridPerpSideRatioSpec {
+   * public:
+   *   HybridPerpSideRatio(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPerpSideRatioSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPerpSideRatioSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPerpSideRatioSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getBidPercentage() = 0;
+      virtual void setBidPercentage(double bidPercentage) = 0;
+      virtual double getAskPercentage() = 0;
+      virtual void setAskPercentage(double askPercentage) = 0;
+      virtual std::string getLongColor() = 0;
+      virtual void setLongColor(const std::string& longColor) = 0;
+      virtual std::string getShortColor() = 0;
+      virtual void setShortColor(const std::string& shortColor) = 0;
+      virtual double getSegmentHeight() = 0;
+      virtual void setSegmentHeight(double segmentHeight) = 0;
+      virtual double getCornerRadius() = 0;
+      virtual void setCornerRadius(double cornerRadius) = 0;
+      virtual double getGap() = 0;
+      virtual void setGap(double gap) = 0;
+      virtual bool getReducedMotion() = 0;
+      virtual void setReducedMotion(bool reducedMotion) = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "PerpSideRatio";
+  };
+
+} // namespace margelo::nitro::perpdepthbar

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

@@ -0,0 +1,171 @@
+///
+/// HybridPerpDepthBarsComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridPerpDepthBarsComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.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>
+
+namespace margelo::nitro::perpdepthbar::views {
+
+  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());
+      }
+    }()),
+    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, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpDepthBars.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridPerpDepthBarsProps::HybridPerpDepthBarsProps(const HybridPerpDepthBarsProps& other):
+    react::ViewProps(),
+    percents(other.percents),
+    rowHeight(other.rowHeight),
+    rowMarginTop(other.rowMarginTop),
+    barInset(other.barInset),
+    color(other.color),
+    origin(other.origin),
+    reducedMotion(other.reducedMotion),
+    epoch(other.epoch),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridPerpDepthBarsProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("percents"): return true;
+      case hashString("rowHeight"): return true;
+      case hashString("rowMarginTop"): return true;
+      case hashString("barInset"): return true;
+      case hashString("color"): return true;
+      case hashString("origin"): return true;
+      case hashString("reducedMotion"): return true;
+      case hashString("epoch"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridPerpDepthBarsComponentDescriptor::HybridPerpDepthBarsComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  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 = dynamic_cast<HybridPerpDepthBarsShadowNode&>(shadowNode);
+    const HybridPerpDepthBarsProps& props = concreteShadowNode.getConcreteProps();
+    HybridPerpDepthBarsState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::perpdepthbar::views

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

@@ -0,0 +1,116 @@
+///
+/// HybridPerpDepthBarsComponent.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 <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 <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <vector>
+#include <string>
+#include <memory>
+#include "HybridPerpDepthBarsSpec.hpp"
+#include <functional>
+#include <optional>
+
+namespace margelo::nitro::perpdepthbar::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridPerpDepthBarsComponentName[];
+
+  /**
+   * Props for the "PerpDepthBars" View.
+   */
+  class HybridPerpDepthBarsProps final: public react::ViewProps {
+  public:
+    HybridPerpDepthBarsProps() = default;
+    HybridPerpDepthBarsProps(const HybridPerpDepthBarsProps&);
+    HybridPerpDepthBarsProps(const react::PropsParserContext& context,
+                             const HybridPerpDepthBarsProps& sourceProps,
+                             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::optional<std::function<void(const std::shared_ptr<HybridPerpDepthBarsSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "PerpDepthBars" View.
+   */
+  class HybridPerpDepthBarsState final {
+  public:
+    HybridPerpDepthBarsState() = default;
+
+  public:
+    void setProps(const HybridPerpDepthBarsProps& props) { _props.emplace(props); }
+    const std::optional<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::optional<HybridPerpDepthBarsProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "PerpDepthBars" View.
+   */
+  using HybridPerpDepthBarsShadowNode = react::ConcreteViewShadowNode<HybridPerpDepthBarsComponentName /* "HybridPerpDepthBars" */,
+                                                                      HybridPerpDepthBarsProps /* custom props */,
+                                                                      react::ViewEventEmitter /* default */,
+                                                                      HybridPerpDepthBarsState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "PerpDepthBars" View.
+   */
+  class HybridPerpDepthBarsComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridPerpDepthBarsShadowNode> {
+  public:
+    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
+  };
+
+  /* The actual view for "PerpDepthBars" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::perpdepthbar::views

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

@@ -0,0 +1,171 @@
+///
+/// HybridPerpSideRatioComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridPerpSideRatioComponent.hpp"
+
+#include <string>
+#include <exception>
+#include <utility>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JSIConverter.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>
+
+namespace margelo::nitro::perpdepthbar::views {
+
+  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, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("PerpSideRatio.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridPerpSideRatioProps::HybridPerpSideRatioProps(const HybridPerpSideRatioProps& other):
+    react::ViewProps(),
+    bidPercentage(other.bidPercentage),
+    askPercentage(other.askPercentage),
+    longColor(other.longColor),
+    shortColor(other.shortColor),
+    segmentHeight(other.segmentHeight),
+    cornerRadius(other.cornerRadius),
+    gap(other.gap),
+    reducedMotion(other.reducedMotion),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridPerpSideRatioProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("bidPercentage"): return true;
+      case hashString("askPercentage"): return true;
+      case hashString("longColor"): return true;
+      case hashString("shortColor"): return true;
+      case hashString("segmentHeight"): return true;
+      case hashString("cornerRadius"): return true;
+      case hashString("gap"): return true;
+      case hashString("reducedMotion"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridPerpSideRatioComponentDescriptor::HybridPerpSideRatioComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  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 = dynamic_cast<HybridPerpSideRatioShadowNode&>(shadowNode);
+    const HybridPerpSideRatioProps& props = concreteShadowNode.getConcreteProps();
+    HybridPerpSideRatioState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::perpdepthbar::views

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

@@ -0,0 +1,115 @@
+///
+/// HybridPerpSideRatioComponent.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 <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 <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+
+#include <string>
+#include <memory>
+#include "HybridPerpSideRatioSpec.hpp"
+#include <functional>
+#include <optional>
+
+namespace margelo::nitro::perpdepthbar::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridPerpSideRatioComponentName[];
+
+  /**
+   * Props for the "PerpSideRatio" View.
+   */
+  class HybridPerpSideRatioProps final: public react::ViewProps {
+  public:
+    HybridPerpSideRatioProps() = default;
+    HybridPerpSideRatioProps(const HybridPerpSideRatioProps&);
+    HybridPerpSideRatioProps(const react::PropsParserContext& context,
+                             const HybridPerpSideRatioProps& sourceProps,
+                             const react::RawProps& rawProps);
+
+  public:
+    CachedProp<double> bidPercentage;
+    CachedProp<double> askPercentage;
+    CachedProp<std::string> longColor;
+    CachedProp<std::string> shortColor;
+    CachedProp<double> segmentHeight;
+    CachedProp<double> cornerRadius;
+    CachedProp<double> gap;
+    CachedProp<bool> reducedMotion;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridPerpSideRatioSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "PerpSideRatio" View.
+   */
+  class HybridPerpSideRatioState final {
+  public:
+    HybridPerpSideRatioState() = default;
+
+  public:
+    void setProps(const HybridPerpSideRatioProps& props) { _props.emplace(props); }
+    const std::optional<HybridPerpSideRatioProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridPerpSideRatioState(const HybridPerpSideRatioState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridPerpSideRatioState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridPerpSideRatioState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridPerpSideRatioProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "PerpSideRatio" View.
+   */
+  using HybridPerpSideRatioShadowNode = react::ConcreteViewShadowNode<HybridPerpSideRatioComponentName /* "HybridPerpSideRatio" */,
+                                                                      HybridPerpSideRatioProps /* custom props */,
+                                                                      react::ViewEventEmitter /* default */,
+                                                                      HybridPerpSideRatioState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "PerpSideRatio" View.
+   */
+  class HybridPerpSideRatioComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridPerpSideRatioShadowNode> {
+  public:
+    HybridPerpSideRatioComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridPerpSideRatioProps`.
+     */
+    std::shared_ptr<const react::Props> cloneProps(const react::PropsParserContext& context,
+                                                   const std::shared_ptr<const react::Props>& props,
+                                                   react::RawProps rawProps) const override;
+#ifdef ANDROID
+    void adopt(react::ShadowNode& shadowNode) const override;
+#endif
+  };
+
+  /* The actual view for "PerpSideRatio" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::perpdepthbar::views

package/lib/nitrogen/generated/shared/json/PerpDepthBarsConfig.json

@@ -0,0 +1,17 @@
+{
+  "uiViewClassName": "PerpDepthBars",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "percents": true,
+    "rowHeight": true,
+    "rowMarginTop": true,
+    "barInset": true,
+    "color": true,
+    "origin": true,
+    "reducedMotion": true,
+    "epoch": true,
+    "hybridRef": true
+  }
+}