Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 6 additions & 0 deletions .changeset/dom-events.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,6 @@
---
'@clack/ui': minor
'@bomb.sh/web-platform-tests': patch
---

Support native event listeners and bubbling through the UI's node tree.
70 changes: 69 additions & 1 deletion packages/ui/src/dom.ts
Original file line number Diff line number Diff line change
Expand Up @@ -79,7 +79,11 @@ export class Document {
}
}

export abstract class Node {
export interface EventListener<Target extends EventTarget = EventTarget> {
(this: Target, event: Event): void;
}

export abstract class Node extends EventTarget {
static readonly ELEMENT_NODE = 1;
static readonly ATTRIBUTE_NODE = 2;
static readonly TEXT_NODE = 3;
Expand All @@ -103,10 +107,60 @@ export abstract class Node {
#parentNode: Node | null = null;

constructor(owner: Document, notify: Node['notify']) {
super();
this.notify = notify;
this.ownerDocument = owner;
}

// Adds bubbling to the host EventTarget. Capture traversal and resetting the
// host's propagation flags after dispatch are not implemented here.
override dispatchEvent(event: Event): boolean {
if (event.eventPhase !== Event.NONE) {
throw new DOMException('Cannot redispatch an active event', 'InvalidStateError');
}

const path: Node[] = [this];
for (let current = this.parentNode; current; current = current.parentNode) {
path.push(current);
}

// Native dispatch retargets on each node. Keep the tree's original target
// and expose its current node and phase while each native dispatch runs.
Object.defineProperty(event, 'target', { configurable: true, value: this });
const originals = Object.getOwnPropertyDescriptors(event);

try {
Object.defineProperty(event, 'composedPath', {
value: () => [...path],
configurable: true,
});
const end = event.bubbles ? path.length : 1;
for (let i = 0; i < end; i++) {
Object.defineProperties(event, {
currentTarget: { value: path[i], configurable: true },
eventPhase: {
value: i === 0 ? Event.AT_TARGET : Event.BUBBLING_PHASE,
configurable: true,
},
});
super.dispatchEvent.call(path[i], event);
if (event.cancelBubble) {
break;
}
}
return !event.defaultPrevented;
} finally {
for (const name of ['currentTarget', 'eventPhase', 'composedPath']) {
const original = originals[name];
if (original) {
Object.defineProperty(event, name, original);
} else {
Reflect.deleteProperty(event, name);
}
}
}
}

hasChildNodes(): boolean {
return this.#childNodes.length > 0;
}
Expand Down Expand Up @@ -468,3 +522,17 @@ interface ElementNamespace {
namespaceURI: string | null;
prefix: string | null;
}

export interface EventOptions {
bubbles?: boolean;
cancelable?: boolean;
composed?: boolean;
}

// Node exposes these constants at runtime, but its type declarations omit them.
const Event = globalThis.Event as typeof globalThis.Event & {
readonly NONE: 0;

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

given its about as much code to re-declare these as it is to just have our own constants, what do you think about having our own constants?

i.e. const EVENT_NONE = 0 etc

otherwise i would try solve this through augmentation rather than casting. augment the global interface/class with the extra members etc

readonly CAPTURING_PHASE: 1;
readonly AT_TARGET: 2;
readonly BUBBLING_PHASE: 3;
};
24 changes: 22 additions & 2 deletions packages/ui/test/wpt.config.ts
Original file line number Diff line number Diff line change
Expand Up @@ -13,22 +13,40 @@ import {
} from '../src/dom.ts';
import { NamedNodeMap } from '../src/named-node-map.ts';

export default {
const config: WPTConfig = {
globals: {
AbortController: globalThis.AbortController,
Attr,
CharacterData,
Comment,
CustomEvent: globalThis.CustomEvent,
Document,
DOMException: globalThis.DOMException,
Element,
Event: globalThis.Event,
EventTarget: globalThis.EventTarget,
HTMLElement,
HTMLSpanElement,
HTMLUnknownElement,
NamedNodeMap,
Node,
Text,
TypeError: globalThis.TypeError,
},
include: {
'dom/events/Event-constructors.any.js': true,
'dom/events/EventTarget-addEventListener.any.js': true,
'dom/events/EventTarget-add-remove-listener.any.js': true,
'dom/events/AddEventListenerOptions-once.any.js': true,
'dom/events/AddEventListenerOptions-signal.any.js': true,
'dom/events/AddEventListenerOptions-passive.any.js': true,
'dom/events/remove-all-listeners.html': true,
'dom/events/EventListener-handleEvent.html': [
'calls `handleEvent` method of `EventListener`',
"doesn't call `handleEvent` method on callable `EventListener`",
// Native EventTarget reads handleEvent at registration; the getter-timing
// case remains excluded until that behavior is implemented.
],
'dom/nodes/Document-createTextNode.html': true,
'dom/nodes/Document-createElement.html': true,
'dom/nodes/Document-createElementNS.html': true,
Expand Down Expand Up @@ -142,4 +160,6 @@ export default {
'uievents/**': true,
'xhr/**': true,
},
} satisfies WPTConfig;
};

export default config;
1 change: 1 addition & 0 deletions packages/web-platform-tests/docs/omissions.md
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,7 @@ the upstream WPT root. Consumer exclusions in `wpt.config.ts` are separate.
| `dom/nodes/Element-matches-namespaced-elements.html` | The `webkitMatchesSelector` rows. | Vendor-prefixed alias. |
| `dom/nodes/ParentNode-querySelector-All.html`, `dom/nodes/ParentNode-querySelector-All-xht.xht`, `dom/nodes/Element-matches.html` | Unnamed iframe-loader cases. | The consumer's document factory replaces upstream fixture loading; behavioral subtests remain. |
| `dom/nodes/attributes.html` | `setAttributeNode, if it fires mutation events, should fire one with the new node when resetting an existing attribute`, and its ` (outer shell)` companion. | Legacy `DOMAttrModified` coverage is outside the current event scope; both the listener assertions and their outer-shell setup remain omitted. |
| `dom/events/EventListener-handleEvent.html` | `` rethrows errors when getting `handleEvent` ``, ``throws if `handleEvent` is falsy and not callable``, and ``throws if `handleEvent` is thruthy and not callable``. | Require asynchronous window error reporting and the upstream `EventWatcher` harness. |
| `domparsing/createContextualFragment.html` | `<script>s should be run when appended to the document (but not before)`. | Requires a script realm installed before parsing. |

## Forms
Expand Down
4 changes: 4 additions & 0 deletions packages/web-platform-tests/src/shared/registry.ts
Original file line number Diff line number Diff line change
Expand Up @@ -67,13 +67,15 @@ import { register as register_dom_events_Event_dispatch_reenter_html } from '../
import { register as register_dom_events_Event_dispatch_target_moved_html } from '../wpt/dom/events/Event-dispatch-target-moved.html.ts';
import { register as register_dom_events_Event_dispatch_throwing_html } from '../wpt/dom/events/Event-dispatch-throwing.html.ts';
import { register as register_dom_events_Event_stopImmediatePropagation_html } from '../wpt/dom/events/Event-stopImmediatePropagation.html.ts';
import { register as register_dom_events_EventListener_handleEvent_html } from '../wpt/dom/events/EventListener-handleEvent.html.ts';
import { register as register_dom_events_EventListenerOptions_capture_html } from '../wpt/dom/events/EventListenerOptions-capture.html.ts';
import { register as register_dom_events_EventTarget_add_remove_listener_any_js } from '../wpt/dom/events/EventTarget-add-remove-listener.any.js.ts';
import { register as register_dom_events_EventTarget_addEventListener_any_js } from '../wpt/dom/events/EventTarget-addEventListener.any.js.ts';
import { register as register_dom_events_EventTarget_dispatchEvent_returnvalue_html } from '../wpt/dom/events/EventTarget-dispatchEvent-returnvalue.html.ts';
import { register as register_dom_events_EventTarget_dispatchEvent_html } from '../wpt/dom/events/EventTarget-dispatchEvent.html.ts';
import { register as register_dom_events_EventTarget_removeEventListener_any_js } from '../wpt/dom/events/EventTarget-removeEventListener.any.js.ts';
import { register as register_dom_events_EventTarget_this_of_listener_html } from '../wpt/dom/events/EventTarget-this-of-listener.html.ts';
import { register as register_dom_events_remove_all_listeners_html } from '../wpt/dom/events/remove-all-listeners.html.ts';
import { register as register_dom_lists_DOMTokenList_coverage_for_attributes_html } from '../wpt/dom/lists/DOMTokenList-coverage-for-attributes.html.ts';
import { register as register_dom_nodes_CharacterData_appendData_html } from '../wpt/dom/nodes/CharacterData-appendData.html.ts';
import { register as register_dom_nodes_CharacterData_data_html } from '../wpt/dom/nodes/CharacterData-data.html.ts';
Expand Down Expand Up @@ -506,13 +508,15 @@ export const registry = {
'dom/events/Event-dispatch-target-moved.html': { register: register_dom_events_Event_dispatch_target_moved_html },
'dom/events/Event-dispatch-throwing.html': { register: register_dom_events_Event_dispatch_throwing_html },
'dom/events/Event-stopImmediatePropagation.html': { register: register_dom_events_Event_stopImmediatePropagation_html },
'dom/events/EventListener-handleEvent.html': { register: register_dom_events_EventListener_handleEvent_html },
'dom/events/EventListenerOptions-capture.html': { register: register_dom_events_EventListenerOptions_capture_html },
'dom/events/EventTarget-add-remove-listener.any.js': { register: register_dom_events_EventTarget_add_remove_listener_any_js },
'dom/events/EventTarget-addEventListener.any.js': { register: register_dom_events_EventTarget_addEventListener_any_js },
'dom/events/EventTarget-dispatchEvent-returnvalue.html': { register: register_dom_events_EventTarget_dispatchEvent_returnvalue_html },
'dom/events/EventTarget-dispatchEvent.html': { register: register_dom_events_EventTarget_dispatchEvent_html },
'dom/events/EventTarget-removeEventListener.any.js': { register: register_dom_events_EventTarget_removeEventListener_any_js },
'dom/events/EventTarget-this-of-listener.html': { register: register_dom_events_EventTarget_this_of_listener_html },
'dom/events/remove-all-listeners.html': { register: register_dom_events_remove_all_listeners_html },
'dom/lists/DOMTokenList-coverage-for-attributes.html': { register: register_dom_lists_DOMTokenList_coverage_for_attributes_html },
'dom/nodes/CharacterData-appendData.html': { register: register_dom_nodes_CharacterData_appendData_html },
'dom/nodes/CharacterData-data.html': { register: register_dom_nodes_CharacterData_data_html },
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,61 @@
import type { CompatibilityContext } from '../../../shared/context.ts';

export function register(context: CompatibilityContext): void {
const { expect } = context.runner;

context.test('calls `handleEvent` method of `EventListener`', ({ document, Event, step }) => {
const type = 'foo';
const target = document.createElement('div');
const eventListener = {
handleEvent: function (evt: Event) {
const that = this;
step(() => {
expect(evt.type).toBe(type);
expect(evt.target).toBe(target);
expect(evt.srcElement).toBe(target);
expect(that).toBe(eventListener);
})();
},
};

target.addEventListener(type, eventListener);
target.dispatchEvent(new Event(type));
});

context.test('performs `Get` every time event is dispatched', ({ document, Event }) => {
const type = 'foo';
const target = document.createElement('div');
let calls = 0;

target.addEventListener(type, {
get handleEvent() {
calls++;
return function () {};
},
});

expect(calls).toBe(0);
target.dispatchEvent(new Event(type));
target.dispatchEvent(new Event(type));
expect(calls).toBe(2);
});

context.test(
"doesn't call `handleEvent` method on callable `EventListener`",
({ document, Event, step }) => {
const type = 'foo';
const target = document.createElement('div');
let calls = 0;
const eventListener = function () {
calls++;
};
eventListener.handleEvent = step(() => {
expect.unreachable('`handleEvent` method should not be called on functions');
});

target.addEventListener(type, eventListener);
target.dispatchEvent(new Event(type));
expect(calls).toBe(1);
},
);
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,95 @@
import type { CompatibilityContext } from '../../../shared/context.ts';

export function register(context: CompatibilityContext): void {
const { expect } = context.runner;

context.test(
'Removing all listeners and then adding a new one should work.',
({ document, Event }) => {
const type = 'foo';
const target = document.createElement('div');

let listener1CallCount = 0;
let listener2CallCount = 0;
let listener3CallCount = 0;
function listener1(): void {
listener1CallCount++;
target.removeEventListener(type, listener1);
target.removeEventListener(type, listener2);
target.addEventListener(type, listener3);
}
function listener2(): void {
listener2CallCount++;
}
function listener3(): void {
listener3CallCount++;
}

target.addEventListener(type, listener1);
target.addEventListener(type, listener2);

// Dispatch the event. Only listener1 should be called because
// it removes listener2. And listener3 is added when we've already
// started iterating, so it shouldn't be called either.
target.dispatchEvent(new Event(type));
expect(listener1CallCount).toBe(1);
expect(listener2CallCount).toBe(0);
expect(listener3CallCount).toBe(0);

// Now that only listener3 is set, dispatch another event. Only
// listener3 should be called.
target.dispatchEvent(new Event(type));
expect(listener1CallCount).toBe(1);
expect(listener2CallCount).toBe(0);
expect(listener3CallCount).toBe(1);
},
);

context.test('Nested usage of once listeners should work.', ({ document, Event, step }) => {
const type = 'foo';
const target = document.createElement('div');

let listener1CallCount = 0;
let listener2CallCount = 0;
let listener3CallCount = 0;
const listener1 = step(function (): void {
listener1CallCount++;
// Recursively dispatch another event from this listener.
// This will only call listener2 because listener1 is a "once" listener.
target.dispatchEvent(new Event(type));
expect(listener1CallCount).toBe(1);
expect(listener2CallCount).toBe(1);
expect(listener3CallCount).toBe(0);

// Now all listeners are removed - the two "once" listeners have already both
// been called once. Add another listener.
target.addEventListener(type, listener3);
});
function listener2(): void {
listener2CallCount++;
}
function listener3(): void {
listener3CallCount++;
}

// Add two "once" listeners.
target.addEventListener(type, listener1, { once: true });
target.addEventListener(type, listener2, { once: true });

// Dispatch the event.
target.dispatchEvent(new Event(type));

// The listener call counts should still match what they were
// at the end of listener1.
expect(listener1CallCount).toBe(1);
expect(listener2CallCount).toBe(1);
expect(listener3CallCount).toBe(0);

// Now that only listener3 is set, dispatch another event. Only
// listener3 should be called.
target.dispatchEvent(new Event(type));
expect(listener1CallCount).toBe(1);
expect(listener2CallCount).toBe(1);
expect(listener3CallCount).toBe(1);
});
}
Loading