Skip to content

Lightpanda: the headless browser designed for AI and automation

Share the flat-tree parent element

Adrià Arrufat99ec332e0dc5
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 201b009b2..083417c13 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -2242,10 +2242,13 @@ pub fn openPopup(self: *Frame, opts: OpenPopupOpts) !*Frame {
pub fn domChanged(self: *Frame) void {
self.page.dom_version += 1;
- self.styleChanged();
+ self.renderingChanged();
+}
- // A DOM change is our "rendering opportunity": re-evaluate the layout
- // observers. Both are no-ops unless something they track actually changed.
+/// A style change that is also our "rendering opportunity": re-evaluate the
+/// layout observers. Both are no-ops unless something they track changed.
+pub fn renderingChanged(self: *Frame) void {
+ self.styleChanged();
observers.scheduleIntersectionChecks(self);
observers.scheduleResizeChecks(self);
}
diff --git a/src/browser/StyleManager.zig b/src/browser/StyleManager.zig
index 2fb4dbaba..fcf6e3eab 100644
--- a/src/browser/StyleManager.zig
+++ b/src/browser/StyleManager.zig
@@ -702,18 +702,6 @@ fn visibilityProps(self: *StyleManager, el: *Element) Visibility.Computed {
return self.visibility.inheritedProps(self.arena.allocator(), el, self.frame);
}
-/// The element `el` inherits from: its flat-tree parent, so shadow content
-/// inherits from the host and a slotted node from its slot.
-fn inheritanceParent(el: *Element, frame: *const Frame) ?*Element {
- var node = el.asNode().flatTreeParent(frame);
- while (node) |n| : (node = n.flatTreeParent(frame)) {
- if (n.is(Element)) |parent| {
- return parent;
- }
- }
- return null;
-}
-
/// Callers must have run rebuildIfDirty, which resets the memo.
fn geometryProps(self: *StyleManager, el: *Element) Geometry.Computed {
return self.geometry.ownProps(self.arena.allocator(), el, self.frame);
@@ -855,7 +843,7 @@ fn Group(comptime Spec: type) type {
self.path.clearRetainingCapacity();
var above: Computed = .{};
var current: ?*Element = el;
- while (current) |elem| : (current = inheritanceParent(elem, frame)) {
+ while (current) |elem| : (current = elem.asNode().flatTreeParentElement(frame)) {
if (memo.get(elem)) |cached| {
above = cached;
break;
@@ -1665,7 +1653,7 @@ pub fn customPropertyValue(self: *StyleManager, el: *Element, property_name: Str
};
var current: ?*Element = el;
- while (current) |elem| : (current = inheritanceParent(elem, self.frame)) {
+ while (current) |elem| : (current = elem.asNode().flatTreeParentElement(self.frame)) {
if (self.inlineStyleValue(elem, property_name)) |value| {
return value;
}
@@ -1744,7 +1732,7 @@ fn computedFontSizeAt(self: *StyleManager, element: ?*Element, depth: u8) f64 {
return DEFAULT_FONT_SIZE;
}
const current = element orelse return DEFAULT_FONT_SIZE;
- const parent = inheritanceParent(current, self.frame);
+ const parent = current.asNode().flatTreeParentElement(self.frame);
if (self.inlineStyleValue(current, comptime .wrap("font-size"))) |raw| {
if (self.parseFontSize(raw, parent, depth + 1)) |size| {
diff --git a/src/browser/frame/observers.zig b/src/browser/frame/observers.zig
index 132e6b6d4..e8fd0526c 100644
--- a/src/browser/frame/observers.zig
+++ b/src/browser/frame/observers.zig
@@ -257,7 +257,7 @@ fn resizeAttributeChanged(frame: *Frame, element: *Element, name: String) void {
}
for (frame._resize.observers.items) |observer| {
- if (observer.observesWithin(element)) {
+ if (observer.observesWithin(element, frame)) {
scheduleResizeDelivery(frame);
return;
}
diff --git a/src/browser/tests/resize_observer/resize.html b/src/browser/tests/resize_observer/resize.html
index ed437249e..c6fc5fa6f 100644
--- a/src/browser/tests/resize_observer/resize.html
+++ b/src/browser/tests/resize_observer/resize.html
@@ -53,3 +53,30 @@
testing.expectEqual(0, widths[1]);
});
</script>
+
+<script id="host_style_change_delivers" type=module>
+ // Hiding a shadow host collapses an observed element inside its shadow tree.
+ const state = await testing.async();
+ const host = document.createElement('div');
+ document.body.appendChild(host);
+ const t = document.createElement('div');
+ t.style.width = '60px';
+ host.attachShadow({ mode: 'open' }).appendChild(t);
+
+ const widths = [];
+ const observer = new ResizeObserver((entries) => {
+ widths.push(entries[0].contentRect.width);
+ if (widths.length === 1) {
+ host.style.display = 'none';
+ } else if (widths.length === 2) {
+ observer.disconnect();
+ state.resolve();
+ }
+ });
+ observer.observe(t);
+
+ await state.done(() => {
+ testing.expectEqual(60, widths[0]);
+ testing.expectEqual(0, widths[1]);
+ });
+</script>
diff --git a/src/browser/webapi/Node.zig b/src/browser/webapi/Node.zig
index 1930217da..0becbee80 100644
--- a/src/browser/webapi/Node.zig
+++ b/src/browser/webapi/Node.zig
@@ -1746,6 +1746,17 @@ pub fn flatTreeParent(self: *Node, frame: *const Frame) ?*Node {
return self._parent;
}
+/// The flat-tree parent element: shadow content inherits from its host, a
+/// slotted node from its slot.
+pub fn flatTreeParentElement(self: *Node, frame: *const Frame) ?*Element {
+ const parent = self.flatTreeParent(frame) orelse return null;
+ if (parent.is(Element)) |el| {
+ return el;
+ }
+ // A shadow root's flat-tree parent is its host
+ return (parent.flatTreeParent(frame) orelse return null).is(Element);
+}
+
pub const JsApi = struct {
pub const bridge = js.Bridge(Node);
diff --git a/src/browser/webapi/ResizeObserver.zig b/src/browser/webapi/ResizeObserver.zig
index b839ce157..34a6ff912 100644
--- a/src/browser/webapi/ResizeObserver.zig
+++ b/src/browser/webapi/ResizeObserver.zig
@@ -135,13 +135,12 @@ pub fn connectivityChanged(self: *const ResizeObserver) bool {
return false;
}
-// True if any observed element is `ancestor` or one of its descendants. Walks
-// the same parentElement chain StyleManager.isHidden resolves visibility
-// through.
-pub fn observesWithin(self: *const ResizeObserver, ancestor: *Element) bool {
+/// True if any observed element is `ancestor` or one of its descendants. Walks
+/// the same flat-tree chain StyleManager.isHidden resolves visibility through.
+pub fn observesWithin(self: *const ResizeObserver, ancestor: *Element, frame: *const Frame) bool {
for (self._observations.items) |obs| {
var current: ?*Element = obs.target;
- while (current) |el| : (current = el.parentElement()) {
+ while (current) |el| : (current = el.asNode().flatTreeParentElement(frame)) {
if (el == ancestor) {
return true;
}
diff --git a/src/browser/webapi/element/slotting.zig b/src/browser/webapi/element/slotting.zig
index 44ec1dc06..5e28abfb5 100644
--- a/src/browser/webapi/element/slotting.zig
+++ b/src/browser/webapi/element/slotting.zig
@@ -130,7 +130,7 @@ fn _assignSlottables(slot: *Slot, frame: *Frame) !void {
frame.signalSlotChange(slot);
// A slotted node inherits from its slot
- frame.styleChanged();
+ frame.renderingChanged();
const page = frame.page;
for (old) |node| {
diff --git a/src/server/cdp/AXNode.zig b/src/server/cdp/AXNode.zig
index d1049f08b..7c32887e0 100644
--- a/src/server/cdp/AXNode.zig
+++ b/src/server/cdp/AXNode.zig
@@ -1110,8 +1110,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 the ancestors. The walk stays in the light
-/// tree; only the root's ancestors are looked up through the flat tree.
+/// 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.
const Walker = struct {
root: *DOMNode,
current: *DOMNode,
@@ -1278,9 +1279,9 @@ fn scratchAllocator(temp_arena: ?*lp.Arena, frame: *Frame) std.mem.Allocator {
/// `visibility: visible`. `pruned` ignores the whole subtree.
const Hidden = enum { visible, invisible, pruned };
-/// Text takes its parent's state.
+/// Text takes its flat-tree parent's state.
fn hiddenState(node: *DOMNode, frame: *Frame) Hidden {
- const elt = node.is(DOMNode.Element) orelse node.parentElement() orelse return .visible;
+ const elt = node.is(DOMNode.Element) orelse node.flatTreeParentElement(frame) orelse return .visible;
if (hidesSubtree(elt.asNode())) {
return .pruned;
}