Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: set eventPhase = AT_TARGET inside direct dispatch listeners

Karl Seguind0180bfa6e44
diff --git a/src/browser/EventManagerBase.zig b/src/browser/EventManagerBase.zig
index 2191e6a6b..f42142d75 100644
--- a/src/browser/EventManagerBase.zig
+++ b/src/browser/EventManagerBase.zig
@@ -352,12 +352,17 @@ pub fn dispatchDirect(
ls.deinit();
}
- // Per spec, currentTarget is only set while listeners are being invoked
- defer event._current_target = null;
-
// This is a slightly simplified version of what you'll find in EventManager.
// dispatchPhase. It is simpler because, for direct dispatching, we know
// there's no ancestors and only the single target phase.
+ event._event_phase = .at_target;
+ defer {
+ event._event_phase = .none;
+ // Per spec, currentTarget is only set while listeners are being invoked
+ event._current_target = null;
+ event._stop_propagation = false;
+ event._stop_immediate_propagation = false;
+ }
// Track dispatch depth for deferred removal.
self.dispatch_depth += 1;
diff --git a/src/browser/tests/events.html b/src/browser/tests/events.html
index 95860c038..7bc12a679 100644
--- a/src/browser/tests/events.html
+++ b/src/browser/tests/events.html
@@ -907,6 +907,77 @@
}
</script>
+<script id=directDispatchEventPhase>
+ // Non-DOM targets have no path: listeners run at the target.
+ for (const target of [new EventTarget(), window]) {
+ const ev = new Event('direct_phase');
+ let phase = null;
+ const listener = (e) => phase = e.eventPhase;
+ target.addEventListener('direct_phase', listener);
+ target.dispatchEvent(ev);
+ target.removeEventListener('direct_phase', listener);
+
+ testing.expectEqual(Event.AT_TARGET, phase);
+ testing.expectEqual(Event.NONE, ev.eventPhase);
+ }
+</script>
+
+<script id=directDispatchIsDispatching>
+ {
+ const target = new EventTarget();
+ const ev = new Event('direct_busy');
+ let redispatch = null;
+ target.addEventListener('direct_busy', (e) => {
+ try {
+ target.dispatchEvent(e);
+ } catch (err) {
+ redispatch = err.name;
+ }
+ // Ignored while the event is being dispatched.
+ e.initEvent('renamed', true, true);
+ });
+ target.dispatchEvent(ev);
+
+ testing.expectEqual('InvalidStateError', redispatch);
+ testing.expectEqual('direct_busy', ev.type);
+ testing.expectEqual(false, ev.bubbles);
+ }
+</script>
+
+<script id=directDispatchClearsStopPropagation>
+ // Fails in Chrome, which doesn't clear the stop flags after dispatching to a
+ // non-Node target (it does for Nodes). The spec and Firefox clear them for
+ // every target.
+ {
+ const target = new EventTarget();
+ const ev = new Event('direct_stop');
+ let calls = 0;
+ target.addEventListener('direct_stop', (e) => {
+ calls += 1;
+ e.stopImmediatePropagation();
+ });
+ target.addEventListener('direct_stop', () => calls += 100);
+
+ target.dispatchEvent(ev);
+ testing.expectEqual(1, calls);
+
+ // The flags are cleared once dispatch ends.
+ target.dispatchEvent(ev);
+ testing.expectEqual(2, calls);
+ }
+</script>
+
+<script id=directDispatchEventPhaseNative type=module>
+{
+ const state = await testing.async();
+ window.addEventListener('message', (e) => state.resolve(e.eventPhase), { once: true });
+ window.postMessage('phase', '*');
+ await state.done((phase) => {
+ testing.expectEqual(Event.AT_TARGET, phase);
+ });
+}
+</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*