@onekeyfe/react-native-native-list 3.0.157-alpha.254 → 3.0.157-alpha.258

package/lib/module/validation.js

@@ -128,13 +128,13 @@ const TEXT_STYLE_KEYS_BY_ROW_TYPE = {
   identity: ['title', 'subtitle', 'tertiary', 'badge', 'value', 'valueSecondary'],
   walletGroup: [],
   rail: ['title', 'badge', 'status'],
-  activity: ['title', 'description', 'status', 'primaryAmount', 'secondaryAmount'],
+  activity: ['title', 'description', 'status', 'amounts', 'badges', 'presentation', 'fee', 'descriptionActionKey', 'primaryAmount', 'secondaryAmount'],
   message: ['title', 'body', 'time'],
   dataRow: ['columns', 'columnSecondary', 'index'],
   market: ['title', 'subtitle', 'price', 'change'],
   mediaTile: ['title', 'subtitle', 'badge'],
   metricCard: ['title', 'value', 'subtitle', 'trend'],
-  sectionHeader: ['title', 'subtitle', 'value'],
+  sectionHeader: ['titleLoading', 'title', 'subtitle', 'value'],
   action: ['title', 'value'],
   system: ['title', 'message', 'actionText']
 };
@@ -517,6 +517,46 @@ function assertVisual(row, path) {
   });
 }
 function assertActivity(row, path) {
+  assertText(row.title, `${path}.title`);
+  assertText(row.description, `${path}.description`);
+  if (row.presentation !== undefined && !['stacked', 'table'].includes(row.presentation)) fail(`${path}.presentation`, 'must be stacked or table');
+  if (row.descriptionActionKey !== undefined) assertKey(row.descriptionActionKey, `${path}.descriptionActionKey`);
+  if ((row.amounts?.length ?? 0) > 32) fail(`${path}.amounts`, 'supports at most 32 amount lines');
+  const amountKeys = new Set();
+  row.amounts?.forEach((amount, index) => {
+    const amountPath = `${path}.amounts[${index}]`;
+    assertKey(amount.key, `${amountPath}.key`);
+    if (amountKeys.has(amount.key)) fail(amountPath, 'duplicate amount key');
+    amountKeys.add(amount.key);
+    assertText(amount.text, `${amountPath}.text`);
+    assertLeadingVisual(amount.leading, `${amountPath}.leading`);
+    assertText(amount.secondaryText, `${amountPath}.secondaryText`);
+    if (amount.tone !== undefined && !['primary', 'secondary', 'positive', 'negative'].includes(amount.tone)) fail(`${amountPath}.tone`, 'invalid text tone');
+    amount.textSegments?.forEach((segment, segmentIndex) => {
+      assertText(segment.text, `${amountPath}.textSegments[${segmentIndex}].text`);
+      if (segment.style !== undefined && segment.style !== 'subscript') fail(amountPath, 'invalid text segment style');
+    });
+  });
+  const assertActivitySegments = (segments, segmentPath) => segments?.forEach((segment, index) => {
+    assertText(segment.text, `${segmentPath}[${index}].text`);
+    if (segment.style !== undefined && segment.style !== 'subscript') fail(segmentPath, 'invalid text segment style');
+  });
+  row.amounts?.forEach((amount, index) => assertActivitySegments(amount.secondaryTextSegments, `${path}.amounts[${index}].secondaryTextSegments`));
+  assertActivitySegments(row.fee?.primaryTextSegments, `${path}.fee.primaryTextSegments`);
+  assertActivitySegments(row.fee?.secondaryTextSegments, `${path}.fee.secondaryTextSegments`);
+  assertText(row.fee?.label, `${path}.fee.label`);
+  assertText(row.fee?.primary, `${path}.fee.primary`);
+  assertText(row.fee?.secondary, `${path}.fee.secondary`);
+  if ((row.badges?.length ?? 0) > 4) fail(`${path}.badges`, 'supports at most 4 activity badges');
+  const badgeKeys = new Set();
+  row.badges?.forEach((badge, index) => {
+    assertKey(badge.key, `${path}.badges[${index}].key`);
+    if (badgeKeys.has(badge.key)) fail(`${path}.badges`, 'duplicate badge key');
+    badgeKeys.add(badge.key);
+    assertText(badge.text, `${path}.badges[${index}].text`);
+    if (badge.tone !== undefined && !['neutral', 'info', 'success', 'warning', 'danger'].includes(badge.tone)) fail(`${path}.badges`, 'invalid badge tone');
+  });
+  if (row.fee?.hidden !== undefined && typeof row.fee.hidden !== 'boolean') fail(`${path}.fee.hidden`, 'must be boolean');
   if ((row.footerActions?.length ?? 0) > MAX_FOOTER_ACTIONS) {
     fail(`${path}.footerActions`, `supports at most ${MAX_FOOTER_ACTIONS} actions`);
   }
@@ -634,12 +674,13 @@ function assertRow(row, index, path = `rows[${index}]`) {
       assertMarketRow(row, path);
       break;
     case 'mediaTile':
+      assertMediaPreview(row.media, `${path}.media`);
       assertImage(row.image, `${path}.image`);
       if (row.imageState !== undefined && !['empty', 'error'].includes(row.imageState)) {
         fail(`${path}.imageState`, 'must be empty or error when provided');
       }
-      if (row.imageState === undefined && row.image === undefined) {
-        fail(`${path}.image`, 'is required unless imageState is empty or error');
+      if (row.imageState === undefined && row.image === undefined && row.media === undefined) {
+        fail(`${path}.image`, 'is required unless media is provided or imageState is empty or error');
       }
       assertImage(row.networkImage, `${path}.networkImage`);
       assertText(row.title, `${path}.title`);
@@ -668,6 +709,7 @@ function assertRow(row, index, path = `rows[${index}]`) {
       }
       break;
     case 'sectionHeader':
+      if (row.titleLoading !== undefined && typeof row.titleLoading !== 'boolean') fail(`${path}.titleLoading`, 'must be boolean');
       assertKey(row.sectionKey, `${path}.sectionKey`);
       if (row.presentation !== undefined && row.presentation !== 'networkSelector') {
         fail(`${path}.presentation`, 'must be networkSelector when provided');
@@ -746,12 +788,27 @@ function assertGroups(rows) {
     }
   }
 }
+function assertMediaPreview(value, path) {
+  if (value === undefined) return;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) fail(path, 'must be a media descriptor');
+  const media = value;
+  assertImage(media.source, `${path}.source`);
+  if (!media.source) fail(`${path}.source`, 'is required');
+  const order = media.probeOrder;
+  if (!Array.isArray(order) || order.length < 1 || order.length > 2 || order.some(kind => kind !== 'image' && kind !== 'video') || new Set(order).size !== order.length) {
+    fail(`${path}.probeOrder`, 'must contain one or two distinct image/video candidates');
+  }
+}
 export function validateSnapshot(snapshot) {
+  if (snapshot.capabilities?.refreshTriggerDistance !== undefined && (!Number.isFinite(snapshot.capabilities.refreshTriggerDistance) || snapshot.capabilities.refreshTriggerDistance <= 0)) fail('capabilities.refreshTriggerDistance', 'must be a positive finite number');
   assertPlainSerializable(snapshot, 'snapshot', new Set());
   if (snapshot.schemaVersion !== 1) fail('snapshot.schemaVersion', 'must be 1');
   if (!Number.isSafeInteger(snapshot.generation) || snapshot.generation < 0) {
     fail('snapshot.generation', 'must be a non-negative safe integer');
   }
+  if (snapshot.layout.gridColumns !== undefined && (!Number.isInteger(snapshot.layout.gridColumns) || snapshot.layout.gridColumns < 2 || snapshot.layout.gridColumns > 7)) {
+    fail('snapshot.layout.gridColumns', 'must be an integer from 2 to 7');
+  }
   if (snapshot.layout.kind === 'grid' && !snapshot.layout.gridColumns) {
     fail('snapshot.layout.gridColumns', 'is required for grid layout');
   }
@@ -880,6 +937,7 @@ function assertPatchChanges(patch, index) {
       assertLeadingVisual(patch.changes.visual, `${path}.visual`);
       break;
     case 'activity':
+      assertActivity(patch.changes, path);
       assertText(patch.changes.title, `${path}.title`);
       assertText(patch.changes.description, `${path}.description`);
       assertText(patch.changes.status, `${path}.status`);
@@ -933,6 +991,7 @@ function assertPatchChanges(patch, index) {
       }, path);
       break;
     case 'mediaTile':
+      assertMediaPreview(patch.changes.media, `${path}.media`);
       assertImage(patch.changes.image, `${path}.image`);
       if (patch.changes.imageState !== undefined && !['empty', 'error'].includes(patch.changes.imageState)) {
         fail(`${path}.imageState`, 'must be empty or error when provided');
@@ -965,6 +1024,7 @@ function assertPatchChanges(patch, index) {
       }
       break;
     case 'sectionHeader':
+      if (patch.changes.titleLoading !== undefined && typeof patch.changes.titleLoading !== 'boolean') fail(`${path}.titleLoading`, 'must be boolean');
       assertSectionHeaderVariant(patch.changes.variant, `${path}.variant`);
       assertText(patch.changes.title, `${path}.title`);
       assertText(patch.changes.subtitle, `${path}.subtitle`);

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_bool.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 <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nativelist {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(isBeyondThreshold: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nativelist/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool isBeyondThreshold) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* isBeyondThreshold */)>("invoke");
+      method(self(), isBeyondThreshold);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  public:
+    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* isBeyondThreshold */)>& func) {
+      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean isBeyondThreshold) {
+      _func(static_cast<bool>(isBeyondThreshold));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* isBeyondThreshold */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nativelist/Func_void_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_cxx(const std::function<void(bool /* isBeyondThreshold */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* isBeyondThreshold */)> _func;
+  };
+
+} // namespace margelo::nitro::nativelist

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

@@ -15,14 +15,15 @@ namespace margelo::nitro::nativelist { enum class NativeListKeyboardShouldPersis
 namespace margelo::nitro::nativelist { enum class NativeListScrollAlignment; }
 
 #include <string>
+#include <functional>
+#include <optional>
+#include "JFunc_void_bool.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include "NativeListKeyboardDismissMode.hpp"
 #include "JNativeListKeyboardDismissMode.hpp"
 #include "NativeListKeyboardShouldPersistTaps.hpp"
 #include "JNativeListKeyboardShouldPersistTaps.hpp"
-#include <functional>
-#include <optional>
 #include "JFunc_void_std__string.hpp"
-#include <NitroModules/JNICallable.hpp>
 #include "NativeListScrollAlignment.hpp"
 #include "JNativeListScrollAlignment.hpp"
 
@@ -65,6 +66,41 @@ namespace margelo::nitro::nativelist {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* snapshotJson */)>("setSnapshotJson");
     method(_javaPart, jni::make_jstring(snapshotJson));
   }
+  std::string JHybridNativeListSpec::getContainerSlotHeightsJson() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getContainerSlotHeightsJson");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridNativeListSpec::setContainerSlotHeightsJson(const std::string& containerSlotHeightsJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* containerSlotHeightsJson */)>("setContainerSlotHeightsJson");
+    method(_javaPart, jni::make_jstring(containerSlotHeightsJson));
+  }
+  std::string JHybridNativeListSpec::getScrollPositionThresholdsJson() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getScrollPositionThresholdsJson");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridNativeListSpec::setScrollPositionThresholdsJson(const std::string& scrollPositionThresholdsJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* scrollPositionThresholdsJson */)>("setScrollPositionThresholdsJson");
+    method(_javaPart, jni::make_jstring(scrollPositionThresholdsJson));
+  }
+  std::optional<std::function<void(bool /* isBeyondThreshold */)>> JHybridNativeListSpec::getOnScrollPositionThresholdChange() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_bool::javaobject>()>("getOnScrollPositionThresholdChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(bool /* isBeyondThreshold */)> {
+      if (__result->isInstanceOf(JFunc_void_bool_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_bool_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_bool, void(bool)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridNativeListSpec::setOnScrollPositionThresholdChange(const std::optional<std::function<void(bool /* isBeyondThreshold */)>>& onScrollPositionThresholdChange) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* onScrollPositionThresholdChange */)>("setOnScrollPositionThresholdChange_cxx");
+    method(_javaPart, onScrollPositionThresholdChange.has_value() ? JFunc_void_bool_cxx::fromCpp(onScrollPositionThresholdChange.value()) : nullptr);
+  }
   NativeListKeyboardDismissMode JHybridNativeListSpec::getKeyboardDismissMode() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JNativeListKeyboardDismissMode>()>("getKeyboardDismissMode");
     auto __result = method(_javaPart);

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

@@ -52,6 +52,12 @@ namespace margelo::nitro::nativelist {
     // Properties
     std::string getSnapshotJson() override;
     void setSnapshotJson(const std::string& snapshotJson) override;
+    std::string getContainerSlotHeightsJson() override;
+    void setContainerSlotHeightsJson(const std::string& containerSlotHeightsJson) override;
+    std::string getScrollPositionThresholdsJson() override;
+    void setScrollPositionThresholdsJson(const std::string& scrollPositionThresholdsJson) override;
+    std::optional<std::function<void(bool /* isBeyondThreshold */)>> getOnScrollPositionThresholdChange() override;
+    void setOnScrollPositionThresholdChange(const std::optional<std::function<void(bool /* isBeyondThreshold */)>>& onScrollPositionThresholdChange) override;
     NativeListKeyboardDismissMode getKeyboardDismissMode() override;
     void setKeyboardDismissMode(NativeListKeyboardDismissMode keyboardDismissMode) override;
     NativeListKeyboardShouldPersistTaps getKeyboardShouldPersistTaps() override;

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

@@ -58,6 +58,21 @@ void JHybridNativeListStateUpdater::updateViewProps(jni::alias_ref<jni::JClass>
         : !newProps->snapshotJson.hasSameValue(oldProps->snapshotJson)) {
     hybridView->setSnapshotJson(newProps->snapshotJson.get());
   }
+  if (oldProps == nullptr
+        ? newProps->containerSlotHeightsJson.isProvided()
+        : !newProps->containerSlotHeightsJson.hasSameValue(oldProps->containerSlotHeightsJson)) {
+    hybridView->setContainerSlotHeightsJson(newProps->containerSlotHeightsJson.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->scrollPositionThresholdsJson.isProvided()
+        : !newProps->scrollPositionThresholdsJson.hasSameValue(oldProps->scrollPositionThresholdsJson)) {
+    hybridView->setScrollPositionThresholdsJson(newProps->scrollPositionThresholdsJson.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onScrollPositionThresholdChange.isProvided()
+        : !newProps->onScrollPositionThresholdChange.hasSameValue(oldProps->onScrollPositionThresholdChange)) {
+    hybridView->setOnScrollPositionThresholdChange(newProps->onScrollPositionThresholdChange.get());
+  }
   if (oldProps == nullptr
         ? newProps->keyboardDismissMode.isProvided()
         : !newProps->keyboardDismissMode.hasSameValue(oldProps->keyboardDismissMode)) {

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

@@ -0,0 +1,78 @@
+///
+/// Func_void_bool.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 `(isBeyondThreshold: boolean) => 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_bool: (Boolean) -> 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(isBeyondThreshold: Boolean): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(isBeyondThreshold: boolean) => 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_bool_cxx: Func_void_bool {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(isBeyondThreshold: Boolean): Unit
+    = invoke_cxx(isBeyondThreshold)
+
+  private external fun invoke_cxx(isBeyondThreshold: Boolean): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(isBeyondThreshold: boolean) => void`.
+ * This is implemented in Java/Kotlin, via a `(Boolean) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_bool_java(private val function: (Boolean) -> Unit): Func_void_bool {
+  @DoNotStrip
+  @Keep
+  override fun invoke(isBeyondThreshold: Boolean): Unit {
+    return this.function(isBeyondThreshold)
+  }
+}

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

@@ -33,6 +33,32 @@ abstract class HybridNativeListSpec: HybridView() {
   @set:Keep
   abstract var snapshotJson: String
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var containerSlotHeightsJson: String
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var scrollPositionThresholdsJson: String
+  
+  abstract var onScrollPositionThresholdChange: ((isBeyondThreshold: Boolean) -> Unit)?
+  
+  private var onScrollPositionThresholdChange_cxx: Func_void_bool?
+    @Keep
+    @DoNotStrip
+    get() {
+      return onScrollPositionThresholdChange?.let { Func_void_bool_java(it) }
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onScrollPositionThresholdChange = value?.let { it }
+    }
+  
   @get:DoNotStrip
   @get:Keep
   @set:DoNotStrip

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

@@ -8,8 +8,9 @@
 package com.margelo.nitro.nativelist.views
 
 import android.view.View
+import android.view.ViewGroup
 import com.facebook.react.uimanager.ReactStylesDiffMap
-import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
 import com.margelo.nitro.R.id.associated_hybrid_view_tag
@@ -19,7 +20,7 @@ import com.margelo.nitro.nativelist.*
 /**
  * Represents the React Native `ViewManager` for the "NativeList" Nitro HybridView.
  */
-public class HybridNativeListManager: SimpleViewManager<View>() {
+public class HybridNativeListManager: ViewGroupManager<ViewGroup>() {
   /**
    * Represents the View and its last state snapshot (mutable)
    */
@@ -35,18 +36,32 @@ public class HybridNativeListManager: SimpleViewManager<View>() {
     }
   }
 
+  // NativeList container slot mounting
+  override fun needsCustomLayoutForChildren(): Boolean = true
+  override fun addView(parent: ViewGroup, child: View, index: Int) {
+    (parent as NativeListView).mountContainerSlot(child, index)
+  }
+  override fun getChildCount(parent: ViewGroup): Int = (parent as NativeListView).containerSlotCount()
+  override fun getChildAt(parent: ViewGroup, index: Int): View = (parent as NativeListView).containerSlotAt(index)
+  override fun removeViewAt(parent: ViewGroup, index: Int) {
+    (parent as NativeListView).unmountContainerSlot(index)
+  }
+  override fun removeAllViews(parent: ViewGroup) {
+    while (getChildCount(parent) > 0) removeViewAt(parent, getChildCount(parent) - 1)
+  }
+
   override fun getName(): String {
     return "NativeList"
   }
 
-  override fun createViewInstance(reactContext: ThemedReactContext): View {
+  override fun createViewInstance(reactContext: ThemedReactContext): ViewGroup {
     val hybridView = HybridNativeList(reactContext)
-    val view = hybridView.view
+    val view = hybridView.view as ViewGroup
     view.setTag(associated_hybrid_view_tag, HybridViewHolder(hybridView))
     return view
   }
 
-  override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
+  override fun updateState(view: ViewGroup, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
     val holder = getHybridViewHolder(view)
       ?: throw Error("Couldn't find view $view in local views table!")
     val hybridView = holder.hybridView
@@ -63,14 +78,14 @@ public class HybridNativeListManager: SimpleViewManager<View>() {
     return super.updateState(view, props, newState)
   }
 
-  override fun onDropViewInstance(view: View) {
+  override fun onDropViewInstance(view: ViewGroup) {
     val holder = getHybridViewHolder(view)
     holder?.lastState = null
     holder?.hybridView?.onDropView()
     return super.onDropViewInstance(view)
   }
 
-  protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? {
+  protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: ViewGroup): ViewGroup? {
     val preparedView = super.prepareToRecycleView(reactContext, view)
       ?: return null
     val holder = getHybridViewHolder(preparedView)
@@ -84,13 +99,13 @@ public class HybridNativeListManager: SimpleViewManager<View>() {
       hybridView.prepareForRecycle()
 
       // Maybe update the view if it changed
-      return hybridView.view
+      return hybridView.view as ViewGroup
     } else {
       return null
     }
   }
 
-  private fun getHybridViewHolder(view: View): HybridViewHolder? {
+  private fun getHybridViewHolder(view: ViewGroup): HybridViewHolder? {
     return view.getTag(associated_hybrid_view_tag) as? HybridViewHolder
   }
 }

package/lib/nitrogen/generated/android/nativelistOnLoad.cpp

@@ -16,6 +16,7 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "JHybridNativeListSpec.hpp"
+#include "JFunc_void_bool.hpp"
 #include "JFunc_void_std__string.hpp"
 #include "views/JHybridNativeListStateUpdater.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
@@ -43,6 +44,7 @@ void registerAllNatives() {
 
   // Register native JNI methods
   margelo::nitro::nativelist::JHybridNativeListSpec::CxxPart::registerNatives();
+  margelo::nitro::nativelist::JFunc_void_bool_cxx::registerNatives();
   margelo::nitro::nativelist::JFunc_void_std__string_cxx::registerNatives();
   margelo::nitro::nativelist::views::JHybridNativeListStateUpdater::registerNatives();
 

package/lib/nitrogen/generated/ios/NativeListModule-Swift-Cxx-Bridge.cpp

@@ -14,6 +14,14 @@
 
 namespace margelo::nitro::nativelist::bridge::swift {
 
+  // pragma MARK: std::function<void(bool /* isBeyondThreshold */)>
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NativeListModule::Func_void_bool::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool isBeyondThreshold) mutable -> void {
+      swiftClosure.call(isBeyondThreshold);
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::string& /* payloadJson */)>
   Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = NativeListModule::Func_void_std__string::fromUnsafe(swiftClosureWrapper);

package/lib/nitrogen/generated/ios/NativeListModule-Swift-Cxx-Bridge.hpp

@@ -30,6 +30,43 @@ namespace NativeListModule { class HybridNativeListSpec_cxx; }
  */
 namespace margelo::nitro::nativelist::bridge::swift {
 
+  // pragma MARK: std::function<void(bool /* isBeyondThreshold */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* isBeyondThreshold */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * isBeyondThreshold * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* isBeyondThreshold */)>&& func): _function(std::make_unique<std::function<void(bool /* isBeyondThreshold */)>>(std::move(func))) {}
+    inline void call(bool isBeyondThreshold) const noexcept {
+      _function->operator()(isBeyondThreshold);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* isBeyondThreshold */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void(bool /* isBeyondThreshold */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(bool / * isBeyondThreshold * /)>>`.
+   */
+  using std__optional_std__function_void_bool____isBeyondThreshold______ = std::optional<std::function<void(bool /* isBeyondThreshold */)>>;
+  inline std::optional<std::function<void(bool /* isBeyondThreshold */)>> create_std__optional_std__function_void_bool____isBeyondThreshold______(const std::function<void(bool /* isBeyondThreshold */)>& value) noexcept {
+    return std::optional<std::function<void(bool /* isBeyondThreshold */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_bool____isBeyondThreshold______(const std::optional<std::function<void(bool /* isBeyondThreshold */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(bool /* isBeyondThreshold */)> get_std__optional_std__function_void_bool____isBeyondThreshold______(const std::optional<std::function<void(bool /* isBeyondThreshold */)>>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::function<void(const std::string& /* payloadJson */)>
   /**
    * Specialized version of `std::function<void(const std::string&)>`.

package/lib/nitrogen/generated/ios/c++/HybridNativeListSpecSwift.hpp

@@ -20,10 +20,10 @@ namespace margelo::nitro::nativelist { enum class NativeListKeyboardShouldPersis
 namespace margelo::nitro::nativelist { enum class NativeListScrollAlignment; }
 
 #include <string>
-#include "NativeListKeyboardDismissMode.hpp"
-#include "NativeListKeyboardShouldPersistTaps.hpp"
 #include <functional>
 #include <optional>
+#include "NativeListKeyboardDismissMode.hpp"
+#include "NativeListKeyboardShouldPersistTaps.hpp"
 #include "NativeListScrollAlignment.hpp"
 
 #include "NativeListModule-Swift-Cxx-Umbrella.hpp"
@@ -79,6 +79,27 @@ namespace margelo::nitro::nativelist {
     inline void setSnapshotJson(const std::string& snapshotJson) noexcept override {
       _swiftPart.setSnapshotJson(snapshotJson);
     }
+    inline std::string getContainerSlotHeightsJson() noexcept override {
+      auto __result = _swiftPart.getContainerSlotHeightsJson();
+      return __result;
+    }
+    inline void setContainerSlotHeightsJson(const std::string& containerSlotHeightsJson) noexcept override {
+      _swiftPart.setContainerSlotHeightsJson(containerSlotHeightsJson);
+    }
+    inline std::string getScrollPositionThresholdsJson() noexcept override {
+      auto __result = _swiftPart.getScrollPositionThresholdsJson();
+      return __result;
+    }
+    inline void setScrollPositionThresholdsJson(const std::string& scrollPositionThresholdsJson) noexcept override {
+      _swiftPart.setScrollPositionThresholdsJson(scrollPositionThresholdsJson);
+    }
+    inline std::optional<std::function<void(bool /* isBeyondThreshold */)>> getOnScrollPositionThresholdChange() noexcept override {
+      auto __result = _swiftPart.getOnScrollPositionThresholdChange();
+      return __result;
+    }
+    inline void setOnScrollPositionThresholdChange(const std::optional<std::function<void(bool /* isBeyondThreshold */)>>& onScrollPositionThresholdChange) noexcept override {
+      _swiftPart.setOnScrollPositionThresholdChange(onScrollPositionThresholdChange);
+    }
     inline NativeListKeyboardDismissMode getKeyboardDismissMode() noexcept override {
       auto __result = _swiftPart.getKeyboardDismissMode();
       return static_cast<NativeListKeyboardDismissMode>(__result);