vitest 5.0.0-beta.6 → 5.0.0-beta.7

package/dist/chunks/{console.DjVIMaXT.js → console.omGxyKMT.js}

@@ -1,11 +1,11 @@
 import { Console } from 'node:console';
 import { relative } from 'node:path';
 import { Writable } from 'node:stream';
-import { getSafeTimers } from '@vitest/utils/timers';
-import c from 'tinyrainbow';
-import { R as RealDate } from './rpc.DZEh5xnQ.js';
+import { a as getSafeTimers } from './source-map.DZdIqpIJ.js';
+import { y } from './tinyrainbow.Ht9iggcq.js';
+import { R as RealDate } from './rpc.iNjF664v.js';
 import { g as getWorkerState } from './utils.DYj33du9.js';
-import 'pathe';
+import './pathe.M-eThtNZ.CbK_Vbae.js';
 import 'vite/module-runner';
 import './index.Chj8NDwU.js';
 
@@ -141,7 +141,7 @@ function createCustomConsole(defaultState) {
 			schedule(id);
 			callback();
 		} }),
-		colorMode: c.isColorSupported,
+		colorMode: y.isColorSupported,
 		groupIndentation: 2
 	});
 }

package/dist/chunks/{coverage.CTzCuANN.js → coverage.BVb1JqW7.js}

@@ -1,3 +1,8 @@
+import { r as resolve } from './pathe.M-eThtNZ.CbK_Vbae.js';
+
+function getCoverageFilesDirectory(reportsDirectory, shard) {
+	return resolve(reportsDirectory, `.tmp${shard ? `-${shard.index}-${shard.count}` : ""}`);
+}
 const CoverageProviderMap = {
 	v8: "@vitest/coverage-v8",
 	istanbul: "@vitest/coverage-istanbul"
@@ -7,7 +12,7 @@ async function resolveCoverageProviderModule(options, loader) {
 	const provider = options.provider;
 	if (provider === "v8" || provider === "istanbul") {
 		let builtInModule = CoverageProviderMap[provider];
-		if (provider === "v8" && loader.isBrowser) builtInModule += "/browser";
+		if (loader.isBrowser) builtInModule += "/browser";
 		const { default: coverageModule } = loader.isBrowser ? await loader.import(builtInModule) : await import(
 			/* @vite-ignore */
 			builtInModule
@@ -25,4 +30,4 @@ async function resolveCoverageProviderModule(options, loader) {
 	return customProviderModule.default;
 }
 
-export { CoverageProviderMap as C, resolveCoverageProviderModule as r };
+export { CoverageProviderMap as C, getCoverageFilesDirectory as g, resolveCoverageProviderModule as r };

package/dist/chunks/coverage.BfSEMtie.js

@@ -0,0 +1,26 @@
+import { r as resolveCoverageProviderModule } from './coverage.BVb1JqW7.js';
+
+async function startCoverageInsideWorker(options, loader, runtimeOptions) {
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) return coverageModule.startCoverage?.({
+		...runtimeOptions,
+		autoAttachSubprocess: options.autoAttachSubprocess,
+		reportsDirectory: options.reportsDirectory
+	});
+	return null;
+}
+async function takeCoverageInsideWorker(options, loader) {
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) return coverageModule.takeCoverage?.({
+		moduleExecutionInfo: loader.moduleExecutionInfo,
+		coverageFilesDirectory: options.coverageFilesDirectory
+	});
+	return null;
+}
+async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
+	const coverageModule = await resolveCoverageProviderModule(options, loader);
+	if (coverageModule) return coverageModule.stopCoverage?.(runtimeOptions);
+	return null;
+}
+
+export { stopCoverageInsideWorker as a, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };

package/dist/chunks/coverage.d.ByaAMV4A.d.ts

@@ -0,0 +1,88 @@
+import { aU as TestError, au as ParsedStack } from './config.d.DsC1jkby.js';
+
+type OriginalMapping = {
+    source: string | null;
+    line: number;
+    column: number;
+    name: string | null;
+};
+
+interface StackTraceParserOptions {
+	ignoreStackEntries?: (RegExp | string)[];
+	getSourceMap?: (file: string) => unknown;
+	getUrlId?: (id: string) => string;
+	frameFilter?: (error: TestError, frame: ParsedStack) => boolean | void;
+}
+interface SourceMapLike {
+	version: number;
+	mappings?: string;
+	names?: string[];
+	sources?: string[];
+	sourcesContent?: string[];
+	sourceRoot?: string;
+}
+interface Needle {
+	line: number;
+	column: number;
+}
+declare class DecodedMap {
+	map: SourceMapLike;
+	_encoded: string;
+	_decoded: undefined | number[][][];
+	_decodedMemo: Stats;
+	url: string;
+	version: number;
+	names: string[];
+	resolvedSources: string[];
+	constructor(map: SourceMapLike, from: string);
+}
+interface Stats {
+	lastKey: number;
+	lastNeedle: number;
+	lastIndex: number;
+}
+declare function getOriginalPosition(map: DecodedMap, needle: Needle): OriginalMapping | null;
+
+interface RuntimeCoverageModuleLoader {
+	import: (id: string) => Promise<{
+		default: RuntimeCoverageProviderModule;
+	}>;
+	isBrowser?: boolean;
+	moduleExecutionInfo?: Map<string, {
+		startOffset: number;
+	}>;
+}
+interface RuntimeCoverageProviderModule {
+	/**
+	* Factory for creating a new coverage provider
+	*/
+	getProvider: () => any;
+	/**
+	* Executed before tests are run in the worker thread.
+	*/
+	startCoverage?: (runtimeOptions: {
+		isolate: boolean;
+		/** @internal */
+		autoAttachSubprocess: boolean;
+		/** @internal */
+		reportsDirectory: string;
+	}) => unknown | Promise<unknown>;
+	/**
+	* Executed on after each run in the worker thread. Possible to return a payload passed to the provider
+	*/
+	takeCoverage?: (runtimeOptions?: {
+		moduleExecutionInfo?: Map<string, {
+			startOffset: number;
+		}>;
+		coverageFilesDirectory: string;
+	}) => unknown | Promise<unknown>;
+	/**
+	* Executed after all tests have been run in the worker thread.
+	*/
+	stopCoverage?: (runtimeOptions: {
+		isolate: boolean;
+	}) => unknown | Promise<unknown>;
+}
+
+export { DecodedMap as D, getOriginalPosition as g };
+export type { RuntimeCoverageModuleLoader as R, StackTraceParserOptions as S, RuntimeCoverageProviderModule as a };

package/dist/chunks/{creator.C4nK7Krt.js → creator.BzMFaPC-.js}

@@ -2,31 +2,55 @@ import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { resolve, dirname, relative } from 'node:path';
 import { detectPackageManager, installPackage } from './index.CMESou6r.js';
-import { p as prompt, f as findConfigFile } from './index.Djaij2xr.js';
+import { w as prompt, x as findConfigFile } from './index.5krd73UD.js';
 import { x } from 'tinyexec';
-import c from 'tinyrainbow';
+import { y } from './tinyrainbow.Ht9iggcq.js';
 import 'node:process';
+import 'node:os';
+import './pathe.M-eThtNZ.CbK_Vbae.js';
+import './source-map.DZdIqpIJ.js';
+import './cac.B41kXwyU.js';
+import 'events';
+import './env.DzFJjrmK.js';
+import 'std-env';
+import './constants.-juJ8b_4.js';
+import 'node:assert';
+import '../path.js';
 import 'node:url';
-import '@vitest/utils/helpers';
-import './index.CesbTg1C.js';
+import './artifact.DC5WoEgy.js';
+import './index.DzTmMrSM.js';
+import './display.CYwyMF4S.js';
+import '../task-utils.js';
+import './nativeModuleRunner.BDnwGb8g.js';
 import 'node:module';
-import 'pathe';
-import 'node:assert';
 import 'node:v8';
 import 'node:util';
-import 'tinyglobby';
+import 'vite/module-runner';
+import '../traces.js';
 import 'vite';
-import './constants.-juJ8b_4.js';
-import './defaults.B_pFOTYy.js';
-import 'node:os';
-import './env.BKKtU2WC.js';
-import 'std-env';
-import './utils.DKODp04v.js';
-import '@vitest/utils/display';
+import 'obug';
 import 'node:crypto';
-import './_commonjsHelpers.D26ty3Ew.js';
+import 'tinyglobby';
+import './defaults.BJUmAuaO.js';
+import 'magic-string';
+import '@vitest/mocker/node';
+import 'node:console';
+import 'node:stream';
+import 'node:perf_hooks';
+import './offset.Dy-5Fdfn.js';
+import './utils.CO-iLyCr.js';
+import '#module-evaluator';
+import 'picomatch';
+import './coverage.BVb1JqW7.js';
+import './resolver.CERfsKE-.js';
+import 'es-module-lexer';
+import 'node:tty';
+import 'node:events';
+import './index.Chj8NDwU.js';
+import './modules.BJuCwlRJ.js';
+import 'node:child_process';
+import 'node:worker_threads';
 import 'readline';
-import 'events';
 
 const jsxExample = {
 	name: "HelloWorld.jsx",
@@ -475,11 +499,11 @@ function getLanguageOptions() {
 }
 async function installPackages(pkgManager, packages) {
 	if (!packages.length) {
-		log(c.green("✔"), c.bold("All packages are already installed."));
+		log(y.green("✔"), y.bold("All packages are already installed."));
 		return;
 	}
-	log(c.cyan("◼"), c.bold("Installing packages..."));
-	log(c.cyan("◼"), packages.join(", "));
+	log(y.cyan("◼"), y.bold("Installing packages..."));
+	log(y.cyan("◼"), packages.join(", "));
 	log();
 	await installPackage(packages, {
 		dev: true,
@@ -579,7 +603,7 @@ async function updatePkgJsonScripts(pkgJsonPath, vitestScript) {
 		pkg.scripts["test:browser"] = vitestScript;
 		await writeFile(pkgJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf-8");
 	}
-	log(c.green("✔"), "Added \"test:browser\" script to your package.json.");
+	log(y.green("✔"), "Added \"test:browser\" script to your package.json.");
 }
 function getRunScript(pkgManager) {
 	switch (pkgManager) {
@@ -602,7 +626,7 @@ function getPlaywrightRunArgs(pkgManager) {
 	}
 }
 async function create() {
-	log(c.cyan("◼"), "This utility will help you set up a browser testing environment.\n");
+	log(y.cyan("◼"), "This utility will help you set up a browser testing environment.\n");
 	const pkgJsonPath = resolve(process.cwd(), "package.json");
 	const pkg = readPkgJson(pkgJsonPath) || {};
 	const dependencies = {
@@ -670,13 +694,13 @@ async function create() {
 			browsers
 		});
 		log(
-			c.green("✔"),
+			y.green("✔"),
 			"Created a new config file for browser tests:",
-			c.bold(relative(process.cwd(), configPath)),
+			y.bold(relative(process.cwd(), configPath)),
 			// TODO: Can we modify the config ourselves?
 			"\nSince you already have a Vitest config file, it is recommended to copy the contents of the new file ",
 			"into your existing config located at ",
-			c.bold(relative(process.cwd(), rootConfig))
+			y.bold(relative(process.cwd(), rootConfig))
 		);
 	} else {
 		const configPath = resolve(process.cwd(), `vitest.config.${lang}`);
@@ -687,7 +711,7 @@ async function create() {
 			provider,
 			browsers
 		});
-		log(c.green("✔"), "Created a config file for browser tests:", c.bold(relative(process.cwd(), configPath)));
+		log(y.green("✔"), "Created a config file for browser tests:", y.bold(relative(process.cwd(), configPath)));
 	}
 	log();
 	await updatePkgJsonScripts(pkgJsonPath, scriptCommand);
@@ -700,7 +724,7 @@ async function create() {
 			"install",
 			"--with-deps"
 		];
-		log(c.cyan("◼"), `Installing Playwright dependencies with \`${c.bold(command)} ${c.bold(allArgs.join(" "))}\`...`);
+		log(y.cyan("◼"), `Installing Playwright dependencies with \`${y.bold(command)} ${y.bold(allArgs.join(" "))}\`...`);
 		log();
 		await x(command, allArgs, { nodeOptions: { stdio: [
 			"pipe",
@@ -710,10 +734,10 @@ async function create() {
 	}
 	log();
 	const exampleTestFile = await generateExampleFiles(framework, lang);
-	log(c.green("✔"), "Created example test file in", c.bold(relative(process.cwd(), exampleTestFile)));
-	log(c.dim("  You can safely delete this file once you have written your own tests."));
+	log(y.green("✔"), "Created example test file in", y.bold(relative(process.cwd(), exampleTestFile)));
+	log(y.dim("  You can safely delete this file once you have written your own tests."));
 	log();
-	log(c.cyan("◼"), "All done! Run your tests with", c.bold(getRunScript(pkgManager)));
+	log(y.cyan("◼"), "All done! Run your tests with", y.bold(getRunScript(pkgManager)));
 }
 
 export { create };

package/dist/chunks/{defaults.B_pFOTYy.js → defaults.BJUmAuaO.js}

@@ -1,5 +1,5 @@
 import nodeos__default from 'node:os';
-import './env.BKKtU2WC.js';
+import './env.DzFJjrmK.js';
 import { isCI, isAgent } from 'std-env';
 
 const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
@@ -50,6 +50,7 @@ const configDefaults = Object.freeze({
 	isolate: true,
 	watch: !isCI && process.stdin.isTTY && !isAgent,
 	globals: false,
+	injectCjsGlobals: true,
 	environment: "node",
 	clearMocks: true,
 	restoreMocks: false,

package/dist/chunks/display.CYwyMF4S.js

@@ -0,0 +1,192 @@
+import { f as format$1, p as plugins, c as createDOMElementFilter } from './index.DzTmMrSM.js';
+
+const { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;
+const PLUGINS = [
+	ReactTestComponent,
+	ReactElement,
+	DOMElement,
+	DOMCollection,
+	Immutable,
+	AsymmetricMatcher
+];
+function stringify(object, maxDepth = 10, { maxLength, filterNode, ...options } = {}) {
+	const MAX_LENGTH = maxLength ?? 1e4;
+	let result;
+	// Convert string selector to filter function
+	const filterFn = typeof filterNode === "string" ? createNodeFilterFromSelector(filterNode) : filterNode;
+	const plugins = filterFn ? [
+		ReactTestComponent,
+		ReactElement,
+		createDOMElementFilter(filterFn),
+		DOMCollection,
+		Immutable,
+		AsymmetricMatcher
+	] : PLUGINS;
+	try {
+		result = format$1(object, {
+			maxDepth,
+			escapeString: false,
+			plugins,
+			...options
+		});
+	} catch {
+		result = format$1(object, {
+			callToJSON: false,
+			maxDepth,
+			escapeString: false,
+			plugins,
+			...options
+		});
+	}
+	// Prevents infinite loop https://github.com/vitest-dev/vitest/issues/7249
+	return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
+		maxLength,
+		filterNode,
+		...options
+	}) : result;
+}
+function createNodeFilterFromSelector(selector) {
+	const ELEMENT_NODE = 1;
+	const COMMENT_NODE = 8;
+	return (node) => {
+		// Filter out comments
+		if (node.nodeType === COMMENT_NODE) return false;
+		// Filter out elements matching the selector
+		if (node.nodeType === ELEMENT_NODE && node.matches) try {
+			return !node.matches(selector);
+		} catch {
+			return true;
+		}
+		return true;
+	};
+}
+const formatRegExp = /%[sdjifoOc%]/g;
+function format(args, options = {}) {
+	const formatArg = (item) => inspect(item, options);
+	if (typeof args[0] !== "string") {
+		const objects = [];
+		for (let i = 0; i < args.length; i++) objects.push(formatArg(args[i]));
+		return objects.join(" ");
+	}
+	const len = args.length;
+	let i = 1;
+	const template = args[0];
+	let str = String(template).replace(formatRegExp, (x) => {
+		if (x === "%%") return "%";
+		if (i >= len) return x;
+		switch (x) {
+			case "%s": {
+				const value = args[i++];
+				if (typeof value === "bigint") return `${value.toString()}n`;
+				if (typeof value === "number" && value === 0 && 1 / value < 0) return "-0";
+				if (typeof value === "object" && value !== null) {
+					if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) return value.toString();
+					return formatArg(value);
+				}
+				return String(value);
+			}
+			case "%d": {
+				const value = args[i++];
+				if (typeof value === "bigint") return `${value.toString()}n`;
+				if (typeof value === "symbol") return "NaN";
+				return Number(value).toString();
+			}
+			case "%i": {
+				const value = args[i++];
+				if (typeof value === "bigint") return `${value.toString()}n`;
+				return Number.parseInt(String(value)).toString();
+			}
+			case "%f": return Number.parseFloat(String(args[i++])).toString();
+			case "%o":
+			case "%O": return formatArg(args[i++]);
+			case "%c":
+				i++;
+				return "";
+			case "%j": try {
+				return JSON.stringify(args[i++]);
+			} catch (err) {
+				const m = err.message;
+				if (m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")) return "[Circular]";
+				throw err;
+			}
+			default: return x;
+		}
+	});
+	for (let x = args[i]; i < len; x = args[++i]) if (x === null || typeof x !== "object") str += ` ${typeof x === "symbol" ? x.toString() : x}`;
+	else str += ` ${formatArg(x)}`;
+	return str;
+}
+function inspect(obj, options) {
+	const { truncate, multiline, ...stringifyOptions } = options ?? {};
+	const prettyFormatOptions = {
+		singleQuote: true,
+		quoteKeys: false,
+		min: true,
+		spacingInner: " ",
+		spacingOuter: " ",
+		printBasicPrototype: false,
+		compareKeys: null,
+		...multiline ? {
+			min: false,
+			spacingInner: void 0,
+			spacingOuter: void 0
+		} : {}
+	};
+	const threshold = truncate ?? 0;
+	const formatted = stringify(obj, void 0, {
+		...prettyFormatOptions,
+		...stringifyOptions,
+		maxLength: threshold || void 0
+	});
+	if (threshold === 0 || formatted.length <= threshold) return formatted;
+	// if stringify's adaptive maxDepth (down to 1) fails to truncate enough,
+	// - for known types (e.g. string, object, array, etc), apply best effort truncation.
+	// - for other values, fallback to maxDepth = 0 which should can show minimal output.
+	const type = Object.prototype.toString.call(obj);
+	if (typeof obj === "string") {
+		let end = threshold - 1;
+		if (end > 0 && isHighSurrogate(formatted[end - 1])) end = end - 1;
+		return `'${formatted.slice(1, end)}…'`;
+	}
+	if (type === "[object Array]" || type === "[object Object]" || type === "[object Set]" || type === "[object Map]") return stringifyByMaxWidth(obj, threshold, {
+		...prettyFormatOptions,
+		...stringifyOptions,
+		maxDepth: 1
+	});
+	return stringify(obj, void 0, {
+		...prettyFormatOptions,
+		...stringifyOptions,
+		maxDepth: 0
+	});
+}
+function truncateString(string, maxLength) {
+	if (string.length <= maxLength) return string;
+	let end = maxLength - 1;
+	if (isHighSurrogate(string[end - 1])) end = end - 1;
+	return `${string.slice(0, end)}…`;
+}
+function stringifyByMaxWidth(object, threshold, options) {
+	function evaluate(x) {
+		return stringify(object, void 0, {
+			...options,
+			maxWidth: x
+		});
+	}
+	return evaluate(binarySearch(0, threshold, (x) => evaluate(x).length <= threshold));
+}
+// find max(x \in [x, y) | f(x) = true)
+// if f(x0) is false, then returns x0.
+function binarySearch(x0, x1, f) {
+	while (x0 + 1 < x1) {
+		const x = Math.floor((x0 + x1) / 2);
+		if (f(x)) x0 = x;
+		else x1 = x;
+	}
+	return x0;
+}
+// https://github.com/chaijs/loupe/pull/79
+function isHighSurrogate(char) {
+	return char >= "\ud800" && char <= "\udbff";
+}
+
+export { formatRegExp as a, format as f, inspect as i, stringify as s, truncateString as t };

package/dist/chunks/{env.BKKtU2WC.js → env.DzFJjrmK.js}

@@ -6,4 +6,4 @@ const isWindows = (isNode || isDeno) && process.platform === "win32";
 const isTTY = (isNode || isDeno) && process.stdout?.isTTY && !isCI;
 const isForceColor = () => "FORCE_COLOR" in process.env;
 
-export { isTTY as a, isWindows as b, isForceColor as i };
+export { isForceColor as a, isTTY as b, isWindows as i };

package/dist/chunks/{environment.d.CrsxCzP1.d.ts → environment.d.4-rzQgpt.d.ts}

@@ -1,4 +1,4 @@
-import { Awaitable } from '@vitest/utils';
+import { A as Awaitable } from './config.d.DsC1jkby.js';
 
 interface EnvironmentReturn {
 	teardown: (global: any) => Awaitable<void>;

package/dist/chunks/globals.sd6Qutmc.js

@@ -0,0 +1,28 @@
+import { g as globalApis } from './constants.-juJ8b_4.js';
+import { i as index } from './index.CLtI1k_4.js';
+import './artifact.DC5WoEgy.js';
+import './index.DzTmMrSM.js';
+import './tinyrainbow.Ht9iggcq.js';
+import './display.CYwyMF4S.js';
+import './pathe.M-eThtNZ.CbK_Vbae.js';
+import './source-map.DZdIqpIJ.js';
+import '../task-utils.js';
+import './utils.DYj33du9.js';
+import './spy.B8mHA9qu.js';
+import './rpc.iNjF664v.js';
+import 'vite/module-runner';
+import './index.Chj8NDwU.js';
+import 'chai';
+import './plugins.CsoX-42X.js';
+import './offset.Dy-5Fdfn.js';
+import 'tinybench';
+import 'expect-type';
+
+function registerApiGlobally() {
+	globalApis.forEach((api) => {
+		// @ts-expect-error I know what I am doing :P
+		globalThis[api] = index[api];
+	});
+}
+
+export { registerApiGlobally };