@remote-dom/polyfill 1.4.5 → 1.4.7

package/source/Window.ts

@@ -2,6 +2,11 @@ import {Document} from './Document.ts';
 import {Event} from './Event.ts';
 import {EventTarget} from './EventTarget.ts';
 import {CustomEvent} from './CustomEvent.ts';
+import {ErrorEvent} from './ErrorEvent.ts';
+import {PromiseRejectionEvent} from './PromiseRejectionEvent.ts';
+import {ToggleEvent} from './ToggleEvent.ts';
+import {FocusEvent} from './FocusEvent.ts';
+import {ClipboardEvent} from './ClipboardEvent.ts';
 import {Node} from './Node.ts';
 import {ParentNode} from './ParentNode.ts';
 import {ChildNode} from './ChildNode.ts';
@@ -18,6 +23,16 @@ import {MutationObserver} from './MutationObserver.ts';
 import {HOOKS} from './constants.ts';
 import type {Hooks} from './hooks.ts';
 
+type OnErrorHandler =
+  | ((
+      message: string,
+      filename?: string,
+      lineno?: number,
+      colno?: number,
+      error?: any,
+    ) => void)
+  | null;
+
 export class Window extends EventTarget {
   [HOOKS]: Partial<Hooks> = {};
   name = '';
@@ -30,6 +45,11 @@ export class Window extends EventTarget {
   location = globalThis.location;
   navigator = globalThis.navigator;
   Event = Event;
+  ErrorEvent = ErrorEvent;
+  PromiseRejectionEvent = PromiseRejectionEvent;
+  ToggleEvent = ToggleEvent;
+  FocusEvent = FocusEvent;
+  ClipboardEvent = ClipboardEvent;
   EventTarget = EventTarget;
   CustomEvent = CustomEvent;
   Node = Node;
@@ -46,6 +66,64 @@ export class Window extends EventTarget {
   HTMLTemplateElement = HTMLTemplateElement;
   MutationObserver = MutationObserver;
 
+  #currentOnErrorHandler: ((event: any) => void) | null = null;
+  #currentOriginalOnErrorHandler: OnErrorHandler = null;
+  #currentOnUnhandledRejectionHandler: WindowEventHandlers['onunhandledrejection'] =
+    null;
+
+  get onerror() {
+    return this.#currentOriginalOnErrorHandler;
+  }
+  set onerror(handler: OnErrorHandler) {
+    if (this.#currentOnErrorHandler) {
+      this.removeEventListener('error', this.#currentOnErrorHandler);
+    }
+    if (handler && typeof handler === 'function') {
+      // the event listener version receives an event object
+      // whereas winwow.onerror receives 5 arguments instead
+      // we need to wrap the handler to convert the event object to the 5 arguments
+      // and also make sure that when window.onerror is read to return the original handler
+      // https://developer.mozilla.org/en-US/docs/Web/API/Window/error_event#syntax
+      this.#currentOriginalOnErrorHandler = handler;
+      this.#currentOnErrorHandler = (event: ErrorEvent) => {
+        handler(
+          event.message ?? 'Error',
+          event.filename,
+          event.lineno,
+          event.colno,
+          event.error,
+        );
+      };
+      this.addEventListener('error', this.#currentOnErrorHandler);
+    } else {
+      this.#currentOnErrorHandler = null;
+      this.#currentOriginalOnErrorHandler = null;
+    }
+  }
+
+  get onunhandledrejection() {
+    return this.#currentOnUnhandledRejectionHandler;
+  }
+  set onunhandledrejection(
+    handler: WindowEventHandlers['onunhandledrejection'],
+  ) {
+    if (this.#currentOnUnhandledRejectionHandler) {
+      this.removeEventListener(
+        'unhandledrejection',
+        this.#currentOnUnhandledRejectionHandler as any,
+      );
+    }
+    if (handler && typeof handler === 'function') {
+      this.#currentOnUnhandledRejectionHandler = handler;
+      this.addEventListener(
+        'unhandledrejection',
+        this.#currentOnUnhandledRejectionHandler as any,
+      );
+    } else {
+      this.#currentOnUnhandledRejectionHandler = null;
+    }
+  }
+
   static setGlobal(window: Window) {
     const properties = Object.getOwnPropertyDescriptors(window);
 

package/source/tests/global-errors.test.ts

@@ -0,0 +1,149 @@
+import {ErrorEvent} from '../ErrorEvent.ts';
+import {PromiseRejectionEvent} from '../PromiseRejectionEvent.ts';
+import {Window} from '../Window.ts';
+import {describe, it, expect, beforeEach, afterEach, vi} from 'vitest';
+
+describe('global errors', () => {
+  describe('onerror', () => {
+    let originalOnerror: any;
+
+    beforeEach(() => {
+      originalOnerror = globalThis.onerror;
+    });
+
+    afterEach(() => {
+      globalThis.onerror = originalOnerror;
+    });
+
+    it('sets onerror handler on window instance', () => {
+      const handler = vi.fn();
+      const window = new Window();
+
+      window.onerror = handler;
+      expect(window.onerror).toBe(handler);
+    });
+
+    it('overrides onerror handler on window instance', () => {
+      const handler = vi.fn();
+      const handler2 = vi.fn();
+
+      const window = new Window();
+      window.onerror = handler;
+      window.onerror = handler2;
+
+      expect(window.onerror).toBe(handler2);
+    });
+
+    it('calls handler when error occurs', () => {
+      const handler = vi.fn();
+      const window = new Window();
+
+      const error = new Error('test');
+
+      window.onerror = handler;
+      window.dispatchEvent(
+        new ErrorEvent('error', {
+          error,
+          filename: 'test.ts',
+          lineno: 1,
+          colno: 1,
+        }),
+      );
+
+      expect(handler).toHaveBeenCalledWith('Error', 'test.ts', 1, 1, error);
+    });
+
+    it('allows null assignment', () => {
+      const handler = vi.fn();
+      const window = new Window();
+      window.onerror = handler;
+      expect(window.onerror).toBe(handler);
+
+      window.onerror = null;
+      expect(window.onerror).toBe(null);
+    });
+
+    it('works when window is set as global', () => {
+      const window = new Window();
+      Window.setGlobalThis(window);
+      const handler = vi.fn();
+      window.onerror = handler;
+
+      expect(window.onerror).toBe(handler);
+    });
+  });
+
+  describe('onunhandledrejection', () => {
+    let originalOnunhandledrejection: any;
+
+    beforeEach(() => {
+      originalOnunhandledrejection = globalThis.onunhandledrejection;
+    });
+
+    afterEach(() => {
+      globalThis.onunhandledrejection = originalOnunhandledrejection;
+    });
+
+    it('sets onunhandledrejection handler on window instance', () => {
+      const handler = vi.fn();
+      const window = new Window();
+
+      window.onunhandledrejection = handler;
+      expect(window.onunhandledrejection).toBe(handler);
+    });
+
+    it('overrides onunhandledrejection handler on window instance', () => {
+      const handler = vi.fn();
+      const handler2 = vi.fn();
+      const window = new Window();
+
+      window.onunhandledrejection = handler;
+      window.onunhandledrejection = handler2;
+      expect(window.onunhandledrejection).toBe(handler2);
+    });
+
+    it('calls handler when unhandled rejection occurs', () => {
+      const handler = vi.fn();
+      const window = new Window();
+      window.onunhandledrejection = handler;
+
+      const error = new Error('test');
+      const promise = Promise.resolve();
+
+      window.dispatchEvent(
+        new PromiseRejectionEvent('unhandledrejection', {
+          promise: promise,
+          reason: error,
+        }),
+      );
+
+      expect(handler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          promise,
+          reason: error,
+        }),
+      );
+
+      expect(handler).toHaveBeenCalledWith(expect.any(PromiseRejectionEvent));
+    });
+
+    it('allows null assignment', () => {
+      const handler = vi.fn();
+      const window = new Window();
+      window.onunhandledrejection = handler;
+      expect(window.onunhandledrejection).toBe(handler);
+
+      window.onunhandledrejection = null;
+      expect(window.onunhandledrejection).toBe(null);
+    });
+
+    it('works when window is set as global', () => {
+      const window = new Window();
+      Window.setGlobalThis(window);
+      const handler = vi.fn();
+      window.onunhandledrejection = handler;
+
+      expect(window.onunhandledrejection).toBe(handler);
+    });
+  });
+});