aix 0.0.15 → 0.1.0-alpha.1

package/nitrogen/generated/android/c++/JHybridAixSpec.cpp

@@ -0,0 +1,137 @@
+///
+/// JHybridAixSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAixSpec.hpp"
+
+// 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 `AixAdditionalContentInsets` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixAdditionalContentInsets; }
+// Forward declaration of `AixScrollIndicatorInsets` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixScrollIndicatorInsets; }
+// Forward declaration of `AixScrollIndicatorInsetValue` to properly resolve imports.
+namespace margelo::nitro::aix { struct AixScrollIndicatorInsetValue; }
+
+#include "AixScrollOnFooterSizeUpdate.hpp"
+#include <optional>
+#include "JAixScrollOnFooterSizeUpdate.hpp"
+#include "AixAdditionalContentInsetsProp.hpp"
+#include "JAixAdditionalContentInsetsProp.hpp"
+#include "AixAdditionalContentInsets.hpp"
+#include "JAixAdditionalContentInsets.hpp"
+#include "AixScrollIndicatorInsets.hpp"
+#include "JAixScrollIndicatorInsets.hpp"
+#include "AixScrollIndicatorInsetValue.hpp"
+#include "JAixScrollIndicatorInsetValue.hpp"
+#include <string>
+
+namespace margelo::nitro::aix {
+
+  jni::local_ref<JHybridAixSpec::jhybriddata> JHybridAixSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridAixSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridAixSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridAixSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridAixSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridAixSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  bool JHybridAixSpec::getShouldStartAtEnd() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getShouldStartAtEnd");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridAixSpec::setShouldStartAtEnd(bool shouldStartAtEnd) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* shouldStartAtEnd */)>("setShouldStartAtEnd");
+    method(_javaPart, shouldStartAtEnd);
+  }
+  std::optional<AixScrollOnFooterSizeUpdate> JHybridAixSpec::getScrollOnFooterSizeUpdate() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JAixScrollOnFooterSizeUpdate>()>("getScrollOnFooterSizeUpdate");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridAixSpec::setScrollOnFooterSizeUpdate(const std::optional<AixScrollOnFooterSizeUpdate>& scrollOnFooterSizeUpdate) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JAixScrollOnFooterSizeUpdate> /* scrollOnFooterSizeUpdate */)>("setScrollOnFooterSizeUpdate");
+    method(_javaPart, scrollOnFooterSizeUpdate.has_value() ? JAixScrollOnFooterSizeUpdate::fromCpp(scrollOnFooterSizeUpdate.value()) : nullptr);
+  }
+  std::optional<double> JHybridAixSpec::getScrollEndReachedThreshold() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getScrollEndReachedThreshold");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAixSpec::setScrollEndReachedThreshold(std::optional<double> scrollEndReachedThreshold) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* scrollEndReachedThreshold */)>("setScrollEndReachedThreshold");
+    method(_javaPart, scrollEndReachedThreshold.has_value() ? jni::JDouble::valueOf(scrollEndReachedThreshold.value()) : nullptr);
+  }
+  std::optional<AixAdditionalContentInsetsProp> JHybridAixSpec::getAdditionalContentInsets() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JAixAdditionalContentInsetsProp>()>("getAdditionalContentInsets");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridAixSpec::setAdditionalContentInsets(const std::optional<AixAdditionalContentInsetsProp>& additionalContentInsets) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JAixAdditionalContentInsetsProp> /* additionalContentInsets */)>("setAdditionalContentInsets");
+    method(_javaPart, additionalContentInsets.has_value() ? JAixAdditionalContentInsetsProp::fromCpp(additionalContentInsets.value()) : nullptr);
+  }
+  std::optional<AixScrollIndicatorInsets> JHybridAixSpec::getAdditionalScrollIndicatorInsets() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JAixScrollIndicatorInsets>()>("getAdditionalScrollIndicatorInsets");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridAixSpec::setAdditionalScrollIndicatorInsets(const std::optional<AixScrollIndicatorInsets>& additionalScrollIndicatorInsets) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JAixScrollIndicatorInsets> /* additionalScrollIndicatorInsets */)>("setAdditionalScrollIndicatorInsets");
+    method(_javaPart, additionalScrollIndicatorInsets.has_value() ? JAixScrollIndicatorInsets::fromCpp(additionalScrollIndicatorInsets.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridAixSpec::getMainScrollViewID() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getMainScrollViewID");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridAixSpec::setMainScrollViewID(const std::optional<std::string>& mainScrollViewID) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* mainScrollViewID */)>("setMainScrollViewID");
+    method(_javaPart, mainScrollViewID.has_value() ? jni::make_jstring(mainScrollViewID.value()) : nullptr);
+  }
+  std::optional<double> JHybridAixSpec::getPenultimateCellIndex() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getPenultimateCellIndex");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridAixSpec::setPenultimateCellIndex(std::optional<double> penultimateCellIndex) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* penultimateCellIndex */)>("setPenultimateCellIndex");
+    method(_javaPart, penultimateCellIndex.has_value() ? jni::JDouble::valueOf(penultimateCellIndex.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridAixSpec::scrollToEnd(std::optional<bool> animated) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* animated */)>("scrollToEnd");
+    method(_javaPart, animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr);
+  }
+  void JHybridAixSpec::scrollToIndexWhenBlankSizeReady(double index, std::optional<bool> animated, std::optional<bool> waitForKeyboardToEnd) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* index */, jni::alias_ref<jni::JBoolean> /* animated */, jni::alias_ref<jni::JBoolean> /* waitForKeyboardToEnd */)>("scrollToIndexWhenBlankSizeReady");
+    method(_javaPart, index, animated.has_value() ? jni::JBoolean::valueOf(animated.value()) : nullptr, waitForKeyboardToEnd.has_value() ? jni::JBoolean::valueOf(waitForKeyboardToEnd.value()) : nullptr);
+  }
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/android/c++/JHybridAixSpec.hpp

@@ -0,0 +1,79 @@
+///
+/// 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
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridAixSpec.hpp"
+
+
+
+
+namespace margelo::nitro::aix {
+
+  using namespace facebook;
+
+  class JHybridAixSpec: public jni::HybridClass<JHybridAixSpec, JHybridObject>,
+                        public virtual HybridAixSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/aix/HybridAixSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridAixSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridAixSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridAixSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridAixSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    bool getShouldStartAtEnd() override;
+    void setShouldStartAtEnd(bool shouldStartAtEnd) override;
+    std::optional<AixScrollOnFooterSizeUpdate> getScrollOnFooterSizeUpdate() override;
+    void setScrollOnFooterSizeUpdate(const std::optional<AixScrollOnFooterSizeUpdate>& scrollOnFooterSizeUpdate) override;
+    std::optional<double> getScrollEndReachedThreshold() override;
+    void setScrollEndReachedThreshold(std::optional<double> scrollEndReachedThreshold) override;
+    std::optional<AixAdditionalContentInsetsProp> getAdditionalContentInsets() override;
+    void setAdditionalContentInsets(const std::optional<AixAdditionalContentInsetsProp>& additionalContentInsets) override;
+    std::optional<AixScrollIndicatorInsets> getAdditionalScrollIndicatorInsets() override;
+    void setAdditionalScrollIndicatorInsets(const std::optional<AixScrollIndicatorInsets>& additionalScrollIndicatorInsets) override;
+    std::optional<std::string> getMainScrollViewID() override;
+    void setMainScrollViewID(const std::optional<std::string>& mainScrollViewID) override;
+    std::optional<double> getPenultimateCellIndex() override;
+    void setPenultimateCellIndex(std::optional<double> penultimateCellIndex) override;
+
+  public:
+    // Methods
+    void scrollToEnd(std::optional<bool> animated) override;
+    void scrollToIndexWhenBlankSizeReady(double index, std::optional<bool> animated, std::optional<bool> waitForKeyboardToEnd) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridAixSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::aix

package/nitrogen/generated/android/c++/views/JHybridAixCellViewStateUpdater.cpp

@@ -0,0 +1,60 @@
+///
+/// JHybridAixCellViewStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAixCellViewStateUpdater.hpp"
+#include "views/HybridAixCellViewComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::aix::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridAixCellViewState>;
+
+void JHybridAixCellViewStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridAixCellViewSpec::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  JHybridAixCellViewSpec* view = javaView->cthis();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::dynamic_pointer_cast<const ConcreteStateData>(state);
+  const HybridAixCellViewState& data = concreteState->getData();
+  const std::optional<HybridAixCellViewProps>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridAixCellViewState's data doesn't contain any props!");
+  }
+  const HybridAixCellViewProps& props = maybeProps.value();
+  if (props.isLast.isDirty) {
+    view->setIsLast(props.isLast.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.index.isDirty) {
+    view->setIndex(props.index.value);
+    // TODO: Set isDirty = false
+  }
+
+  // Update hybridRef if it changed
+  if (props.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      std::shared_ptr<JHybridAixCellViewSpec> shared = javaView->cthis()->shared_cast<JHybridAixCellViewSpec>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace margelo::nitro::aix::views

package/nitrogen/generated/android/c++/views/JHybridAixCellViewStateUpdater.hpp

@@ -0,0 +1,49 @@
+///
+/// JHybridAixCellViewStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error Aix was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridAixCellViewSpec.hpp"
+#include "views/HybridAixCellViewComponent.hpp"
+
+namespace margelo::nitro::aix::views {
+
+using namespace facebook;
+
+class JHybridAixCellViewStateUpdater: public jni::JavaClass<JHybridAixCellViewStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/aix/views/HybridAixCellViewStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridAixCellViewSpec::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridAixCellViewStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridAixCellViewComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::aix::views

package/nitrogen/generated/android/c++/views/JHybridAixComposerStateUpdater.cpp

@@ -0,0 +1,53 @@
+///
+/// JHybridAixComposerStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAixComposerStateUpdater.hpp"
+#include "views/HybridAixComposerComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::aix::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridAixComposerState>;
+
+void JHybridAixComposerStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridAixComposerSpec::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  JHybridAixComposerSpec* view = javaView->cthis();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::dynamic_pointer_cast<const ConcreteStateData>(state);
+  const HybridAixComposerState& data = concreteState->getData();
+  const std::optional<HybridAixComposerProps>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridAixComposerState's data doesn't contain any props!");
+  }
+  const HybridAixComposerProps& props = maybeProps.value();
+  
+
+  // Update hybridRef if it changed
+  if (props.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      std::shared_ptr<JHybridAixComposerSpec> shared = javaView->cthis()->shared_cast<JHybridAixComposerSpec>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace margelo::nitro::aix::views

package/nitrogen/generated/android/c++/views/JHybridAixComposerStateUpdater.hpp

@@ -0,0 +1,49 @@
+///
+/// JHybridAixComposerStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error Aix was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridAixComposerSpec.hpp"
+#include "views/HybridAixComposerComponent.hpp"
+
+namespace margelo::nitro::aix::views {
+
+using namespace facebook;
+
+class JHybridAixComposerStateUpdater: public jni::JavaClass<JHybridAixComposerStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/aix/views/HybridAixComposerStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridAixComposerSpec::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridAixComposerStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridAixComposerComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::aix::views

package/nitrogen/generated/android/c++/views/JHybridAixStateUpdater.cpp

@@ -0,0 +1,80 @@
+///
+/// JHybridAixStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridAixStateUpdater.hpp"
+#include "views/HybridAixComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::aix::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridAixState>;
+
+void JHybridAixStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridAixSpec::javaobject> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface) {
+  JHybridAixSpec* view = javaView->cthis();
+
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapperInterface.get();
+  if (!stateWrapperInterface->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) {
+      throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapper = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+            static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)};
+
+  std::shared_ptr<const react::State> state = stateWrapper->cthis()->getState();
+  auto concreteState = std::dynamic_pointer_cast<const ConcreteStateData>(state);
+  const HybridAixState& data = concreteState->getData();
+  const std::optional<HybridAixProps>& maybeProps = data.getProps();
+  if (!maybeProps.has_value()) {
+    // Props aren't set yet!
+    throw std::runtime_error("HybridAixState's data doesn't contain any props!");
+  }
+  const HybridAixProps& props = maybeProps.value();
+  if (props.shouldStartAtEnd.isDirty) {
+    view->setShouldStartAtEnd(props.shouldStartAtEnd.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.scrollOnFooterSizeUpdate.isDirty) {
+    view->setScrollOnFooterSizeUpdate(props.scrollOnFooterSizeUpdate.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.scrollEndReachedThreshold.isDirty) {
+    view->setScrollEndReachedThreshold(props.scrollEndReachedThreshold.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.additionalContentInsets.isDirty) {
+    view->setAdditionalContentInsets(props.additionalContentInsets.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.additionalScrollIndicatorInsets.isDirty) {
+    view->setAdditionalScrollIndicatorInsets(props.additionalScrollIndicatorInsets.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.mainScrollViewID.isDirty) {
+    view->setMainScrollViewID(props.mainScrollViewID.value);
+    // TODO: Set isDirty = false
+  }
+  if (props.penultimateCellIndex.isDirty) {
+    view->setPenultimateCellIndex(props.penultimateCellIndex.value);
+    // TODO: Set isDirty = false
+  }
+
+  // Update hybridRef if it changed
+  if (props.hybridRef.isDirty) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = props.hybridRef.value;
+    if (maybeFunc.has_value()) {
+      std::shared_ptr<JHybridAixSpec> shared = javaView->cthis()->shared_cast<JHybridAixSpec>();
+      maybeFunc.value()(shared);
+    }
+    // TODO: Set isDirty = false
+  }
+}
+
+} // namespace margelo::nitro::aix::views

package/nitrogen/generated/android/c++/views/JHybridAixStateUpdater.hpp

@@ -0,0 +1,49 @@
+///
+/// JHybridAixStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error Aix was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridAixSpec.hpp"
+#include "views/HybridAixComponent.hpp"
+
+namespace margelo::nitro::aix::views {
+
+using namespace facebook;
+
+class JHybridAixStateUpdater: public jni::JavaClass<JHybridAixStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/aix/views/HybridAixStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridAixSpec::javaobject> view,
+                              jni::alias_ref<JStateWrapper::javaobject> stateWrapperInterface);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridAixStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridAixComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::aix::views

package/nitrogen/generated/android/kotlin/com/margelo/nitro/aix/AixAdditionalContentInsets.kt

@@ -0,0 +1,41 @@
+///
+/// AixAdditionalContentInsets.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.aix
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "AixAdditionalContentInsets".
+ */
+@DoNotStrip
+@Keep
+data class AixAdditionalContentInsets(
+  @DoNotStrip
+  @Keep
+  val whenKeyboardOpen: Double,
+  @DoNotStrip
+  @Keep
+  val whenKeyboardClosed: Double
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(whenKeyboardOpen: Double, whenKeyboardClosed: Double): AixAdditionalContentInsets {
+      return AixAdditionalContentInsets(whenKeyboardOpen, whenKeyboardClosed)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/aix/AixAdditionalContentInsetsProp.kt

@@ -0,0 +1,41 @@
+///
+/// AixAdditionalContentInsetsProp.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.aix
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "AixAdditionalContentInsetsProp".
+ */
+@DoNotStrip
+@Keep
+data class AixAdditionalContentInsetsProp(
+  @DoNotStrip
+  @Keep
+  val top: AixAdditionalContentInsets?,
+  @DoNotStrip
+  @Keep
+  val bottom: AixAdditionalContentInsets?
+) {
+  /* primary constructor */
+
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(top: AixAdditionalContentInsets?, bottom: AixAdditionalContentInsets?): AixAdditionalContentInsetsProp {
+      return AixAdditionalContentInsetsProp(top, bottom)
+    }
+  }
+}