aix 0.0.15 → 0.1.0

package/nitrogen/generated/shared/c++/HybridAixCellViewSpec.cpp

@@ -0,0 +1,24 @@
+///
+/// HybridAixCellViewSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixCellViewSpec.hpp"
+
+namespace margelo::nitro::aix {
+
+  void HybridAixCellViewSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("isLast", &HybridAixCellViewSpec::getIsLast);
+      prototype.registerHybridSetter("isLast", &HybridAixCellViewSpec::setIsLast);
+      prototype.registerHybridGetter("index", &HybridAixCellViewSpec::getIndex);
+      prototype.registerHybridSetter("index", &HybridAixCellViewSpec::setIndex);
+    });
+  }
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/shared/c++/HybridAixCellViewSpec.hpp

@@ -0,0 +1,65 @@
+///
+/// HybridAixCellViewSpec.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
+
+
+
+
+
+namespace margelo::nitro::aix {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AixCellView`
+   * Inherit this class to create instances of `HybridAixCellViewSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAixCellView: public HybridAixCellViewSpec {
+   * public:
+   *   HybridAixCellView(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAixCellViewSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAixCellViewSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAixCellViewSpec() override = default;
+
+    public:
+      // Properties
+      virtual bool getIsLast() = 0;
+      virtual void setIsLast(bool isLast) = 0;
+      virtual double getIndex() = 0;
+      virtual void setIndex(double index) = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AixCellView";
+  };
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/shared/c++/HybridAixComposerSpec.cpp

@@ -0,0 +1,21 @@
+///
+/// HybridAixComposerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixComposerSpec.hpp"
+
+namespace margelo::nitro::aix {
+
+  void HybridAixComposerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      
+    });
+  }
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/shared/c++/HybridAixComposerSpec.hpp

@@ -0,0 +1,62 @@
+///
+/// HybridAixComposerSpec.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
+
+
+
+
+
+namespace margelo::nitro::aix {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AixComposer`
+   * Inherit this class to create instances of `HybridAixComposerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAixComposer: public HybridAixComposerSpec {
+   * public:
+   *   HybridAixComposer(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAixComposerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAixComposerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAixComposerSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AixComposer";
+  };
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/shared/c++/HybridAixSpec.cpp

@@ -0,0 +1,36 @@
+///
+/// HybridAixSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixSpec.hpp"
+
+namespace margelo::nitro::aix {
+
+  void HybridAixSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("shouldStartAtEnd", &HybridAixSpec::getShouldStartAtEnd);
+      prototype.registerHybridSetter("shouldStartAtEnd", &HybridAixSpec::setShouldStartAtEnd);
+      prototype.registerHybridGetter("scrollOnFooterSizeUpdate", &HybridAixSpec::getScrollOnFooterSizeUpdate);
+      prototype.registerHybridSetter("scrollOnFooterSizeUpdate", &HybridAixSpec::setScrollOnFooterSizeUpdate);
+      prototype.registerHybridGetter("scrollEndReachedThreshold", &HybridAixSpec::getScrollEndReachedThreshold);
+      prototype.registerHybridSetter("scrollEndReachedThreshold", &HybridAixSpec::setScrollEndReachedThreshold);
+      prototype.registerHybridGetter("additionalContentInsets", &HybridAixSpec::getAdditionalContentInsets);
+      prototype.registerHybridSetter("additionalContentInsets", &HybridAixSpec::setAdditionalContentInsets);
+      prototype.registerHybridGetter("additionalScrollIndicatorInsets", &HybridAixSpec::getAdditionalScrollIndicatorInsets);
+      prototype.registerHybridSetter("additionalScrollIndicatorInsets", &HybridAixSpec::setAdditionalScrollIndicatorInsets);
+      prototype.registerHybridGetter("mainScrollViewID", &HybridAixSpec::getMainScrollViewID);
+      prototype.registerHybridSetter("mainScrollViewID", &HybridAixSpec::setMainScrollViewID);
+      prototype.registerHybridGetter("penultimateCellIndex", &HybridAixSpec::getPenultimateCellIndex);
+      prototype.registerHybridSetter("penultimateCellIndex", &HybridAixSpec::setPenultimateCellIndex);
+      prototype.registerHybridMethod("scrollToEnd", &HybridAixSpec::scrollToEnd);
+      prototype.registerHybridMethod("scrollToIndexWhenBlankSizeReady", &HybridAixSpec::scrollToIndexWhenBlankSizeReady);
+    });
+  }
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/shared/c++/HybridAixSpec.hpp

@@ -0,0 +1,85 @@
+///
+/// HybridAixSpec.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
+
+// Forward declaration of `AixScrollOnFooterSizeUpdate` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixScrollOnFooterSizeUpdate; }
+// Forward declaration of `AixAdditionalContentInsetsProp` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixAdditionalContentInsetsProp; }
+// Forward declaration of `AixScrollIndicatorInsets` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixScrollIndicatorInsets; }
+
+#include "AixScrollOnFooterSizeUpdate.hpp"
+#include <optional>
+#include "AixAdditionalContentInsetsProp.hpp"
+#include "AixScrollIndicatorInsets.hpp"
+#include <string>
+
+namespace margelo::nitro::aix {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Aix`
+   * Inherit this class to create instances of `HybridAixSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAix: public HybridAixSpec {
+   * public:
+   *   HybridAix(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAixSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAixSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAixSpec() override = default;
+
+    public:
+      // Properties
+      virtual bool getShouldStartAtEnd() = 0;
+      virtual void setShouldStartAtEnd(bool shouldStartAtEnd) = 0;
+      virtual std::optional<AixScrollOnFooterSizeUpdate> getScrollOnFooterSizeUpdate() = 0;
+      virtual void setScrollOnFooterSizeUpdate(const std::optional<AixScrollOnFooterSizeUpdate>& scrollOnFooterSizeUpdate) = 0;
+      virtual std::optional<double> getScrollEndReachedThreshold() = 0;
+      virtual void setScrollEndReachedThreshold(std::optional<double> scrollEndReachedThreshold) = 0;
+      virtual std::optional<AixAdditionalContentInsetsProp> getAdditionalContentInsets() = 0;
+      virtual void setAdditionalContentInsets(const std::optional<AixAdditionalContentInsetsProp>& additionalContentInsets) = 0;
+      virtual std::optional<AixScrollIndicatorInsets> getAdditionalScrollIndicatorInsets() = 0;
+      virtual void setAdditionalScrollIndicatorInsets(const std::optional<AixScrollIndicatorInsets>& additionalScrollIndicatorInsets) = 0;
+      virtual std::optional<std::string> getMainScrollViewID() = 0;
+      virtual void setMainScrollViewID(const std::optional<std::string>& mainScrollViewID) = 0;
+      virtual std::optional<double> getPenultimateCellIndex() = 0;
+      virtual void setPenultimateCellIndex(std::optional<double> penultimateCellIndex) = 0;
+
+    public:
+      // Methods
+      virtual void scrollToEnd(std::optional<bool> animated) = 0;
+      virtual void scrollToIndexWhenBlankSizeReady(double index, std::optional<bool> animated, std::optional<bool> waitForKeyboardToEnd) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Aix";
+  };
+
+} // namespace margelo::nitro::aix

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

@@ -0,0 +1,99 @@
+///
+/// HybridAixCellViewComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixCellViewComponent.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::aix::views {
+
+  extern const char HybridAixCellViewComponentName[] = "AixCellView";
+
+  HybridAixCellViewProps::HybridAixCellViewProps(const react::PropsParserContext& context,
+                                                 const HybridAixCellViewProps& sourceProps,
+                                                 const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    isLast([&]() -> CachedProp<bool> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("isLast", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.isLast;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.isLast);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixCellView.isLast: ") + exc.what());
+      }
+    }()),
+    index([&]() -> CachedProp<double> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("index", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.index;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<double>::fromRawValue(*runtime, value, sourceProps.index);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixCellView.index: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixCellViewSpec>& /* 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<HybridAixCellViewSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("AixCellView.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridAixCellViewProps::HybridAixCellViewProps(const HybridAixCellViewProps& other):
+    react::ViewProps(),
+    isLast(other.isLast),
+    index(other.index),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridAixCellViewProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("isLast"): return true;
+      case hashString("index"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridAixCellViewComponentDescriptor::HybridAixCellViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridAixCellViewComponentDescriptor::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 HybridAixCellViewShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridAixCellViewComponentDescriptor::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<HybridAixCellViewShadowNode&>(shadowNode);
+    const HybridAixCellViewProps& props = concreteShadowNode.getConcreteProps();
+    HybridAixCellViewState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::aix::views

package/nitrogen/generated/shared/c++/views/HybridAixCellViewComponent.hpp

@@ -0,0 +1,108 @@
+///
+/// HybridAixCellViewComponent.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 <memory>
+#include "HybridAixCellViewSpec.hpp"
+#include <functional>
+#include <optional>
+
+namespace margelo::nitro::aix::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridAixCellViewComponentName[];
+
+  /**
+   * Props for the "AixCellView" View.
+   */
+  class HybridAixCellViewProps final: public react::ViewProps {
+  public:
+    HybridAixCellViewProps() = default;
+    HybridAixCellViewProps(const HybridAixCellViewProps&);
+    HybridAixCellViewProps(const react::PropsParserContext& context,
+                           const HybridAixCellViewProps& sourceProps,
+                           const react::RawProps& rawProps);
+
+  public:
+    CachedProp<bool> isLast;
+    CachedProp<double> index;
+    CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixCellViewSpec>& /* ref */)>>> hybridRef;
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "AixCellView" View.
+   */
+  class HybridAixCellViewState final {
+  public:
+    HybridAixCellViewState() = default;
+
+  public:
+    void setProps(const HybridAixCellViewProps& props) { _props.emplace(props); }
+    const std::optional<HybridAixCellViewProps>& getProps() const { return _props; }
+
+  public:
+#ifdef ANDROID
+  HybridAixCellViewState(const HybridAixCellViewState& /* previousState */, folly::dynamic /* data */) {}
+  folly::dynamic getDynamic() const {
+    throw std::runtime_error("HybridAixCellViewState does not support folly!");
+  }
+  react::MapBuffer getMapBuffer() const {
+    throw std::runtime_error("HybridAixCellViewState does not support MapBuffer!");
+  };
+#endif
+
+  private:
+    std::optional<HybridAixCellViewProps> _props;
+  };
+
+  /**
+   * The Shadow Node for the "AixCellView" View.
+   */
+  using HybridAixCellViewShadowNode = react::ConcreteViewShadowNode<HybridAixCellViewComponentName /* "HybridAixCellView" */,
+                                                                    HybridAixCellViewProps /* custom props */,
+                                                                    react::ViewEventEmitter /* default */,
+                                                                    HybridAixCellViewState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "AixCellView" View.
+   */
+  class HybridAixCellViewComponentDescriptor final: public react::ConcreteComponentDescriptor<HybridAixCellViewShadowNode> {
+  public:
+    HybridAixCellViewComponentDescriptor(const react::ComponentDescriptorParameters& parameters);
+
+  public:
+    /**
+     * A faster path for cloning props - reuses the caching logic from `HybridAixCellViewProps`.
+     */
+    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 "AixCellView" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::aix::views

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

@@ -0,0 +1,159 @@
+///
+/// HybridAixComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridAixComponent.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::aix::views {
+
+  extern const char HybridAixComponentName[] = "Aix";
+
+  HybridAixProps::HybridAixProps(const react::PropsParserContext& context,
+                                 const HybridAixProps& sourceProps,
+                                 const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    shouldStartAtEnd([&]() -> CachedProp<bool> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("shouldStartAtEnd", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.shouldStartAtEnd;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<bool>::fromRawValue(*runtime, value, sourceProps.shouldStartAtEnd);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.shouldStartAtEnd: ") + exc.what());
+      }
+    }()),
+    scrollOnFooterSizeUpdate([&]() -> CachedProp<std::optional<AixScrollOnFooterSizeUpdate>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("scrollOnFooterSizeUpdate", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.scrollOnFooterSizeUpdate;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<AixScrollOnFooterSizeUpdate>>::fromRawValue(*runtime, value, sourceProps.scrollOnFooterSizeUpdate);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.scrollOnFooterSizeUpdate: ") + exc.what());
+      }
+    }()),
+    scrollEndReachedThreshold([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("scrollEndReachedThreshold", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.scrollEndReachedThreshold;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.scrollEndReachedThreshold);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.scrollEndReachedThreshold: ") + exc.what());
+      }
+    }()),
+    additionalContentInsets([&]() -> CachedProp<std::optional<AixAdditionalContentInsetsProp>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("additionalContentInsets", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.additionalContentInsets;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<AixAdditionalContentInsetsProp>>::fromRawValue(*runtime, value, sourceProps.additionalContentInsets);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.additionalContentInsets: ") + exc.what());
+      }
+    }()),
+    additionalScrollIndicatorInsets([&]() -> CachedProp<std::optional<AixScrollIndicatorInsets>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("additionalScrollIndicatorInsets", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.additionalScrollIndicatorInsets;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<AixScrollIndicatorInsets>>::fromRawValue(*runtime, value, sourceProps.additionalScrollIndicatorInsets);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.additionalScrollIndicatorInsets: ") + exc.what());
+      }
+    }()),
+    mainScrollViewID([&]() -> CachedProp<std::optional<std::string>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("mainScrollViewID", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.mainScrollViewID;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<std::string>>::fromRawValue(*runtime, value, sourceProps.mainScrollViewID);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.mainScrollViewID: ") + exc.what());
+      }
+    }()),
+    penultimateCellIndex([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("penultimateCellIndex", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.penultimateCellIndex;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.penultimateCellIndex);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.penultimateCellIndex: ") + exc.what());
+      }
+    }()),
+    hybridRef([&]() -> CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridAixSpec>& /* 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<HybridAixSpec>& /* ref */)>>>::fromRawValue(*runtime, value.asObject(*runtime).getProperty(*runtime, "f"), sourceProps.hybridRef);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("Aix.hybridRef: ") + exc.what());
+      }
+    }()) { }
+
+  HybridAixProps::HybridAixProps(const HybridAixProps& other):
+    react::ViewProps(),
+    shouldStartAtEnd(other.shouldStartAtEnd),
+    scrollOnFooterSizeUpdate(other.scrollOnFooterSizeUpdate),
+    scrollEndReachedThreshold(other.scrollEndReachedThreshold),
+    additionalContentInsets(other.additionalContentInsets),
+    additionalScrollIndicatorInsets(other.additionalScrollIndicatorInsets),
+    mainScrollViewID(other.mainScrollViewID),
+    penultimateCellIndex(other.penultimateCellIndex),
+    hybridRef(other.hybridRef) { }
+
+  bool HybridAixProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("shouldStartAtEnd"): return true;
+      case hashString("scrollOnFooterSizeUpdate"): return true;
+      case hashString("scrollEndReachedThreshold"): return true;
+      case hashString("additionalContentInsets"): return true;
+      case hashString("additionalScrollIndicatorInsets"): return true;
+      case hashString("mainScrollViewID"): return true;
+      case hashString("penultimateCellIndex"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+  HybridAixComponentDescriptor::HybridAixComponentDescriptor(const react::ComponentDescriptorParameters& parameters)
+    : ConcreteComponentDescriptor(parameters,
+                                  react::RawPropsParser(/* enableJsiParser */ true)) {}
+
+  std::shared_ptr<const react::Props> HybridAixComponentDescriptor::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 HybridAixShadowNode::Props(context, /* & */ rawProps, props);
+  }
+
+#ifdef ANDROID
+  void HybridAixComponentDescriptor::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<HybridAixShadowNode&>(shadowNode);
+    const HybridAixProps& props = concreteShadowNode.getConcreteProps();
+    HybridAixState state;
+    state.setProps(props);
+    concreteShadowNode.setStateData(std::move(state));
+  }
+#endif
+
+} // namespace margelo::nitro::aix::views