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.zigindex 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: []consreturn 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 bubblingevent._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.zigindex 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.zigindex 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, deltinline 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.zigindex 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.zigindex 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);}