happy-dom 15.0.0 → 15.1.0

package/src/custom-element/CustomElementRegistry.ts

@@ -1,4 +1,3 @@
-import DOMException from '../exception/DOMException.js';
 import * as PropertySymbol from '../PropertySymbol.js';
 import HTMLElement from '../nodes/html-element/HTMLElement.js';
 import Node from '../nodes/node/Node.js';
@@ -13,7 +12,8 @@ export default class CustomElementRegistry {
 		[k: string]: { elementClass: typeof HTMLElement; extends: string };
 	} = {};
 	public [PropertySymbol.registedClass]: Map<typeof HTMLElement, string> = new Map();
-	public [PropertySymbol.callbacks]: { [k: string]: (() => void)[] } = {};
+	public [PropertySymbol.callbacks]: Map<string, Array<() => void>> = new Map();
+	public [PropertySymbol.destroyed]: boolean = false;
 	#window: BrowserWindow;
 
 	/**
@@ -22,6 +22,9 @@ export default class CustomElementRegistry {
 	 * @param window Window.
 	 */
 	constructor(window: BrowserWindow) {
+		if (!window) {
+			throw new TypeError('Illegal constructor');
+		}
 		this.#window = window;
 	}
 
@@ -38,30 +41,35 @@ export default class CustomElementRegistry {
 		elementClass: typeof HTMLElement,
 		options?: { extends?: string }
 	): void {
+		if (this[PropertySymbol.destroyed]) {
+			return;
+		}
+
 		if (!this.#isValidCustomElementName(name)) {
-			throw new DOMException(
+			throw new this.#window.DOMException(
 				`Failed to execute 'define' on 'CustomElementRegistry': "${name}" is not a valid custom element name`
 			);
 		}
 
 		if (this[PropertySymbol.registry][name]) {
-			throw new DOMException(
+			throw new this.#window.DOMException(
 				`Failed to execute 'define' on 'CustomElementRegistry': the name "${name}" has already been used with this registry`
 			);
 		}
 
 		if (this[PropertySymbol.registedClass].has(elementClass)) {
-			throw new DOMException(
+			throw new this.#window.DOMException(
 				"Failed to execute 'define' on 'CustomElementRegistry': this constructor has already been used with this registry"
 			);
 		}
 
 		const tagName = name.toUpperCase();
 
-		elementClass[PropertySymbol.ownerDocument] = this.#window.document;
-		elementClass[PropertySymbol.tagName] = tagName;
-		elementClass[PropertySymbol.localName] = name;
-		elementClass[PropertySymbol.namespaceURI] = NamespaceURI.html;
+		elementClass.prototype[PropertySymbol.window] = this.#window;
+		elementClass.prototype[PropertySymbol.ownerDocument] = this.#window.document;
+		elementClass.prototype[PropertySymbol.tagName] = tagName;
+		elementClass.prototype[PropertySymbol.localName] = name;
+		elementClass.prototype[PropertySymbol.namespaceURI] = NamespaceURI.html;
 
 		this[PropertySymbol.registry][name] = {
 			elementClass,
@@ -74,9 +82,9 @@ export default class CustomElementRegistry {
 			(name) => String(name).toLowerCase()
 		);
 
-		if (this[PropertySymbol.callbacks][name]) {
-			const callbacks = this[PropertySymbol.callbacks][name];
-			delete this[PropertySymbol.callbacks][name];
+		const callbacks = this[PropertySymbol.callbacks].get(name);
+		if (callbacks) {
+			this[PropertySymbol.callbacks].delete(name);
 			for (const callback of callbacks) {
 				callback();
 			}
@@ -110,15 +118,30 @@ export default class CustomElementRegistry {
 	 * @param name Tag name of element.
 	 */
 	public whenDefined(name: string): Promise<void> {
+		if (this[PropertySymbol.destroyed]) {
+			return Promise.reject(
+				new this.#window.DOMException(
+					`Failed to execute 'whenDefined' on 'CustomElementRegistry': The custom element registry has been destroyed.`
+				)
+			);
+		}
 		if (!this.#isValidCustomElementName(name)) {
-			return Promise.reject(new DOMException(`Invalid custom element name: "${name}"`));
+			return Promise.reject(
+				new this.#window.DOMException(
+					`Failed to execute 'whenDefined' on 'CustomElementRegistry': Invalid custom element name: "${name}"`
+				)
+			);
 		}
 		if (this.get(name)) {
 			return Promise.resolve();
 		}
 		return new Promise((resolve) => {
-			this[PropertySymbol.callbacks][name] = this[PropertySymbol.callbacks][name] || [];
-			this[PropertySymbol.callbacks][name].push(resolve);
+			const callbacks: Array<() => void> = this[PropertySymbol.callbacks].get(name);
+			if (callbacks) {
+				callbacks.push(resolve);
+			} else {
+				this[PropertySymbol.callbacks].set(name, [resolve]);
+			}
 		});
 	}
 
@@ -136,12 +159,17 @@ export default class CustomElementRegistry {
 	 * Destroys the registry.
 	 */
 	public [PropertySymbol.destroy](): void {
+		this[PropertySymbol.destroyed] = true;
 		for (const entity of Object.values(this[PropertySymbol.registry])) {
-			entity.elementClass[PropertySymbol.ownerDocument] = null;
+			entity.elementClass.prototype[PropertySymbol.window] = null;
+			entity.elementClass.prototype[PropertySymbol.ownerDocument] = null;
+			entity.elementClass.prototype[PropertySymbol.tagName] = null;
+			entity.elementClass.prototype[PropertySymbol.localName] = null;
+			entity.elementClass.prototype[PropertySymbol.namespaceURI] = null;
 		}
 		this[PropertySymbol.registry] = {};
 		this[PropertySymbol.registedClass] = new Map();
-		this[PropertySymbol.callbacks] = {};
+		this[PropertySymbol.callbacks] = new Map();
 	}
 
 	/**

package/src/dom-implementation/DOMImplementation.ts

@@ -12,26 +12,34 @@ export default class DOMImplementation {
 	/**
 	 * Constructor.
 	 *
-	 * @param window Window.
+	 * @param document Document.
 	 */
-	constructor(window: Document) {
-		this.#document = window;
+	constructor(document: Document) {
+		this.#document = document;
 	}
 
 	/**
 	 * Creates and returns an XML Document.
 	 *
 	 * TODO: Not fully implemented.
+	 *
+	 * @param _namespaceURI Namespace URI.
+	 * @param _qualifiedName Qualified name.
+	 * @param [_docType] Document type.
 	 */
-	public createDocument(): Document {
-		return new this.#document[PropertySymbol.ownerWindow].HTMLDocument();
+	public createDocument(
+		_namespaceURI: string,
+		_qualifiedName: string,
+		_docType?: string
+	): Document {
+		return new this.#document[PropertySymbol.window].HTMLDocument();
 	}
 
 	/**
 	 * Creates and returns an HTML Document.
 	 */
 	public createHTMLDocument(): Document {
-		return new this.#document[PropertySymbol.ownerWindow].HTMLDocument();
+		return new this.#document[PropertySymbol.window].HTMLDocument();
 	}
 
 	/**
@@ -46,10 +54,7 @@ export default class DOMImplementation {
 		publicId: string,
 		systemId: string
 	): DocumentType {
-		const documentType = NodeFactory.createNode(
-			this.#document,
-			this.#document[PropertySymbol.ownerWindow].DocumentType
-		);
+		const documentType = NodeFactory.createNode<DocumentType>(this.#document, DocumentType);
 
 		documentType[PropertySymbol.name] = qualifiedName;
 		documentType[PropertySymbol.publicId] = publicId;

package/src/dom-parser/DOMParser.ts

@@ -1,7 +1,6 @@
 import Document from '../nodes/document/Document.js';
 import * as PropertySymbol from '../PropertySymbol.js';
 import XMLParser from '../xml-parser/XMLParser.js';
-import DOMException from '../exception/DOMException.js';
 import DocumentFragment from '../nodes/document-fragment/DocumentFragment.js';
 import BrowserWindow from '../window/BrowserWindow.js';
 import NodeTypeEnum from '../nodes/node/NodeTypeEnum.js';
@@ -13,16 +12,8 @@ import NodeTypeEnum from '../nodes/node/NodeTypeEnum.js';
  * https://developer.mozilla.org/en-US/docs/Web/API/DOMParser.
  */
 export default class DOMParser {
-	readonly #window: BrowserWindow;
-
-	/**
-	 * Constructor.
-	 *
-	 * @param window Window.
-	 */
-	constructor(window: BrowserWindow) {
-		this.#window = window;
-	}
+	// Injected by WindowClassExtender
+	protected declare [PropertySymbol.window]: BrowserWindow;
 
 	/**
 	 * Parses HTML and returns a root element.
@@ -33,7 +24,9 @@ export default class DOMParser {
 	 */
 	public parseFromString(string: string, mimeType: string): Document {
 		if (!mimeType) {
-			throw new DOMException('Second parameter "mimeType" is mandatory.');
+			throw new this[PropertySymbol.window].DOMException(
+				'Second parameter "mimeType" is mandatory.'
+			);
 		}
 
 		const newDocument = <Document>this.#createDocument(mimeType);
@@ -107,17 +100,19 @@ export default class DOMParser {
 	 * @returns Document.
 	 */
 	#createDocument(mimeType: string): Document {
+		const window = this[PropertySymbol.window];
+
 		switch (mimeType) {
 			case 'text/html':
-				return new this.#window.HTMLDocument();
+				return new window.HTMLDocument();
 			case 'image/svg+xml':
-				return new this.#window.SVGDocument();
+				return new window.SVGDocument();
 			case 'text/xml':
 			case 'application/xml':
 			case 'application/xhtml+xml':
-				return new this.#window.XMLDocument();
+				return new window.XMLDocument();
 			default:
-				throw new DOMException(`Unknown mime type "${mimeType}".`);
+				throw new window.DOMException(`Unknown mime type "${mimeType}".`);
 		}
 	}
 }

package/src/event/Event.ts

@@ -12,18 +12,19 @@ import Document from '../nodes/document/Document.js';
  * Event.
  */
 export default class Event {
-	public composed: boolean;
-	public bubbles: boolean;
-	public cancelable: boolean;
-	public defaultPrevented = false;
-	public eventPhase: EventPhaseEnum = EventPhaseEnum.none;
-	public timeStamp: number = performance.now();
-	public type: string;
 	public NONE = EventPhaseEnum.none;
 	public CAPTURING_PHASE = EventPhaseEnum.capturing;
 	public AT_TARGET = EventPhaseEnum.atTarget;
 	public BUBBLING_PHASE = EventPhaseEnum.bubbling;
 
+	public [PropertySymbol.composed] = false;
+	public [PropertySymbol.bubbles] = false;
+	public [PropertySymbol.cancelable] = false;
+	public [PropertySymbol.defaultPrevented] = false;
+	public [PropertySymbol.eventPhase] = EventPhaseEnum.none;
+	public [PropertySymbol.timeStamp] = performance.now();
+	public [PropertySymbol.type]: string;
+
 	public [PropertySymbol.immediatePropagationStopped] = false;
 	public [PropertySymbol.propagationStopped] = false;
 	public [PropertySymbol.target]: EventTarget = null;
@@ -37,11 +38,73 @@ export default class Event {
 	 * @param [eventInit] Event init.
 	 */
 	constructor(type: string, eventInit: IEventInit | null = null) {
-		this.type = type;
+		this[PropertySymbol.type] = type;
+		this[PropertySymbol.bubbles] = eventInit?.bubbles ?? false;
+		this[PropertySymbol.cancelable] = eventInit?.cancelable ?? false;
+		this[PropertySymbol.composed] = eventInit?.composed ?? false;
+	}
+
+	/**
+	 * Returns composed.
+	 *
+	 * @returns Composed.
+	 */
+	public get composed(): boolean {
+		return this[PropertySymbol.composed];
+	}
 
-		this.bubbles = eventInit?.bubbles ?? false;
-		this.cancelable = eventInit?.cancelable ?? false;
-		this.composed = eventInit?.composed ?? false;
+	/**
+	 * Returns bubbles.
+	 *
+	 * @returns Bubbles.
+	 */
+	public get bubbles(): boolean {
+		return this[PropertySymbol.bubbles];
+	}
+
+	/**
+	 * Returns cancelable.
+	 *
+	 * @returns Cancelable.
+	 */
+	public get cancelable(): boolean {
+		return this[PropertySymbol.cancelable];
+	}
+
+	/**
+	 * Returns defaultPrevented.
+	 *
+	 * @returns Default prevented.
+	 */
+	public get defaultPrevented(): boolean {
+		return this[PropertySymbol.defaultPrevented];
+	}
+
+	/**
+	 * Returns eventPhase.
+	 *
+	 * @returns Event phase.
+	 */
+	public get eventPhase(): EventPhaseEnum {
+		return this[PropertySymbol.eventPhase];
+	}
+
+	/**
+	 * Returns timeStamp.
+	 *
+	 * @returns Time stamp.
+	 */
+	public get timeStamp(): number {
+		return this[PropertySymbol.timeStamp];
+	}
+
+	/**
+	 * Returns type.
+	 *
+	 * @returns Type.
+	 */
+	public get type(): string {
+		return this[PropertySymbol.type];
 	}
 
 	/**
@@ -92,13 +155,17 @@ export default class Event {
 			if ((<Node>(<unknown>eventTarget)).parentNode) {
 				eventTarget = (<Node>(<unknown>eventTarget)).parentNode;
 			} else if (
-				this.composed &&
+				this[PropertySymbol.composed] &&
 				(<Node>eventTarget)[PropertySymbol.nodeType] === NodeTypeEnum.documentFragmentNode &&
 				(<ShadowRoot>eventTarget).host
 			) {
 				eventTarget = (<ShadowRoot>eventTarget).host;
-			} else if ((<Node>eventTarget)[PropertySymbol.nodeType] === NodeTypeEnum.documentNode) {
-				eventTarget = (<Document>(<unknown>eventTarget))[PropertySymbol.ownerWindow];
+			} else if (
+				(<Node>eventTarget)[PropertySymbol.nodeType] === NodeTypeEnum.documentNode &&
+				// The "load" event is a special case. It should not bubble up to the window.
+				this[PropertySymbol.type] !== 'load'
+			) {
+				eventTarget = (<Document>(<unknown>eventTarget))[PropertySymbol.window];
 			} else {
 				break;
 			}
@@ -116,9 +183,9 @@ export default class Event {
 	 * @param [cancelable=false] "true" if it cancelable.
 	 */
 	public initEvent(type: string, bubbles = false, cancelable = false): void {
-		this.type = type;
-		this.bubbles = bubbles;
-		this.cancelable = cancelable;
+		this[PropertySymbol.type] = type;
+		this[PropertySymbol.bubbles] = bubbles;
+		this[PropertySymbol.cancelable] = cancelable;
 	}
 
 	/**
@@ -126,7 +193,7 @@ export default class Event {
 	 */
 	public preventDefault(): void {
 		if (!this[PropertySymbol.isInPassiveEventListener] && this.cancelable) {
-			this.defaultPrevented = true;
+			this[PropertySymbol.defaultPrevented] = true;
 		}
 	}