craft-native 0.0.276 → 0.0.290

package/dist/ios/templates/CraftNativeMutation.swift

@@ -115,6 +115,9 @@ final class CraftNativeMutationDocument {
                     // A child crossing parents needs the committed tree to be
                     // reconciled so the host can move its existing native view.
                     requiresFullRender = true
+                case "replaceChildren":
+                    let parentId = try replaceChildren(operation, nodes: &candidateNodes)
+                    appendUnique(parentId, to: &affectedNodeIds)
                 case "removeNode":
                     if let id = operation["id"] as? String, let parent = candidateNodes[id]?.parent {
                         appendUnique(parent, to: &affectedNodeIds)
@@ -287,6 +290,54 @@ final class CraftNativeMutationDocument {
         return previousParentId
     }
 
+    /// Replaces a container's ordered child snapshot in one atomic mutation.
+    ///
+    /// The list protocol uses this operation when a keyed `:for` expansion
+    /// produces a new row set. Existing nodes may stay attached to the same
+    /// parent; removed children become detached and can be reused or removed
+    /// by later operations in the same batch.
+    private func replaceChildren(_ operation: [String: Any], nodes: inout [String: Node]) throws -> String {
+        let parentId = try requiredId(operation, field: "parentId", name: "replaceChildren")
+        guard var parent = nodes[parentId] else {
+            throw CraftNativeMutationFailure("UNKNOWN_PARENT", "node \(parentId) does not exist")
+        }
+        guard acceptsChildren(parent.type) else {
+            throw CraftNativeMutationFailure("INVALID_PARENT", "node \(parentId) cannot contain child nodes")
+        }
+        guard let values = operation["children"] as? [Any] else {
+            throw CraftNativeMutationFailure("INVALID_CHILDREN", "replaceChildren.children must be an array")
+        }
+        var childIds: [String] = []
+        for value in values {
+            guard let childId = value as? String, !childId.isEmpty else {
+                throw CraftNativeMutationFailure("INVALID_CHILDREN", "replaceChildren.children must contain non-empty ids")
+            }
+            guard !childIds.contains(childId) else {
+                throw CraftNativeMutationFailure("DUPLICATE_CHILD", "child \(childId) appears more than once")
+            }
+            guard let child = nodes[childId] else {
+                throw CraftNativeMutationFailure("UNKNOWN_NODE", "node \(childId) does not exist")
+            }
+            guard childId != parentId, !descendants(of: childId, nodes: nodes).contains(parentId) else {
+                throw CraftNativeMutationFailure("CYCLE", "attaching node \(childId) would create a cycle")
+            }
+            guard child.parent == nil || child.parent == parentId else {
+                throw CraftNativeMutationFailure("NODE_ATTACHED", "node \(childId) already has a parent")
+            }
+            childIds.append(childId)
+        }
+        let removedChildIds = parent.children.filter { !childIds.contains($0) }
+        for oldChildId in removedChildIds {
+            for descendant in descendants(of: oldChildId, nodes: nodes).union([oldChildId]) {
+                nodes.removeValue(forKey: descendant)
+            }
+        }
+        parent.children = childIds
+        nodes[parentId] = parent
+        for childId in childIds { nodes[childId]?.parent = parentId }
+        return parentId
+    }
+
     private func removeNode(
         _ operation: [String: Any],
         nodes: inout [String: Node],

package/dist/ios/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) } }