Skip to content

Lightpanda: the headless browser designed for AI and automation

Give the document a height and clamp the viewport scroll to it

Adrià Arrufatf5d9f3e7378a
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 7298a2150..8c1d7bcad 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -154,6 +154,10 @@ _queued_events: *std.ArrayList(QueuedEvent) = undefined,
_focus_fixup_pending: bool = false,
_style_manager: StyleManager,
+
+// Element.documentHeight, valid while the style version and viewport height
+// it was computed for hold.
+_document_height: ?struct { version: usize, viewport: u32, value: f64 } = null,
_script_manager: ScriptManager,
_http_owner: HttpClient.Owner,
diff --git a/src/browser/tests/element/position.html b/src/browser/tests/element/position.html
index 17568d68c..eeeace6bc 100644
--- a/src/browser/tests/element/position.html
+++ b/src/browser/tests/element/position.html
@@ -337,17 +337,17 @@
testing.expectEqual(0, panel.clientHeight);
testing.expectTrue(panel.scrollHeight > 0);
- // The root containers keep their synthetic size rather than summing
- // children. The root element's clientHeight is the viewport (CSSOM View):
- // jstracker tiles clientWidth/10 cells over clientHeight and calls
- // elementFromPoint per cell, which the 100M px box turned into ~5M walks.
+ // The root containers span the document rather than summing children.
+ // The root element's clientHeight is the viewport (CSSOM View): jstracker
+ // tiles clientWidth/10 cells over clientHeight and calls elementFromPoint
+ // per cell, which a document-sized box turned into ~5M walks.
testing.expectEqual(document.body.clientHeight, document.body.scrollHeight);
testing.expectEqual(window.innerHeight, document.documentElement.clientHeight);
testing.expectEqual(
document.documentElement.offsetHeight,
document.documentElement.scrollHeight,
);
- testing.expectTrue(document.documentElement.scrollHeight > document.documentElement.clientHeight);
+ testing.expectTrue(document.documentElement.scrollHeight >= document.documentElement.clientHeight);
}
</script>
@@ -578,6 +578,11 @@
deep.id = 'deep';
document.body.appendChild(deep);
+ // Room below it, or the viewport couldn't bring its top up
+ const room = document.createElement('div');
+ room.style.height = '10000px';
+ document.body.appendChild(room);
+
const targetY = deep.getBoundingClientRect().y;
testing.expectTrue(targetY > 0);
diff --git a/src/browser/tests/mcp_actions.html b/src/browser/tests/mcp_actions.html
index c6e409ce5..75bda144f 100644
--- a/src/browser/tests/mcp_actions.html
+++ b/src/browser/tests/mcp_actions.html
@@ -70,5 +70,7 @@
document.getElementById('rad').addEventListener('click', function() { window.radClicked = true; });
document.getElementById('rad').addEventListener('change', function() { window.radChanged = true; });
</script>
+ <!-- Room to scroll the window: the document can't scroll past its bottom -->
+ <div style="height: 10000px"></div>
</body>
</html>
diff --git a/src/browser/tests/window_scroll.html b/src/browser/tests/window_scroll.html
index 6d16dc0c3..dda8a1d51 100644
--- a/src/browser/tests/window_scroll.html
+++ b/src/browser/tests/window_scroll.html
@@ -1,6 +1,9 @@
<!DOCTYPE html>
<script src="testing.js"></script>
+<!-- Room to scroll: the document can't scroll past its bottom -->
+<div style="height: 10000px"></div>
+
<script id=scrollBy_exists>
testing.expectEqual('function', typeof window.scrollBy);
</script>
@@ -45,6 +48,28 @@
testing.expectEqual(0, window.scrollY);
</script>
+<script id=scrollTo_clamps_to_document>
+ const max = document.documentElement.scrollHeight - window.innerHeight;
+ testing.expectTrue(max > 0);
+ window.scrollTo(0, 99999999);
+ testing.expectEqual(max, window.scrollY);
+ window.scrollBy(0, 100);
+ testing.expectEqual(max, window.scrollY);
+
+ // The document has no honest width, so x isn't bounded
+ window.scrollTo(99999, 0);
+ testing.expectEqual(99999, window.scrollX);
+
+ // Content added at the bottom extends the limit
+ const more = document.createElement('div');
+ more.style.height = '5000px';
+ document.body.appendChild(more);
+ window.scrollTo(0, 99999999);
+ testing.expectEqual(max + 5000, window.scrollY);
+ more.remove();
+ window.scrollTo(0, 0);
+</script>
+
<script id=element_scroll_events_coalesce_and_preserve_reentrancy type=module>
const state = await testing.async();
const element = document.createElement('div');
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index 373e142e1..25e37a6d4 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -1500,12 +1500,12 @@ pub fn getElementAxis(self: *Element, frame: *Frame, comptime axis: Axis) Axis.S
}
}
- // Root containers get large default size to contain descendant positions.
- // With calculateDocumentPosition using linear depth scaling (100px per level),
- // even very deep trees (100 levels) stay within 10,000px.
- // 100M pixels is plausible for very long documents.
+ // Root containers span the document, see documentHeight.
if (root) {
- return .{ .value = if (axis == .width) 1920.0 else 100_000_000.0 };
+ return .{ .value = switch (axis) {
+ .width => 1920.0,
+ .height => if (self.ownerFrame(frame)) |owner| documentHeight(owner) else 0.0,
+ } };
}
// Presentational attributes lose to CSS sizes.
@@ -1679,8 +1679,7 @@ pub fn getScrollHeight(self: *Element, frame: *Frame) f64 {
const height = self.getElementAxis(frame, .height).value;
const tag = self.getTag();
- // As in getScrollWidth: the root containers carry artificial giant
- // defaults, and page-level overflow checks read them.
+ // The root containers already span the document.
if (tag == .html or tag == .body) {
return height;
}
@@ -1696,9 +1695,9 @@ pub fn getScrollWidth(self: *Element, frame: *Frame) f64 {
const width = self.getElementAxis(frame, .width).value;
const tag = self.getTag();
- // The root containers carry artificial giant defaults (1920 and
- // 100_000_000, see getElementAxis). Stacking their children on
- // top would inflate a value sites read to detect page overflow.
+ // The root containers span the document (see getElementAxis), and
+ // their children don't lie side by side on one row: stacking them
+ // would inflate a value sites read to detect page overflow.
if (tag == .html or tag == .body) {
return width;
}
@@ -1708,9 +1707,9 @@ pub fn getScrollWidth(self: *Element, frame: *Frame) f64 {
/// Null where we can't prove a limit, which leaves the offset unbounded:
/// without an explicit size the client and content measurements collapse onto
-/// the same sum, and html and body carry giant defaults that would fabricate
-/// an extent against the real viewport. Refusing a scroll we can't prove
-/// impossible is worse than allowing one too many.
+/// the same sum. html and body scroll the viewport, which Window.scrollTo
+/// clamps. Refusing a scroll we can't prove impossible is worse than allowing
+/// one too many.
fn scrollExtent(self: *Element, frame: *Frame, comptime axis: Axis) ?f64 {
if (self.scrollsViewport() or !self.getElementAxis(frame, axis).explicit) {
return null;
@@ -1781,8 +1780,8 @@ fn contentAxis(self: *Element, frame: *Frame, comptime axis: Axis) f64 {
return total;
}
-// Unlike clientHeight, the root's offsetHeight is its box (the document
-// extent), so it stays on the synthetic root default.
+// Unlike clientHeight, the root's offsetHeight is its box: the document
+// height.
pub fn getOffsetHeight(self: *Element, frame: *Frame) f64 {
if (!self.isVisible(frame)) {
return 0.0;
@@ -1913,6 +1912,37 @@ fn calculateDocumentPosition(node: *Node) f64 {
return position * 5.0; // 5px per node
}
+/// The document's height, which html and body span and the viewport scrolls
+/// over. Tall enough for every synthetic position (calculateDocumentPosition's
+/// 5px per node), for body's children stacked on top of each other, and never
+/// shorter than the viewport, like the root's scrollHeight.
+pub fn documentHeight(frame: *Frame) f64 {
+ const version = frame.page.style_version;
+ const viewport = frame.page.getViewport().height;
+ if (frame._document_height) |cached| {
+ if (cached.version == version and cached.viewport == viewport) {
+ return cached.value;
+ }
+ }
+
+ const doc = frame.document;
+ var height = @max(@as(f64, @floatFromInt(viewport)), countSubtreeNodes(doc.asNode()) * 5.0);
+ if (doc.getDocumentElement()) |root| {
+ var child = root.asNode().firstChild();
+ while (child) |node| : (child = node.nextSibling()) {
+ if (node.is(Html.Body)) |body| {
+ height = @max(height, body.asElement().contentAxis(frame, .height));
+ break;
+ }
+ }
+ }
+
+ // Whole pixels, like the scroll offsets clamped against it
+ height = @ceil(height);
+ frame._document_height = .{ .version = version, .viewport = viewport, .value = height };
+ return height;
+}
+
// Counts total nodes in a subtree (node + all descendants)
fn countSubtreeNodes(node: *Node) f64 {
var count: f64 = 1.0; // Count this node
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index 44f99b2e5..bffa6c04e 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -952,7 +952,12 @@ fn getDevicePixelRatio(_: *const Window, frame: *Frame) f32 {
pub fn scrollTo(self: *Window, opts: Element.ScrollToOpts, y: ?i32, frame: *Frame) !void {
const o = opts.offsets(y);
const new_x: u32 = if (o.left) |left| @intCast(@max(0, left)) else self._scroll_pos.x;
- const new_y: u32 = if (o.top) |top| @intCast(@max(0, top)) else self._scroll_pos.y;
+ var new_y: u32 = if (o.top) |top| @intCast(@max(0, top)) else self._scroll_pos.y;
+
+ // The document can't scroll past its bottom. It has no honest width
+ // (children don't lie side by side), so x stays unbounded.
+ const max_y = Element.documentHeight(self._frame) - @as(f64, @floatFromInt(self.getInnerHeight(self._frame)));
+ new_y = @min(new_y, @as(u32, @intFromFloat(@max(0, @min(max_y, std.math.maxInt(u32))))));
if (new_x == self._scroll_pos.x and new_y == self._scroll_pos.y) {
return;