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

package/ios/NativeListTextStyles.swift

@@ -0,0 +1,236 @@
+import CoreText
+import UIKit
+
+// Apply semantic overrides after a renderer has restored its resolved defaults.
+enum NativeListTextStyles {
+  static func applyStyledText(_ label: UILabel, _ style: [String: Any]) {
+    let text = label.attributedText?.string ?? label.text ?? ""
+    guard !text.isEmpty, !style.isEmpty else { return }
+    let originalText = label.attributedText
+    let textLabel = label as? NativeListTextLabel
+    let baseFont =
+      (originalText?.attribute(.font, at: 0, effectiveRange: nil) as? UIFont) ?? label.font
+      ?? nativeListFont(ofSize: 14)
+    let size = CGFloat(style.double("fontSize", default: Double(baseFont.pointSize)))
+    let font: UIFont
+    if let weightName = style["fontWeight"] as? String {
+      font = nativeListFont(
+        ofSize: size,
+        weight: marketFontWeight(weightName, fallback: .regular)
+      )
+    } else {
+      font = baseFont.withSize(size)
+    }
+    let color =
+      (style["color"] as? String)
+      .map { UIColor(nativeListHex: $0, fallback: label.textColor ?? .black) }
+      ?? label.textColor ?? .black
+    if style["lines"] != nil {
+      label.numberOfLines = min(3, max(1, style.int("lines", default: 1)))
+      label.lineBreakMode = .byTruncatingTail
+    }
+    if let alignmentName = style["alignment"] as? String {
+      label.textAlignment = marketTextAlignment(
+        alignmentName, direction: label.effectiveUserInterfaceLayoutDirection)
+    }
+    if style["truncate"] != nil || style["lines"] != nil {
+      label.lineBreakMode = styledLineBreakMode(style, lines: label.numberOfLines)
+    }
+    if let alignment = style["verticalAlignment"] as? String {
+      textLabel?.rowVerticalAlignment = alignment
+    }
+    if style["offsetY"] != nil { textLabel?.rowOffsetY = CGFloat(style.double("offsetY")) }
+    label.font = font
+    label.textColor = color
+    let attributed =
+      originalText.map { NSMutableAttributedString(attributedString: $0) }
+      ?? NSMutableAttributedString(string: text)
+    let paragraph =
+      (attributed.attribute(.paragraphStyle, at: 0, effectiveRange: nil)
+      as? NSParagraphStyle)?.mutableCopy() as? NSMutableParagraphStyle ?? NSMutableParagraphStyle()
+    if style["alignment"] != nil { paragraph.alignment = label.textAlignment }
+    if style["lines"] != nil || style["truncate"] != nil {
+      paragraph.lineBreakMode = label.lineBreakMode
+    }
+    var attributes: [NSAttributedString.Key: Any] = [:]
+    applyStyledFont(attributed, style, fallback: baseFont)
+    if style["color"] != nil { attributes[.foregroundColor] = color }
+    if style["alignment"] != nil || style["lines"] != nil || style["truncate"] != nil
+      || style["lineHeight"] != nil
+    {
+      attributes[.paragraphStyle] = paragraph
+    }
+    if style["lineHeight"] != nil {
+      let box = CGFloat(style.double("lineHeight"))
+      paragraph.minimumLineHeight = box
+      paragraph.maximumLineHeight = box
+      // React Native centers font metrics inside an explicit line height.
+      attributes[.baselineOffset] = max(0, (box - font.lineHeight) / 2)
+    }
+    attributed.addAttributes(attributes, range: NSRange(location: 0, length: attributed.length))
+    if label.numberOfLines == 1 && (style["lines"] != nil || style["truncate"] != nil) {
+      normalizeSingleLine(attributed)
+    }
+    label.attributedText = attributed
+  }
+
+  static func applyStyledButton(_ button: UIButton, _ style: [String: Any]) {
+    let text =
+      button.attributedTitle(for: .normal)?.string
+      ?? button.title(for: .normal)
+      ?? ""
+    guard !text.isEmpty, !style.isEmpty else { return }
+    let originalText = button.attributedTitle(for: .normal)
+    let accessory = button as? NativeListAccessoryButton
+    let baseFont =
+      (originalText?.attribute(.font, at: 0, effectiveRange: nil) as? UIFont) ?? button.titleLabel?
+      .font ?? nativeListFont(ofSize: 14)
+    let size = CGFloat(style.double("fontSize", default: Double(baseFont.pointSize)))
+    let font: UIFont
+    if let weightName = style["fontWeight"] as? String {
+      font = nativeListFont(
+        ofSize: size,
+        weight: marketFontWeight(weightName, fallback: .regular)
+      )
+    } else {
+      font = baseFont.withSize(size)
+    }
+    let fallbackColor = button.titleColor(for: .normal) ?? .black
+    let color =
+      (style["color"] as? String)
+      .map { UIColor(nativeListHex: $0, fallback: fallbackColor) }
+      ?? fallbackColor
+    let attributed =
+      button.attributedTitle(for: .normal)
+      .map { NSMutableAttributedString(attributedString: $0) }
+      ?? NSMutableAttributedString(string: text)
+    let paragraph =
+      (attributed.attribute(.paragraphStyle, at: 0, effectiveRange: nil)
+      as? NSParagraphStyle)?.mutableCopy() as? NSMutableParagraphStyle ?? NSMutableParagraphStyle()
+    if let alignmentName = style["alignment"] as? String {
+      paragraph.alignment = marketTextAlignment(
+        alignmentName, direction: button.effectiveUserInterfaceLayoutDirection)
+      button.contentHorizontalAlignment =
+        alignmentName == "start"
+        ? .leading
+        : alignmentName == "end" ? .trailing : .center
+    }
+    var attributes: [NSAttributedString.Key: Any] = [:]
+    applyStyledFont(attributed, style, fallback: baseFont)
+    if style["color"] != nil { attributes[.foregroundColor] = color }
+    if style["alignment"] != nil || style["lineHeight"] != nil || style["lines"] != nil
+      || style["truncate"] != nil
+    {
+      attributes[.paragraphStyle] = paragraph
+    }
+    if style["lineHeight"] != nil {
+      let box = CGFloat(style.double("lineHeight"))
+      paragraph.minimumLineHeight = box
+      paragraph.maximumLineHeight = box
+      attributes[.baselineOffset] = max(0, (box - font.lineHeight) / 2)
+      if accessory?.marketLineHeight != nil { accessory?.marketLineHeight = box }
+      if accessory?.selectorSummaryLineHeight != nil { accessory?.selectorSummaryLineHeight = box }
+    }
+    if style["lines"] != nil {
+      button.titleLabel?.numberOfLines = min(3, max(1, style.int("lines", default: 1)))
+    }
+    if style["lines"] != nil || style["truncate"] != nil {
+      let mode = styledLineBreakMode(style, lines: button.titleLabel?.numberOfLines ?? 1)
+      button.titleLabel?.lineBreakMode = mode
+      paragraph.lineBreakMode = mode
+      if button.titleLabel?.numberOfLines == 1 { normalizeSingleLine(attributed) }
+    }
+    if let alignment = style["verticalAlignment"] as? String {
+      button.contentVerticalAlignment =
+        alignment == "top" ? .top : alignment == "bottom" ? .bottom : .center
+    }
+    if style["offsetY"] != nil {
+      (button as? NativeListAccessoryButton)?.rowTextOffsetY = CGFloat(style.double("offsetY"))
+    }
+    button.titleLabel?.font = font
+    attributed.addAttributes(attributes, range: NSRange(location: 0, length: attributed.length))
+    button.setAttributedTitle(attributed, for: .normal)
+  }
+
+  static func applyStyledFont(
+    _ text: NSMutableAttributedString, _ style: [String: Any], fallback: UIFont
+  ) {
+    guard style["fontSize"] != nil || style["fontWeight"] != nil else { return }
+    text.enumerateAttribute(.font, in: NSRange(location: 0, length: text.length)) {
+      value, range, _ in
+      let original = (value as? UIFont) ?? fallback
+      let size = CGFloat(style.double("fontSize", default: Double(original.pointSize)))
+      let font =
+        style["fontWeight"] == nil
+        ? original.withSize(size)
+        : nativeListFont(
+          ofSize: size, weight: marketFontWeight(style.string("fontWeight"), fallback: .regular))
+      text.addAttribute(.font, value: font, range: range)
+    }
+  }
+
+  static func normalizeSingleLine(_ text: NSMutableAttributedString) {
+    let pattern = try! NSRegularExpression(pattern: "\\r\\n|[\\r\\n]")
+    for match in pattern.matches(in: text.string, range: NSRange(location: 0, length: text.length))
+      .reversed()
+    {
+      text.replaceCharacters(in: match.range, with: " ")
+    }
+  }
+
+  static func styledLineBreakMode(_ style: [String: Any], lines: Int) -> NSLineBreakMode {
+    if style.string("truncate", default: "tail") != "clip" { return .byTruncatingTail }
+    // Clipping disables wrapping; multi-line clip must wrap without adding an ellipsis.
+    return lines == 1 ? .byClipping : .byWordWrapping
+  }
+
+  static func marketFontWeight(_ value: String, fallback: NativeListFontWeight)
+    -> NativeListFontWeight
+  {
+    switch value {
+    case "regular": return .regular
+    case "semibold": return .semibold
+    case "bold": return .bold
+    case "medium": return .medium
+    default: return fallback
+    }
+  }
+
+  /// Legacy selector/warning typography: monospaced digits and zero kerning on the label.
+  static func applyTabularDigits(_ label: UILabel) {
+    guard let font = label.font else { return }
+    label.font = tabularDigitsFont(font)
+    guard let original = label.attributedText else { return }
+    let result = NSMutableAttributedString(attributedString: original)
+    let range = NSRange(location: 0, length: result.length)
+    result.addAttribute(.kern, value: 0, range: range)
+    original.enumerateAttribute(.font, in: range) { value, range, _ in
+      if let font = value as? UIFont {
+        result.addAttribute(.font, value: tabularDigitsFont(font), range: range)
+      }
+    }
+    label.attributedText = result
+  }
+
+  static func tabularDigitsFont(_ font: UIFont) -> UIFont {
+    var settings =
+      font.fontDescriptor.fontAttributes[.featureSettings] as? [[UIFontDescriptor.FeatureKey: Int]]
+      ?? []
+    settings.removeAll { $0[.type] == kNumberSpacingType }
+    settings.append([.type: kNumberSpacingType, .selector: kMonospacedNumbersSelector])
+    return UIFont(
+      descriptor: font.fontDescriptor.addingAttributes([.featureSettings: settings]),
+      size: font.pointSize)
+  }
+
+  static func marketTextAlignment(_ value: String, direction: UIUserInterfaceLayoutDirection)
+    -> NSTextAlignment
+  {
+    switch value {
+    case "center": return .center
+    case "start": return direction == .rightToLeft ? .right : .left
+    case "end": return direction == .rightToLeft ? .left : .right
+    default: return .natural
+    }
+  }
+}

package/ios/NativeListWalletGroupRenderer.swift

@@ -0,0 +1,255 @@
+import UIKit
+
+/// Composite only: member content, assets and local styles belong to Identity.
+final class NativeListWalletGroupCell: NativeListRendererCell, UIGestureRecognizerDelegate {
+  private struct MemberView {
+    let cell: NativeListIdentityCell
+    let height: NSLayoutConstraint
+  }
+  private var members: [NativeListItem] = []
+  private var memberViews: [String: MemberView] = [:]
+  private var compactCell: NativeListIdentityCell?
+  private let compactContainer = UIView()
+  private let dragBadge = NativeListInsetLabel()
+  private var compact = false
+  private lazy var memberTap = UITapGestureRecognizer(
+    target: self, action: #selector(memberPressed(_:)))
+  override var usesIntrinsicContentHeight: Bool { true }
+  override var defaultCornerRadius: CGFloat { 20 }
+  override var defaultCornerCurve: CALayerCornerCurve { .continuous }
+  override var defaultBorderWidth: CGFloat { 1 }
+  override var pressChangesBackground: Bool { false }
+  override var showsSelection: Bool { false }
+  // Legacy fill is `subduedBackground`; the group's row-level `backgroundColor` is ignored.
+  override var honorsRowBackgroundColor: Bool { false }
+  override func defaultBorderColor(_ theme: [String: Any]?) -> UIColor {
+    nativeListColor(theme, "separator", "#E0E0E0")
+  }
+  override func unselectedBackground(
+    _ item: NativeListItem, theme: [String: Any]?, layout: String, itemIndex: Int?
+  ) -> UIColor {
+    nativeListColor(theme, "subduedBackground", "#F9F9F9")
+  }
+  private static func memberItems(_ item: NativeListItem) -> [NativeListItem] {
+    ([item.data.dictionary("parent")].compactMap { $0 } + item.data.dictionaries("children"))
+      .compactMap { try? NativeListItem(data: $0) }
+  }
+  private static func memberHeight(_ item: NativeListItem) -> CGFloat {
+    item.styledHeight
+      ?? (item.data["height"] != nil
+        ? CGFloat(item.data.double("height"))
+        // Legacy member default is independent of the member's presentation.
+        : item.data.dictionaries("badges").isEmpty ? 68 : 92)
+  }
+  /// Legacy default: a one-point inset (source group border) when the parent carries an
+  /// explicit height, otherwise none. `style.*Padding` overrides it; bind and measure share it.
+  private static func padding(_ item: NativeListItem, members: [NativeListItem]) -> (
+    horizontal: CGFloat, vertical: CGFloat
+  ) {
+    let style = item.data.dictionary("style") ?? [:]
+    let inset: Double = members.first?.data["height"] != nil ? 1 : 0
+    return (
+      CGFloat(style.double("horizontalPadding", default: inset)),
+      CGFloat(style.double("verticalPadding", default: inset))
+    )
+  }
+  override class func appliesSizePreset(_ item: NativeListItem) -> Bool { false }
+  override class func measure(
+    _ item: NativeListItem, width: CGFloat, theme: [String: Any]?, layout: String
+  ) -> CGFloat? {
+    let members = memberItems(item)
+    return members.reduce(
+      CGFloat(max(0, members.count - 1) * 12) + padding(item, members: members).vertical * 2
+    ) { $0 + memberHeight($1) }
+  }
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+    root.axis = .vertical
+    root.alignment = .fill
+    root.spacing = 12
+    memberTap.delegate = self
+    root.addGestureRecognizer(memberTap)
+    compactContainer.translatesAutoresizingMaskIntoConstraints = false
+    compactContainer.isUserInteractionEnabled = false
+    compactContainer.isHidden = true
+    contentView.addSubview(compactContainer)
+    dragBadge.translatesAutoresizingMaskIntoConstraints = false
+    dragBadge.horizontalInset = 6
+    dragBadge.textAlignment = .center
+    dragBadge.font = nativeListTabularFont(ofSize: 12, weight: .semibold)
+    dragBadge.layer.cornerRadius = 12
+    dragBadge.layer.masksToBounds = true
+    dragBadge.layer.borderWidth = 1
+    compactContainer.addSubview(dragBadge)
+    NSLayoutConstraint.activate([
+      compactContainer.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),
+      compactContainer.trailingAnchor.constraint(equalTo: contentView.trailingAnchor),
+      compactContainer.topAnchor.constraint(equalTo: contentView.topAnchor),
+      compactContainer.heightAnchor.constraint(equalToConstant: 68),
+      dragBadge.trailingAnchor.constraint(equalTo: compactContainer.trailingAnchor, constant: -4),
+      dragBadge.bottomAnchor.constraint(equalTo: compactContainer.bottomAnchor, constant: -4),
+      dragBadge.heightAnchor.constraint(equalToConstant: 24),
+      dragBadge.widthAnchor.constraint(greaterThanOrEqualToConstant: 24),
+    ])
+  }
+  required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+  override func accessibilityText(_ item: NativeListItem) -> String {
+    item.data.string(
+      "accessibilityLabel", default: item.data.dictionary("parent")?.string("title") ?? "")
+  }
+  override func bindContent(
+    _ item: NativeListItem, theme: [String: Any]?, layout: String,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String
+  ) {
+    members = Self.memberItems(item)
+    let keys = Set(members.map(\.key))
+    for key in Array(memberViews.keys) where !keys.contains(key) {
+      let view = memberViews.removeValue(forKey: key)!
+      view.cell.prepareForReuse()
+      root.removeArrangedSubview(view.cell)
+      view.cell.removeFromSuperview()
+    }
+    let (horizontal, vertical) = Self.padding(item, members: members)
+    contentInsets = UIEdgeInsets(
+      top: vertical, left: horizontal, bottom: vertical, right: horizontal)
+    for (index, member) in members.enumerated() {
+      let view: MemberView
+      if let existing = memberViews[member.key] {
+        view = existing
+      } else {
+        let cell = NativeListIdentityCell(frame: .zero)
+        cell.translatesAutoresizingMaskIntoConstraints = false
+        let height = cell.heightAnchor.constraint(equalToConstant: Self.memberHeight(member))
+        height.isActive = true
+        view = MemberView(cell: cell, height: height)
+        memberViews[member.key] = view
+        cell.onAction = { [weak self] item, action, target, origin in
+          self?.onAction?(item, action, target, origin)
+        }
+        cell.onBindingInvalidated = { [weak self] cell, epoch in
+          self?.onBindingInvalidated?(cell, epoch)
+        }
+      }
+      view.height.constant = Self.memberHeight(member)
+      view.cell.listStyle = listStyle
+      view.cell.bind(
+        item: member, theme: theme, layout: layout, selected: member.data.bool("selected"),
+        checkboxState: checkboxState)
+      root.insertArrangedSubview(view.cell, at: index)
+    }
+    if let parent = members.first {
+      if compactCell == nil {
+        let cell = NativeListIdentityCell(frame: .zero)
+        cell.translatesAutoresizingMaskIntoConstraints = false
+        compactContainer.insertSubview(cell, at: 0)
+        NSLayoutConstraint.activate([
+          cell.leadingAnchor.constraint(equalTo: compactContainer.leadingAnchor),
+          cell.trailingAnchor.constraint(equalTo: compactContainer.trailingAnchor),
+          cell.topAnchor.constraint(equalTo: compactContainer.topAnchor),
+          cell.bottomAnchor.constraint(equalTo: compactContainer.bottomAnchor),
+        ])
+        compactCell = cell
+      }
+      compactCell?.listStyle = listStyle
+      compactCell?.bind(
+        item: parent, theme: theme, layout: layout, selected: parent.data.bool("selected"),
+        checkboxState: checkboxState)
+    }
+    let count = members.dropFirst().filter { ($0.data["draggable"] as? Bool) != false }.count
+    dragBadge.text = count > 0 ? "+\(count)" : nil
+    dragBadge.isHidden = count == 0
+    dragBadge.backgroundColor = nativeListColor(theme, "inverseBackground", "#202020")
+    dragBadge.textColor = nativeListColor(theme, "inverseText", "#FCFCFC")
+    dragBadge.layer.borderColor = nativeListColor(theme, "rowBackground", "#FFFFFF").cgColor
+  }
+  override func bindSelectionContent(
+    _ item: NativeListItem,
+    checkboxState: (NativeListItem, NativeSelectionTarget?, String) -> String
+  ) {
+    members = Self.memberItems(item)
+    for member in members {
+      memberViews[member.key]?.cell.updateSelection(
+        item: member, selected: member.data.bool("selected"), checkboxState: checkboxState)
+    }
+    if let parent = members.first {
+      compactCell?.updateSelection(
+        item: parent, selected: parent.data.bool("selected"), checkboxState: checkboxState)
+    }
+  }
+  func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch)
+    -> Bool
+  {
+    var view = touch.view
+    while let current = view, current !== root {
+      if current is UIControl { return false }
+      view = current.superview
+    }
+    return true
+  }
+  @objc private func memberPressed(_ gesture: UITapGestureRecognizer) {
+    let point = gesture.location(in: root)
+    for member in members {
+      guard let cell = memberViews[member.key]?.cell, cell.frame.contains(point) else { continue }
+      if !member.data.bool("disabled") && !member.data.bool("pressDisabled") {
+        onAction?(member, "press", nil, cell.rowActionOrigin())
+      }
+      return
+    }
+  }
+  override func canStartWalletGroupReorder(at point: CGPoint) -> Bool {
+    let point = root.convert(point, from: self)
+    for member in members where memberViews[member.key]?.cell.frame.contains(point) == true {
+      // Legacy: only `draggable: false` excludes a member; disabled members may start a drag.
+      return (member.data["draggable"] as? Bool) != false
+    }
+    return true
+  }
+  override func applyAppearance() {
+    super.applyAppearance()
+    if compact {
+      contentView.backgroundColor = .clear
+      contentView.layer.borderWidth = 0
+    }
+  }
+  override func setPressed(_ pressed: Bool) {
+    if compact { compactCell?.setPressed(pressed) } else { super.setPressed(pressed) }
+  }
+  override func setWalletGroupReorderCompact(_ compact: Bool) {
+    self.compact = compact
+    root.isHidden = compact
+    root.alpha = compact ? 0 : 1
+    compactContainer.isHidden = !compact
+    compactContainer.alpha = compact ? 1 : 0
+    applyAppearance()
+  }
+  override func prepareWalletGroupReorderExpansion() {
+    compact = false
+    root.isHidden = false
+    root.alpha = 0
+    compactContainer.isHidden = false
+    compactContainer.alpha = 1
+    applyAppearance()
+  }
+  override func animateWalletGroupReorderExpansion() {
+    root.alpha = 1
+    compactContainer.alpha = 0
+  }
+  override func finishWalletGroupReorderExpansion() { setWalletGroupReorderCompact(false) }
+  override func recycleContent() {
+    for view in memberViews.values {
+      view.cell.prepareForReuse()
+      view.cell.removeFromSuperview()
+    }
+    memberViews.removeAll()
+    members.removeAll()
+    compactCell?.prepareForReuse()
+    compactCell?.removeFromSuperview()
+    compactCell = nil
+    compact = false
+    root.isHidden = false
+    root.alpha = 1
+    compactContainer.isHidden = true
+    compactContainer.alpha = 1
+    dragBadge.text = nil
+  }
+}