Skip to content

Lightpanda: the headless browser designed for AI and automation

Trim comments

Adrià Arrufat9dfeef2aef48
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index d8f8f8d5e..f953a3147 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -155,8 +155,7 @@ _focus_fixup_pending: bool = false,
_style_manager: StyleManager,
-// Element.documentExtent, valid while the style version and viewport it was
-// computed for hold.
+// Element.documentExtent cache, keyed on style version and viewport.
_document_extent: ?struct {
version: usize,
viewport_width: u32,
diff --git a/src/browser/tests/element/position.html b/src/browser/tests/element/position.html
index 8b696c269..03011d772 100644
--- a/src/browser/tests/element/position.html
+++ b/src/browser/tests/element/position.html
@@ -337,13 +337,10 @@
testing.expectEqual(0, panel.clientHeight);
testing.expectTrue(panel.scrollHeight > 0);
- // 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.
+ // The root element's clientHeight is the viewport (CSSOM View); jstracker
+ // tiles it with elementFromPoint calls.
testing.expectEqual(document.body.clientHeight, document.body.scrollHeight);
testing.expectEqual(window.innerHeight, document.documentElement.clientHeight);
- // What the viewport scrolls over: the document, or the viewport itself
testing.expectEqual(
Math.max(document.documentElement.offsetHeight, document.documentElement.clientHeight),
document.documentElement.scrollHeight,
@@ -578,7 +575,7 @@
deep.id = 'deep';
document.body.appendChild(deep);
- // Room below it, or the viewport couldn't bring its top up
+ // Room to scroll it to the top
const room = document.createElement('div');
room.style.height = '10000px';
document.body.appendChild(room);
diff --git a/src/browser/tests/mcp_actions.html b/src/browser/tests/mcp_actions.html
index c407bffa6..50941d429 100644
--- a/src/browser/tests/mcp_actions.html
+++ b/src/browser/tests/mcp_actions.html
@@ -70,7 +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 -->
+ <!-- Room to scroll the window -->
<div style="height: 10000px; width: 10000px"></div>
</body>
</html>
diff --git a/src/browser/tests/window_scroll.html b/src/browser/tests/window_scroll.html
index 89c1fa498..a79508684 100644
--- a/src/browser/tests/window_scroll.html
+++ b/src/browser/tests/window_scroll.html
@@ -1,7 +1,7 @@
<!DOCTYPE html>
<script src="testing.js"></script>
-<!-- Room to scroll: the document can't scroll past its bottom -->
+<!-- Room to scroll -->
<div style="height: 10000px; width: 10000px"></div>
<script id=scrollBy_exists>
@@ -56,13 +56,12 @@
window.scrollBy(0, 100);
testing.expectEqual(max, window.scrollY);
- // x clamps the same way, against the widest content
const maxX = document.documentElement.scrollWidth - window.innerWidth;
testing.expectTrue(maxX > 0);
window.scrollTo(99999999, 0);
testing.expectEqual(maxX, window.scrollX);
- // Content added at the bottom extends the limit
+ // Added content extends the limit
const more = document.createElement('div');
more.style.height = '5000px';
document.body.appendChild(more);
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index 91b43fefd..5a62980b4 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -1686,8 +1686,7 @@ pub fn getScrollHeight(self: *Element, frame: *Frame) f64 {
const height = self.getElementAxis(frame, .height).value;
const tag = self.getTag();
- // The root containers already span the document. The one scrolling the
- // viewport reports what the viewport scrolls over.
+ // The root scroller reports what the viewport scrolls over.
if (tag == .html or tag == .body) {
return self.rootScrollSize(frame, .height) orelse height;
}
@@ -1703,10 +1702,8 @@ pub fn getScrollWidth(self: *Element, frame: *Frame) f64 {
const width = self.getElementAxis(frame, .width).value;
const tag = self.getTag();
- // The root containers keep their box: their children don't lie side by
- // side on one row, and stacking them would inflate a value sites read to
- // detect page overflow. The one scrolling the viewport reports what the
- // viewport scrolls over.
+ // Roots don't sum their children side by side. The root scroller
+ // reports what the viewport scrolls over.
if (tag == .html or tag == .body) {
return self.rootScrollSize(frame, .width) orelse width;
}
@@ -1716,9 +1713,7 @@ 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. 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.
+/// the same sum. html and body scroll the viewport, clamped by Window.
fn scrollExtent(self: *Element, frame: *Frame, comptime axis: Axis) ?f64 {
if (self.scrollsViewport() or !self.getElementAxis(frame, axis).explicit) {
return null;
@@ -1789,8 +1784,7 @@ fn contentAxis(self: *Element, frame: *Frame, comptime axis: Axis) f64 {
return total;
}
-// Unlike clientHeight, the root's offsetHeight is its box: the document
-// height.
+// Unlike clientHeight, the root's offsetHeight is the document height.
pub fn getOffsetHeight(self: *Element, frame: *Frame) f64 {
if (!self.isVisible(frame)) {
return 0.0;
@@ -1923,11 +1917,9 @@ fn calculateDocumentPosition(node: *Node) f64 {
pub const DocumentExtent = struct { width: f64, height: f64 };
-/// The document's extent. Its height, which html and body span, fits every
-/// synthetic position (calculateDocumentPosition's 5px per node) and body's
-/// children stacked on top of each other. Its width is body's widest child:
-/// block children don't lie side by side on one row. An inline size on body
-/// stretches both.
+/// The document's size. Height: enough for every synthetic position (5px per
+/// node) and body's stacked children. Width: body's widest child. An inline
+/// size on body stretches both.
pub fn documentExtent(frame: *Frame) DocumentExtent {
const version = frame.page.style_version;
const viewport = frame.page.getViewport();
@@ -1952,7 +1944,7 @@ pub fn documentExtent(frame: *Frame) DocumentExtent {
}
}
- // Whole pixels, like the scroll offsets clamped against it
+ // Whole pixels, like scroll offsets
extent = .{ .width = @ceil(extent.width), .height = @ceil(extent.height) };
frame._document_extent = .{
.version = version,
@@ -1963,8 +1955,7 @@ pub fn documentExtent(frame: *Frame) DocumentExtent {
return extent;
}
-/// What the viewport scrolls over: the document, but never less than the
-/// viewport itself, like the root scroller's scrollWidth and scrollHeight.
+/// What the viewport scrolls over: the document, at least viewport-sized.
pub fn documentScrollSize(frame: *Frame) DocumentExtent {
const extent = documentExtent(frame);
const viewport = frame.page.getViewport();
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index bede248ac..a44afbd9f 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -951,7 +951,6 @@ 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);
- // The viewport can't scroll past the document's edges
const size = Element.documentScrollSize(self._frame);
const max_x = scrollLimit(size.width, self.getInnerWidth(self._frame));
const max_y = scrollLimit(size.height, self.getInnerHeight(self._frame));