happy-dom 8.9.0 → 9.0.0

package/src/fetch/Headers.ts

@@ -1,7 +1,155 @@
-import * as NodeFetch from 'node-fetch';
-import IHeaders from './IHeaders';
+import DOMException from '../exception/DOMException';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum';
+import IHeaders from './types/IHeaders';
+import IHeadersInit from './types/IHeadersInit';
 
 /**
  * Fetch headers.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Headers
  */
-export default class Headers extends NodeFetch.Headers implements IHeaders {}
+export default class Headers implements IHeaders {
+	public _entries: { [k: string]: { name: string; value: string } } = {};
+
+	/**
+	 * Constructor.
+	 *
+	 * @param init Headers init.
+	 */
+	constructor(init?: IHeadersInit) {
+		if (init) {
+			if (init instanceof Headers) {
+				this._entries = JSON.parse(JSON.stringify(init._entries));
+			} else if (Array.isArray(init)) {
+				for (const entry of init) {
+					if (entry.length !== 2) {
+						throw new DOMException(
+							'Failed to construct "Headers": The provided init is not a valid array.',
+							DOMExceptionNameEnum.invalidStateError
+						);
+					}
+					this.append(entry[0], entry[1]);
+				}
+			} else {
+				for (const name of Object.keys(init)) {
+					this.set(name, init[name]);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Appends a new value onto an existing header inside a Headers object, or adds the header if it does not already exist.
+	 *
+	 * @param name Name.
+	 * @param value Value.
+	 */
+	public append(name: string, value: string): void {
+		const lowerName = name.toLowerCase();
+		if (this._entries[lowerName]) {
+			this._entries[lowerName].value += `, ${value}`;
+		} else {
+			this._entries[lowerName] = {
+				name,
+				value
+			};
+		}
+	}
+
+	/**
+	 * Removes an header.
+	 *
+	 * @param name Name.
+	 */
+	public delete(name: string): void {
+		delete this._entries[name.toLowerCase()];
+	}
+
+	/**
+	 * Returns header value.
+	 *
+	 * @param name Name.
+	 * @returns Value.
+	 */
+	public get(name: string): string | null {
+		return this._entries[name.toLowerCase()]?.value || null;
+	}
+
+	/**
+	 * Sets a new value for an existing header inside a Headers object, or adds the header if it does not already exist.
+	 *
+	 * @param name Name.
+	 * @param value Value.
+	 */
+	public set(name: string, value: string): void {
+		this._entries[name.toLowerCase()] = {
+			name,
+			value
+		};
+	}
+
+	/**
+	 * Returns whether an Headers object contains a certain key.
+	 *
+	 * @param name Name.
+	 * @returns "true" if the Headers object contains the key.
+	 */
+	public has(name: string): boolean {
+		return !!this._entries[name.toLowerCase()];
+	}
+
+	/**
+	 * Executes a callback function once per each key/value pair in the Headers object.
+	 *
+	 * @param callback Callback.
+	 */
+	public forEach(callback: (name: string, value: string, thisArg: IHeaders) => void): void {
+		for (const key of Object.keys(this._entries)) {
+			callback(this._entries[key].value, this._entries[key].name, this);
+		}
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all keys of the key/value pairs contained in this object.
+	 *
+	 * @returns Iterator.
+	 */
+	public *keys(): IterableIterator<string> {
+		for (const header of Object.values(this._entries)) {
+			yield header.name;
+		}
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all values of the key/value pairs contained in this object.
+	 *
+	 * @returns Iterator.
+	 */
+	public *values(): IterableIterator<string> {
+		for (const header of Object.values(this._entries)) {
+			yield header.value;
+		}
+	}
+
+	/**
+	 * Returns an iterator, allowing you to go through all key/value pairs contained in this object.
+	 *
+	 * @returns Iterator.
+	 */
+	public *entries(): IterableIterator<[string, string]> {
+		for (const header of Object.values(this._entries)) {
+			yield [header.name, header.value];
+		}
+	}
+
+	/**
+	 * Iterator.
+	 *
+	 * @returns Iterator.
+	 */
+	public *[Symbol.iterator](): IterableIterator<[string, string]> {
+		for (const header of Object.values(this._entries)) {
+			yield [header.name, header.value];
+		}
+	}
+}

package/src/fetch/Request.ts

@@ -1,159 +1,291 @@
-import * as NodeFetch from 'node-fetch';
-import IRequest from './IRequest';
 import IBlob from '../file/IBlob';
 import IDocument from '../nodes/document/IDocument';
+import IRequestInit from './types/IRequestInit';
+import { URL } from 'url';
+import DOMException from '../exception/DOMException';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum';
+import IRequestInfo from './types/IRequestInfo';
+import IRequest from './types/IRequest';
+import Headers from './Headers';
+import FetchBodyUtility from './utilities/FetchBodyUtility';
+import AbortSignal from './AbortSignal';
+import Stream from 'stream';
+import Blob from '../file/Blob';
+import { TextDecoder } from 'util';
+import FetchRequestValidationUtility from './utilities/FetchRequestValidationUtility';
+import IRequestReferrerPolicy from './types/IRequestReferrerPolicy';
+import IRequestRedirect from './types/IRequestRedirect';
+import FetchRequestReferrerUtility from './utilities/FetchRequestReferrerUtility';
+import FetchRequestHeaderUtility from './utilities/FetchRequestHeaderUtility';
+import IRequestCredentials from './types/IRequestCredentials';
 
 /**
  * Fetch request.
+ *
+ * Based on:
+ * https://github.com/node-fetch/node-fetch/blob/main/src/request.js
+ *
+ * @see https://fetch.spec.whatwg.org/#request-class
  */
-export default class Request extends NodeFetch.Request implements IRequest {
+export default class Request implements IRequest {
 	// Owner document is set by a sub-class in the Window constructor
 	public static _ownerDocument: IDocument = null;
 	public readonly _ownerDocument: IDocument = null;
 
+	// Public properties
+	public readonly method: string;
+	public readonly body: Stream.Readable | null;
+	public readonly headers: Headers;
+	public readonly redirect: IRequestRedirect;
+	public readonly referrerPolicy: IRequestReferrerPolicy;
+	public readonly signal: AbortSignal;
+	public readonly bodyUsed: boolean = false;
+	public readonly credentials: IRequestCredentials;
+
+	// Internal properties
+	public readonly _contentLength: number | null = null;
+	public readonly _contentType: string | null = null;
+	public _referrer: '' | 'no-referrer' | 'client' | URL = 'client';
+	public readonly _url: URL;
+	public readonly _bodyBuffer: Buffer | null;
+
 	/**
 	 * Constructor.
 	 *
 	 * @param input Input.
 	 * @param [init] Init.
 	 */
-	constructor(input: NodeFetch.RequestInfo, init?: NodeFetch.RequestInit) {
-		super(input, init);
+	constructor(input: IRequestInfo, init?: IRequestInit) {
 		this._ownerDocument = (<typeof Request>this.constructor)._ownerDocument;
+
+		if (!input) {
+			throw new TypeError(`Failed to contruct 'Request': 1 argument required, only 0 present.`);
+		}
+
+		this.method = (init?.method || (<Request>input).method || 'GET').toUpperCase();
+
+		const { stream, buffer, contentType, contentLength } = FetchBodyUtility.getBodyStream(
+			input instanceof Request && (input._bodyBuffer || input.body)
+				? input._bodyBuffer || FetchBodyUtility.cloneRequestBodyStream(input)
+				: init?.body
+		);
+
+		this._bodyBuffer = buffer;
+		this.body = stream;
+		this.credentials = init?.credentials || (<Request>input).credentials || 'same-origin';
+		this.headers = new Headers(init?.headers || (<Request>input).headers || {});
+
+		FetchRequestHeaderUtility.removeForbiddenHeaders(this.headers);
+
+		if (contentLength) {
+			this._contentLength = contentLength;
+		} else if (!this.body && (this.method === 'POST' || this.method === 'PUT')) {
+			this._contentLength = 0;
+		}
+
+		if (contentType) {
+			this._contentType = contentType;
+		} else if (input instanceof Request && input._contentType) {
+			this._contentType = input._contentType;
+		}
+
+		this.redirect = init?.redirect || (<Request>input).redirect || 'follow';
+		this.referrerPolicy = <IRequestReferrerPolicy>(
+			(init?.referrerPolicy || (<Request>input).referrerPolicy || '').toLowerCase()
+		);
+		this.signal = init?.signal || (<Request>input).signal || new AbortSignal();
+		this._referrer = FetchRequestReferrerUtility.getInitialReferrer(
+			this._ownerDocument,
+			init?.referrer !== null && init?.referrer !== undefined
+				? init?.referrer
+				: (<Request>input).referrer
+		);
+
+		if (input instanceof URL) {
+			this._url = input;
+		} else {
+			try {
+				if (input instanceof Request && input.url) {
+					this._url = new URL(input.url, this._ownerDocument.location);
+				} else {
+					this._url = new URL(<string>input, this._ownerDocument.location);
+				}
+			} catch (error) {
+				throw new DOMException(
+					`Failed to construct 'Request. Invalid URL "${input}" on document location '${
+						this._ownerDocument.location
+					}'.${
+						this._ownerDocument.location.origin === 'null'
+							? ' Relative URLs are not permitted on current document location.'
+							: ''
+					}`,
+					DOMExceptionNameEnum.notSupportedError
+				);
+			}
+		}
+
+		FetchRequestValidationUtility.validateBody(this);
+		FetchRequestValidationUtility.validateURL(this._url);
+		FetchRequestValidationUtility.validateReferrerPolicy(this.referrerPolicy);
+		FetchRequestValidationUtility.validateRedirect(this.redirect);
 	}
 
 	/**
-	 * Returns array buffer.
+	 * Returns referrer.
 	 *
-	 * @returns Array buffer.
+	 * @returns Referrer.
 	 */
-	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));
-		});
+	public get referrer(): string {
+		if (!this._referrer || this._referrer === 'no-referrer') {
+			return '';
+		}
+
+		if (this._referrer === 'client') {
+			return 'about:client';
+		}
+
+		return this._referrer.toString();
 	}
 
 	/**
-	 * Returns blob.
+	 * Returns URL.
 	 *
-	 * @returns Blob.
+	 * @returns URL.
 	 */
-	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));
-		});
+	public get url(): string {
+		return this._url.href;
 	}
 
 	/**
-	 * Returns buffer.
+	 * Returns string tag.
 	 *
-	 * @returns Buffer.
+	 * @returns String tag.
 	 */
-	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));
-		});
+	public get [Symbol.toStringTag](): string {
+		return 'Request';
 	}
 
 	/**
-	 * Returns json.
+	 * Returns array buffer.
 	 *
-	 * @returns JSON.
+	 * @returns Array buffer.
 	 */
-	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));
-		});
+	public async arrayBuffer(): Promise<ArrayBuffer> {
+		if (this.bodyUsed) {
+			throw new DOMException(
+				`Body has already been used for "${this.url}".`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		(<boolean>this.bodyUsed) = true;
+
+		const taskManager = this._ownerDocument.defaultView.happyDOM.asyncTaskManager;
+		const taskID = taskManager.startTask(() => this.signal._abort());
+		let buffer: Buffer;
+
+		try {
+			buffer = await FetchBodyUtility.consumeBodyStream(this.body);
+		} catch (error) {
+			taskManager.endTask(taskID);
+			throw error;
+		}
+
+		taskManager.endTask(taskID);
+
+		return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 	}
 
 	/**
-	 * Returns json.
+	 * Returns blob.
 	 *
-	 * @returns JSON.
+	 * @returns Blob.
 	 */
-	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));
-		});
+	public async blob(): Promise<IBlob> {
+		const type = this.headers.get('content-type') || '';
+		const buffer = await this.arrayBuffer();
+
+		return new Blob([buffer], { type });
 	}
 
 	/**
-	 * Returns json.
+	 * Returns buffer.
 	 *
-	 * @returns JSON.
+	 * @returns Buffer.
 	 */
-	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));
-		});
+	public async buffer(): Promise<Buffer> {
+		if (this.bodyUsed) {
+			throw new DOMException(
+				`Body has already been used for "${this.url}".`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		(<boolean>this.bodyUsed) = true;
+
+		const taskManager = this._ownerDocument.defaultView.happyDOM.asyncTaskManager;
+		const taskID = taskManager.startTask(() => this.signal._abort());
+		let buffer: Buffer;
+
+		try {
+			buffer = await FetchBodyUtility.consumeBodyStream(this.body);
+		} catch (error) {
+			taskManager.endTask(taskID);
+			throw error;
+		}
+
+		taskManager.endTask(taskID);
+
+		return buffer;
 	}
 
 	/**
-	 * Handles promise start.
+	 * Returns text.
 	 *
-	 * @returns Task ID.
+	 * @returns Text.
 	 */
-	private _handlePromiseStart(): number {
+	public async text(): Promise<string> {
+		if (this.bodyUsed) {
+			throw new DOMException(
+				`Body has already been used for "${this.url}".`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		(<boolean>this.bodyUsed) = true;
+
 		const taskManager = this._ownerDocument.defaultView.happyDOM.asyncTaskManager;
-		return taskManager.startTask();
+		const taskID = taskManager.startTask(() => this.signal._abort());
+		let buffer: Buffer;
+
+		try {
+			buffer = await FetchBodyUtility.consumeBodyStream(this.body);
+		} catch (error) {
+			taskManager.endTask(taskID);
+			throw error;
+		}
+
+		taskManager.endTask(taskID);
+
+		return new TextDecoder().decode(buffer);
 	}
 
 	/**
-	 * Handles promise end.
+	 * Returns json.
 	 *
-	 * @param resolve Resolve.
-	 * @param reject Reject.
-	 * @param taskID Task ID.
-	 * @param response Response.
+	 * @returns JSON.
 	 */
-	private _handlePromiseEnd(
-		resolve: (response: unknown) => void,
-		reject: (error: Error) => void,
-		taskID: number,
-		response: unknown
-	): void {
-		const taskManager = this._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);
-		}
+	public async json(): Promise<string> {
+		const text = await this.text();
+		return JSON.parse(text);
 	}
 
 	/**
-	 * Handles promise error.
+	 * Clones request.
 	 *
-	 * @param error
-	 * @param reject
+	 * @returns Clone.
 	 */
-	private _handlePromiseError(reject: (error: Error) => void, error: Error): void {
-		const taskManager = this._ownerDocument.defaultView.happyDOM.asyncTaskManager;
-		reject(error);
-		taskManager.cancelAll(error);
+	public clone(): IRequest {
+		return <IRequest>new Request(this);
 	}
 }

package/src/fetch/{ResourceFetchHandler.ts → ResourceFetch.ts}

@@ -1,11 +1,11 @@
-import RelativeURL from '../location/RelativeURL';
 import DOMException from '../exception/DOMException';
 import IDocument from '../nodes/document/IDocument';
+import { URL } from 'url';
 
 /**
  * Helper class for performing fetch of resources.
  */
-export default class ResourceFetchHandler {
+export default class ResourceFetch {
 	/**
 	 * Returns resource data asynchronously.
 	 *
@@ -32,7 +32,7 @@ export default class ResourceFetchHandler {
 	 */
 	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 absoluteURL = RelativeURL.getAbsoluteURL(document.defaultView.location, url).href;
+		const absoluteURL = new URL(url, document.defaultView.location).href;
 
 		const xhr = new document.defaultView.XMLHttpRequest();
 		xhr.open('GET', absoluteURL, false);