vitest 4.0.0-beta.4 → 4.0.0-beta.6

package/dist/chunks/{index.CmSc2RE5.js → index.BG0gqZH-.js}

@@ -180,8 +180,7 @@ const LIVING_KEYS = [
 	"Audio",
 	"Option",
 	"CSS"
-];
-const OTHER_KEYS = [
+], OTHER_KEYS = [
 	"addEventListener",
 	"alert",
 	"blur",
@@ -244,11 +243,8 @@ const skipKeys = [
 	"parent"
 ];
 function getWindowKeys(global, win, additionalKeys = []) {
-	const keysArray = [...additionalKeys, ...KEYS];
-	const keys = new Set(keysArray.concat(Object.getOwnPropertyNames(win)).filter((k) => {
-		if (skipKeys.includes(k)) return false;
-		if (k in global) return keysArray.includes(k);
-		return true;
+	const keysArray = [...additionalKeys, ...KEYS], keys = new Set(keysArray.concat(Object.getOwnPropertyNames(win)).filter((k) => {
+		return skipKeys.includes(k) ? false : k in global ? keysArray.includes(k) : true;
 	}));
 	return keys;
 }
@@ -256,18 +252,13 @@ function isClassLikeName(name) {
 	return name[0] === name[0].toUpperCase();
 }
 function populateGlobal(global, win, options = {}) {
-	const { bindFunctions = false } = options;
-	const keys = getWindowKeys(global, win, options.additionalKeys);
-	const originals = /* @__PURE__ */ new Map();
-	const overrideObject = /* @__PURE__ */ new Map();
+	const { bindFunctions = false } = options, keys = getWindowKeys(global, win, options.additionalKeys), originals = /* @__PURE__ */ new Map(), overrideObject = /* @__PURE__ */ new Map();
 	for (const key of keys) {
 		const boundFunction = bindFunctions && typeof win[key] === "function" && !isClassLikeName(key) && win[key].bind(win);
 		if (KEYS.includes(key) && key in global) originals.set(key, global[key]);
 		Object.defineProperty(global, key, {
 			get() {
-				if (overrideObject.has(key)) return overrideObject.get(key);
-				if (boundFunction) return boundFunction;
-				return win[key];
+				return overrideObject.has(key) ? overrideObject.get(key) : boundFunction || win[key];
 			},
 			set(v) {
 				overrideObject.set(key, v);
@@ -275,19 +266,14 @@ function populateGlobal(global, win, options = {}) {
 			configurable: true
 		});
 	}
-	global.window = global;
-	global.self = global;
-	global.top = global;
-	global.parent = global;
-	if (global.global) global.global = global;
+	if (global.window = global, global.self = global, global.top = global, global.parent = global, global.global) global.global = global;
 	// rewrite defaultView to reference the same global context
 	if (global.document && global.document.defaultView) Object.defineProperty(global.document, "defaultView", {
 		get: () => global,
 		enumerable: true,
 		configurable: true
 	});
-	skipKeys.forEach((k) => keys.add(k));
-	return {
+	return skipKeys.forEach((k) => keys.add(k)), {
 		keys,
 		skipKeys,
 		originals
@@ -296,13 +282,10 @@ function populateGlobal(global, win, options = {}) {
 
 var edge = {
 	name: "edge-runtime",
-	transformMode: "ssr",
+	viteEnvironment: "ssr",
 	async setupVM() {
-		const { EdgeVM } = await import('@edge-runtime/vm');
-		const vm = new EdgeVM({ extend: (context) => {
-			context.global = context;
-			context.Buffer = Buffer;
-			return context;
+		const { EdgeVM } = await import('@edge-runtime/vm'), vm = new EdgeVM({ extend: (context) => {
+			return context.global = context, context.Buffer = Buffer, context;
 		} });
 		return {
 			getVmContext() {
@@ -314,32 +297,24 @@ var edge = {
 		};
 	},
 	async setup(global) {
-		const { EdgeVM } = await import('@edge-runtime/vm');
-		const vm = new EdgeVM({ extend: (context) => {
-			context.global = context;
-			context.Buffer = Buffer;
-			KEYS.forEach((key) => {
+		const { EdgeVM } = await import('@edge-runtime/vm'), vm = new EdgeVM({ extend: (context) => {
+			return context.global = context, context.Buffer = Buffer, KEYS.forEach((key) => {
 				if (key in global) context[key] = global[key];
-			});
-			return context;
-		} });
-		const { keys, originals } = populateGlobal(global, vm.context, { bindFunctions: true });
+			}), context;
+		} }), { keys, originals } = populateGlobal(global, vm.context, { bindFunctions: true });
 		return { teardown(global) {
-			keys.forEach((key) => delete global[key]);
-			originals.forEach((v, k) => global[k] = v);
+			keys.forEach((key) => delete global[key]), originals.forEach((v, k) => global[k] = v);
 		} };
 	}
 };
 
 async function teardownWindow(win) {
-	if (win.close && win.happyDOM.abort) {
-		await win.happyDOM.abort();
-		win.close();
-	} else win.happyDOM.cancelAsync();
+	if (win.close && win.happyDOM.abort) await win.happyDOM.abort(), win.close();
+	else win.happyDOM.cancelAsync();
 }
 var happy = {
 	name: "happy-dom",
-	transformMode: "web",
+	viteEnvironment: "client",
 	async setupVM({ happyDOM = {} }) {
 		const { Window } = await import('happy-dom');
 		let win = new Window({
@@ -351,25 +326,21 @@ var happy = {
 				disableErrorCapturing: true
 			}
 		});
-		// TODO: browser doesn't expose Buffer, but a lot of dependencies use it
-		win.Buffer = Buffer;
 		// inject structuredClone if it exists
-		if (typeof structuredClone !== "undefined" && !win.structuredClone) win.structuredClone = structuredClone;
+		if (win.Buffer = Buffer, typeof structuredClone !== "undefined" && !win.structuredClone) win.structuredClone = structuredClone;
 		return {
 			getVmContext() {
 				return win;
 			},
 			async teardown() {
-				await teardownWindow(win);
-				win = void 0;
+				await teardownWindow(win), win = void 0;
 			}
 		};
 	},
 	async setup(global, { happyDOM = {} }) {
 		// happy-dom v3 introduced a breaking change to Window, but
 		// provides GlobalWindow as a way to use previous behaviour
-		const { Window, GlobalWindow } = await import('happy-dom');
-		const win = new (GlobalWindow || Window)({
+		const { Window, GlobalWindow } = await import('happy-dom'), win = new (GlobalWindow || Window)({
 			...happyDOM,
 			console: console && global.console ? global.console : void 0,
 			url: happyDOM.url || "http://localhost:3000",
@@ -377,8 +348,7 @@ var happy = {
 				...happyDOM.settings,
 				disableErrorCapturing: true
 			}
-		});
-		const { keys, originals } = populateGlobal(global, win, {
+		}), { keys, originals } = populateGlobal(global, win, {
 			bindFunctions: true,
 			additionalKeys: [
 				"Request",
@@ -388,9 +358,7 @@ var happy = {
 			]
 		});
 		return { async teardown(global) {
-			await teardownWindow(win);
-			keys.forEach((key) => delete global[key]);
-			originals.forEach((v, k) => global[k] = v);
+			await teardownWindow(win), keys.forEach((key) => delete global[key]), originals.forEach((v, k) => global[k] = v);
 		} };
 	}
 };
@@ -400,27 +368,22 @@ function catchWindowErrors(window) {
 	function throwUnhandlerError(e) {
 		if (userErrorListenerCount === 0 && e.error != null) process.emit("uncaughtException", e.error);
 	}
-	const addEventListener = window.addEventListener.bind(window);
-	const removeEventListener = window.removeEventListener.bind(window);
-	window.addEventListener("error", throwUnhandlerError);
-	window.addEventListener = function(...args) {
+	const addEventListener = window.addEventListener.bind(window), removeEventListener = window.removeEventListener.bind(window);
+	return window.addEventListener("error", throwUnhandlerError), window.addEventListener = function(...args) {
 		if (args[0] === "error") userErrorListenerCount++;
 		return addEventListener.apply(this, args);
-	};
-	window.removeEventListener = function(...args) {
+	}, window.removeEventListener = function(...args) {
 		if (args[0] === "error" && userErrorListenerCount) userErrorListenerCount--;
 		return removeEventListener.apply(this, args);
-	};
-	return function clearErrorHandlers() {
+	}, function clearErrorHandlers() {
 		window.removeEventListener("error", throwUnhandlerError);
 	};
 }
 var jsdom = {
 	name: "jsdom",
-	transformMode: "web",
+	viteEnvironment: "client",
 	async setupVM({ jsdom = {} }) {
-		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom');
-		const { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom;
+		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom'), { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom;
 		let dom = new JSDOM(html, {
 			pretendToBeVisual,
 			resources: resources ?? (userAgent ? new ResourceLoader({ userAgent }) : void 0),
@@ -434,9 +397,7 @@ var jsdom = {
 			...restOptions
 		});
 		const clearWindowErrors = catchWindowErrors(dom.window);
-		// TODO: browser doesn't expose Buffer, but a lot of dependencies use it
-		dom.window.Buffer = Buffer;
-		dom.window.jsdom = dom;
+		dom.window.Buffer = Buffer, dom.window.jsdom = dom;
 		// inject web globals if they missing in JSDOM but otherwise available in Nodejs
 		// https://nodejs.org/dist/latest/docs/api/globals.html
 		const globalNames = [
@@ -459,16 +420,12 @@ var jsdom = {
 				return dom.getInternalVMContext();
 			},
 			teardown() {
-				clearWindowErrors();
-				dom.window.close();
-				dom = void 0;
+				clearWindowErrors(), dom.window.close(), dom = void 0;
 			}
 		};
 	},
 	async setup(global, { jsdom = {} }) {
-		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom');
-		const { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom;
-		const dom = new JSDOM(html, {
+		const { CookieJar, JSDOM, ResourceLoader, VirtualConsole } = await import('jsdom'), { html = "<!DOCTYPE html>", userAgent, url = "http://localhost:3000", contentType = "text/html", pretendToBeVisual = true, includeNodeLocations = false, runScripts = "dangerously", resources, console = false, cookieJar = false,...restOptions } = jsdom, dom = new JSDOM(html, {
 			pretendToBeVisual,
 			resources: resources ?? (userAgent ? new ResourceLoader({ userAgent }) : void 0),
 			runScripts,
@@ -479,16 +436,9 @@ var jsdom = {
 			contentType,
 			userAgent,
 			...restOptions
-		});
-		const { keys, originals } = populateGlobal(global, dom.window, { bindFunctions: true });
-		const clearWindowErrors = catchWindowErrors(global);
-		global.jsdom = dom;
-		return { teardown(global) {
-			clearWindowErrors();
-			dom.window.close();
-			delete global.jsdom;
-			keys.forEach((key) => delete global[key]);
-			originals.forEach((v, k) => global[k] = v);
+		}), { keys, originals } = populateGlobal(global, dom.window, { bindFunctions: true }), clearWindowErrors = catchWindowErrors(global);
+		return global.jsdom = dom, { teardown(global) {
+			clearWindowErrors(), dom.window.close(), delete global.jsdom, keys.forEach((key) => delete global[key]), originals.forEach((v, k) => global[k] = v);
 		} };
 	}
 };
@@ -501,19 +451,17 @@ const denyList = new Set([
 	"Buffer",
 	"ArrayBuffer",
 	"Uint8Array"
-]);
-const nodeGlobals = new Map(Object.getOwnPropertyNames(globalThis).filter((global) => !denyList.has(global)).map((nodeGlobalsKey) => {
+]), nodeGlobals = new Map(Object.getOwnPropertyNames(globalThis).filter((global) => !denyList.has(global)).map((nodeGlobalsKey) => {
 	const descriptor = Object.getOwnPropertyDescriptor(globalThis, nodeGlobalsKey);
 	if (!descriptor) throw new Error(`No property descriptor for ${nodeGlobalsKey}, this is a bug in Vitest.`);
 	return [nodeGlobalsKey, descriptor];
 }));
 var node = {
 	name: "node",
-	transformMode: "ssr",
+	viteEnvironment: "ssr",
 	async setupVM() {
 		const vm = await import('node:vm');
-		let context = vm.createContext();
-		let global = vm.runInContext("this", context);
+		let context = vm.createContext(), global = vm.runInContext("this", context);
 		const contextGlobals = new Set(Object.getOwnPropertyNames(global));
 		for (const [nodeGlobalsKey, descriptor] of nodeGlobals) if (!contextGlobals.has(nodeGlobalsKey)) if (descriptor.configurable) Object.defineProperty(global, nodeGlobalsKey, {
 			configurable: true,
@@ -521,14 +469,12 @@ var node = {
 			get() {
 				// @ts-expect-error: no index signature
 				const val = globalThis[nodeGlobalsKey];
-				// override lazy getter
-				Object.defineProperty(global, nodeGlobalsKey, {
+				return Object.defineProperty(global, nodeGlobalsKey, {
 					configurable: true,
 					enumerable: descriptor.enumerable,
 					value: val,
 					writable: descriptor.writable === true || nodeGlobalsKey === "performance"
-				});
-				return val;
+				}), val;
 			},
 			set(val) {
 				// override lazy getter
@@ -552,26 +498,17 @@ var node = {
 			get: descriptor.get,
 			set: descriptor.set
 		});
-		global.global = global;
-		global.Buffer = Buffer;
-		global.ArrayBuffer = ArrayBuffer;
-		// TextEncoder (global or via 'util') references a Uint8Array constructor
-		// different than the global one used by users in tests. This makes sure the
-		// same constructor is referenced by both.
-		global.Uint8Array = Uint8Array;
-		return {
+		return global.global = global, global.Buffer = Buffer, global.ArrayBuffer = ArrayBuffer, global.Uint8Array = Uint8Array, {
 			getVmContext() {
 				return context;
 			},
 			teardown() {
-				context = void 0;
-				global = void 0;
+				context = void 0, global = void 0;
 			}
 		};
 	},
 	async setup(global) {
-		global.console.Console = Console;
-		return { teardown(global) {
+		return global.console.Console = Console, { teardown(global) {
 			delete global.console.Console;
 		} };
 	}

package/dist/chunks/{index.CtUvr1c8.js → index.CsFXYRkW.js}

@@ -1,9 +1,9 @@
 import * as chai from 'chai';
-import { resolve } from 'node:path';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.Ebx5x0eP.js';
+import { resolve, join } from 'node:path';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.hLGRxhC8.js';
 import { distDir } from '../path.js';
-import { r as rpc } from './rpc.jnQO9F8a.js';
-import { g as getWorkerState } from './utils.XdZDrNZV.js';
+import { r as rpc } from './rpc.RpPylpp0.js';
+import { g as getWorkerState } from './utils.C7__0Iv5.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
@@ -11,95 +11,76 @@ function setupChaiConfig(config) {
 
 async function resolveSnapshotEnvironment(config, executor) {
 	if (!config.snapshotEnvironment) {
-		const { VitestNodeSnapshotEnvironment } = await import('./node.fjCdwEIl.js');
+		const { VitestNodeSnapshotEnvironment } = await import('./node.BOqcT2jW.js');
 		return new VitestNodeSnapshotEnvironment();
 	}
-	const mod = await executor.executeId(config.snapshotEnvironment);
+	const mod = await executor.import(config.snapshotEnvironment);
 	if (typeof mod.default !== "object" || !mod.default) throw new Error("Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`");
 	return mod.default;
 }
 
 const runnersFile = resolve(distDir, "runners.js");
-async function getTestRunnerConstructor(config, executor) {
+async function getTestRunnerConstructor(config, moduleRunner) {
 	if (!config.runner) {
-		const { VitestTestRunner, NodeBenchmarkRunner } = await executor.executeFile(runnersFile);
+		const { VitestTestRunner, NodeBenchmarkRunner } = await moduleRunner.import(join("/@fs/", runnersFile));
 		return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
 	}
-	const mod = await executor.executeId(config.runner);
+	const mod = await moduleRunner.import(config.runner);
 	if (!mod.default && typeof mod.default !== "function") throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
 	return mod.default;
 }
-async function resolveTestRunner(config, executor) {
-	const TestRunner = await getTestRunnerConstructor(config, executor);
-	const testRunner = new TestRunner(config);
-	// inject private executor to every runner
-	Object.defineProperty(testRunner, "__vitest_executor", {
-		value: executor,
+async function resolveTestRunner(config, moduleRunner) {
+	const TestRunner = await getTestRunnerConstructor(config, moduleRunner), testRunner = new TestRunner(config);
+	if (Object.defineProperty(testRunner, "moduleRunner", {
+		value: moduleRunner,
 		enumerable: false,
 		configurable: false
-	});
-	if (!testRunner.config) testRunner.config = config;
+	}), !testRunner.config) testRunner.config = config;
 	if (!testRunner.importFile) throw new Error("Runner must implement \"importFile\" method.");
-	const [diffOptions] = await Promise.all([loadDiffConfig(config, executor), loadSnapshotSerializers(config, executor)]);
+	const [diffOptions] = await Promise.all([loadDiffConfig(config, moduleRunner), loadSnapshotSerializers(config, moduleRunner)]);
 	testRunner.config.diffOptions = diffOptions;
 	// patch some methods, so custom runners don't need to call RPC
 	const originalOnTaskUpdate = testRunner.onTaskUpdate;
 	testRunner.onTaskUpdate = async (task, events) => {
 		const p = rpc().onTaskUpdate(task, events);
-		await originalOnTaskUpdate?.call(testRunner, task, events);
-		return p;
+		return await originalOnTaskUpdate?.call(testRunner, task, events), p;
 	};
 	// patch some methods, so custom runners don't need to call RPC
 	const originalOnTestAnnotate = testRunner.onTestAnnotate;
 	testRunner.onTestAnnotate = async (test, annotation) => {
-		const p = rpc().onTaskAnnotate(test.id, annotation);
-		const overridenResult = await originalOnTestAnnotate?.call(testRunner, test, annotation);
-		const vitestResult = await p;
-		return overridenResult || vitestResult;
+		const p = rpc().onTaskAnnotate(test.id, annotation), overriddenResult = await originalOnTestAnnotate?.call(testRunner, test, annotation), vitestResult = await p;
+		return overriddenResult || vitestResult;
 	};
 	const originalOnCollectStart = testRunner.onCollectStart;
 	testRunner.onCollectStart = async (file) => {
-		await rpc().onQueued(file);
-		await originalOnCollectStart?.call(testRunner, file);
+		await rpc().onQueued(file), await originalOnCollectStart?.call(testRunner, file);
 	};
 	const originalOnCollected = testRunner.onCollected;
 	testRunner.onCollected = async (files) => {
 		const state = getWorkerState();
 		files.forEach((file) => {
-			file.prepareDuration = state.durations.prepare;
-			file.environmentLoad = state.durations.environment;
-			// should be collected only for a single test file in a batch
-			state.durations.prepare = 0;
-			state.durations.environment = 0;
-		});
-		rpc().onCollected(files);
-		await originalOnCollected?.call(testRunner, files);
+			file.prepareDuration = state.durations.prepare, file.environmentLoad = state.durations.environment, state.durations.prepare = 0, state.durations.environment = 0;
+		}), rpc().onCollected(files), await originalOnCollected?.call(testRunner, files);
 	};
 	const originalOnAfterRun = testRunner.onAfterRunFiles;
 	testRunner.onAfterRunFiles = async (files) => {
-		const state = getWorkerState();
-		const coverage = await takeCoverageInsideWorker(config.coverage, executor);
+		const state = getWorkerState(), coverage = await takeCoverageInsideWorker(config.coverage, moduleRunner);
 		if (coverage) rpc().onAfterSuiteRun({
 			coverage,
 			testFiles: files.map((file) => file.name).sort(),
-			transformMode: state.environment.transformMode,
+			environment: state.environment.viteEnvironment || state.environment.name,
 			projectName: state.ctx.projectName
 		});
 		await originalOnAfterRun?.call(testRunner, files);
 	};
 	const originalOnAfterRunTask = testRunner.onAfterRunTask;
-	testRunner.onAfterRunTask = async (test) => {
+	return testRunner.onAfterRunTask = async (test) => {
 		if (config.bail && test.result?.state === "fail") {
-			const previousFailures = await rpc().getCountOfFailedTests();
-			const currentFailures = 1 + previousFailures;
-			if (currentFailures >= config.bail) {
-				rpc().onCancel("test-failure");
-				testRunner.cancel?.("test-failure");
-			}
+			const previousFailures = await rpc().getCountOfFailedTests(), currentFailures = 1 + previousFailures;
+			if (currentFailures >= config.bail) rpc().onCancel("test-failure"), testRunner.cancel?.("test-failure");
 		}
 		await originalOnAfterRunTask?.call(testRunner, test);
-	};
-	return testRunner;
+	}, testRunner;
 }
 
 export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };