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

package/ios/RNCNativeListView.swift

@@ -4,6 +4,54 @@ import UIKit
 import UniformTypeIdentifiers
 
 final class NativeListView: UIView {
+  private var refreshEmittedForDrag = false
+  private var minimumDragOffset: CGFloat = 0
+  private var reactContainerSlots: [UIView] = []
+  private var containerSlotHeights: [CGFloat] = [0, 0, 0]
+  private var lastLaidOutContentHeight: CGFloat?
+  private var needsContentShrinkCorrection = false
+  private var contentShrinkCorrectionScheduled = false
+
+  @objc func mountContainerSlot(_ view: UIView, atIndex index: Int) {
+    reactContainerSlots.insert(view, at: min(index, reactContainerSlots.count))
+    collectionView.addSubview(view)
+    setNeedsLayout()
+  }
+
+  @objc func unmountContainerSlot(_ view: UIView) {
+    reactContainerSlots.removeAll { $0 === view }
+    view.removeFromSuperview()
+  }
+
+  func setContainerSlotHeightsJson(_ json: String) {
+    guard let data = json.data(using: .utf8),
+          let heights = try? JSONSerialization.jsonObject(with: data) as? [Double],
+          heights.count == 3, heights.allSatisfy({ $0.isFinite && $0 >= 0 }) else { return }
+    containerSlotHeights = heights.map { CGFloat($0) }
+    if let config { configureLayout(config) }
+    setNeedsLayout()
+  }
+
+  private func layoutContainerSlots() {
+    guard reactContainerSlots.count == 3 else { return }
+    let empty = config?.items.isEmpty ?? true
+    let header = containerSlotHeights[0]
+    let emptyHeight = empty ? containerSlotHeights[1] : 0
+    let footer = containerSlotHeights[2]
+    let paddingTop = config?.contentPaddingTop ?? 0
+    let paddingBottom = config?.contentPaddingBottom ?? 0
+    let footerY = max(paddingTop + header + emptyHeight,
+      collectionView.contentSize.height - paddingBottom - footer)
+    let positions = [paddingTop, paddingTop + header, footerY]
+    for (index, view) in reactContainerSlots.enumerated() {
+      view.isHidden = index == 1 && !empty
+      let horizontalPadding = config?.contentPaddingHorizontal ?? 0
+      view.frame = CGRect(x: horizontalPadding, y: positions[index],
+        width: max(0, collectionView.bounds.width - horizontalPadding * 2),
+        height: containerSlotHeights[index])
+    }
+  }
+
   private final class ActionAnchorRecord {
     let token: String
     weak var sourceView: UIView?
@@ -47,6 +95,26 @@ final class NativeListView: UIView {
     case end(Bool)
   }
 
+  private var scrollPositionTracker = NativeListScrollPositionTracker()
+  var onScrollPositionThresholdChange: ((Bool) -> Void)? {
+    didSet {
+      scrollPositionTracker.resetDelivery()
+      emitScrollPositionThresholdIfNeeded()
+    }
+  }
+
+  func setScrollPositionThresholdsJson(_ json: String) {
+    scrollPositionTracker.configure(json: json)
+    emitScrollPositionThresholdIfNeeded()
+  }
+
+  private func emitScrollPositionThresholdIfNeeded() {
+    guard let callback = onScrollPositionThresholdChange,
+          let next = scrollPositionTracker.update(offset: Double(max(0,
+            collectionView.contentOffset.y + collectionView.contentInset.top))) else { return }
+    callback(next)
+  }
+
   var onRowAction: ((String) -> Void)?
   var onActionAnchorInvalidated: ((String) -> Void)?
   var onSelectionDelta: ((String) -> Void)?
@@ -60,7 +128,14 @@ final class NativeListView: UIView {
   }
 
   private let flowLayout = NativeListFlowLayout()
-  private lazy var collectionView = NativeListCollectionView(frame: .zero, collectionViewLayout: flowLayout)
+  private lazy var collectionView: NativeListCollectionView = {
+    let view = NativeListCollectionView(frame: .zero, collectionViewLayout: flowLayout)
+    view.onContentLayout = { [weak self] in
+      self?.layoutContainerSlots()
+      self?.contentLayoutDidChange()
+    }
+    return view
+  }()
   private let footerContainer = UIView()
   private var footerCell: NativeListRowHost = NativeListRendererRegistry.create(.action)
   private var footerRendererKey = NativeListRendererKey.action
@@ -333,6 +408,7 @@ final class NativeListView: UIView {
       rebindRowsForLayoutDirection(config)
     }
     performPendingScrollIfNeeded()
+    layoutContainerSlots()
   }
 
   // A layout-direction change may arrive without a layout pass (semantic attribute or trait).
@@ -673,6 +749,39 @@ final class NativeListView: UIView {
     collectionView.setContentOffset(point, animated: animated)
   }
 
+  private func contentLayoutDidChange() {
+    let height = collectionView.contentSize.height
+    if config?.orientation != "horizontal",
+       let previous = lastLaidOutContentHeight, height < previous {
+      needsContentShrinkCorrection = true
+    }
+    lastLaidOutContentHeight = height
+    scheduleContentShrinkCorrection()
+  }
+
+  private func scheduleContentShrinkCorrection() {
+    guard needsContentShrinkCorrection, !contentShrinkCorrectionScheduled, !disposed else { return }
+    contentShrinkCorrectionScheduled = true
+    // Wait for the collection layout and ancestor pager inset observers to settle.
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+      self.contentShrinkCorrectionScheduled = false
+      guard !self.disposed, self.needsContentShrinkCorrection,
+            !self.collectionView.isTracking, !self.collectionView.isDragging,
+            !self.collectionView.isDecelerating,
+            self.collectionView.refreshControl?.isRefreshing != true,
+            self.config?.refreshing != true else { return }
+      self.needsContentShrinkCorrection = false
+      guard self.config?.orientation != "horizontal", self.collectionView.bounds.height > 0 else { return }
+      let insets = self.collectionView.adjustedContentInset
+      let maximum = max(-insets.top,
+        self.collectionView.contentSize.height - self.collectionView.bounds.height + insets.bottom)
+      if self.collectionView.contentOffset.y > maximum {
+        self.setScrollOffset(self.collectionView.contentOffset.y, animated: false)
+      }
+    }
+  }
+
   func setRefreshing(_ refreshing: Bool) {
     guard var current = config else { return }
     current.refreshing = refreshing
@@ -681,6 +790,7 @@ final class NativeListView: UIView {
       collectionView.refreshControl?.beginRefreshing()
     } else {
       collectionView.refreshControl?.endRefreshing()
+      scheduleContentShrinkCorrection()
     }
   }
 
@@ -693,11 +803,14 @@ final class NativeListView: UIView {
     flowLayout.minimumLineSpacing = config.itemSpacing
     flowLayout.minimumInteritemSpacing = config.itemSpacing
     flowLayout.sectionInset = UIEdgeInsets(
-      top: config.contentPaddingTop,
+      top: config.contentPaddingTop + containerSlotHeights[0],
       left: config.contentPaddingHorizontal + (isRightToLeft ? indexGutter : 0),
-      bottom: config.contentPaddingBottom,
+      bottom: config.contentPaddingBottom + containerSlotHeights[2],
       right: config.contentPaddingHorizontal + (isRightToLeft ? 0 : indexGutter)
     )
+    flowLayout.minimumContainerContentHeight = config.items.isEmpty
+      ? config.contentPaddingTop + config.contentPaddingBottom + containerSlotHeights.reduce(0, +)
+      : 0
     flowLayout.stickyItemIndexes = config.stickyHeaders
       ? Set(config.items.enumerated().compactMap {
           $0.element.type == "sectionHeader" && $0.element.data.bool("sticky", default: true) && $0.element.data.string("variant") != "summary"
@@ -1347,6 +1460,7 @@ final class NativeListView: UIView {
     } else {
       collectionView.refreshControl = nil
     }
+    if !config.refreshing { scheduleContentShrinkCorrection() }
   }
 
   private func configureFooter(_ config: NativeListConfig) {
@@ -1539,6 +1653,7 @@ final class NativeListView: UIView {
           current.rowPressToggles == next.rowPressToggles,
           current.reorderable == next.reorderable,
           current.pullToRefresh == next.pullToRefresh,
+          current.refreshTriggerDistance == next.refreshTriggerDistance,
           current.refreshing == next.refreshing,
           current.loadMore == next.loadMore,
           current.endReachedThreshold == next.endReachedThreshold,
@@ -1849,6 +1964,8 @@ final class NativeListView: UIView {
     itemsByKey.removeAll()
     sectionIndexEntries.removeAll()
     pendingScrollRequest = nil
+    needsContentShrinkCorrection = false
+    lastLaidOutContentHeight = nil
     lastVisibleRange = nil
     onRowAction = nil
     onActionAnchorInvalidated = nil
@@ -1856,6 +1973,7 @@ final class NativeListView: UIView {
     onReorder = nil
     onEndReached = nil
     onVisibleRangeChanged = nil
+    onScrollPositionThresholdChange = nil
   }
 
   private func createActionAnchor(origin: NativeListActionOrigin) -> [String: Any]? {
@@ -1921,6 +2039,9 @@ final class NativeListView: UIView {
   }
 
   @objc private func refreshTriggered() {
+    guard !disposed, config?.pullToRefresh == true,
+          config?.refreshing != true, !refreshEmittedForDrag else { return }
+    refreshEmittedForDrag = true
     emit(onRowAction, ["actionKey": "nativeList.refresh"])
   }
 
@@ -2142,7 +2263,31 @@ extension NativeListView: UICollectionViewDelegateFlowLayout {
     return item.isRowPressEnabled
   }
 
+  func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
+    minimumDragOffset = 0
+    refreshEmittedForDrag = false
+  }
+
+  func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
+    defer { if !decelerate { scheduleContentShrinkCorrection() } }
+    minimumDragOffset = min(minimumDragOffset, scrollView.contentOffset.y + scrollView.contentInset.top)
+    guard let threshold = config?.refreshTriggerDistance,
+          config?.pullToRefresh == true, config?.refreshing != true,
+          minimumDragOffset <= -threshold, !refreshEmittedForDrag else { return }
+    collectionView.refreshControl?.beginRefreshing()
+    refreshTriggered()
+  }
+
+  func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
+    scheduleContentShrinkCorrection()
+  }
+
   func scrollViewDidScroll(_ scrollView: UIScrollView) {
+    if scrollView.isDragging {
+      minimumDragOffset = min(minimumDragOffset, scrollView.contentOffset.y + scrollView.contentInset.top)
+    }
+    layoutContainerSlots()
+    emitScrollPositionThresholdIfNeeded()
     invalidateActionAnchor(reason: "scroll")
     syncSectionIndexToVisibleRows()
     emitVisibleRangeIfNeeded()
@@ -2205,6 +2350,13 @@ extension NativeListView: UICollectionViewDragDelegate, UICollectionViewDropDele
 // quick tap highlighted and unhighlighted a row within one frame and the pressed background never
 // rendered. Deliver touches immediately, as Android rows do.
 private final class NativeListCollectionView: UICollectionView {
+  var onContentLayout: (() -> Void)?
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    onContentLayout?()
+  }
+
   override init(frame: CGRect, collectionViewLayout layout: UICollectionViewLayout) {
     super.init(frame: frame, collectionViewLayout: layout)
     delaysContentTouches = false
@@ -2223,6 +2375,7 @@ private final class NativeListCollectionView: UICollectionView {
 
 final class NativeListFlowLayout: UICollectionViewFlowLayout {
   var stickyItemIndexes: Set<Int> = []
+  var minimumContainerContentHeight: CGFloat = 0
   private var horizontalAttributes: [IndexPath: UICollectionViewLayoutAttributes] = [:]
   private var horizontalContentSize: CGSize = .zero
 
@@ -2251,7 +2404,9 @@ final class NativeListFlowLayout: UICollectionViewFlowLayout {
   }
 
   override var collectionViewContentSize: CGSize {
-    scrollDirection == .horizontal ? horizontalContentSize : super.collectionViewContentSize
+    if scrollDirection == .horizontal { return horizontalContentSize }
+    let size = super.collectionViewContentSize
+    return CGSize(width: size.width, height: max(size.height, minimumContainerContentHeight))
   }
 
   override func shouldInvalidateLayout(forBoundsChange newBounds: CGRect) -> Bool {

package/ios/tests/NativeListActivityPresentationTests.swift

@@ -0,0 +1,43 @@
+import UIKit
+import XCTest
+@testable import NativeListModule
+
+@MainActor
+final class NativeListActivityPresentationTests: XCTestCase {
+  func testSmallNumberRunsPreserveBaselineAcrossAmountsFiatAndFee() throws {
+    func segments(_ prefix: String, _ suffix: String) -> [[String: Any]] {
+      [["text": prefix], ["text": "5", "style": "subscript"], ["text": suffix]]
+    }
+    let item = try NativeListItem(data: [
+      "type": "activity", "key": "transfer", "title": "Transfer",
+      "leading": ["kind": "icon", "name": "ArrowTopOutline"],
+      "amounts": [[
+        "key": "receive", "text": "0.051 ETH", "textSegments": segments("0.0", "1 ETH"),
+        "secondaryText": "$0.051", "secondaryTextSegments": segments("$0.0", "1"),
+      ]],
+      "fee": [
+        "primary": "0.051 GAS", "primaryTextSegments": segments("0.0", "1 GAS"),
+        "secondary": "€0.051", "secondaryTextSegments": segments("€0.0", "1"),
+      ],
+    ])
+    let view = NativeListActivityDetailsView()
+    view.bind(item, theme: nil)
+    func labels(in view: UIView) -> [UILabel] {
+      (view as? UILabel).map { [$0] } ?? view.subviews.flatMap { labels(in: $0) }
+    }
+    let cases: [(String, Int, CGFloat)] = [
+      ("0.051 ETH", 3, 16), ("$0.051", 4, 14),
+      ("0.051 GAS", 3, 14), ("€0.051", 4, 12),
+    ]
+    let rendered = labels(in: view)
+    for (text, countIndex, parentSize) in cases {
+      let label = try XCTUnwrap(rendered.first { $0.attributedText?.string == text })
+      let value = try XCTUnwrap(label.attributedText)
+      let font = try XCTUnwrap(value.attribute(.font, at: countIndex, effectiveRange: nil) as? UIFont)
+      XCTAssertEqual(font.pointSize, ceil(parentSize * 0.6))
+      let baseline = value.attribute(.baselineOffset, at: 0, effectiveRange: nil) as? NSNumber
+      let countBaseline = value.attribute(.baselineOffset, at: countIndex, effectiveRange: nil) as? NSNumber
+      XCTAssertEqual(countBaseline?.doubleValue ?? 0, baseline?.doubleValue ?? 0)
+    }
+  }
+}

package/ios/tests/NativeListLifecycleTests.swift

@@ -4,6 +4,42 @@ import XCTest
 
 @MainActor
 final class NativeListLifecycleTests: XCTestCase {
+  func testSectionLoadingStopsOnRebindReuseAndDetach() throws {
+    let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 320, height: 480))
+    let controller = UIViewController()
+    window.rootViewController = controller
+    window.isHidden = false
+    defer { window.isHidden = true }
+    let cell = NativeListSectionHeaderCell(frame: CGRect(x: 0, y: 0, width: 320, height: 40))
+    controller.view.addSubview(cell)
+    func bind(loading: Bool) throws {
+      let item = try NativeListItem(data: [
+        "key": "section", "type": "sectionHeader", "sectionKey": "pending",
+        "title": "Confirming", "variant": "history", "titleLoading": loading,
+        "style": ["title": ["color": "#FFAA00"]],
+      ])
+      cell.bind(item: item, theme: nil, layout: "sectioned", selected: false,
+                checkboxState: { _, _, fallback in fallback })
+    }
+    try bind(loading: true)
+    let spinner = try XCTUnwrap(cell.root.arrangedSubviews.first as? UIActivityIndicatorView)
+    XCTAssertTrue(spinner.isAnimating)
+    XCTAssertFalse(spinner.isAccessibilityElement)
+    XCTAssertEqual(spinner.color, UIColor(nativeListHex: "#FFAA00", fallback: .clear))
+
+    try bind(loading: false)
+    XCTAssertFalse(spinner.isAnimating)
+    XCTAssertNil(spinner.superview)
+    try bind(loading: true)
+    XCTAssertTrue(spinner.isAnimating)
+    cell.removeFromSuperview()
+    XCTAssertFalse(spinner.isAnimating)
+    controller.view.addSubview(cell)
+    XCTAssertTrue(spinner.isAnimating)
+    cell.prepareForReuse()
+    XCTAssertFalse(spinner.isAnimating)
+  }
+
   func testRebindingAndReuseInvalidateThePreviousActionEpoch() throws {
     let cell = NativeListActionCell(frame: CGRect(x: 0, y: 0, width: 320, height: 60))
     let first = try NativeListItem(data: ["key": "row", "type": "action", "title": "First"])
@@ -82,6 +118,93 @@ final class NativeListLifecycleTests: XCTestCase {
     return String(decoding: data, as: UTF8.self)
   }
 
+  func testContentShrinkCorrectsRestoredOffsetAfterPagerInsetsAndUpdatesObserver() throws {
+    let view = try makeScrollingList()
+    let list = try XCTUnwrap(view.subviews.compactMap { $0 as? UICollectionView }.first)
+    list.contentInset = UIEdgeInsets(top: 108, left: 0, bottom: 0, right: 0)
+    list.contentOffset.y = 600
+    var savedLogicalOffset = list.contentOffset.y + list.contentInset.top
+    let offsetObserver = list.observe(\.contentOffset, options: [.new]) { list, _ in
+      savedLogicalOffset = list.contentOffset.y + list.contentInset.top
+    }
+    // Model the pager's synchronous content-size observer and cached-offset restoration.
+    let sizeObserver = list.observe(\.contentSize, options: [.old, .new]) { list, change in
+      if change.oldValue != change.newValue, list.contentSize.height < 200 {
+        list.contentInset.bottom = max(0, list.bounds.height - 44 - list.contentSize.height)
+        list.contentOffset.y = 600
+      }
+    }
+    view.applySnapshotJson(try scrollingSnapshot(count: 0))
+    view.layoutIfNeeded()
+    list.layoutIfNeeded()
+    drainMainQueue()
+    XCTAssertEqual(list.contentSize.height, 132, accuracy: 0.5)
+    XCTAssertEqual(list.contentOffset.y, -44, accuracy: 0.5)
+    XCTAssertEqual(savedLogicalOffset, 64, accuracy: 0.5)
+    withExtendedLifetime((offsetObserver, sizeObserver)) {}
+  }
+
+  func testContentShrinkPreservesInRangeAndNegativePullOffsets() throws {
+    for offset in [CGFloat(120), CGFloat(-160)] {
+      let view = try makeScrollingList()
+      let list = try XCTUnwrap(view.subviews.compactMap { $0 as? UICollectionView }.first)
+      list.contentInset.top = 108
+      view.applySnapshotJson(try scrollingSnapshot(count: 20))
+      view.layoutIfNeeded()
+      list.layoutIfNeeded()
+      // Preserve a valid offset or a refresh pull while shrink correction is queued.
+      list.contentOffset.y = offset
+      drainMainQueue()
+      XCTAssertEqual(list.contentOffset.y, offset, accuracy: 0.5)
+    }
+  }
+
+  func testContentShrinkWaitsForRefreshCompletion() throws {
+    let view = try makeScrollingList()
+    let list = try XCTUnwrap(view.subviews.compactMap { $0 as? UICollectionView }.first)
+    view.applySnapshotJson(try scrollingSnapshot(count: 0, refreshing: true))
+    view.layoutIfNeeded()
+    list.layoutIfNeeded()
+    list.contentOffset.y = 600
+    drainMainQueue()
+    XCTAssertEqual(list.contentOffset.y, 600, accuracy: 0.5)
+    view.setRefreshing(false)
+    drainMainQueue()
+    let inset = list.adjustedContentInset
+    let maximum = max(-inset.top, list.contentSize.height - list.bounds.height + inset.bottom)
+    XCTAssertEqual(list.contentOffset.y, maximum, accuracy: 0.5)
+  }
+
+  private func makeScrollingList() throws -> NativeListView {
+    let view = NativeListView(frame: CGRect(x: 0, y: 0, width: 320, height: 708))
+    for index in 0..<3 { view.mountContainerSlot(UIView(), atIndex: index) }
+    view.setContainerSlotHeightsJson("[44,44,44]")
+    view.applySnapshotJson(try scrollingSnapshot(count: 40))
+    view.layoutIfNeeded()
+    let list = try XCTUnwrap(view.subviews.compactMap { $0 as? UICollectionView }.first)
+    list.layoutIfNeeded()
+    drainMainQueue()
+    return view
+  }
+
+  private func scrollingSnapshot(count: Int, refreshing: Bool = false) throws -> String {
+    let rows: [[String: Any]] = (0..<count).map {
+      ["key": "row-\($0)", "type": "action", "title": "Row", "height": 80]
+    }
+    let value: [String: Any] = [
+      "schemaVersion": 1, "generation": count + 1,
+      "layout": ["kind": "linear"], "rows": rows,
+      "capabilities": ["pullToRefresh": true, "refreshing": refreshing],
+    ]
+    return String(decoding: try JSONSerialization.data(withJSONObject: value), as: UTF8.self)
+  }
+
+  private func drainMainQueue() {
+    let settled = expectation(description: "Deferred content shrink correction")
+    DispatchQueue.main.async { settled.fulfill() }
+    wait(for: [settled], timeout: 1)
+  }
+
   private func footerCell(in view: NativeListView) -> NativeListRowHost? {
     view.subviews.lazy.compactMap { container in
       container.subviews.compactMap { $0 as? NativeListRowHost }.first

package/ios/tests/NativeListMediaVisibilityTests.swift

@@ -0,0 +1,42 @@
+import UIKit
+import XCTest
+@testable import NativeListModule
+
+@MainActor
+final class NativeListMediaVisibilityTests: XCTestCase {
+  func testRetainedPagerAndListCellsRequireViewportIntersection() {
+    let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 320, height: 480))
+    let controller = UIViewController()
+    window.rootViewController = controller
+    window.isHidden = false
+    defer { window.isHidden = true }
+    let pager = UIScrollView(frame: CGRect(x: 0, y: 0, width: 320, height: 480))
+    pager.contentSize = CGSize(width: 640, height: 480)
+    controller.view.addSubview(pager)
+    let list = UIScrollView(frame: CGRect(x: 320, y: 0, width: 320, height: 480))
+    list.contentSize = CGSize(width: 320, height: 960)
+    pager.addSubview(list)
+    let tile = UIView(frame: CGRect(x: 10, y: 10, width: 100, height: 100))
+    list.addSubview(tile)
+
+    XCTAssertNotNil(tile.window, "Pager retains the offscreen cell in the window")
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    pager.contentOffset.x = 320
+    XCTAssertTrue(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.contentOffset.y = 110
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.contentOffset.y = 100
+    XCTAssertTrue(NativeListMediaPreviewSlot.intersectsViewport(tile), "Partially visible previews remain eligible")
+    list.transform = CGAffineTransform(translationX: 320, y: 0)
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.transform = .identity
+    XCTAssertTrue(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.isHidden = true
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    list.isHidden = false
+    list.alpha = 0
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+    tile.removeFromSuperview()
+    XCTAssertFalse(NativeListMediaPreviewSlot.intersectsViewport(tile))
+  }
+}

package/ios/tests/NativeListScrollPositionTrackerTests.swift

@@ -0,0 +1,25 @@
+import XCTest
+@testable import NativeListModule
+
+final class NativeListScrollPositionTrackerTests: XCTestCase {
+  func testHysteresisAndDisabledLifecycle() {
+    var tracker = NativeListScrollPositionTracker()
+    XCTAssertNil(tracker.update(offset: 200))
+    tracker.configure(json: "{\"start\":48,\"end\":160}")
+    XCTAssertEqual(tracker.update(offset: 0), false)
+    XCTAssertNil(tracker.update(offset: 159))
+    XCTAssertEqual(tracker.update(offset: 160), true)
+    XCTAssertNil(tracker.update(offset: 100))
+    XCTAssertEqual(tracker.update(offset: 48), false)
+    XCTAssertNil(tracker.update(offset: 49))
+    tracker.configure(json: "")
+    XCTAssertNil(tracker.update(offset: 200))
+    tracker.configure(json: "{\"start\":48,\"end\":160}")
+    XCTAssertEqual(tracker.update(offset: 200), true)
+    tracker.resetDelivery()
+    XCTAssertEqual(tracker.update(offset: 200), true)
+    XCTAssertNil(tracker.update(offset: .nan))
+    tracker.configure(json: "{\"start\":48,\"end\":48}")
+    XCTAssertNil(tracker.update(offset: 48))
+  }
+}

package/lib/module/NativeList.js

@@ -1,8 +1,9 @@
 "use strict";
 
-import React, { forwardRef, useEffect, useImperativeHandle, useMemo, useRef } from 'react';
+import React, { forwardRef, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
 import { OneKeyImageCache, OneKeyImageCachePolicy } from '@onekeyfe/react-native-image';
 import { NativeAvatarPrefetchModel, NativeAvatarPrefetchQueue } from "./avatarPrefetch.js";
+import { View } from 'react-native';
 import { callback, getHostComponent } from 'react-native-nitro-modules';
 import { isSelectableRow } from "./selection.js";
 import { normalizeIndexScroll, normalizeKeyScroll, normalizePositionScroll, resolveLocationIndex, scrollFailure, validateOffset } from "./scrolling.js";
@@ -26,6 +27,10 @@ function parsePayload(payloadJson) {
 }
 export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   snapshot,
+  listHeader,
+  listFooter,
+  listEmpty,
+  scrollPositionThresholds,
   webVirtualizationEnabled: _webVirtualizationEnabled,
   webSectionIndexContainerRef: _webSectionIndexContainerRef,
   keyboardDismissMode = 'none',
@@ -36,6 +41,7 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   onReorder,
   onEndReached,
   onVisibleRangeChanged,
+  onScrollPositionThresholdChange,
   onRefresh,
   onScrollToIndexFailed,
   initialScrollIndex,
@@ -44,6 +50,13 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   initialScrollViewOffset,
   ...viewProps
 }, forwardedRef) {
+  const [slotHeights, setSlotHeights] = useState([0, 0, 0]);
+  const containerSlotHeightsJson = JSON.stringify(slotHeights);
+  const slotInset = snapshot.layout.contentPaddingHorizontal ?? snapshot.layout.contentPadding ?? 0;
+  if (snapshot.layout.orientation === 'horizontal' && (listHeader || listEmpty || listFooter)) {
+    throw new Error('NativeList container slots require vertical orientation');
+  }
+  const slotContents = [listHeader, listEmpty, listFooter];
   const normalizedKeyboardShouldPersistTaps = keyboardShouldPersistTaps === true ? 'always' : keyboardShouldPersistTaps === false ? 'never' : keyboardShouldPersistTaps;
   const nativeRef = useRef(null);
   const callbacksRef = useRef({
@@ -53,6 +66,7 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     onReorder,
     onEndReached,
     onVisibleRangeChanged,
+    onScrollPositionThresholdChange,
     onRefresh,
     onScrollToIndexFailed
   });
@@ -63,9 +77,24 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     onReorder,
     onEndReached,
     onVisibleRangeChanged,
+    onScrollPositionThresholdChange,
     onRefresh,
     onScrollToIndexFailed
   };
+  const scrollPositionThresholdsJson = useMemo(() => {
+    if (!scrollPositionThresholds || scrollPositionThresholds.enabled === false) return '';
+    const {
+      start,
+      end
+    } = scrollPositionThresholds;
+    if (!Number.isFinite(start) || !Number.isFinite(end) || start < 0 || end <= start) {
+      throw new Error('scrollPositionThresholds requires 0 <= start < end and finite values');
+    }
+    return JSON.stringify({
+      start,
+      end
+    });
+  }, [scrollPositionThresholds]);
   const snapshotJson = useMemo(() => serializeSnapshot(snapshot), [snapshot]);
   const snapshotRef = useRef(snapshot);
   const previousSnapshotJsonRef = useRef(snapshotJson);
@@ -235,7 +264,10 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     }),
     onRowAction: callback(payloadJson => {
       const payload = parsePayload(payloadJson);
-      if (payload.actionKey === 'nativeList.refresh') callbacksRef.current.onRefresh?.();
+      if (payload.actionKey === 'nativeList.refresh' && payload.rowKey === undefined) {
+        callbacksRef.current.onRefresh?.();
+        return;
+      }
       callbacksRef.current.onRowAction?.(payload);
     }),
     onActionAnchorInvalidated: callback(payloadJson => {
@@ -264,6 +296,11 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     onEndReached: callback(payloadJson => {
       callbacksRef.current.onEndReached?.(parsePayload(payloadJson));
     }),
+    onScrollPositionThresholdChange: callback(isBeyondThreshold => {
+      callbacksRef.current.onScrollPositionThresholdChange?.({
+        isBeyondThreshold
+      });
+    }),
     onVisibleRangeChanged: callback(payloadJson => {
       const payload = parsePayload(payloadJson);
       const previous = avatarRangeRef.current;
@@ -280,8 +317,24 @@ export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
     ...viewProps,
     ...nativeCallbacks,
     snapshotJson: snapshotJson,
+    containerSlotHeightsJson: containerSlotHeightsJson,
+    scrollPositionThresholdsJson: scrollPositionThresholdsJson,
     keyboardDismissMode: keyboardDismissMode,
-    keyboardShouldPersistTaps: normalizedKeyboardShouldPersistTaps
+    keyboardShouldPersistTaps: normalizedKeyboardShouldPersistTaps,
+    children: slotContents.map((content, index) => /*#__PURE__*/_jsx(View, {
+      collapsable: false,
+      style: {
+        position: 'absolute',
+        left: slotInset,
+        right: slotInset,
+        top: 0
+      },
+      onLayout: event => {
+        const height = Math.ceil(event.nativeEvent.layout.height);
+        setSlotHeights(previous => previous[index] === height ? previous : previous.map((value, slot) => slot === index ? height : value));
+      },
+      children: content
+    }, index))
   });
 });
 //# sourceMappingURL=NativeList.js.map

package/lib/module/NativeList.web.js

@@ -22,6 +22,11 @@ export function preloadNativeListAvatarImages(sources) {
 }
 export const NativeList = /*#__PURE__*/forwardRef(function NativeList({
   snapshot,
+  listHeader: _listHeader,
+  listEmpty: _listEmpty,
+  listFooter: _listFooter,
+  scrollPositionThresholds: _scrollPositionThresholds,
+  onScrollPositionThresholdChange: _onScrollPositionThresholdChange,
   webVirtualizationEnabled = true,
   webSectionIndexContainerRef,
   keyboardDismissMode: _keyboardDismissMode,