happy-dom 16.8.1 → 20.0.2

package/src/event/DataTransfer.ts

@@ -28,10 +28,13 @@ export default class DataTransfer {
 	 * @returns Files.
 	 */
 	public get files(): File[] {
-		const files = [];
+		const files: File[] = [];
 		for (const item of this.items) {
 			if (item.kind === 'file') {
-				files.push(item.getAsFile());
+				const file = item.getAsFile();
+				if (file) {
+					files.push(file);
+				}
 			}
 		}
 		return files;

package/src/event/DataTransferItem.ts

@@ -9,7 +9,7 @@ import File from '../file/File.js';
 export default class DataTransferItem {
 	public readonly kind: 'string' | 'file';
 	public readonly type: string;
-	#item: string | File = null;
+	#item: string | File | null = null;
 
 	/**
 	 * Constructor.
@@ -26,7 +26,7 @@ export default class DataTransferItem {
 	/**
 	 * Returns file.
 	 */
-	public getAsFile(): File {
+	public getAsFile(): File | null {
 		if (this.kind === 'string') {
 			return null;
 		}

package/src/event/Event.ts

@@ -12,10 +12,15 @@ import Document from '../nodes/document/Document.js';
  * Event.
  */
 export default class Event {
-	public NONE = EventPhaseEnum.none;
-	public CAPTURING_PHASE = EventPhaseEnum.capturing;
-	public AT_TARGET = EventPhaseEnum.atTarget;
-	public BUBBLING_PHASE = EventPhaseEnum.bubbling;
+	public static NONE = EventPhaseEnum.none;
+	public static CAPTURING_PHASE = EventPhaseEnum.capturing;
+	public static AT_TARGET = EventPhaseEnum.atTarget;
+	public static BUBBLING_PHASE = EventPhaseEnum.bubbling;
+
+	public NONE = Event.NONE;
+	public CAPTURING_PHASE = Event.CAPTURING_PHASE;
+	public AT_TARGET = Event.AT_TARGET;
+	public BUBBLING_PHASE = Event.BUBBLING_PHASE;
 
 	public [PropertySymbol.composed] = false;
 	public [PropertySymbol.bubbles] = false;
@@ -28,8 +33,8 @@ export default class Event {
 	public [PropertySymbol.dispatching] = false;
 	public [PropertySymbol.immediatePropagationStopped] = false;
 	public [PropertySymbol.propagationStopped] = false;
-	public [PropertySymbol.target]: EventTarget = null;
-	public [PropertySymbol.currentTarget]: EventTarget = null;
+	public [PropertySymbol.target]: EventTarget | null = null;
+	public [PropertySymbol.currentTarget]: EventTarget | null = null;
 	public [PropertySymbol.isInPassiveEventListener] = false;
 
 	/**
@@ -114,7 +119,7 @@ export default class Event {
 	 * @returns Target.
 	 */
 	public get target(): EventTarget {
-		return this[PropertySymbol.target];
+		return this[PropertySymbol.target]!;
 	}
 
 	/**
@@ -123,7 +128,7 @@ export default class Event {
 	 * @returns Target.
 	 */
 	public get currentTarget(): EventTarget {
-		return this[PropertySymbol.currentTarget];
+		return this[PropertySymbol.currentTarget]!;
 	}
 
 	/**
@@ -146,15 +151,15 @@ export default class Event {
 		}
 
 		const composedPath = [];
-		let eventTarget: Node | ShadowRoot | BrowserWindow = <Node | ShadowRoot>(
-			(<unknown>this[PropertySymbol.target])
+		let eventTarget: Node | ShadowRoot | BrowserWindow | null = <Node | ShadowRoot>(
+			this[PropertySymbol.target]
 		);
 
 		while (eventTarget) {
 			composedPath.push(eventTarget);
 
 			if ((<Node>(<unknown>eventTarget)).parentNode) {
-				eventTarget = (<Node>(<unknown>eventTarget)).parentNode;
+				eventTarget = (<Node>(<unknown>eventTarget)).parentNode!;
 			} else if (
 				this[PropertySymbol.composed] &&
 				(<Node>eventTarget)[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode &&

package/src/event/EventTarget.ts

@@ -2,7 +2,6 @@ import * as PropertySymbol from '../PropertySymbol.js';
 import Event from './Event.js';
 import IEventListenerOptions from './IEventListenerOptions.js';
 import EventPhaseEnum from './EventPhaseEnum.js';
-import WindowErrorUtility from '../window/WindowErrorUtility.js';
 import WindowBrowserContext from '../window/WindowBrowserContext.js';
 import BrowserErrorCaptureEnum from '../browser/enums/BrowserErrorCaptureEnum.js';
 import TEventListener from './TEventListener.js';
@@ -46,6 +45,7 @@ export default class EventTarget {
 	 * @param listener Listener.
 	 * @param options An object that specifies characteristics about the event listener.(currently only once)
 	 * @param options.once
+	 * @param options.signal An AbortSignal. The listener will be removed when the given AbortSignal object's abort() method is called.
 	 */
 	public addEventListener(
 		type: string,
@@ -55,11 +55,13 @@ export default class EventTarget {
 		options = typeof options === 'boolean' ? { capture: options } : options || {};
 		const eventPhase = options.capture ? 'capturing' : 'bubbling';
 
-		let listeners: TEventListener[] = this[PropertySymbol.listeners][eventPhase].get(type);
-		let listenerOptions: IEventListenerOptions[] =
-			this[PropertySymbol.listenerOptions][eventPhase].get(type);
+		let listeners: TEventListener[] | undefined =
+			this[PropertySymbol.listeners][eventPhase].get(type);
+		let listenerOptions: IEventListenerOptions[];
 
-		if (!listeners) {
+		if (listeners) {
+			listenerOptions = this[PropertySymbol.listenerOptions][eventPhase].get(type)!;
+		} else {
 			listeners = [];
 			listenerOptions = [];
 			this[PropertySymbol.listeners][eventPhase].set(type, listeners);
@@ -72,6 +74,12 @@ export default class EventTarget {
 
 		listeners.push(listener);
 		listenerOptions.push(options);
+
+		if (options.signal && !options.signal.aborted) {
+			options.signal.addEventListener('abort', () => {
+				this.removeEventListener(type, listener);
+			});
+		}
 	}
 
 	/**
@@ -86,7 +94,7 @@ export default class EventTarget {
 			const index = bubblingListeners.indexOf(listener);
 			if (index !== -1) {
 				bubblingListeners.splice(index, 1);
-				this[PropertySymbol.listenerOptions].bubbling.get(type).splice(index, 1);
+				this[PropertySymbol.listenerOptions].bubbling.get(type)!.splice(index, 1);
 				return;
 			}
 		}
@@ -96,7 +104,7 @@ export default class EventTarget {
 			const index = capturingListeners.indexOf(listener);
 			if (index !== -1) {
 				capturingListeners.splice(index, 1);
-				this[PropertySymbol.listenerOptions].capturing.get(type).splice(index, 1);
+				this[PropertySymbol.listenerOptions].capturing.get(type)!.splice(index, 1);
 			}
 		}
 	}
@@ -116,7 +124,7 @@ export default class EventTarget {
 			(event[PropertySymbol.type] !== 'load' || !event[PropertySymbol.target])
 		) {
 			event[PropertySymbol.dispatching] = true;
-			event[PropertySymbol.target] = this[PropertySymbol.proxy] || this;
+			event[PropertySymbol.target] = (<any>this)[PropertySymbol.proxy] || this;
 
 			this.#goThroughDispatchEventPhases(event);
 
@@ -186,8 +194,8 @@ export default class EventTarget {
 
 		// At target phase
 		event[PropertySymbol.eventPhase] = EventPhaseEnum.atTarget;
-		event[PropertySymbol.currentTarget] = this[PropertySymbol.proxy] || this;
-		event[PropertySymbol.target].dispatchEvent(event);
+		event[PropertySymbol.currentTarget] = (<any>this)[PropertySymbol.proxy] || this;
+		event[PropertySymbol.target]!.dispatchEvent(event);
 
 		// Bubbling phase
 		event[PropertySymbol.eventPhase] = EventPhaseEnum.bubbling;
@@ -228,10 +236,22 @@ export default class EventTarget {
 		const browserSettings = window ? new WindowBrowserContext(window).getSettings() : null;
 		const eventPhase = event.eventPhase === EventPhaseEnum.capturing ? 'capturing' : 'bubbling';
 
-		if (event.eventPhase !== EventPhaseEnum.capturing) {
-			const onEventName = 'on' + event.type.toLowerCase();
+		// We need to clone the arrays because the listeners may remove themselves while we are iterating.
+		const listeners = this[PropertySymbol.listeners][eventPhase].get(event.type)?.slice();
+
+		if (listeners && listeners.length) {
+			const listenerOptions = this[PropertySymbol.listenerOptions][eventPhase]
+				.get(event.type)!
+				.slice();
+
+			for (let i = 0, max = listeners.length; i < max; i++) {
+				const listener = listeners[i];
+				const options = listenerOptions[i];
+
+				if (options?.passive) {
+					event[PropertySymbol.isInPassiveEventListener] = true;
+				}
 
-			if (typeof this[onEventName] === 'function') {
 				// We can end up in a never ending loop if the listener for the error event on Window also throws an error.
 				if (
 					window &&
@@ -239,72 +259,80 @@ export default class EventTarget {
 					!browserSettings?.disableErrorCapturing &&
 					browserSettings?.errorCapture === BrowserErrorCaptureEnum.tryAndCatch
 				) {
-					WindowErrorUtility.captureError(window, this[onEventName].bind(this, event));
+					if ((<TEventListenerObject>listener).handleEvent) {
+						let result: any;
+						try {
+							result = (<TEventListenerObject>listener).handleEvent.call(listener, event);
+						} catch (error) {
+							window[PropertySymbol.dispatchError](<Error>error);
+						}
+
+						if (result instanceof Promise) {
+							result.catch((error) => window[PropertySymbol.dispatchError](error));
+						}
+					} else {
+						let result: any;
+						try {
+							result = (<TEventListenerFunction>listener).call(this, event);
+						} catch (error) {
+							window[PropertySymbol.dispatchError](<Error>error);
+						}
+
+						if (result instanceof Promise) {
+							result.catch((error) => window[PropertySymbol.dispatchError](error));
+						}
+					}
 				} else {
-					this[onEventName].call(this, event);
+					if ((<TEventListenerObject>listener).handleEvent) {
+						(<TEventListenerObject>listener).handleEvent.call(listener, event);
+					} else {
+						(<TEventListenerFunction>listener).call(this, event);
+					}
 				}
-			}
-		}
-
-		// We need to clone the arrays because the listeners may remove themselves while we are iterating.
-		const listeners = this[PropertySymbol.listeners][eventPhase].get(event.type)?.slice();
-
-		if (!listeners) {
-			return;
-		}
-
-		const listenerOptions = this[PropertySymbol.listenerOptions][eventPhase]
-			.get(event.type)
-			?.slice();
 
-		for (let i = 0, max = listeners.length; i < max; i++) {
-			const listener = listeners[i];
-			const options = listenerOptions[i];
-
-			if (options?.passive) {
-				event[PropertySymbol.isInPassiveEventListener] = true;
-			}
+				event[PropertySymbol.isInPassiveEventListener] = false;
 
-			// We can end up in a never ending loop if the listener for the error event on Window also throws an error.
-			if (
-				window &&
-				(this !== <EventTarget>window || event.type !== 'error') &&
-				!browserSettings?.disableErrorCapturing &&
-				browserSettings?.errorCapture === BrowserErrorCaptureEnum.tryAndCatch
-			) {
-				if ((<TEventListenerObject>listener).handleEvent) {
-					WindowErrorUtility.captureError(
-						window,
-						(<TEventListenerObject>listener).handleEvent.bind(listener, event)
-					);
-				} else {
-					WindowErrorUtility.captureError(
-						window,
-						(<TEventListenerFunction>listener).bind(this, event)
-					);
+				if (options?.once) {
+					// At this time, listeners and listenersOptions are cloned arrays. When the original value is deleted,
+					// The value corresponding to the cloned array is not deleted. So we need to delete the value in the cloned array.
+					listeners.splice(i, 1);
+					listenerOptions.splice(i, 1);
+					this.removeEventListener(event.type, listener);
+					i--;
+					max--;
 				}
-			} else {
-				if ((<TEventListenerObject>listener).handleEvent) {
-					(<TEventListenerObject>listener).handleEvent(event);
-				} else {
-					(<TEventListenerFunction>listener).call(this, event);
+
+				if (event[PropertySymbol.immediatePropagationStopped]) {
+					return;
 				}
 			}
+		}
 
-			event[PropertySymbol.isInPassiveEventListener] = false;
-
-			if (options?.once) {
-				// At this time, listeners and listenersOptions are cloned arrays. When the original value is deleted,
-				// The value corresponding to the cloned array is not deleted. So we need to delete the value in the cloned array.
-				listeners.splice(i, 1);
-				listenerOptions.splice(i, 1);
-				this.removeEventListener(event.type, listener);
-				i--;
-				max--;
-			}
+		if (event.eventPhase !== EventPhaseEnum.capturing) {
+			const onEventName = 'on' + event.type.toLowerCase();
+			const eventListener = (<any>this)[onEventName];
 
-			if (event[PropertySymbol.immediatePropagationStopped]) {
-				return;
+			if (typeof eventListener === 'function') {
+				// We can end up in a never ending loop if the listener for the error event on Window also throws an error.
+				if (
+					window &&
+					(this !== <EventTarget>window || event.type !== 'error') &&
+					!browserSettings?.disableErrorCapturing &&
+					browserSettings?.errorCapture === BrowserErrorCaptureEnum.tryAndCatch
+				) {
+					let result: any;
+					try {
+						result = eventListener(event);
+					} catch (error) {
+						window[PropertySymbol.dispatchError](<Error>error);
+					}
+
+					if (result instanceof Promise) {
+						result.catch((error) => window[PropertySymbol.dispatchError](error));
+					}
+				} else {
+					eventListener(event);
+				}
 			}
 		}
 	}

package/src/event/IEventListenerOptions.ts

@@ -1,8 +1,10 @@
+import AbortSignal from '../fetch/AbortSignal.js';
+
 export default interface IEventListenerOptions {
 	once?: boolean;
 
 	// TODO: Not implemented yet.
 	capture?: boolean;
 	passive?: boolean;
-	signal?: unknown;
+	signal?: AbortSignal;
 }

package/src/event/events/CustomEvent.ts

@@ -43,7 +43,7 @@ export default class CustomEvent extends Event {
 		type: string,
 		bubbles = false,
 		cancelable = false,
-		detail: object = null
+		detail: object | null = null
 	): void {
 		this[PropertySymbol.type] = type;
 		this[PropertySymbol.bubbles] = bubbles;

package/src/event/events/IFocusEventInit.ts

@@ -2,5 +2,5 @@ import EventTarget from '../EventTarget.js';
 import IUIEventInit from '../IUIEventInit.js';
 
 export default interface IFocusEventInit extends IUIEventInit {
-	relatedTarget?: EventTarget;
+	relatedTarget?: EventTarget | null;
 }

package/src/event/events/IMouseEventInit.ts

@@ -12,6 +12,8 @@ export default interface IMouseEventInit extends IUIEventInit {
 	metaKey?: boolean;
 	movementX?: number;
 	movementY?: number;
+	offsetX?: number;
+	offsetY?: number;
 	button?: number;
 	buttons?: number;
 	relatedTarget?: EventTarget;

package/src/event/events/IPopStateEventInit.ts

@@ -0,0 +1,6 @@
+import IEventInit from '../IEventInit.js';
+
+export default interface IPopStateEventInit extends IEventInit {
+	state?: object | null;
+	hasUAVisualTransition?: boolean;
+}

package/src/event/events/InputEvent.ts

@@ -7,7 +7,7 @@ import IInputEventInit from './IInputEventInit.js';
  */
 export default class InputEvent extends UIEvent {
 	public readonly data: string;
-	public readonly dataTransfer: DataTransfer;
+	public readonly dataTransfer: DataTransfer | null;
 	public readonly inputType: string;
 	public readonly isComposing: boolean;
 

package/src/event/events/KeyboardEvent.ts

@@ -44,4 +44,31 @@ export default class KeyboardEvent extends UIEvent {
 		this.shiftKey = eventInit?.shiftKey ?? false;
 		this.keyCode = eventInit?.keyCode ?? 0;
 	}
+
+	/**
+	 * Returns the state of a modifier key.
+	 *
+	 * @param key A modifier key value.
+	 * @returns True if it's pressed, false otherwise.
+	 */
+	public getModifierState(key: string): boolean {
+		if (arguments.length < 1) {
+			throw new TypeError(
+				"Failed to execute 'getModifierState' on 'KeyboardEvent': 1 argument required, but only 0 present."
+			);
+		}
+		switch (String(key).toLowerCase()) {
+			case 'alt':
+			case 'altgraph':
+				return this.altKey;
+			case 'control':
+				return this.ctrlKey;
+			case 'meta':
+				return this.metaKey;
+			case 'shift':
+				return this.shiftKey;
+			default:
+				return false;
+		}
+	}
 }

package/src/event/events/MouseEvent.ts

@@ -41,6 +41,8 @@ export default class MouseEvent extends UIEvent {
 		this.metaKey = eventInit?.metaKey ?? false;
 		this.movementX = eventInit?.movementX ?? 0;
 		this.movementY = eventInit?.movementY ?? 0;
+		this.offsetX = eventInit?.offsetX ?? 0;
+		this.offsetY = eventInit?.offsetY ?? 0;
 		this.region = eventInit?.region ?? '';
 		this.relatedTarget = eventInit?.relatedTarget ?? null;
 		this.screenX = eventInit?.screenX ?? 0;

package/src/event/events/PopStateEvent.ts

@@ -0,0 +1,23 @@
+import Event from '../Event.js';
+import IPopStateEventInit from './IPopStateEventInit.js';
+
+/**
+ *
+ */
+export default class PopStateEvent extends Event {
+	public readonly state: object | null;
+	public readonly hasUAVisualTransition: boolean;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param type Event type.
+	 * @param [eventInit] Event init.
+	 */
+	constructor(type: string, eventInit: IPopStateEventInit | null = null) {
+		super(type);
+
+		this.state = eventInit?.state ?? null;
+		this.hasUAVisualTransition = eventInit?.hasUAVisualTransition ?? false;
+	}
+}

package/src/exception/DOMException.ts

@@ -13,7 +13,7 @@ export default class DOMException extends Error {
 	 * @param message Message.
 	 * @param name Name.
 	 */
-	constructor(message: string, name: string = null) {
+	constructor(message: string, name: string | null = null) {
 		super(message);
 
 		this.name = name || DOMExceptionNameEnum.domException;

package/src/exception/DOMExceptionNameEnum.ts

@@ -17,6 +17,7 @@ enum DOMExceptionNameEnum {
 	timeoutError = 'TimeoutError',
 	encodingError = 'EncodingError',
 	uriMismatchError = 'URIMismatchError',
-	inUseAttributeError = 'InUseAttributeError'
+	inUseAttributeError = 'InUseAttributeError',
+	namespaceError = 'NamespaceError'
 }
 export default DOMExceptionNameEnum;

package/src/fetch/AbortController.ts

@@ -19,7 +19,7 @@ export default class AbortController {
 	 *
 	 * @param [reason] Reason.
 	 */
-	public abort(reason?: Error): void {
+	public abort(reason?: any): void {
 		this.signal[PropertySymbol.abort](reason);
 	}
 }

package/src/fetch/AbortSignal.ts

@@ -14,9 +14,9 @@ export default class AbortSignal extends EventTarget {
 	protected declare static [PropertySymbol.window]: BrowserWindow;
 	protected declare [PropertySymbol.window]: BrowserWindow;
 
-	// Public properties
-	public readonly aborted: boolean = false;
-	public readonly reason: Error | null = null;
+	// Internal properties
+	public [PropertySymbol.aborted]: boolean = false;
+	public [PropertySymbol.reason]: any = undefined;
 
 	// Events
 	public onabort: ((this: AbortSignal, event: Event) => void) | null = null;
@@ -28,9 +28,7 @@ export default class AbortSignal extends EventTarget {
 		super();
 
 		if (!this[PropertySymbol.window]) {
-			throw new TypeError(
-				`Failed to construct '${this.constructor.name}': '${this.constructor.name}' was constructed outside a Window context.`
-			);
+			throw new TypeError(`Failed to construct 'AbortSignal': Illegal constructor`);
 		}
 	}
 
@@ -41,22 +39,59 @@ export default class AbortSignal extends EventTarget {
 		return 'AbortSignal';
 	}
 
+	/**
+	 * Returns true if the signal has been aborted.
+	 *
+	 * @returns True if the signal has been aborted.
+	 */
+	public get aborted(): boolean {
+		return this[PropertySymbol.aborted];
+	}
+
+	/**
+	 * Setter for aborted. Value will be ignored as the property is read-only.
+	 *
+	 * @param _value Aborted.
+	 */
+	public set aborted(_value: boolean) {
+		// Do nothing
+	}
+
+	/**
+	 * Returns the reason the signal was aborted.
+	 *
+	 * @returns Reason.
+	 */
+	public get reason(): any {
+		return this[PropertySymbol.reason];
+	}
+
+	/**
+	 * Setter for reason. Value will be ignored as the property is read-only.
+	 *
+	 * @param _value Reason.
+	 */
+	public set reason(_value: any) {
+		// Do nothing
+	}
+
 	/**
 	 * Aborts the signal.
 	 *
 	 * @param [reason] Reason.
 	 */
-	public [PropertySymbol.abort](reason?: Error): void {
+	public [PropertySymbol.abort](reason?: any): void {
 		if (this.aborted) {
 			return;
 		}
-		(<Error>this.reason) =
-			reason ||
-			new this[PropertySymbol.window].DOMException(
-				'signal is aborted without reason',
-				DOMExceptionNameEnum.abortError
-			);
-		(<boolean>this.aborted) = true;
+		this[PropertySymbol.reason] =
+			reason !== undefined
+				? reason
+				: new this[PropertySymbol.window].DOMException(
+						'signal is aborted without reason',
+						DOMExceptionNameEnum.abortError
+					);
+		this[PropertySymbol.aborted] = true;
 		this.dispatchEvent(new Event('abort'));
 	}
 
@@ -75,15 +110,16 @@ export default class AbortSignal extends EventTarget {
 	 * @param [reason] Reason.
 	 * @returns AbortSignal instance.
 	 */
-	public static abort(reason?: Error): AbortSignal {
+	public static abort(reason?: any): AbortSignal {
 		const signal = new this();
-		(<Error>signal.reason) =
-			reason ||
-			new this[PropertySymbol.window].DOMException(
-				'signal is aborted without reason',
-				DOMExceptionNameEnum.abortError
-			);
-		(<boolean>signal.aborted) = true;
+		signal[PropertySymbol.reason] =
+			reason !== undefined
+				? reason
+				: new this[PropertySymbol.window].DOMException(
+						'signal is aborted without reason',
+						DOMExceptionNameEnum.abortError
+					);
+		signal[PropertySymbol.aborted] = true;
 		return signal;
 	}
 
@@ -118,8 +154,8 @@ export default class AbortSignal extends EventTarget {
 	 */
 	public static any(signals: AbortSignal[]): AbortSignal {
 		for (const signal of signals) {
-			if (signal.aborted) {
-				return this.abort(signal.reason);
+			if (signal[PropertySymbol.aborted]) {
+				return this.abort(signal[PropertySymbol.reason]);
 			}
 		}
 
@@ -128,14 +164,14 @@ export default class AbortSignal extends EventTarget {
 
 		const stopListening = (): void => {
 			for (const signal of signals) {
-				signal.removeEventListener('abort', handlers.get(signal));
+				signal.removeEventListener('abort', handlers.get(signal)!);
 			}
 		};
 
 		for (const signal of signals) {
 			const handler = (): void => {
 				stopListening();
-				anySignal[PropertySymbol.abort](signal.reason);
+				anySignal[PropertySymbol.abort](signal[PropertySymbol.reason]);
 			};
 			handlers.set(signal, handler);
 			signal.addEventListener('abort', handler);