Skip to content

Lightpanda: the headless browser designed for AI and automation

Resolve scroll-blocking cancelability on the dispatch path

Adrià Arrufat057738ef2a35
diff --git a/src/browser/EventManager.zig b/src/browser/EventManager.zig
index a09c98b00..c0c62febc 100644
--- a/src/browser/EventManager.zig
+++ b/src/browser/EventManager.zig
@@ -149,21 +149,6 @@ pub fn hasDirectListeners(self: *EventManager, target: *EventTarget, typ: []cons
return self.base.hasDirectListeners(target, typ, handler);
}
-/// Whether any listener for `typ` on the path from `node` up to the window
-/// is non-passive. The UA dispatches scroll-blocking events as
-/// non-cancelable when none is: it already knows preventDefault can't be
-/// called.
-pub fn hasNonPassiveListener(self: *EventManager, node: *Node, comptime typ: []const u8) bool {
- const event_type: lp.String = comptime .wrap(typ);
- var current: ?*Node = node;
- while (current) |n| : (current = n.parentNode()) {
- if (self.base.hasNonPassiveListener(n.asEventTarget(), event_type)) {
- return true;
- }
- }
- return self.base.hasNonPassiveListener(self.frame.window.asEventTarget(), event_type);
-}
-
fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
const target_et = target.asEventTarget();
event._target = target_et;
@@ -312,6 +297,10 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
const path = path_buffer[0..path_len];
+ if (event._cancelable_unless_passive) {
+ event._cancelable = self.anyNonPassive(path, event);
+ }
+
// Phase 1: Capturing phase (root → target, excluding target)
// This happens for all events, regardless of bubbling
event._event_phase = .capturing_phase;
@@ -434,6 +423,22 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
}
}
+/// Whether a listener on the path could call preventDefault. An inline
+/// handler always can; addEventListener listeners can unless passive.
+fn anyNonPassive(self: *EventManager, path: []const *EventTarget, event: *Event) bool {
+ for (path) |target| {
+ if (self.getInlineHandler(target, event) != null) {
+ return true;
+ }
+ if (self.base.getListeners(target, event._type_string)) |list| {
+ if (EventManagerBase.hasNonPassiveListener(list)) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
fn processHandlerReturnValue(event: *Event, handler_return: ?js.Value) void {
const ret = handler_return orelse return;
if (ret.isFalse() and !event._type_string.eql(comptime .wrap("error"))) {
diff --git a/src/browser/EventManagerBase.zig b/src/browser/EventManagerBase.zig
index c6ad1a124..f3e901559 100644
--- a/src/browser/EventManagerBase.zig
+++ b/src/browser/EventManagerBase.zig
@@ -205,11 +205,9 @@ pub fn getListeners(self: *EventManagerBase, target: *EventTarget, event_type: S
});
}
-/// Whether the target has a listener for `event_type` that can call
-/// preventDefault. A removed listener isn't "in" the list anymore, same as
-/// findListener.
-pub fn hasNonPassiveListener(self: *EventManagerBase, target: *EventTarget, event_type: String) bool {
- const list = self.getListeners(target, event_type) orelse return false;
+/// Whether a listener in the list can call preventDefault. A removed
+/// listener isn't "in" the list anymore, same as findListener.
+pub fn hasNonPassiveListener(list: *const std.DoublyLinkedList) bool {
var node = list.first;
while (node) |n| : (node = n.next) {
const listener: *align(8) Listener = @fieldParentPtr("node", n);
diff --git a/src/browser/frame/user_input.zig b/src/browser/frame/user_input.zig
index cd50e4b02..5beb51713 100644
--- a/src/browser/frame/user_input.zig
+++ b/src/browser/frame/user_input.zig
@@ -292,7 +292,7 @@ pub fn triggerMouseWheel(frame: *Frame, x: f64, y: f64, delta_x: f64, delta_y: f
/// A wheel over `target`: trusted `wheel`, the legacy `mousewheel` Blink
/// still fires, then the scroll unless either was canceled. Each event is
-/// non-cancelable when every listener on its path is passive.
+/// cancelable only while a listener on its dispatch path is non-passive.
pub fn wheel(frame: *Frame, target: *Element, x: f64, y: f64, delta_x: f64, delta_y: f64) !void {
// Listeners live in the event manager of the element's own frame, which
// is not the caller's when the element belongs to an iframe's document.
@@ -303,13 +303,13 @@ pub fn wheel(frame: *Frame, target: *Element, x: f64, y: f64, delta_x: f64, delt
inline for (.{ "wheel", "mousewheel" }) |typ| {
const event: *WheelEvent = try .initTrusted(typ, .{
.bubbles = true,
- .cancelable = event_manager.hasNonPassiveListener(target.asNode(), typ),
.composed = true,
.clientX = x,
.clientY = y,
.deltaX = delta_x,
.deltaY = delta_y,
}, owner);
+ event.asEvent()._cancelable_unless_passive = true;
if (try event_manager.dispatchCancelable(target.asEventTarget(), event.asEvent())) {
canceled = true;
}
diff --git a/src/browser/webapi/Event.zig b/src/browser/webapi/Event.zig
index 0be7ad4bf..42805f2c4 100644
--- a/src/browser/webapi/Event.zig
+++ b/src/browser/webapi/Event.zig
@@ -36,6 +36,9 @@ _type: Type,
_arena: *lp.Arena,
_bubbles: bool = false,
_cancelable: bool = false,
+// Resolved at dispatch: cancelable only while a listener on the path could
+// call preventDefault. The UA's scroll-blocking events work this way.
+_cancelable_unless_passive: bool = false,
_composed: bool = false,
_type_string: String,
_target: ?*EventTarget = null,
diff --git a/src/browser/webapi/WebDriver.zig b/src/browser/webapi/WebDriver.zig
index 68c84f556..b8db4f5be 100644
--- a/src/browser/webapi/WebDriver.zig
+++ b/src/browser/webapi/WebDriver.zig
@@ -608,12 +608,12 @@ fn dispatchTouch(el: *Element, comptime typ: []const u8, frame: *Frame) void {
const owner = el.ownerFrame(frame) orelse return;
const event = TouchEvent.initTrusted(typ, .{
.bubbles = true,
- .cancelable = owner._event_manager.hasNonPassiveListener(el.asNode(), typ),
.composed = true,
}, owner) catch |err| {
log.warn(.app, "webdriver touch event", .{ .err = err });
return;
};
+ event.asEvent()._cancelable_unless_passive = true;
dispatch(el.asEventTarget(), event.asEvent(), owner, typ);
}