craft-native 0.0.201 → 0.0.203

package/dist/ios/templates/CraftHybrid.swift

@@ -972,9 +972,26 @@ final class CraftHybridWebSlot: UIViewController {
     /// page's stack is all the page's.
     var depth: Int?
     let isTabRoot: Bool
-    /// The page has not reached `path` yet: the entry shows its background,
-    /// not the page it is leaving, until it has.
+    /// The page has not reached `path` yet: retain its last rendered content
+    /// until the replacement is ready.
     var awaitingPage = false
+    /// A slow page keeps the last rendered content until its replacement is
+    /// ready. This belongs to the incoming slot, beyond the push animation.
+    private(set) var waitingPageSnapshot: UIView?
+
+    func keepPageVisible(_ snapshot: UIView) {
+        waitingPageSnapshot?.removeFromSuperview()
+        snapshot.frame = view.bounds
+        snapshot.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        snapshot.accessibilityElementsHidden = true
+        view.addSubview(snapshot)
+        waitingPageSnapshot = snapshot
+    }
+
+    func pageBecameVisible() {
+        waitingPageSnapshot?.removeFromSuperview()
+        waitingPageSnapshot = nil
+    }
 
     init(path: String, depth: Int?, isTabRoot: Bool) {
         self.path = path
@@ -1023,6 +1040,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     private var tabSwipeRecognizers: [UIGestureRecognizer] = []
     private var activeTabSwipeTarget: String?
     private var tabSwipeSettling = false
+    private var tabSwipeGeneration: UInt = 0
     /// The edge the incoming tab started from for the current gesture. Keep
     /// this separate from the live frame: deriving it after the drag begins
     /// makes the target jump when the translation crosses the midpoint.
@@ -1195,10 +1213,13 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         let end = completed ? 0 : direction * width
         let settlingDuration = completed ? 0.22 : 0.18
         let duration = CraftChrome.motion(.easeOut(duration: settlingDuration)) == nil ? 0 : settlingDuration
+        let generation = tabSwipeGeneration
         UIView.animate(withDuration: duration, delay: 0, options: [.curveEaseOut, .beginFromCurrentState], animations: {
             target.view.frame.origin.x = end
             current.view.frame.origin.x = completed ? -direction * width : 0
         }, completion: { _ in
+            guard self.tabSwipeGeneration == generation,
+                  self.activeTabSwipeTarget == targetId else { return }
             if completed {
                 current.view.isHidden = true
                 current.view.frame = self.view.bounds
@@ -1216,6 +1237,29 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         })
     }
 
+    /// A newer navigation action wins immediately, including a tap back on
+    /// the outgoing tab. Invalidate the old animation before removing it:
+    /// UIKit may deliver its completion while the replacement is starting.
+    private func interruptTabSwipe(restoringSelection: Bool) {
+        guard let targetId = activeTabSwipeTarget else { return }
+        tabSwipeGeneration &+= 1
+        activeTabSwipeTarget = nil
+        tabSwipeSettling = false
+        for nav in [visibleStack, stacks[targetId]].compactMap({ $0 }) {
+            nav.view.layer.removeAllAnimations()
+            nav.view.frame = view.bounds
+            nav.view.isHidden = nav !== visibleStack
+        }
+        // Cancel the current touch stream, so its later moved/ended events
+        // cannot claim another tab after the explicit navigation.
+        for recognizer in tabSwipeRecognizers {
+            recognizer.isEnabled = false
+            recognizer.isEnabled = true
+        }
+        CraftChrome.shared.cancelTabSwipe(restoringSelection: restoringSelection)
+        if visibleStack?.topViewController is CraftNativeScreenController { parkWeb() }
+    }
+
     private func horizontalScrollAt(_ point: CGPoint, in root: UIView) -> Bool {
         let local = root.convert(point, from: view)
         guard root.bounds.contains(local), let hit = root.hitTest(local, with: nil) else { return false }
@@ -1304,6 +1348,10 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         snapshot.autoresizingMask = [.flexibleWidth, .flexibleHeight]
         source.view.addSubview(snapshot)
         webTransitionSnapshots.append(snapshot)
+        if slot.awaitingPage,
+           let waiting = webHost.view.snapshotView(afterScreenUpdates: false) {
+            slot.keepPageVisible(waiting)
+        }
     }
 
     private var visibleStack: UINavigationController? { stacks[currentTab] }
@@ -1365,6 +1413,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     }
 
     private func show(tab id: String, rootPath: String? = nil) {
+        interruptTabSwipe(restoringSelection: false)
         cancelPendingTab()
         let nav = stacks[id] ?? makeStack(tab: id, rootPath: rootPath ?? (id.isEmpty ? hybrid.startPath : id))
         // A stack is hidden and shown rather than moved, so UIKit tells its
@@ -1395,6 +1444,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         attachWeb()
         moveWeb(to: slot, in: slot.view)
         webHost.view.alpha = slot.awaitingPage ? 0 : 1
+        if !slot.awaitingPage { slot.pageBecameVisible() }
         hybrid.setPageBase(slot.isTabRoot ? nil : slot.depth)
     }
 
@@ -1448,6 +1498,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     /// it), a tab's root, or a new one pushed.
     func showNative(path raw: String, replace: Bool, fromLink: Bool = false) {
         guard let match = hybrid.routes.match(raw) else { return }
+        interruptTabSwipe(restoringSelection: true)
         let tabs = hybrid.tabIds
         if let tab = tabs.first(where: { CraftHybridRoutes.normalize($0) == match.path }) {
             if tab != currentTab {
@@ -1483,6 +1534,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     /// slide, then the entry slides in over the screen that opened it.
     private func pushWeb(_ path: String) {
         guard hybrid.hasWeb, !openingWeb, let nav = visibleStack else { return }
+        interruptTabSwipe(restoringSelection: true)
         openingWeb = true
         hybrid.navigatePage(path) { [weak self, weak nav] depth in
             guard let self else { return }
@@ -1504,7 +1556,10 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     private func reveal(_ slot: CraftHybridWebSlot) {
         slot.awaitingPage = false
         guard let webHost, webHost.view.superview === slot.view else { return }
-        UIView.animate(withDuration: 0.15) { webHost.view.alpha = 1 }
+        // Commit the ready page and remove its placeholder in the same frame.
+        // Fading it up from zero exposed the slot's empty background again.
+        webHost.view.alpha = 1
+        slot.pageBecameVisible()
     }
 
     /// Back from the web entry on top, as the page's Back at that entry asks.
@@ -1557,7 +1612,11 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     // MARK: Tabs
 
     func tabTapped(_ id: String, reselect: Bool) -> Bool {
-        if reselect || id == currentTab {
+        let interruptedSwipe = activeTabSwipeTarget != nil
+        interruptTabSwipe(restoringSelection: false)
+        // The incoming tab is only a preview until the swipe commits, so a
+        // tap on its already-lit indicator is a selection, not a reselect.
+        if (reselect && !interruptedSwipe) || id == currentTab {
             guard let nav = stacks[id] else { return true }
             if nav.viewControllers.count > 1 {
                 nav.popToRootViewController(animated: true)

package/dist/ios/templates/CraftNativeFiles.swift

@@ -555,11 +555,13 @@ enum CraftNativeMedia {
         let staging = root.appendingPathComponent(UUID().uuidString + ".part")
         defer { try? fm.removeItem(at: staging) }
         do {
-            let size = (try location.resourceValues(forKeys: [.fileSizeKey])).fileSize ?? 0
+            // URL resource values can retain a previous size when a retry
+            // reuses a temporary location. Validate the current file itself.
+            let size = (try fm.attributesOfItem(atPath: location.path)[.size] as? NSNumber)?.int64Value ?? 0
             // URLSession normally rejects a truncated transfer; also guard this boundary.
             let expected = response.expectedContentLength
             let encoded = response.value(forHTTPHeaderField: "Content-Encoding")
-            if size <= 0 || (encoded == nil && expected >= 0 && Int64(size) != expected) {
+            if size <= 0 || (encoded == nil && expected >= 0 && size != expected) {
                 return .failure(CraftNativeActionError(code: "NETWORK_ERROR", message: "media.keep received an incomplete file"))
             }
             var folder = root

package/dist/ios/templates/CraftNativeFlatList.swift

@@ -1,11 +1,40 @@
 import UIKit
 
 private final class CraftNativeFlatListLayout: UICollectionViewFlowLayout {
+    private var preparedExtent: CGFloat?
+
+    override func prepare() {
+        // Content-size queries can prepare layout before layoutSubviews runs.
+        (collectionView as? CraftNativeFlatList)?.updateItemEstimate()
+        super.prepare()
+        preparedExtent = collectionView.map { extent(of: $0.bounds) }
+    }
+
+    private func extent(of bounds: CGRect) -> CGFloat {
+        scrollDirection == .vertical ? bounds.width : bounds.height
+    }
+
     override func shouldInvalidateLayout(forBoundsChange newBounds: CGRect) -> Bool {
-        guard let current = collectionView?.bounds else { return true }
-        return scrollDirection == .vertical
-            ? abs(current.width - newBounds.width) > .ulpOfOne
-            : abs(current.height - newBounds.height) > .ulpOfOne
+        guard let preparedExtent else { return true }
+        return abs(preparedExtent - extent(of: newBounds)) > .ulpOfOne
+    }
+
+    override func invalidationContext(forBoundsChange newBounds: CGRect) -> UICollectionViewLayoutInvalidationContext {
+        let context = super.invalidationContext(forBoundsChange: newBounds)
+        if shouldInvalidateLayout(forBoundsChange: newBounds), let flow = context as? UICollectionViewFlowLayoutInvalidationContext {
+            flow.invalidateFlowLayoutDelegateMetrics = true
+            flow.invalidateFlowLayoutAttributes = true
+            // Self-sized item dimensions are cached separately from flow
+            // metrics. Clear them before a narrower viewport validates old
+            // widths, while keeping the cells and their rendered state.
+            if let collectionView {
+                let paths = (0..<collectionView.numberOfSections).flatMap { section in
+                    (0..<collectionView.numberOfItems(inSection: section)).map { IndexPath(item: $0, section: section) }
+                }
+                flow.invalidateItems(at: paths)
+            }
+        }
+        return context
     }
 }
 
@@ -190,9 +219,30 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
     /// 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
+        // Flex measurement proposes several widths before committing a frame.
+        // Mutating the collection here lets self-sizing cache a provisional
+        // width and can reenter parent measurement through contentSize.didSet.
+        // Read the committed measurement, or estimate until layout measures
+        // rows at their actual width and onFittingHeightChanged asks for room.
+        let content: CGFloat
+        if abs(bounds.width - width) <= 0.5, contentSize.height > 0 {
+            content = contentSize.height
+        } else if flowLayout.scrollDirection == .horizontal {
+            content = items.isEmpty ? 0 : 44
+        } else {
+            var rows = 0
+            var pending = 0
+            for item in items {
+                if item.isChrome {
+                    rows += (pending + columns - 1) / columns + 1
+                    pending = 0
+                } else {
+                    pending += 1
+                }
+            }
+            rows += (pending + columns - 1) / columns
+            content = CGFloat(rows) * 44 + CGFloat(max(0, rows - 1)) * flowLayout.minimumLineSpacing
+        }
         return max(0, ceil(content + contentInset.top + contentInset.bottom))
     }
 
@@ -208,13 +258,17 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         return max(1, (width - spacing) / CGFloat(count))
     }
 
-    override func layoutSubviews() {
+    fileprivate func updateItemEstimate() {
         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
         }
+    }
+
+    override func layoutSubviews() {
+        updateItemEstimate()
         super.layoutSubviews()
         craftApplyCornerRadius()
     }

package/dist/ios/templates/CraftNativeScreen.swift

@@ -4650,16 +4650,22 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         /// The scroll view the screen starts with, when nothing sits above it:
         /// the root's first child, its first, and so on, none padded on top.
-        func leading(_ node: RenderedNode) -> UIScrollView? {
-            if let scroll = node.view as? CraftNativeScrollView { return scroll.isVertical && scroll.isScrollEnabled ? scroll : nil }
+        func leading(_ node: RenderedNode) -> RenderedNode? {
+            if let scroll = node.view as? CraftNativeScrollView { return scroll.isVertical && scroll.isScrollEnabled ? node : nil }
             if let list = node.view as? CraftNativeFlatList {
-                return list.isScrollEnabled && (list.collectionViewLayout as? UICollectionViewFlowLayout)?.scrollDirection != .horizontal ? list : nil
+                return list.isScrollEnabled && (list.collectionViewLayout as? UICollectionViewFlowLayout)?.scrollDirection != .horizontal ? node : nil
             }
             guard paddingInsets(node.style).top == 0,
                   let first = node.children.first(where: { $0.type != "Modal" && !$0.view.isHidden }) else { return nil }
             return leading(first)
         }
         let scroll = find(renderedRoot)
+        let leadingScroll = leading(renderedRoot)
+        // Only the screen's leading scroller draws beneath floating chrome.
+        // A bounded list inside a form must clip its rows to its viewport.
+        if let leadingScroll, leadingScroll.style["overflow"] as? String != "hidden" {
+            leadingScroll.view.clipsToBounds = false
+        }
         // Under a large title the screen runs edge to edge, as UIKit's own
         // screens do: the scroll view starts under the bar and insets its
         // content by it, so the title collapses and pull to refresh draws
@@ -4667,7 +4673,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // view: its content scrolls up under the bar behind iOS's scroll edge
         // effect, rather than over the bar's back button. Other screens stay
         // inside the safe area.
-        let edgeToEdge = scroll != nil && (prefersLargeTitle == true || scroll === leading(renderedRoot))
+        let edgeToEdge = scroll != nil && (prefersLargeTitle == true || scroll === leadingScroll?.view)
         let fullEdgeToEdge = rootIsSafeAreaView
         let topEdgeToEdge = fullEdgeToEdge || edgeToEdge
         rootTopToSafeArea?.isActive = !topEdgeToEdge
@@ -5801,6 +5807,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         case "sectionlist": return "SectionList"
         case "flatlist": return "FlatList"
         case "svg": return "Svg"
+        case "g": return "G"
+        case "svgtext", "svg-text": return "SvgText"
         case "touchableopacity": return "TouchableOpacity"
         case "touchablehighlight": return "TouchableHighlight"
         case "pressable": return "Pressable"
@@ -5848,7 +5856,20 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             stack.removeArrangedSubview(spacer)
             spacer.removeFromSuperview()
         }
-        let nodes = children.compactMap { $0 as? [String: Any] }
+        // STX permits text directly inside containers (including HTML links).
+        // Give it a native label, inheriting typography without duplicating
+        // the parent's padding, dimensions or flex layout.
+        let typography = style.filter { key, _ in
+            key == "color" || key == "letterSpacing" || key == "lineHeight"
+                || key.hasPrefix("font") || key.hasPrefix("text")
+        }
+        let nodes = children.compactMap { child -> [String: Any]? in
+            if let node = child as? [String: Any] { return node }
+            if let text = child as? String {
+                return ["type": "Text", "style": typography, "children": [text]]
+            }
+            return nil
+        }
         let keys = nodes.compactMap { explicitKey($0, props: $0["props"] as? [String: Any] ?? [:]) }
         let counts = Dictionary(keys.map { ($0, 1) }, uniquingKeysWith: +)
         let old = Dictionary(uniqueKeysWithValues: parent.children.map { ($0.identity, $0) })
@@ -6157,10 +6178,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     /// Views that take their own touches whatever handlers the screen gives
-    /// them: a scroll view, a modal, and a video's system controls (with
+    /// them: native controls, a scroll view, a modal, and a video's controls (with
     /// interaction off, its play, scrubber and full screen never answered).
     private func ownsTouches(_ view: UIView) -> Bool {
-        view is UIScrollView || view is CraftNativeModalView || view is CraftNativeVideoView
+        view is UIControl || view is UIScrollView || view is CraftNativeModalView || view is CraftNativeVideoView
     }
 
     private func updatePressHandler(_ handler: String?, for view: UIView) {
@@ -6172,7 +6193,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             let recognizer = UITapGestureRecognizer(target: self, action: #selector(viewPressed(_:)))
             tapRecognizers[id] = recognizer
             view.addGestureRecognizer(recognizer)
-        } else if handler == nil, let recognizer = tapRecognizers.removeValue(forKey: id) {
+        } else if !actionable, let recognizer = tapRecognizers.removeValue(forKey: id) {
             view.removeGestureRecognizer(recognizer)
         }
         // A container keeps receiving touches without a handler of its own,
@@ -6420,11 +6441,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         )
         // A label paints its background inside its own bounds, so a rounded
         // chip of text clips to its corners.
-        // A scroll view does not clip either: its content runs on under the
-        // floating tab bar and the home indicator, as iOS 26's own screens'
-        // does. At the top, a screen that starts with one runs edge to edge
-        // (trackContentScrollView), so nothing scrolls over the bar.
-        view.clipsToBounds = style["overflow"] as? String == "hidden"
+        // Native scrollers clip their viewport unless explicitly made
+        // visible. trackContentScrollView opens only the leading scroller
+        // beneath the screen's floating chrome.
+        let overflow = style["overflow"] as? String
+        view.clipsToBounds = overflow == "hidden"
+            || (view is UIScrollView && overflow != "visible")
             || (view is UILabel && (view.craftRequestedCornerRadius ?? 0) > 0)
         view.layer.masksToBounds = view.clipsToBounds
         view.craftLayoutStyle = CraftNativeLayoutStyle(style)
@@ -6809,7 +6831,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         } else if type != "TextInput" {
             view.accessibilityValue = nil
         }
-        let role = props["accessibilityRole"] as? String
+        let hasLinkTarget = ["href", "to"].contains { !(props[$0] as? String ?? "").isEmpty }
+        let linkedControl = ["Link", "TouchableOpacity", "TouchableHighlight", "Pressable"].contains(type) && hasLinkTarget
+        let role = (props["accessibilityRole"] as? String) ?? (linkedControl ? "link" : nil)
         // A scroll view, a list or a group of controls holds what VoiceOver
         // reads: its label names the group, as a tab strip or a pager's
         // name, and never stands in for its content. As an element of its

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.201",
+  "version": "0.0.203",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",