happy-dom 16.8.1 → 20.0.2

package/src/console/VirtualConsolePrinter.ts

@@ -13,6 +13,16 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 		print: Array<(event: Event) => void>;
 		clear: Array<(event: Event) => void>;
 	} = { print: [], clear: [] };
+	#closed = false;
+
+	/**
+	 * Returns closed state.
+	 *
+	 * @returns True if the printer is closed.
+	 */
+	public get closed(): boolean {
+		return this.#closed;
+	}
 
 	/**
 	 * Writes to the output.
@@ -20,6 +30,9 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * @param logEntry Log entry.
 	 */
 	public print(logEntry: IVirtualConsoleLogEntry): void {
+		if (this.#closed) {
+			return;
+		}
 		this.#logEntries.push(logEntry);
 		this.dispatchEvent(new Event('print'));
 	}
@@ -28,10 +41,25 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * Clears the output.
 	 */
 	public clear(): void {
+		if (this.#closed) {
+			return;
+		}
 		this.#logEntries = [];
 		this.dispatchEvent(new Event('clear'));
 	}
 
+	/**
+	 * Clears and closes the virtual console printer.
+	 */
+	public close(): void {
+		if (this.#closed) {
+			return;
+		}
+		this.#logEntries = [];
+		this.#listeners = { print: [], clear: [] };
+		this.#closed = true;
+	}
+
 	/**
 	 * Adds an event listener.
 	 *
@@ -39,6 +67,9 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * @param listener Listener.
 	 */
 	public addEventListener(eventType: 'print' | 'clear', listener: (event: Event) => void): void {
+		if (this.#closed) {
+			return;
+		}
 		if (!this.#listeners[eventType]) {
 			throw new Error(`Event type "${eventType}" is not supported.`);
 		}
@@ -52,6 +83,9 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * @param listener Listener.
 	 */
 	public removeEventListener(eventType: 'print' | 'clear', listener: (event: Event) => void): void {
+		if (this.#closed) {
+			return;
+		}
 		if (!this.#listeners[eventType]) {
 			throw new Error(`Event type "${eventType}" is not supported.`);
 		}
@@ -67,11 +101,18 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * @param event Event.
 	 */
 	public dispatchEvent(event: Event): void {
-		if (!this.#listeners[event.type]) {
-			throw new Error(`Event type "${event.type}" is not supported.`);
+		if (this.#closed) {
+			return;
 		}
-		for (const listener of this.#listeners[event.type]) {
-			listener(event);
+		switch (event.type) {
+			case 'print':
+			case 'clear':
+				for (const listener of this.#listeners[event.type]) {
+					listener(event);
+				}
+				break;
+			default:
+				throw new Error(`Event type "${event.type}" is not supported.`);
 		}
 	}
 

package/src/console/utilities/VirtualConsoleLogEntryStringifier.ts

@@ -27,7 +27,7 @@ export default class VirtualConsoleLogEntryStringifier {
 				try {
 					output += JSON.stringify(part);
 				} catch (error) {
-					output += new Error('Failed to JSON stringify object in log entry.').stack.replace(
+					output += new Error('Failed to JSON stringify object in log entry.').stack!.replace(
 						/\n    at/gm,
 						'\n    ' + tabbing + 'at'
 					);

package/src/cookie/CookieContainer.ts

@@ -21,13 +21,13 @@ export default class CookieContainer implements ICookieContainer {
 	 * @param cookies Cookies.
 	 */
 	public addCookies(cookies: IOptionalCookie[]): void {
-		const indexMap: { [k: string]: number } = {};
+		const indexMap: Map<string, number> = new Map();
 		const getKey = (cookie: ICookie): string =>
 			`${cookie.key}-${cookie.originURL.hostname}-${cookie.path}-${typeof cookie.value}`;
 
 		// Creates a map of cookie key, domain, path and value to index.
 		for (let i = 0, max = this.#cookies.length; i < max; i++) {
-			indexMap[getKey(this.#cookies[i])] = i;
+			indexMap.set(getKey(this.#cookies[i]), i);
 		}
 
 		for (const cookie of cookies) {
@@ -35,14 +35,14 @@ export default class CookieContainer implements ICookieContainer {
 
 			if (newCookie && newCookie.key && newCookie.originURL) {
 				// Remove existing cookie with same name, domain and path.
-				const index = indexMap[getKey(newCookie)];
+				const index = indexMap.get(getKey(newCookie));
 
 				if (index !== undefined) {
 					this.#cookies.splice(index, 1);
 				}
 
 				if (!CookieExpireUtility.hasExpired(newCookie)) {
-					indexMap[getKey(newCookie)] = this.#cookies.length;
+					indexMap.set(getKey(newCookie), this.#cookies.length);
 					this.#cookies.push(newCookie);
 				}
 			}
@@ -71,4 +71,11 @@ export default class CookieContainer implements ICookieContainer {
 
 		return cookies;
 	}
+
+	/**
+	 * Clears all cookies.
+	 */
+	public clearCookies(): void {
+		this.#cookies = [];
+	}
 }

package/src/cookie/DefaultCookie.ts

@@ -3,8 +3,8 @@ import ICookie from './ICookie.js';
 
 export default <ICookie>{
 	// Required
-	key: null,
-	originURL: null,
+	key: null!,
+	originURL: null!,
 
 	// Optional
 	value: null,

package/src/cookie/ICookieContainer.ts

@@ -23,5 +23,10 @@ export default interface ICookieContainer {
 	 * @param [httpOnly] "true" if only http cookies should be returned.
 	 * @returns Cookies.
 	 */
-	getCookies(url: URL | null, httpOnly?: boolean): ICookie[];
+	getCookies(url?: URL | null, httpOnly?: boolean): ICookie[];
+
+	/**
+	 * Clears all cookies.
+	 */
+	clearCookies(): void;
 }

package/src/cookie/urilities/CookieStringUtility.ts

@@ -2,6 +2,7 @@ import CookieSameSiteEnum from '../enums/CookieSameSiteEnum.js';
 import URL from '../../url/URL.js';
 import ICookie from '../ICookie.js';
 import DefaultCookie from '../DefaultCookie.js';
+import Location from '../../location/Location.js';
 
 /**
  * Cookie string.
@@ -14,9 +15,14 @@ export default class CookieStringUtility {
 	 * @param cookieString Cookie string.
 	 * @returns Cookie.
 	 */
-	public static stringToCookie(originURL: URL, cookieString: string): ICookie | null {
+	public static stringToCookie(originURL: URL | Location, cookieString: string): ICookie | null {
 		const parts = cookieString.split(';');
 		const part = parts.shift();
+
+		if (!part) {
+			return null;
+		}
+
 		const index = part.indexOf('=');
 		const key = index !== -1 ? part.slice(0, index).trim() : part.trim();
 		const value = index !== -1 ? part.slice(index + 1).trim() : null;

package/src/cookie/urilities/CookieURLUtility.ts

@@ -14,8 +14,9 @@ export default class CookieURLUtility {
 	 * @returns "true" if cookie matches URL.
 	 */
 	public static cookieMatchesURL(cookie: ICookie, url: URL): boolean {
+		const isLocalhost = url.hostname === 'localhost' || url.hostname.endsWith('.localhost');
 		return (
-			(!cookie.secure || url.protocol === 'https:') &&
+			(!cookie.secure || url.protocol === 'https:' || isLocalhost) &&
 			(!cookie.domain || url.hostname.endsWith(cookie.domain)) &&
 			(!cookie.path || url.pathname.startsWith(cookie.path)) &&
 			// @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value

package/src/css/CSS.ts

@@ -1,6 +1,5 @@
 import CSSEscaper from './utilities/CSSEscaper.js';
 import CSSUnitValue from './CSSUnitValue.js';
-import CSSUnits from './CSSUnits.js';
 
 /**
  * The CSS interface holds useful CSS-related methods.
@@ -9,14 +8,35 @@ import CSSUnits from './CSSUnits.js';
  * https://developer.mozilla.org/en-US/docs/Web/API/CSS.
  */
 export default class CSS {
-	/**
-	 * Constructor.
-	 */
-	constructor() {
-		for (const unit of CSSUnits) {
-			this[unit] = (value: number) => new CSSUnitValue(value, unit);
-		}
-	}
+	public readonly Hz = (value: number): CSSUnitValue => new CSSUnitValue(value, 'Hz');
+	public readonly Q = (value: number): CSSUnitValue => new CSSUnitValue(value, 'Q');
+	public readonly ch = (value: number): CSSUnitValue => new CSSUnitValue(value, 'ch');
+	public readonly cm = (value: number): CSSUnitValue => new CSSUnitValue(value, 'cm');
+	public readonly deg = (value: number): CSSUnitValue => new CSSUnitValue(value, 'deg');
+	public readonly dpcm = (value: number): CSSUnitValue => new CSSUnitValue(value, 'dpcm');
+	public readonly dpi = (value: number): CSSUnitValue => new CSSUnitValue(value, 'dpi');
+	public readonly dppx = (value: number): CSSUnitValue => new CSSUnitValue(value, 'dppx');
+	public readonly em = (value: number): CSSUnitValue => new CSSUnitValue(value, 'em');
+	public readonly ex = (value: number): CSSUnitValue => new CSSUnitValue(value, 'ex');
+	public readonly fr = (value: number): CSSUnitValue => new CSSUnitValue(value, 'fr');
+	public readonly grad = (value: number): CSSUnitValue => new CSSUnitValue(value, 'grad');
+	public readonly in = (value: number): CSSUnitValue => new CSSUnitValue(value, 'in');
+	public readonly kHz = (value: number): CSSUnitValue => new CSSUnitValue(value, 'kHz');
+	public readonly mm = (value: number): CSSUnitValue => new CSSUnitValue(value, 'mm');
+	public readonly ms = (value: number): CSSUnitValue => new CSSUnitValue(value, 'ms');
+	public readonly number = (value: number): CSSUnitValue => new CSSUnitValue(value, 'number');
+	public readonly pc = (value: number): CSSUnitValue => new CSSUnitValue(value, 'pc');
+	public readonly percent = (value: number): CSSUnitValue => new CSSUnitValue(value, 'percent');
+	public readonly pt = (value: number): CSSUnitValue => new CSSUnitValue(value, 'pt');
+	public readonly px = (value: number): CSSUnitValue => new CSSUnitValue(value, 'px');
+	public readonly rad = (value: number): CSSUnitValue => new CSSUnitValue(value, 'rad');
+	public readonly rem = (value: number): CSSUnitValue => new CSSUnitValue(value, 'rem');
+	public readonly s = (value: number): CSSUnitValue => new CSSUnitValue(value, 's');
+	public readonly turn = (value: number): CSSUnitValue => new CSSUnitValue(value, 'turn');
+	public readonly vh = (value: number): CSSUnitValue => new CSSUnitValue(value, 'vh');
+	public readonly vmax = (value: number): CSSUnitValue => new CSSUnitValue(value, 'vmax');
+	public readonly vmin = (value: number): CSSUnitValue => new CSSUnitValue(value, 'vmin');
+	public readonly vw = (value: number): CSSUnitValue => new CSSUnitValue(value, 'vw');
 
 	/**
 	 * Returns a Boolean indicating if the pair property-value, or the condition, given in parameter is supported.

package/src/css/CSSRule.ts

@@ -2,11 +2,14 @@ import CSSStyleSheet from './CSSStyleSheet.js';
 import CSSRuleTypeEnum from './CSSRuleTypeEnum.js';
 import * as PropertySymbol from '../PropertySymbol.js';
 import BrowserWindow from '../window/BrowserWindow.js';
+import CSSParser from './utilities/CSSParser.js';
 
 /**
  * CSSRule interface.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CSSRule
  */
-export default class CSSRule {
+export default abstract class CSSRule {
 	// Static properties
 	public static CONTAINER_RULE = CSSRuleTypeEnum.containerRule;
 	public static STYLE_RULE = CSSRuleTypeEnum.styleRule;
@@ -25,32 +28,57 @@ export default class CSSRule {
 
 	// Internal properties
 	public [PropertySymbol.window]: BrowserWindow;
+	public [PropertySymbol.cssParser]: CSSParser;
 
 	// Public properties
-	public parentRule: CSSRule = null;
-	public parentStyleSheet: CSSStyleSheet = null;
-	public type: number = null;
+	public [PropertySymbol.parentRule]: CSSRule | null = null;
+	public [PropertySymbol.parentStyleSheet]: CSSStyleSheet | null = null;
 
 	/**
 	 * Constructor.
 	 *
 	 * @param illegalConstructorSymbol Illegal constructor symbol.
 	 * @param window Window.
+	 * @param cssParser CSS parser.
 	 */
-	constructor(illegalConstructorSymbol: Symbol, window: BrowserWindow) {
+	constructor(illegalConstructorSymbol: Symbol, window: BrowserWindow, cssParser: CSSParser) {
 		if (illegalConstructorSymbol !== PropertySymbol.illegalConstructor) {
 			throw new TypeError('Illegal constructor');
 		}
 
 		this[PropertySymbol.window] = window;
+		this[PropertySymbol.cssParser] = cssParser;
 	}
 
 	/**
-	 * Returns selector text.
+	 * Returns parent rule.
 	 *
-	 * @returns Selector text.
+	 * @returns Parent rule.
 	 */
-	public get cssText(): string {
-		return '';
+	public get parentRule(): CSSRule | null {
+		return this[PropertySymbol.parentRule];
 	}
+
+	/**
+	 * Returns parent style sheet.
+	 *
+	 * @returns Parent style sheet.
+	 */
+	public get parentStyleSheet(): CSSStyleSheet | null {
+		return this[PropertySymbol.parentStyleSheet];
+	}
+
+	/**
+	 * Returns type.
+	 *
+	 * @returns Type.
+	 */
+	public abstract get type(): CSSRuleTypeEnum;
+
+	/**
+	 * Returns CSS text.
+	 *
+	 * @returns CSS text.
+	 */
+	public abstract get cssText(): string;
 }

package/src/css/CSSStyleSheet.ts

@@ -15,9 +15,6 @@ export default class CSSStyleSheet {
 	// Injected by WindowContextClassExtender
 	protected declare [PropertySymbol.window]: BrowserWindow;
 
-	public value: string = null;
-	public name: string = null;
-	public namespaceURI: string = null;
 	public readonly cssRules: CSSRule[] = [];
 
 	// TODO: MediaList is not fully implemented.
@@ -25,7 +22,7 @@ export default class CSSStyleSheet {
 	public title: string;
 	public alternate: boolean;
 	public disabled: boolean;
-	#currentText: string = null;
+	#currentText: string | null = null;
 
 	/**
 	 * Constructor.
@@ -57,18 +54,18 @@ export default class CSSStyleSheet {
 	 * @returns The newly inserterted rule's index.
 	 */
 	public insertRule(rule: string, index?: number): number {
-		const rules = CSSParser.parseFromString(this, rule);
-
-		if (rules.length === 0) {
-			throw new this[PropertySymbol.window].DOMException(
-				'Invalid CSS rule.',
-				DOMExceptionNameEnum.hierarchyRequestError
+		if (arguments.length === 0) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'insertRule' on 'CSSStyleSheet': 1 argument required, but only 0 present.`
 			);
 		}
 
-		if (rules.length > 1) {
+		const parser = new CSSParser(this);
+		const rules = parser.parseFromString(rule);
+
+		if (rules.length === 0 || rules.length > 1) {
 			throw new this[PropertySymbol.window].DOMException(
-				'Only one rule is allowed to be added.',
+				`Failed to execute 'insertRule' on 'CSSStyleSheet': Failed to parse the rule '${rule}'.`,
 				DOMExceptionNameEnum.syntaxError
 			);
 		}
@@ -76,7 +73,9 @@ export default class CSSStyleSheet {
 		if (index !== undefined) {
 			if (index > this.cssRules.length) {
 				throw new this[PropertySymbol.window].DOMException(
-					'Index is more than the length of CSSRuleList.',
+					`Failed to execute 'insertRule' on 'CSSStyleSheet': The index provided (${index}) is larger than the maximum index (${
+						this.cssRules.length - 1
+					}).`,
 					DOMExceptionNameEnum.indexSizeError
 				);
 			}
@@ -98,7 +97,12 @@ export default class CSSStyleSheet {
 	 * @param index Index.
 	 */
 	public deleteRule(index: number): void {
-		delete this.cssRules[index];
+		if (arguments.length === 0) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'deleteRule' on 'CSSStyleSheet': 1 argument required, but only 0 present.`
+			);
+		}
+		this.cssRules.splice(index, 1);
 	}
 
 	/**
@@ -109,6 +113,11 @@ export default class CSSStyleSheet {
 	 * @returns Promise.
 	 */
 	public async replace(text: string): Promise<void> {
+		if (arguments.length === 0) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'replace' on 'CSSStyleSheet': 1 argument required, but only 0 present.`
+			);
+		}
 		this.replaceSync(text);
 	}
 
@@ -119,9 +128,14 @@ export default class CSSStyleSheet {
 	 * @param text CSS text.
 	 */
 	public replaceSync(text: string): void {
+		if (arguments.length === 0) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'replaceSync' on 'CSSStyleSheet': 1 argument required, but only 0 present.`
+			);
+		}
 		if (this.#currentText !== text) {
 			this.#currentText = text;
-			(<CSSRule[]>this.cssRules) = CSSParser.parseFromString(this, text);
+			(<CSSRule[]>this.cssRules) = new CSSParser(this).parseFromString(text);
 		}
 	}
 }

package/src/css/CSSUnitValue.ts

@@ -4,8 +4,8 @@ import CSSUnits from './CSSUnits.js';
  * CSS unit value.
  */
 export default class CSSUnitValue {
-	public unit: string = null;
-	public value: number = null;
+	public unit: string;
+	public value: number;
 
 	/**
 	 * Constructor.

package/src/css/MediaList.ts

@@ -1,20 +1,127 @@
+import CSSMediaRule from './rules/CSSMediaRule.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import ClassMethodBinder from '../utilities/ClassMethodBinder.js';
+
+const MEDIUM_REGEXP = /\s*,\s*/;
+
 /**
  * MediaList interface.
  */
 export default class MediaList {
-	public readonly length = 0;
+	[index: number]: string;
+	public [PropertySymbol.cssRule]: CSSMediaRule;
+
+	/**
+	 *
+	 * @param illegalConstructorSymbol
+	 * @param cssRule
+	 */
+	constructor(illegalConstructorSymbol: Symbol, cssRule: CSSMediaRule) {
+		if (illegalConstructorSymbol !== PropertySymbol.illegalConstructor) {
+			throw new TypeError('Illegal constructor');
+		}
+
+		this[PropertySymbol.cssRule] = cssRule;
+
+		const methodBinder = new ClassMethodBinder(this, [MediaList]);
+
+		return new Proxy(this, {
+			get: (target, property) => {
+				if (property in target || typeof property === 'symbol') {
+					methodBinder.bind(property);
+					return (<any>target)[property];
+				}
+				const index = Number(property);
+				if (!isNaN(index)) {
+					return (<any>target)[PropertySymbol.getItemList]()[index];
+				}
+			},
+			set(target, property, newValue): boolean {
+				methodBinder.bind(property);
+				if (property in target || typeof property === 'symbol') {
+					(<any>target)[property] = newValue;
+					return true;
+				}
+				return true;
+			},
+			deleteProperty(target, property): boolean {
+				if (property in target || typeof property === 'symbol') {
+					delete (<any>target)[property];
+					return true;
+				}
+				return true;
+			},
+			ownKeys(target): string[] {
+				return Object.keys(target[PropertySymbol.getItemList]());
+			},
+			has(target, property): boolean {
+				if (typeof property === 'symbol') {
+					return false;
+				}
+
+				if (property in target) {
+					return true;
+				}
+
+				const index = Number(property);
+				return !isNaN(index) && index >= 0 && index < target[PropertySymbol.getItemList]().length;
+			},
+			defineProperty(target, property, descriptor): boolean {
+				methodBinder.preventBinding(property);
+
+				if (property in target) {
+					Object.defineProperty(target, property, descriptor);
+					return true;
+				}
+
+				return false;
+			},
+			getOwnPropertyDescriptor(target, property): PropertyDescriptor | undefined {
+				if (property in target || typeof property === 'symbol') {
+					return;
+				}
+
+				const index = Number(property);
+				const items = target[PropertySymbol.getItemList]();
+
+				if (!isNaN(index) && items[index]) {
+					return {
+						value: items[index],
+						writable: false,
+						enumerable: true,
+						configurable: true
+					};
+				}
+			}
+		});
+	}
+
+	/**
+	 * Returns length.
+	 *
+	 * @returns Length.
+	 */
+	public get length(): number {
+		return this[PropertySymbol.getItemList]().length;
+	}
 
 	/**
-	 * Media text.
+	 * Returns media text.
 	 *
 	 * @returns Media text.
 	 */
 	public get mediaText(): string {
-		const mediaText = [];
-		for (let i = 0; i < this.length; i++) {
-			mediaText.push(this[i]);
-		}
-		return mediaText.join(', ');
+		return this[PropertySymbol.cssRule][PropertySymbol.conditionText];
+	}
+
+	/**
+	 * Sets media text.
+	 *
+	 * @param mediaText Media text.
+	 */
+	public set mediaText(mediaText: string | null) {
+		this[PropertySymbol.cssRule][PropertySymbol.conditionText] =
+			mediaText === null ? '' : String(mediaText).split(MEDIUM_REGEXP).join(', ');
 	}
 
 	/**
@@ -23,8 +130,9 @@ export default class MediaList {
 	 * @param index Index.
 	 * @returns Item.
 	 */
-	public item(index: number): string {
-		return this[index] || '';
+	public item(index: number): string | null {
+		const items = this[PropertySymbol.getItemList]();
+		return items[Number(index)] || null;
 	}
 
 	/**
@@ -33,8 +141,11 @@ export default class MediaList {
 	 * @param medium Medium.
 	 */
 	public appendMedium(medium: string): void {
-		this[this.length] = medium;
-		(<number>this.length)++;
+		const items = this[PropertySymbol.getItemList]();
+		if (items.indexOf(medium) === -1) {
+			items.push(medium);
+			this[PropertySymbol.cssRule][PropertySymbol.conditionText] = items.join(', ');
+		}
 	}
 
 	/**
@@ -43,17 +154,24 @@ export default class MediaList {
 	 * @param medium Medium.
 	 */
 	public deleteMedium(medium: string): void {
-		let isDeleted = false;
-		for (let i = 0; i < this.length; i++) {
-			if (isDeleted) {
-				this[i - 1] = this[i];
-			}
-			if (this[i] === medium) {
-				isDeleted = true;
-			}
-		}
-		if (isDeleted) {
-			(<number>this.length)--;
+		const items = this[PropertySymbol.getItemList]();
+		const index = items.indexOf(medium);
+		if (index !== -1) {
+			items.splice(index, 1);
+			this[PropertySymbol.cssRule][PropertySymbol.conditionText] = items.join(', ');
 		}
 	}
+
+	/**
+	 * Returns item list.
+	 *
+	 * @returns Item list.
+	 */
+	public [PropertySymbol.getItemList](): string[] {
+		const text = this[PropertySymbol.cssRule][PropertySymbol.conditionText].trim();
+		const media = text
+			? this[PropertySymbol.cssRule][PropertySymbol.conditionText].split(MEDIUM_REGEXP)
+			: [];
+		return media;
+	}
 }