@onekeyfe/react-native-native-list 3.0.157-alpha.249 → 3.0.157-alpha.250

package/ios/NativeListRendererCell.swift

@@ -0,0 +1,311 @@
+import UIKit
+
+// Shared chrome and binding lifetime; the subclass owns its template views.
+enum NativeListRendererUpdate { case unchanged, content, assets, replace }
+
+class NativeListRendererCell: NativeListRowHost {
+  let root = UIStackView()
+  var contentInsets = UIEdgeInsets.zero
+  var usesIntrinsicContentHeight: Bool { false }
+  var defaultBorderWidth: CGFloat { 0 }
+  func defaultBorderColor(_ theme: [String: Any]?) -> UIColor { .clear }
+  var defaultCornerRadius: CGFloat { 0 }
+  /// Legacy pressed rows round all corners (12pt) while highlighted; nil opts out.
+  var pressedCornerRadius: CGFloat? { pressChangesBackground ? 12 : nil }
+  /// Radius for `groupPosition` rows when listStyle does not set one (legacy 12).
+  var groupCornerRadius: CGFloat { 12 }
+  var defaultCornerCurve: CALayerCornerCurve { .circular }
+  var pressChangesBackground: Bool { true }
+  func pressedBackground(_ theme: [String: Any]?) -> UIColor {
+    nativeListColor(theme, "rowPressedBackground", "#E8E8E8")
+  }
+  var showsSelection: Bool { true }
+  /// Whether the legacy row-level `backgroundColor` paints this row (resting and full-width
+  /// fills). `style.container.backgroundColor` always applies.
+  var honorsRowBackgroundColor: Bool { true }
+  var defaultVerticalAlignment: String? { nil }
+  var defaultSeparatorInset: CGFloat { 12 }
+  func bindContent(
+    _ item: NativeListItem, theme: [String: Any]?, layout: String,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String
+  ) {}
+  func recycleContent() {}
+  func bindSelectionContent(
+    _ item: NativeListItem,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String
+  ) {}
+  var assetFields: [String] { [] }
+  private func update(from old: NativeListItem?, to new: NativeListItem) -> NativeListRendererUpdate
+  {
+    guard let old, old.key == new.key, old.rendererKey == new.rendererKey else { return .replace }
+    if old.content == new.content { return .unchanged }
+    for field in assetFields where !nativeListValuesEqual(old.data[field], new.data[field]) {
+      return .assets
+    }
+    return .content
+  }
+  private let separator = UIView()
+  private let fullWidthBackground = CALayer()
+  private var contentPosition: NSLayoutConstraint?
+  private var rootConstraints: [NSLayoutConstraint] = []
+  private var item: NativeListItem?
+  private var theme: [String: Any]?
+  private var layout = "linear"
+  private var itemIndex: Int?
+  func unselectedBackground(
+    _ item: NativeListItem, theme: [String: Any]?, layout: String, itemIndex: Int?
+  ) -> UIColor { nativeListColor(theme, "rowBackground", "#FFFFFF") }
+  private(set) var selectedState = false
+  // Last applied list-level inputs; compared structurally (no serialization/hashing per bind).
+  // The layout direction is an input because renderers resolve start/end alignment at bind.
+  private var boundInputs:
+    (
+      theme: NSDictionary?, layout: String, listStyle: NSDictionary?,
+      direction: UIUserInterfaceLayoutDirection
+    )?
+
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+    root.translatesAutoresizingMaskIntoConstraints = false
+    contentView.addSubview(root)
+    contentView.addSubview(separator)
+    rootConstraints = [
+      root.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),
+      root.trailingAnchor.constraint(equalTo: contentView.trailingAnchor),
+      root.topAnchor.constraint(equalTo: contentView.topAnchor),
+      root.bottomAnchor.constraint(equalTo: contentView.bottomAnchor),
+    ]
+    NSLayoutConstraint.activate(rootConstraints)
+  }
+  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+  func accessibilityText(_ item: NativeListItem) -> String {
+    item.data.string("accessibilityLabel", default: item.data.string("title"))
+  }
+  @discardableResult func retainBoundItem(_ item: NativeListItem) -> Bool {
+    guard self.item?.key == item.key else { return false }
+    self.item = item
+    return true
+  }
+
+  override func bind(
+    item: NativeListItem, theme: [String: Any]?, layout: String, itemIndex: Int? = nil,
+    selected: Bool, checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String
+  ) {
+    let update = update(from: self.item, to: item)
+    let inputs = (
+      theme: theme.map { $0 as NSDictionary }, layout: layout,
+      listStyle: listStyle.map { $0 as NSDictionary },
+      direction: effectiveUserInterfaceLayoutDirection
+    )
+    let inputsChanged =
+      boundInputs.map {
+        // A missing theme/listStyle is the empty object, as in the former `?? [:]` JSON digest.
+        $0.layout != inputs.layout || $0.direction != inputs.direction
+          || !nativeListValuesEqual($0.theme ?? [:], inputs.theme ?? [:])
+          || !nativeListValuesEqual($0.listStyle ?? [:], inputs.listStyle ?? [:])
+      } ?? true
+    if update != .unchanged || inputsChanged {
+      if self.item != nil { onBindingInvalidated?(self, bindingEpoch) }
+      bindingEpoch &+= 1
+      if update == .replace {
+        recycleContent()
+        isHighlighted = false
+      }
+      contentPosition?.isActive = false
+      contentPosition = nil
+      NSLayoutConstraint.activate(Array(rootConstraints.suffix(2)))
+      bindContent(item, theme: theme, layout: layout, checkboxState: checkboxState)
+      rootConstraints[0].constant = contentInsets.left
+      rootConstraints[1].constant = -contentInsets.right
+      rootConstraints[2].constant = contentInsets.top
+      rootConstraints[3].constant = -contentInsets.bottom
+      if root.axis == .vertical,
+        let alignment = item.data.dictionary("style")?.dictionary("container")?[
+          "contentVerticalAlignment"] as? String
+          ?? (item.styledHeight != nil || usesIntrinsicContentHeight
+            ? (defaultVerticalAlignment ?? "top") : nil)
+      {
+        NSLayoutConstraint.deactivate(Array(rootConstraints.suffix(2)))
+        contentPosition =
+          alignment == "bottom"
+          ? root.bottomAnchor.constraint(
+            equalTo: contentView.bottomAnchor, constant: -contentInsets.bottom)
+          : alignment == "center"
+            ? root.centerYAnchor.constraint(
+              equalTo: contentView.centerYAnchor,
+              constant: (contentInsets.top - contentInsets.bottom) / 2)
+            : root.topAnchor.constraint(equalTo: contentView.topAnchor, constant: contentInsets.top)
+        contentPosition?.isActive = true
+      }
+      boundInputs = inputs
+    }
+    self.item = item
+    self.theme = theme
+    self.layout = layout
+    self.itemIndex = itemIndex
+    self.selectedState = selected
+    bindSelectionContent(item, checkboxState: checkboxState)
+    accessibilityLabel = accessibilityText(item)
+    accessibilityIdentifier = item.data["testID"] as? String
+    isUserInteractionEnabled = !item.data.bool("disabled")
+    if !isUserInteractionEnabled { isHighlighted = false }
+    applyAppearance()
+    setNeedsLayout()
+  }
+
+  override func updateSelection(
+    item: NativeListItem, selected: Bool,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String
+  ) {
+    guard self.item?.key == item.key else { return }
+    self.item = item
+    self.selectedState = selected
+    bindSelectionContent(item, checkboxState: checkboxState)
+    applyAppearance()
+  }
+  override var isHighlighted: Bool { didSet { applyAppearance() } }
+
+  func emitAction(
+    _ key: String, from view: UIView, source: String, slot: Int? = nil,
+    target: NativeSelectionTarget? = nil, anchorInset: CGFloat = 0
+  ) {
+    guard let item, !key.isEmpty, !item.data.bool("disabled") else { return }
+    onAction?(
+      item, key, target,
+      NativeListActionOrigin(
+        sourceView: view, ownerCell: self,
+        bindingEpoch: bindingEpoch, source: source, slot: slot, anchorInset: anchorInset))
+  }
+
+  func applyAppearance() {
+    guard let item else { return }
+    let container = item.data.dictionary("style")?.dictionary("container") ?? [:]
+    let showSelection =
+      showsSelection && selectedState && (layout != "sectioned" || item.data.bool("selected"))
+    var background =
+      showSelection
+      ? nativeListColor(theme, "rowSelectedBackground", "#F0F0F0")
+      : unselectedBackground(item, theme: theme, layout: layout, itemIndex: itemIndex)
+    let rowFill =
+      container["backgroundColor"]
+      ?? (honorsRowBackgroundColor ? item.data["backgroundColor"] : nil)
+    if let color = rowFill as? String {
+      background = UIColor(nativeListHex: color, fallback: background)
+    }
+    contentView.backgroundColor =
+      isHighlighted && pressChangesBackground
+      ? pressedBackground(theme) : background
+    contentView.alpha =
+      CGFloat(container.double("opacity", default: item.data.double("opacity", default: 1)))
+      * (item.data.bool("disabled") ? 0.5 : 1)
+    let position = item.data.string("groupPosition")
+    let grouped = ["first", "last", "single"].contains(position)
+    let pressedRadius =
+      isHighlighted && isUserInteractionEnabled ? pressedCornerRadius.map(Double.init) : nil
+    let fallbackRadius =
+      defaultCornerRadius > 0
+      ? Double(defaultCornerRadius)
+      : grouped
+        ? listStyle?.double("groupCornerRadius", default: Double(groupCornerRadius))
+          ?? Double(groupCornerRadius) : 0
+    let radius = CGFloat(
+      container.double(
+        "cornerRadius", default: pressedRadius ?? fallbackRadius))
+    let top: CACornerMask = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
+    let bottom: CACornerMask = [.layerMinXMaxYCorner, .layerMaxXMaxYCorner]
+    layer.maskedCorners =
+      container["cornerRadius"] != nil || position == "single" || defaultCornerRadius > 0
+        || pressedRadius != nil
+      ? top.union(bottom) : position == "first" ? top : position == "last" ? bottom : []
+    layer.cornerCurve = defaultCornerCurve
+    contentView.layer.cornerCurve = defaultCornerCurve
+    layer.cornerRadius = radius
+    layer.masksToBounds = radius > 0
+    contentView.layer.cornerRadius = radius
+    contentView.layer.maskedCorners = layer.maskedCorners
+    contentView.layer.borderWidth = CGFloat(
+      container.double("borderWidth", default: Double(defaultBorderWidth)))
+    contentView.layer.borderColor =
+      UIColor(
+        nativeListHex: container.string("borderColor"), fallback: defaultBorderColor(theme)
+      ).cgColor
+    if item.data.bool("backgroundFullWidth"),
+      let fill = rowFill as? String
+    {
+      fullWidthBackground.backgroundColor = UIColor(nativeListHex: fill, fallback: .clear).cgColor
+      contentView.layer.insertSublayer(fullWidthBackground, at: 0)
+      clipsToBounds = false
+    } else {
+      fullWidthBackground.removeFromSuperlayer()
+    }
+    separator.isHidden = !item.data.bool("separator")
+    separator.backgroundColor = UIColor(
+      nativeListHex: listStyle?.dictionary("separator")?.string(
+        "color", default: theme?.string("separator", default: "#E0E0E0") ?? "#E0E0E0") ?? theme?
+        .string("separator", default: "#E0E0E0") ?? "#E0E0E0", fallback: .lightGray)
+  }
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    fullWidthBackground.frame = CGRect(
+      x: -frame.minX, y: 0, width: superview?.bounds.width ?? bounds.width, height: bounds.height)
+    let inset = CGFloat(
+      listStyle?.dictionary("separator")?.double("inset", default: Double(defaultSeparatorInset))
+        ?? Double(defaultSeparatorInset))
+    separator.frame = CGRect(
+      x: effectiveUserInterfaceLayoutDirection == .rightToLeft ? 0 : inset,
+      y: contentView.bounds.height - 1 / UIScreen.main.scale,
+      width: max(0, contentView.bounds.width - inset), height: 1 / UIScreen.main.scale)
+  }
+  override func prepareForReuse() {
+    super.prepareForReuse()
+    if item != nil { onBindingInvalidated?(self, bindingEpoch) }
+    bindingEpoch &+= 1
+    item = nil
+    boundInputs = nil
+    recycleContent()
+    fullWidthBackground.removeFromSuperlayer()
+    isHighlighted = false
+  }
+}
+
+/// Type-aware structural equality for bridged JSON values, matching the former
+/// sorted-keys JSON digest without serializing: `true` != `1` (CFBoolean vs NSNumber),
+/// numbers compare by value (`1` == `1.0`), strings by UTF-16 code units, and inside objects
+/// an explicit `null` differs from a missing key. At the top level a missing value equals
+/// `NSNull` (the digest used `value ?? NSNull()`).
+func nativeListValuesEqual(_ lhs: Any?, _ rhs: Any?) -> Bool {
+  switch (lhs.flatMap { $0 is NSNull ? nil : $0 }, rhs.flatMap { $0 is NSNull ? nil : $0 }) {
+  case (nil, nil): return true
+  case let (lhs?, rhs?): return nativeListJSONEqual(lhs as AnyObject, rhs as AnyObject)
+  default: return false
+  }
+}
+
+private func nativeListJSONEqual(_ lhs: AnyObject, _ rhs: AnyObject) -> Bool {
+  if lhs === rhs { return true }
+  if let lhs = lhs as? NSNumber, let rhs = rhs as? NSNumber {
+    let boolean = CFBooleanGetTypeID()
+    return (CFGetTypeID(lhs) == boolean) == (CFGetTypeID(rhs) == boolean) && lhs.isEqual(to: rhs)
+  }
+  if let lhs = lhs as? NSString, let rhs = rhs as? NSString { return lhs.isEqual(to: rhs as String) }
+  if let lhs = lhs as? NSDictionary, let rhs = rhs as? NSDictionary {
+    guard lhs.count == rhs.count else { return false }
+    for (key, value) in lhs {
+      guard let other = rhs.object(forKey: key),
+        nativeListJSONEqual(value as AnyObject, other as AnyObject)
+      else { return false }
+    }
+    return true
+  }
+  if let lhs = lhs as? NSArray, let rhs = rhs as? NSArray {
+    guard lhs.count == rhs.count else { return false }
+    for index in 0..<lhs.count
+    where !nativeListJSONEqual(lhs[index] as AnyObject, rhs[index] as AnyObject) {
+      return false
+    }
+    return true
+  }
+  if lhs is NSNull || rhs is NSNull { return lhs is NSNull && rhs is NSNull }
+  return lhs.isEqual(rhs)
+}

package/ios/NativeListRendererRegistry.swift

@@ -0,0 +1,50 @@
+import UIKit
+
+// Closed internal registry; no public plugin or bridge surface.
+enum NativeListRendererRegistry {
+  private static let hosts:
+    [NativeListRendererKey: (type: NativeListRowHost.Type, create: () -> NativeListRowHost)] = [
+      .sectionHeader: (
+        NativeListSectionHeaderCell.self, { NativeListSectionHeaderCell(frame: .zero) }
+      ),
+      .walletGroup: (NativeListWalletGroupCell.self, { NativeListWalletGroupCell(frame: .zero) }),
+      .identity: (NativeListIdentityCell.self, { NativeListIdentityCell(frame: .zero) }),
+      .market: (NativeListMarketCell.self, { NativeListMarketCell(frame: .zero) }),
+      .message: (NativeListMessageCell.self, { NativeListMessageCell(frame: .zero) }),
+      .rail: (NativeListRailCell.self, { NativeListRailCell(frame: .zero) }),
+      .mediaTile: (NativeListMediaTileCell.self, { NativeListMediaTileCell(frame: .zero) }),
+      .metricCard: (NativeListMetricCardCell.self, { NativeListMetricCardCell(frame: .zero) }),
+      .dataRow: (NativeListDataRowCell.self, { NativeListDataRowCell(frame: .zero) }),
+      .activity: (NativeListActivityCell.self, { NativeListActivityCell(frame: .zero) }),
+      .system: (NativeListSystemCell.self, { NativeListSystemCell(frame: .zero) }),
+      .action: (NativeListActionCell.self, { NativeListActionCell(frame: .zero) }),
+      .unsupported: (
+        NativeListUnsupportedCell.self, { NativeListUnsupportedCell(frame: .zero) }
+      ),
+    ]
+  static func create(_ key: NativeListRendererKey) -> NativeListRowHost { hosts[key]!.create() }
+  static func reuseIdentifier(for key: NativeListRendererKey) -> String {
+    "NativeList.\(key.rawValue)"
+  }
+  static func register(in collectionView: UICollectionView) {
+    for (key, host) in hosts {
+      collectionView.register(host.type, forCellWithReuseIdentifier: reuseIdentifier(for: key))
+    }
+  }
+  static func appliesSizePreset(_ item: NativeListItem) -> Bool {
+    hosts[item.rendererKey]!.type.appliesSizePreset(item)
+  }
+  static func measure(_ item: NativeListItem, width: CGFloat, theme: [String: Any]?, layout: String)
+    -> CGFloat?
+  {
+    hosts[item.rendererKey]!.type.measure(item, width: width, theme: theme, layout: layout)
+  }
+}
+
+/// Legacy fallback for unknown row types: shared chrome only, 56-point default height
+/// (plus the size preset), no template content.
+final class NativeListUnsupportedCell: NativeListRendererCell {
+  override class func measure(
+    _ item: NativeListItem, width: CGFloat, theme: [String: Any]?, layout: String
+  ) -> CGFloat? { 56 }
+}

package/ios/NativeListResolvedText.swift

@@ -0,0 +1,122 @@
+import UIKit
+
+struct NativeListResolvedText {
+  let text: String
+  let font: UIFont
+  let color: UIColor
+  let lineHeight: CGFloat
+  let lines: Int
+  /// Semantic `start | center | end`; nil keeps the legacy `.natural` default.
+  let alignmentName: String?
+  let breakMode: NSLineBreakMode
+  let verticalAlignment: String?
+  let offsetY: CGFloat
+  let explicitLineHeight: Bool
+  let explicitTruncation: Bool
+  let tabular: Bool
+  /// Keep the label's break mode in the attributed paragraph (legacy plain-text labels kept
+  /// their tail ellipsis; attributed paragraphs otherwise default to word wrapping).
+  let preservesBreakMode: Bool
+
+  init(
+    _ value: String, style: [String: Any]?, size: CGFloat, weight: NativeListFontWeight = .regular,
+    color: UIColor, lineHeight: CGFloat, lines: Int, breakMode: NSLineBreakMode = .byTruncatingTail,
+    tabular: Bool = false, preservesBreakMode: Bool = false
+  ) {
+    let style = style ?? [:]
+    self.tabular = tabular
+    self.preservesBreakMode = preservesBreakMode
+    self.lines = min(3, max(1, style.int("lines", default: lines)))
+    explicitTruncation = style["lines"] != nil || style["truncate"] != nil
+    text =
+      self.lines == 1 && explicitTruncation
+      ? value.replacingOccurrences(of: "\r\n|[\r\n]", with: " ", options: .regularExpression)
+      : value
+    let resolvedWeight: NativeListFontWeight
+    switch style.string("fontWeight") {
+    case "regular": resolvedWeight = .regular
+    case "medium": resolvedWeight = .medium
+    case "semibold": resolvedWeight = .semibold
+    case "bold": resolvedWeight = .bold
+    default: resolvedWeight = weight
+    }
+    let resolvedSize = CGFloat(style.double("fontSize", default: Double(size)))
+    font =
+      tabular
+      ? nativeListTabularFont(ofSize: resolvedSize, weight: resolvedWeight)
+      : nativeListFont(ofSize: resolvedSize, weight: resolvedWeight)
+    self.color =
+      (style["color"] as? String).map { UIColor(nativeListHex: $0, fallback: color) } ?? color
+    self.lineHeight = CGFloat(style.double("lineHeight", default: Double(lineHeight)))
+    explicitLineHeight = style["lineHeight"] != nil
+    alignmentName = style["alignment"] as? String
+    self.breakMode =
+      explicitTruncation
+      ? (style.string("truncate", default: "tail") == "clip"
+        ? (self.lines == 1 ? .byClipping : .byWordWrapping) : .byTruncatingTail) : breakMode
+    verticalAlignment = style["verticalAlignment"] as? String
+    offsetY = CGFloat(style.double("offsetY"))
+  }
+
+  /// Start/end follow the host view's layout direction, as legacy `marketTextAlignment` did.
+  func alignment(for direction: UIUserInterfaceLayoutDirection) -> NSTextAlignment {
+    guard let alignmentName else { return .natural }
+    return NativeListTextStyles.marketTextAlignment(alignmentName, direction: direction)
+  }
+
+  func attributed(direction: UIUserInterfaceLayoutDirection) -> NSAttributedString {
+    let paragraph = NSMutableParagraphStyle()
+    paragraph.minimumLineHeight = lineHeight
+    paragraph.maximumLineHeight = lineHeight
+    paragraph.alignment = alignment(for: direction)
+    if explicitTruncation || preservesBreakMode { paragraph.lineBreakMode = breakMode }
+    var attributes: [NSAttributedString.Key: Any] = [
+      .font: font, .foregroundColor: color, .paragraphStyle: paragraph,
+    ]
+    if explicitLineHeight {
+      attributes[.baselineOffset] = max(0, (lineHeight - font.lineHeight) / 2)
+    }
+    return NSAttributedString(string: text, attributes: attributes)
+  }
+
+  /// Resolves start/end once from the label's current direction; the list rebinds bound rows
+  /// when its effective layout direction changes (NativeListRendererCell bound inputs).
+  func bind(_ label: NativeListTextLabel) {
+    let direction = label.effectiveUserInterfaceLayoutDirection
+    label.font = font
+    label.textColor = color
+    label.numberOfLines = lines
+    label.textAlignment = alignment(for: direction)
+    label.lineBreakMode = breakMode
+    label.rowVerticalAlignment = verticalAlignment
+    label.rowOffsetY = offsetY
+    label.attributedText = attributed(direction: direction)
+    label.isHidden = text.isEmpty
+  }
+
+  // Measurement runs for every row on every snapshot. It reuses one sizing label (the same
+  // UILabel metrics, line cap and truncation as the bound view) and memoizes by the inputs
+  // that affect height; alignment and color do not.
+  private static let sizingLabel = NativeListTextLabel()
+  private static let heightCache: NSCache<NSString, NSNumber> = {
+    let cache = NSCache<NSString, NSNumber>()
+    cache.countLimit = 4096
+    return cache
+  }()
+
+  func measure(width: CGFloat) -> CGFloat {
+    guard !text.isEmpty else { return 0 }
+    let width = max(1, width)
+    let key =
+      "\(width)|\(lines)|\(lineHeight)|\(explicitLineHeight)|\(explicitTruncation)|\(breakMode.rawValue)|\(preservesBreakMode)|\(font.fontName)|\(font.pointSize)|\(tabular)|\(text)"
+      as NSString
+    if let cached = Self.heightCache.object(forKey: key) { return CGFloat(cached.doubleValue) }
+    let label = Thread.isMainThread ? Self.sizingLabel : NativeListTextLabel()
+    bind(label)
+    let height = ceil(
+      label.sizeThatFits(CGSize(width: width, height: .greatestFiniteMagnitude)).height)
+    if label === Self.sizingLabel { label.attributedText = nil }
+    Self.heightCache.setObject(NSNumber(value: Double(height)), forKey: key)
+    return height
+  }
+}

package/ios/NativeListRowHost.swift

@@ -0,0 +1,63 @@
+import UIKit
+
+final class NativeListActionOrigin {
+  weak var sourceView: UIView?
+  weak var ownerCell: NativeListRowHost?
+  let bindingEpoch: Int
+  let source: String
+  let slot: Int?
+  // OneKey patch: expose the layout slot while preserving the larger hit target.
+  let anchorInset: CGFloat
+  var windowPoint: CGPoint?
+
+  init(
+    sourceView: UIView,
+    ownerCell: NativeListRowHost,
+    bindingEpoch: Int,
+    source: String,
+    slot: Int? = nil,
+    anchorInset: CGFloat = 0
+  ) {
+    self.sourceView = sourceView
+    self.ownerCell = ownerCell
+    self.bindingEpoch = bindingEpoch
+    self.source = source
+    self.slot = slot
+    self.anchorInset = anchorInset
+  }
+}
+
+// Common list-facing lifecycle; each renderer owns its view allocation and reset.
+class NativeListRowHost: UICollectionViewCell {
+  class func measure(_ item: NativeListItem, width: CGFloat, theme: [String: Any]?, layout: String)
+    -> CGFloat?
+  { nil }
+  class func appliesSizePreset(_ item: NativeListItem) -> Bool { true }
+
+  var bindingEpoch = 0
+  var listStyle: [String: Any]?
+  var onAction: ((NativeListItem, String, NativeSelectionTarget?, NativeListActionOrigin?) -> Void)?
+  var onBindingInvalidated: ((NativeListRowHost, Int) -> Void)?
+
+  func bind(
+    item: NativeListItem, theme: [String: Any]?, layout: String, itemIndex: Int? = nil,
+    selected: Bool, checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String
+  ) {
+    preconditionFailure("A row host must implement binding")
+  }
+  func updateSelection(
+    item: NativeListItem, selected: Bool,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String
+  ) {}
+  func updateMarketQuote(_ item: NativeListItem, theme: [String: Any]?) {}
+  func setPressed(_ pressed: Bool) { isHighlighted = pressed && isUserInteractionEnabled }
+  func canStartWalletGroupReorder(at point: CGPoint) -> Bool { true }
+  func setWalletGroupReorderCompact(_ compact: Bool) {}
+  func prepareWalletGroupReorderExpansion() {}
+  func animateWalletGroupReorderExpansion() {}
+  func finishWalletGroupReorderExpansion() {}
+  func rowActionOrigin() -> NativeListActionOrigin {
+    NativeListActionOrigin(
+      sourceView: contentView, ownerCell: self, bindingEpoch: bindingEpoch, source: "row")
+  }
+}