craft-native 0.0.212 → 0.0.213

package/dist/android/templates/CraftNative.kt.template

@@ -353,6 +353,12 @@ object CraftNative {
         nodeData: FloatArray,
         treeMeta: FloatArray,
     ): FloatArray?
+    private external fun nativeLayoutTreeV4(
+        width: Float,
+        height: Float,
+        nodeData: FloatArray,
+        treeMeta: FloatArray,
+    ): FloatArray?
     private external fun nativeClipboardRead(activity: Activity): String?
     private external fun nativeClipboardWrite(activity: Activity, text: String): Boolean
     private external fun nativeOpenUrl(activity: Activity, url: String): Boolean
@@ -635,6 +641,17 @@ object CraftNative {
         }
     }
 
+    /** Resolve a reverse-aware tree with shared grid-auto-rows support. */
+    fun layoutTreeV4(width: Float, height: Float, nodeData: FloatArray, treeMeta: FloatArray): FloatArray? {
+        if (!isAvailable || nodeData.isEmpty() || treeMeta.isEmpty()) return null
+        return try {
+            nativeLayoutTreeV4(width, height, nodeData, treeMeta)
+                ?.takeIf { it.size >= treeMeta.size / 2 * 4 && it.all { value -> value.isFinite() } }
+        } catch (e: UnsatisfiedLinkError) {
+            null
+        }
+    }
+
     /**
      * The clipboard's text, or null to use the Kotlin implementation.
      *

package/dist/cli.js

@@ -3424,7 +3424,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.212";
+var version = "0.0.213";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -309,7 +309,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.212";
+var version = "0.0.213";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -57,7 +57,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.212";
+var version = "0.0.213";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/templates/testing/DriverTests.swift.template

@@ -87,6 +87,13 @@ final class DriverTests: XCTestCase {
         XCTAssertTrue(ok, what)
     }
 
+    /// testIDs are exact identifiers. Resolving a unique element with the
+    /// subscript scans the whole accessibility tree for ambiguous matches;
+    /// firstMatch can stop at the identified node, including a scrolled row.
+    func identified(_ id: String) -> XCUIElement {
+        app.descendants(matching: .any).matching(NSPredicate(format: "identifier == %@", id)).firstMatch
+    }
+
     func element(containing text: String, in target: XCUIApplication? = nil) -> XCUIElement? {
         let root = target ?? app
         let predicate = NSPredicate(format: "label CONTAINS[c] %@ OR value CONTAINS[c] %@ OR identifier == %@", text, text, text)
@@ -197,7 +204,7 @@ final class DriverTests: XCTestCase {
         switch command {
         case "ifid":
             let rest = arg.split(separator: " ", maxSplits: 1).map(String.init)
-            if rest.count == 2, app.descendants(matching: .any)[rest[0]].waitForExistence(timeout: 3) { note("ifid \(rest[0]): shown"); run(rest[1]) }
+            if rest.count == 2, identified(rest[0]).waitForExistence(timeout: 3) { note("ifid \(rest[0]): shown"); run(rest[1]) }
             else { note("ifid \(rest.first ?? ""): not shown") }
         case "launch": app.launch()
         case "activate": app.activate()
@@ -261,7 +268,7 @@ final class DriverTests: XCTestCase {
             if let target = poll(10, { exact(arg) }) { press(target); note("tapexact \(arg): ok") }
             else { XCTFail("Element not found"); note("FAIL tapexact \(arg): NOT FOUND") }
         case "tapid":
-            let target = app.descendants(matching: .any)[arg]
+            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") }
         case "tapxy":
@@ -281,7 +288,7 @@ final class DriverTests: XCTestCase {
         case "return": app.typeText(XCUIKeyboardKey.return.rawValue); note("return")
         case "typeid":
             let idParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
-            let target = app.descendants(matching: .any)[idParts[0]]
+            let target = identified(idParts[0])
             if target.waitForExistence(timeout: 10) {
                 target.tap()
                 Thread.sleep(forTimeInterval: 0.8)
@@ -306,15 +313,15 @@ final class DriverTests: XCTestCase {
             check(poll(seconds, { exact(text) }) != nil, "expectexact \(text)")
         case "expectid":
             let (id, seconds) = split(arg)
-            check(app.descendants(matching: .any)[id].waitForExistence(timeout: seconds), "expectid \(id)")
+            check(identified(id).waitForExistence(timeout: seconds), "expectid \(id)")
         case "labelid":
             let idParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
-            let target = app.descendants(matching: .any)[idParts[0]]
+            let target = identified(idParts[0])
             let want = idParts.count > 1 ? idParts[1] : ""
             let seen = target.waitForExistence(timeout: 5) ? target.label : "(missing)"
             check(seen == want, "labelid \(idParts[0]) \(want) (saw \(seen))")
         case "absentid":
-            check(!app.descendants(matching: .any)[arg].exists, "absentid \(arg)")
+            check(!identified(arg).exists, "absentid \(arg)")
         case "absent":
             check(element(containing: arg) == nil, "absent \(arg)")
         case "tabbar":

package/dist/macos/templates/native_layout.zig

@@ -98,6 +98,10 @@ pub const Style = struct {
     grid_columns: u32 = 1,
     row_gap: f32 = 0,
     column_gap: f32 = 0,
+    /// Minimum height for generated grid rows. This is optional in the tree
+    /// ABI and remains host-neutral because hosts resolve percentages before
+    /// serializing the style.
+    grid_auto_rows: ?f32 = null,
 };
 
 pub const Node = struct {
@@ -243,6 +247,53 @@ pub const LayoutNodeInputV2 = extern struct {
     child_count: u32,
 };
 
+/// Versioned tree input that carries the resolved `grid-auto-rows` minimum.
+/// Appending the field keeps the v1/v2/v3 layouts ABI-compatible for older
+/// hosts while allowing a native tree to use the same auto-row rule on every
+/// platform.
+pub const LayoutStyleInputV4 = extern struct {
+    direction: u32,
+    width: f32,
+    height: f32,
+    intrinsic_width: f32,
+    intrinsic_height: f32,
+    baseline: f32,
+    aspect_ratio: f32,
+    flex_basis: f32,
+    flex_grow: f32,
+    flex_shrink: f32,
+    min_width: f32,
+    max_width: f32,
+    min_height: f32,
+    max_height: f32,
+    gap: f32,
+    justify_content: u32,
+    align_items: u32,
+    align_self: u32,
+    flex_wrap: u32,
+    align_content: u32,
+    margin_top: f32,
+    margin_right: f32,
+    margin_bottom: f32,
+    margin_left: f32,
+    padding_top: f32,
+    padding_right: f32,
+    padding_bottom: f32,
+    padding_left: f32,
+    grid: u32,
+    grid_columns: u32,
+    row_gap: f32,
+    column_gap: f32,
+    reverse: u32,
+    grid_auto_rows: f32,
+};
+
+pub const LayoutNodeInputV4 = extern struct {
+    style: LayoutStyleInputV4,
+    first_child: u32,
+    child_count: u32,
+};
+
 const max_layout_nodes: usize = 65_536;
 
 /// Resolve an entire native view tree using the same layout rules used by the
@@ -361,6 +412,43 @@ pub export fn craft_native_layout_tree_v3(
     return if (result == node_count) 0 else -1;
 }
 
+/// v4 tree layout entry point. It preserves v3's reverse/wrap-reverse bits
+/// and adds one resolved `grid-auto-rows` minimum per node.
+pub export fn craft_native_layout_tree_v4(
+    viewport_width: f32,
+    viewport_height: f32,
+    nodes: [*]const LayoutNodeInputV4,
+    node_count: usize,
+    frames: [*]Frame,
+    frame_count: usize,
+) callconv(.c) c_int {
+    if (node_count == 0 or node_count > max_layout_nodes or frame_count < node_count) return -1;
+
+    const input = nodes[0..node_count];
+    const visited = std.heap.page_allocator.alloc(bool, node_count) catch return -1;
+    defer std.heap.page_allocator.free(visited);
+    @memset(visited, false);
+    if (!validateLayoutTreeV4(input, 0, visited)) return -1;
+
+    var tree = std.heap.page_allocator.alloc(Node, node_count) catch return -1;
+    defer std.heap.page_allocator.free(tree);
+    for (input, 0..) |item, index| {
+        const first = @as(usize, @intCast(item.first_child));
+        const count = @as(usize, @intCast(item.child_count));
+        tree[index] = .{
+            .style = layoutStyleV4(item.style),
+            .children = tree[first .. first + count],
+        };
+    }
+
+    const result = layout(
+        tree[0],
+        .{ .width = finiteNonNegative(viewport_width), .height = finiteNonNegative(viewport_height) },
+        frames[0..frame_count],
+    ) catch return -1;
+    return if (result == node_count) 0 else -1;
+}
+
 fn validateLayoutTree(input: []const LayoutNodeInput, index: usize, visited: []bool) bool {
     if (index >= input.len or visited[index]) return false;
     visited[index] = true;
@@ -387,6 +475,19 @@ fn validateLayoutTreeV2(input: []const LayoutNodeInputV2, index: usize, visited:
     return true;
 }
 
+fn validateLayoutTreeV4(input: []const LayoutNodeInputV4, index: usize, visited: []bool) bool {
+    if (index >= input.len or visited[index]) return false;
+    visited[index] = true;
+    const item = input[index];
+    const first = @as(usize, @intCast(item.first_child));
+    const count = @as(usize, @intCast(item.child_count));
+    if (first > input.len or count > input.len - first or (count > 0 and first <= index)) return false;
+    for (first..first + count) |child| {
+        if (!validateLayoutTreeV4(input, child, visited)) return false;
+    }
+    return true;
+}
+
 fn layoutStyle(input: LayoutStyleInput) Style {
     return .{
         .direction = if (input.direction == 1) .column else .row,
@@ -470,6 +571,46 @@ fn layoutStyleV3(input: LayoutStyleInputV2) Style {
     return style;
 }
 
+fn layoutStyleV4(input: LayoutStyleInputV4) Style {
+    return .{
+        .direction = if (input.direction == 1) .column else .row,
+        .reverse = (input.reverse & 1) != 0,
+        .wrap_reverse = (input.reverse & 2) != 0,
+        .width = optionalFinite(input.width),
+        .height = optionalFinite(input.height),
+        .intrinsic_width = optionalFinite(input.intrinsic_width),
+        .intrinsic_height = optionalFinite(input.intrinsic_height),
+        .baseline = optionalFinite(input.baseline),
+        .aspect_ratio = optionalFinite(input.aspect_ratio),
+        .flex_basis = optionalFinite(input.flex_basis),
+        .flex_grow = finiteNonNegative(input.flex_grow),
+        .flex_shrink = finiteNonNegative(input.flex_shrink),
+        .min_width = optionalFinite(input.min_width),
+        .max_width = optionalFinite(input.max_width),
+        .min_height = optionalFinite(input.min_height),
+        .max_height = optionalFinite(input.max_height),
+        .gap = finiteNonNegative(input.gap),
+        .justify_content = @fromBackingInt(@intCast(@min(input.justify_content, 5))),
+        .align_items = @fromBackingInt(@intCast(@min(input.align_items, 4))),
+        .align_self = if (input.align_self == 0) null else @fromBackingInt(@intCast(@min(input.align_self - 1, 4))),
+        .flex_wrap = input.flex_wrap != 0,
+        .align_content = @fromBackingInt(@intCast(@min(input.align_content, 6))),
+        .margin_top = finiteNonNegative(input.margin_top),
+        .margin_right = finiteNonNegative(input.margin_right),
+        .margin_bottom = finiteNonNegative(input.margin_bottom),
+        .margin_left = finiteNonNegative(input.margin_left),
+        .padding_top = finiteNonNegative(input.padding_top),
+        .padding_right = finiteNonNegative(input.padding_right),
+        .padding_bottom = finiteNonNegative(input.padding_bottom),
+        .padding_left = finiteNonNegative(input.padding_left),
+        .grid = input.grid != 0,
+        .grid_columns = @max(@as(u32, 1), input.grid_columns),
+        .row_gap = finiteNonNegative(input.row_gap),
+        .column_gap = finiteNonNegative(input.column_gap),
+        .grid_auto_rows = optionalFinite(input.grid_auto_rows),
+    };
+}
+
 fn optionalFinite(value: f32) ?f32 {
     return if (std.math.isFinite(value)) value else null;
 }
@@ -1267,7 +1408,7 @@ fn gridRowHeight(node: Node, row: usize, column_count: usize) f32 {
         const child_height = child.style.height orelse ratio_height orelse child.style.intrinsic_height orelse child.style.flex_basis orelse 0;
         height = @max(height, clamp(child_height, child.style.min_height, child.style.max_height) + verticalMargins(child));
     }
-    return height;
+    return @max(height, finiteNonNegative(node.style.grid_auto_rows orelse 0));
 }
 
 fn childMainBasis(node: Node, parent_direction: Axis) f32 {
@@ -1524,6 +1665,46 @@ fn emptyLayoutStyleInputV2() LayoutStyleInputV2 {
     };
 }
 
+fn emptyLayoutStyleInputV4() LayoutStyleInputV4 {
+    const unset = std.math.nan(f32);
+    return .{
+        .direction = 0,
+        .width = unset,
+        .height = unset,
+        .intrinsic_width = unset,
+        .intrinsic_height = unset,
+        .baseline = unset,
+        .aspect_ratio = unset,
+        .flex_basis = unset,
+        .flex_grow = 0,
+        .flex_shrink = 0,
+        .min_width = unset,
+        .max_width = unset,
+        .min_height = unset,
+        .max_height = unset,
+        .gap = 0,
+        .justify_content = 0,
+        .align_items = 3,
+        .align_self = 0,
+        .flex_wrap = 0,
+        .align_content = 6,
+        .margin_top = 0,
+        .margin_right = 0,
+        .margin_bottom = 0,
+        .margin_left = 0,
+        .padding_top = 0,
+        .padding_right = 0,
+        .padding_bottom = 0,
+        .padding_left = 0,
+        .grid = 0,
+        .grid_columns = 1,
+        .row_gap = 0,
+        .column_gap = 0,
+        .reverse = 0,
+        .grid_auto_rows = unset,
+    };
+}
+
 fn clampBounds(value: f32, lower: f32, upper: f32) f32 {
     var result = finiteNonNegative(value);
     if (std.math.isFinite(lower) and lower >= 0) result = @max(result, lower);
@@ -1566,6 +1747,37 @@ test "exports the host-neutral tree layout contract" {
     try std.testing.expectEqual(@as(f32, 10), frames[1].height);
 }
 
+test "v4 tree layout applies a resolved grid auto-row minimum" {
+    var root_style = emptyLayoutStyleInputV4();
+    root_style.width = 100;
+    root_style.height = 100;
+    root_style.grid = 1;
+    root_style.grid_columns = 2;
+    root_style.grid_auto_rows = 20;
+
+    var first_style = emptyLayoutStyleInputV4();
+    first_style.intrinsic_width = 10;
+    first_style.intrinsic_height = 5;
+    var second_style = emptyLayoutStyleInputV4();
+    second_style.intrinsic_width = 10;
+    second_style.intrinsic_height = 7;
+    var third_style = emptyLayoutStyleInputV4();
+    third_style.intrinsic_width = 10;
+    third_style.intrinsic_height = 4;
+
+    const nodes = [_]LayoutNodeInputV4{
+        .{ .style = root_style, .first_child = 1, .child_count = 3 },
+        .{ .style = first_style, .first_child = 0, .child_count = 0 },
+        .{ .style = second_style, .first_child = 0, .child_count = 0 },
+        .{ .style = third_style, .first_child = 0, .child_count = 0 },
+    };
+    var frames: [4]Frame = undefined;
+    try std.testing.expectEqual(@as(c_int, 0), craft_native_layout_tree_v4(100, 100, &nodes, nodes.len, &frames, frames.len));
+    try std.testing.expectEqual(@as(f32, 0), frames[1].y);
+    try std.testing.expectEqual(@as(f32, 0), frames[2].y);
+    try std.testing.expectEqual(@as(f32, 20), frames[3].y);
+}
+
 test "lays out nested flat trees with absolute descendant frames" {
     var root_style = emptyLayoutStyleInput();
     root_style.width = 200;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.212",
+  "version": "0.0.213",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",