happy-dom 12.10.3 → 13.0.1

package/src/console/VirtualConsolePrinter.ts

@@ -8,8 +8,8 @@ import IVirtualConsolePrinter from './types/IVirtualConsolePrinter.js';
  * Virtual console printer.
  */
 export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
-	private _logEntries: IVirtualConsoleLogEntry[] = [];
-	private _listeners: {
+	#logEntries: IVirtualConsoleLogEntry[] = [];
+	#listeners: {
 		print: Array<(event: Event) => void>;
 		clear: Array<(event: Event) => void>;
 	} = { print: [], clear: [] };
@@ -20,7 +20,7 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * @param logEntry Log entry.
 	 */
 	public print(logEntry: IVirtualConsoleLogEntry): void {
-		this._logEntries.push(logEntry);
+		this.#logEntries.push(logEntry);
 		this.dispatchEvent(new Event('print'));
 	}
 
@@ -28,7 +28,7 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * Clears the output.
 	 */
 	public clear(): void {
-		this._logEntries = [];
+		this.#logEntries = [];
 		this.dispatchEvent(new Event('clear'));
 	}
 
@@ -39,10 +39,10 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * @param listener Listener.
 	 */
 	public addEventListener(eventType: 'print' | 'clear', listener: (event: Event) => void): void {
-		if (!this._listeners[eventType]) {
+		if (!this.#listeners[eventType]) {
 			throw new Error(`Event type "${eventType}" is not supported.`);
 		}
-		this._listeners[eventType].push(listener);
+		this.#listeners[eventType].push(listener);
 	}
 
 	/**
@@ -52,12 +52,12 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * @param listener Listener.
 	 */
 	public removeEventListener(eventType: 'print' | 'clear', listener: (event: Event) => void): void {
-		if (!this._listeners[eventType]) {
+		if (!this.#listeners[eventType]) {
 			throw new Error(`Event type "${eventType}" is not supported.`);
 		}
-		const index = this._listeners[eventType].indexOf(listener);
+		const index = this.#listeners[eventType].indexOf(listener);
 		if (index !== -1) {
-			this._listeners[eventType].splice(index, 1);
+			this.#listeners[eventType].splice(index, 1);
 		}
 	}
 
@@ -67,10 +67,10 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * @param event Event.
 	 */
 	public dispatchEvent(event: Event): void {
-		if (!this._listeners[event.type]) {
+		if (!this.#listeners[event.type]) {
 			throw new Error(`Event type "${event.type}" is not supported.`);
 		}
-		for (const listener of this._listeners[event.type]) {
+		for (const listener of this.#listeners[event.type]) {
 			listener(event);
 		}
 	}
@@ -81,8 +81,8 @@ export default class VirtualConsolePrinter implements IVirtualConsolePrinter {
 	 * @returns Console log entries.
 	 */
 	public read(): IVirtualConsoleLogEntry[] {
-		const logEntries = this._logEntries;
-		this._logEntries = [];
+		const logEntries = this.#logEntries;
+		this.#logEntries = [];
 		return logEntries;
 	}
 

package/src/console/types/IVirtualConsolePrinter.ts

@@ -54,5 +54,5 @@ export default interface IVirtualConsolePrinter {
 	 * @param [logLevel] Log level.
 	 * @returns Buffer as a string of concatenated log entries.
 	 */
-	readAsString(logLevel: VirtualConsoleLogLevelEnum): string;
+	readAsString(logLevel?: VirtualConsoleLogLevelEnum): string;
 }

package/src/cookie/CookieContainer.ts

@@ -0,0 +1,72 @@
+import URL from '../url/URL.js';
+import ICookie from './types/ICookie.js';
+import ICookieContainer from './types/ICookieContainer.js';
+import CookieExpireUtility from './urilities/CookieExpireUtility.js';
+import CookieURLUtility from './urilities/CookieURLUtility.js';
+
+/**
+ * Cookie Container.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cookie.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie.
+ */
+export default class CookieContainer implements ICookieContainer {
+	#cookies: ICookie[] = [];
+
+	/**
+	 * Adds cookies.
+	 *
+	 * @param cookies Cookies.
+	 */
+	public addCookies(cookies: ICookie[]): void {
+		const indexMap: { [k: string]: number } = {};
+		const getKey = (cookie: ICookie): string =>
+			`${cookie.key}-${cookie.originURL.hostname}-${
+				cookie.originURL.pathname
+			}-${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;
+		}
+
+		for (const cookie of cookies) {
+			if (cookie?.key) {
+				// Remove existing cookie with same name, domain and path.
+				const index = indexMap[getKey(cookie)];
+
+				if (index !== undefined) {
+					this.#cookies.splice(index, 1);
+				}
+
+				if (!CookieExpireUtility.hasExpired(cookie)) {
+					indexMap[getKey(cookie)] = this.#cookies.length;
+					this.#cookies.push(cookie);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Returns cookies.
+	 *
+	 * @param [url] URL.
+	 * @param [httpOnly] "true" if only http cookies should be returned.
+	 * @returns Cookies.
+	 */
+	public getCookies(url: URL | null = null, httpOnly = false): ICookie[] {
+		const cookies = [];
+
+		for (const cookie of this.#cookies) {
+			if (
+				!CookieExpireUtility.hasExpired(cookie) &&
+				(!httpOnly || !cookie.httpOnly) &&
+				(!url || CookieURLUtility.cookieMatchesURL(cookie, url || cookie.originURL))
+			) {
+				cookies.push(cookie);
+			}
+		}
+
+		return cookies;
+	}
+}

package/src/cookie/types/ICookie.ts

@@ -0,0 +1,16 @@
+import CookieSameSiteEnum from '../enums/CookieSameSiteEnum.js';
+
+export default interface ICookie {
+	// Required
+	key: string;
+	value: string | null;
+	originURL: URL;
+
+	// Optional
+	domain: string;
+	path: string;
+	expires: Date | null;
+	httpOnly: boolean;
+	secure: boolean;
+	sameSite: CookieSameSiteEnum;
+}

package/src/cookie/types/ICookieContainer.ts

@@ -0,0 +1,26 @@
+import URL from '../../url/URL.js';
+import ICookie from '../types/ICookie.js';
+
+/**
+ * Cookie Container.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cookie.
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie.
+ */
+export default interface ICookieContainer {
+	/**
+	 * Adds cookies.
+	 *
+	 * @param cookies Cookies.
+	 */
+	addCookies(cookies: ICookie[]): void;
+
+	/**
+	 * Returns cookies.
+	 *
+	 * @param [url] URL.
+	 * @param [httpOnly] "true" if only http cookies should be returned.
+	 * @returns Cookies.
+	 */
+	getCookies(url: URL | null, httpOnly: boolean): ICookie[];
+}

package/src/cookie/urilities/CookieExpireUtility.ts

@@ -0,0 +1,16 @@
+import ICookie from '../types/ICookie.js';
+
+/**
+ * Cookie expire utility.
+ */
+export default class CookieExpireUtility {
+	/**
+	 * Returns "true" if cookie has expired.
+	 *
+	 * @param cookie Cookie.
+	 * @returns "true" if cookie has expired.
+	 */
+	public static hasExpired(cookie: ICookie): boolean {
+		return cookie.expires && cookie.expires.getTime() < Date.now();
+	}
+}

package/src/cookie/urilities/CookieStringUtility.ts

@@ -0,0 +1,116 @@
+import CookieSameSiteEnum from '../enums/CookieSameSiteEnum.js';
+import URL from '../../url/URL.js';
+import ICookie from '../types/ICookie.js';
+
+/**
+ * Cookie string.
+ */
+export default class CookieStringUtility {
+	/**
+	 * Returns cookie.
+	 *
+	 * @param originURL Origin URL.
+	 * @param cookieString Cookie string.
+	 * @returns Cookie.
+	 */
+	public static stringToCookie(originURL: URL, cookieString: string): ICookie | null {
+		const parts = cookieString.split(';');
+		const [key, value] = parts.shift().split('=');
+
+		const cookie: ICookie = {
+			// Required
+			key: key.trim(),
+			value: value ?? null,
+			originURL,
+
+			// Optional
+			domain: '',
+			path: '',
+			expires: null,
+			httpOnly: false,
+			secure: false,
+			sameSite: CookieSameSiteEnum.lax
+		};
+
+		// Invalid if key is empty.
+		if (!cookie.key) {
+			return null;
+		}
+
+		for (const part of parts) {
+			const keyAndValue = part.split('=');
+			const key = keyAndValue[0].trim().toLowerCase();
+			const value = keyAndValue[1];
+
+			switch (key) {
+				case 'expires':
+					cookie.expires = new Date(value);
+					break;
+				case 'max-age':
+					cookie.expires = new Date(parseInt(value, 10) * 1000 + Date.now());
+					break;
+				case 'domain':
+					cookie.domain = value;
+					break;
+				case 'path':
+					cookie.path = value.startsWith('/') ? value : `/${value}`;
+					break;
+				case 'httponly':
+					cookie.httpOnly = true;
+					break;
+				case 'secure':
+					cookie.secure = true;
+					break;
+				case 'samesite':
+					switch (value.toLowerCase()) {
+						case 'strict':
+							cookie.sameSite = CookieSameSiteEnum.strict;
+							break;
+						case 'lax':
+							cookie.sameSite = CookieSameSiteEnum.lax;
+							break;
+						case 'none':
+							cookie.sameSite = CookieSameSiteEnum.none;
+					}
+					break;
+			}
+		}
+
+		const lowerKey = cookie.key.toLowerCase();
+
+		// Invalid if __secure- prefix is used and cookie is not secure.
+		if (lowerKey.startsWith('__secure-') && !cookie.secure) {
+			return null;
+		}
+
+		// Invalid if __host- prefix is used and cookie is not secure, not on root path or has a domain.
+		if (
+			lowerKey.startsWith('__host-') &&
+			(!cookie.secure || cookie.path !== '/' || cookie.domain)
+		) {
+			return null;
+		}
+
+		return cookie;
+	}
+
+	/**
+	 * Returns cookie string with key and value.
+	 *
+	 * @param cookies Cookies.
+	 * @returns Cookie string.
+	 */
+	public static cookiesToString(cookies: ICookie[]): string {
+		const cookieString: string[] = [];
+
+		for (const cookie of cookies) {
+			if (cookie.value !== null) {
+				cookieString.push(`${cookie.key}=${cookie.value}`);
+			} else {
+				cookieString.push(cookie.key);
+			}
+		}
+
+		return cookieString.join('; ');
+	}
+}

package/src/cookie/urilities/CookieURLUtility.ts

@@ -0,0 +1,26 @@
+import CookieSameSiteEnum from '../enums/CookieSameSiteEnum.js';
+import URL from '../../url/URL.js';
+import ICookie from '../types/ICookie.js';
+
+/**
+ * Cookie string.
+ */
+export default class CookieURLUtility {
+	/**
+	 * Returns "true" if cookie matches URL.
+	 *
+	 * @param cookie Cookie.
+	 * @param url URL.
+	 * @returns "true" if cookie matches URL.
+	 */
+	public static cookieMatchesURL(cookie: ICookie, url: URL): boolean {
+		return (
+			(!cookie.secure || url.protocol === 'https:') &&
+			(!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
+			((cookie.sameSite === CookieSameSiteEnum.none && cookie.secure) ||
+				cookie.originURL.hostname === url.hostname)
+		);
+	}
+}

package/src/css/CSSParser.ts

@@ -1,4 +1,5 @@
 import CSSRule from './CSSRule.js';
+import * as PropertySymbol from '../PropertySymbol.js';
 import CSSStyleSheet from './CSSStyleSheet.js';
 import CSSStyleRule from './rules/CSSStyleRule.js';
 import CSSKeyframeRule from './rules/CSSKeyframeRule.js';
@@ -131,7 +132,7 @@ export default class CSSParser {
 						case CSSRule.FONT_FACE_RULE:
 						case CSSRule.KEYFRAME_RULE:
 						case CSSRule.STYLE_RULE:
-							(<CSSStyleRule>parentRule)._cssText = cssText;
+							(<CSSStyleRule>parentRule)[PropertySymbol.cssText] = cssText;
 							break;
 					}
 				}

package/src/css/CSSStyleSheet.ts

@@ -21,7 +21,7 @@ export default class CSSStyleSheet {
 	public title: string;
 	public alternate: boolean;
 	public disabled: boolean;
-	private _currentText: string = null;
+	#currentText: string = null;
 
 	/**
 	 * Constructor.
@@ -112,8 +112,8 @@ export default class CSSStyleSheet {
 	 * @param text CSS text.
 	 */
 	public replaceSync(text: string): void {
-		if (this._currentText !== text) {
-			this._currentText = text;
+		if (this.#currentText !== text) {
+			this.#currentText = text;
 			(<CSSRule[]>this.cssRules) = CSSParser.parseFromString(this, text);
 		}
 	}

package/src/css/declaration/AbstractCSSStyleDeclaration.ts

@@ -1,4 +1,5 @@
 import IElement from '../../nodes/element/IElement.js';
+import * as PropertySymbol from '../../PropertySymbol.js';
 import IAttr from '../../nodes/attr/IAttr.js';
 import CSSRule from '../CSSRule.js';
 import DOMExceptionNameEnum from '../../exception/DOMExceptionNameEnum.js';
@@ -12,10 +13,10 @@ import NamedNodeMap from '../../named-node-map/NamedNodeMap.js';
  */
 export default abstract class AbstractCSSStyleDeclaration {
 	public readonly parentRule: CSSRule = null;
-	protected _style: CSSStyleDeclarationPropertyManager = null;
-	protected _ownerElement: IElement;
-	protected _computed: boolean;
-	protected _elementStyle: CSSStyleDeclarationElementStyle = null;
+	#style: CSSStyleDeclarationPropertyManager = null;
+	#ownerElement: IElement;
+	#computed: boolean;
+	#elementStyle: CSSStyleDeclarationElementStyle = null;
 
 	/**
 	 * Constructor.
@@ -24,11 +25,11 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 * @param [computed] Computed.
 	 */
 	constructor(ownerElement: IElement = null, computed = false) {
-		this._style = !ownerElement ? new CSSStyleDeclarationPropertyManager() : null;
-		this._ownerElement = ownerElement;
-		this._computed = ownerElement ? computed : false;
-		this._elementStyle = ownerElement
-			? new CSSStyleDeclarationElementStyle(ownerElement, this._computed)
+		this.#style = !ownerElement ? new CSSStyleDeclarationPropertyManager() : null;
+		this.#ownerElement = ownerElement;
+		this.#computed = ownerElement ? computed : false;
+		this.#elementStyle = ownerElement
+			? new CSSStyleDeclarationElementStyle(ownerElement, this.#computed)
 			: null;
 	}
 
@@ -38,12 +39,12 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 * @returns Length.
 	 */
 	public get length(): number {
-		if (this._ownerElement) {
-			const style = this._elementStyle.getElementStyle();
+		if (this.#ownerElement) {
+			const style = this.#elementStyle.getElementStyle();
 			return style.size();
 		}
 
-		return this._style.size();
+		return this.#style.size();
 	}
 
 	/**
@@ -52,15 +53,15 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 * @returns CSS text.
 	 */
 	public get cssText(): string {
-		if (this._ownerElement) {
-			if (this._computed) {
+		if (this.#ownerElement) {
+			if (this.#computed) {
 				return '';
 			}
 
-			return this._elementStyle.getElementStyle().toString();
+			return this.#elementStyle.getElementStyle().toString();
 		}
 
-		return this._style.toString();
+		return this.#style.toString();
 	}
 
 	/**
@@ -69,32 +70,32 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 * @param cssText CSS text.
 	 */
 	public set cssText(cssText: string) {
-		if (this._computed) {
+		if (this.#computed) {
 			throw new DOMException(
 				`Failed to execute 'cssText' on 'CSSStyleDeclaration': These styles are computed, and the properties are therefore read-only.`,
 				DOMExceptionNameEnum.domException
 			);
 		}
 
-		if (this._ownerElement) {
+		if (this.#ownerElement) {
 			const style = new CSSStyleDeclarationPropertyManager({ cssText });
-			let styleAttribute = <IAttr>this._ownerElement.attributes['style'];
+			let styleAttribute = <IAttr>this.#ownerElement.attributes['style'];
 
 			if (!styleAttribute) {
-				styleAttribute = this._ownerElement.ownerDocument.createAttribute('style');
-				// We use "_setNamedItemWithoutConsequences" here to avoid triggering setting "Element.style.cssText" when setting the "style" attribute.
-				(<NamedNodeMap>this._ownerElement.attributes)._setNamedItemWithoutConsequences(
-					styleAttribute
-				);
+				styleAttribute = this.#ownerElement.ownerDocument.createAttribute('style');
+				// We use "[PropertySymbol.setNamedItemWithoutConsequences]" here to avoid triggering setting "Element.style.cssText" when setting the "style" attribute.
+				(<NamedNodeMap>this.#ownerElement.attributes)[
+					PropertySymbol.setNamedItemWithoutConsequences
+				](styleAttribute);
 			}
 
-			if (this._ownerElement.isConnected) {
-				this._ownerElement.ownerDocument['_cacheID']++;
+			if (this.#ownerElement.isConnected) {
+				this.#ownerElement.ownerDocument[PropertySymbol.cacheID]++;
 			}
 
 			styleAttribute.value = style.toString();
 		} else {
-			this._style = new CSSStyleDeclarationPropertyManager({ cssText });
+			this.#style = new CSSStyleDeclarationPropertyManager({ cssText });
 		}
 	}
 
@@ -105,10 +106,10 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 * @returns Item.
 	 */
 	public item(index: number): string {
-		if (this._ownerElement) {
-			return this._elementStyle.getElementStyle().item(index);
+		if (this.#ownerElement) {
+			return this.#elementStyle.getElementStyle().item(index);
 		}
-		return this._style.item(index);
+		return this.#style.item(index);
 	}
 
 	/**
@@ -119,7 +120,7 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 * @param [priority] Can be "important", or an empty string.
 	 */
 	public setProperty(name: string, value: string, priority?: 'important' | '' | undefined): void {
-		if (this._computed) {
+		if (this.#computed) {
 			throw new DOMException(
 				`Failed to execute 'setProperty' on 'CSSStyleDeclaration': These styles are computed, and therefore the '${name}' property is read-only.`,
 				DOMExceptionNameEnum.domException
@@ -134,28 +135,28 @@ export default abstract class AbstractCSSStyleDeclaration {
 
 		if (!stringValue) {
 			this.removeProperty(name);
-		} else if (this._ownerElement) {
-			let styleAttribute = <IAttr>this._ownerElement.attributes['style'];
+		} else if (this.#ownerElement) {
+			let styleAttribute = <IAttr>this.#ownerElement.attributes['style'];
 
 			if (!styleAttribute) {
-				styleAttribute = this._ownerElement.ownerDocument.createAttribute('style');
+				styleAttribute = this.#ownerElement.ownerDocument.createAttribute('style');
 
-				// We use "_setNamedItemWithoutConsequences" here to avoid triggering setting "Element.style.cssText" when setting the "style" attribute.
-				(<NamedNodeMap>this._ownerElement.attributes)._setNamedItemWithoutConsequences(
-					styleAttribute
-				);
+				// We use "[PropertySymbol.setNamedItemWithoutConsequences]" here to avoid triggering setting "Element.style.cssText" when setting the "style" attribute.
+				(<NamedNodeMap>this.#ownerElement.attributes)[
+					PropertySymbol.setNamedItemWithoutConsequences
+				](styleAttribute);
 			}
 
-			if (this._ownerElement.isConnected) {
-				this._ownerElement.ownerDocument['_cacheID']++;
+			if (this.#ownerElement.isConnected) {
+				this.#ownerElement.ownerDocument[PropertySymbol.cacheID]++;
 			}
 
-			const style = this._elementStyle.getElementStyle();
+			const style = this.#elementStyle.getElementStyle();
 			style.set(name, stringValue, !!priority);
 
 			styleAttribute.value = style.toString();
 		} else {
-			this._style.set(name, stringValue, !!priority);
+			this.#style.set(name, stringValue, !!priority);
 		}
 	}
 
@@ -167,30 +168,32 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 * @param [priority] Can be "important", or an empty string.
 	 */
 	public removeProperty(name: string): void {
-		if (this._computed) {
+		if (this.#computed) {
 			throw new DOMException(
 				`Failed to execute 'removeProperty' on 'CSSStyleDeclaration': These styles are computed, and therefore the '${name}' property is read-only.`,
 				DOMExceptionNameEnum.domException
 			);
 		}
 
-		if (this._ownerElement) {
-			const style = this._elementStyle.getElementStyle();
+		if (this.#ownerElement) {
+			const style = this.#elementStyle.getElementStyle();
 			style.remove(name);
 			const newCSSText = style.toString();
 
-			if (this._ownerElement.isConnected) {
-				this._ownerElement.ownerDocument['_cacheID']++;
+			if (this.#ownerElement.isConnected) {
+				this.#ownerElement.ownerDocument[PropertySymbol.cacheID]++;
 			}
 
 			if (newCSSText) {
-				(<IAttr>this._ownerElement.attributes['style']).value = newCSSText;
+				(<IAttr>this.#ownerElement.attributes['style']).value = newCSSText;
 			} else {
-				// We use "_removeNamedItemWithoutConsequences" here to avoid triggering setting "Element.style.cssText" when setting the "style" attribute.
-				(<NamedNodeMap>this._ownerElement.attributes)._removeNamedItemWithoutConsequences('style');
+				// We use "[PropertySymbol.removeNamedItemWithoutConsequences]" here to avoid triggering setting "Element.style.cssText" when setting the "style" attribute.
+				(<NamedNodeMap>this.#ownerElement.attributes)[
+					PropertySymbol.removeNamedItemWithoutConsequences
+				]('style');
 			}
 		} else {
-			this._style.remove(name);
+			this.#style.remove(name);
 		}
 	}
 
@@ -201,11 +204,11 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 * @returns Property value.
 	 */
 	public getPropertyValue(name: string): string {
-		if (this._ownerElement) {
-			const style = this._elementStyle.getElementStyle();
+		if (this.#ownerElement) {
+			const style = this.#elementStyle.getElementStyle();
 			return style.get(name)?.value || '';
 		}
-		return this._style.get(name)?.value || '';
+		return this.#style.get(name)?.value || '';
 	}
 
 	/**
@@ -215,10 +218,10 @@ export default abstract class AbstractCSSStyleDeclaration {
 	 * @returns "important" if set to be important.
 	 */
 	public getPropertyPriority(name: string): string {
-		if (this._ownerElement) {
-			const style = this._elementStyle.getElementStyle();
+		if (this.#ownerElement) {
+			const style = this.#elementStyle.getElementStyle();
 			return style.get(name)?.important ? 'important' : '';
 		}
-		return this._style.get(name)?.important ? 'important' : '';
+		return this.#style.get(name)?.important ? 'important' : '';
 	}
 }