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

package/lib/nitrogen/nitrogen/generated/ios/swift/HybridPerpSideRatioSpec_cxx.swift

@@ -0,0 +1,217 @@
+///
+/// HybridPerpSideRatioSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridPerpSideRatioSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridPerpSideRatioSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::perpdepthbar::bridge::swift`)
+   * from `PerpDepthBar-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.perpdepthbar.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridPerpSideRatioSpec` Swift protocol.
+   */
+  private var __implementation: any HybridPerpSideRatioSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridPerpSideRatioSpec_
+
+  /**
+   * Create a new `HybridPerpSideRatioSpec_cxx` that wraps the given `HybridPerpSideRatioSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridPerpSideRatioSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridPerpSideRatioSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridPerpSideRatioSpec() -> any HybridPerpSideRatioSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridPerpSideRatioSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridPerpSideRatioSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridPerpSideRatioSpec_cxx {
+    return Unmanaged<HybridPerpSideRatioSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridPerpSideRatioSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridPerpSideRatioSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridPerpSideRatioSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridPerpSideRatioSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  public final var bidPercentage: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.bidPercentage
+    }
+    @inline(__always)
+    set {
+      self.__implementation.bidPercentage = newValue
+    }
+  }
+  
+  public final var askPercentage: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.askPercentage
+    }
+    @inline(__always)
+    set {
+      self.__implementation.askPercentage = newValue
+    }
+  }
+  
+  public final var longColor: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.longColor)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.longColor = String(newValue)
+    }
+  }
+  
+  public final var shortColor: std.string {
+    @inline(__always)
+    get {
+      return std.string(self.__implementation.shortColor)
+    }
+    @inline(__always)
+    set {
+      self.__implementation.shortColor = String(newValue)
+    }
+  }
+  
+  public final var segmentHeight: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.segmentHeight
+    }
+    @inline(__always)
+    set {
+      self.__implementation.segmentHeight = newValue
+    }
+  }
+  
+  public final var cornerRadius: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.cornerRadius
+    }
+    @inline(__always)
+    set {
+      self.__implementation.cornerRadius = newValue
+    }
+  }
+  
+  public final var gap: Double {
+    @inline(__always)
+    get {
+      return self.__implementation.gap
+    }
+    @inline(__always)
+    set {
+      self.__implementation.gap = newValue
+    }
+  }
+  
+  public final var reducedMotion: Bool {
+    @inline(__always)
+    get {
+      return self.__implementation.reducedMotion
+    }
+    @inline(__always)
+    set {
+      self.__implementation.reducedMotion = newValue
+    }
+  }
+
+  // Methods
+  public final func getView() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(__implementation.view).toOpaque()
+  }
+  
+  public final func beforeUpdate() {
+    __implementation.beforeUpdate()
+  }
+  
+  public final func afterUpdate() {
+    __implementation.afterUpdate()
+  }
+}

package/lib/nitrogen/nitrogen/generated/shared/c++/HybridPerpDepthBarsSpec.cpp

@@ -0,0 +1,36 @@
+///
+/// HybridPerpDepthBarsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridPerpDepthBarsSpec.hpp"
+
+namespace margelo::nitro::perpdepthbar {
+
+  void HybridPerpDepthBarsSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("percents", &HybridPerpDepthBarsSpec::getPercents);
+      prototype.registerHybridSetter("percents", &HybridPerpDepthBarsSpec::setPercents);
+      prototype.registerHybridGetter("rowHeight", &HybridPerpDepthBarsSpec::getRowHeight);
+      prototype.registerHybridSetter("rowHeight", &HybridPerpDepthBarsSpec::setRowHeight);
+      prototype.registerHybridGetter("rowMarginTop", &HybridPerpDepthBarsSpec::getRowMarginTop);
+      prototype.registerHybridSetter("rowMarginTop", &HybridPerpDepthBarsSpec::setRowMarginTop);
+      prototype.registerHybridGetter("barInset", &HybridPerpDepthBarsSpec::getBarInset);
+      prototype.registerHybridSetter("barInset", &HybridPerpDepthBarsSpec::setBarInset);
+      prototype.registerHybridGetter("color", &HybridPerpDepthBarsSpec::getColor);
+      prototype.registerHybridSetter("color", &HybridPerpDepthBarsSpec::setColor);
+      prototype.registerHybridGetter("origin", &HybridPerpDepthBarsSpec::getOrigin);
+      prototype.registerHybridSetter("origin", &HybridPerpDepthBarsSpec::setOrigin);
+      prototype.registerHybridGetter("reducedMotion", &HybridPerpDepthBarsSpec::getReducedMotion);
+      prototype.registerHybridSetter("reducedMotion", &HybridPerpDepthBarsSpec::setReducedMotion);
+      prototype.registerHybridGetter("epoch", &HybridPerpDepthBarsSpec::getEpoch);
+      prototype.registerHybridSetter("epoch", &HybridPerpDepthBarsSpec::setEpoch);
+    });
+  }
+
+} // namespace margelo::nitro::perpdepthbar

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

@@ -0,0 +1,78 @@
+///
+/// HybridPerpDepthBarsSpec.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 <vector>
+#include <string>
+
+namespace margelo::nitro::perpdepthbar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `PerpDepthBars`
+   * Inherit this class to create instances of `HybridPerpDepthBarsSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPerpDepthBars: public HybridPerpDepthBarsSpec {
+   * public:
+   *   HybridPerpDepthBars(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPerpDepthBarsSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPerpDepthBarsSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPerpDepthBarsSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::vector<double> getPercents() = 0;
+      virtual void setPercents(const std::vector<double>& percents) = 0;
+      virtual double getRowHeight() = 0;
+      virtual void setRowHeight(double rowHeight) = 0;
+      virtual double getRowMarginTop() = 0;
+      virtual void setRowMarginTop(double rowMarginTop) = 0;
+      virtual double getBarInset() = 0;
+      virtual void setBarInset(double barInset) = 0;
+      virtual std::string getColor() = 0;
+      virtual void setColor(const std::string& color) = 0;
+      virtual std::string getOrigin() = 0;
+      virtual void setOrigin(const std::string& origin) = 0;
+      virtual bool getReducedMotion() = 0;
+      virtual void setReducedMotion(bool reducedMotion) = 0;
+      virtual double getEpoch() = 0;
+      virtual void setEpoch(double epoch) = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "PerpDepthBars";
+  };
+
+} // namespace margelo::nitro::perpdepthbar

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

@@ -0,0 +1,36 @@
+///
+/// HybridPerpSideRatioSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridPerpSideRatioSpec.hpp"
+
+namespace margelo::nitro::perpdepthbar {
+
+  void HybridPerpSideRatioSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("bidPercentage", &HybridPerpSideRatioSpec::getBidPercentage);
+      prototype.registerHybridSetter("bidPercentage", &HybridPerpSideRatioSpec::setBidPercentage);
+      prototype.registerHybridGetter("askPercentage", &HybridPerpSideRatioSpec::getAskPercentage);
+      prototype.registerHybridSetter("askPercentage", &HybridPerpSideRatioSpec::setAskPercentage);
+      prototype.registerHybridGetter("longColor", &HybridPerpSideRatioSpec::getLongColor);
+      prototype.registerHybridSetter("longColor", &HybridPerpSideRatioSpec::setLongColor);
+      prototype.registerHybridGetter("shortColor", &HybridPerpSideRatioSpec::getShortColor);
+      prototype.registerHybridSetter("shortColor", &HybridPerpSideRatioSpec::setShortColor);
+      prototype.registerHybridGetter("segmentHeight", &HybridPerpSideRatioSpec::getSegmentHeight);
+      prototype.registerHybridSetter("segmentHeight", &HybridPerpSideRatioSpec::setSegmentHeight);
+      prototype.registerHybridGetter("cornerRadius", &HybridPerpSideRatioSpec::getCornerRadius);
+      prototype.registerHybridSetter("cornerRadius", &HybridPerpSideRatioSpec::setCornerRadius);
+      prototype.registerHybridGetter("gap", &HybridPerpSideRatioSpec::getGap);
+      prototype.registerHybridSetter("gap", &HybridPerpSideRatioSpec::setGap);
+      prototype.registerHybridGetter("reducedMotion", &HybridPerpSideRatioSpec::getReducedMotion);
+      prototype.registerHybridSetter("reducedMotion", &HybridPerpSideRatioSpec::setReducedMotion);
+    });
+  }
+
+} // namespace margelo::nitro::perpdepthbar

package/lib/nitrogen/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/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