vitest 3.2.0-beta.1 → 3.2.0-beta.2

package/dist/chunks/{index.BPc7M5ni.js → index.CfXMNXHg.js}

@@ -1,18 +1,10 @@
 import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.BFR5YIgu.js';
-import { i as isFirstRun, a as runOnce } from './run-once.Dimr7O9f.js';
 import { b as bench } from './benchmark.BoF7jW0Q.js';
 import { expectTypeOf } from 'expect-type';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
 import * as chai from 'chai';
 import { assert, should } from 'chai';
 
-function getRunningMode() {
-	return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
-}
-function isWatchMode() {
-	return getRunningMode() === "watch";
-}
-
 const assertType = function assertType() {};
 
 var VitestIndex = /*#__PURE__*/Object.freeze({
@@ -29,14 +21,10 @@ var VitestIndex = /*#__PURE__*/Object.freeze({
   describe: describe,
   expect: globalExpect,
   expectTypeOf: expectTypeOf,
-  getRunningMode: getRunningMode,
   inject: inject,
-  isFirstRun: isFirstRun,
-  isWatchMode: isWatchMode,
   it: it,
   onTestFailed: onTestFailed,
   onTestFinished: onTestFinished,
-  runOnce: runOnce,
   should: should,
   suite: suite,
   test: test,
@@ -44,4 +32,4 @@ var VitestIndex = /*#__PURE__*/Object.freeze({
   vitest: vitest
 });
 
-export { VitestIndex as V, assertType as a, getRunningMode as g, isWatchMode as i };
+export { VitestIndex as V, assertType as a };

package/dist/chunks/index.CmC5OK9L.js

@@ -0,0 +1,275 @@
+import fs from 'node:fs';
+import { getTasks, getFullName, getTests } from '@vitest/runner/utils';
+import * as pathe from 'pathe';
+import c from 'tinyrainbow';
+import { g as getStateSymbol, t as truncateString, F as F_RIGHT, D as DefaultReporter, f as formatProjectName } from './index.CV36oG_L.js';
+import { stripVTControlCharacters } from 'node:util';
+import { notNullish } from '@vitest/utils';
+
+function createBenchmarkJsonReport(files) {
+	const report = { files: [] };
+	for (const file of files) {
+		const groups = [];
+		for (const task of getTasks(file)) {
+			if (task?.type === "suite") {
+				const benchmarks = [];
+				for (const t of task.tasks) {
+					const benchmark = t.meta.benchmark && t.result?.benchmark;
+					if (benchmark) {
+						benchmarks.push({
+							id: t.id,
+							...benchmark,
+							samples: []
+						});
+					}
+				}
+				if (benchmarks.length) {
+					groups.push({
+						fullName: getFullName(task, " > "),
+						benchmarks
+					});
+				}
+			}
+		}
+		report.files.push({
+			filepath: file.filepath,
+			groups
+		});
+	}
+	return report;
+}
+function flattenFormattedBenchmarkReport(report) {
+	const flat = {};
+	for (const file of report.files) {
+		for (const group of file.groups) {
+			for (const t of group.benchmarks) {
+				flat[t.id] = t;
+			}
+		}
+	}
+	return flat;
+}
+
+const outputMap = new WeakMap();
+function formatNumber(number) {
+	const res = String(number.toFixed(number < 100 ? 4 : 2)).split(".");
+	return res[0].replace(/(?=(?:\d{3})+$)\B/g, ",") + (res[1] ? `.${res[1]}` : "");
+}
+const tableHead = [
+	"name",
+	"hz",
+	"min",
+	"max",
+	"mean",
+	"p75",
+	"p99",
+	"p995",
+	"p999",
+	"rme",
+	"samples"
+];
+function renderBenchmarkItems(result) {
+	return [
+		result.name,
+		formatNumber(result.hz || 0),
+		formatNumber(result.min || 0),
+		formatNumber(result.max || 0),
+		formatNumber(result.mean || 0),
+		formatNumber(result.p75 || 0),
+		formatNumber(result.p99 || 0),
+		formatNumber(result.p995 || 0),
+		formatNumber(result.p999 || 0),
+		`±${(result.rme || 0).toFixed(2)}%`,
+		(result.sampleCount || 0).toString()
+	];
+}
+function computeColumnWidths(results) {
+	const rows = [tableHead, ...results.map((v) => renderBenchmarkItems(v))];
+	return Array.from(tableHead, (_, i) => Math.max(...rows.map((row) => stripVTControlCharacters(row[i]).length)));
+}
+function padRow(row, widths) {
+	return row.map((v, i) => i ? v.padStart(widths[i], " ") : v.padEnd(widths[i], " "));
+}
+function renderTableHead(widths) {
+	return " ".repeat(3) + padRow(tableHead, widths).map(c.bold).join("  ");
+}
+function renderBenchmark(result, widths) {
+	const padded = padRow(renderBenchmarkItems(result), widths);
+	return [
+		padded[0],
+		c.blue(padded[1]),
+		c.cyan(padded[2]),
+		c.cyan(padded[3]),
+		c.cyan(padded[4]),
+		c.cyan(padded[5]),
+		c.cyan(padded[6]),
+		c.cyan(padded[7]),
+		c.cyan(padded[8]),
+		c.dim(padded[9]),
+		c.dim(padded[10])
+	].join("  ");
+}
+function renderTable(options) {
+	const output = [];
+	const benchMap = {};
+	for (const task of options.tasks) {
+		if (task.meta.benchmark && task.result?.benchmark) {
+			benchMap[task.id] = {
+				current: task.result.benchmark,
+				baseline: options.compare?.[task.id]
+			};
+		}
+	}
+	const benchCount = Object.entries(benchMap).length;
+	const columnWidths = computeColumnWidths(Object.values(benchMap).flatMap((v) => [v.current, v.baseline]).filter(notNullish));
+	let idx = 0;
+	const padding = "  ".repeat(1 );
+	for (const task of options.tasks) {
+		const duration = task.result?.duration;
+		const bench = benchMap[task.id];
+		let prefix = "";
+		if (idx === 0 && task.meta?.benchmark) {
+			prefix += `${renderTableHead(columnWidths)}\n${padding}`;
+		}
+		prefix += ` ${getStateSymbol(task)} `;
+		let suffix = "";
+		if (task.type === "suite") {
+			suffix += c.dim(` (${getTests(task).length})`);
+		}
+		if (task.mode === "skip" || task.mode === "todo") {
+			suffix += c.dim(c.gray(" [skipped]"));
+		}
+		if (duration != null) {
+			const color = duration > options.slowTestThreshold ? c.yellow : c.green;
+			suffix += color(` ${Math.round(duration)}${c.dim("ms")}`);
+		}
+		if (options.showHeap && task.result?.heap != null) {
+			suffix += c.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
+		}
+		if (bench) {
+			let body = renderBenchmark(bench.current, columnWidths);
+			if (options.compare && bench.baseline) {
+				if (bench.current.hz) {
+					const diff = bench.current.hz / bench.baseline.hz;
+					const diffFixed = diff.toFixed(2);
+					if (diffFixed === "1.0.0") {
+						body += c.gray(`  [${diffFixed}x]`);
+					}
+					if (diff > 1) {
+						body += c.blue(`  [${diffFixed}x] ⇑`);
+					} else {
+						body += c.red(`  [${diffFixed}x] ⇓`);
+					}
+				}
+				output.push(padding + prefix + body + suffix);
+				const bodyBaseline = renderBenchmark(bench.baseline, columnWidths);
+				output.push(`${padding}   ${bodyBaseline}  ${c.dim("(baseline)")}`);
+			} else {
+				if (bench.current.rank === 1 && benchCount > 1) {
+					body += c.bold(c.green("   fastest"));
+				}
+				if (bench.current.rank === benchCount && benchCount > 2) {
+					body += c.bold(c.gray("   slowest"));
+				}
+				output.push(padding + prefix + body + suffix);
+			}
+		} else {
+			output.push(padding + prefix + task.name + suffix);
+		}
+		if (task.result?.state !== "pass" && outputMap.get(task) != null) {
+			let data = outputMap.get(task);
+			if (typeof data === "string") {
+				data = stripVTControlCharacters(data.trim().split("\n").filter(Boolean).pop());
+				if (data === "") {
+					data = undefined;
+				}
+			}
+			if (data != null) {
+				const out = `   ${"  ".repeat(options.level)}${F_RIGHT} ${data}`;
+				output.push(c.gray(truncateString(out, options.columns)));
+			}
+		}
+		idx++;
+	}
+	return output.filter(Boolean).join("\n");
+}
+
+class BenchmarkReporter extends DefaultReporter {
+	compare;
+	async onInit(ctx) {
+		super.onInit(ctx);
+		if (this.ctx.config.benchmark?.compare) {
+			const compareFile = pathe.resolve(this.ctx.config.root, this.ctx.config.benchmark?.compare);
+			try {
+				this.compare = flattenFormattedBenchmarkReport(JSON.parse(await fs.promises.readFile(compareFile, "utf-8")));
+			} catch (e) {
+				this.error(`Failed to read '${compareFile}'`, e);
+			}
+		}
+	}
+	onTaskUpdate(packs) {
+		for (const pack of packs) {
+			const task = this.ctx.state.idMap.get(pack[0]);
+			if (task?.type === "suite" && task.result?.state !== "run") {
+				task.tasks.filter((task) => task.result?.benchmark).sort((benchA, benchB) => benchA.result.benchmark.mean - benchB.result.benchmark.mean).forEach((bench, idx) => {
+					bench.result.benchmark.rank = Number(idx) + 1;
+				});
+			}
+		}
+	}
+	onTestSuiteResult(testSuite) {
+		super.onTestSuiteResult(testSuite);
+		this.printSuiteTable(testSuite);
+	}
+	printTestModule(testModule) {
+		this.printSuiteTable(testModule);
+	}
+	printSuiteTable(testTask) {
+		const state = testTask.state();
+		if (state === "pending" || state === "queued") {
+			return;
+		}
+		const benches = testTask.task.tasks.filter((t) => t.meta.benchmark);
+		const duration = testTask.task.result?.duration || 0;
+		if (benches.length > 0 && benches.every((t) => t.result?.state !== "run" && t.result?.state !== "queued")) {
+			let title = `\n ${getStateSymbol(testTask.task)} ${formatProjectName(testTask.project)}${getFullName(testTask.task, c.dim(" > "))}`;
+			if (duration != null && duration > this.ctx.config.slowTestThreshold) {
+				title += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
+			}
+			this.log(title);
+			this.log(renderTable({
+				tasks: benches,
+				level: 1,
+				columns: this.ctx.logger.getColumns(),
+				compare: this.compare,
+				showHeap: this.ctx.config.logHeapUsage,
+				slowTestThreshold: this.ctx.config.slowTestThreshold
+			}));
+		}
+	}
+	async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
+		super.onFinished(files, errors);
+		let outputFile = this.ctx.config.benchmark?.outputJson;
+		if (outputFile) {
+			outputFile = pathe.resolve(this.ctx.config.root, outputFile);
+			const outputDirectory = pathe.dirname(outputFile);
+			if (!fs.existsSync(outputDirectory)) {
+				await fs.promises.mkdir(outputDirectory, { recursive: true });
+			}
+			const output = createBenchmarkJsonReport(files);
+			await fs.promises.writeFile(outputFile, JSON.stringify(output, null, 2));
+			this.log(`Benchmark report written to ${outputFile}`);
+		}
+	}
+}
+
+class VerboseBenchmarkReporter extends BenchmarkReporter {
+	verbose = true;
+}
+
+const BenchmarkReportsMap = {
+	default: BenchmarkReporter,
+	verbose: VerboseBenchmarkReporter
+};
+
+export { BenchmarkReporter as B, VerboseBenchmarkReporter as V, BenchmarkReportsMap as a };

package/dist/chunks/{index.DbWBPwtH.js → index.DswW_LEs.js}

@@ -1,6 +1,6 @@
 import * as chai from 'chai';
 import { resolve } from 'node:path';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.BP6KrF_Z.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.CYo3Y0dD.js';
 import { distDir } from '../path.js';
 import { r as rpc } from './rpc.D9_013TY.js';
 import { g as getWorkerState } from './utils.CgTj3MsC.js';

package/dist/chunks/{index.DBIGubLC.js → index.X0nbfr6-.js}

@@ -1,4 +1,4 @@
-import p from 'node:path';
+import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import process$1 from 'node:process';
 import { promises } from 'node:fs';
@@ -237,7 +237,7 @@ async function locatePath(
 
 	return pLocate(paths, async path_ => {
 		try {
-			const stat = await statFunction(p.resolve(cwd, path_));
+			const stat = await statFunction(path.resolve(cwd, path_));
 			return matchType(type, stat);
 		} catch {
 			return false;
@@ -250,9 +250,9 @@ const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath)
 const findUpStop = Symbol('findUpStop');
 
 async function findUpMultiple(name, options = {}) {
-	let directory = p.resolve(toPath(options.cwd) || '');
-	const {root} = p.parse(directory);
-	const stopAt = p.resolve(directory, options.stopAt || root);
+	let directory = path.resolve(toPath(options.cwd) || '');
+	const {root} = path.parse(directory);
+	const stopAt = path.resolve(directory, options.stopAt || root);
 	const limit = options.limit || Number.POSITIVE_INFINITY;
 	const paths = [name].flat();
 
@@ -280,14 +280,14 @@ async function findUpMultiple(name, options = {}) {
 		}
 
 		if (foundPath) {
-			matches.push(p.resolve(directory, foundPath));
+			matches.push(path.resolve(directory, foundPath));
 		}
 
 		if (directory === stopAt || matches.length >= limit) {
 			break;
 		}
 
-		directory = p.dirname(directory);
+		directory = path.dirname(directory);
 	}
 
 	return matches;

package/dist/chunks/{reporters.d.DGm4k1Wx.d.ts → reporters.d.CLC9rhKy.d.ts}

@@ -1444,6 +1444,15 @@ interface SequenceOptions {
 	*/
 	sequencer?: TestSequencerConstructor;
 	/**
+	* Controls the order in which this project runs its tests when using multiple [projects](/guide/projects).
+	*
+	* - Projects with the same group order number will run together, and groups are run from lowest to highest.
+	* - If you don’t set this option, all projects run in parallel.
+	* - If several projects use the same group order, they will run at the same time.
+	* @default 0
+	*/
+	groupOrder?: number;
+	/**
 	* Should files and tests run in random order.
 	* @default false
 	*/
@@ -2277,6 +2286,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, "project" | "config"
 		shuffle?: boolean
 		concurrent?: boolean
 		seed: number
+		groupOrder: number
 	};
 	typecheck: Omit<TypecheckConfig, "enabled"> & {
 		enabled: boolean
@@ -2598,6 +2608,12 @@ declare class TestProject {
 	private _provided;
 	constructor(path: string | number, vitest: Vitest, options?: InitializeProjectOptions | undefined);
 	/**
+	* The unique hash of this project. This value is consistent between the reruns.
+	*
+	* It is based on the root of the project (not consistent between OS) and its name.
+	*/
+	get hash(): string;
+	/**
 	* Provide a value to the test context. This value will be available to all tests with `inject`.
 	*/
 	provide: <T extends keyof ProvidedContext & string>(key: T, value: ProvidedContext[T]) => void;
@@ -2698,6 +2714,7 @@ declare class TestProject {
 	getName(): string;
 	/** @deprecated internal */
 	setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
+	private _setHash;
 	private _serializeOverriddenConfig;
 	private clearTmpDir;
 	/** @deprecated */

package/dist/chunks/{runBaseTests.CguliJB5.js → runBaseTests.Dn2vyej_.js}

@@ -1,7 +1,7 @@
 import { performance } from 'node:perf_hooks';
 import { startTests, collectTests } from '@vitest/runner';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.DbWBPwtH.js';
-import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.BP6KrF_Z.js';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.DswW_LEs.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.CYo3Y0dD.js';
 import { a as globalExpect, v as vi } from './vi.BFR5YIgu.js';
 import { c as closeInspector } from './inspector.DbDkSkFn.js';
 import { createRequire } from 'node:module';
@@ -11,7 +11,7 @@ import util from 'node:util';
 import { getSafeTimers } from '@vitest/utils';
 import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
 import { installSourcemapsSupport } from 'vite-node/source-map';
-import { V as VitestIndex } from './index.BPc7M5ni.js';
+import { V as VitestIndex } from './index.CfXMNXHg.js';
 import { g as getWorkerState, r as resetModules } from './utils.CgTj3MsC.js';
 import 'chai';
 import 'node:path';
@@ -21,7 +21,6 @@ import './rpc.D9_013TY.js';
 import './index.CJ0plNrh.js';
 import './coverage.0iPg4Wrz.js';
 import '@vitest/snapshot';
-import './run-once.Dimr7O9f.js';
 import '@vitest/expect';
 import '@vitest/runner/utils';
 import './_commonjsHelpers.BFTU3MAI.js';

package/dist/chunks/{setup-common.BP6KrF_Z.js → setup-common.CYo3Y0dD.js}

@@ -1,7 +1,6 @@
 import { r as resolveCoverageProviderModule } from './coverage.0iPg4Wrz.js';
 import { addSerializer } from '@vitest/snapshot';
 import { setSafeTimers } from '@vitest/utils';
-import { r as resetRunOnceCounter } from './run-once.Dimr7O9f.js';
 
 async function startCoverageInsideWorker(options, loader, runtimeOptions) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
@@ -27,7 +26,6 @@ async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
-	resetRunOnceCounter();
 	setupDefines(config.defines);
 	setupEnv(config.env);
 	if (globalSetup) {
@@ -36,7 +34,7 @@ async function setupCommonEnv(config) {
 	globalSetup = true;
 	setSafeTimers();
 	if (config.globals) {
-		(await import('./globals.Cg4NtV4P.js')).registerApiGlobally();
+		(await import('./globals.CpxW8ccg.js')).registerApiGlobally();
 	}
 }
 function setupDefines(defines) {