@craft-native/ios 0.0.435 → 0.0.436

package/package.json

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

package/templates/CraftNativeMutation.swift

@@ -18,10 +18,22 @@ struct CraftNativeMutationFailure: Error, Equatable {
 struct CraftNativeMutationResult {
     let batchId: String
     let revision: Int
-    let document: [String: Any]?
     let updatedNodeIds: [String]
     let affectedNodeIds: [String]
     let requiresFullRender: Bool
+    private let materialize: () -> [String: Any]?
+    /// The committed tree, built when asked for: a host that redraws only the
+    /// nodes a batch touched never needs the whole tree.
+    var document: [String: Any]? { materialize() }
+
+    init(batchId: String, revision: Int, document: @escaping () -> [String: Any]?, updatedNodeIds: [String], affectedNodeIds: [String], requiresFullRender: Bool) {
+        self.batchId = batchId
+        self.revision = revision
+        self.materialize = document
+        self.updatedNodeIds = updatedNodeIds
+        self.affectedNodeIds = affectedNodeIds
+        self.requiresFullRender = requiresFullRender
+    }
 }
 
 /// Validates and applies versioned native-tree mutations without touching UIKit.
@@ -91,6 +103,8 @@ final class CraftNativeMutationDocument {
         var updatedNodeIds: [String] = []
         var affectedNodeIds: [String] = []
         var requiresFullRender = false
+        // Only an operation that adds, moves or removes nodes can leave one unreachable.
+        var reshaped = false
         for (index, value) in operations.enumerated() {
             guard let operation = value as? [String: Any], let name = operation["op"] as? String else {
                 throw CraftNativeMutationFailure(
@@ -99,6 +113,7 @@ final class CraftNativeMutationDocument {
                     operationIndex: index
                 )
             }
+            if name != "updateNode" { reshaped = true }
             do {
                 switch name {
                 case "createNode":
@@ -147,7 +162,7 @@ final class CraftNativeMutationDocument {
             guard let root = candidateNodes[candidateRoot], root.parent == nil else {
                 throw CraftNativeMutationFailure("INVALID_TREE", "root node must not have a parent")
             }
-            guard descendants(of: candidateRoot, nodes: candidateNodes).count + 1 == candidateNodes.count else {
+            guard !reshaped || descendants(of: candidateRoot, nodes: candidateNodes).count + 1 == candidateNodes.count else {
                 throw CraftNativeMutationFailure("INVALID_TREE", "all nodes must be reachable from the root")
             }
         }
@@ -158,7 +173,7 @@ final class CraftNativeMutationDocument {
         return CraftNativeMutationResult(
             batchId: batchId,
             revision: nextRevision,
-            document: candidateRoot.flatMap { materialize($0, nodes: candidateNodes) },
+            document: { [candidateRoot, candidateNodes, weak self] in candidateRoot.flatMap { self?.materialize($0, nodes: candidateNodes) } },
             updatedNodeIds: updatedNodeIds,
             affectedNodeIds: affectedNodeIds,
             requiresFullRender: requiresFullRender

package/templates/testing/DriverTests.swift.template

@@ -285,8 +285,15 @@ final class DriverTests: XCTestCase {
         return (parts[0], parts.count > 1 ? Double(parts[1]) ?? 10 : 10)
     }
 
-    /// A tap that never fails the run: an element covered a moment (the big
-    /// timer coming up) is tapped where it is, and the check after says.
+    /// A switch reports "0" or "1". Any other value is not a switch state to
+    /// wait on, so the tap stands as it would for any other control.
+    func switchFlipped(from before: String?, to after: String?) -> Bool {
+        let states: Set<String> = ["0", "1"]
+        guard let before, let after, states.contains(before), states.contains(after) else { return true }
+        return before != after
+    }
+
+    /// Deliver one gesture; the command's observation determines success.
     func press(_ element: XCUIElement) {
         if element.isHittable { element.tap() }
         else { element.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5)).tap() }
@@ -438,8 +445,21 @@ final class DriverTests: XCTestCase {
             else { XCTFail("Element not found"); note("FAIL tapexact \(arg): NOT FOUND") }
         case "tapid":
             let target = identified(arg)
-            if target.waitForExistence(timeout: 10) { press(target); note("tapid \(arg): ok") }
-            else { XCTFail("Element not found"); note("FAIL tapid \(arg): NOT FOUND") }
+            if !target.waitForExistence(timeout: 10) { XCTFail("Element not found"); note("FAIL tapid \(arg): NOT FOUND") }
+            else if target.elementType == .switch {
+                // Observe one physical gesture. Retapping could conceal a
+                // renderer or hit-testing failure (HQ agreement job 7570).
+                let before = target.value as? String
+                press(target)
+                let settle = Date().addingTimeInterval(1.5)
+                var flipped = false
+                repeat {
+                    flipped = switchFlipped(from: before, to: target.value as? String)
+                    if !flipped { Thread.sleep(forTimeInterval: 0.25) }
+                } while !flipped && Date() < settle
+                check(flipped, "tapid \(arg) flips the switch")
+            }
+            else { press(target); note("tapid \(arg): ok") }
         case "longpressid":
             let target = identified(arg)
             guard target.waitForExistence(timeout: 10), target.isHittable else {