@onekeyfe/react-native-native-list 3.0.157-alpha.253 → 3.0.157-alpha.255

package/docs/ROW_TEMPLATES.md

@@ -143,6 +143,26 @@ separately from source implementation in STYLE_SPEC §9.
 - **Common-capability boundary:** `footerActions` are inside this activity row.
   The list footer is independently configured through the container.
 
+- **Native rich amounts:** optional `amounts` replaces the legacy two strings,
+  with at most 32 unique keyed entries. Each entry supports a leading visual,
+  tone, primary/secondary text and subscript segments. The title supports at
+  most four keyed badges. `descriptionActionKey` emits a description action.
+  `presentation: 'table'` allocates equal identity/amount columns and an
+  optional fee column; `stacked` keeps right-aligned amounts beside identity.
+  `fee.hidden` reserves its column while hiding its content. These native
+  additions do not change the Web renderer.
+
+```text
+stacked (phone)                     table (wide)
+┌────┬────────────────┬───────────┐  ┌────┬────────────┬────────────┬─────────┐
+│icon│title + badges  │amount 1   │  │icon│title/badges│amount 1    │fee label│
+│    │description ↗   │secondary  │  │    │description │secondary   │fee/fiat │
+│    │status          │amount 2…  │  │    │status      │amount 2…   │         │
+├────┴────────────────┴───────────┤  ├────┴────────────┴────────────┴─────────┤
+│     optional row action buttons│  │     optional row action buttons       │
+└────────────────────────────────┘  └───────────────────────────────────────┘
+```
+
 ## message
 
 ![Message: title and timestamp over body text, with optional leading visual and thumbnail](images/row-message.svg)
@@ -225,6 +245,19 @@ separately from source implementation in STYLE_SPEC §9.
 - **Use:** a gallery tile or browser preview.
 - **Required data:** `variant: gallery | browserPreview`, `title`. Optional
   image/image-state, subtitle, badge, network image and close-action key.
+- **Native media preview:** optional `media: { source: ImageSource, probeOrder }`
+  supplies one or two distinct `image`/`video` candidates. It takes precedence
+  over `image`; explicit `imageState: empty | error` still suppresses loading.
+  A video candidate uses a muted paused native player, with no playback/controls or
+  touch target. Detail playback remains caller-owned. Failure advances once to
+  the next candidate, then displays the standard error placeholder. The same
+  media box and caption diagram apply; this adds no new layout region.
+  Web keeps the existing `image` field and does not execute media probing.
+- **Native lifetime:** request identity includes row key, full source, fit,
+  placeholder and probe order. Rebinding only text preserves the preview;
+  changed identity or recycle cancels work and rejects late callbacks. Frame
+  loading owns at most one player per attached tile. Detach/background/recycle
+  releases player resources; no autoplay, audio focus or NativeList disk cache.
 - **Text style roles:** `title`, `subtitle`, `badge`.
 - **Layout boundary:** media stays above caption metadata; network/close/badge
   overlays keep their template anchors. A text style cannot change the grid
@@ -256,6 +289,18 @@ separately from source implementation in STYLE_SPEC §9.
 
 ## sectionHeader
 
+Native-only optional title loading presentation (`titleLoading: true`):
+
+```text
+┌────────────────────────────────────────────────────────────┐
+│ [spinner 20pt]  Title                         Value/control │
+└────────────────────────────────────────────────────────────┘
+```
+
+The spinner inherits the resolved title color, has an 8-point trailing gap,
+and stops/disappears when loading clears or the row is recycled. It is section
+chrome and emits no row action. Omission preserves existing rendering.
+
 ![Section header: title/subtitle and optional summary value, help or selection control](images/row-section-header.svg)
 
 - **Use:** a structural section heading or list summary, independent of the

package/docs/SPEC.md

@@ -7,7 +7,8 @@ architecture and runtime evidence.
 ## Purpose and non-goals
 
 NativeList renders bounded data with fixed row templates on iOS, Android and
-Web. It does not render arbitrary React children. Integrators own overflow
+Web. Data rows do not render arbitrary React children. Native-only named container slots
+may render React chrome outside the data-row stream. Integrators own overflow
 prevention; there is no automatic fitting or shrinking pass.
 
 ## Definitions and ownership
@@ -52,6 +53,23 @@ image that already loaded. Common container styling clears what it wrote on the
 next bind, including properties it set on template children. UI mutation remains on the platform
 UI thread; [DESIGN.md](DESIGN.md) describes update and event ownership.
 
+### Native section title loading indicator
+
+Status: implemented source; simulator rendering acceptance pending.
+On iOS and Android, `sectionHeader.titleLoading` defaults to `false`. When
+`true`, a 20-point native indeterminate indicator precedes the section heading
+with an 8-point gap and inherits the resolved title color. It emits no action
+and does not create a separate accessibility target. Clearing the field, full
+rebind, recycling and disposal stop and hide the indicator; detached native views do
+not keep a visible animation. The History template's minimum content height
+increases from 16 to 20 points while loading. Explicit caller row/container
+heights still take precedence and must fit their padding. Web does not render
+this new native-only indicator; its existing section presentation is unchanged.
+
+Acceptance requires loading → idle → loading reuse, title color updates and
+detachment on each native platform. A title's localized confirming text remains
+caller-owned; the renderer does not infer transaction status.
+
 ## Data, cache and identity
 
 `row.key` identifies data; renderer reuse identity describes compatible view
@@ -356,3 +374,211 @@ audit; they are not new in this change.
   templates to 12 on native; Web defaults to 0 (STYLE_SPEC §6.2).
 - **DataRow linear layout.** See ROW_TEMPLATES.md: native unstyled linear rows
   keep the legacy single-label column.
+
+## Native scroll-position thresholds and tablet grids
+
+Status: Source implemented; native runtime acceptance pending. These additions are native
+only. Existing Web rendering and caller behavior are unchanged.
+
+- `scrollPositionThresholds?: { start: number; end: number; enabled?: boolean }`
+  observes the list's logical distance from its content start, in logical pixels.
+  `start` and `end` must be finite, nonnegative, and `start < end`. Omitted or
+  `enabled: false` disables observation.
+- `onScrollPositionThresholdChange({ isBeyondThreshold })` reports initial state
+  after enabling/configuration changes, then only hysteresis transitions: enter
+  when distance >= end, leave when distance <= start. No per-frame JS events.
+  Replacing the JS callback takes effect on the next event; disabling emits no event.
+  Configuration updates reset hysteresis before recomputing current position.
+- iOS uses contentOffset + contentInset, excluding overscroll below zero. Android
+  accumulates consumed child scroll distance and rebases from first-item geometry.
+  Parent-pager header contributions and arbitrary index-jump acceptance are tracked
+  separately; no estimate-based parity claim is made for unverified jumps.
+- `layout.gridColumns` accepts integers 2 through 7 on native. Native parsers
+  clamp malformed external JSON to 1 through 7 as before; public JS validation
+  rejects invalid requested counts. Grid geometry remains container-owned.
+
+Required acceptance: disabled/enable lifecycle, both equality boundaries,
+oscillation inside the band, programmatic scroll, page/identity replacement,
+refresh and header insets, grid 6/7 layout/rotation, and no stale callbacks after
+disposal. Unit checks prove transition semantics, not rendered behavior.
+
+## Native media preview probing
+
+Status: Source implemented; native runtime acceptance pending. `mediaTile.media`
+is an opt-in native-only preview descriptor: `{ source: ImageSource, probeOrder:
+('image' | 'video')[] }`. The order contains one or two distinct candidates.
+The caller supplies the order; the renderer never guesses asset semantics.
+When provided, media takes precedence over `image`, unless `imageState` is
+explicitly empty/error. Web keeps its existing `image` behavior; native callers
+that also target Web must supply that existing image independently.
+
+Image uses the shared OneKeyImage lifecycle. Video uses a paused, muted AVPlayer
+on iOS and Media3 ExoPlayer on Android, preserving the native Video source
+families including streaming media instead of approximating them with a frame
+extractor. Video defaults to contain; an explicit image fit may select cover.
+There are no controls or video touch targets; the row owns press interaction.
+Android preserves a black letterbox and iOS a transparent one, matching the
+existing native Video views. No code calls play or requests audio focus.
+
+A failed candidate advances once; exhaustion displays the existing error
+placeholder. New source/row identity resets probing; binding, candidate and
+player generations reject stale callbacks, including A→B→A. Text-only updates
+preserve the current request. On Android, terminal image/player completion is
+posted to the next UI queue turn before advancing probes or notifying the row;
+it MUST NOT clear or rebind a Glide request inside its terminal listener.
+Posted work rechecks binding/candidate generations, and player callbacks also
+recheck the player generation. Recycling removes queued completion work before
+releasing resources. This repairs the image-to-video fallback crash without
+changing probe order or the terminal result contract; native runtime regression
+acceptance is still required. A tile owns at most one native player. On iOS,
+eligibility requires intersection with the window and every clipping/scroll
+ancestor viewport; native scroll, bounds, layer transform/position and visibility
+observations release retained offscreen pager pages. Detach, background,
+invisibility and recycle release the player; reattachment rebuilds its retained
+source while remaining paused. Android observes native global scroll/layout and
+pre-draw geometry (including property animations), checking ancestor alpha and
+getGlobalVisibleRect before allocating a player. These observers do not schedule
+frames or emit JavaScript events.
+Player count is bounded by intersecting native video tiles, including partially
+visible tiles; there is no numeric cap that blanks visible iPad cells. iOS requests
+one second of forward buffer; AVFoundation treats this as an advisory preference,
+not a hard byte limit. Android uses a 250–1000 ms forward buffer, zero back buffer
+and a 2 MiB target allocator; Media3 may exceed a target by allocation granularity.
+These are per-player buffer targets, not hard total-process memory limits.
+Platform decoder/surface overhead is additional. No
+process-wide player cache or NativeList media disk cache is introduced. Source headers are never
+logged. Android uses Media3 1.4.1 (matching native Video's default), including
+HLS/DASH, UI and OkHttp data source; the existing root media3Version override is
+honored. Cookie handling uses the React Native cookie store without replacing
+the global HTTP client's cookie jar.
+
+Required runtime cases: image→video, video→image, exhaustion, file/HTTP/HLS,
+non-square fit, silent paused initial frame, same-source text update, quick
+A→B→A reuse, detach/background and return, row tap, grid resize, and absence of
+leaked audio/player resources. Static API checks do not prove these cases.
+
+## Native container slots (source implementation, runtime verification pending)
+
+`listHeader`, `listEmpty` and `listFooter` accept React nodes on iOS and Android
+vertical lists only. They are optional and default to absent. They are common
+container capabilities, not row templates, and MUST NOT be used for per-item
+rendering. Horizontal orientation with any supplied slot is rejected. Web ignores
+these new native-only props; existing Web lists and callers retain their behavior.
+
+The order is header, data rows (or empty slot when there are no data rows), footer.
+On iOS, after the laid-out vertical content shrinks, an offset beyond the new
+bottom is corrected to the current adjusted-inset-aware maximum. In-range offsets
+and negative pull overscroll remain unchanged. Correction waits until active
+dragging, deceleration and refresh finish; it is not an unconditional layout or
+snapshot reset to the top. The native content-offset change remains observable to
+ancestor pager coordinators so their saved logical offsets stay synchronized.
+Recycling/disposal cancels deferred correction. Runtime acceptance includes a
+scrolled retained-page round trip followed by empty content with scrolling slots.
+
+Slots scroll with the native list. `fixedFooter` remains a separate fixed native
+row descriptor. `scrollToEnd` aligns the final scrolling slot bottom with the
+viewport end, including footer/empty/header-only slots taller than the viewport. Callers using `listEmpty` MUST omit `snapshot.emptyState`, whose
+existing native descriptor becomes a data item. Horizontal content padding applies
+to slots as well as data rows. Slot React trees own their internal layout and
+business actions; NativeList owns their scroll placement and lifecycle.
+
+The wrapper mounts exactly three non-collapsible slot roots and reports measured
+heights through `containerSlotHeightsJson` in header/empty/footer order. Native
+validates three finite, non-negative heights. Slot updates MUST NOT alter data-row
+keys or public row indices. No per-scroll-frame JS position updates are used.
+iOS mounts slot roots inside UICollectionView and reserves native layout space.
+Android uses ConcatAdapter with three single-item slot adapters around the existing
+data adapter; adapter binding indices stay local while layout-manager positions
+are explicitly translated. Slots span all grid columns, do not select/reorder,
+and do not emit row actions, visible-row indices, or image-prefetch work.
+
+Fabric mount/unmount ownership remains explicit even when RecyclerView detaches a
+slot holder. The native manager retains at most three roots until Fabric unmount;
+recycling detaches slot content without disposing its React tree. Unmount removes
+that exact view. Native list disposal MUST NOT dispatch pending row/slot events.
+The generated Nitro 0.37 leaf managers require deterministic child-forwarding
+customization: `scripts/enable-container-slots.mjs` runs after nitrogen and rejects
+unexpected generator output. Generated files are never maintained by hand.
+
+Acceptance requires both platforms: dynamic header height, empty/nonempty changes,
+scrolling footer with pagination, grid full-span slots, scrolling from interactive
+slot content, refresh from header/empty, row-index scroll APIs, reuse/unmount, and
+rapid account changes. Source/type checks do not establish this runtime acceptance.
+
+
+## Refresh trigger distance
+
+Optional `snapshot.capabilities.refreshTriggerDistance` is a positive finite
+logical-pixel distance. Omission preserves the platform control's default.
+iOS adds a release-trigger fallback based on the deepest normalized overscroll
+(contentOffset plus contentInset.top); the fallback and UIRefreshControl emit
+at most one refresh action per drag. Android passes the distance to
+SwipeRefreshLayout's native trigger setting. These native controls differ in
+rubber-band/drag scaling, so equal values do not promise equal finger travel.
+The caller continues to own refreshing state, completion, and optional haptic feedback.
+On native, the row-less `nativeList.refresh` bridge envelope is container-owned:
+the JS wrapper consumes it and invokes only `onRefresh`, when supplied. It MUST
+NOT also invoke the public `onRowAction`, even when `onRefresh` is absent.
+An actual row action carrying a `rowKey` remains a row action, including one
+whose caller-defined action key matches this internal name. Web retains its
+legacy dual notification behavior; this native correction does not change Web.
+The container does not emit a second haptic for the release fallback. The fallback is
+inactive unless pull-to-refresh is enabled; no product-specific threshold is
+hardcoded into the module.
+
+## Native rich activity presentation
+
+Status: Source implemented; native runtime acceptance pending. Optional `amounts`
+supersedes legacy `primaryAmount`/`secondaryAmount` only on native. It accepts at
+most 32 keyed lines, each with formatted text, optional leading visual, tone,
+secondary text and subscript text segments. Segments are caller-formatted and
+never interpreted as numbers by NativeList. Omission preserves the legacy tree.
+
+`presentation: stacked` places the amount lines after the identity column and
+right-aligns them; `table` uses equal identity/amount columns, left-aligns amount
+lines and adds an optional trailing fee column. Fee supports label, primary and
+secondary text with their own segments; `hidden` preserves its column width
+while hiding its contents. Up to four uniquely keyed title badges use declared
+tones. `descriptionActionKey` makes only the description emit that action with
+source `description`; footer actions retain their existing source/keys and
+disabled behavior. All actions use the current host binding epoch.
+
+Rich rows measure the declared line/visual metrics; there is no six-line native
+truncation. The existing height override contract still applies. RTL follows
+semantic leading/trailing anchors. Clearing rich fields returns to the legacy
+renderer, and removing amount lines recycles their visual slots. Web rendering
+remains unchanged; rich fields are native-only until a separate Web migration.
+
+Acceptance: 1/2/6/32 lines, changed keys/order, paired icons and network overlays,
+small-number segments in amounts/fiat/fee (ceil(0.6 × parent font size), unchanged
+baseline, matching NumberSizeableText), badge tone/clear, hidden fee, disabled
+actions, description anchors, dark/RTL/font scaling and explicit/automatic height.
+
+
+### Android ancestor scroll distance
+
+Threshold hysteresis combines the primary RecyclerView's actual consumed scroll
+with all native ancestor header contributions. CollapsiblePagerView publishes
+weak-owner contributions through the namespaced View-tag protocol documented in
+its SPEC.md; no pager dependency or product semantics are required. Absence is
+zero. NativeList owns one native listener, registers it on attach, and removes
+only its own listener on detach. Header-only scrolling therefore crosses the
+same logical Home threshold as iOS normalized content scrolling, without a JS
+scroll-frame event. Changes to the listener or public callbacks do not replace
+native resource ownership.
+
+Child distance uses actual onScrolled dy and rebases from first-item geometry at
+top; scrollToOffset seeds a known explicit offset. It does not use RecyclerView's
+average-height scrollbar estimate. Continuous scrolling and return-to-top are
+covered by this policy; exact classification immediately after arbitrary distant
+scrollToIndex jumps remains pending measured-prefix correction and MUST NOT be
+claimed as verified. A later top anchor restores exact distance.
+
+
+### Container follow-up verification
+
+The pure Android end-alignment policy has four focused JVM tests: tall footer,
+tall empty slot with viewport padding, animated decorated-bottom correction,
+and short footer. These validate geometry, not actual RecyclerView animation or
+Fabric lifecycle. Native simulator acceptance remains required. The iOS fallback
+retains one refresh action per drag and leaves haptic feedback to its caller.

package/docs/STYLE_SPEC.md

@@ -976,3 +976,11 @@ the contract; no shared cross-language renderer or code generator is required.
   before treating the refactor as device-accepted.
 
 Overflow fitting is the integrating developer's responsibility.
+
+### Native tablet grid allocation
+
+`layout.gridColumns` accepts integers 2 through 7. The container derives tile
+width from available width, content padding and spacing; mediaTile styles do
+not choose the column count. This extends native parser limits from four to
+seven without changing existing 2/3/4 geometry. Runtime acceptance for 6/7
+columns, rotation, and text scaling remains required.

package/ios/HybridNativeList.swift

@@ -7,6 +7,35 @@ final class HybridNativeList: HybridNativeListSpec {
 
   var view: UIView { hostView ?? disposedView }
 
+  var scrollPositionThresholdsJson: String = "" {
+    didSet {
+      guard scrollPositionThresholdsJson != oldValue else { return }
+      runOnMain { [weak self] in
+        guard let self else { return }
+        self.hostView?.setScrollPositionThresholdsJson(self.scrollPositionThresholdsJson)
+      }
+    }
+  }
+
+  var onScrollPositionThresholdChange: ((Bool) -> Void)? {
+    didSet {
+      runOnMain { [weak self] in
+        guard let self else { return }
+        self.hostView?.onScrollPositionThresholdChange = self.onScrollPositionThresholdChange
+      }
+    }
+  }
+
+  var containerSlotHeightsJson: String = "[]" {
+    didSet {
+      guard containerSlotHeightsJson != oldValue else { return }
+      runOnMain { [weak self] in
+        guard let self else { return }
+        self.hostView?.setContainerSlotHeightsJson(self.containerSlotHeightsJson)
+      }
+    }
+  }
+
   var snapshotJson: String = "" {
     didSet {
       guard snapshotJson != oldValue else { return }
@@ -156,6 +185,7 @@ final class HybridNativeList: HybridNativeListSpec {
     onReorder = nil
     onEndReached = nil
     onVisibleRangeChanged = nil
+    onScrollPositionThresholdChange = nil
     hostView.dispose()
     self.hostView = nil
     snapshotJson = ""

package/ios/NativeListActivityDetailsView.swift

@@ -0,0 +1,229 @@
+import UIKit
+
+/// The activity template's bounded rich presentation; all values are caller-formatted.
+final class NativeListActivityDetailsView: UIStackView {
+  var onAction: ((String, UIView, String, Int) -> Void)?
+  private let main = UIStackView()
+  private let visual = NativeListLeadingVisual()
+  private let identity = UIStackView()
+  private let titleLine = UIStackView()
+  private let title = NativeListTextLabel()
+  private let descriptionLabel = NativeListTextLabel()
+  private let status = NativeListTextLabel()
+  private let amounts = UIStackView()
+  private let fee = UIStackView()
+  private let feeLabel = NativeListTextLabel()
+  private let feeLine = UIStackView()
+  private let feePrimary = NativeListTextLabel()
+  private let feeSecondary = NativeListTextLabel()
+  private let actions = UIStackView()
+  private var amountViews: [NativeListActivityAmountView] = []
+  private var badgeViews: [NativeListTextLabel] = []
+  private var buttons: [UIButton] = []
+  private var actionKeys: [String] = []
+  private var descriptionKey = ""
+  private var dimensions: [NSLayoutConstraint] = []
+
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+    axis = .vertical; alignment = .fill; spacing = 8
+    main.axis = .horizontal; main.alignment = .center; main.spacing = 12
+    identity.axis = .vertical; identity.alignment = .fill
+    titleLine.axis = .horizontal; titleLine.alignment = .center; titleLine.spacing = 4
+    titleLine.addArrangedSubview(title)
+    [titleLine, descriptionLabel, status].forEach(identity.addArrangedSubview)
+    amounts.axis = .vertical; amounts.alignment = .fill; amounts.spacing = 2
+    fee.axis = .vertical; fee.alignment = .trailing
+    feeLine.axis = .horizontal; feeLine.spacing = 4
+    [feePrimary, feeSecondary].forEach(feeLine.addArrangedSubview)
+    [feeLabel, feeLine].forEach(fee.addArrangedSubview)
+    [visual, identity, amounts, fee].forEach(main.addArrangedSubview)
+    [main, actions].forEach(addArrangedSubview)
+    actions.axis = .horizontal; actions.alignment = .leading; actions.spacing = 8
+    actions.isLayoutMarginsRelativeArrangement = true
+    descriptionLabel.isUserInteractionEnabled = true
+    descriptionLabel.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(descriptionPressed)))
+    title.setContentCompressionResistancePriority(.defaultLow, for: .horizontal)
+    identity.setContentHuggingPriority(.defaultLow, for: .horizontal)
+    amounts.setContentHuggingPriority(.defaultHigh, for: .horizontal)
+  }
+  required init(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+  static func measure(_ data: [String: Any], width: CGFloat) -> CGFloat {
+    let style = data.dictionary("style") ?? [:]
+    let primary = style.dictionary("primaryAmount") ?? [:]
+    let secondary = style.dictionary("secondaryAmount") ?? [:]
+    let rows = data.dictionaries("amounts")
+    let gap = CGFloat(style.double("trailingGap", default: 2))
+    let amountsHeight = rows.reduce(CGFloat(0)) { height, row in
+      height + CGFloat(primary.double("lineHeight", default: 24)) +
+        (row.string("secondaryText").isEmpty ? 0 : CGFloat(secondary.double("lineHeight", default: 20)))
+    } + CGFloat(max(0, rows.count - 1)) * gap
+    let titleHeight = CGFloat(style.dictionary("title")?.double("lineHeight", default: 24) ?? 24)
+    let description = NativeListResolvedText(data.string("description"), style: style.dictionary("description"),
+      size: 14, color: .label, lineHeight: 20, lines: 2)
+    let identityHeight = titleHeight + description.measure(width: max(1, width * 0.4 - 52)) +
+      (data.string("status").isEmpty ? 0 : 16)
+    let imageHeight = CGFloat(style.dictionary("image")?.double("height", default: 40) ?? 40)
+    return max(imageHeight, identityHeight, amountsHeight) +
+      CGFloat(style.double("verticalPadding", default: 8)) * 2 +
+      (data.dictionaries("footerActions").isEmpty ? 0 : 40)
+  }
+
+  func bind(_ item: NativeListItem, theme: [String: Any]?) {
+    let data = item.data
+    let style = data.dictionary("style") ?? [:]
+    let image = style.dictionary("image") ?? [:]
+    let table = data.string("presentation") == "table"
+    let gap = CGFloat(style.double("leadingGap", default: 12))
+    main.spacing = gap
+    identity.spacing = CGFloat(style.double("lineGap"))
+    amounts.spacing = CGFloat(style.double("trailingGap", default: 2))
+    titleLine.spacing = CGFloat(style.double("titleBadgeGap", default: 4))
+    NSLayoutConstraint.deactivate(dimensions)
+    dimensions = [
+      visual.widthAnchor.constraint(equalToConstant: CGFloat(image.double("width", default: 40))),
+      visual.heightAnchor.constraint(equalToConstant: CGFloat(image.double("height", default: 40))),
+      amounts.widthAnchor.constraint(lessThanOrEqualTo: main.widthAnchor, multiplier: table ? 0.42 : 0.5),
+    ]
+    if table { dimensions.append(amounts.widthAnchor.constraint(equalTo: identity.widthAnchor)) }
+    NSLayoutConstraint.activate(dimensions)
+    visual.bind(data.dictionary("leading") ?? [:], style: image, key: item.key, theme: theme,
+      isUnread: false, secondaryVisual: data.dictionary("secondaryLeading"))
+    NativeListResolvedText(data.string("title"), style: style.dictionary("title"), size: 16,
+      weight: .medium, color: nativeListColor(theme, "primaryText", "#202020"), lineHeight: 24, lines: 1).bind(title)
+    NativeListResolvedText(data.string("description"), style: style.dictionary("description"), size: 14,
+      color: nativeListColor(theme, "secondaryText", "#646464"), lineHeight: 20, lines: 2).bind(descriptionLabel)
+    NativeListResolvedText(data.string("status"), style: style.dictionary("status"), size: 12,
+      color: nativeListColor(theme, "secondaryText", "#646464"), lineHeight: 16, lines: 1).bind(status)
+    descriptionKey = data.string("descriptionActionKey")
+    descriptionLabel.isUserInteractionEnabled = !descriptionKey.isEmpty
+    descriptionLabel.accessibilityTraits = descriptionKey.isEmpty ? .staticText : .button
+    for badge in badgeViews { titleLine.removeArrangedSubview(badge); badge.removeFromSuperview() }
+    badgeViews = data.dictionaries("badges").map { descriptor in
+      let label = NativeListTextLabel()
+      let tone = descriptor.string("tone")
+      let tint = nativeListActivityTone(tone, theme: theme)
+      NativeListResolvedText("  \(descriptor.string("text"))  ", style: nil, size: 12,
+        weight: .medium, color: tint, lineHeight: 16, lines: 1).bind(label)
+      label.backgroundColor = tint.withAlphaComponent(0.1)
+      label.layer.cornerRadius = 4; label.clipsToBounds = true
+      label.setContentCompressionResistancePriority(.required, for: .horizontal)
+      titleLine.addArrangedSubview(label)
+      return label
+    }
+    let descriptors = data.dictionaries("amounts")
+    while amountViews.count > descriptors.count {
+      let view = amountViews.removeLast(); view.recycle(); amounts.removeArrangedSubview(view); view.removeFromSuperview()
+    }
+    while amountViews.count < descriptors.count {
+      let view = NativeListActivityAmountView(); amountViews.append(view); amounts.addArrangedSubview(view)
+    }
+    for (index, descriptor) in descriptors.enumerated() {
+      amountViews[index].bind(descriptor, key: "\(item.key):\(descriptor.string("key"))", style: style, theme: theme, table: table)
+    }
+    let feeData = data.dictionary("fee")
+    fee.isHidden = feeData == nil
+    fee.alpha = feeData?.bool("hidden") == true ? 0 : 1
+    NativeListResolvedText(feeData?.string("label") ?? "", style: style.dictionary("secondaryAmount"),
+      size: 12, color: nativeListColor(theme, "secondaryText", "#646464"), lineHeight: 16, lines: 1).bind(feeLabel)
+    NativeListResolvedText(feeData?.string("primary") ?? "", style: style.dictionary("secondaryAmount"),
+      size: 14, color: nativeListColor(theme, "primaryText", "#202020"), lineHeight: 20, lines: 1).bind(feePrimary)
+    NativeListResolvedText(feeData?.string("secondary") ?? "", style: style.dictionary("secondaryAmount"),
+      size: 12, color: nativeListColor(theme, "secondaryText", "#646464"), lineHeight: 16, lines: 1).bind(feeSecondary)
+    for button in buttons { actions.removeArrangedSubview(button); button.removeFromSuperview() }
+    buttons = []
+    nativeListActivitySegments(feePrimary, feeData?.dictionaries("primaryTextSegments") ?? [])
+    nativeListActivitySegments(feeSecondary, feeData?.dictionaries("secondaryTextSegments") ?? [])
+    let actionData = data.dictionaries("footerActions")
+    actionKeys = actionData.map { $0.string("key") }
+    actions.isHidden = actionData.isEmpty
+    actions.directionalLayoutMargins = NSDirectionalEdgeInsets(top: 0, leading: CGFloat(image.double("width", default: 40)) + gap, bottom: 0, trailing: 0)
+    for (index, descriptor) in actionData.enumerated() {
+      let button = UIButton(type: .system); button.tag = index
+      button.setTitle(descriptor.string("label"), for: .normal)
+      button.titleLabel?.font = nativeListFont(ofSize: 14, weight: .medium)
+      button.setTitleColor(nativeListActivityTone(descriptor.string("tone"), theme: theme), for: .normal)
+      button.backgroundColor = nativeListColor(theme, "strongBackground", "#F0F0F0")
+      button.layer.cornerRadius = 8
+      button.contentEdgeInsets = UIEdgeInsets(top: 4, left: 8, bottom: 4, right: 8)
+      button.isEnabled = !data.bool("disabled") && !descriptor.bool("disabled")
+      button.addTarget(self, action: #selector(actionPressed(_:)), for: .touchUpInside)
+      buttons.append(button); actions.addArrangedSubview(button)
+    }
+    let spacer = UIView(); spacer.setContentHuggingPriority(.defaultLow, for: .horizontal)
+    // The last flexible spacer is separate from the fixed action buttons.
+    actions.arrangedSubviews.filter { !($0 is UIButton) }.forEach { actions.removeArrangedSubview($0); $0.removeFromSuperview() }
+    actions.addArrangedSubview(spacer)
+  }
+  @objc private func descriptionPressed() { onAction?(descriptionKey, descriptionLabel, "description", 0) }
+  @objc private func actionPressed(_ button: UIButton) {
+    guard button.tag < actionKeys.count else { return }
+    onAction?(actionKeys[button.tag], button, "footerAction", button.tag)
+  }
+  func recycle() {
+    visual.recycle(); amountViews.forEach { $0.recycle() }; actionKeys = []; descriptionKey = ""
+  }
+}
+
+private func nativeListActivityTone(_ tone: String, theme: [String: Any]?) -> UIColor {
+  switch tone {
+  case "positive", "success": return nativeListColor(theme, "positive", "#218358")
+  case "negative", "danger": return nativeListColor(theme, "negative", "#CE2C31")
+  case "secondary": return nativeListColor(theme, "secondaryText", "#646464")
+  case "warning": return nativeListColor(theme, "warning", "#AB6400")
+  case "info": return nativeListColor(theme, "info", "#007BEF")
+  default: return nativeListColor(theme, "primaryText", "#202020")
+  }
+}
+
+private final class NativeListActivityAmountView: UIStackView {
+  private let visual = NativeListLeadingVisual()
+  private let labels = UIStackView()
+  private let primary = NativeListTextLabel()
+  private let secondary = NativeListTextLabel()
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+    axis = .horizontal; alignment = .center; spacing = 6
+    labels.axis = .vertical; labels.alignment = .fill
+    [primary, secondary].forEach(labels.addArrangedSubview)
+    [visual, labels].forEach(addArrangedSubview)
+    NSLayoutConstraint.activate([visual.widthAnchor.constraint(equalToConstant: 20), visual.heightAnchor.constraint(equalToConstant: 20)])
+  }
+  required init(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+  func bind(_ data: [String: Any], key: String, style: [String: Any], theme: [String: Any]?, table: Bool) {
+    let leading = data.dictionary("leading")
+    visual.isHidden = leading == nil
+    if let leading { visual.bind(leading, style: ["width": 20, "height": 20], key: key, theme: theme, isUnread: false) } else { visual.recycle() }
+    var primaryStyle = style.dictionary("primaryAmount") ?? [:]
+    if primaryStyle["alignment"] == nil { primaryStyle["alignment"] = table ? "start" : "end" }
+    let resolved = NativeListResolvedText(data.string("text"), style: primaryStyle, size: 16,
+      weight: .medium, color: nativeListActivityTone(data.string("tone"), theme: theme), lineHeight: 24, lines: 1, tabular: true)
+    resolved.bind(primary)
+    nativeListActivitySegments(primary, data.dictionaries("textSegments"))
+    var secondaryStyle = style.dictionary("secondaryAmount") ?? [:]
+    if secondaryStyle["alignment"] == nil { secondaryStyle["alignment"] = table ? "start" : "end" }
+    NativeListResolvedText(data.string("secondaryText"), style: secondaryStyle, size: 14,
+      color: nativeListColor(theme, "secondaryText", "#646464"), lineHeight: 20, lines: 1).bind(secondary)
+    nativeListActivitySegments(secondary, data.dictionaries("secondaryTextSegments"))
+  }
+  func recycle() { visual.recycle() }
+}
+
+private func nativeListActivitySegments(_ label: NativeListTextLabel, _ segments: [[String: Any]]) {
+  guard !segments.isEmpty else { return }
+  let text = segments.map { $0.string("text") }.joined()
+  let attributes = (label.attributedText?.length ?? 0) > 0
+    ? label.attributedText!.attributes(at: 0, effectiveRange: nil)
+    : [.font: label.font as Any, .foregroundColor: label.textColor as Any]
+  let value = NSMutableAttributedString(string: text, attributes: attributes)
+  var offset = 0
+  for segment in segments {
+    let length = (segment.string("text") as NSString).length
+    if segment.string("style") == "subscript" {
+      value.addAttributes([.font: label.font.withSize(ceil(label.font.pointSize * 0.6))], range: NSRange(location: offset, length: length))
+    }
+    offset += length
+  }
+  label.attributedText = value
+}

package/ios/NativeListActivityRenderer.swift

@@ -4,9 +4,11 @@ final class NativeListActivityCell: NativeListRendererCell {
   override class func measure(
     _ item: NativeListItem, width: CGFloat, theme: [String: Any]?, layout: String
   ) -> CGFloat? {
+    if item.data["amounts"] != nil { return NativeListActivityDetailsView.measure(item.data, width: width) }
     return item.data.dictionaries("footerActions").isEmpty ? 60 : 100
   }
 
+  private let details = NativeListActivityDetailsView()
   private let visual = NativeListLeadingVisual()
   private let column = UIStackView()
   private let titleLine = UIStackView()
@@ -22,7 +24,7 @@ final class NativeListActivityCell: NativeListRendererCell {
   private let buttons = (0..<3).map { _ in UIButton(type: .system) }
   private var actionKeys: [String] = []
   private var dimensions: [NSLayoutConstraint] = []
-  override var assetFields: [String] { ["leading", "secondaryLeading"] }
+  override var assetFields: [String] { ["leading", "secondaryLeading", "amounts"] }
 
   override init(frame: CGRect) {
     super.init(frame: frame)
@@ -60,7 +62,11 @@ final class NativeListActivityCell: NativeListRendererCell {
       button.addTarget(self, action: #selector(pressed(_:)), for: .touchUpInside)
       actions.addArrangedSubview(button)
     }
-    [visual, column, amounts].forEach(root.addArrangedSubview)
+    [visual, column, amounts, details].forEach(root.addArrangedSubview)
+    details.isHidden = true
+    details.onAction = { [weak self] key, view, source, slot in
+      self?.emitAction(key, from: view, source: source, slot: slot)
+    }
   }
   required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
   override func bindContent(
@@ -68,6 +74,21 @@ final class NativeListActivityCell: NativeListRendererCell {
     checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String
   ) {
     let data = item.data
+    let rich = data["amounts"] != nil
+    details.isHidden = !rich
+    [visual, column, amounts].forEach { $0.isHidden = rich }
+    root.axis = rich ? .vertical : .horizontal
+    root.alignment = rich ? .fill : .center
+    if rich {
+      let style = data.dictionary("style") ?? [:]
+      let hp = CGFloat(style.double("horizontalPadding", default: data.string("presentation") == "table" ? 16 : 12))
+      let vp = CGFloat(style.double("verticalPadding", default: 8))
+      contentInsets = UIEdgeInsets(top: vp, left: hp, bottom: vp, right: hp)
+      visual.recycle()
+      details.bind(item, theme: theme)
+      return
+    }
+    details.recycle()
     let style = data.dictionary("style") ?? [:]
     let image = style.dictionary("image") ?? [:]
     root.spacing = 12
@@ -173,6 +194,7 @@ final class NativeListActivityCell: NativeListRendererCell {
   }
   override func recycleContent() {
     visual.recycle()
+    details.recycle()
     actionKeys = []
     buttons.forEach { $0.isHidden = true }
   }