vitest 4.0.0-beta.11 → 4.0.0-beta.13

package/dist/chunks/{reporters.d.CVzhsTvK.d.ts → reporters.d.xGvTJYG3.d.ts}

@@ -5,8 +5,8 @@ import { Writable } from 'node:stream';
 import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, DepOptimizationConfig, ServerOptions, ConfigEnv, AliasOptions } from 'vite';
 import { MockedModule } from '@vitest/mocker';
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
-import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.Dx7DO_Ce.js';
-import { a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.B_LthbQq.js';
+import { B as BrowserTraceViewMode, a as SerializedConfig, F as FakeTimerInstallOpts } from './config.d.DGazh2r6.js';
+import { B as BrowserTesterOptions, S as SerializedTestSpecification } from './browser.d.D9YV3JvA.js';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
@@ -80,9 +80,10 @@ interface BrowserModuleMocker {
 	delete: (sessionId: string, url: string) => Promise<void>;
 	clear: (sessionId: string) => Promise<void>;
 }
-interface BrowserProviderOption {
+interface BrowserProviderOption<Options extends object = object> {
 	name: string;
 	supportedBrowser?: ReadonlyArray<string>;
+	options: Options;
 	factory: (project: TestProject) => BrowserProvider;
 }
 interface BrowserProvider {
@@ -178,6 +179,31 @@ interface BrowserConfigOptions {
 		testIdAttribute?: string;
 	};
 	/**
+	* Generate traces that can be viewed on https://trace.playwright.dev/
+	*
+	* This option is supported only by **playwright** provider.
+	*/
+	trace?: BrowserTraceViewMode | {
+		mode: BrowserTraceViewMode;
+		/**
+		* The directory where all traces will be stored. By default, Vitest
+		* stores all traces in `__traces__` folder close to the test file.
+		*/
+		tracesDir?: string;
+		/**
+		* Whether to capture screenshots during tracing. Screenshots are used to build a timeline preview.
+		* @default true
+		*/
+		screenshots?: boolean;
+		/**
+		* If this option is true tracing will
+		* - capture DOM snapshot on every action
+		* - record network activity
+		* @default true
+		*/
+		snapshots?: boolean;
+	};
+	/**
 	* Directory where screenshots will be saved when page.screenshot() is called
 	* If not set, all screenshots are saved to __screenshots__ directory in the same folder as the test file.
 	* If this is set, it will be resolved relative to the project root.
@@ -261,7 +287,7 @@ interface ProjectBrowser {
 	parseStacktrace: (stack: string) => ParsedStack[];
 	parseErrorStacktrace: (error: TestError, options?: StackTraceParserOptions) => ParsedStack[];
 }
-interface BrowserCommand<Payload extends unknown[]> {
+interface BrowserCommand<Payload extends unknown[] = []> {
 	(context: BrowserCommandContext, ...payload: Payload): Awaitable<any>;
 }
 interface BrowserScript {
@@ -308,6 +334,12 @@ interface ResolvedBrowserOptions extends BrowserConfigOptions {
 	locators: {
 		testIdAttribute: string;
 	};
+	trace: {
+		mode: BrowserTraceViewMode;
+		tracesDir?: string;
+		screenshots?: boolean;
+		snapshots?: boolean;
+	};
 }
 type ToMatchScreenshotResolvePath = (data: {
 	/**
@@ -1512,6 +1544,7 @@ declare class StateManager {
 	clearFiles(project: TestProject, paths?: string[]): void;
 	updateId(task: Task, project: TestProject): void;
 	getReportedEntity(task: Task): TestModule | TestCase | TestSuite | undefined;
+	getReportedEntityById(taskId: string): TestModule | TestCase | TestSuite | undefined;
 	updateTasks(packs: TaskResultPack[]): void;
 	updateUserLog(log: UserConsoleLog): void;
 	getCountOfFailedTests(): number;
@@ -1674,6 +1707,10 @@ declare class Vitest {
 	* Merge reports from multiple runs located in the specified directory (value from `--merge-reports` if not specified).
 	*/
 	mergeReports(directory?: string): Promise<TestRunResult>;
+	/**
+	* Returns the seed, if tests are running in a random order.
+	*/
+	getSeed(): number | null;
 	collect(filters?: string[]): Promise<TestRunResult>;
 	/**
 	* Returns the list of test files that match the config and filters.

package/dist/chunks/{resolveSnapshotEnvironment.DQVamkje.js → resolveSnapshotEnvironment.BsJpmVZR.js}

@@ -1,8 +1,8 @@
 import { chai } from '@vitest/expect';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.NAWRuMRP.js';
-import { r as rpc } from './rpc.jKGRSXIH.js';
-import { g as getWorkerState } from './utils.DGKhod2J.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.KC5tH8hC.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.BewgbkTd.js';
+import { r as rpc } from './rpc.cD77ENhU.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.CTuWuHYH.js';
 
 function setupChaiConfig(config) {
 	Object.assign(chai.config, config);
@@ -15,7 +15,7 @@ async function getTestRunnerConstructor(config, moduleRunner) {
 	return mod.default;
 }
 async function resolveTestRunner(config, moduleRunner) {
-	const TestRunner = await getTestRunnerConstructor(config, moduleRunner), testRunner = new TestRunner(config);
+	const testRunner = new (await (getTestRunnerConstructor(config, moduleRunner)))(config);
 	if (Object.defineProperty(testRunner, "moduleRunner", {
 		value: moduleRunner,
 		enumerable: false,
@@ -61,8 +61,7 @@ async function resolveTestRunner(config, moduleRunner) {
 	const originalOnAfterRunTask = testRunner.onAfterRunTask;
 	return testRunner.onAfterRunTask = async (test) => {
 		if (config.bail && test.result?.state === "fail") {
-			const previousFailures = await rpc().getCountOfFailedTests(), currentFailures = 1 + previousFailures;
-			if (currentFailures >= config.bail) rpc().onCancel("test-failure"), testRunner.cancel?.("test-failure");
+			if (1 + await rpc().getCountOfFailedTests() >= config.bail) rpc().onCancel("test-failure"), testRunner.cancel?.("test-failure");
 		}
 		await originalOnAfterRunTask?.call(testRunner, test);
 	}, testRunner;
@@ -70,7 +69,7 @@ async function resolveTestRunner(config, moduleRunner) {
 
 async function resolveSnapshotEnvironment(config, executor) {
 	if (!config.snapshotEnvironment) {
-		const { VitestNodeSnapshotEnvironment } = await import('./node.BsdMi6DV.js');
+		const { VitestNodeSnapshotEnvironment } = await import('./node.BwAWWjHZ.js');
 		return new VitestNodeSnapshotEnvironment();
 	}
 	const mod = await executor.import(config.snapshotEnvironment);

package/dist/chunks/{rpc.jKGRSXIH.js → rpc.cD77ENhU.js}

@@ -1,6 +1,6 @@
 import { getSafeTimers } from '@vitest/utils/timers';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { g as getWorkerState } from './utils.DGKhod2J.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
 
 const { get } = Reflect;
 function withSafeTimers(fn) {
@@ -9,8 +9,7 @@ function withSafeTimers(fn) {
 		if (globalThis.setTimeout = setTimeout, globalThis.clearTimeout = clearTimeout, setImmediate) globalThis.setImmediate = setImmediate;
 		if (clearImmediate) globalThis.clearImmediate = clearImmediate;
 		if (globalThis.process && nextTick) globalThis.process.nextTick = nextTick;
-		const result = fn();
-		return result;
+		return fn();
 	} finally {
 		if (globalThis.setTimeout = currentSetTimeout, globalThis.clearTimeout = currentClearTimeout, globalThis.setImmediate = currentSetImmediate, globalThis.clearImmediate = currentClearImmediate, globalThis.process && nextTick) nextTick(() => {
 			globalThis.process.nextTick = currentNextTick;
@@ -27,17 +26,17 @@ function createRuntimeRpc(options) {
 	let setCancel = (_reason) => {};
 	const onCancel = new Promise((resolve) => {
 		setCancel = resolve;
-	}), rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
-		eventNames: [
-			"onUserConsoleLog",
-			"onCollected",
-			"onCancel"
-		],
-		timeout: -1,
-		...options
-	}));
+	});
 	return {
-		rpc,
+		rpc: createSafeRpc(createBirpc({ onCancel: setCancel }, {
+			eventNames: [
+				"onUserConsoleLog",
+				"onCollected",
+				"onCancel"
+			],
+			timeout: -1,
+			...options
+		})),
 		onCancel
 	};
 }

package/dist/chunks/{setup-common.NAWRuMRP.js → setup-common.BewgbkTd.js}

@@ -1,7 +1,7 @@
 import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 import { addSerializer } from '@vitest/snapshot';
 import { setSafeTimers } from '@vitest/utils/timers';
-import { g as getWorkerState } from './utils.DGKhod2J.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
 
 async function startCoverageInsideWorker(options, loader, runtimeOptions) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
@@ -18,7 +18,7 @@ async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
-	if (setupDefines(config), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.BjvYA-AD.js')).registerApiGlobally();
+	if (setupDefines(config), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.DC4ntO86.js')).registerApiGlobally();
 }
 function setupDefines(config) {
 	for (const key in config.defines) globalThis[key] = config.defines[key];
@@ -35,14 +35,14 @@ async function loadDiffConfig(config, moduleRunner) {
 	throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
 }
 async function loadSnapshotSerializers(config, moduleRunner) {
-	const files = config.snapshotSerializers, snapshotSerializers = await Promise.all(files.map(async (file) => {
+	const files = config.snapshotSerializers;
+	(await Promise.all(files.map(async (file) => {
 		const mo = await moduleRunner.import(file);
 		if (!mo || typeof mo.default !== "object" || mo.default === null) throw new Error(`invalid snapshot serializer file ${file}. Must export a default object`);
 		const config = mo.default;
 		if (typeof config.test !== "function" || typeof config.serialize !== "function" && typeof config.print !== "function") throw new TypeError(`invalid snapshot serializer in ${file}. Must have a 'test' method along with either a 'serialize' or 'print' method.`);
 		return config;
-	}));
-	snapshotSerializers.forEach((serializer) => addSerializer(serializer));
+	}))).forEach((serializer) => addSerializer(serializer));
 }
 
 export { stopCoverageInsideWorker as a, loadSnapshotSerializers as b, setupCommonEnv as c, loadDiffConfig as l, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };

package/dist/chunks/{startModuleRunner.oAuCu1yL.js → startModuleRunner.DPBo3mme.js}

@@ -28,8 +28,8 @@ const _UNC_REGEX = /^[/\\]{2}/, _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\
 	for (const seg of segments) {
 		if (!seg) continue;
 		if (path.length > 0) {
-			const pathTrailing = path[path.length - 1] === "/", segLeading = seg[0] === "/", both = pathTrailing && segLeading;
-			if (both) path += seg.slice(1);
+			const pathTrailing = path[path.length - 1] === "/", segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
 			else path += pathTrailing || segLeading ? seg : `/${seg}`;
 		} else path += seg;
 	}
@@ -114,17 +114,14 @@ function findMockRedirect(root, mockPath, external) {
 		const baseOriginal = basename(path);
 		function findFile(mockFolder, baseOriginal) {
 			const files = readdirSync(mockFolder);
-			for (const file of files) {
-				const baseFile = basename(file, extname(file));
-				if (baseFile === baseOriginal) {
-					const path = resolve(mockFolder, file);
-					// if the same name, return the file
-					if (statSync(path).isFile()) return path;
-					{
-						// find folder/index.{js,ts}
-						const indexFile = findFile(path, "index");
-						if (indexFile) return indexFile;
-					}
+			for (const file of files) if (basename(file, extname(file)) === baseOriginal) {
+				const path = resolve(mockFolder, file);
+				// if the same name, return the file
+				if (statSync(path).isFile()) return path;
+				{
+					// find folder/index.{js,ts}
+					const indexFile = findFile(path, "index");
+					if (indexFile) return indexFile;
 				}
 			}
 			return null;
@@ -278,7 +275,7 @@ class VitestMocker {
 			if (prop === "then") {
 				if (target instanceof Promise) return target.then.bind(target);
 			} else if (!(prop in target)) {
-				if (this.filterPublicKeys.includes(prop)) return void 0;
+				if (this.filterPublicKeys.includes(prop)) return;
 				throw this.createError(`[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. Did you forget to return it from "vi.mock"?
 If you need to partially mock a module, you can use "importOriginal" helper inside:
 `, `vi.mock(import("${mock.raw}"), async (importOriginal) => {
@@ -302,8 +299,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		return `mock:${dep}`;
 	}
 	getDependencyMock(id) {
-		const registry = this.getMockerRegistry();
-		return registry.getById(fixLeadingSlashes(id));
+		return this.getMockerRegistry().getById(fixLeadingSlashes(id));
 	}
 	findMockRedirect(mockPath, external) {
 		return findMockRedirect(this.root, mockPath, external);
@@ -318,8 +314,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		}, object, mockExports);
 	}
 	unmockPath(id) {
-		const registry = this.getMockerRegistry();
-		registry.deleteById(id), this.invalidateModuleById(id);
+		this.getMockerRegistry().deleteById(id), this.invalidateModuleById(id);
 	}
 	mockPath(originalId, id, url, external, mockType, factory) {
 		const registry = this.getMockerRegistry();
@@ -334,8 +329,8 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		this.invalidateModuleById(id);
 	}
 	async importActual(rawId, importer, callstack) {
-		const { url } = await this.resolveId(rawId, importer), node = await this.moduleRunner.fetchModule(url, importer), result = await this.moduleRunner.cachedRequest(node.url, node, callstack || [importer], void 0, true);
-		return result;
+		const { url } = await this.resolveId(rawId, importer), node = await this.moduleRunner.fetchModule(url, importer);
+		return await this.moduleRunner.cachedRequest(node.url, node, callstack || [importer], void 0, true);
 	}
 	async importMock(rawId, importer) {
 		const { id, url, external } = await this.resolveId(rawId, importer);
@@ -420,11 +415,8 @@ const prefixedBuiltins = new Set([
 // C:\root\id.js -> /id.js
 // TODO: expose this in vite/module-runner
 function normalizeModuleId(file) {
-	if (prefixedBuiltins.has(file)) return file;
-	// unix style, but Windows path still starts with the drive letter to check the root
-	const unixFile = slash(file).replace(/^\/@fs\//, isWindows$1 ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
 	// if it's not in the root, keep it as a path, not a URL
-	return unixFile.replace(/^file:\//, "/");
+	return prefixedBuiltins.has(file) ? file : slash(file).replace(/^\/@fs\//, isWindows$1 ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
 }
 const windowsSlashRE = /\\/g;
 function slash(p) {
@@ -446,17 +438,27 @@ class VitestTransport {
 		const { name, data } = event.data;
 		if (name !== "fetchModule") return { error: /* @__PURE__ */ new Error(`Unknown method: ${name}. Expected "fetchModule".`) };
 		try {
-			const result = await this.options.fetchModule(...data);
-			return { result };
+			return { result: await this.options.fetchModule(...data) };
 		} catch (error) {
 			return { error };
 		}
 	}
 }
 
-// eslint-disable-next-line ts/ban-ts-comment
-// @ts-ignore
-const createNodeImportMeta = viteModuleRunner.createNodeImportMeta;
+const createNodeImportMeta = (modulePath) => {
+	if (!viteModuleRunner.createDefaultImportMeta) throw new Error(`createNodeImportMeta is not supported in this version of Vite.`);
+	const defaultMeta = viteModuleRunner.createDefaultImportMeta(modulePath), href = defaultMeta.url, importMetaResolver = createImportMetaResolver();
+	return {
+		...defaultMeta,
+		main: false,
+		resolve(id, parent) {
+			return (importMetaResolver ?? defaultMeta.resolve)(id, parent ?? href);
+		}
+	};
+};
+function createImportMetaResolver() {
+	if (import.meta.resolve) return (specifier, importer) => import.meta.resolve(specifier, importer);
+}
 // @ts-expect-error overriding private method
 class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 	mocker;
@@ -491,11 +493,10 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 	}
 	async import(rawId) {
 		const resolved = await this.vitestOptions.transport.resolveId(rawId);
-		return resolved ? super.import(resolved.url) : super.import(rawId);
+		return super.import(resolved ? resolved.url : rawId);
 	}
 	async fetchModule(url, importer) {
-		const module = await this.cachedModule(url, importer);
-		return module;
+		return await this.cachedModule(url, importer);
 	}
 	_cachedRequest(url, module, callstack = [], metadata) {
 		// @ts-expect-error "cachedRequest" is private
@@ -564,10 +565,10 @@ const dispose = [];
 function listenForErrors(state) {
 	dispose.forEach((fn) => fn()), dispose.length = 0;
 	function catchError(err, type, event) {
-		const worker = state(), listeners = process.listeners(event);
+		const worker = state();
 		// if there is another listener, assume that it's handled by user code
 		// one is Vitest's own listener
-		if (listeners.length > 1) return;
+		if (process.listeners(event).length > 1) return;
 		const error = serializeValue(err);
 		if (typeof error === "object" && error != null) {
 			if (error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : void 0, worker.filepath) error.VITEST_TEST_PATH = worker.filepath;
@@ -614,10 +615,7 @@ function startVitestModuleRunner(options) {
 				if (isWindows) {
 					if (id[1] === ":") {
 						// The drive letter is different for whatever reason, we need to normalize it to CWD
-						if (id[0] !== cwd[0] && id[0].toUpperCase() === cwd[0].toUpperCase()) {
-							const isUpperCase = cwd[0].toUpperCase() === cwd[0];
-							id = (isUpperCase ? id[0].toUpperCase() : id[0].toLowerCase()) + id.slice(1);
-						}
+						if (id[0] !== cwd[0] && id[0].toUpperCase() === cwd[0].toUpperCase()) id = (cwd[0].toUpperCase() === cwd[0] ? id[0].toUpperCase() : id[0].toLowerCase()) + id.slice(1);
 						// always mark absolute windows paths, otherwise Vite will externalize it
 						id = `/@id/${id}`;
 					}
@@ -642,14 +640,10 @@ function startVitestModuleRunner(options) {
 						type: "builtin"
 					};
 					const result = await rpc().fetch(id, importer, environment(), options);
-					if ("cached" in result) {
-						const code = readFileSync(result.tmp, "utf-8");
-						return {
-							code,
-							...result
-						};
-					}
-					return result;
+					return "cached" in result ? {
+						code: readFileSync(result.tmp, "utf-8"),
+						...result
+					} : result;
 				} catch (cause) {
 					// rethrow vite error if it cannot load the module because it's not resolved
 					if (typeof cause === "object" && cause != null && cause.code === "ERR_LOAD_URL" || typeof cause?.message === "string" && cause.message.includes("Failed to load url") || typeof cause?.message === "string" && cause.message.startsWith("Cannot find module '")) {
@@ -669,8 +663,6 @@ function startVitestModuleRunner(options) {
 		vm,
 		createImportMeta: options.createImportMeta
 	});
-	// await moduleRunner.import('/@vite/env')
-	// await moduleRunner.mocker.initializeSpyModule()
 	return moduleRunner;
 }
 function toBuiltin(id) {

package/dist/chunks/{test.KC5tH8hC.js → test.CTuWuHYH.js}

@@ -1,14 +1,14 @@
 import { updateTask } from '@vitest/runner';
 import { createDefer } from '@vitest/utils/helpers';
 import { getSafeTimers } from '@vitest/utils/timers';
-import { a as getBenchOptions, g as getBenchFn } from './benchmark.LXhJ0F0X.js';
-import { g as getWorkerState } from './utils.DGKhod2J.js';
+import { a as getBenchOptions, g as getBenchFn } from './benchmark.DHKMYAts.js';
+import { g as getWorkerState } from './utils.CG9h5ccR.js';
 import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
 import { getTests, getNames, getTestName } from '@vitest/runner/utils';
 import { processError } from '@vitest/utils/error';
 import { normalize } from 'pathe';
-import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.CiJ0Laa6.js';
-import { r as rpc } from './rpc.jKGRSXIH.js';
+import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.B2--mG9U.js';
+import { r as rpc } from './rpc.cD77ENhU.js';
 
 function createBenchmarkResult(name) {
 	return {
@@ -37,7 +37,7 @@ async function runBenchmarkSuite(suite, runner) {
 		}, updateTask$1("suite-prepare", suite);
 		const addBenchTaskListener = (task, benchmark) => {
 			task.addEventListener("complete", (e) => {
-				const task = e.task, taskRes = task.result, result = benchmark.result.benchmark;
+				const taskRes = e.task.result, result = benchmark.result.benchmark;
 				benchmark.result.state = "pass", Object.assign(result, taskRes);
 				// compute extra stats and free raw samples as early as possible
 				const samples = result.samples;