Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: Make AxNode writer shadowroot aware

Karl Seguin21b42ae0efe8
diff --git a/src/browser/tests/cdp/shadow_dom.html b/src/browser/tests/cdp/shadow_dom.html
new file mode 100644
index 000000000..5f1dc5629
--- /dev/null
+++ b/src/browser/tests/cdp/shadow_dom.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<body>
+ <x-coupon id="coupon"><span id="slotted">slotted-text</span><span id="unslotted" slot="nope">unslotted-text</span></x-coupon>
+ <div id="closed-host"></div>
+ <script>
+ customElements.define('x-coupon', class extends HTMLElement {
+ connectedCallback() {
+ this.attachShadow({ mode: 'open' }).innerHTML =
+ '<label>Coupon code <input id="code"></label><button id="apply">Apply</button><slot></slot>';
+ }
+ });
+ document.getElementById("closed-host").attachShadow({ mode: "closed" }).innerHTML =
+ '<button id="in-closed">in-closed</button>';
+ </script>
+</body>
+</html>
diff --git a/src/browser/webapi/Node.zig b/src/browser/webapi/Node.zig
index ec837703d..216293467 100644
--- a/src/browser/webapi/Node.zig
+++ b/src/browser/webapi/Node.zig
@@ -1831,6 +1831,34 @@ pub fn flatParent(self: *Node, frame: *const Frame) ?*Node {
return parent;
}
+/// The first child in the flat tree: a host's first shadow child, an assigned
+/// slot's first slottable, else the DOM first child.
+pub fn flatFirstChild(self: *Node, frame: *const Frame) ?*Node {
+ if (self.is(Element)) |el| {
+ if (el.hostedShadowRoot(frame)) |shadow| {
+ return shadow.asNode().firstChild();
+ }
+ }
+ if (self.is(Element.Html.Slot)) |slot| {
+ // empty while the slot isn't in a shadow tree
+ if (slot._assigned.items.len > 0) {
+ return slot._assigned.items[0];
+ }
+ }
+ return self.firstChild();
+}
+
+/// The next sibling in the flat tree: a slotted node's next slottable, else
+/// the DOM next sibling.
+pub fn flatNextSibling(self: *Node, frame: *const Frame) ?*Node {
+ if (self.assignedSlot(frame)) |slot| {
+ const assigned = slot._assigned.items;
+ const i = std.mem.indexOfScalar(*Node, assigned, self) orelse return null;
+ return if (i + 1 < assigned.len) assigned[i + 1] else null;
+ }
+ return self.nextSibling();
+}
+
pub const JsApi = struct {
pub const bridge = js.Bridge(Node);
diff --git a/src/browser/webapi/TreeWalker.zig b/src/browser/webapi/TreeWalker.zig
index 26be40f8a..ddd6eadd8 100644
--- a/src/browser/webapi/TreeWalker.zig
+++ b/src/browser/webapi/TreeWalker.zig
@@ -23,12 +23,13 @@ const Element = @import("Element.zig");
const Frame = @import("../Frame.zig");
pub const Full = TreeWalker(.full, .dom);
-pub const FullExcludeSelf = TreeWalker(.exclude_self, .dom);
pub const Children = TreeWalker(.children, .dom);
+pub const FullExcludeSelf = TreeWalker(.exclude_self, .dom);
// Pierces the shadow roots, apply slots/fallback and skip unslotted light children
pub const Flat = TreeWalker(.full, .flat);
pub const FlatChildren = TreeWalker(.children, .flat);
+pub const FlatExcludeSelf = TreeWalker(.exclude_self, .flat);
const Mode = enum {
full,
@@ -151,28 +152,14 @@ pub fn TreeWalker(comptime mode: Mode, comptime tree: Tree) type {
fn firstChildOf(self: *const Self, node: *Node) ?*Node {
if (comptime tree == .flat) {
- if (node.is(Element)) |el| {
- if (el.hostedShadowRoot(self._frame)) |shadow| {
- return shadow.asNode().firstChild();
- }
- }
- if (node.is(Element.Html.Slot)) |slot| {
- // empty while the slot isn't in a shadow tree
- if (slot._assigned.items.len > 0) {
- return slot._assigned.items[0];
- }
- }
+ return node.flatFirstChild(self._frame);
}
return node.firstChild();
}
fn nextSiblingOf(self: *const Self, node: *Node) ?*Node {
if (comptime tree == .flat) {
- if (node.assignedSlot(self._frame)) |slot| {
- const assigned = slot._assigned.items;
- const i = std.mem.indexOfScalar(*Node, assigned, node) orelse return null;
- return if (i + 1 < assigned.len) assigned[i + 1] else null;
- }
+ return node.flatNextSibling(self._frame);
}
return node.nextSibling();
}
diff --git a/src/server/cdp/AXNode.zig b/src/server/cdp/AXNode.zig
index eca097343..c2b88357f 100644
--- a/src/server/cdp/AXNode.zig
+++ b/src/server/cdp/AXNode.zig
@@ -132,7 +132,7 @@ pub const Writer = struct {
if (dom_node.is(DOMNode.CData.Text) == null) {
continue;
}
- if (ignoreText(dom_node._parent.?)) {
+ if (ignoreText(dom_node.flatParent(self.frame).?)) {
continue;
}
},
@@ -653,7 +653,7 @@ pub const Writer = struct {
const n = axn.dom;
// Parent
- if (n._parent) |p| {
+ if (n.flatParent(self.frame)) |p| {
const parent_node = try self.registry.register(p);
try w.objectField("parentId");
try writeIdString(parent_node.id, w);
@@ -667,7 +667,7 @@ pub const Writer = struct {
try w.beginArray();
if (write_children) {
var registry = self.registry;
- var it = n.childrenIterator();
+ var it: TreeWalker.FlatChildren = .init(n, .{ .frame = self.frame });
while (it.next()) |child| {
// ignore non-elements or text.
if (child.is(DOMNode.Element.Html) == null and (child.is(DOMNode.CData.Text) == null or skip_text)) {
@@ -1148,7 +1148,7 @@ fn writeName(
if (use_name_for_content) {
var buf: std.Io.Writer.Allocating = .init(scratchAllocator(temp_arena, frame));
- try writeAccessibleNameFallback(node, &buf.writer);
+ try writeAccessibleNameFallback(node, &buf.writer, frame);
if (buf.written().len > 0) {
try writeString(buf.written(), w);
return .contents;
@@ -1175,10 +1175,10 @@ fn writeName(
};
}
-fn writeAccessibleNameFallback(node: *DOMNode, writer: *std.Io.Writer) !void {
- var tw = TreeWalker.FullExcludeSelf.init(node, .{});
+fn writeAccessibleNameFallback(node: *DOMNode, writer: *std.Io.Writer, frame: *const Frame) !void {
+ var tw: TreeWalker.FlatExcludeSelf = .init(node, .{ .frame = frame });
while (tw.next()) |child| {
- const parent = child._parent.?;
+ const parent = child.flatParent(frame).?;
const in_svg = if (parent.is(DOMNode.Element)) |p| p.getTag() == .svg else false;
if (in_svg and parent != node) {
// Inside an SVG, only a <title> names it
@@ -1222,9 +1222,9 @@ fn writeAccessibleNameFallback(node: *DOMNode, writer: *std.Io.Writer) !void {
/// Pre-order walk tracking the outermost aria-hidden or inert ancestor, since
/// TreeWalker leaves subtrees without saying so. CSS needs no tracking: the
-/// StyleManager resolves it through flat-tree ancestors. The walk itself stays
-/// in the light tree; only the root's ancestors are looked up through the flat
-/// tree.
+/// StyleManager resolves it through flat-tree ancestors. Walks the flat tree,
+/// like Chrome's AX tree: shadow content under its host, slotted nodes under
+/// their slot, unslotted light children skipped.
const Walker = struct {
root: *DOMNode,
current: *DOMNode,
@@ -1239,7 +1239,7 @@ const Walker = struct {
/// `descend` false skips the current node's children.
fn next(self: *Walker, descend: bool) ?*DOMNode {
if (descend) {
- if (self.current.firstChild()) |child| {
+ if (self.current.flatFirstChild(self.frame)) |child| {
if (self.hiding_ancestor == null and hidesSubtree(self.current)) {
self.hiding_ancestor = self.current;
}
@@ -1251,11 +1251,11 @@ const Walker = struct {
var node = self.current;
while (node != self.root) {
- if (node.nextSibling()) |sibling| {
+ if (node.flatNextSibling(self.frame)) |sibling| {
self.current = sibling;
return sibling;
}
- node = node._parent.?;
+ node = node.flatParent(self.frame).?;
self.depth -= 1;
if (node == self.hiding_ancestor) {
self.hiding_ancestor = null;
@@ -1480,7 +1480,7 @@ const IgnoreCache = struct {
fn isGenericIgnored(self: *IgnoreCache, root: *DOMNode, frame: *Frame) !bool {
if (self.map.get(root)) |ignored| return ignored;
- var tw = TreeWalker.FullExcludeSelf.init(root, .{});
+ var tw: TreeWalker.FlatExcludeSelf = .init(root, .{ .frame = frame });
const exposed = while (tw.next()) |node| {
const hidden = hiddenState(node, frame);
if (hidden == .pruned) {
@@ -1504,8 +1504,8 @@ const IgnoreCache = struct {
}
} else return true;
- var node = exposed._parent.?;
- while (node != root) : (node = node._parent.?) {
+ var node = exposed.flatParent(frame).?;
+ while (node != root) : (node = node.flatParent(frame).?) {
self.map.getPtr(node).?.* = false;
}
return false;
@@ -2467,3 +2467,49 @@ test "AXNode: custom ARIA states and tabindex focusability" {
try testing.expect(findNode(nodes, "checkbox", "Inert terms") == null);
try testing.expect(findNode(nodes, "checkbox", "Hidden terms") == null);
}
+
+test "AXNode: writer walks the flat tree" {
+ var registry = NodeRegistry.init(testing.allocator);
+ defer registry.deinit();
+
+ var page = try testing.pageTest("cdp/shadow_dom.html", .{});
+ defer page.close();
+
+ const frame = page.frame().?;
+ const doc = frame.window._document;
+
+ var label_index: Label.LabelByForIndex = .{};
+ const temp_arena = try frame.getArena(.medium, "AXNode");
+ defer temp_arena.release();
+ const json = try std.json.Stringify.valueAlloc(testing.arena_allocator, Writer{
+ .root = try registry.register(doc.asNode()),
+ .registry = &registry,
+ .frame = frame,
+ .label_index = &label_index,
+ .temp_arena = temp_arena,
+ }, .{});
+ const nodes = (try std.json.parseFromSliceLeaky(std.json.Value, testing.arena_allocator, json, .{})).array.items;
+
+ try testing.expect(findNode(nodes, "textbox", "Coupon code") != null);
+ try testing.expect(findNode(nodes, "button", "in-closed") != null);
+ try testing.expect(findNode(nodes, "StaticText", "slotted-text") != null);
+ try testing.expect(findNode(nodes, null, "unslotted-text") == null);
+
+ // Shadow content hangs off the host; the shadow root isn't an AX node.
+ const host = doc.getElementById("coupon").?;
+ var host_id_buf: [10]u8 = undefined;
+ const host_id = try std.fmt.bufPrint(&host_id_buf, "{d}", .{(try registry.register(host.asNode())).id});
+
+ const apply = findNode(nodes, "button", "Apply") orelse return error.ApplyNotFound;
+ try testing.expectEqual(host_id, apply.get("parentId").?.string);
+
+ const apply_id = apply.get("nodeId").?.string;
+ for (nodes) |n| {
+ if (std.mem.eql(u8, n.object.get("nodeId").?.string, host_id)) {
+ for (n.object.get("childIds").?.array.items) |cid| {
+ if (std.mem.eql(u8, cid.string, apply_id)) break;
+ } else return error.ApplyNotChildOfHost;
+ break;
+ }
+ } else return error.HostNotFound;
+}
diff --git a/src/server/cdp/CDP.zig b/src/server/cdp/CDP.zig
index f02abd2f5..1ae7eacc9 100644
--- a/src/server/cdp/CDP.zig
+++ b/src/server/cdp/CDP.zig
@@ -746,12 +746,15 @@ pub const BrowserContext = struct {
}
}
- pub fn nodeWriter(self: *BrowserContext, root: *const NodeRegistry.Node, opts: Node.Writer.Opts) Node.Writer {
+ pub fn nodeWriter(self: *BrowserContext, root: *const NodeRegistry.Node, opts: Node.Writer.Opts) !Node.Writer {
return .{
.root = root,
.depth = opts.depth,
.exclude_root = opts.exclude_root,
+ .pierce = opts.pierce,
.registry = &self.node_registry,
+ // shadow roots are tracked per Page, any of its frames will do
+ .frame = self.mainFrame() orelse return error.FrameNotLoaded,
};
}
diff --git a/src/server/cdp/Node.zig b/src/server/cdp/Node.zig
index ffeb49ec6..2c2f895a3 100644
--- a/src/server/cdp/Node.zig
+++ b/src/server/cdp/Node.zig
@@ -24,6 +24,7 @@ const lp = @import("lightpanda");
const id = @import("id.zig");
const DOMNode = @import("../../browser/webapi/Node.zig");
+const Frame = @import("../../browser/Frame.zig");
const IFrame = @import("../../browser/webapi/element/html/IFrame.zig");
const NodeRegistry = @import("../../NodeRegistry.zig");
@@ -129,12 +130,15 @@ pub const Search = struct {
pub const Writer = struct {
depth: i32,
exclude_root: bool,
+ pierce: bool = false,
root: *const NodeRegistry.Node,
registry: *NodeRegistry,
+ frame: *const Frame,
pub const Opts = struct {
depth: i32 = 0,
exclude_root: bool = false,
+ pierce: bool = false,
};
pub fn jsonStringify(self: *const Writer, w: anytype) error{WriteFailed}!void {
@@ -157,6 +161,7 @@ pub const Writer = struct {
fn toJSON(self: *const Writer, node: *const NodeRegistry.Node, depth: usize, w: anytype) !void {
try w.beginObject();
try self.writeCommon(node, false, w);
+ try self.writeShadowRoots(node, self.pierce, depth, w);
try w.objectField("children");
const child_count = try self.writeChildren(node, depth, w);
@@ -166,12 +171,33 @@ pub const Writer = struct {
try w.endObject();
}
+ fn writeShadowRoots(self: *const Writer, node: *const NodeRegistry.Node, pierce: bool, depth: usize, w: anytype) anyerror!void {
+ const el = node.dom.is(DOMNode.Element) orelse return;
+ const shadow = el.hostedShadowRoot(self.frame) orelse return;
+ const shadow_node = try self.registry.register(shadow.asNode());
+
+ try w.objectField("shadowRoots");
+ try w.beginArray();
+ if (pierce and self.isFull(depth)) {
+ try self.toJSON(shadow_node, depth + 1, w);
+ } else {
+ try w.beginObject();
+ try self.writeCommon(shadow_node, true, w);
+ try w.endObject();
+ }
+ try w.endArray();
+ }
+
+ fn isFull(self: *const Writer, depth: usize) bool {
+ return self.depth < 0 or self.depth < depth;
+ }
+
fn writeChildren(self: *const Writer, node: *const NodeRegistry.Node, depth: usize, w: anytype) anyerror!usize {
var count: usize = 0;
var it = node.dom.childrenIterator();
var registry = self.registry;
- const full_child = self.depth < 0 or self.depth < depth;
+ const full_child = self.isFull(depth);
try w.beginArray();
while (it.next()) |dom_child| {
@@ -181,6 +207,7 @@ pub const Writer = struct {
} else {
try w.beginObject();
try self.writeCommon(child_node, true, w);
+ try self.writeShadowRoots(child_node, false, depth + 1, w);
try w.endObject();
}
count += 1;
@@ -257,6 +284,11 @@ pub const Writer = struct {
try w.write("");
}
+ if (dom_node.is(DOMNode.ShadowRoot)) |shadow| {
+ try w.objectField("shadowRootType");
+ try w.write(@tagName(shadow._mode));
+ }
+
if (include_child_count) {
try w.objectField("childNodeCount");
try w.write(dom_node.getChildrenCount());
@@ -363,6 +395,7 @@ test "cdp Node: Writer" {
.depth = 0,
.exclude_root = false,
.registry = &registry,
+ .frame = frame,
}, .{});
defer testing.allocator.free(json);
@@ -403,6 +436,7 @@ test "cdp Node: Writer" {
.depth = 1,
.exclude_root = false,
.registry = &registry,
+ .frame = frame,
}, .{});
defer testing.allocator.free(json);
@@ -458,6 +492,7 @@ test "cdp Node: Writer" {
.depth = -1,
.exclude_root = true,
.registry = &registry,
+ .frame = frame,
}, .{});
defer testing.allocator.free(json);
@@ -518,3 +553,76 @@ test "cdp Node: Writer" {
} }, json);
}
}
+
+test "cdp Node: Writer shadowRoots" {
+ var registry = NodeRegistry.init(testing.allocator);
+ defer registry.deinit();
+
+ var page = try testing.pageTest("cdp/shadow_dom.html", .{});
+ defer page.close();
+
+ const frame = page.frame().?;
+ const host = try registry.register(frame.window._document.getElementById("coupon").?.asNode());
+
+ {
+ const json = try std.json.Stringify.valueAlloc(testing.allocator, Writer{
+ .root = host,
+ .depth = -1,
+ .exclude_root = false,
+ .pierce = true,
+ .registry = &registry,
+ .frame = frame,
+ }, .{});
+ defer testing.allocator.free(json);
+
+ try testing.expectJson(.{
+ .localName = "x-coupon",
+ .childNodeCount = 2,
+ .shadowRoots = &.{.{
+ .nodeType = 11,
+ .nodeName = "#document-fragment",
+ .shadowRootType = "open",
+ .childNodeCount = 3,
+ .children = &.{
+ .{ .localName = "label", .childNodeCount = 2 },
+ .{ .localName = "button", .attributes = &.{ "id", "apply" } },
+ .{ .localName = "slot" },
+ },
+ }},
+ }, json);
+ }
+
+ {
+ // without pierce, the root is listed but not walked
+ const json = try std.json.Stringify.valueAlloc(testing.allocator, Writer{
+ .root = host,
+ .depth = -1,
+ .exclude_root = false,
+ .registry = &registry,
+ .frame = frame,
+ }, .{});
+ defer testing.allocator.free(json);
+
+ try testing.expectJson(.{ .shadowRoots = &.{.{ .shadowRootType = "open", .childNodeCount = 3 }} }, json);
+ try testing.expect(std.mem.find(u8, json, "\"apply\"") == null);
+ }
+
+ {
+ // closed roots too
+ const closed = try registry.register(frame.window._document.getElementById("closed-host").?.asNode());
+ const json = try std.json.Stringify.valueAlloc(testing.allocator, Writer{
+ .root = closed,
+ .depth = -1,
+ .exclude_root = false,
+ .pierce = true,
+ .registry = &registry,
+ .frame = frame,
+ }, .{});
+ defer testing.allocator.free(json);
+
+ try testing.expectJson(.{ .shadowRoots = &.{.{
+ .shadowRootType = "closed",
+ .children = &.{.{ .localName = "button", .attributes = &.{ "id", "in-closed" } }},
+ }} }, json);
+ }
+}
diff --git a/src/server/cdp/domains/dom.zig b/src/server/cdp/domains/dom.zig
index 8680dd298..a519e7e84 100644
--- a/src/server/cdp/domains/dom.zig
+++ b/src/server/cdp/domains/dom.zig
@@ -91,15 +91,11 @@ fn getDocument(cmd: *CDP.Command) !void {
};
const params = try cmd.params(Params) orelse Params{};
- if (params.pierce) {
- log.debug(.not_implemented, "DOM.getDocument", .{ .param = "pierce" });
- }
-
const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
const frame = bc.mainFrame() orelse return error.FrameNotLoaded;
const node = try bc.node_registry.register(frame.window._document.asNode());
- return cmd.sendResult(.{ .root = bc.nodeWriter(node, .{ .depth = params.depth }) }, .{});
+ return cmd.sendResult(.{ .root = try bc.nodeWriter(node, .{ .depth = params.depth, .pierce = params.pierce }) }, .{});
}
// Closed set of XPath 1.0 named axes. Matched literally before `::` so
@@ -235,7 +231,7 @@ fn dispatchSetChildNodes(cmd: *CDP.Command, dom_nodes: []const *DOMNode) !void {
try cmd.sendEvent("DOM.setChildNodes", .{
.parentId = parent_node.id,
- .nodes = .{bc.nodeWriter(node, .{})},
+ .nodes = .{try bc.nodeWriter(node, .{})},
}, .{
.session_id = session_id,
});
@@ -431,14 +427,11 @@ fn describeNode(cmd: *CDP.Command) !void {
pierce: bool = false,
})) orelse return error.InvalidParams;
- if (params.pierce) {
- log.debug(.not_implemented, "DOM.describeNode", .{ .param = "pierce" });
- }
const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
const node = try getNode(cmd.arena, bc, cmd.input.session_id, params.nodeId, params.backendNodeId, params.objectId);
- return cmd.sendResult(.{ .node = bc.nodeWriter(node, .{ .depth = params.depth }) }, .{});
+ return cmd.sendResult(.{ .node = try bc.nodeWriter(node, .{ .depth = params.depth, .pierce = params.pierce }) }, .{});
}
// An array of quad vertices, x immediately followed by y for each point, points clock-wise.
@@ -606,7 +599,7 @@ fn requestChildNodes(cmd: *CDP.Command) !void {
try cmd.sendEvent("DOM.setChildNodes", .{
.parentId = node.id,
- .nodes = bc.nodeWriter(node, .{ .depth = params.depth, .exclude_root = true }),
+ .nodes = try bc.nodeWriter(node, .{ .depth = params.depth, .exclude_root = true, .pierce = params.pierce }),
}, .{
.session_id = session_id,
});