happy-dom 16.8.1 → 20.0.2

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

@@ -1,4 +1,5 @@
 import IBrowserFrame from '../browser/types/IBrowserFrame.js';
+import AsyncTaskManagerDebugError from './AsyncTaskManagerDebugError.js';
 
 // We need to set this as a global constant, so that using fake timers in Jest and Vitest won't override this on the global object.
 const TIMER = {
@@ -16,10 +17,14 @@ export default class AsyncTaskManager {
 	private runningTaskCount = 0;
 	private runningTimers: NodeJS.Timeout[] = [];
 	private runningImmediates: NodeJS.Immediate[] = [];
+	private debugTrace: Map<number | NodeJS.Timeout | NodeJS.Immediate, string> = new Map();
 	private waitUntilCompleteTimer: NodeJS.Timeout | null = null;
-	private waitUntilCompleteResolvers: Array<() => void> = [];
-	private aborted = false;
+	private waitUntilCompleteResolvers: Array<{
+		resolve: () => void;
+		reject: (error: Error) => void;
+	}> = [];
 	private destroyed = false;
+	#debugTimeout: NodeJS.Timeout | null = null;
 	#browserFrame: IBrowserFrame;
 
 	/**
@@ -37,8 +42,8 @@ export default class AsyncTaskManager {
 	 * @returns Promise.
 	 */
 	public waitUntilComplete(): Promise<void> {
-		return new Promise((resolve) => {
-			this.waitUntilCompleteResolvers.push(resolve);
+		return new Promise((resolve, reject) => {
+			this.waitUntilCompleteResolvers.push({ resolve, reject });
 			this.resolveWhenComplete();
 		});
 	}
@@ -47,9 +52,9 @@ export default class AsyncTaskManager {
 	 * Aborts all tasks.
 	 */
 	public abort(): Promise<void> {
-		if (this.aborted) {
-			return new Promise((resolve) => {
-				this.waitUntilCompleteResolvers.push(resolve);
+		if (this.destroyed) {
+			return new Promise((resolve, reject) => {
+				this.waitUntilCompleteResolvers.push({ resolve, reject });
 				this.resolveWhenComplete();
 			});
 		}
@@ -60,9 +65,9 @@ export default class AsyncTaskManager {
 	 * Destroys the manager.
 	 */
 	public destroy(): Promise<void> {
-		if (this.aborted) {
-			return new Promise((resolve) => {
-				this.waitUntilCompleteResolvers.push(resolve);
+		if (this.destroyed) {
+			return new Promise((resolve, reject) => {
+				this.waitUntilCompleteResolvers.push({ resolve, reject });
 				this.resolveWhenComplete();
 			});
 		}
@@ -75,7 +80,7 @@ export default class AsyncTaskManager {
 	 * @param timerID Timer ID.
 	 */
 	public startTimer(timerID: NodeJS.Timeout): void {
-		if (this.aborted) {
+		if (this.destroyed) {
 			TIMER.clearTimeout(timerID);
 			return;
 		}
@@ -84,6 +89,9 @@ export default class AsyncTaskManager {
 			this.waitUntilCompleteTimer = null;
 		}
 		this.runningTimers.push(timerID);
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.set(timerID, new AsyncTaskManagerDebugError().stack!);
+		}
 	}
 
 	/**
@@ -92,16 +100,17 @@ export default class AsyncTaskManager {
 	 * @param timerID Timer ID.
 	 */
 	public endTimer(timerID: NodeJS.Timeout): void {
-		if (this.aborted) {
+		if (this.destroyed) {
 			TIMER.clearTimeout(timerID);
 			return;
 		}
 		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();
-			}
+			this.resolveWhenComplete();
+		}
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.delete(timerID);
 		}
 	}
 
@@ -111,7 +120,7 @@ export default class AsyncTaskManager {
 	 * @param immediateID Immediate ID.
 	 */
 	public startImmediate(immediateID: NodeJS.Immediate): void {
-		if (this.aborted) {
+		if (this.destroyed) {
 			TIMER.clearImmediate(immediateID);
 			return;
 		}
@@ -120,6 +129,9 @@ export default class AsyncTaskManager {
 			this.waitUntilCompleteTimer = null;
 		}
 		this.runningImmediates.push(immediateID);
+		if (this.#browserFrame.page?.context?.browser?.settings?.debug?.traceWaitUntilComplete > 0) {
+			this.debugTrace.set(immediateID, new AsyncTaskManagerDebugError().stack!);
+		}
 	}
 
 	/**
@@ -128,16 +140,17 @@ export default class AsyncTaskManager {
 	 * @param immediateID Immediate ID.
 	 */
 	public endImmediate(immediateID: NodeJS.Immediate): void {
-		if (this.aborted) {
+		if (this.destroyed) {
 			TIMER.clearImmediate(immediateID);
 			return;
 		}
 		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();
-			}
+			this.resolveWhenComplete();
+		}
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.delete(immediateID);
 		}
 	}
 
@@ -148,12 +161,12 @@ export default class AsyncTaskManager {
 	 * @returns Task ID.
 	 */
 	public startTask(abortHandler?: (destroy?: boolean) => void): number {
-		if (this.aborted) {
+		if (this.destroyed) {
 			if (abortHandler) {
 				abortHandler(this.destroyed);
 			}
 			throw new this.#browserFrame.window.Error(
-				`Failed to execute 'startTask()' on 'AsyncTaskManager': The asynchrounous task manager has been aborted.`
+				`Failed to execute 'startTask()' on 'AsyncTaskManager': The asynchronous task manager has been destroyed. This error can be thrown if scripts continue to run while a browser frame is closed.`
 			);
 		}
 		if (this.waitUntilCompleteTimer) {
@@ -163,6 +176,9 @@ export default class AsyncTaskManager {
 		const taskID = this.newTaskID();
 		this.runningTasks[taskID] = abortHandler ? abortHandler : () => {};
 		this.runningTaskCount++;
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.set(taskID, new AsyncTaskManagerDebugError().stack!);
+		}
 		return taskID;
 	}
 
@@ -172,15 +188,16 @@ export default class AsyncTaskManager {
 	 * @param taskID Task ID.
 	 */
 	public endTask(taskID: number): void {
-		if (this.aborted) {
+		if (this.destroyed) {
 			return;
 		}
 		if (this.runningTasks[taskID]) {
 			delete this.runningTasks[taskID];
 			this.runningTaskCount--;
-			if (!this.runningTaskCount && !this.runningTimers.length && !this.runningImmediates.length) {
-				this.resolveWhenComplete();
-			}
+			this.resolveWhenComplete();
+		}
+		if (this.#browserFrame.page.context.browser.settings.debug.traceWaitUntilComplete > 0) {
+			this.debugTrace.delete(taskID);
 		}
 	}
 
@@ -207,6 +224,8 @@ export default class AsyncTaskManager {
 	 * Resolves when complete.
 	 */
 	private resolveWhenComplete(): void {
+		this.applyDebugging();
+
 		if (this.runningTaskCount || this.runningTimers.length || this.runningImmediates.length) {
 			return;
 		}
@@ -222,16 +241,60 @@ export default class AsyncTaskManager {
 		this.waitUntilCompleteTimer = TIMER.setTimeout(() => {
 			this.waitUntilCompleteTimer = null;
 			if (!this.runningTaskCount && !this.runningTimers.length && !this.runningImmediates.length) {
+				if (this.#debugTimeout) {
+					TIMER.clearTimeout(this.#debugTimeout);
+				}
 				const resolvers = this.waitUntilCompleteResolvers;
 				this.waitUntilCompleteResolvers = [];
 				for (const resolver of resolvers) {
-					resolver();
+					resolver.resolve();
 				}
-				this.aborted = false;
+				this.destroyed = false;
+			} else {
+				this.applyDebugging();
 			}
 		}, 1);
 	}
 
+	/**
+	 * Applies debugging.
+	 */
+	private applyDebugging(): void {
+		const debug = this.#browserFrame.page.context.browser.settings.debug;
+		if (!debug?.traceWaitUntilComplete || debug.traceWaitUntilComplete < 1) {
+			return;
+		}
+		if (this.#debugTimeout) {
+			return;
+		}
+		this.#debugTimeout = TIMER.setTimeout(() => {
+			this.#debugTimeout = null;
+
+			let errorMessage = `The maximum time was reached for "waitUntilComplete()".\n\n${
+				this.debugTrace.size
+			} task${
+				this.debugTrace.size === 1 ? '' : 's'
+			} did not end in time.\n\nThe following traces were recorded:\n\n`;
+
+			let number = 1;
+			for (const [key, value] of this.debugTrace.entries()) {
+				const type = typeof key === 'number' ? 'Task' : 'Timer';
+				errorMessage += `${type} #${number}\n‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾${value
+					.replace(/AsyncTaskManagerDebugError:{0,1}/, '')
+					.replace(/\s+at /gm, '\n> ')}\n\n`;
+				number++;
+			}
+
+			const error = new Error(errorMessage);
+
+			for (const resolver of this.waitUntilCompleteResolvers) {
+				resolver.reject(error);
+			}
+
+			this.abortAll(true);
+		}, debug.traceWaitUntilComplete);
+	}
+
 	/**
 	 * Aborts all tasks.
 	 *
@@ -242,12 +305,14 @@ export default class AsyncTaskManager {
 		const runningImmediates = this.runningImmediates;
 		const runningTasks = this.runningTasks;
 
-		this.aborted = true;
-		this.destroyed = destroy;
+		if (destroy) {
+			this.destroyed = true;
+		}
 		this.runningTasks = {};
 		this.runningTaskCount = 0;
 		this.runningImmediates = [];
 		this.runningTimers = [];
+		this.debugTrace = new Map();
 
 		if (this.waitUntilCompleteTimer) {
 			TIMER.clearTimeout(this.waitUntilCompleteTimer);
@@ -267,8 +332,8 @@ export default class AsyncTaskManager {
 		}
 
 		// We need to wait for microtasks to complete before resolving.
-		return new Promise((resolve) => {
-			this.waitUntilCompleteResolvers.push(resolve);
+		return new Promise((resolve, reject) => {
+			this.waitUntilCompleteResolvers.push({ resolve, reject });
 			this.resolveWhenComplete();
 		});
 	}

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

@@ -0,0 +1,14 @@
+/**
+ * Error thrown for retrieving the stack trace during debugging.
+ */
+export default class AsyncTaskManagerDebugError extends Error {
+	/**
+	 * Constructor.
+	 *
+	 * @param message Message.
+	 */
+	constructor(message?: string) {
+		super(message);
+		this.name = 'AsyncTaskManagerDebugError';
+	}
+}

package/src/browser/Browser.ts

@@ -10,8 +10,6 @@ import BrowserErrorCaptureEnum from './enums/BrowserErrorCaptureEnum.js';
 
 /**
  * Browser.
- *
- * Much of the interface for the browser has been taken from Puppeteer and Playwright, so that the API is familiar.
  */
 export default class Browser implements IBrowser {
 	public readonly contexts: BrowserContext[];
@@ -35,6 +33,15 @@ export default class Browser implements IBrowser {
 		this.contexts = [new BrowserContext(this)];
 	}
 
+	/**
+	 * Returns true if the browser is closed.
+	 *
+	 * @returns True if the browser is closed.
+	 */
+	public get closed(): boolean {
+		return this.contexts.length === 0;
+	}
+
 	/**
 	 * Returns the default context.
 	 *
@@ -51,8 +58,12 @@ export default class Browser implements IBrowser {
 	 * Aborts all ongoing operations and destroys the browser.
 	 */
 	public async close(): Promise<void> {
-		await Promise.all(this.contexts.slice().map((context) => context.close()));
+		if (this.contexts.length === 0) {
+			return;
+		}
+		const contexts = this.contexts;
 		(<BrowserContext[]>this.contexts) = [];
+		await Promise.all(contexts.map((context) => context.close()));
 	}
 
 	/**

package/src/browser/BrowserContext.ts

@@ -17,6 +17,7 @@ export default class BrowserContext implements IBrowserContext {
 	public readonly cookieContainer: ICookieContainer = new CookieContainer();
 	public readonly responseCache: IResponseCache = new ResponseCache();
 	public readonly preflightResponseCache: IPreflightResponseCache = new PreflightResponseCache();
+	public readonly closed: boolean = false;
 
 	/**
 	 * Constructor.
@@ -31,25 +32,31 @@ export default class BrowserContext implements IBrowserContext {
 	 * Aborts all ongoing operations and destroys the context.
 	 */
 	public async close(): Promise<void> {
-		if (!this.browser) {
+		if (this.closed) {
 			return;
 		}
+
+		if (this.browser.contexts[0] === this) {
+			throw new Error(
+				'Cannot close the default context. Use `browser.close()` to close the browser instead.'
+			);
+		}
+
+		(<boolean>this.closed) = true;
+
 		await Promise.all(this.pages.slice().map((page) => page.close()));
+
 		const browser = this.browser;
 		const index = browser.contexts.indexOf(this);
+
 		if (index !== -1) {
 			browser.contexts.splice(index, 1);
 		}
+
 		(<BrowserPage[]>this.pages) = [];
-		(<Browser | null>this.browser) = null;
-		(<ICookieContainer | null>this.cookieContainer) = null;
+		this.cookieContainer.clearCookies();
 		this.responseCache.clear();
 		this.preflightResponseCache.clear();
-		(<ResponseCache | null>this.responseCache) = null;
-		(<PreflightResponseCache | null>this.preflightResponseCache) = null;
-		if (browser.contexts.length === 0) {
-			browser.close();
-		}
 	}
 
 	/**

package/src/browser/BrowserFrame.ts

@@ -12,8 +12,7 @@ import BrowserFrameScriptEvaluator from './utilities/BrowserFrameScriptEvaluator
 import BrowserFrameNavigator from './utilities/BrowserFrameNavigator.js';
 import IReloadOptions from './types/IReloadOptions.js';
 import Document from '../nodes/document/Document.js';
-import IHistoryItem from '../history/IHistoryItem.js';
-import HistoryScrollRestorationEnum from '../history/HistoryScrollRestorationEnum.js';
+import HistoryItemList from '../history/HistoryItemList.js';
 
 /**
  * Browser frame.
@@ -23,22 +22,13 @@ export default class BrowserFrame implements IBrowserFrame {
 	public readonly parentFrame: BrowserFrame | null = null;
 	public readonly page: BrowserPage;
 	public readonly window: BrowserWindow;
-	public [PropertySymbol.asyncTaskManager] = new AsyncTaskManager(this);
+	public readonly closed: boolean = false;
+	public [PropertySymbol.asyncTaskManager]: AsyncTaskManager = new AsyncTaskManager(this);
 	public [PropertySymbol.listeners]: { navigation: Array<() => void> } = { navigation: [] };
 	public [PropertySymbol.openerFrame]: IBrowserFrame | null = null;
 	public [PropertySymbol.openerWindow]: BrowserWindow | CrossOriginBrowserWindow | null = null;
 	public [PropertySymbol.popup] = false;
-	public [PropertySymbol.history]: IHistoryItem[] = [
-		{
-			title: '',
-			href: 'about:blank',
-			state: null,
-			scrollRestoration: HistoryScrollRestorationEnum.auto,
-			method: 'GET',
-			formData: null,
-			isCurrent: true
-		}
-	];
+	public [PropertySymbol.history] = new HistoryItemList();
 
 	/**
 	 * Constructor.

package/src/browser/BrowserPage.ts

@@ -10,7 +10,6 @@ import Response from '../fetch/Response.js';
 import IReloadOptions from './types/IReloadOptions.js';
 import IBrowserPageViewport from './types/IBrowserPageViewport.js';
 import IOptionalBrowserPageViewport from './types/IOptionalBrowserPageViewport.js';
-import DefaultBrowserPageViewport from './DefaultBrowserPageViewport.js';
 import Event from '../event/Event.js';
 
 /**
@@ -21,7 +20,8 @@ export default class BrowserPage implements IBrowserPage {
 	public readonly mainFrame: BrowserFrame;
 	public readonly context: BrowserContext;
 	public readonly console: Console;
-	public readonly viewport: IBrowserPageViewport = Object.assign({}, DefaultBrowserPageViewport);
+	public readonly viewport: IBrowserPageViewport;
+	public readonly closed: boolean = false;
 
 	/**
 	 * Constructor.
@@ -32,6 +32,11 @@ export default class BrowserPage implements IBrowserPage {
 		this.context = context;
 		this.console = context.browser.console ?? new VirtualConsole(this.virtualConsolePrinter);
 		this.mainFrame = new BrowserFrame(this);
+		this.viewport = {
+			width: context.browser.settings.viewport.width,
+			height: context.browser.settings.viewport.height,
+			devicePixelRatio: context.browser.settings.viewport.devicePixelRatio
+		};
 	}
 
 	/**

package/src/browser/BrowserSettingsFactory.ts

@@ -10,10 +10,12 @@ export default class BrowserSettingsFactory {
 	 * Returns browser settings.
 	 *
 	 * @param [settings] Browser settings.
-	 * @param [freezeObject] "true" to freeze the object.
 	 * @returns Settings.
 	 */
 	public static createSettings(settings?: IOptionalBrowserSettings): IBrowserSettings {
+		if (settings) {
+			this.validate(DefaultBrowserSettings, settings);
+		}
 		return {
 			...DefaultBrowserSettings,
 			...settings,
@@ -36,7 +38,54 @@ export default class BrowserSettingsFactory {
 			device: {
 				...DefaultBrowserSettings.device,
 				...settings?.device
+			},
+			debug: {
+				...DefaultBrowserSettings.debug,
+				...settings?.debug
+			},
+			viewport: {
+				...DefaultBrowserSettings.viewport,
+				...settings?.viewport
 			}
 		};
 	}
+
+	/**
+	 * Validates settings.
+	 *
+	 * @param target Target.
+	 * @param source Source.
+	 * @param [parentNamespace] Parent namespace.
+	 */
+	private static validate(target: any, source: any, parentNamespace?: string): void {
+		for (const key of Object.keys(source)) {
+			if (target[key] === undefined) {
+				const namespace = parentNamespace ? parentNamespace + '.' + key : key;
+				throw new Error(`Unknown browser setting "${namespace}"`);
+			}
+			if (typeof target[key] === 'object' && !Array.isArray(target[key]) && target[key] !== null) {
+				const namespace = parentNamespace ? parentNamespace + '.' + key : key;
+				if (typeof source[key] !== 'object' || Array.isArray(source[key]) || source[key] === null) {
+					throw new Error(`Browser setting "${namespace}" cannot be null`);
+				}
+				this.validate(target[key], source[key], namespace);
+			} else {
+				if (
+					(typeof target[key] === 'boolean' ||
+						typeof target[key] === 'number' ||
+						typeof target[key] === 'string') &&
+					typeof source[key] !== typeof target[key]
+				) {
+					const isValidPreventTimerLoops =
+						key === 'preventTimerLoops' && typeof source[key] === 'object' && source[key] !== null;
+					if (!isValidPreventTimerLoops) {
+						const namespace = parentNamespace ? parentNamespace + '.' + key : key;
+						throw new Error(
+							`Browser setting "${namespace}" must be of type "${typeof target[key]}"`
+						);
+					}
+				}
+			}
+		}
+	}
 }

package/src/browser/DefaultBrowserSettings.ts

@@ -5,13 +5,17 @@ import IBrowserSettings from './types/IBrowserSettings.js';
 
 export default <IBrowserSettings>{
 	disableJavaScriptEvaluation: false,
+	enableJavaScriptEvaluation: false,
 	disableJavaScriptFileLoading: false,
 	disableCSSFileLoading: false,
 	disableIframePageLoading: false,
 	disableComputedStyleRendering: false,
+	handleDisabledFileLoadingAsSuccess: false,
 	disableErrorCapturing: false,
 	errorCapture: BrowserErrorCaptureEnum.tryAndCatch,
 	enableFileSystemHttpRequests: false,
+	suppressCodeGenerationFromStringsWarning: false,
+	suppressInsecureJavaScriptEnvironmentWarning: false,
 	timer: {
 		maxTimeout: -1,
 		maxIntervalTime: -1,
@@ -20,7 +24,9 @@ export default <IBrowserSettings>{
 	},
 	fetch: {
 		disableSameOriginPolicy: false,
+		disableStrictSSL: false,
 		interceptor: null,
+		requestHeaders: null,
 		virtualServers: null
 	},
 	navigation: {
@@ -28,7 +34,8 @@ export default <IBrowserSettings>{
 		disableChildFrameNavigation: false,
 		disableChildPageNavigation: false,
 		disableFallbackToSetURL: false,
-		crossOriginPolicy: BrowserNavigationCrossOriginPolicyEnum.anyOrigin
+		crossOriginPolicy: BrowserNavigationCrossOriginPolicyEnum.anyOrigin,
+		beforeContentCallback: null
 	},
 	navigator: {
 		userAgent: `Mozilla/5.0 (X11; ${
@@ -38,6 +45,16 @@ export default <IBrowserSettings>{
 	},
 	device: {
 		prefersColorScheme: 'light',
-		mediaType: 'screen'
+		prefersReducedMotion: 'no-preference',
+		mediaType: 'screen',
+		forcedColors: 'none'
+	},
+	debug: {
+		traceWaitUntilComplete: -1
+	},
+	viewport: {
+		width: 1024,
+		height: 768,
+		devicePixelRatio: 1
 	}
 };

package/src/browser/detached-browser/DetachedBrowser.ts

@@ -9,11 +9,10 @@ import BrowserWindow from '../../window/BrowserWindow.js';
 import * as PropertySymbol from '../../PropertySymbol.js';
 import BrowserErrorCaptureEnum from '../enums/BrowserErrorCaptureEnum.js';
 import BrowserExceptionObserver from '../utilities/BrowserExceptionObserver.js';
+import BrowserContext from '../BrowserContext.js';
 
 /**
  * Detached browser used when constructing a Window instance without a browser.
- *
- * Much of the interface for the browser has been taken from Puppeteer and Playwright, so that the API is familiar.
  */
 export default class DetachedBrowser implements IBrowser {
 	public readonly contexts: DetachedBrowserContext[];
@@ -22,7 +21,7 @@ export default class DetachedBrowser implements IBrowser {
 	public readonly windowClass: new (
 		browserFrame: IBrowserFrame,
 		options?: { url?: string; width?: number; height?: number }
-	) => BrowserWindow | null;
+	) => BrowserWindow;
 	public [PropertySymbol.exceptionObserver]: BrowserExceptionObserver | null = null;
 
 	/**
@@ -50,6 +49,15 @@ export default class DetachedBrowser implements IBrowser {
 		this.contexts.push(new DetachedBrowserContext(this));
 	}
 
+	/**
+	 * Returns true if the browser is closed.
+	 *
+	 * @returns True if the browser is closed.
+	 */
+	public get closed(): boolean {
+		return this.contexts.length === 0;
+	}
+
 	/**
 	 * Returns the default context.
 	 *
@@ -66,10 +74,12 @@ export default class DetachedBrowser implements IBrowser {
 	 * Aborts all ongoing operations and destroys the browser.
 	 */
 	public async close(): Promise<void> {
-		await Promise.all(this.contexts.slice().map((context) => context.close()));
-		(<DetachedBrowserContext[]>this.contexts) = [];
-		(<Console | null>this.console) = null;
-		(<(new (browserFrame: IBrowserFrame) => BrowserWindow) | null>this.windowClass) = null;
+		if (this.contexts.length === 0) {
+			return;
+		}
+		const contexts = this.contexts;
+		(<BrowserContext[]>this.contexts) = [];
+		await Promise.all(contexts.map((context) => context.close()));
 	}
 
 	/**

package/src/browser/detached-browser/DetachedBrowserContext.ts

@@ -17,6 +17,7 @@ export default class DetachedBrowserContext implements IBrowserContext {
 	public readonly cookieContainer: ICookieContainer = new CookieContainer();
 	public readonly responseCache: IResponseCache = new ResponseCache();
 	public readonly preflightResponseCache: IPreflightResponseCache = new PreflightResponseCache();
+	public readonly closed: boolean = false;
 
 	/**
 	 * Constructor.
@@ -33,25 +34,31 @@ export default class DetachedBrowserContext implements IBrowserContext {
 	 * Aborts all ongoing operations and destroys the context.
 	 */
 	public async close(): Promise<void> {
-		if (!this.browser) {
+		if (this.closed) {
 			return;
 		}
+
+		if (this.browser.contexts[0] === this) {
+			throw new Error(
+				'Cannot close the default context. Use `browser.close()` to close the browser instead.'
+			);
+		}
+
+		(<boolean>this.closed) = true;
+
 		await Promise.all(this.pages.slice().map((page) => page.close()));
+
 		const browser = this.browser;
 		const index = browser.contexts.indexOf(this);
+
 		if (index !== -1) {
 			browser.contexts.splice(index, 1);
 		}
+
 		(<DetachedBrowserPage[]>this.pages) = [];
-		(<DetachedBrowser | null>this.browser) = null;
-		(<ICookieContainer | null>this.cookieContainer) = null;
+		this.cookieContainer.clearCookies();
 		this.responseCache.clear();
 		this.preflightResponseCache.clear();
-		(<ResponseCache | null>this.responseCache) = null;
-		(<PreflightResponseCache | null>this.preflightResponseCache) = null;
-		if (browser.contexts.length === 0) {
-			browser.close();
-		}
 	}
 
 	/**