@craft-native/ios 0.0.278 → 0.0.290

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/ios",
-  "version": "0.0.278",
+  "version": "0.0.290",
   "homepage": "https://github.com/craft-native/craft/tree/main/packages/ios#readme",
   "repository": {
     "type": "git",

package/templates/CraftApp.swift

@@ -903,6 +903,9 @@ final class CraftChrome: ObservableObject {
     func tap(_ tab: Tab) {
         let reselect = tab.id == selected
         if !reselect {
+            // A tab's screen not made yet is made first, so the pill moves on
+            // a free main thread rather than stalling behind its mount.
+            CraftHybrid.shared.mountTabBeforeSelecting(tab.id)
             withAnimation(Self.motion(.spring(response: 0.32, dampingFraction: 0.86))) { selected = tab.id }
         }
         // A hybrid app shows the tab's own stack first; the page hears the
@@ -1162,11 +1165,7 @@ struct CraftTabBarView: View {
                     VStack(spacing: 3) {
                         ZStack(alignment: .topTrailing) {
                             if let image = tab.image, let url = URL(string: image) {
-                                AsyncImage(url: url) { image in
-                                    image.resizable().scaledToFill()
-                                } placeholder: {
-                                    Image(systemName: symbol(tab.symbol, selected: isSelected))
-                                }
+                                CraftTabPicture(url: url, placeholder: symbol(tab.symbol, selected: isSelected))
                                 .frame(width: iconSize + 4, height: iconSize + 4)
                                 .clipShape(Circle())
                                 .frame(height: iconSize + 6)
@@ -1258,6 +1257,46 @@ struct CraftTabBarView: View {
     }
 }
 
+/// A tab's picture (HQ's Me: the account's photo). It is kept once loaded,
+/// so a tab item drawn again (its screen mounting, the bar coming back) shows
+/// it at once: AsyncImage keeps nothing, so the photo went back to the
+/// person symbol, loaded again and arrived inside whatever animation was
+/// running, sliding in from the side on the first visit to Me.
+private struct CraftTabPicture: View {
+    let url: URL
+    let placeholder: String
+    @State private var image: UIImage?
+
+    private static let cache: NSCache<NSURL, UIImage> = {
+        let cache = NSCache<NSURL, UIImage>()
+        cache.countLimit = 16
+        return cache
+    }()
+
+    var body: some View {
+        Group {
+            if let shown = image ?? Self.cache.object(forKey: url as NSURL) {
+                Image(uiImage: shown).resizable().scaledToFill()
+            } else {
+                Image(systemName: placeholder)
+            }
+        }
+        // A picture arriving never animates, whatever transaction it lands in.
+        .transaction { $0.animation = nil }
+        .task(id: url) {
+            if let cached = Self.cache.object(forKey: url as NSURL) {
+                image = cached
+                return
+            }
+            guard let (data, response) = try? await URLSession.shared.data(from: url),
+                  (response as? HTTPURLResponse).map({ (200..<300).contains($0.statusCode) }) ?? true,
+                  let loaded = UIImage(data: data) else { return }
+            Self.cache.setObject(loaded, forKey: url as NSURL)
+            image = loaded
+        }
+    }
+}
+
 private struct CraftTabSelectionShape: Shape {
     let cornerRadius: CGFloat?
 

package/templates/CraftHybrid.swift

@@ -880,6 +880,13 @@ final class CraftHybrid: NSObject {
         return controller.tabTapped(id, reselect: reselect)
     }
 
+    /// A native tab not prepared yet mounts its screen now, hidden, before
+    /// the bar's selection moves (CraftChrome.tap).
+    func mountTabBeforeSelecting(_ id: String) {
+        guard isEnabled else { return }
+        controller?.mountTabBeforeSelecting(id)
+    }
+
     /// The page chose a tab itself (its `selectTab`, or a tab link).
     func pageSelectedTab(_ id: String) {
         guard isEnabled else { return }
@@ -1731,6 +1738,20 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     private var preparation: Timer?
 
+    /// A native tab tapped before the shell prepared it (HQ's Me, prepared
+    /// last, tapped right after launch) mounts its screen hidden first. Mounted
+    /// in the tap's own turn after the selection began, it held the main
+    /// thread while SwiftUI's spring should have moved the pill, which then
+    /// stalled and jumped in from the side.
+    func mountTabBeforeSelecting(_ id: String) {
+        guard stacks[id] == nil, id != currentTab, activeTabSwipeTarget == nil,
+              hybrid.tabIds.contains(id), hybrid.routes.match(id) != nil, view.window != nil else { return }
+        let nav = makeStack(tab: id, rootPath: id, hidden: true)
+        nav.view.layoutIfNeeded()
+        Self.drawContents(of: nav.view.layer)
+        (visibleStack?.topViewController as? CraftNativeScreenController)?.screenVisibilityChanged(true)
+    }
+
     /// When the shell last moved between screens: a tab, a push or a pop.
     private var lastNavigation: CFTimeInterval = 0
 

package/templates/CraftNativeScreen.swift

@@ -5101,6 +5101,17 @@ private final class CraftNativeTextView: UITextView {
 
     override func layoutSubviews() {
         super.layoutSubviews()
+        // A multiline input grows with its text up to its `maxHeight`, then
+        // scrolls inside itself. Never scrolling, the text past that height
+        // was cut off and could not be reached (a long workout comment).
+        // With scrolling off, contentSize is the view's own height: measure
+        // the text itself.
+        let needed = isEditable ? sizeThatFits(CGSize(width: bounds.width, height: .greatestFiniteMagnitude)).height : 0
+        let overflows = isEditable && bounds.height > 0 && needed > bounds.height + 1
+        if isScrollEnabled != overflows {
+            isScrollEnabled = overflows
+            if overflows, isFirstResponder { scrollRangeToVisible(selectedRange) }
+        }
         let inset = textContainerInset
         let padding = textContainer.lineFragmentPadding
         placeholderLabel.frame = CGRect(
@@ -5117,6 +5128,7 @@ private final class CraftNativeTextView: UITextView {
     }
 
     private func configurePlaceholder() {
+        isScrollEnabled = false
         placeholderLabel.numberOfLines = 0
         placeholderLabel.font = font
         placeholderLabel.textColor = .placeholderText
@@ -5623,6 +5635,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // A tab prepared in a hidden stack "appears" to UIKit as well; the
         // shell says when it really shows (screenVisibilityChanged).
         if isShownOnScreen {
+            hasAppeared = true
             screenVisibilityChanged(true)
             // A navigation breadcrumb for the crash reporter: the trail a
             // crash report carries is the screens that led to it.
@@ -5694,6 +5707,14 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // preview also restores a screen that never lost focus, so restore its
         // chrome even when no new SCREEN_FOCUS event is needed.
         if visible { restoreShellChrome() }
+        // A prepared tab the shell now shows has appeared once its frame is
+        // drawn; what its script asks for until then is there from the start.
+        if visible, !hasAppeared {
+            DispatchQueue.main.async { [weak self] in
+                guard let self, self.isViewLoaded, self.isShownOnScreen else { return }
+                self.hasAppeared = true
+            }
+        }
         if visible, frameWanted { CraftNativeFrameClock.shared.request(self) { [weak self] in self?.fireFrame() } }
         if !visible { CraftNativeFrameClock.shared.cancel(self) }
         guard visible != reportedVisible else { return }
@@ -5780,6 +5801,27 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         super.viewDidLayoutSubviews()
         positionModals()
         emitLayoutEvents()
+        sendViewportIfChanged()
+    }
+
+    /// The width the bundle last heard, so a layout pass at the same size says nothing.
+    private var reportedViewportWidth: CGFloat = -1
+
+    /// The screen's own width once laid out, else its window's: what a web
+    /// page's media queries would measure.
+    private func currentViewportWidth() -> CGFloat {
+        let width = view.bounds.width > 0 ? view.bounds.width : (view.window ?? CraftPresenter.keyWindow())?.bounds.width ?? 0
+        reportedViewportWidth = width
+        return width
+    }
+
+    /// A rotation, iPad split view or a resized Stage Manager window: the
+    /// bundle's width classes (`md:`, `lg:`) follow the screen's new width.
+    private func sendViewportIfChanged() {
+        let width = view.bounds.width
+        guard width > 0, abs(width - reportedViewportWidth) >= 0.5 else { return }
+        reportedViewportWidth = width
+        send(type: "VIEWPORT", payload: ["width": Double(width), "height": Double(view.bounds.height)])
     }
 
     /// Modals cover the screen; their content starts below its bars (the
@@ -5864,6 +5906,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let appearanceJSON: String
         let sessionTokenKey: String
         let focused: Bool?
+        /// The screen's width in points, for the bundle's `sm:`/`md:`/`lg:` classes.
+        let viewportWidth: Double
     }
 
     private func scriptInputs() -> ScriptInputs {
@@ -5875,7 +5919,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             colorScheme: colorScheme,
             appearanceJSON: appearanceJSON(),
             sessionTokenKey: Self.jsonString(CraftSession.tokenKey(config)),
-            focused: reportedVisible
+            focused: reportedVisible,
+            viewportWidth: Double(currentViewportWidth())
         )
     }
 
@@ -5977,6 +6022,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 capabilities: \(capabilityJSON),
                 initialAppState: "\(inputs.appState)",
                 colorScheme: "\(inputs.colorScheme)",
+                viewportWidth: \(inputs.viewportWidth),
                 appearance: \(inputs.appearanceJSON),
                 appURL: \(appURL),
                 appVersion: \(appVersion),
@@ -6546,6 +6592,14 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// own horizontal pager or chart gesture.
     private(set) var tabSwipeEnabled = true
     private var prefersLargeTitle: Bool?
+    /// Whether the screen has been on screen. Until then, a bar its script
+    /// asks for is simply there in its first frame: a tab opened for the
+    /// first time (HQ's Me) mounts in the window, and its bar and large title
+    /// slid in from the side as the screen appeared.
+    private var hasAppeared = false
+    /// A bar shown or hidden after the screen has appeared animates; before,
+    /// it is in place from the start.
+    var animatesNavigationBarChanges: Bool { hasAppeared && view.window != nil }
     /// Whether this screen opts into an opaque navigation bar filled with its
     /// own background colour. The default keeps UIKit's material appearance.
     private var navigationBarSolid = false
@@ -6624,7 +6678,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         if let hidden = options["hidden"] as? Bool {
             navigationBarHidden = hidden
             if navigationController?.topViewController === self {
-                navigationController?.setNavigationBarHidden(hidden, animated: view.window != nil)
+                navigationController?.setNavigationBarHidden(hidden, animated: animatesNavigationBarChanges)
             }
         }
         if options.keys.contains("leftButtons") {
@@ -6642,7 +6696,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // Asked for after the bar was hidden for a bare root screen.
         if navigationBarHidden == nil, wantsNavigationBar, navigationController?.topViewController === self,
            navigationController?.isNavigationBarHidden == true {
-            navigationController?.setNavigationBarHidden(false, animated: view.window != nil)
+            navigationController?.setNavigationBarHidden(false, animated: animatesNavigationBarChanges)
         }
     }
 
@@ -7104,13 +7158,39 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// `input`, scrolled into the visible part of the scroll view it is in.
     /// Internal for XCTest.
     func scrollIntoView(_ input: UIView, animated: Bool) {
-        var ancestor = input.superview
-        while let current = ancestor, !(current is CraftNativeScrollView) { ancestor = current.superview }
-        guard let scroll = ancestor as? CraftNativeScrollView, scroll.isVertical else { return }
-        let rect = input.convert(input.bounds, to: scroll).insetBy(dx: 0, dy: -16)
+        guard let scroll = enclosingVerticalScroll(of: input) else { return }
+        var rect = input.convert(input.bounds, to: scroll).insetBy(dx: 0, dy: -16)
+        // A field taller than the part the keyboard leaves (a long comment
+        // with no max height) shows its caret rather than its top: scrolled
+        // to its top, the caret at the end of the text stayed under the
+        // keyboard with no way to scroll it out.
+        let visible = scroll.bounds.inset(by: scroll.adjustedContentInset)
+        if rect.height > visible.height, let caret = caretRect(of: input, in: scroll) { rect = caret }
         scroll.scrollRectToVisible(rect, animated: animated)
     }
 
+    /// The vertical scroll view `view` sits in, if any.
+    private func enclosingVerticalScroll(of view: UIView) -> CraftNativeScrollView? {
+        var ancestor = view.superview
+        while let current = ancestor, !(current is CraftNativeScrollView) { ancestor = current.superview }
+        guard let scroll = ancestor as? CraftNativeScrollView, scroll.isVertical else { return nil }
+        return scroll
+    }
+
+    /// A focused input's caret in `scroll`'s coordinates, with a little room
+    /// around it, kept within the input (one scrolling inside itself has its
+    /// caret beyond its own frame until it scrolls to it).
+    private func caretRect(of input: UIView, in scroll: UIScrollView) -> CGRect? {
+        guard input.isFirstResponder, let text = input as? UITextInput,
+              let end = text.selectedTextRange?.end else { return nil }
+        let caret = text.caretRect(for: end)
+        guard caret.minY.isFinite, caret.height > 0 else { return nil }
+        let frame = input.convert(input.bounds, to: scroll)
+        var rect = input.convert(caret, to: scroll)
+        rect.origin.y = min(max(rect.minY, frame.minY), max(frame.minY, frame.maxY - rect.height))
+        return rect.insetBy(dx: 0, dy: -16)
+    }
+
     private func sendAppState(_ state: String) {
         // A screen hears it while it is on top of its stack; the app script,
         // which is on no stack, always.
@@ -8977,7 +9057,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if textView.textContainerInset != padding { textView.textContainerInset = padding }
             textView.textContainer.lineFragmentPadding = 0
         }
-        textView.isScrollEnabled = false
+        // An input's own scrolling follows its height (CraftNativeTextView).
+        if !(textView is CraftNativeTextView) { textView.isScrollEnabled = false }
         let numberOfLines = Int(number(props["numberOfLines"]) ?? 0)
         if numberOfLines > 0 {
             textView.textContainer.maximumNumberOfLines = numberOfLines
@@ -9846,11 +9927,38 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let id = ObjectIdentifier(textView)
         inputIdentities[id].map { inputDrafts[$0] = textView.text ?? "" }
         (textView as? CraftNativeTextView)?.refreshPlaceholder()
+        keepCaretVisible(in: textView)
         guard let handler = handlers[id] else { return }
         noteSentText(textView.text ?? "", for: textView)
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["text": textView.text ?? ""]])
     }
 
+    func textViewDidChangeSelection(_ textView: UITextView) {
+        guard textView.isFirstResponder else { return }
+        keepCaretVisible(in: textView)
+    }
+
+    /// The caret, kept where it can be seen as a multiline input grows or the
+    /// caret moves: in the part of the screen's scroll view the keyboard
+    /// leaves. Only the field was scrolled into view, when editing began, so
+    /// a long comment typed at the bottom of a screen went under the keyboard.
+    private func keepCaretVisible(in textView: UITextView) {
+        DispatchQueue.main.async { [weak self, weak textView] in
+            guard let self, let textView, textView.isFirstResponder else { return }
+            // The input grows with its text first: a text view's new lines
+            // are news to the flex layout around it, which sized the scroll
+            // view's content to the old height.
+            textView.invalidateIntrinsicContentSize()
+            CraftNativeFlexLayout.invalidateAncestors(of: textView)
+            self.view.layoutIfNeeded()
+            guard let scroll = self.enclosingVerticalScroll(of: textView),
+                  let rect = self.caretRect(of: textView, in: scroll) else { return }
+            let visible = scroll.bounds.inset(by: scroll.adjustedContentInset)
+            guard !visible.contains(rect) else { return }
+            scroll.scrollRectToVisible(rect, animated: false)
+        }
+    }
+
     func textViewDidBeginEditing(_ textView: UITextView) {
         lastFocusedInput = textView
         if keyboardScreenFrame != nil { DispatchQueue.main.async { self.scrollFocusedInputIntoView(animated: true) } }