@onekeyfe/react-native-native-list 3.0.105

package/lib/nitrogen/generated/.gitattributes

@@ -0,0 +1 @@
+** linguist-generated=true

package/lib/nitrogen/generated/android/c++/JFunc_void_std__string.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__string.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nativelist {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(payloadJson: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nativelist/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& payloadJson) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* payloadJson */)>("invoke");
+      method(self(), jni::make_jstring(payloadJson));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* payloadJson */)>& func) {
+      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> payloadJson) {
+      _func(payloadJson->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* payloadJson */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nativelist/Func_void_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* payloadJson */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* payloadJson */)> _func;
+  };
+
+} // namespace margelo::nitro::nativelist

package/lib/nitrogen/generated/android/c++/JHybridNativeListSpec.cpp

@@ -0,0 +1,201 @@
+///
+/// JHybridNativeListSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNativeListSpec.hpp"
+
+// Forward declaration of `NativeListScrollAlignment` to properly resolve imports.
+namespace margelo::nitro::nativelist { enum class NativeListScrollAlignment; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include "JFunc_void_std__string.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "NativeListScrollAlignment.hpp"
+#include "JNativeListScrollAlignment.hpp"
+
+namespace margelo::nitro::nativelist {
+
+  std::shared_ptr<JHybridNativeListSpec> JHybridNativeListSpec::JavaPart::getJHybridNativeListSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridNativeListSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridNativeListSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridNativeListSpec::CxxPart::jhybriddata> JHybridNativeListSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridNativeListSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridNativeListSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridNativeListSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridNativeListSpec>(castJavaPart);
+  }
+
+  void JHybridNativeListSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNativeListSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  std::string JHybridNativeListSpec::getSnapshotJson() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getSnapshotJson");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridNativeListSpec::setSnapshotJson(const std::string& snapshotJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* snapshotJson */)>("setSnapshotJson");
+    method(_javaPart, jni::make_jstring(snapshotJson));
+  }
+  std::optional<std::function<void(const std::string& /* payloadJson */)>> JHybridNativeListSpec::getOnRowAction() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnRowAction_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* payloadJson */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNativeListSpec::setOnRowAction(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onRowAction) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onRowAction */)>("setOnRowAction_cxx");
+    method(_javaPart, onRowAction.has_value() ? JFunc_void_std__string_cxx::fromCpp(onRowAction.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* payloadJson */)>> JHybridNativeListSpec::getOnActionAnchorInvalidated() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnActionAnchorInvalidated_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* payloadJson */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNativeListSpec::setOnActionAnchorInvalidated(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onActionAnchorInvalidated) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onActionAnchorInvalidated */)>("setOnActionAnchorInvalidated_cxx");
+    method(_javaPart, onActionAnchorInvalidated.has_value() ? JFunc_void_std__string_cxx::fromCpp(onActionAnchorInvalidated.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* payloadJson */)>> JHybridNativeListSpec::getOnSelectionDelta() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnSelectionDelta_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* payloadJson */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNativeListSpec::setOnSelectionDelta(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onSelectionDelta) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onSelectionDelta */)>("setOnSelectionDelta_cxx");
+    method(_javaPart, onSelectionDelta.has_value() ? JFunc_void_std__string_cxx::fromCpp(onSelectionDelta.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* payloadJson */)>> JHybridNativeListSpec::getOnReorder() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnReorder_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* payloadJson */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNativeListSpec::setOnReorder(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onReorder) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onReorder */)>("setOnReorder_cxx");
+    method(_javaPart, onReorder.has_value() ? JFunc_void_std__string_cxx::fromCpp(onReorder.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* payloadJson */)>> JHybridNativeListSpec::getOnEndReached() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnEndReached_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* payloadJson */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNativeListSpec::setOnEndReached(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onEndReached) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onEndReached */)>("setOnEndReached_cxx");
+    method(_javaPart, onEndReached.has_value() ? JFunc_void_std__string_cxx::fromCpp(onEndReached.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* payloadJson */)>> JHybridNativeListSpec::getOnVisibleRangeChanged() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnVisibleRangeChanged_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* payloadJson */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNativeListSpec::setOnVisibleRangeChanged(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onVisibleRangeChanged) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onVisibleRangeChanged */)>("setOnVisibleRangeChanged_cxx");
+    method(_javaPart, onVisibleRangeChanged.has_value() ? JFunc_void_std__string_cxx::fromCpp(onVisibleRangeChanged.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridNativeListSpec::applySnapshot(const std::string& snapshotJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* snapshotJson */)>("applySnapshot");
+    method(_javaPart, jni::make_jstring(snapshotJson));
+  }
+  void JHybridNativeListSpec::applyPatches(const std::string& patchesJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* patchesJson */)>("applyPatches");
+    method(_javaPart, jni::make_jstring(patchesJson));
+  }
+  void JHybridNativeListSpec::reconcileSelection(const std::string& selectedKeysJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* selectedKeysJson */)>("reconcileSelection");
+    method(_javaPart, jni::make_jstring(selectedKeysJson));
+  }
+  void JHybridNativeListSpec::scrollToKey(const std::string& key, bool animated, NativeListScrollAlignment alignment, double viewPosition, double viewOffset) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* key */, jboolean /* animated */, jni::alias_ref<JNativeListScrollAlignment> /* alignment */, double /* viewPosition */, double /* viewOffset */)>("scrollToKey");
+    method(_javaPart, jni::make_jstring(key), animated, JNativeListScrollAlignment::fromCpp(alignment), viewPosition, viewOffset);
+  }
+  void JHybridNativeListSpec::scrollToIndex(double index, bool animated, NativeListScrollAlignment alignment, double viewPosition, double viewOffset) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* index */, jboolean /* animated */, jni::alias_ref<JNativeListScrollAlignment> /* alignment */, double /* viewPosition */, double /* viewOffset */)>("scrollToIndex");
+    method(_javaPart, index, animated, JNativeListScrollAlignment::fromCpp(alignment), viewPosition, viewOffset);
+  }
+  void JHybridNativeListSpec::scrollToOffset(double offset, bool animated) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* offset */, jboolean /* animated */)>("scrollToOffset");
+    method(_javaPart, offset, animated);
+  }
+  void JHybridNativeListSpec::scrollToEnd(bool animated) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* animated */)>("scrollToEnd");
+    method(_javaPart, animated);
+  }
+  void JHybridNativeListSpec::setActionAnchorState(const std::string& stateJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* stateJson */)>("setActionAnchorState");
+    method(_javaPart, jni::make_jstring(stateJson));
+  }
+  void JHybridNativeListSpec::setRefreshing(bool refreshing) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* refreshing */)>("setRefreshing");
+    method(_javaPart, refreshing);
+  }
+
+} // namespace margelo::nitro::nativelist

package/lib/nitrogen/generated/android/c++/JHybridNativeListSpec.hpp

@@ -0,0 +1,84 @@
+///
+/// HybridNativeListSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNativeListSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nativelist {
+
+  using namespace facebook;
+
+  class JHybridNativeListSpec: public virtual HybridNativeListSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nativelist/HybridNativeListSpec;";
+      std::shared_ptr<JHybridNativeListSpec> getJHybridNativeListSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nativelist/HybridNativeListSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridNativeListSpec(const jni::local_ref<JHybridNativeListSpec::JavaPart>& javaPart):
+      HybridObject(HybridNativeListSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridNativeListSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridNativeListSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::string getSnapshotJson() override;
+    void setSnapshotJson(const std::string& snapshotJson) override;
+    std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnRowAction() override;
+    void setOnRowAction(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onRowAction) override;
+    std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnActionAnchorInvalidated() override;
+    void setOnActionAnchorInvalidated(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onActionAnchorInvalidated) override;
+    std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnSelectionDelta() override;
+    void setOnSelectionDelta(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onSelectionDelta) override;
+    std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnReorder() override;
+    void setOnReorder(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onReorder) override;
+    std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnEndReached() override;
+    void setOnEndReached(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onEndReached) override;
+    std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnVisibleRangeChanged() override;
+    void setOnVisibleRangeChanged(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onVisibleRangeChanged) override;
+
+  public:
+    // Methods
+    void applySnapshot(const std::string& snapshotJson) override;
+    void applyPatches(const std::string& patchesJson) override;
+    void reconcileSelection(const std::string& selectedKeysJson) override;
+    void scrollToKey(const std::string& key, bool animated, NativeListScrollAlignment alignment, double viewPosition, double viewOffset) override;
+    void scrollToIndex(double index, bool animated, NativeListScrollAlignment alignment, double viewPosition, double viewOffset) override;
+    void scrollToOffset(double offset, bool animated) override;
+    void scrollToEnd(bool animated) override;
+    void setActionAnchorState(const std::string& stateJson) override;
+    void setRefreshing(bool refreshing) override;
+
+  private:
+    jni::global_ref<JHybridNativeListSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nativelist

package/lib/nitrogen/generated/android/c++/JNativeListScrollAlignment.hpp

@@ -0,0 +1,64 @@
+///
+/// JNativeListScrollAlignment.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "NativeListScrollAlignment.hpp"
+
+namespace margelo::nitro::nativelist {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "NativeListScrollAlignment" and the Kotlin enum "NativeListScrollAlignment".
+   */
+  struct JNativeListScrollAlignment final: public jni::JavaClass<JNativeListScrollAlignment> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nativelist/NativeListScrollAlignment;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum NativeListScrollAlignment.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NativeListScrollAlignment toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<NativeListScrollAlignment>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JNativeListScrollAlignment> fromCpp(NativeListScrollAlignment value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case NativeListScrollAlignment::START:
+          static const auto fieldSTART = clazz->getStaticField<JNativeListScrollAlignment>("START");
+          return clazz->getStaticFieldValue(fieldSTART);
+        case NativeListScrollAlignment::CENTER:
+          static const auto fieldCENTER = clazz->getStaticField<JNativeListScrollAlignment>("CENTER");
+          return clazz->getStaticFieldValue(fieldCENTER);
+        case NativeListScrollAlignment::END:
+          static const auto fieldEND = clazz->getStaticField<JNativeListScrollAlignment>("END");
+          return clazz->getStaticFieldValue(fieldEND);
+        case NativeListScrollAlignment::NEAREST:
+          static const auto fieldNEAREST = clazz->getStaticField<JNativeListScrollAlignment>("NEAREST");
+          return clazz->getStaticFieldValue(fieldNEAREST);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nativelist

package/lib/nitrogen/generated/android/c++/views/JHybridNativeListStateUpdater.cpp

@@ -0,0 +1,104 @@
+///
+/// JHybridNativeListStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNativeListStateUpdater.hpp"
+#include "views/HybridNativeListComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+#include <react/fabric/StateWrapperImpl.h>
+
+namespace margelo::nitro::nativelist::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridNativeListState>;
+
+std::shared_ptr<const HybridNativeListProps> JHybridNativeListStateUpdater::getPropsFromStateWrapper(
+    jni::alias_ref<JStateWrapper::javaobject> stateWrapper) {
+  if (stateWrapper.get() == nullptr) {
+    return nullptr;
+  }
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapper.get();
+  if (!stateWrapper->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+    throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapperImpl = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+    static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)
+  };
+  std::shared_ptr<const react::State> state = stateWrapperImpl->cthis()->getState();
+  if (state == nullptr) {
+    return nullptr;
+  }
+  auto concreteState = std::static_pointer_cast<const ConcreteStateData>(state);
+  const HybridNativeListState& data = concreteState->getData();
+  const std::shared_ptr<const HybridNativeListProps>& props = data.getProps();
+  if (props == nullptr) [[unlikely]] {
+    throw std::runtime_error("HybridNativeListState's data doesn't contain any props!");
+  }
+  return props;
+}
+
+void JHybridNativeListStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridNativeListSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<JHybridNativeListSpec> hybridView = javaView->getJHybridNativeListSpec();
+  std::shared_ptr<const HybridNativeListProps> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const HybridNativeListProps> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
+  }
+
+  // Update only props that differ from the previous State snapshot.
+  if (oldProps == nullptr
+        ? newProps->snapshotJson.isProvided()
+        : !newProps->snapshotJson.hasSameValue(oldProps->snapshotJson)) {
+    hybridView->setSnapshotJson(newProps->snapshotJson.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onRowAction.isProvided()
+        : !newProps->onRowAction.hasSameValue(oldProps->onRowAction)) {
+    hybridView->setOnRowAction(newProps->onRowAction.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onActionAnchorInvalidated.isProvided()
+        : !newProps->onActionAnchorInvalidated.hasSameValue(oldProps->onActionAnchorInvalidated)) {
+    hybridView->setOnActionAnchorInvalidated(newProps->onActionAnchorInvalidated.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onSelectionDelta.isProvided()
+        : !newProps->onSelectionDelta.hasSameValue(oldProps->onSelectionDelta)) {
+    hybridView->setOnSelectionDelta(newProps->onSelectionDelta.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onReorder.isProvided()
+        : !newProps->onReorder.hasSameValue(oldProps->onReorder)) {
+    hybridView->setOnReorder(newProps->onReorder.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onEndReached.isProvided()
+        : !newProps->onEndReached.hasSameValue(oldProps->onEndReached)) {
+    hybridView->setOnEndReached(newProps->onEndReached.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onVisibleRangeChanged.isProvided()
+        : !newProps->onVisibleRangeChanged.hasSameValue(oldProps->onVisibleRangeChanged)) {
+    hybridView->setOnVisibleRangeChanged(newProps->onVisibleRangeChanged.get());
+  }
+
+  // Update hybridRef if it changed
+  if (oldProps == nullptr
+        ? newProps->hybridRef.isProvided()
+        : !newProps->hybridRef.hasSameValue(oldProps->hybridRef)) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newProps->hybridRef.get();
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(hybridView);
+    }
+  }
+}
+
+} // namespace margelo::nitro::nativelist::views

package/lib/nitrogen/generated/android/c++/views/JHybridNativeListStateUpdater.hpp

@@ -0,0 +1,54 @@
+///
+/// JHybridNativeListStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error nativelist 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/CoreComponentsRegistry.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridNativeListSpec.hpp"
+#include "views/HybridNativeListComponent.hpp"
+
+namespace margelo::nitro::nativelist::views {
+
+using namespace facebook;
+
+class JHybridNativeListStateUpdater final: public jni::JavaClass<JHybridNativeListStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nativelist/views/HybridNativeListStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridNativeListSpec::JavaPart> view,
+                              jni::alias_ref<JStateWrapper::javaobject> newState,
+                              jni::alias_ref<JStateWrapper::javaobject> oldState);
+
+private:
+  static std::shared_ptr<const HybridNativeListProps> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridNativeListStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridNativeListComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::nativelist::views

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/nativelist/Func_void_std__string.kt

@@ -0,0 +1,78 @@
+///
+/// Func_void_std__string.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nativelist
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript callback `(payloadJson: string) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_std__string: (String) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(payloadJson: String): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(payloadJson: string) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_std__string_cxx: Func_void_std__string {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(payloadJson: String): Unit
+    = invoke_cxx(payloadJson)
+
+  private external fun invoke_cxx(payloadJson: String): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(payloadJson: string) => void`.
+ * This is implemented in Java/Kotlin, via a `(String) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_std__string_java(private val function: (String) -> Unit): Func_void_std__string {
+  @DoNotStrip
+  @Keep
+  override fun invoke(payloadJson: String): Unit {
+    return this.function(payloadJson)
+  }
+}