happy-dom 8.9.0 → 9.0.0

package/src/fetch/Response.ts

@@ -1,25 +1,79 @@
-import IResponse from './IResponse';
+import IResponse from './types/IResponse';
 import IBlob from '../file/IBlob';
 import IDocument from '../nodes/document/IDocument';
-import * as NodeFetch from 'node-fetch';
+import IResponseInit from './types/IResponseInit';
+import IResponseBody from './types/IResponseBody';
+import Headers from './Headers';
+import IHeaders from './types/IHeaders';
+import { URL, URLSearchParams } from 'url';
+import Blob from '../file/Blob';
+import Stream from 'stream';
+import FormData from '../form-data/FormData';
+import FetchBodyUtility from './utilities/FetchBodyUtility';
+import DOMException from '../exception/DOMException';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum';
+import { TextDecoder } from 'util';
+import MultipartFormDataParser from './multipart/MultipartFormDataParser';
+
+const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308];
 
 /**
  * Fetch response.
+ *
+ * Based on:
+ * https://github.com/node-fetch/node-fetch/blob/main/src/response.js (MIT)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Response/Response
  */
-export default class Response extends NodeFetch.Response implements IResponse {
+export default class Response implements IResponse {
 	// 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 body: Stream.Readable | null = null;
+	public readonly bodyUsed = false;
+	public readonly redirected = false;
+	public readonly type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect' =
+		'basic';
+	public readonly url: string = '';
+	public readonly status: number;
+	public readonly statusText: string;
+	public readonly ok: boolean;
+	public readonly headers: IHeaders;
+
 	/**
 	 * Constructor.
 	 *
-	 * @param [body] An object defining a body for the response (can be omitted)
-	 * @param [init] An options object containing any custom settings that you want to apply to the response, or an empty object (which is the default value)
+	 * @param input Input.
+	 * @param body
+	 * @param [init] Init.
 	 */
-	constructor(body?: NodeFetch.BodyInit, init?: NodeFetch.ResponseInit) {
-		super(body, init);
+	constructor(body?: IResponseBody, init?: IResponseInit) {
 		this._ownerDocument = (<typeof Response>this.constructor)._ownerDocument;
+
+		this.status = init?.status !== undefined ? init.status : 200;
+		this.statusText = init?.statusText || '';
+		this.ok = this.status >= 200 && this.status < 300;
+		this.headers = new Headers(init?.headers);
+
+		if (body) {
+			const { stream, contentType } = FetchBodyUtility.getBodyStream(body);
+			this.body = stream;
+
+			if (contentType && !this.headers.has('Content-Type')) {
+				this.headers.set('Content-Type', contentType);
+			}
+		}
+	}
+
+	/**
+	 * Returns string tag.
+	 *
+	 * @returns String tag.
+	 */
+	public get [Symbol.toStringTag](): string {
+		return 'Response';
 	}
 
 	/**
@@ -27,14 +81,30 @@ export default class Response extends NodeFetch.Response implements IResponse {
 	 *
 	 * @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));
-		});
+	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();
+		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);
 	}
 
 	/**
@@ -42,14 +112,11 @@ export default class Response extends NodeFetch.Response implements IResponse {
 	 *
 	 * @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));
-		});
+	public async blob(): Promise<IBlob> {
+		const type = this.headers.get('content-type') || '';
+		const buffer = await this.arrayBuffer();
+
+		return new Blob([buffer], { type });
 	}
 
 	/**
@@ -57,29 +124,61 @@ export default class Response extends NodeFetch.Response implements IResponse {
 	 *
 	 * @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));
-		});
+	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();
+		let buffer: Buffer;
+
+		try {
+			buffer = await FetchBodyUtility.consumeBodyStream(this.body);
+		} catch (error) {
+			taskManager.endTask(taskID);
+			throw error;
+		}
+
+		taskManager.endTask(taskID);
+
+		return buffer;
 	}
 
 	/**
-	 * Returns json.
+	 * Returns text.
 	 *
-	 * @returns JSON.
+	 * @returns Text.
 	 */
-	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 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;
+		const taskID = taskManager.startTask();
+		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);
 	}
 
 	/**
@@ -87,73 +186,137 @@ export default class Response extends NodeFetch.Response implements IResponse {
 	 *
 	 * @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));
-		});
+	public async json(): Promise<string> {
+		const text = await this.text();
+		return JSON.parse(text);
 	}
 
 	/**
-	 * Returns json.
+	 * Returns form data.
 	 *
-	 * @returns JSON.
+	 * @returns Form data.
 	 */
-	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 formData(): Promise<FormData> {
+		const contentType = this.headers.get('content-type');
+		const taskManager = this._ownerDocument.defaultView.happyDOM.asyncTaskManager;
+		const taskID = taskManager.startTask();
+
+		if (contentType.startsWith('application/x-www-form-urlencoded')) {
+			const formData = new FormData();
+			let text: string;
+
+			try {
+				text = await this.text();
+			} catch (error) {
+				taskManager.endTask(taskID);
+				throw error;
+			}
+
+			const parameters = new URLSearchParams(text);
+
+			for (const [name, value] of parameters) {
+				formData.append(name, value);
+			}
+
+			taskManager.endTask(taskID);
+
+			return formData;
+		}
+
+		let formData: FormData;
+
+		try {
+			formData = await MultipartFormDataParser.streamToFormData(this.body, contentType);
+		} catch (error) {
+			taskManager.endTask(taskID);
+			throw error;
+		}
+
+		taskManager.endTask(taskID);
+
+		return formData;
 	}
 
 	/**
-	 * Handles promise start.
+	 * Clones request.
 	 *
-	 * @returns Task ID.
+	 * @returns Clone.
 	 */
-	private _handlePromiseStart(): number {
-		const taskManager = this._ownerDocument.defaultView.happyDOM.asyncTaskManager;
-		return taskManager.startTask();
-	}
+	public clone(): IResponse {
+		const response = new Response();
+
+		(<number>response.status) = this.status;
+		(<string>response.statusText) = this.statusText;
+		(<boolean>response.ok) = this.ok;
+		(<Headers>response.headers) = new Headers(this.headers);
+		(<Stream.Readable>response.body) = this.body;
+		(<boolean>response.bodyUsed) = this.bodyUsed;
+		(<boolean>response.redirected) = this.redirected;
+		(<string>response.type) = this.type;
+		(<string>response.url) = this.url;
 
+		return <IResponse>response;
+	}
 	/**
-	 * Handles promise end.
+	 * Returns a redirect response.
 	 *
-	 * @param resolve Resolve.
-	 * @param reject Reject.
-	 * @param taskID Task ID.
-	 * @param response Response.
+	 * @param url URL.
+	 * @param status Status code.
+	 * @returns Response.
 	 */
-	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 static redirect(url: string, status = 302): IResponse {
+		if (!REDIRECT_STATUS_CODES.includes(status)) {
+			throw new DOMException(
+				'Failed to create redirect response: Invalid redirect status code.',
+				DOMExceptionNameEnum.invalidStateError
+			);
 		}
+
+		return new Response(null, {
+			headers: {
+				location: new URL(url).toString()
+			},
+			status
+		});
 	}
 
 	/**
-	 * Handles promise error.
+	 * Returns an error response.
 	 *
-	 * @param error
-	 * @param reject
+	 * @param url URL.
+	 * @param status Status code.
+	 * @returns Response.
 	 */
-	private _handlePromiseError(reject: (error: Error) => void, error: Error): void {
-		const taskManager = this._ownerDocument.defaultView.happyDOM.asyncTaskManager;
-		reject(error);
-		taskManager.cancelAll(error);
+	public static error(): IResponse {
+		const response = new Response(null, { status: 0, statusText: '' });
+		(<string>response.type) = 'error';
+		return response;
+	}
+
+	/**
+	 * Returns an JSON response.
+	 *
+	 * @param data Data.
+	 * @param [init] Init.
+	 * @returns Response.
+	 */
+	public static json(data: object, init?: IResponseInit): IResponse {
+		const body = JSON.stringify(data);
+
+		if (body === undefined) {
+			throw new TypeError('data is not JSON serializable');
+		}
+
+		const headers = new Headers(init && init.headers);
+
+		if (!headers.has('content-type')) {
+			headers.set('content-type', 'application/json');
+		}
+
+		return new Response(body, {
+			status: 200,
+			...init,
+			headers
+		});
 	}
 }

package/src/fetch/data-uri/DataURIParser.ts

@@ -0,0 +1,66 @@
+/**
+ * Data URI parser.
+ *
+ * Based on:
+ * https://github.com/TooTallNate/node-data-uri-to-buffer/blob/main/src/index.ts (MIT)
+ */
+export default class DataURIParser {
+	/**
+	 * Returns a Buffer instance from the given data URI `uri`.
+	 *
+	 * @param uri Data URI.
+	 * @returns Buffer.
+	 */
+	public static parse(uri: string): {
+		type: string;
+		charset: string;
+		buffer: Buffer;
+	} {
+		if (!/^data:/i.test(uri)) {
+			throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
+		}
+
+		// Strip newlines
+		uri = uri.replace(/\r?\n/g, '');
+
+		// Split the URI up into the "metadata" and the "data" portions
+		const firstComma = uri.indexOf(',');
+		if (firstComma === -1 || firstComma <= 4) {
+			throw new TypeError('malformed data: URI');
+		}
+
+		// Remove the "data:" scheme and parse the metadata
+		const meta = uri.substring(5, firstComma).split(';');
+		let charset = '';
+		let base64 = false;
+		let type = meta[0] || 'text/plain';
+
+		for (let i = 1; i < meta.length; i++) {
+			if (meta[i] === 'base64') {
+				base64 = true;
+			} else if (meta[i]) {
+				type += `;${meta[i]}`;
+				if (meta[i].indexOf('charset=') === 0) {
+					charset = meta[i].substring(8);
+				}
+			}
+		}
+
+		// Defaults to US-ASCII only if type is not provided
+		if (!meta[0] && !charset.length) {
+			type += ';charset=US-ASCII';
+			charset = 'US-ASCII';
+		}
+
+		// Get the encoded data portion and decode URI-encoded chars
+		const encoding = base64 ? 'base64' : 'ascii';
+		const data = unescape(uri.substring(firstComma + 1));
+		const buffer = Buffer.from(data, encoding);
+
+		return {
+			type,
+			charset,
+			buffer
+		};
+	}
+}

package/src/fetch/multipart/MultipartFormDataParser.ts

@@ -0,0 +1,113 @@
+import FormData from '../../form-data/FormData';
+import Stream from 'stream';
+import MultipartReader from './MultipartReader';
+import DOMException from '../../exception/DOMException';
+import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum';
+
+/**
+ * Multipart form data factory.
+ *
+ * Based on:
+ * https://github.com/node-fetch/node-fetch/blob/main/src/utils/multipart-parser.js (MIT)
+ */
+export default class MultipartFormDataParser {
+	/**
+	 * Returns form data.
+	 *
+	 * @param body Body.
+	 * @param contentType Content type header value.
+	 * @returns Form data.
+	 */
+	public static async streamToFormData(
+		body: Stream.Readable,
+		contentType: string
+	): Promise<FormData> {
+		if (!/multipart/i.test(contentType)) {
+			throw new DOMException(
+				`Failed to build FormData object: The "content-type" header isn't of type "multipart/form-data".`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		const match = contentType.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+
+		if (!match) {
+			throw new DOMException(
+				`Failed to build FormData object: The "content-type" header doesn't contain any multipart boundary.`,
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		const reader = new MultipartReader(match[1] || match[2]);
+
+		for await (const chunk of body) {
+			reader.write(chunk);
+		}
+
+		return reader.end();
+	}
+
+	/**
+	 * Converts a FormData object to a ReadableStream.
+	 *
+	 * @param formData FormData.
+	 * @returns Stream and type.
+	 */
+	public static formDataToStream(formData: FormData): {
+		contentType: string;
+		contentLength: number;
+		buffer: Buffer;
+		stream: Stream.Readable;
+	} {
+		const boundary = '----HappyDOMFormDataBoundary' + Math.random().toString(36);
+		const chunks: Buffer[] = [];
+		const prefix = `--${boundary}\r\nContent-Disposition: form-data; name="`;
+
+		for (const [name, value] of formData) {
+			if (typeof value === 'string') {
+				chunks.push(
+					Buffer.from(
+						`${prefix}${this.escapeName(name)}"\r\n\r\n${value.replace(
+							/\r(?!\n)|(?<!\r)\n/g,
+							'\r\n'
+						)}\r\n`
+					)
+				);
+			} else {
+				chunks.push(
+					Buffer.from(
+						`${prefix}${this.escapeName(name)}"; filename="${this.escapeName(
+							value.name,
+							true
+						)}"\r\nContent-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`
+					)
+				);
+				chunks.push(value._buffer);
+				chunks.push(Buffer.from('\r\n'));
+			}
+		}
+
+		const buffer = Buffer.concat(chunks);
+
+		return {
+			contentType: `multipart/form-data; boundary=${boundary}`,
+			contentLength: buffer.length,
+			buffer,
+			stream: Stream.Readable.from(buffer)
+		};
+	}
+
+	/**
+	 * Escapes a form data entry name.
+	 *
+	 * @param name Name.
+	 * @param filename Whether it is a filename.
+	 * @returns Escaped name.
+	 */
+	private static escapeName(name: string, filename = false): string {
+		return (filename ? name : name.replace(/\r?\n|\r/g, '\r\n'))
+			.replace(/\n/g, '%0A')
+			.replace(/\r/g, '%0D')
+			.replace(/"/g, '%22');
+	}
+}