Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: event handlers returning false cancel the event

Francis Bouvierdaa3b1d4513c
diff --git a/src/browser/EventManager.zig b/src/browser/EventManager.zig
index a03d36d47..81e581585 100644
--- a/src/browser/EventManager.zig
+++ b/src/browser/EventManager.zig
@@ -351,9 +351,11 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event, comptime opts
// Inline handlers (e.g. onclick property) follow the same "report,
// don't propagate" rule as addEventListener listeners — see Listener.run.
var caught: js.TryCatch.Caught = undefined;
- ls.toLocal(inline_handler).tryCallWithThis(void, target_et, .{event}, &caught) catch |err| {
+ const handler_return: ?js.Value = ls.toLocal(inline_handler).tryCallWithThis(js.Value, target_et, .{event}, &caught) catch |err| ret: {
log.warn(.event, "inline handler", .{ .err = err, .caught = caught });
+ break :ret null;
};
+ processHandlerReturnValue(event, handler_return);
if (event._stop_propagation) {
return;
@@ -405,9 +407,11 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event, comptime opts
}
var caught: js.TryCatch.Caught = undefined;
- ls.toLocal(inline_handler).tryCallWithThis(void, current_target, .{event}, &caught) catch |err| {
+ const handler_return: ?js.Value = ls.toLocal(inline_handler).tryCallWithThis(js.Value, current_target, .{event}, &caught) catch |err| ret: {
log.warn(.event, "inline handler", .{ .err = err, .caught = caught });
+ break :ret null;
};
+ processHandlerReturnValue(event, handler_return);
if (event._needs_retargeting) {
event._target = original_target;
@@ -428,6 +432,20 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event, comptime opts
}
}
+// Per the HTML "event handler processing algorithm", an event handler (on*
+// property or attribute) returning false cancels the event — unlike
+// addEventListener listeners, whose return value is ignored. The inverted
+// special case for onerror only applies to the global's onerror, which is
+// invoked via Window.reportError, not through this node dispatch path.
+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"))) {
+ event.preventDefault();
+ }
+}
+
+// Per spec ("invocation target in shadow tree"), window.event is left
+// undefined while invoking listeners whose target lives in a shadow tree.
fn currentEventForTarget(target: *EventTarget, event: *Event) ?*Event {
return if (rootIsShadowRoot(target)) null else event;
}
diff --git a/src/browser/tests/events.html b/src/browser/tests/events.html
index 1245e98d0..6be2ee8f3 100644
--- a/src/browser/tests/events.html
+++ b/src/browser/tests/events.html
@@ -900,3 +900,43 @@
window.removeEventListener('win_throw', c);
}
</script>
+
+<div id=return_false_parent><span id=return_false_child></span></div>
+<script id=inlineHandlerReturnFalseCancels>
+ // Per the HTML event handler processing algorithm, an event handler (on*
+ // property/attribute) returning false cancels the event; the return value
+ // of addEventListener listeners is ignored.
+ {
+ const parent = $('#return_false_parent');
+ const child = $('#return_false_child');
+
+ // At-target inline handler.
+ child.onclick = () => false;
+ const ev1 = new MouseEvent('click', {bubbles: true, cancelable: true});
+ testing.expectEqual(false, child.dispatchEvent(ev1));
+ testing.expectEqual(true, ev1.defaultPrevented);
+ child.onclick = null;
+
+ // Inline handler on an ancestor (bubble phase).
+ parent.onclick = () => false;
+ const ev2 = new MouseEvent('click', {bubbles: true, cancelable: true});
+ testing.expectEqual(false, child.dispatchEvent(ev2));
+ testing.expectEqual(true, ev2.defaultPrevented);
+ parent.onclick = null;
+
+ // Only false cancels; other falsy values don't.
+ child.onclick = () => undefined;
+ const ev3 = new MouseEvent('click', {bubbles: true, cancelable: true});
+ testing.expectEqual(true, child.dispatchEvent(ev3));
+ testing.expectEqual(false, ev3.defaultPrevented);
+ child.onclick = null;
+
+ // addEventListener listeners returning false don't cancel.
+ const listener = () => false;
+ child.addEventListener('click', listener);
+ const ev4 = new MouseEvent('click', {bubbles: true, cancelable: true});
+ testing.expectEqual(true, child.dispatchEvent(ev4));
+ testing.expectEqual(false, ev4.defaultPrevented);
+ child.removeEventListener('click', listener);
+ }
+</script>