happy-dom 2.49.2 → 2.51.1

package/src/async-task-manager/AsyncTaskManager.ts

@@ -0,0 +1,128 @@
+/**
+ * Handles async tasks.
+ */
+export default class AsyncTaskManager {
+	private static taskID = 0;
+	private runningTasks: number[] = [];
+	private runningTimers: NodeJS.Timeout[] = [];
+	private queue: { resolve: () => void; reject: (error: Error) => void }[] = [];
+
+	/**
+	 * Returns a promise that is fulfilled when async tasks are complete.
+	 * This method is not part of the HTML standard.
+	 *
+	 * @returns Promise.
+	 */
+	public async whenComplete(): Promise<void> {
+		return new Promise((resolve, reject) => {
+			const timerID = global.setTimeout(() => {
+				this.endTimer(timerID);
+			}, 0);
+			this.startTimer(timerID);
+			this.queue.push({ resolve, reject });
+		});
+	}
+
+	/**
+	 * Cancels all tasks.
+	 *
+	 * @param [error] Error.
+	 */
+	public cancelAll(error?: Error): void {
+		for (const timerID of this.runningTimers) {
+			global.clearTimeout(timerID);
+		}
+
+		const promises = this.queue;
+
+		this.runningTasks = [];
+		this.runningTimers = [];
+		this.queue = [];
+
+		for (const promise of promises) {
+			if (error) {
+				promise.reject(error);
+			} else {
+				promise.resolve();
+			}
+		}
+	}
+
+	/**
+	 * Starts a timer.
+	 *
+	 * @param timerID Timer ID.
+	 */
+	public startTimer(timerID: NodeJS.Timeout): void {
+		this.runningTimers.push(timerID);
+	}
+
+	/**
+	 * Ends a timer.
+	 *
+	 * @param timerID Timer ID.
+	 */
+	public endTimer(timerID: NodeJS.Timeout): void {
+		const index = this.runningTimers.indexOf(timerID);
+		if (index !== -1) {
+			this.runningTimers.splice(index, 1);
+		}
+		if (!this.runningTasks.length && !this.runningTimers.length) {
+			this.cancelAll();
+		}
+	}
+
+	/**
+	 * Starts an async task.
+	 *
+	 * @returns Task ID.
+	 */
+	public startTask(): number {
+		const taskID = this.newTaskID();
+		this.runningTasks.push(taskID);
+		return taskID;
+	}
+
+	/**
+	 * Ends an async task.
+	 *
+	 * @param taskID Task ID.
+	 */
+	public endTask(taskID: number): void {
+		const index = this.runningTasks.indexOf(taskID);
+		if (index !== -1) {
+			this.runningTasks.splice(index, 1);
+		}
+		if (!this.runningTasks.length && !this.runningTimers.length) {
+			this.cancelAll();
+		}
+	}
+
+	/**
+	 * Returns the amount of running tasks.
+	 *
+	 * @returns Count.
+	 */
+	public getTaskCount(): number {
+		return this.runningTasks.length;
+	}
+
+	/**
+	 * Returns the amount of running timers.
+	 *
+	 * @returns Count.
+	 */
+	public getTimerCount(): number {
+		return this.runningTimers.length;
+	}
+
+	/**
+	 * Returns a new task ID.
+	 *
+	 * @returns Task ID.
+	 */
+	private newTaskID(): number {
+		(<typeof AsyncTaskManager>this.constructor).taskID++;
+		return (<typeof AsyncTaskManager>this.constructor).taskID;
+	}
+}

package/src/cookie/CookieUtility.ts

@@ -14,10 +14,7 @@ export default class CookieUtility {
 	 */
 	public static getCookieString(location: Location, cookies: string, newCookie): string {
 		const newCookieParts = newCookie.split(';');
-		const [newCookieName, newCookieValue] = newCookieParts
-			.shift()
-			.trim()
-			.split('=');
+		const [newCookieName, newCookieValue] = newCookieParts.shift().trim().split('=');
 		let isExpired = false;
 
 		for (const part of newCookieParts) {

package/src/custom-element/CustomElementRegistry.ts

@@ -84,7 +84,7 @@ export default class CustomElementRegistry {
 		if (this.get(upperTagName)) {
 			return Promise.resolve();
 		}
-		return new Promise(resolve => {
+		return new Promise((resolve) => {
 			this._callbacks[upperTagName] = this._callbacks[upperTagName] || [];
 			this._callbacks[upperTagName].push(resolve);
 		});

package/src/dom-token-list/DOMTokenList.ts

@@ -84,8 +84,6 @@ export default class DOMTokenList implements IDOMTokenList {
 
 	/**
 	 * Returns an iterator, allowing you to go through all values of the key/value pairs contained in this object.
-	 *
-	 *
 	 */
 	public values(): IterableIterator<string> {
 		const attr = this._ownerElement.getAttributeNS(null, this._attributeName);
@@ -94,8 +92,6 @@ export default class DOMTokenList implements IDOMTokenList {
 
 	/**
 	 * Returns an iterator, allowing you to go through all key/value pairs contained in this object.
-	 *
-	 *
 	 */
 	public entries(): IterableIterator<[number, string]> {
 		const attr = this._ownerElement.getAttributeNS(null, this._attributeName);

package/src/fetch/FetchHandler.ts

@@ -0,0 +1,54 @@
+import RelativeURL from '../location/RelativeURL';
+import IRequestInit from './IRequestInit';
+import IDocument from '../nodes/document/IDocument';
+import IResponse from './IResponse';
+
+/**
+ * Helper class for performing fetch.
+ */
+export default class FetchHandler {
+	/**
+	 * Returns resource data asynchonously.
+	 *
+	 * @param document Document.
+	 * @param url URL to resource.
+	 * @param [init] Init.
+	 * @returns Response.
+	 */
+	public static fetch(document: IDocument, url: string, init?: IRequestInit): Promise<IResponse> {
+		// We want to only load NodeFetch when it is needed to improve performance and not have direct dependencies to server side packages.
+		const nodeFetch = require('node-fetch');
+		const Response = require('./Response').default;
+		const taskManager = document.defaultView.happyDOM.asyncTaskManager;
+
+		return new Promise((resolve, reject) => {
+			const taskID = taskManager.startTask();
+
+			nodeFetch(RelativeURL.getAbsoluteURL(document.defaultView.location, url), init)
+				.then((response) => {
+					if (taskManager.getTaskCount() === 0) {
+						reject(new Error('Failed to complete fetch request. Task was canceled.'));
+					} else {
+						response.constructor['_ownerDocument'] = document;
+
+						for (const key of Object.keys(Response.prototype)) {
+							if (Response.prototype.hasOwnProperty(key) && key !== 'constructor') {
+								if (typeof Response.prototype[key] === 'function') {
+									response[key] = Response.prototype[key].bind(response);
+								} else {
+									response[key] = Response.prototype[key];
+								}
+							}
+						}
+
+						taskManager.endTask(taskID);
+						resolve(response);
+					}
+				})
+				.catch((error) => {
+					reject(error);
+					taskManager.cancelAll(error);
+				});
+		});
+	}
+}

package/src/fetch/Headers.ts

@@ -0,0 +1,7 @@
+import * as NodeFetch from 'node-fetch';
+import IHeaders from './IHeaders';
+
+/**
+ * Fetch headers.
+ */
+export default class Headers extends NodeFetch.Headers implements IHeaders {}

package/src/fetch/IAbortSignal.ts

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Abort signal.
+ */
+export default interface IAbortSignal {
+	aborted: boolean;
+
+	addEventListener: (
+		type: 'abort',
+		listener: (this: IAbortSignal, event: any) => any,
+		options?:
+			| boolean
+			| {
+					capture?: boolean | undefined;
+					once?: boolean | undefined;
+					passive?: boolean | undefined;
+			  }
+	) => void;
+
+	removeEventListener: (
+		type: 'abort',
+		listener: (this: IAbortSignal, event: any) => any,
+		options?:
+			| boolean
+			| {
+					capture?: boolean | undefined;
+			  }
+	) => void;
+
+	dispatchEvent: (event: any) => boolean;
+
+	onabort: null | ((this: IAbortSignal, event: any) => void);
+}

package/src/fetch/IBody.ts

@@ -0,0 +1,18 @@
+import IBlob from '../file/IBlob';
+
+/**
+ * Fetch response.
+ */
+export default interface IBody {
+	readonly body: NodeJS.ReadableStream;
+	readonly bodyUsed: boolean;
+	readonly size: number;
+	readonly timeout: number;
+
+	arrayBuffer(): Promise<ArrayBuffer>;
+	blob(): Promise<IBlob>;
+	buffer(): Promise<Buffer>;
+	json(): Promise<unknown>;
+	text(): Promise<string>;
+	textConverted(): Promise<string>;
+}

package/src/fetch/IHeaders.ts

@@ -0,0 +1,18 @@
+/**
+ * Fetch headers.
+ */
+export default interface IHeaders extends Iterable<[string, string]> {
+	forEach(callback: (value: string, name: string) => void): void;
+	append(name: string, value: string): void;
+	delete(name: string): void;
+	get(name: string): string | null;
+	has(name: string): boolean;
+	raw(): { [k: string]: string[] };
+	set(name: string, value: string): void;
+
+	// Iterable methods
+	entries(): IterableIterator<[string, string]>;
+	keys(): IterableIterator<string>;
+	values(): IterableIterator<string>;
+	[Symbol.iterator](): Iterator<[string, string]>;
+}

package/src/fetch/IHeadersInit.ts

@@ -0,0 +1,5 @@
+import IHeaders from './IHeaders';
+
+type IHeadersInit = string[][] | { [key: string]: string } | IHeaders;
+
+export default IHeadersInit;

package/src/fetch/IRequest.ts

@@ -0,0 +1,59 @@
+import IHeaders from './IHeaders';
+import IBody from './IBody';
+
+/**
+ * Fetch request.
+ */
+export default interface IRequest extends IBody {
+	readonly headers: IHeaders;
+	readonly method: string;
+	readonly redirect: 'error' | 'follow' | 'manual';
+	readonly referrer: string;
+	readonly url: string;
+
+	/**
+	 * Returns a clone.
+	 *
+	 * @returns Clone.
+	 */
+	clone(): IRequest;
+
+	// Not implemented:
+	// Readonly cache: 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload';
+	// Readonly credentials: 'include' | 'omit' | 'same-origin';
+	// Readonly destination:
+	// 	| ''
+	// 	| 'object'
+	// 	| 'audio'
+	// 	| 'audioworklet'
+	// 	| 'document'
+	// 	| 'embed'
+	// 	| 'font'
+	// 	| 'frame'
+	// 	| 'iframe'
+	// 	| 'image'
+	// 	| 'manifest'
+	// 	| 'paintworklet'
+	// 	| 'report'
+	// 	| 'script'
+	// 	| 'sharedworker'
+	// 	| 'style'
+	// 	| 'track'
+	// 	| 'video'
+	// 	| 'worker'
+	// 	| 'xslt';
+	// Readonly referrerPolicy:
+	// 	| ''
+	// 	| 'same-origin'
+	// 	| 'no-referrer'
+	// 	| 'no-referrer-when-downgrade'
+	// 	| 'origin'
+	// 	| 'origin-when-cross-origin'
+	// 	| 'strict-origin'
+	// 	| 'strict-origin-when-cross-origin'
+	// 	| 'unsafe-url';
+	// Readonly signal: AbortSignal;
+	// Readonly integrity: string;
+	// Readonly keepalive: boolean;
+	// Readonly mode: 'same-origin' | 'cors' | 'navigate' | 'no-cors';
+}

package/src/fetch/IRequestInit.ts

@@ -0,0 +1,41 @@
+import IHeadersInit from './IHeadersInit';
+import IAbortSignal from './IAbortSignal';
+import { URLSearchParams } from 'url';
+import IFormData from '../form-data/IFormData';
+
+/**
+ * Fetch request init.
+ */
+export default interface IRequestInit {
+	body?:
+		| ArrayBuffer
+		| ArrayBufferView
+		| NodeJS.ReadableStream
+		| string
+		| URLSearchParams
+		| IFormData
+		| null;
+	headers?: IHeadersInit;
+	method?: string;
+	redirect?: 'error' | 'manual' | 'follow';
+	signal?: IAbortSignal | null;
+
+	// Not implemented:
+	// Cache?: 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload';
+	// Credentials?: 'include' | 'omit' | 'same-origin';
+	// Integrity?: string;
+	// Keepalive?: boolean;
+	// Mode?: 'same-origin' | 'cors' | 'navigate' | 'no-cors';
+	// Referrer?: string;
+	// ReferrerPolicy?:
+	// 	| ''
+	// 	| 'same-origin'
+	// 	| 'no-referrer'
+	// 	| 'no-referrer-when-downgrade'
+	// 	| 'origin'
+	// 	| 'origin-when-cross-origin'
+	// 	| 'strict-origin'
+	// 	| 'strict-origin-when-cross-origin'
+	// 	| 'unsafe-url';
+	// Window?: unknown;
+}

package/src/fetch/IResponse.ts

@@ -0,0 +1,22 @@
+import IHeaders from './IHeaders';
+import IBody from './IBody';
+
+/**
+ * Fetch response.
+ */
+export default interface IResponse extends IBody {
+	readonly headers: IHeaders;
+	readonly ok: boolean;
+	readonly redirected: boolean;
+	readonly status: number;
+	readonly statusText: string;
+	readonly type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
+	readonly url: string;
+
+	/**
+	 * Returns a clone.
+	 *
+	 * @returns Clone.
+	 */
+	clone(): IResponse;
+}

package/src/fetch/IResponseInit.ts

@@ -0,0 +1,10 @@
+import IHeaders from './IHeaders';
+
+/**
+ * Response init.
+ */
+export default interface IResponseInit {
+	headers?: IHeaders | string[][] | Record<string, string>;
+	status?: number;
+	statusText?: string;
+}

package/src/fetch/Request.ts

@@ -0,0 +1,149 @@
+import * as NodeFetch from 'node-fetch';
+import IRequest from './IRequest';
+import IBlob from '../file/IBlob';
+import IDocument from '../nodes/document/IDocument';
+
+/**
+ * Fetch request.
+ */
+export default class Request extends NodeFetch.Request implements IRequest {
+	public static _ownerDocument: IDocument = null;
+
+	/**
+	 * Returns array buffer.
+	 *
+	 * @returns Array buffer.
+	 */
+	public arrayBuffer(): Promise<ArrayBuffer> {
+		return new Promise((resolve, reject) => {
+			const taskID = this._handlePromiseStart();
+			super
+				.arrayBuffer()
+				.then(this._handlePromiseEnd.bind(this, resolve, reject, taskID))
+				.catch(this._handlePromiseError.bind(this, reject));
+		});
+	}
+
+	/**
+	 * Returns blob.
+	 *
+	 * @returns Blob.
+	 */
+	public blob(): Promise<IBlob> {
+		return new Promise((resolve, reject) => {
+			const taskID = this._handlePromiseStart();
+			super
+				.blob()
+				.then(this._handlePromiseEnd.bind(this, resolve, reject, taskID))
+				.catch(this._handlePromiseError.bind(this, reject));
+		});
+	}
+
+	/**
+	 * Returns buffer.
+	 *
+	 * @returns Buffer.
+	 */
+	public buffer(): Promise<Buffer> {
+		return new Promise((resolve, reject) => {
+			const taskID = this._handlePromiseStart();
+			super
+				.buffer()
+				.then(this._handlePromiseEnd.bind(this, resolve, reject, taskID))
+				.catch(this._handlePromiseError.bind(this, reject));
+		});
+	}
+
+	/**
+	 * Returns json.
+	 *
+	 * @returns JSON.
+	 */
+	public json(): Promise<unknown> {
+		return new Promise((resolve, reject) => {
+			const taskID = this._handlePromiseStart();
+			super
+				.json()
+				.then(this._handlePromiseEnd.bind(this, resolve, reject, taskID))
+				.catch(this._handlePromiseError.bind(this, reject));
+		});
+	}
+
+	/**
+	 * Returns json.
+	 *
+	 * @returns JSON.
+	 */
+	public text(): Promise<string> {
+		return new Promise((resolve, reject) => {
+			const taskID = this._handlePromiseStart();
+			super
+				.text()
+				.then(this._handlePromiseEnd.bind(this, resolve, reject, taskID))
+				.catch(this._handlePromiseError.bind(this, reject));
+		});
+	}
+
+	/**
+	 * Returns json.
+	 *
+	 * @returns JSON.
+	 */
+	public textConverted(): Promise<string> {
+		return new Promise((resolve, reject) => {
+			const taskID = this._handlePromiseStart();
+			super
+				.textConverted()
+				.then(this._handlePromiseEnd.bind(this, resolve, reject, taskID))
+				.catch(this._handlePromiseError.bind(this, reject));
+		});
+	}
+
+	/**
+	 * Handles promise start.
+	 *
+	 * @returns Task ID.
+	 */
+	private _handlePromiseStart(): number {
+		const taskManager = (<typeof Request>this.constructor)._ownerDocument.defaultView.happyDOM
+			.asyncTaskManager;
+		return taskManager.startTask();
+	}
+
+	/**
+	 * Handles promise end.
+	 *
+	 * @param resolve Resolve.
+	 * @param reject Reject.
+	 * @param taskID Task ID.
+	 * @param response Response.
+	 */
+	private _handlePromiseEnd(
+		resolve: (response: unknown) => void,
+		reject: (error: Error) => void,
+		taskID: number,
+		response: unknown
+	): void {
+		const taskManager = (<typeof Request>this.constructor)._ownerDocument.defaultView.happyDOM
+			.asyncTaskManager;
+		if (taskManager.getTaskCount() === 0) {
+			reject(new Error('Failed to complete fetch request. Task was canceled.'));
+		} else {
+			resolve(response);
+			taskManager.endTask(taskID);
+		}
+	}
+
+	/**
+	 * Handles promise error.
+	 *
+	 * @param error
+	 * @param reject
+	 */
+	private _handlePromiseError(reject: (error: Error) => void, error: Error): void {
+		const taskManager = (<typeof Request>this.constructor)._ownerDocument.defaultView.happyDOM
+			.asyncTaskManager;
+		reject(error);
+		taskManager.cancelAll(error);
+	}
+}

package/src/fetch/ResourceFetchHandler.ts

@@ -0,0 +1,47 @@
+import RelativeURL from '../location/RelativeURL';
+import DOMException from '../exception/DOMException';
+import IDocument from '../nodes/document/IDocument';
+
+/**
+ * Helper class for performing fetch of resources.
+ */
+export default class ResourceFetchHandler {
+	/**
+	 * Returns resource data asynchonously.
+	 *
+	 * @param document Document.
+	 * @param url URL.
+	 * @returns Response.
+	 */
+	public static async fetch(document: IDocument, url: string): Promise<string> {
+		const response = await document.defaultView.fetch(url);
+		if (!response.ok) {
+			throw new DOMException(
+				`Failed to perform request to "${url}". Status code: ${response.status}`
+			);
+		}
+		return await response.text();
+	}
+
+	/**
+	 * Returns resource data synchonously.
+	 *
+	 * @param document Document.
+	 * @param url URL.
+	 * @returns Response.
+	 */
+	public static fetchSync(document: IDocument, url: string): string {
+		// We want to only load SyncRequest when it is needed to improve performance and not have direct dependencies to server side packages.
+		const syncRequest = require('sync-request');
+		const absoluteURL = RelativeURL.getAbsoluteURL(document.defaultView.location, url);
+		const response = syncRequest('GET', absoluteURL);
+
+		if (response.isError()) {
+			throw new DOMException(
+				`Failed to perform request to "${absoluteURL}". Status code: ${response.statusCode}`
+			);
+		}
+
+		return response.getBody();
+	}
+}