craft-native 0.0.122 → 0.0.124

package/dist/ios/templates/CraftNativeActions.swift

@@ -44,6 +44,10 @@ enum CraftNativeActions {
             guard config.enableHaptics else { return failure("CAPABILITY_DISABLED", "Haptics is disabled") }
             triggerHaptic(style: body["style"] as? String ?? "medium")
             return .success(true)
+        case "hapticPrepare":
+            guard config.enableHaptics else { return failure("CAPABILITY_DISABLED", "Haptics is disabled") }
+            CraftHaptics.prepare(body["kind"] as? String)
+            return .success(true)
         case "clipboardWrite":
             guard config.enableClipboard else { return failure("CAPABILITY_DISABLED", "Clipboard is disabled") }
             guard let text = body["text"] as? String else {
@@ -82,6 +86,12 @@ enum CraftNativeActions {
             sync = perform(action: "getDeviceInfo", body: [:], config: config)
         case ("Haptics", "impact"):
             sync = perform(action: "haptic", body: ["style": args.first ?? NSNull()], config: config)
+        case ("Haptics", "notification"):
+            sync = perform(action: "haptic", body: ["style": (args.first as? String) ?? "success"], config: config)
+        case ("Haptics", "selection"):
+            sync = perform(action: "haptic", body: ["style": "selection"], config: config)
+        case ("Haptics", "prepare"):
+            sync = perform(action: "hapticPrepare", body: ["kind": args.first ?? NSNull()], config: config)
         case ("Clipboard", "write"):
             sync = perform(action: "clipboardWrite", body: ["text": args.first ?? NSNull()], config: config)
         case ("Clipboard", "read"):
@@ -460,15 +470,7 @@ enum CraftNativeActions {
     }
 
     static func triggerHaptic(style: String) {
-        switch style {
-        case "light": UIImpactFeedbackGenerator(style: .light).impactOccurred()
-        case "heavy": UIImpactFeedbackGenerator(style: .heavy).impactOccurred()
-        case "success": UINotificationFeedbackGenerator().notificationOccurred(.success)
-        case "warning": UINotificationFeedbackGenerator().notificationOccurred(.warning)
-        case "error": UINotificationFeedbackGenerator().notificationOccurred(.error)
-        case "selection": UISelectionFeedbackGenerator().selectionChanged()
-        default: UIImpactFeedbackGenerator(style: .medium).impactOccurred()
-        }
+        CraftHaptics.play(style)
     }
 
     static func currentAppState() -> String {
@@ -532,3 +534,89 @@ enum CraftNativeActions {
         ]
     }
 }
+
+/// The Taptic Engine's generators, held for the life of the process.
+///
+/// Each haptic used to make a fresh generator at the moment of the tap. A new
+/// generator has to wake the engine before it can play, which is the tens of
+/// milliseconds between a finger landing and the feel that makes web haptics
+/// read as late. These are made once, prepared again after every use, and
+/// `prepare` lets a page warm one before a gesture it knows is coming (the
+/// start of a drag, a long press about to complete).
+///
+/// The three kinds are the three UIKit has, and they are not interchangeable:
+/// a notification is the success, warning or error pattern, a selection is the
+/// detent a picker plays, and an impact is a single tap at one of five weights.
+/// The page used to get impacts for all of them.
+///
+/// Main thread only, like every UIFeedbackGenerator. Every caller is.
+enum CraftHaptics {
+    private static var impacts: [UIImpactFeedbackGenerator.FeedbackStyle: UIImpactFeedbackGenerator] = [:]
+    private static var notifier: UINotificationFeedbackGenerator?
+    private static var selector: UISelectionFeedbackGenerator?
+
+    /// An impact weight by name, or nil for a name that is not one.
+    static func impactStyle(_ name: String) -> UIImpactFeedbackGenerator.FeedbackStyle? {
+        switch name {
+        case "light": return .light
+        case "medium": return .medium
+        case "heavy": return .heavy
+        case "soft": return .soft
+        case "rigid": return .rigid
+        default: return nil
+        }
+    }
+
+    /// Play one haptic: an impact weight, a notification type, or `selection`.
+    /// Anything else plays a medium impact, as an unknown style always has.
+    static func play(_ style: String) {
+        switch style {
+        case "success": notification().notificationOccurred(.success); notification().prepare()
+        case "warning": notification().notificationOccurred(.warning); notification().prepare()
+        case "error": notification().notificationOccurred(.error); notification().prepare()
+        case "selection": selection().selectionChanged(); selection().prepare()
+        default:
+            let generator = impact(impactStyle(style) ?? .medium)
+            generator.impactOccurred()
+            generator.prepare()
+        }
+    }
+
+    /// Warm a generator so the next haptic plays without the engine's wake-up
+    /// delay. `impact`, `notification` or `selection` for one kind, an impact
+    /// weight or notification type for that one, nothing for all of them.
+    /// UIKit keeps a prepared engine awake for a few seconds only.
+    static func prepare(_ kind: String?) {
+        switch kind {
+        case "impact": impact(.medium).prepare()
+        case "notification", "success", "warning", "error": notification().prepare()
+        case "selection": selection().prepare()
+        case let name? where impactStyle(name) != nil: impact(impactStyle(name)!).prepare()
+        default:
+            impact(.medium).prepare()
+            notification().prepare()
+            selection().prepare()
+        }
+    }
+
+    private static func impact(_ style: UIImpactFeedbackGenerator.FeedbackStyle) -> UIImpactFeedbackGenerator {
+        if let generator = impacts[style] { return generator }
+        let generator = UIImpactFeedbackGenerator(style: style)
+        impacts[style] = generator
+        return generator
+    }
+
+    private static func notification() -> UINotificationFeedbackGenerator {
+        if let notifier { return notifier }
+        let generator = UINotificationFeedbackGenerator()
+        notifier = generator
+        return generator
+    }
+
+    private static func selection() -> UISelectionFeedbackGenerator {
+        if let selector { return selector }
+        let generator = UISelectionFeedbackGenerator()
+        selector = generator
+        return generator
+    }
+}

package/dist/ios/templates/CraftNativeFlatList.swift

@@ -56,13 +56,32 @@ 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 target = CGSize(
+                    width: UIView.layoutFittingCompressedSize.width,
+                    height: layoutAttributes.size.height
+                )
+                let measured = hostedView.systemLayoutSizeFitting(
+                    target,
+                    withHorizontalFittingPriority: .fittingSizeLevel,
+                    verticalFittingPriority: .required
+                )
+                attributes.size.width = max(1, measured.width)
+            } else {
+                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)
+            }
             return attributes
         }
     }
@@ -86,11 +105,20 @@ 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
 
     init() {
         let layout = CraftNativeFlatListLayout()
@@ -220,7 +248,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 +264,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 scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
+        onScrollEndDrag?(scrollView)
+    }
+
+    func scrollViewWillBeginDecelerating(_ scrollView: UIScrollView) {
+        onMomentumScrollBegin?(scrollView)
     }
 
-    func scrollViewDidScroll(_ scrollView: UIScrollView) { evaluateEndReached() }
+    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
+        onMomentumScrollEnd?(scrollView)
+    }
 
     func collectionView(
         _ collectionView: UICollectionView,
@@ -244,7 +320,7 @@ 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: max(1, bounds.height))
         }
         let count = item.isChrome ? 1 : columns
         let spacing = flowLayout.minimumInteritemSpacing * CGFloat(count - 1)
@@ -261,8 +337,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 +352,11 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
                 pendingApply()
                 return
             }
+            if self.pendingThemeRefresh {
+                self.pendingThemeRefresh = false
+                self.refreshThemeDefaults()
+                return
+            }
             self.evaluateEndReached()
         }
     }