@onekeyfe/react-native-native-list 3.0.105

package/lib/typescript/src/web/NativeListWebEngine.d.ts

@@ -0,0 +1,203 @@
+import type { ActionAnchorInvalidatedEvent, NativeListSnapshot, NativeListActionAnchor, NativeListActionSource, ReorderEvent, RowActionEvent, RowModel, RowPatch, SelectionDeltaEvent, VisibleRangeChangedEvent } from '../models';
+import type { ActionAnchorState, ScrollToIndexFailedInfo, ScrollToLocationParams } from '../NativeList.types';
+import { type NormalizedPositionScroll } from '../scrolling';
+export declare const WEB_REORDER_ANIMATION: {
+    readonly outOfWayDurationMs: 200;
+    readonly outOfWayTimingFunction: "cubic-bezier(0.2, 0, 0, 1)";
+    readonly dropDurationMs: 80;
+    readonly dropTimingFunction: "ease";
+};
+export type WebLayoutItem = Readonly<{
+    index: number;
+    key: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>;
+export type WebListLayout = Readonly<{
+    items: readonly WebLayoutItem[];
+    contentWidth: number;
+    contentHeight: number;
+    horizontal: boolean;
+}>;
+export type NativeListWebCallbacks = Readonly<{
+    onRowAction?: (event: RowActionEvent) => void;
+    onActionAnchorInvalidated?: (event: ActionAnchorInvalidatedEvent) => void;
+    onSelectionDelta?: (event: SelectionDeltaEvent) => void;
+    onReorder?: (event: ReorderEvent) => void;
+    onEndReached?: (event: {
+        generation: number;
+        lastKey?: string;
+    }) => void;
+    onVisibleRangeChanged?: (event: VisibleRangeChangedEvent) => void;
+    onRefresh?: () => void;
+    onScrollToIndexFailed?: (info: ScrollToIndexFailedInfo) => void;
+}>;
+export declare function webActionAnchorPayload(token: string, rect: Readonly<{
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}>, source: NativeListActionSource, generation: number, layoutDirection: 'ltr' | 'rtl', slot?: number): NativeListActionAnchor;
+export declare function isWebRowReorderable(snapshot: NativeListSnapshot, row: RowModel): boolean;
+export declare function moveWebReorderRow(rows: readonly RowModel[], fromIndex: number, toIndex: number): readonly RowModel[];
+export declare function cancelWebReorderRows(originalRows: readonly RowModel[]): readonly RowModel[];
+export declare function webReorderEventForRows(originalRows: readonly RowModel[], finalRows: readonly RowModel[], key: string): ReorderEvent | undefined;
+export declare function webReorderAutoScrollVelocity(point: number, start: number, end: number, elapsedMs: number): number;
+export declare function hasExceededWebReorderMouseThreshold(deltaX: number, deltaY: number): boolean;
+export declare function estimateWebRowHeight(row: RowModel, snapshot: NativeListSnapshot, availableWidth: number): number;
+export declare function computeWebListLayout(snapshot: NativeListSnapshot, viewportWidth: number, viewportHeight: number, compactRowKey?: string): WebListLayout;
+export declare function webWalletGroupReorderBadge(row: RowModel): string | undefined;
+export declare function visibleWebLayoutItems(layout: WebListLayout, offset: number, viewportLength: number, overscan?: number): readonly WebLayoutItem[];
+export declare function webLayoutItemsForMount(layout: WebListLayout, offset: number, viewportLength: number, virtualizationEnabled: boolean, overscan?: number): readonly WebLayoutItem[];
+export declare function webRowRenderSignature(row: RowModel): string;
+export declare const WEB_LIST_CSS: string;
+export declare class NativeListWebEngine {
+    private readonly document;
+    private readonly root;
+    private readonly viewportFrame;
+    private readonly viewport;
+    private readonly content;
+    private readonly footer;
+    private readonly sticky;
+    private readonly indexRail;
+    private readonly indexPreview;
+    private readonly refreshIndicator;
+    private readonly reorderPreview;
+    private readonly previousHostPosition;
+    private snapshot;
+    private rows;
+    private selectedKeys;
+    private callbacks;
+    private layout;
+    private readonly mounted;
+    private readonly pool;
+    private frameHandle;
+    private resizeObserver;
+    private pendingScroll;
+    private lastVisibleSignature;
+    private reachedGeneration;
+    private stickyKey;
+    private previewTimer;
+    private pointerReorder;
+    private keyboardReorder;
+    private reorderMoveFrame;
+    private reorderAutoScrollFrame;
+    private reorderDropTimer;
+    private reorderMovementTimer;
+    private reorderSettlingKey;
+    private reorderCompactKey;
+    private reorderExpandingKey;
+    private suppressClickUntil;
+    private pullStartY;
+    private pullDistance;
+    private virtualizationEnabled;
+    private actionAnchor;
+    private readonly actionAnchorInstanceId;
+    private actionAnchorCounter;
+    private bindingEpochCounter;
+    private lastViewportWidth;
+    private lastViewportHeight;
+    private destroyed;
+    constructor(host: HTMLElement, snapshot: NativeListSnapshot, callbacks: NativeListWebCallbacks, virtualizationEnabled?: boolean);
+    updateCallbacks(callbacks: NativeListWebCallbacks): void;
+    setVirtualizationEnabled(enabled: boolean): void;
+    applySnapshot(snapshot: NativeListSnapshot): void;
+    applyPatches(patches: readonly RowPatch[]): void;
+    reconcileSelection(keys: readonly string[]): void;
+    scrollToIndex(index: number, scroll: NormalizedPositionScroll): void;
+    scrollToKey(key: string, scroll: NormalizedPositionScroll): void;
+    scrollToOffset(offset: number, animated: boolean): void;
+    scrollToEnd(animated: boolean): void;
+    scrollToLocation(params: ScrollToLocationParams, scroll: NormalizedPositionScroll): void;
+    setRefreshing(refreshing: boolean): void;
+    setActionAnchorState(state: ActionAnchorState): void;
+    destroy(): void;
+    private setSnapshot;
+    private applyTheme;
+    private recomputeLayout;
+    private renderWindow;
+    private positionElement;
+    private renderElement;
+    private renderFooter;
+    private renderSectionIndex;
+    private updateVisibleSelection;
+    private updateVisibleState;
+    private updateStickyHeader;
+    private updateSectionIndex;
+    private checkEndReached;
+    private emitScrollFailure;
+    private canScroll;
+    private viewportLength;
+    private contentLength;
+    private currentOffset;
+    private scrollToAbsoluteOffset;
+    private performPendingScroll;
+    private rowAtElement;
+    private rowLabel;
+    private isReorderable;
+    private activateSelection;
+    private emitRowAction;
+    private createActionAnchor;
+    private isActionAnchorValid;
+    private invalidateActionAnchorForElement;
+    private invalidateActionAnchor;
+    private emitActionAnchorInvalidated;
+    private handleRowPress;
+    private handleClick;
+    private handleKeyDown;
+    private startKeyboardReorder;
+    private moveKeyboardReorder;
+    private finishKeyboardReorder;
+    private cancelKeyboardReorder;
+    private handleScroll;
+    private handleWindowResize;
+    private scheduleFrame;
+    private requestFrame;
+    private cancelFrame;
+    private selectIndexPosition;
+    private indexButtonAtEvent;
+    private handleIndexPointer;
+    private handleIndexClick;
+    private handlePullStart;
+    private handlePullMove;
+    private handlePullEnd;
+    private updateRefreshIndicator;
+    private handleReorderPointerDown;
+    private activatePointerReorder;
+    private captureReorderPointer;
+    private releaseReorderPointer;
+    private clearReorderLongPress;
+    private handleReorderPointerMove;
+    private handleReorderTouchMove;
+    private handleReorderTouchEnd;
+    private handleReorderTouchCancel;
+    private setCurrentOffset;
+    private showReorderPreview;
+    private animateReorderPreviewToCurrent;
+    private clearReorderPreviewVisual;
+    private finishReorderDrop;
+    private hideReorderPreview;
+    private updateReorderPreview;
+    private reorderViewportRect;
+    private scheduleReorderMove;
+    private runReorderMove;
+    private flushReorderMove;
+    private stopReorderMove;
+    private reorderIndexAtPointer;
+    private movePointerReorderTo;
+    private canReuseReorderLayout;
+    private remapMountedRowsForMove;
+    private reorderAutoScrollVelocity;
+    private scheduleReorderAutoScroll;
+    private runReorderAutoScroll;
+    private handleReorderPointerEnd;
+    private completePointerReorder;
+    private handleReorderPointerCancel;
+    private stopReorderAutoScroll;
+    private cancelPointerReorder;
+    private remapMountedRows;
+    private updateReorderVisualState;
+}
+//# sourceMappingURL=NativeListWebEngine.d.ts.map

package/nitro.json

@@ -0,0 +1,23 @@
+{
+  "cxxNamespace": ["nativelist"],
+  "ios": {
+    "iosModuleName": "NativeListModule"
+  },
+  "android": {
+    "androidNamespace": ["nativelist"],
+    "androidCxxLibName": "nativelist"
+  },
+  "autolinking": {
+    "NativeList": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridNativeList"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridNativeList"
+      }
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/.gitattributes

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

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