craft-native 0.0.497 → 0.0.500

package/dist/ios/templates/CraftNativeScreen.swift

@@ -150,6 +150,38 @@ func craftNativeNumber(_ value: Any?) -> NSNumber? {
     return number
 }
 
+/// A number from a prop as an `Int`, the way `toInt()` gives it on the
+/// Android host: toward zero, the nearest end of the 32-bit range when it is
+/// outside it, and 0 when it is not a number.
+///
+/// `Int(_:)` traps on a value it cannot hold, and a prop is whatever the
+/// screen's script said: `maxLength={Number.MAX_VALUE}` ended the process
+/// (#510). The 32-bit range is the other host's, and it leaves room for the
+/// arithmetic done on the result, which `Int.max` would not.
+func craftNativeInt(_ value: Double) -> Int {
+    guard !value.isNaN else { return 0 }
+    return Int(max(Double(Int32.min), min(Double(Int32.max), value.rounded(.towardZero))))
+}
+
+func craftNativeInt(_ value: CGFloat) -> Int { craftNativeInt(Double(value)) }
+
+/// The most a number may be in layout, either side of zero: 2^25 points. It
+/// is far past any screen, and small enough that what the layout makes of a
+/// few such numbers multiplied together still fits a Float, which the flex
+/// engine works in.
+let craftNativeLayoutLimit: CGFloat = 33_554_432
+
+/// A number for layout: inside that limit, and 0 when it is not a number.
+///
+/// A style is whatever the script said. `flex: Number.MAX_VALUE` is finite,
+/// and became an infinite share of a row, an infinite frame, and then
+/// UIKit's `NSLayoutConstraint constant is not finite! That's illegal`, an
+/// exception nothing catches: the app ended. Lengths and flex factors are
+/// held to this as they are read, and so is every frame the layout produces.
+func craftNativeLayoutNumber(_ value: CGFloat) -> CGFloat {
+    value.isNaN ? 0 : max(-craftNativeLayoutLimit, min(craftNativeLayoutLimit, value))
+}
+
 /// A finite number from a prop, for the views outside the screen controller,
 /// which has its own: the keyboard-avoiding view and SVG text read theirs
 /// with it, and without it the template did not compile.
@@ -161,11 +193,19 @@ private func number(_ value: Any?) -> CGFloat? {
     return value.isFinite ? value : nil
 }
 
+/// A finite number from a style, held to what layout can use (see
+/// `craftNativeLayoutNumber`). A padding, radius, spacing or size of
+/// `Number.MAX_VALUE` reached UIKit as an inset or a font it could not place,
+/// and UIKit raised `CALayer position contains NaN`: the app ended.
+private func styleNumber(_ value: Any?) -> CGFloat? {
+    number(value).map(craftNativeLayoutNumber)
+}
+
 private func craftNativeFontWeight(_ value: Any?) -> String? {
     if let value = value as? String { return value }
     guard let number = craftNativeNumber(value), number.doubleValue.isFinite else { return nil }
     let integer = number.doubleValue.rounded()
-    return integer == number.doubleValue ? String(Int(integer)) : nil
+    return integer == number.doubleValue ? String(craftNativeInt(integer)) : nil
 }
 
 private func craftNativePickerValue(_ value: Any?) -> String? {
@@ -2389,16 +2429,16 @@ private enum CraftNativeLength: Equatable {
         if let number = craftNativeNumber(value) {
             let points = CGFloat(truncating: number)
             guard points.isFinite else { return nil }
-            self = .points(points)
+            self = .points(craftNativeLayoutNumber(points))
             return
         }
         guard let text = (value as? String)?.trimmingCharacters(in: .whitespaces), !text.isEmpty else { return nil }
         if text.hasSuffix("%"), let fraction = Double(text.dropLast()), fraction.isFinite {
-            self = .percent(CGFloat(fraction) / 100)
+            self = .percent(craftNativeLayoutNumber(CGFloat(fraction) / 100))
         } else if text.hasSuffix("px"), let points = Double(text.dropLast(2)), points.isFinite {
-            self = .points(CGFloat(points))
+            self = .points(craftNativeLayoutNumber(CGFloat(points)))
         } else if let points = Double(text), points.isFinite {
-            self = .points(CGFloat(points))
+            self = .points(craftNativeLayoutNumber(CGFloat(points)))
         } else {
             return nil
         }
@@ -2449,7 +2489,7 @@ private struct CraftNativeLayoutStyle {
         func number(_ value: Any?) -> CGFloat? {
             guard let number = craftNativeNumber(value) else { return nil }
             let value = CGFloat(truncating: number)
-            return value.isFinite ? value : nil
+            return value.isFinite ? craftNativeLayoutNumber(value) : nil
         }
         width = CraftNativeLength(raw["width"])
         height = CraftNativeLength(raw["height"])
@@ -2466,7 +2506,7 @@ private struct CraftNativeLayoutStyle {
         left = number(raw["left"])
         let align = raw["alignSelf"] as? String
         alignSelf = align == "auto" ? nil : align
-        order = number(raw["order"]).map { Int($0.rounded(.towardZero)) } ?? 0
+        order = number(raw["order"]).map { craftNativeInt($0) } ?? 0
         // `flex: n` is the web's and React Native's shorthand: a positive
         // number grows by n, shrinks, and starts from nothing, so `flex-1`
         // siblings share a row equally whatever their content.
@@ -2832,7 +2872,7 @@ enum CraftNativeFlexLayout {
     static func ceiled(_ size: CGSize, scale: CGFloat, atLeast floor: CGSize) -> CGSize {
         let scale = max(1, scale)
         // Less a hair, so a size already on the pixel grid stays put.
-        func up(_ value: CGFloat) -> CGFloat { (value * scale - 0.001).rounded(.up) / scale }
+        func up(_ value: CGFloat) -> CGFloat { (craftNativeLayoutNumber(value) * scale - 0.001).rounded(.up) / scale }
         return CGSize(width: max(floor.width, up(size.width)), height: max(floor.height, up(size.height)))
     }
 
@@ -2840,7 +2880,9 @@ enum CraftNativeFlexLayout {
     /// neither overlap nor leave a hairline between them.
     static func snapped(_ rect: CGRect, scale: CGFloat) -> CGRect {
         let scale = max(1, scale)
-        func snap(_ value: CGFloat) -> CGFloat { (value * scale).rounded() / scale }
+        // Whatever the arithmetic before this made of the styles it was
+        // given, the frame UIKit is handed is one it accepts.
+        func snap(_ value: CGFloat) -> CGFloat { (craftNativeLayoutNumber(value) * scale).rounded() / scale }
         let minX = snap(rect.minX), minY = snap(rect.minY)
         return CGRect(x: minX, y: minY, width: max(0, snap(rect.maxX) - minX), height: max(0, snap(rect.maxY) - minY))
     }
@@ -3314,6 +3356,7 @@ private class CraftNativeFlowView: UIStackView {
             if moved {
                 craftScreenController?.scheduleLayoutEvents()
                 craftScreenController?.scheduleKeyboardInsets()
+                craftScreenController?.scheduleFloatingClearance()
             }
         }
         for (child, frame) in result.frames {
@@ -4798,14 +4841,23 @@ final class CraftPressFeedbackDelegate: NSObject, UIGestureRecognizerDelegate {
 
 /// Whether a scrolling view's gesture runs together with `other`. A scroll
 /// view is the delegate of its own pan as well as of its keyboard tap, so this
-/// answers for both. Everything runs together (the keyboard tap watches
+/// answers for both. Most things run together (the keyboard tap watches
 /// alongside a control's own gestures; the back-swipe and the tab swipe decide
-/// for themselves) except two scroll views' pans: run together, a drag on a
-/// nested scroll view scrolled its parent at the same time.
+/// for themselves), with two exceptions for a scroll view's pan.
+///
+/// Another scroll view's pan: run together, a drag on a nested scroll view
+/// scrolled its parent at the same time.
+///
+/// A press. A row or a card that can be pressed is a view with a tap
+/// recognizer, and UIKit fails a tap the moment a drag begins on the scroll
+/// view around it. That is what keeps a flick, or the touch that stops a
+/// moving list, from also pressing whatever is under the finger. Told to run
+/// together, both happened: a short scroll pressed the thing it began on.
 func craftScrollGesture(_ gesture: UIGestureRecognizer, runsWith other: UIGestureRecognizer) -> Bool {
-    guard let scroll = gesture.view as? UIScrollView, gesture === scroll.panGestureRecognizer,
-          let otherScroll = other.view as? UIScrollView, other === otherScroll.panGestureRecognizer else { return true }
-    return false
+    guard let scroll = gesture.view as? UIScrollView, gesture === scroll.panGestureRecognizer else { return true }
+    if let otherScroll = other.view as? UIScrollView, other === otherScroll.panGestureRecognizer { return false }
+    if other is UITapGestureRecognizer, other.delegate is CraftPressGestureDelegate { return false }
+    return true
 }
 
 /// Scroll containers observe taps without cancelling native input focus or
@@ -4992,7 +5044,7 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
     /// these indices stay at the top of the visible area once scrolled to,
     /// each pushed up by the next. Vertical scroll views only.
     func setStickyHeaderIndices(_ value: Any?) {
-        let next = Array(Set(((value as? [Any]) ?? []).compactMap { number($0).map { Int($0) } }.filter { $0 >= 0 })).sorted()
+        let next = Array(Set(((value as? [Any]) ?? []).compactMap { number($0).map { craftNativeInt($0) } }.filter { $0 >= 0 })).sorted()
         guard next != stickyIndices else { return }
         stickyIndices = next
         setNeedsLayout()
@@ -5108,6 +5160,19 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
         setContentNeedsLayout()
     }
 
+    /// What covers the end of this scroll view from below: the keyboard, and
+    /// the compact tab actions floating above the tab bar (#523). The content
+    /// is inset by the larger, so its last lines can be scrolled clear of
+    /// whichever reaches further.
+    var keyboardCover: CGFloat = 0 { didSet { applyCover() } }
+    var floatingCover: CGFloat = 0 { didSet { applyCover() } }
+
+    private func applyCover() {
+        let cover = max(keyboardCover, floatingCover)
+        if abs(contentInset.bottom - cover) > 0.5 { contentInset.bottom = cover }
+        if abs(verticalScrollIndicatorInsets.bottom - cover) > 0.5 { verticalScrollIndicatorInsets.bottom = cover }
+    }
+
     private var refreshingProp = false
 
     /// `onRefresh` and `refreshing`: the system's pull to refresh, controlled
@@ -5516,7 +5581,7 @@ final class CraftNativeSvgView: UIView {
         var out = from
         var i = 0
         while i < from.count {
-            let command = Int(from[i])
+            let command = craftNativeInt(from[i])
             guard to[i] == from[i] else { return from }
             let count: Int
             switch command {
@@ -5701,7 +5766,7 @@ final class CraftNativeSvgView: UIView {
         guard !text.isEmpty else { return }
         let props = node["props"] as? [String: Any] ?? [:]
         let style = node["style"] as? [String: Any] ?? [:]
-        let size = number(props["fontSize"]) ?? number(style["fontSize"]) ?? 12
+        let size = number(props["fontSize"]) ?? styleNumber(style["fontSize"]) ?? 12
         let weight: UIFont.Weight = {
             switch paint.fontWeight?.lowercased() {
             case "500": return .medium
@@ -5743,7 +5808,7 @@ final class CraftNativeSvgView: UIView {
         var i = 0
         func point(_ at: Int) -> CGPoint { CGPoint(x: n[at], y: n[at + 1]) }
         while i < n.count {
-            switch Int(n[i]) {
+            switch craftNativeInt(n[i]) {
             case 0 where i + 2 < n.count: path.move(to: point(i + 1)); i += 3
             case 1 where i + 2 < n.count: path.addLine(to: point(i + 1)); i += 3
             case 2 where i + 6 < n.count: path.addCurve(to: point(i + 5), controlPoint1: point(i + 1), controlPoint2: point(i + 3)); i += 7
@@ -6848,6 +6913,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         /// targeted update of this subtree inherits it without its ancestors.
         var inheritedFontFamily: String?
         var children: [RenderedNode] = []
+        /// `autoFocus` was on when this input was last drawn. Focus is taken
+        /// when it turns on, which mounting with it on is, and not on each
+        /// render while it stays on (#511).
+        var autoFocus = false
         var widthConstraint: NSLayoutConstraint?
         var heightConstraint: NSLayoutConstraint?
 
@@ -6930,6 +6999,17 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var runningAnimation: CraftNativeRunningAnimation?
     private var renderedRoot: RenderedNode?
     private weak var lastFocusedInput: UIView?
+    /// On its way off screen, or off it: from `viewWillDisappear` until the
+    /// screen is next about to appear.
+    ///
+    /// A screen ends editing as it starts to leave (#497), and its view stays
+    /// in the window for the length of the transition. Whatever put focus
+    /// back in that time brought the keyboard up for a screen that was then
+    /// removed, where nothing could put it away: a render, and a sign-in
+    /// screen makes one as it navigates; the acknowledgement an input had
+    /// scheduled a tenth of a second before; a modal closing; `autoFocus`.
+    /// Each of them asks this first.
+    private var isLeavingScreen = false
 
     /// The person put the keyboard away (Return, or a tap on nothing in a
     /// scroll view): the last input is let go. Kept, the next render or
@@ -6995,6 +7075,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// Where the keyboard is on the screen while it is up, in screen coordinates.
     private var keyboardScreenFrame: CGRect?
     private var keyboardInsetsScheduled = false
+    private var floatingClearanceScheduled = false
+    /// Whether any scroll view may still hold room for actions that have gone.
+    private var floatingClearanceApplied = false
     /// The hybrid shell (CraftHybrid.swift), when this screen is one of a web
     /// app's native screens: told of the first frame, of a first frame that
     /// could not be drawn, and of `craft.navigation.open(path)`.
@@ -7035,6 +7118,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let timers = self.timers
         CraftNativeScriptThread.run { timers.pending.values.forEach { $0.cancel() } }
         pendingCapabilityRequests.forEach { CraftNativeActions.cancel(requestToken: $0) }
+        CraftNativeActions.endScope(capabilityScope)
         lifecycleObservers.forEach(NotificationCenter.default.removeObserver)
         if let deepLinkListener = deepLinkListener { DeepLinkManager.shared.removeNativeListener(deepLinkListener) }
     }
@@ -7091,6 +7175,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     override func viewWillAppear(_ animated: Bool) {
         super.viewWillAppear(animated)
+        isLeavingScreen = false
         if let navigationBarHidden, navigationController?.isNavigationBarHidden != navigationBarHidden {
             navigationController?.setNavigationBarHidden(navigationBarHidden, animated: animated)
         } else if navigationBarHidden == nil, navigationController?.isNavigationBarHidden == true,
@@ -7133,7 +7218,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         //
         // `lastFocusedInput` is deliberately left alone. A screen merely
         // covered by a push comes back, and restoreFocus putting the person
-        // back where they were is the behaviour that was already there.
+        // back where they were is the behaviour that was already there. It
+        // is not consulted again until the screen is coming back, or what
+        // is ended here would be started again a moment later.
+        isLeavingScreen = true
         view.endEditing(true)
         screenVisibilityChanged(false)
         stopCelebrations(in: view)
@@ -7298,6 +7386,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         pendingCapabilityDeadlines.values.forEach { $0.cancel() }
         pendingCapabilityDeadlines.removeAll()
         pendingCapabilityRequests.forEach { CraftNativeActions.cancel(requestToken: $0) }
+        CraftNativeActions.endScope(capabilityScope)
         pendingCapabilityRequests.removeAll()
         if let owner = voiceRecordingOwner {
             voiceRecordingOwner = nil
@@ -7370,6 +7459,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         emitLayoutEvents()
         sendViewportIfChanged()
         scheduleKeyboardInsets()
+        scheduleFloatingClearance()
     }
 
     /// The width the bundle last heard, so a layout pass at the same size says nothing.
@@ -8790,6 +8880,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         // The app script has no screen for the keyboard to cover.
         if !isAppScript {
+            lifecycleObservers.append(NotificationCenter.default.addObserver(
+                forName: CraftChrome.floatingActionsDidMove,
+                object: nil,
+                queue: .main
+            ) { [weak self] _ in
+                self?.scheduleFloatingClearance()
+            })
             lifecycleObservers.append(NotificationCenter.default.addObserver(
                 forName: UIResponder.keyboardWillChangeFrameNotification,
                 object: nil,
@@ -8934,7 +9031,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// took account of) insets its content by that much, so everything in it
     /// can be scrolled above the keyboard. Internal for XCTest.
     func insetScrollViewsForKeyboard() {
-        var scrolls: [UIScrollView] = []
+        var scrolls: [CraftNativeScrollView] = []
         func collect(_ node: RenderedNode?) {
             guard let node else { return }
             if let scroll = node.view as? CraftNativeScrollView, scroll.isVertical { scrolls.append(scroll) }
@@ -8951,8 +9048,51 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 let automaticBottom = max(0, scroll.adjustedContentInset.bottom - scroll.contentInset.bottom)
                 overlap = max(0, overlap - automaticBottom)
             }
-            if abs(scroll.contentInset.bottom - overlap) > 0.5 { scroll.contentInset.bottom = overlap }
-            if abs(scroll.verticalScrollIndicatorInsets.bottom - overlap) > 0.5 { scroll.verticalScrollIndicatorInsets.bottom = overlap }
+            // Its own inset is what is being measured, not part of the answer.
+            scroll.keyboardCover = overlap
+        }
+    }
+
+    /// The compact tab actions float over the trailing end of whatever
+    /// scrolls behind them. Each vertical scroll view and list they reach
+    /// into gets that much room at its end, so its last row can be brought
+    /// clear of them; one that ends above them gets none. How wide a scroll
+    /// 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.
+    func insetScrollViewsForFloatingActions() {
+        let chrome = CraftChrome.shared
+        let actions = chrome.floatingActions.flatMap { frame in
+            chrome.floatingActionsHost.flatMap { view.isDescendant(of: $0) ? frame : nil }
+        }
+        func cover(_ scroll: UIScrollView) -> CGFloat {
+            guard let actions, let window = scroll.window else { return 0 }
+            let frame = scroll.convert(scroll.bounds, to: window)
+            // 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)
+        }
+        func visit(_ node: RenderedNode?) {
+            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)
+        }
+        visit(renderedRoot)
+        floatingClearanceApplied = actions != nil
+    }
+
+    /// A layout moved a view, or the actions moved: measured again once the
+    /// pass is over, where each scroll view now ends.
+    fileprivate func scheduleFloatingClearance() {
+        guard CraftChrome.shared.floatingActions != nil || floatingClearanceApplied, !floatingClearanceScheduled else { return }
+        floatingClearanceScheduled = true
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.floatingClearanceScheduled = false
+            self.insetScrollViewsForFloatingActions()
         }
     }
 
@@ -9307,7 +9447,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                     reply(.failure(CraftNativeActionError(code: "UNSUPPORTED_TARGET", message: "Keyboard focus is supported only for text inputs")))
                     return true
                 }
-                guard node.view.becomeFirstResponder() else {
+                // A screen that is leaving does not open a keyboard it will
+                // not be there to close.
+                guard !isLeavingScreen, node.view.becomeFirstResponder() else {
                     reply(.failure(CraftNativeActionError(code: "FOCUS_FAILED", message: "The mounted view refused keyboard focus")))
                     return true
                 }
@@ -9652,6 +9794,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     private func restoreFocus(_ focused: UIView?) {
+        guard !isLeavingScreen else { return }
         guard let focused, focused.window != nil, !focused.isFirstResponder,
               lastFocusedInput === focused, firstResponder(in: rootStack) == nil else { return }
         var ancestor: UIView? = focused
@@ -9737,12 +9880,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         case "Text":
             let text = children.compactMap { $0 as? String }.joined()
             if let selectable = result as? CraftNativeSelectableTextView {
-                selectable.textContainer.maximumNumberOfLines = max(0, Int(number(props["numberOfLines"]) ?? 0))
+                selectable.textContainer.maximumNumberOfLines = max(0, craftNativeInt(number(props["numberOfLines"]) ?? 0))
                 selectable.textContainer.lineBreakMode = textLineBreakMode(props["ellipsizeMode"])
                 configureSelectableText(selectable, text: text, style: style)
             } else {
                 let label = result as! UILabel
-                label.numberOfLines = max(0, Int(number(props["numberOfLines"]) ?? 0))
+                label.numberOfLines = max(0, craftNativeInt(number(props["numberOfLines"]) ?? 0))
                 label.lineBreakMode = textLineBreakMode(props["ellipsizeMode"])
                 (label as? CraftNativeLabel)?.insets = paddingInsets(style)
                 configureText(label, text: text, style: style)
@@ -9801,6 +9944,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                         ? nil
                         : inputDrafts[current.identity] ?? props["defaultValue"] as? String
                 )
+                applyAutoFocus(props["autoFocus"], to: textView, node: current)
                 break
             }
             let field = result as! UITextField
@@ -9819,7 +9963,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             field.tintColor = color(props["selectionColor"])
             let fieldId = ObjectIdentifier(field)
             inputIdentities[fieldId] = current.identity
-            let maxLength = Int(number(props["maxLength"]) ?? 0)
+            let maxLength = craftNativeInt(number(props["maxLength"]) ?? 0)
             if maxLength > 0 {
                 textMaxLengths[fieldId] = maxLength
             } else {
@@ -9861,9 +10005,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             updateAuxiliaryHandler(events["onBlur"], in: &blurHandlers, for: field)
             updateAuxiliaryHandler(events["onEndEditing"], in: &endEditingHandlers, for: field)
             updateAuxiliaryHandler(events["onSubmitEditing"], in: &submitHandlers, for: field)
-            if props["autoFocus"] as? Bool == true, !field.isFirstResponder {
-                DispatchQueue.main.async { _ = field.becomeFirstResponder() }
-            }
+            applyAutoFocus(props["autoFocus"], to: field, node: current)
         case "SegmentedControl":
             let control = result as! CraftNativeSegmentedControl
             let items = props["items"] as? [[String: Any]] ?? []
@@ -9932,7 +10074,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 if picker.preferredDatePickerStyle != display { picker.preferredDatePickerStyle = display }
             }
             // UIKit takes an interval that divides an hour, and ignores others.
-            let interval = Int(number(props["minuteInterval"]) ?? 1)
+            let interval = craftNativeInt(number(props["minuteInterval"]) ?? 1)
             picker.minuteInterval = (1...30).contains(interval) && 60 % interval == 0 ? interval : 1
             picker.minimumDate = Self.pickerDate(props["minimumDate"])
             picker.maximumDate = Self.pickerDate(props["maximumDate"])
@@ -9978,11 +10120,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 modalFocusRestore[modalID] = focusBeforeContent
             }
             if visible, wasVisible != true { positionModals() }
-            modal.setVisible(visible, opacity: number(style["opacity"]) ?? 1, animationType: props["animationType"] as? String)
+            modal.setVisible(visible, opacity: styleNumber(style["opacity"]) ?? 1, animationType: props["animationType"] as? String)
             if !visible, wasVisible == true {
                 let restore = modalFocusRestore.removeValue(forKey: modalID)
                 DispatchQueue.main.async { [weak self, weak restore] in
-                    guard let self, let restore, restore.window != nil, restore.isDescendant(of: self.view) else { return }
+                    guard let self, !self.isLeavingScreen, let restore, restore.window != nil, restore.isDescendant(of: self.view) else { return }
                     self.lastFocusedInput = restore
                     _ = restore.becomeFirstResponder()
                 }
@@ -10005,7 +10147,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             let disabled = props["disabled"] as? Bool == true
             pressable.pressActiveOpacity = disabled
                 ? nil : number(props["activeOpacity"]) ?? 0.5
-            pressable.pressBaseOpacity = number(style["opacity"]) ?? 1
+            pressable.pressBaseOpacity = styleNumber(style["opacity"]) ?? 1
             pressable.pressUnderlayColor = type == "TouchableHighlight" && !disabled ? color(props["underlayColor"]) : nil
         case "Switch":
             if let toggle = result as? CraftNativeSolidSwitch {
@@ -10615,7 +10757,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         list.apply(
             nodes: children,
             horizontal: props["horizontal"] as? Bool == true,
-            columns: Int(number(props["numColumns"]) ?? 1),
+            columns: craftNativeInt(number(props["numColumns"]) ?? 1),
             inverted: props["inverted"] as? Bool == true,
             endReachedThreshold: threshold,
             renderItem: { [weak self] node, identity, reusable in
@@ -11148,13 +11290,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         // An input's own scrolling follows its height (CraftNativeTextView).
         if !(textView is CraftNativeTextView) { textView.isScrollEnabled = false }
-        let numberOfLines = Int(number(props["numberOfLines"]) ?? 0)
+        let numberOfLines = craftNativeInt(number(props["numberOfLines"]) ?? 0)
         if numberOfLines > 0 {
             textView.textContainer.maximumNumberOfLines = numberOfLines
         } else {
             textView.textContainer.maximumNumberOfLines = 0
         }
-        let maxLength = Int(number(props["maxLength"]) ?? 0)
+        let maxLength = craftNativeInt(number(props["maxLength"]) ?? 0)
         if maxLength > 0 {
             textMaxLengths[id] = maxLength
         } else {
@@ -11184,8 +11326,19 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         updateAuxiliaryHandler(events["onBlur"], in: &blurHandlers, for: textView)
         updateAuxiliaryHandler(events["onEndEditing"], in: &endEditingHandlers, for: textView)
         updateAuxiliaryHandler(events["onSubmitEditing"], in: &submitHandlers, for: textView)
-        if props["autoFocus"] as? Bool == true, !textView.isFirstResponder {
-            DispatchQueue.main.async { _ = textView.becomeFirstResponder() }
+    }
+
+    /// `autoFocus`: focus when the input mounts with it, or when it is turned
+    /// on later. Applied on every render it took the keyboard back each time
+    /// anything else on the screen changed (#511).
+    private func applyAutoFocus(_ value: Any?, to input: UIView, node: RenderedNode) {
+        let wanted = value as? Bool == true
+        let turnedOn = wanted && !node.autoFocus
+        node.autoFocus = wanted
+        guard turnedOn, !input.isFirstResponder else { return }
+        DispatchQueue.main.async { [weak self] in
+            guard self?.isLeavingScreen == false else { return }
+            _ = input.becomeFirstResponder()
         }
     }
 
@@ -11195,8 +11348,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// leaving a hole.
     private func configureIcon(_ icon: UIImageView, props: [String: Any], style: [String: Any]) {
         let name = (props["symbol"] as? String) ?? (props["name"] as? String) ?? ""
-        let box = [number(style["width"]), number(style["height"])].compactMap { $0 }.min()
-        let fontSize = number(style["fontSize"])
+        let box = [styleNumber(style["width"]), styleNumber(style["height"])].compactMap { $0 }.min()
+        let fontSize = styleNumber(style["fontSize"])
         // Without a size of its own an icon is a 20 pt square (contract A2).
         (icon as? CraftNativeIconView)?.defaultBox = box == nil && fontSize == nil ? 20 : nil
         let pointSize = fontSize ?? (box ?? 20) * 0.84
@@ -11237,10 +11390,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         stack.alignItems = style["alignItems"] as? String ?? "stretch"
         stack.alignContent = style["alignContent"] as? String ?? "flex-start"
         stack.justifyContent = style["justifyContent"] as? String ?? "flex-start"
-        let gap = max(0, number(style["gap"]) ?? 0)
+        let gap = max(0, styleNumber(style["gap"]) ?? 0)
         stack.gap = gap
-        stack.rowGap = max(0, number(style["rowGap"]) ?? gap)
-        stack.columnGap = max(0, number(style["columnGap"]) ?? gap)
+        stack.rowGap = max(0, styleNumber(style["rowGap"]) ?? gap)
+        stack.columnGap = max(0, styleNumber(style["columnGap"]) ?? gap)
         stack.grid = style["display"] as? String == "grid"
         stack.gridColumns = craftNativeGridColumnCount(style["gridTemplateColumns"] ?? style["gridColumns"])
         stack.gridRows = craftNativeGridRowCount(style["gridTemplateRows"])
@@ -11252,8 +11405,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func addJustificationSpacers(to stack: CraftNativeFlowView, value: String?) { }
 
     private func applyViewStyle(_ style: [String: Any], to view: UIView, node: RenderedNode) {
-        let width = style["minWidth"] == nil && style["maxWidth"] == nil ? number(style["width"]) : nil
-        let height = style["minHeight"] == nil && style["maxHeight"] == nil ? number(style["height"]) : nil
+        let width = style["minWidth"] == nil && style["maxWidth"] == nil ? styleNumber(style["width"]) : nil
+        let height = style["minHeight"] == nil && style["maxHeight"] == nil ? styleNumber(style["height"]) : nil
         updateDimension(width, constraint: &node.widthConstraint, anchor: view.widthAnchor)
         updateDimension(height, constraint: &node.heightConstraint, anchor: view.heightAnchor)
         view.backgroundColor = color(style["backgroundColor"]) ?? .clear
@@ -11272,31 +11425,31 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             direction: style["gradientDirection"] as? String,
             colors: [color(style["gradientFrom"]), color(style["gradientVia"]), color(style["gradientTo"])]
         )
-        view.alpha = number(style["opacity"]) ?? 1
+        view.alpha = styleNumber(style["opacity"]) ?? 1
         view.isHidden = style["display"] as? String == "none"
-        let borderRadius = number(style["borderRadius"]) ?? 0
+        let borderRadius = styleNumber(style["borderRadius"]) ?? 0
         let cornerRadiusKeys = ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomRightRadius", "borderBottomLeftRadius"]
         let hasCornerRadii = cornerRadiusKeys.contains { style[$0] != nil }
         view.craftRequestedCornerRadius = borderRadius
         view.craftRequestedCornerRadii = hasCornerRadii
-            ? cornerRadiusKeys.map { number(style[$0]) ?? borderRadius }
+            ? cornerRadiusKeys.map { styleNumber(style[$0]) ?? borderRadius }
             : nil
-        let borderWidth = number(style["borderWidth"]) ?? 0
+        let borderWidth = styleNumber(style["borderWidth"]) ?? 0
         let borderColor = color(style["borderColor"]) ?? .clear
         let sideWidthKeys = ["borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth"]
         let sideColorKeys = ["borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor"]
         view.craftApplySideBorders(
             (sideWidthKeys + sideColorKeys).contains { style[$0] != nil },
             style: style["borderStyle"] as? String,
-            widths: sideWidthKeys.map { number(style[$0]) ?? borderWidth },
+            widths: sideWidthKeys.map { styleNumber(style[$0]) ?? borderWidth },
             colors: sideColorKeys.map { color(style[$0]) ?? borderColor }
         )
-        view.layer.zPosition = number(style["zIndex"]) ?? 0
+        view.layer.zPosition = styleNumber(style["zIndex"]) ?? 0
         applyTransform(style["transform"], to: view)
-        let elevation = max(0, number(style["elevation"]) ?? 0)
+        let elevation = max(0, styleNumber(style["elevation"]) ?? 0)
         let shadowColor = color(style["shadowColor"]) ?? .black
-        let shadowOpacity = min(1, max(0, number(style["shadowOpacity"]) ?? (elevation > 0 ? min(0.28, 0.12 + elevation * 0.02) : 0)))
-        let shadowRadius = max(0, number(style["shadowRadius"]) ?? elevation * 0.5)
+        let shadowOpacity = min(1, max(0, styleNumber(style["shadowOpacity"]) ?? (elevation > 0 ? min(0.28, 0.12 + elevation * 0.02) : 0)))
+        let shadowRadius = max(0, styleNumber(style["shadowRadius"]) ?? elevation * 0.5)
         let shadowOffset = style["shadowOffset"] as? [String: Any]
         view.layer.shadowColor = shadowColor.cgColor
         view.layer.shadowOpacity = Float(shadowOpacity)
@@ -11329,7 +11482,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     private func paddingInsets(_ style: [String: Any]) -> UIEdgeInsets {
         func nonNegative(_ value: Any?) -> CGFloat? {
-            guard let value = number(value), value >= 0 else { return nil }
+            guard let value = styleNumber(value), value >= 0 else { return nil }
             return value
         }
         let padding = nonNegative(style["padding"]) ?? 0
@@ -11352,11 +11505,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         var threeDimensional = CATransform3DIdentity
         var hasThreeDimensionalRotation = false
         for transform in transforms {
-            if let value = number(transform["translateX"]) { affine = affine.translatedBy(x: value, y: 0) }
-            if let value = number(transform["translateY"]) { affine = affine.translatedBy(x: 0, y: value) }
-            if let value = number(transform["scale"]) { affine = affine.scaledBy(x: value, y: value) }
-            if let value = number(transform["scaleX"]) { affine = affine.scaledBy(x: value, y: 1) }
-            if let value = number(transform["scaleY"]) { affine = affine.scaledBy(x: 1, y: value) }
+            if let value = styleNumber(transform["translateX"]) { affine = affine.translatedBy(x: value, y: 0) }
+            if let value = styleNumber(transform["translateY"]) { affine = affine.translatedBy(x: 0, y: value) }
+            if let value = styleNumber(transform["scale"]) { affine = affine.scaledBy(x: value, y: value) }
+            if let value = styleNumber(transform["scaleX"]) { affine = affine.scaledBy(x: value, y: 1) }
+            if let value = styleNumber(transform["scaleY"]) { affine = affine.scaledBy(x: 1, y: value) }
             if let value = transformAngle(transform["rotate"] ?? transform["rotateZ"]) { affine = affine.rotated(by: value) }
             if let value = transformAngle(transform["skewX"]) { affine = affine.concatenating(CGAffineTransform(a: 1, b: 0, c: tan(value), d: 1, tx: 0, ty: 0)) }
             if let value = transformAngle(transform["skewY"]) { affine = affine.concatenating(CGAffineTransform(a: 1, b: tan(value), c: 0, d: 1, tx: 0, ty: 0)) }
@@ -11394,10 +11547,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         label.font = textFont(style, default: .systemFont(ofSize: 16))
         label.textAlignment = textAlignment(style["textAlign"])
         var attributes: [NSAttributedString.Key: Any] = [:]
-        if let spacing = number(style["letterSpacing"]) { attributes[.kern] = spacing }
+        if let spacing = styleNumber(style["letterSpacing"]) { attributes[.kern] = spacing }
         addTextDecorationAttributes(style, to: &attributes)
         if let shadow = textShadow(style) { attributes[.shadow] = shadow }
-        if let lineHeight = number(style["lineHeight"]) {
+        if let lineHeight = styleNumber(style["lineHeight"]) {
             let paragraph = NSMutableParagraphStyle()
             paragraph.minimumLineHeight = lineHeight
             paragraph.maximumLineHeight = lineHeight
@@ -11451,8 +11604,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             .foregroundColor: color,
             .font: font,
         ]
-        if let spacing = number(style["letterSpacing"]) { attributes[.kern] = spacing }
-        if let lineHeight = number(style["lineHeight"]) {
+        if let spacing = styleNumber(style["letterSpacing"]) { attributes[.kern] = spacing }
+        if let lineHeight = styleNumber(style["lineHeight"]) {
             let paragraph = NSMutableParagraphStyle()
             paragraph.minimumLineHeight = lineHeight
             paragraph.maximumLineHeight = lineHeight
@@ -11474,14 +11627,14 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             .foregroundColor: color(style["color"]) ?? .label,
             .font: font,
         ]
-        if let spacing = number(style["letterSpacing"]) { attributes[.kern] = spacing }
+        if let spacing = styleNumber(style["letterSpacing"]) { attributes[.kern] = spacing }
         // UIKit otherwise resets the field's alignment to natural when these attributes are applied.
         let paragraph = NSMutableParagraphStyle()
         paragraph.alignment = alignment
         // The default paragraph wraps even inside a UITextField. A long URL
         // then paints a second line outside the field instead of scrolling.
         if singleLine { paragraph.lineBreakMode = .byClipping }
-        if let lineHeight = number(style["lineHeight"]) {
+        if let lineHeight = styleNumber(style["lineHeight"]) {
             paragraph.minimumLineHeight = lineHeight
             paragraph.maximumLineHeight = lineHeight
         }
@@ -11500,7 +11653,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             width: number(offset?["width"]) ?? 0,
             height: number(offset?["height"]) ?? 0
         )
-        shadow.shadowBlurRadius = max(0, number(style["textShadowRadius"]) ?? 0)
+        shadow.shadowBlurRadius = max(0, styleNumber(style["textShadowRadius"]) ?? 0)
         return shadow
     }
 
@@ -11539,7 +11692,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     private func textFont(_ style: [String: Any], default fallback: UIFont) -> UIFont {
-        let size = number(style["fontSize"]) ?? fallback.pointSize
+        let size = styleNumber(style["fontSize"]) ?? fallback.pointSize
         let weight: UIFont.Weight
         switch craftNativeFontWeight(style["fontWeight"]) {
         case "100": weight = .ultraLight