craft-native 0.0.123 → 0.0.125

package/dist/ios/templates/CraftNativeFlatList.swift

@@ -9,10 +9,10 @@ private final class CraftNativeFlatListLayout: UICollectionViewFlowLayout {
     }
 }
 
-/// A keyed, recycling native list used by the stx-native FlatList primitive.
+/// A keyed, recycling native list used by stx's native FlatList primitive.
 /// The screen controller owns rendered row state; this view owns collection
 /// diffs, viewport state, and UICollectionView cell reuse.
-final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowLayout {
+final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowLayout, UIGestureRecognizerDelegate {
     typealias RenderItem = (_ node: [String: Any], _ identity: String, _ previous: UIView?) -> UIView
 
     private final class Cell: UICollectionViewCell {
@@ -21,6 +21,9 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         private(set) var representedIdentity: String?
         private(set) var hostedView: UIView?
         var onRecycle: ((String) -> Void)?
+        /// The width (or, sideways, height) the list gives this row, so a row
+        /// is measured at the list's width rather than the layout's estimate.
+        var fittingExtent: CGFloat?
 
         override func prepareForReuse() {
             super.prepareForReuse()
@@ -56,13 +59,33 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         ) -> UICollectionViewLayoutAttributes {
             guard let hostedView = hostedView else { return layoutAttributes }
             let attributes = layoutAttributes.copy() as! UICollectionViewLayoutAttributes
-            let target = CGSize(width: layoutAttributes.size.width, height: UIView.layoutFittingCompressedSize.height)
-            let measured = hostedView.systemLayoutSizeFitting(
-                target,
-                withHorizontalFittingPriority: .required,
-                verticalFittingPriority: .fittingSizeLevel
-            )
-            attributes.size.height = max(1, measured.height)
+            // A cell has no collectionView property; the list is its nearest
+            // collection view ancestor.
+            var ancestor = superview
+            while let view = ancestor, !(view is UICollectionView) { ancestor = view.superview }
+            if let collectionView = ancestor as? UICollectionView,
+               let flowLayout = collectionView.collectionViewLayout as? UICollectionViewFlowLayout,
+               flowLayout.scrollDirection == .horizontal {
+                let height = fittingExtent ?? layoutAttributes.size.height
+                let measured = CraftNativeFlexLayout.measure(
+                    hostedView,
+                    width: nil,
+                    height: height,
+                    maxWidth: CraftNativeFlexLayout.unbounded,
+                    maxHeight: height
+                )
+                attributes.size = CGSize(width: max(1, ceil(measured.width)), height: max(1, height))
+            } else {
+                let width = fittingExtent ?? layoutAttributes.size.width
+                let measured = CraftNativeFlexLayout.measure(
+                    hostedView,
+                    width: width,
+                    height: nil,
+                    maxWidth: width,
+                    maxHeight: CraftNativeFlexLayout.unbounded
+                )
+                attributes.size = CGSize(width: max(1, width), height: max(1, ceil(measured.height)))
+            }
             return attributes
         }
     }
@@ -86,11 +109,24 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
     private var renderItem: RenderItem?
     private var recycleItem: ((String) -> Void)?
     private var endReached: (() -> Void)?
+    var onScrollEvent: ((UIScrollView) -> Void)?
+    /// Called as the visible rows move, for a screen that lays out around them.
+    var onLayoutChanged: (() -> Void)?
+    var onScrollBeginDrag: ((UIScrollView) -> Void)?
+    var onScrollEndDrag: ((UIScrollView) -> Void)?
+    var onMomentumScrollBegin: ((UIScrollView) -> Void)?
+    var onMomentumScrollEnd: ((UIScrollView) -> Void)?
     private var endReachedThreshold = 0.1
     private var endReachedSignature: String?
+    private var dataContentSignature = ""
     private var columns = 1
     private var isApplyingSnapshot = false
     private var pendingApply: (() -> Void)?
+    private var pendingThemeRefresh = false
+    private let nativeRefreshControl = UIRefreshControl()
+    private var refreshHandler: (() -> Void)?
+    private let keyboardTapGesture = UITapGestureRecognizer()
+    private var keyboardShouldPersistTaps = "never"
 
     init() {
         let layout = CraftNativeFlatListLayout()
@@ -102,7 +138,12 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         backgroundColor = .clear
         alwaysBounceVertical = true
         delegate = self
+        keyboardTapGesture.cancelsTouchesInView = false
+        keyboardTapGesture.delegate = self
+        keyboardTapGesture.addTarget(self, action: #selector(keyboardTap))
+        addGestureRecognizer(keyboardTapGesture)
         register(Cell.self, forCellWithReuseIdentifier: Cell.reuseIdentifier)
+        nativeRefreshControl.addTarget(self, action: #selector(refreshTriggered), for: .valueChanged)
         diffableDataSource = UICollectionViewDiffableDataSource<Int, String>(collectionView: self) {
             [weak self] collectionView, indexPath, identity in
             guard let self = self,
@@ -114,6 +155,7 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
                   let renderItem = self.renderItem else { return UICollectionViewCell() }
             let view = renderItem(item.node, identity, cell.hostedView)
             cell.onRecycle = self.recycleItem
+            cell.fittingExtent = self.itemExtent(isChrome: item.isChrome)
             cell.host(view, identity: identity)
             return cell
         }
@@ -121,6 +163,123 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
 
     required init?(coder: NSCoder) { nil }
 
+    /// Called when a list that does not scroll changes height, so the
+    /// containers around it make room.
+    var onFittingHeightChanged: (() -> Void)?
+
+    override var contentSize: CGSize {
+        didSet {
+            guard !isScrollEnabled, abs(oldValue.height - contentSize.height) > 0.5 else { return }
+            invalidateIntrinsicContentSize()
+            onFittingHeightChanged?()
+        }
+    }
+
+    override var isScrollEnabled: Bool {
+        didSet {
+            guard isScrollEnabled != oldValue else { return }
+            alwaysBounceVertical = isScrollEnabled && flowLayout.scrollDirection == .vertical
+            onFittingHeightChanged?()
+        }
+    }
+
+    /// The height of every row at `width`: what a list that does not scroll
+    /// (`scrollEnabled={false}`) takes inside a scroll view or a column.
+    /// Rows not measured yet count at their estimate, and the list asks for
+    /// room again as they are.
+    func fittingHeight(width: CGFloat) -> CGFloat {
+        guard !isScrollEnabled else { return 0 }
+        if abs(bounds.width - width) > 0.5 { frame.size.width = width }
+        layoutIfNeeded()
+        let content = flowLayout.collectionViewContentSize.height
+        return max(0, ceil(content + contentInset.top + contentInset.bottom))
+    }
+
+    /// The width a row gets: the list's own width inside its content padding,
+    /// shared between columns for data rows.
+    private func itemExtent(isChrome: Bool) -> CGFloat {
+        if flowLayout.scrollDirection == .horizontal {
+            return max(1, bounds.height - adjustedContentInset.top - adjustedContentInset.bottom)
+        }
+        let width = max(1, bounds.width - adjustedContentInset.left - adjustedContentInset.right)
+        let count = isChrome ? 1 : columns
+        let spacing = flowLayout.minimumInteritemSpacing * CGFloat(count - 1)
+        return max(1, (width - spacing) / CGFloat(count))
+    }
+
+    override func layoutSubviews() {
+        let estimate = flowLayout.scrollDirection == .horizontal
+            ? CGSize(width: 44, height: itemExtent(isChrome: true))
+            : CGSize(width: itemExtent(isChrome: false), height: 44)
+        if flowLayout.estimatedItemSize != estimate, bounds.width > 0 {
+            flowLayout.estimatedItemSize = estimate
+        }
+        super.layoutSubviews()
+        craftApplyCornerRadius()
+    }
+
+    func setContentContainerStyle(_ raw: [String: Any]?) {
+        func number(_ value: Any?) -> CGFloat? { (value as? NSNumber).map { CGFloat(truncating: $0) } }
+        let padding = number(raw?["padding"]) ?? 0
+        let horizontal = number(raw?["paddingHorizontal"]) ?? padding
+        let vertical = number(raw?["paddingVertical"]) ?? padding
+        contentInset = UIEdgeInsets(
+            top: number(raw?["paddingTop"]) ?? vertical,
+            left: number(raw?["paddingLeft"]) ?? horizontal,
+            bottom: number(raw?["paddingBottom"]) ?? vertical,
+            right: number(raw?["paddingRight"]) ?? horizontal
+        )
+        scrollIndicatorInsets = contentInset
+        collectionViewLayout.invalidateLayout()
+    }
+
+    func setKeyboardShouldPersistTaps(_ value: Any?) {
+        let requested = value as? String
+        keyboardShouldPersistTaps = ["always", "handled", "never"].contains(requested) ? requested! : "never"
+        keyboardTapGesture.isEnabled = keyboardShouldPersistTaps != "always"
+    }
+
+    private var refreshingProp = false
+
+    /// `onRefresh` and `refreshing`, controlled as in React Native: a pull
+    /// the screen does not answer with `refreshing` true ends at once.
+    func setRefreshHandler(_ handler: (() -> Void)?, refreshing: Bool) {
+        refreshHandler = handler
+        refreshingProp = refreshing
+        let control = handler == nil ? nil : nativeRefreshControl
+        if refreshControl !== control { refreshControl = control }
+        if handler == nil || !refreshing {
+            if nativeRefreshControl.isRefreshing { nativeRefreshControl.endRefreshing() }
+        } else if !nativeRefreshControl.isRefreshing {
+            nativeRefreshControl.beginRefreshing()
+        }
+    }
+
+    @objc private func refreshTriggered() {
+        refreshHandler?()
+        DispatchQueue.main.async { [weak self] in
+            guard let self, !self.refreshingProp, self.nativeRefreshControl.isRefreshing else { return }
+            self.nativeRefreshControl.endRefreshing()
+        }
+    }
+
+    @objc private func keyboardTap() {
+        guard keyboardShouldPersistTaps != "always" else { return }
+        if keyboardShouldPersistTaps == "handled" {
+            let point = keyboardTapGesture.location(in: self)
+            var hit = hitTest(point, with: nil)
+            while let view = hit, view !== self {
+                if view is UIControl || !(view.gestureRecognizers ?? []).isEmpty { return }
+                hit = view.superview
+            }
+        }
+        window?.endEditing(true)
+    }
+
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+        true
+    }
+
     var visibleItemIdentities: [String] {
         indexPathsForVisibleItems
             .sorted { $0.item < $1.item }
@@ -220,7 +379,11 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         }
 
         let dataItems = next.filter { !$0.isChrome }
-        let contentSignature = "\(dataItems.count):\(dataItems.last?.identity ?? "empty")"
+        let contentSignature = dataItems.map {
+            let encoded = $0.signature.base64EncodedString()
+            return "\($0.identity.utf8.count):\($0.identity)\(encoded.utf8.count):\(encoded)"
+        }.joined()
+        dataContentSignature = contentSignature
         if contentSignature != endReachedSignature { endReachedSignature = nil }
     }
 
@@ -232,9 +395,53 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         renderItem = nil
         recycleItem = nil
         endReached = nil
+        dataContentSignature = ""
+        onScrollEvent = nil
+        onLayoutChanged = nil
+        onScrollBeginDrag = nil
+        onScrollEndDrag = nil
+        onMomentumScrollBegin = nil
+        onMomentumScrollEnd = nil
+        pendingThemeRefresh = false
+    }
+
+    func refreshThemeDefaults() {
+        if isApplyingSnapshot {
+            pendingThemeRefresh = true
+            return
+        }
+        var snapshot = diffableDataSource.snapshot()
+        let identities = snapshot.itemIdentifiers
+        guard !identities.isEmpty else { return }
+        pendingThemeRefresh = false
+        snapshot.reconfigureItems(identities)
+        isApplyingSnapshot = true
+        diffableDataSource.apply(snapshot, animatingDifferences: false) { [weak self] in
+            self?.finishApplyingSnapshot()
+        }
+    }
+
+    func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        onScrollEvent?(scrollView)
+        onLayoutChanged?()
+        evaluateEndReached()
+    }
+
+    func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
+        onScrollBeginDrag?(scrollView)
     }
 
-    func scrollViewDidScroll(_ scrollView: UIScrollView) { evaluateEndReached() }
+    func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
+        onScrollEndDrag?(scrollView)
+    }
+
+    func scrollViewWillBeginDecelerating(_ scrollView: UIScrollView) {
+        onMomentumScrollBegin?(scrollView)
+    }
+
+    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
+        onMomentumScrollEnd?(scrollView)
+    }
 
     func collectionView(
         _ collectionView: UICollectionView,
@@ -244,11 +451,9 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         guard items.indices.contains(indexPath.item) else { return CGSize(width: bounds.width, height: 44) }
         let item = items[indexPath.item]
         if flowLayout.scrollDirection == .horizontal {
-            return CGSize(width: max(1, bounds.width * 0.8), height: max(1, bounds.height))
+            return CGSize(width: 44, height: itemExtent(isChrome: item.isChrome))
         }
-        let count = item.isChrome ? 1 : columns
-        let spacing = flowLayout.minimumInteritemSpacing * CGFloat(count - 1)
-        return CGSize(width: max(1, (bounds.width - spacing) / CGFloat(count)), height: 44)
+        return CGSize(width: itemExtent(isChrome: item.isChrome), height: 44)
     }
 
     private func evaluateEndReached() {
@@ -261,8 +466,7 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         let remaining = dataIndices.count - lastDataOrdinal - 1
         let thresholdItems = max(1, Int(ceil(Double(dataIndices.count) * endReachedThreshold)))
         guard remaining <= thresholdItems else { return }
-        let lastIdentity = items[dataIndices[dataIndices.count - 1]].identity
-        let signature = "\(dataIndices.count):\(lastIdentity)"
+        let signature = dataContentSignature
         guard endReachedSignature != signature else { return }
         endReachedSignature = signature
         endReached()
@@ -277,6 +481,11 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
                 pendingApply()
                 return
             }
+            if self.pendingThemeRefresh {
+                self.pendingThemeRefresh = false
+                self.refreshThemeDefaults()
+                return
+            }
             self.evaluateEndReached()
         }
     }