@remote-dom/polyfill 1.5.1 → 1.6.0

package/source/tests/event-dispatch.test.ts

@@ -0,0 +1,270 @@
+import {describe, expect, it, vi} from 'vitest';
+
+import {Event} from '../Event.ts';
+import {EventTarget} from '../EventTarget.ts';
+import {Window} from '../Window.ts';
+
+const PRE_DISPATCH_STOP_FORMS = [
+  ['stopPropagation()', (event: Event) => event.stopPropagation()],
+  [
+    'stopImmediatePropagation()',
+    (event: Event) => event.stopImmediatePropagation(),
+  ],
+  ['cancelBubble = true', (event: Event) => (event.cancelBubble = true)],
+] as const;
+
+describe('EventTarget dispatch lifecycle', () => {
+  it('resets stopped propagation before redispatching an event', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    const event = new Event('change');
+
+    target.addEventListener('change', (event) => event.stopPropagation(), {
+      capture: true,
+      once: true,
+    });
+    target.addEventListener('change', listener);
+
+    target.dispatchEvent(event);
+    expect(listener).not.toHaveBeenCalled();
+
+    target.dispatchEvent(event);
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('resets stopped immediate propagation before redispatching an event', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    const event = new Event('change');
+
+    target.addEventListener(
+      'change',
+      (event) => event.stopImmediatePropagation(),
+      {once: true},
+    );
+    target.addEventListener('change', listener);
+
+    target.dispatchEvent(event);
+    expect(listener).not.toHaveBeenCalled();
+
+    target.dispatchEvent(event);
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  describe.each(PRE_DISPATCH_STOP_FORMS)(
+    'an event stopped with %s before dispatch',
+    (_name, stop) => {
+      it.each([false, true])(
+        'skips capture=%s listeners and resets propagation state',
+        (capture) => {
+          const target = new EventTarget();
+          const listener = vi.fn();
+          const event = new Event('change');
+
+          target.addEventListener('change', listener, {capture});
+          stop(event);
+
+          expect(target.dispatchEvent(event)).toBe(true);
+          expect(listener).not.toHaveBeenCalled();
+          expect(event.cancelBubble).toBe(false);
+
+          expect(target.dispatchEvent(event)).toBe(true);
+          expect(listener).toHaveBeenCalledOnce();
+        },
+      );
+    },
+  );
+
+  it('rejects in-flight redispatch and permits redispatch after completion', () => {
+    const target = new EventTarget();
+    const event = new Event('change');
+    let redispatchError: unknown;
+
+    target.addEventListener(
+      'change',
+      () => {
+        try {
+          target.dispatchEvent(event);
+        } catch (error) {
+          redispatchError = error;
+        }
+      },
+      {once: true},
+    );
+
+    expect(target.dispatchEvent(event)).toBe(true);
+    expect(redispatchError).toBeInstanceOf(DOMException);
+    expect((redispatchError as DOMException).name).toBe('InvalidStateError');
+    expect(target.dispatchEvent(event)).toBe(true);
+  });
+
+  it('names in-flight redispatch errors without a global DOMException', () => {
+    const target = new EventTarget();
+    const event = new Event('change');
+    let redispatchError: unknown;
+
+    vi.stubGlobal('DOMException', undefined);
+    try {
+      target.addEventListener(
+        'change',
+        () => {
+          try {
+            target.dispatchEvent(event);
+          } catch (error) {
+            redispatchError = error;
+          }
+        },
+        {once: true},
+      );
+
+      target.dispatchEvent(event);
+    } finally {
+      vi.unstubAllGlobals();
+    }
+
+    expect(redispatchError).toBeInstanceOf(Error);
+    expect(redispatchError).toMatchObject({
+      name: 'InvalidStateError',
+      message: expect.stringContaining('already being dispatched'),
+    });
+  });
+
+  it('defers listeners added during dispatch until the next dispatch', () => {
+    const target = new EventTarget();
+    const addedListener = vi.fn();
+
+    target.addEventListener('change', () => {
+      target.addEventListener('change', addedListener);
+    });
+
+    target.dispatchEvent(new Event('change'));
+    expect(addedListener).not.toHaveBeenCalled();
+
+    target.dispatchEvent(new Event('change'));
+    expect(addedListener).toHaveBeenCalledOnce();
+  });
+
+  it('defers a function listener removed and re-added during dispatch', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    let firstDispatch = true;
+
+    target.addEventListener('change', () => {
+      if (!firstDispatch) return;
+      firstDispatch = false;
+      target.removeEventListener('change', listener);
+      target.addEventListener('change', listener);
+    });
+    target.addEventListener('change', listener);
+
+    target.dispatchEvent(new Event('change'));
+    expect(listener).not.toHaveBeenCalled();
+
+    target.dispatchEvent(new Event('change'));
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('defers a listener object removed and re-added during dispatch', () => {
+    const target = new EventTarget();
+    const listener = {handleEvent: vi.fn()};
+    let firstDispatch = true;
+
+    target.addEventListener('change', () => {
+      if (!firstDispatch) return;
+      firstDispatch = false;
+      target.removeEventListener('change', listener);
+      target.addEventListener('change', listener);
+    });
+    target.addEventListener('change', listener);
+
+    target.dispatchEvent(new Event('change'));
+    expect(listener.handleEvent).not.toHaveBeenCalled();
+
+    target.dispatchEvent(new Event('change'));
+    expect(listener.handleEvent).toHaveBeenCalledOnce();
+  });
+
+  it('skips a snapshotted listener whose signal is aborted during dispatch', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    const controller = new AbortController();
+
+    target.addEventListener('change', () => controller.abort());
+    target.addEventListener('change', listener, {signal: controller.signal});
+
+    target.dispatchEvent(new Event('change'));
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('returns defensive copies that cannot corrupt event traversal', () => {
+    const window = new Window();
+    const parent = window.document.createElement('div');
+    const target = window.document.createElement('button');
+    const targetListener = vi.fn((event: globalThis.Event) =>
+      event.composedPath(),
+    );
+    parent.appendChild(target);
+
+    parent.addEventListener(
+      'change',
+      (event) => {
+        event.composedPath().length = 0;
+      },
+      {capture: true},
+    );
+    target.addEventListener('change', targetListener);
+
+    target.dispatchEvent(new Event('change', {bubbles: true}));
+
+    expect(targetListener).toHaveBeenCalledOnce();
+    expect(targetListener.mock.results[0]!.value).toEqual([target, parent]);
+  });
+
+  it('skips snapshotted listeners removed during dispatch', () => {
+    const target = new EventTarget();
+    const removedListener = vi.fn();
+
+    target.addEventListener('change', () => {
+      target.removeEventListener('change', removedListener);
+    });
+    target.addEventListener('change', removedListener);
+
+    target.dispatchEvent(new Event('change'));
+
+    expect(removedListener).not.toHaveBeenCalled();
+  });
+
+  it('normalizes transient state after dispatch', () => {
+    const target = new EventTarget();
+    const event = new Event('change');
+    let stateDuringDispatch:
+      | {
+          eventPhase: number;
+          currentTarget: globalThis.EventTarget | null;
+          path: globalThis.EventTarget[];
+        }
+      | undefined;
+
+    target.addEventListener('change', (event) => {
+      stateDuringDispatch = {
+        eventPhase: event.eventPhase,
+        currentTarget: event.currentTarget,
+        path: event.composedPath(),
+      };
+      event.stopPropagation();
+    });
+
+    target.dispatchEvent(event);
+
+    expect(stateDuringDispatch).toEqual({
+      eventPhase: Event.AT_TARGET,
+      currentTarget: target,
+      path: [target],
+    });
+    expect(event.eventPhase).toBe(Event.NONE);
+    expect(event.currentTarget).toBeNull();
+    expect(event.composedPath()).toEqual([]);
+    expect(event.cancelBubble).toBe(false);
+  });
+});

package/source/tests/event-target.test.ts

@@ -0,0 +1,208 @@
+import {describe, expect, it, vi} from 'vitest';
+
+import {Event} from '../Event.ts';
+import {EventTarget} from '../EventTarget.ts';
+
+describe('EventTarget listener registration', () => {
+  it('deduplicates listeners by type, callback, and capture', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+
+    target.addEventListener('change', listener);
+    target.addEventListener('change', listener, false);
+    target.addEventListener('change', listener, {capture: false});
+
+    target.dispatchEvent(new Event('change'));
+
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('treats capture and non-capture registrations as distinct', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+
+    target.addEventListener('change', listener);
+    target.addEventListener('change', listener, true);
+    target.removeEventListener('change', listener, false);
+
+    target.dispatchEvent(new Event('change'));
+    expect(listener).toHaveBeenCalledOnce();
+
+    target.removeEventListener('change', listener, true);
+    target.dispatchEvent(new Event('change'));
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('keeps colliding event names in separate capture lists', () => {
+    const target = new EventTarget();
+    const nameListener = vi.fn();
+    const nameWithMarkerListener = vi.fn();
+
+    target.addEventListener('name', nameListener, true);
+    target.addEventListener('name@', nameWithMarkerListener);
+
+    target.dispatchEvent(new Event('name'));
+    expect(nameListener).toHaveBeenCalledOnce();
+    expect(nameWithMarkerListener).not.toHaveBeenCalled();
+
+    target.dispatchEvent(new Event('name@'));
+    expect(nameListener).toHaveBeenCalledOnce();
+    expect(nameWithMarkerListener).toHaveBeenCalledOnce();
+  });
+
+  it('removes colliding event names by type and capture', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+
+    target.addEventListener('name', listener, true);
+    target.addEventListener('name@', listener);
+
+    target.removeEventListener('name', listener, false);
+    target.removeEventListener('name@', listener, true);
+    target.dispatchEvent(new Event('name'));
+    target.dispatchEvent(new Event('name@'));
+    expect(listener).toHaveBeenCalledTimes(2);
+
+    listener.mockClear();
+    target.removeEventListener('name', listener, true);
+    target.dispatchEvent(new Event('name@'));
+    expect(listener).toHaveBeenCalledOnce();
+
+    target.removeEventListener('name@', listener);
+    target.dispatchEvent(new Event('name@'));
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('does not orphan a once listener when removing the wrong capture mode', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+
+    target.addEventListener('change', listener, {once: true});
+    target.removeEventListener('change', listener, true);
+    target.removeEventListener('change', listener);
+
+    target.dispatchEvent(new Event('change'));
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('keeps once listeners distinct across event types', () => {
+    const target = new EventTarget();
+    const listener = vi.fn((event: globalThis.Event) => event.type);
+
+    target.addEventListener('start', listener, {once: true});
+    target.addEventListener('finish', listener, {once: true});
+
+    target.dispatchEvent(new Event('start'));
+    target.dispatchEvent(new Event('start'));
+    target.dispatchEvent(new Event('finish'));
+    target.dispatchEvent(new Event('finish'));
+
+    expect(listener.mock.results.map(({value}) => value)).toEqual([
+      'start',
+      'finish',
+    ]);
+  });
+
+  it('deduplicates once listeners and removes them after dispatch', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+
+    target.addEventListener('change', listener, {once: true});
+    target.addEventListener('change', listener, {once: true});
+
+    target.dispatchEvent(new Event('change'));
+    target.dispatchEvent(new Event('change'));
+
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('uses the registered capture value when removing a once listener', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    const options = {capture: false, once: true};
+
+    target.addEventListener('change', listener, options);
+    options.capture = true;
+
+    target.dispatchEvent(new Event('change'));
+    target.dispatchEvent(new Event('change'));
+
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('does not register a listener with an already-aborted signal', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    const controller = new AbortController();
+    controller.abort();
+
+    target.addEventListener('change', listener, {
+      signal: controller.signal,
+    });
+    target.dispatchEvent(new Event('change'));
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('removes a registered listener when its signal aborts', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    const controller = new AbortController();
+
+    target.addEventListener('change', listener, {
+      signal: controller.signal,
+    });
+    target.dispatchEvent(new Event('change'));
+    controller.abort();
+    target.dispatchEvent(new Event('change'));
+
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it('uses the registered capture value when a signal removes a listener', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    const controller = new AbortController();
+    const options = {capture: false, signal: controller.signal};
+
+    target.addEventListener('change', listener, options);
+    options.capture = true;
+    controller.abort();
+    target.dispatchEvent(new Event('change'));
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('does not invoke a signal listener during an earlier abort handler', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    const controller = new AbortController();
+
+    controller.signal.addEventListener('abort', () => {
+      target.dispatchEvent(new Event('change'));
+    });
+    target.addEventListener('change', listener, {signal: controller.signal});
+
+    controller.abort();
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('does not let an old signal remove a later registration', () => {
+    const target = new EventTarget();
+    const listener = vi.fn();
+    const controller = new AbortController();
+
+    target.addEventListener('change', listener, {
+      signal: controller.signal,
+    });
+    target.removeEventListener('change', listener);
+    target.addEventListener('change', listener);
+
+    controller.abort();
+    target.dispatchEvent(new Event('change'));
+
+    expect(listener).toHaveBeenCalledOnce();
+  });
+});

package/source/tests/event.test.ts

@@ -0,0 +1,98 @@
+import {beforeEach, describe, expect, it} from 'vitest';
+
+import {Window} from '../index.ts';
+
+let window: Window;
+
+beforeEach(() => {
+  window = new Window();
+  Window.setGlobalThis(window);
+});
+
+describe('Event cancellation', () => {
+  it('returns true when the event is not canceled', () => {
+    const target = new window.EventTarget();
+
+    expect(target.dispatchEvent(new window.Event('event'))).toBe(true);
+  });
+
+  it('returns false when a cancelable event is canceled', () => {
+    const target = new window.EventTarget();
+    const event = new window.Event('event', {cancelable: true});
+    target.addEventListener('event', (event) => event.preventDefault());
+
+    expect(target.dispatchEvent(event)).toBe(false);
+    expect(event.defaultPrevented).toBe(true);
+  });
+
+  it('does not cancel a non-cancelable event', () => {
+    const target = new window.EventTarget();
+    const event = new window.Event('event');
+    target.addEventListener('event', (event) => event.preventDefault());
+
+    expect(target.dispatchEvent(event)).toBe(true);
+    expect(event.defaultPrevented).toBe(false);
+  });
+
+  it('returns the cancellation result when propagation is stopped', () => {
+    const target = new window.EventTarget();
+    target.addEventListener(
+      'event',
+      (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+      },
+      true,
+    );
+
+    expect(
+      target.dispatchEvent(new window.Event('event', {cancelable: true})),
+    ).toBe(false);
+  });
+
+  it('returns true when propagation is stopped without cancellation', () => {
+    const target = new window.EventTarget();
+    target.addEventListener('event', (event) => event.stopPropagation());
+
+    expect(target.dispatchEvent(new window.Event('event'))).toBe(true);
+  });
+
+  it('cancels cancelable events for falsy returnValue assignments', () => {
+    for (const value of [false, 0, '', null, undefined]) {
+      const event = new window.Event('event', {cancelable: true});
+
+      (event as any).returnValue = value;
+
+      expect(event.defaultPrevented).toBe(true);
+      expect(event.returnValue).toBe(false);
+    }
+  });
+
+  it('does not cancel or uncancel events for truthy returnValue assignments', () => {
+    for (const value of [true, 1, 'false', {}]) {
+      const event = new window.Event('event', {cancelable: true});
+
+      (event as any).returnValue = value;
+
+      expect(event.defaultPrevented).toBe(false);
+      expect(event.returnValue).toBe(true);
+
+      event.preventDefault();
+      (event as any).returnValue = value;
+
+      expect(event.defaultPrevented).toBe(true);
+      expect(event.returnValue).toBe(false);
+    }
+  });
+
+  it('does not cancel non-cancelable events through falsy returnValue', () => {
+    for (const value of [false, 0, '', null, undefined]) {
+      const event = new window.Event('event');
+
+      (event as any).returnValue = value;
+
+      expect(event.defaultPrevented).toBe(false);
+      expect(event.returnValue).toBe(true);
+    }
+  });
+});