@craft-native/ios 0.0.500 → 0.0.502

package/package.json

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

package/templates/CraftNativeScreen.swift

@@ -214,31 +214,34 @@ private func craftNativePickerValue(_ value: Any?) -> String? {
     return nil
 }
 
-private func craftNativeGridColumnCount(_ value: Any?) -> Int {
-    if let number = craftNativeNumber(value) { return max(1, number.intValue) }
-    guard let text = value as? String else { return 1 }
-    let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
-    if trimmed.hasPrefix("repeat(") {
-        let digits = trimmed.dropFirst("repeat(".count).prefix { $0.isNumber }
-        if let count = Int(digits) { return max(1, count) }
+/// The most tracks a grid is given, either way. A count is whatever the
+/// script said (`gridTemplateRows: Number.MAX_VALUE`,
+/// `repeat(4294967296, 1fr)`), and the layout makes an array of rows that
+/// long and hands the shared engine both counts as a `UInt32`: the first ran
+/// the process out of memory and the second trapped. No screen has room to
+/// show more tracks than this.
+let craftNativeGridTrackLimit = 1024
+
+func craftNativeGridTrackCount(_ value: Any?) -> Int? {
+    if let number = craftNativeNumber(value) {
+        return min(craftNativeGridTrackLimit, max(1, craftNativeInt(number.doubleValue)))
     }
-    let tracks = trimmed.split(whereSeparator: { $0 == " " || $0 == "\t" || $0 == "\n" })
-    return max(1, tracks.count)
-}
-
-private func craftNativeGridRowCount(_ value: Any?) -> Int? {
-    if let number = craftNativeNumber(value) { return max(1, number.intValue) }
     guard let text = value as? String else { return nil }
     let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
     guard !trimmed.isEmpty else { return nil }
     if trimmed.hasPrefix("repeat(") {
-        let digits = trimmed.dropFirst("repeat(".count).prefix { $0.isNumber }
-        if let count = Int(digits) { return max(1, count) }
+        let digits = trimmed.dropFirst("repeat(".count).prefix { ("0"..."9").contains($0) }
+        // Digits past what an Int holds are still a count, and still too many.
+        if !digits.isEmpty { return min(craftNativeGridTrackLimit, max(1, Int(digits) ?? craftNativeGridTrackLimit)) }
     }
     let tracks = trimmed.split(whereSeparator: { $0 == " " || $0 == "\t" || $0 == "\n" })
-    return tracks.isEmpty ? nil : max(1, tracks.count)
+    return tracks.isEmpty ? nil : min(craftNativeGridTrackLimit, tracks.count)
 }
 
+private func craftNativeGridColumnCount(_ value: Any?) -> Int { craftNativeGridTrackCount(value) ?? 1 }
+
+private func craftNativeGridRowCount(_ value: Any?) -> Int? { craftNativeGridTrackCount(value) }
+
 /// Optional bridge to the shared Zig flex rule. Native hosts retain their
 /// local implementation when no Craft runtime is linked (the normal SDK
 /// fallback), while runtime-backed apps get one cross-platform calculation.
@@ -4376,7 +4379,11 @@ class CraftNativePositionedImageView: UIView {
         }
         let rawFit = value("objectFit"), rawPosition = value("objectPosition")
         if rawFit != nil || rawPosition != nil {
-            let requested = rawFit as? String ?? "fill"
+            // A position does not choose a fit, as in CSS. STX compiles
+            // `object-cover` to `resizeMode: "cover"` and sets no objectFit,
+            // so a cover image given a position was drawn as "fill":
+            // stretched to its box instead of cropped (#532).
+            let requested = rawFit as? String ?? Self.objectFit(resizeMode: style["resizeMode"] as? String ?? props["resizeMode"] as? String)
             fit = ["fill", "contain", "cover", "none", "scale-down"].contains(requested) ? requested : "fill"
             position = Self.objectPosition(rawPosition)
         } else { fit = nil }
@@ -4404,6 +4411,17 @@ class CraftNativePositionedImageView: UIView {
     var usesObjectGeometry: Bool { fit != nil }
     var objectCovers: Bool { fit == "cover" }
 
+    /// The fit a `resizeMode` already asks for, for an image that has a
+    /// position and no `objectFit`; "fill" when it has neither.
+    static func objectFit(resizeMode: String?) -> String {
+        switch resizeMode {
+        case "cover": return "cover"
+        case "contain": return "contain"
+        case "center": return "none"
+        default: return "fill"
+        }
+    }
+
     private static func objectPosition(_ raw: Any?) -> CGPoint {
         guard let text = raw as? String else { return CGPoint(x: 0.5, y: 0.5) }
         var parts = text.lowercased().split(whereSeparator: { $0.isWhitespace }).map(String.init)
@@ -7184,6 +7202,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             // a screen that hid its own.
             navigationController?.setNavigationBarHidden(false, animated: animated)
         }
+        // Options can arrive before the screen is in a stack: whether it has
+        // a screen to go back to is known now.
+        if backButtonSpec != nil { applyLeadingBarItems() }
         applyNavigationBarAppearance()
         // Each screen says whether it wants the tab bar, so one that hid it
         // never leaves it hidden for the next. Only the screen on screen:
@@ -7858,7 +7879,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// - `craft.secureStorage.getSync(key)`: the Keychain item the web page's
     ///   `craft.secureStorage.set` wrote.
     /// - `craft.navigation.setOptions({ title, titleColor, largeTitle, hidden,
-    ///   backTitle, tabBarHidden, tabBarHiddenWhenPushed, tabItem, swipeBack,
+    ///   backTitle, backButton, tabBarHidden, tabBarHiddenWhenPushed, tabItem, swipeBack,
     ///   contentSwipeBack,
     ///   tabSwipeEnabled, backgroundColor, navigationBarSolid, leftButtons,
     ///   rightButtons, tabAccessory })`; a button's tap is the event
@@ -8474,10 +8495,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 navigationController?.setNavigationBarHidden(hidden, animated: animatesNavigationBarChanges)
             }
         }
+        if options.keys.contains("backButton") {
+            backButtonSpec = options["backButton"] as? [String: Any]
+            backButtonItem = nil
+        }
         if options.keys.contains("leftButtons") {
             let buttons = (options["leftButtons"] as? [[String: Any]]) ?? []
-            navigationItem.leftItemsSupplementBackButton = true
-            navigationItem.leftBarButtonItems = buttons.compactMap(navigationButton)
+            leftButtonItems = buttons.compactMap(navigationButton)
+        }
+        if options.keys.contains("backButton") || options.keys.contains("leftButtons") {
+            applyLeadingBarItems()
         }
         if options.keys.contains("rightButtons") {
             let buttons = (options["rightButtons"] as? [[String: Any]]) ?? []
@@ -8575,6 +8602,44 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         return actions.isEmpty ? nil : UIMenu(children: actions)
     }
 
+    /// `backButton`: what this screen's Back is drawn with, when it is not
+    /// the chevron (`{ symbol: "xmark", accessibilityLabel: "Close" }` for a
+    /// screen that closes rather than goes back). `leftButtons` are added
+    /// beside Back, so a screen could not put its own symbol in Back's place
+    /// (#527). Nil is the system's chevron.
+    private var backButtonSpec: [String: Any]?
+    private var backButtonItem: UIBarButtonItem?
+    private var leftButtonItems: [UIBarButtonItem] = []
+
+    /// The screen's own Back, when it asked for one and has a screen to go
+    /// back to, then its left buttons. The chevron is hidden only while the
+    /// item that replaces it is in the bar: a symbol UIKit does not have
+    /// leaves the chevron. The back-swipe is the shell's to allow, and is
+    /// not affected.
+    private func applyLeadingBarItems() {
+        // Known to be the first screen of its stack: nothing to go back to.
+        let isRoot = navigationController?.viewControllers.first === self
+        if !isRoot, backButtonItem == nil, let spec = backButtonSpec,
+           let symbol = spec["symbol"] as? String, let image = UIImage(systemName: symbol) {
+            let item = UIBarButtonItem(image: image, style: .plain, target: self, action: #selector(backButtonTapped))
+            item.accessibilityIdentifier = "nav-back"
+            item.accessibilityLabel = (spec["accessibilityLabel"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+                ?? (symbol.hasPrefix("xmark") ? "Close" : "Back")
+            backButtonItem = item
+        }
+        let back = isRoot ? nil : backButtonItem
+        navigationItem.hidesBackButton = back != nil
+        navigationItem.leftItemsSupplementBackButton = true
+        navigationItem.leftBarButtonItems = (back.map { [$0] } ?? []) + leftButtonItems
+    }
+
+    /// What `craft.navigation.back()` does.
+    @objc private func backButtonTapped() {
+        if !isAppScript, navigationController?.topViewController === self {
+            navigationController?.popViewController(animated: true)
+        }
+    }
+
     private func navigationButton(_ spec: [String: Any]) -> UIBarButtonItem? {
         guard let id = spec["id"] as? String, !id.isEmpty else { return nil }
         let action = UIAction { [weak self] _ in
@@ -9060,27 +9125,44 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// view is does not come into it: a page of a pager that is off to one
     /// side now is under the actions once it is swiped to. The safe area and
     /// the viewport are left alone: content still scrolls behind the
-    /// actions. Internal for XCTest.
+    /// actions.
+    ///
+    /// Two things are not behind the actions, and get none. A scroll view
+    /// that is not inside the shell the actions float in: a sheet is
+    /// presented in front of them, and its scroll view was given the room of
+    /// a capsule it covers, so every sheet could be dragged up into blank
+    /// space. And a scroll view or list inside another that scrolls the same
+    /// way: it is brought clear by the outer one, and where it sits in a page
+    /// not yet scrolled to it says nothing about the glass; a short list
+    /// below the fold was given the height of the page above it. Internal
+    /// for XCTest.
     func insetScrollViewsForFloatingActions() {
         let chrome = CraftChrome.shared
-        let actions = chrome.floatingActions.flatMap { frame in
-            chrome.floatingActionsHost.flatMap { view.isDescendant(of: $0) ? frame : nil }
-        }
+        let host = chrome.floatingActionsHost.flatMap { view.isDescendant(of: $0) ? $0 : nil }
+        let actions = host == nil ? nil : chrome.floatingActions
         func cover(_ scroll: UIScrollView) -> CGFloat {
-            guard let actions, let window = scroll.window else { return 0 }
+            guard let actions, let host, let window = scroll.window, scroll.isDescendant(of: host) else { return 0 }
             let frame = scroll.convert(scroll.bounds, to: window)
+            // Nothing past the end of the shell is on the glass.
+            let end = min(frame.maxY, host.convert(host.bounds, to: window).maxY)
             // An edge-to-edge scroller already clears the tab bar through
             // UIKit's safe area. Add only what the actions reach above it.
             let automaticBottom = max(0, scroll.adjustedContentInset.bottom - scroll.contentInset.bottom)
-            return max(0, frame.maxY - actions.minY - automaticBottom)
+            return max(0, end - actions.minY - automaticBottom)
         }
-        func visit(_ node: RenderedNode?) {
+        func visit(_ node: RenderedNode?, inside: Bool) {
             guard let node else { return }
-            if let scroll = node.view as? CraftNativeScrollView, scroll.isVertical { scroll.floatingCover = cover(scroll) }
-            else if let list = node.view as? CraftNativeFlatList { list.floatingCover = cover(list) }
-            node.children.forEach(visit)
+            var inside = inside
+            if let scroll = node.view as? CraftNativeScrollView, scroll.isVertical {
+                scroll.floatingCover = inside ? 0 : cover(scroll)
+                inside = true
+            } else if let list = node.view as? CraftNativeFlatList {
+                list.floatingCover = inside ? 0 : cover(list)
+                if (list.collectionViewLayout as? UICollectionViewFlowLayout)?.scrollDirection != .horizontal { inside = true }
+            }
+            node.children.forEach { visit($0, inside: inside) }
         }
-        visit(renderedRoot)
+        visit(renderedRoot, inside: false)
         floatingClearanceApplied = actions != nil
     }