happy-dom 12.8.1 → 12.9.0

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

@@ -4,30 +4,55 @@
 export default class AsyncTaskManager {
 	private static taskID = 0;
 	private runningTasks: { [k: string]: () => void } = {};
+	private runningTaskCount = 0;
 	private runningTimers: NodeJS.Timeout[] = [];
-	private callbacks: Array<() => void> = [];
-	private callbackTimeout: NodeJS.Timeout | null = null;
+	private runningImmediates: NodeJS.Immediate[] = [];
+	private whenCompleteImmediate: NodeJS.Immediate | null = null;
+	private whenCompleteResolvers: Array<() => void> = [];
 
 	/**
-	 * Returns a promise that is fulfilled when async tasks are complete.
-	 * This method is not part of the HTML standard.
+	 * Returns a promise that is resolved when async tasks are complete.
 	 *
 	 * @returns Promise.
 	 */
 	public whenComplete(): Promise<void> {
 		return new Promise((resolve) => {
-			this.callbacks.push(resolve);
-			this.endTask(null);
+			this.whenCompleteResolvers.push(resolve);
+			this.endTask(this.startTask());
 		});
 	}
 
 	/**
-	 * Ends all tasks.
-	 *
-	 * @param [error] Error.
+	 * Cancels all tasks.
 	 */
 	public cancelAll(): void {
-		this.endAll(true);
+		const runningTimers = this.runningTimers;
+		const runningImmediates = this.runningImmediates;
+		const runningTasks = this.runningTasks;
+
+		this.runningTasks = {};
+		this.runningTaskCount = 0;
+		this.runningImmediates = [];
+		this.runningTimers = [];
+
+		if (this.whenCompleteImmediate) {
+			global.clearImmediate(this.whenCompleteImmediate);
+			this.whenCompleteImmediate = null;
+		}
+
+		for (const immediate of runningImmediates) {
+			global.clearImmediate(immediate);
+		}
+
+		for (const timer of runningTimers) {
+			global.clearTimeout(timer);
+		}
+
+		for (const key of Object.keys(runningTasks)) {
+			runningTasks[key]();
+		}
+
+		this.resolveWhenComplete();
 	}
 
 	/**
@@ -37,10 +62,6 @@ export default class AsyncTaskManager {
 	 */
 	public startTimer(timerID: NodeJS.Timeout): void {
 		this.runningTimers.push(timerID);
-		if (this.callbackTimeout) {
-			global.clearTimeout(this.callbackTimeout);
-			this.callbackTimeout = null;
-		}
 	}
 
 	/**
@@ -52,13 +73,33 @@ export default class AsyncTaskManager {
 		const index = this.runningTimers.indexOf(timerID);
 		if (index !== -1) {
 			this.runningTimers.splice(index, 1);
+			if (!this.runningTaskCount && !this.runningTimers.length && !this.runningImmediates.length) {
+				this.resolveWhenComplete();
+			}
 		}
-		if (this.callbackTimeout) {
-			global.clearTimeout(this.callbackTimeout);
-			this.callbackTimeout = null;
-		}
-		if (!Object.keys(this.runningTasks).length && !this.runningTimers.length) {
-			this.endAll();
+	}
+
+	/**
+	 * Starts an immediate.
+	 *
+	 * @param immediateID Immediate ID.
+	 */
+	public startImmediate(immediateID: NodeJS.Immediate): void {
+		this.runningImmediates.push(immediateID);
+	}
+
+	/**
+	 * Ends an immediate.
+	 *
+	 * @param immediateID Immediate ID.
+	 */
+	public endImmediate(immediateID: NodeJS.Immediate): void {
+		const index = this.runningImmediates.indexOf(immediateID);
+		if (index !== -1) {
+			this.runningImmediates.splice(index, 1);
+			if (!this.runningTaskCount && !this.runningTimers.length && !this.runningImmediates.length) {
+				this.resolveWhenComplete();
+			}
 		}
 	}
 
@@ -71,10 +112,7 @@ export default class AsyncTaskManager {
 	public startTask(abortHandler?: () => void): number {
 		const taskID = this.newTaskID();
 		this.runningTasks[taskID] = abortHandler ? abortHandler : () => {};
-		if (this.callbackTimeout) {
-			global.clearTimeout(this.callbackTimeout);
-			this.callbackTimeout = null;
-		}
+		this.runningTaskCount++;
 		return taskID;
 	}
 
@@ -86,13 +124,22 @@ export default class AsyncTaskManager {
 	public endTask(taskID: number): void {
 		if (this.runningTasks[taskID]) {
 			delete this.runningTasks[taskID];
-		}
-		if (this.callbackTimeout) {
-			global.clearTimeout(this.callbackTimeout);
-			this.callbackTimeout = null;
-		}
-		if (!Object.keys(this.runningTasks).length && !this.runningTimers.length) {
-			this.endAll();
+			this.runningTaskCount--;
+			if (this.whenCompleteImmediate) {
+				global.clearImmediate(this.whenCompleteImmediate);
+			}
+			if (!this.runningTaskCount && !this.runningTimers.length && !this.runningImmediates.length) {
+				this.whenCompleteImmediate = global.setImmediate(() => {
+					this.whenCompleteImmediate = null;
+					if (
+						!this.runningTaskCount &&
+						!this.runningTimers.length &&
+						!this.runningImmediates.length
+					) {
+						this.resolveWhenComplete();
+					}
+				});
+			}
 		}
 	}
 
@@ -102,7 +149,7 @@ export default class AsyncTaskManager {
 	 * @returns Count.
 	 */
 	public getTaskCount(): number {
-		return Object.keys(this.runningTasks).length;
+		return this.runningTaskCount;
 	}
 
 	/**
@@ -116,47 +163,13 @@ export default class AsyncTaskManager {
 	}
 
 	/**
-	 * Ends all tasks.
-	 *
-	 * @param [canceled] Canceled.
+	 * Resolves when complete.
 	 */
-	private endAll(canceled?: boolean): void {
-		const runningTimers = this.runningTimers;
-		const runningTasks = this.runningTasks;
-
-		this.runningTasks = {};
-		this.runningTimers = [];
-
-		for (const timer of runningTimers) {
-			global.clearTimeout(timer);
-		}
-
-		for (const key of Object.keys(runningTasks)) {
-			runningTasks[key]();
-		}
-
-		if (this.callbackTimeout) {
-			global.clearTimeout(this.callbackTimeout);
-			this.callbackTimeout = null;
-		}
-		if (this.callbacks.length) {
-			if (canceled) {
-				const callbacks = this.callbacks;
-				this.callbacks = [];
-				for (const callback of callbacks) {
-					callback();
-				}
-			} else {
-				this.callbackTimeout = global.setTimeout(() => {
-					const callbacks = this.callbacks;
-					this.callbackTimeout = null;
-					this.callbacks = [];
-					this.runningTimers = [];
-					for (const callback of callbacks) {
-						callback();
-					}
-				}, 10);
-			}
+	private resolveWhenComplete(): void {
+		const resolvers = this.whenCompleteResolvers;
+		this.whenCompleteResolvers = [];
+		for (const resolver of resolvers) {
+			resolver();
 		}
 	}
 }

package/src/fetch/Fetch.ts

@@ -92,12 +92,12 @@ export default class Fetch {
 			}
 
 			this.resolve = (response: IResponse | Promise<IResponse>): void => {
-				resolve(response);
 				taskManager.endTask(taskID);
+				resolve(response);
 			};
 			this.reject = (error: Error): void => {
-				reject(error);
 				taskManager.endTask(taskID);
+				reject(error);
 			};
 
 			this.prepareRequest();

package/src/nodes/document/DocumentReadyStateManager.ts

@@ -7,7 +7,7 @@ export default class DocumentReadyStateManager {
 	private totalTasks = 0;
 	private readyStateCallbacks: (() => void)[] = [];
 	private window: IWindow = null;
-	private timer: NodeJS.Timeout = null;
+	private immediate: NodeJS.Immediate | null = null;
 	private isComplete = false;
 
 	/**
@@ -30,8 +30,8 @@ export default class DocumentReadyStateManager {
 				resolve();
 			} else {
 				this.readyStateCallbacks.push(resolve);
-				if (this.totalTasks === 0 && !this.timer) {
-					this.timer = this.window.setTimeout(this.endTask.bind(this));
+				if (this.totalTasks === 0 && !this.immediate) {
+					this.immediate = this.window.requestAnimationFrame(this.endTask.bind(this));
 				}
 			}
 		});
@@ -45,9 +45,9 @@ export default class DocumentReadyStateManager {
 			return;
 		}
 
-		if (this.timer) {
-			this.window.clearTimeout(this.timer);
-			this.timer = null;
+		if (this.immediate) {
+			this.window.cancelAnimationFrame(this.immediate);
+			this.immediate = null;
 		}
 
 		this.totalTasks++;
@@ -61,9 +61,9 @@ export default class DocumentReadyStateManager {
 			return;
 		}
 
-		if (this.timer) {
-			this.window.clearTimeout(this.timer);
-			this.timer = null;
+		if (this.immediate) {
+			this.window.cancelAnimationFrame(this.immediate);
+			this.immediate = null;
 		}
 
 		this.totalTasks--;

package/src/window/IWindow.ts

@@ -492,16 +492,16 @@ export default interface IWindow extends IEventTarget, INodeJSGlobal {
 	 * Mock animation frames with timeouts.
 	 *
 	 * @param {Function} callback Callback.
-	 * @returns {NodeJS.Timeout} Timeout ID.
+	 * @returns {NodeJS.Timeout} ID.
 	 */
-	requestAnimationFrame(callback: (timestamp: number) => void): NodeJS.Timeout;
+	requestAnimationFrame(callback: (timestamp: number) => void): NodeJS.Immediate;
 
 	/**
 	 * Mock animation frames with timeouts.
 	 *
-	 * @param {NodeJS.Timeout} id Timeout ID.
+	 * @param {NodeJS.Timeout} id ID.
 	 */
-	cancelAnimationFrame(id: NodeJS.Timeout): void;
+	cancelAnimationFrame(id: NodeJS.Immediate): void;
 
 	/**
 	 * This method provides an easy, logical way to fetch resources asynchronously across the network.

package/src/window/Window.ts

@@ -837,12 +837,12 @@ export default class Window extends EventTarget implements IWindow {
 	 */
 	public setTimeout(callback: Function, delay = 0, ...args: unknown[]): NodeJS.Timeout {
 		const id = this._setTimeout(() => {
-			this.happyDOM.asyncTaskManager.endTimer(id);
 			if (this.happyDOM.settings.disableErrorCapturing) {
 				callback(...args);
 			} else {
 				WindowErrorUtility.captureError(this, () => callback(...args));
 			}
+			this.happyDOM.asyncTaskManager.endTimer(id);
 		}, delay);
 		this.happyDOM.asyncTaskManager.startTimer(id);
 		return id;
@@ -896,19 +896,29 @@ export default class Window extends EventTarget implements IWindow {
 	 * Mock animation frames with timeouts.
 	 *
 	 * @param callback Callback.
-	 * @returns Timeout ID.
+	 * @returns ID.
 	 */
-	public requestAnimationFrame(callback: (timestamp: number) => void): NodeJS.Timeout {
-		return this.setTimeout(() => callback(this.performance.now()));
+	public requestAnimationFrame(callback: (timestamp: number) => void): NodeJS.Immediate {
+		const id = global.setImmediate(() => {
+			if (this.happyDOM.settings.disableErrorCapturing) {
+				callback(this.performance.now());
+			} else {
+				WindowErrorUtility.captureError(this, () => callback(this.performance.now()));
+			}
+			this.happyDOM.asyncTaskManager.endImmediate(id);
+		});
+		this.happyDOM.asyncTaskManager.startImmediate(id);
+		return id;
 	}
 
 	/**
 	 * Mock animation frames with timeouts.
 	 *
-	 * @param id Timeout ID.
+	 * @param id ID.
 	 */
-	public cancelAnimationFrame(id: NodeJS.Timeout): void {
-		this.clearTimeout(id);
+	public cancelAnimationFrame(id: NodeJS.Immediate): void {
+		global.clearImmediate(id);
+		this.happyDOM.asyncTaskManager.endImmediate(id);
 	}
 
 	/**
@@ -921,13 +931,12 @@ export default class Window extends EventTarget implements IWindow {
 		const taskId = this.happyDOM.asyncTaskManager.startTask(() => (isAborted = true));
 		this._queueMicrotask(() => {
 			if (!isAborted) {
-				this.happyDOM.asyncTaskManager.endTask(taskId);
-
 				if (this.happyDOM.settings.disableErrorCapturing) {
 					callback();
 				} else {
 					WindowErrorUtility.captureError(this, <() => unknown>callback);
 				}
+				this.happyDOM.asyncTaskManager.endTask(taskId);
 			}
 		});
 	}