vitest 4.0.7 → 4.0.9

package/dist/chunks/{test.B6aJd6T3.js → test.w5HLbjmU.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.DHKMYAts.js';
-import { g as getWorkerState } from './utils.CG9h5ccR.js';
+import { a as getBenchOptions, g as getBenchFn } from './benchmark.B3N2zMcH.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.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.BZvkKVkM.js';
-import { r as rpc } from './rpc.D38ahn14.js';
+import { a as getSnapshotClient, i as inject, c as createExpect, v as vi } from './vi.CyIUVSoU.js';
+import { r as rpc } from './rpc.BytlcPfC.js';
 
 function createBenchmarkResult(name) {
 	return {
@@ -20,7 +20,10 @@ function createBenchmarkResult(name) {
 }
 const benchmarkTasks = /* @__PURE__ */ new WeakMap();
 async function runBenchmarkSuite(suite, runner) {
-	const { Task, Bench } = await runner.importTinybench(), start = performance.now(), benchmarkGroup = [], benchmarkSuiteGroup = [];
+	const { Task, Bench } = await runner.importTinybench();
+	const start = performance.now();
+	const benchmarkGroup = [];
+	const benchmarkSuiteGroup = [];
 	for (const task of suite.tasks) {
 		if (task.mode !== "run" && task.mode !== "queued") continue;
 		if (task.meta?.benchmark) benchmarkGroup.push(task);
@@ -34,38 +37,53 @@ async function runBenchmarkSuite(suite, runner) {
 			state: "run",
 			startTime: start,
 			benchmark: createBenchmarkResult(suite.name)
-		}, updateTask$1("suite-prepare", suite);
+		};
+		updateTask$1("suite-prepare", suite);
 		const addBenchTaskListener = (task, benchmark) => {
 			task.addEventListener("complete", (e) => {
-				const taskRes = e.task.result, result = benchmark.result.benchmark;
-				benchmark.result.state = "pass", Object.assign(result, taskRes);
+				const taskRes = e.task.result;
+				const 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;
-				if (result.sampleCount = samples.length, result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2, !runner.config.benchmark?.includeSamples) result.samples.length = 0;
+				result.sampleCount = samples.length;
+				result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
+				if (!runner.config.benchmark?.includeSamples) result.samples.length = 0;
 				updateTask$1("test-finished", benchmark);
-			}, { once: true }), task.addEventListener("error", (e) => {
+			}, { once: true });
+			task.addEventListener("error", (e) => {
 				const task = e.task;
 				defer.reject(benchmark ? task.result.error : e);
 			}, { once: true });
 		};
 		benchmarkGroup.forEach((benchmark) => {
-			const options = getBenchOptions(benchmark), benchmarkInstance = new Bench(options), benchmarkFn = getBenchFn(benchmark);
+			const benchmarkInstance = new Bench(getBenchOptions(benchmark));
+			const benchmarkFn = getBenchFn(benchmark);
 			benchmark.result = {
 				state: "run",
 				startTime: start,
 				benchmark: createBenchmarkResult(benchmark.name)
 			};
 			const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
-			benchmarkTasks.set(benchmark, task), addBenchTaskListener(task, benchmark);
+			benchmarkTasks.set(benchmark, task);
+			addBenchTaskListener(task, benchmark);
 		});
-		const { setTimeout } = getSafeTimers(), tasks = [];
+		const { setTimeout } = getSafeTimers();
+		const tasks = [];
 		for (const benchmark of benchmarkGroup) {
 			const task = benchmarkTasks.get(benchmark);
-			updateTask$1("test-prepare", benchmark), await task.warmup(), tasks.push([await new Promise((resolve) => setTimeout(async () => {
+			updateTask$1("test-prepare", benchmark);
+			await task.warmup();
+			tasks.push([await new Promise((resolve) => setTimeout(async () => {
 				resolve(await task.run());
 			})), benchmark]);
 		}
-		suite.result.duration = performance.now() - start, suite.result.state = "pass", updateTask$1("suite-finished", suite), defer.resolve(null), await defer;
+		suite.result.duration = performance.now() - start;
+		suite.result.state = "pass";
+		updateTask$1("suite-finished", suite);
+		defer.resolve(null);
+		await defer;
 	}
 	function updateTask$1(event, task) {
 		updateTask(event, task, runner);
@@ -120,7 +138,8 @@ class VitestTestRunner {
 		this.workerState.onCleanup(listener);
 	}
 	onAfterRunFiles() {
-		this.snapshotClient.clear(), this.workerState.current = void 0;
+		this.snapshotClient.clear();
+		this.workerState.current = void 0;
 	}
 	getWorkerContext() {
 		return workerContext;
@@ -137,7 +156,9 @@ class VitestTestRunner {
 			if (this.workerState.config.snapshotOptions.updateSnapshot === "none" && result.unchecked) {
 				let message = `Obsolete snapshots found when no snapshot update is expected.\n`;
 				for (const key of result.uncheckedKeys) message += `· ${key}\n`;
-				suite.result.errors ??= [], suite.result.errors.push(processError(new Error(message))), suite.result.state = "fail";
+				suite.result.errors ??= [];
+				suite.result.errors.push(processError(new Error(message)));
+				suite.result.state = "fail";
 			}
 			await rpc().snapshotSaved(result);
 		}
@@ -157,7 +178,8 @@ class VitestTestRunner {
 	}
 	async onBeforeRunTask(test) {
 		if (this.cancelRun) test.mode = "skip";
-		test.mode !== "run" && test.mode !== "queued" || (this.workerState.current = test);
+		if (test.mode !== "run" && test.mode !== "queued") return;
+		this.workerState.current = test;
 	}
 	async onBeforeRunSuite(suite) {
 		if (this.cancelRun) suite.mode = "skip";
@@ -166,7 +188,9 @@ class VitestTestRunner {
 		this.workerState.current = suite;
 	}
 	onBeforeTryTask(test) {
-		clearModuleMocks(this.config), this.snapshotClient.clearTest(test.file.filepath, test.id), setState({
+		clearModuleMocks(this.config);
+		this.snapshotClient.clearTest(test.file.filepath, test.id);
+		setState({
 			assertionCalls: 0,
 			isExpectingAssertions: false,
 			isExpectingAssertionsError: null,
@@ -186,12 +210,14 @@ class VitestTestRunner {
 		// create error during the test initialization so we have a nice stack trace
 		if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error("expected any number of assertion, but got none"));
 		let _expect;
-		return Object.defineProperty(context, "expect", { get() {
+		Object.defineProperty(context, "expect", { get() {
 			if (!_expect) _expect = createExpect(context.task);
 			return _expect;
-		} }), Object.defineProperty(context, "_local", { get() {
+		} });
+		Object.defineProperty(context, "_local", { get() {
 			return _expect != null;
-		} }), context;
+		} });
+		return context;
 	}
 	getImportDurations() {
 		const entries = [...this.workerState.moduleExecutionInfo?.entries() ?? []];

package/dist/chunks/{utils.CG9h5ccR.js → utils.DvEY5TfP.js}

@@ -8,12 +8,13 @@ function getWorkerState() {
 	return workerState;
 }
 function provideWorkerState(context, state) {
-	return Object.defineProperty(context, NAME_WORKER_STATE, {
+	Object.defineProperty(context, NAME_WORKER_STATE, {
 		value: state,
 		configurable: true,
 		writable: true,
 		enumerable: false
-	}), state;
+	});
+	return state;
 }
 function isChildProcess() {
 	return typeof process !== "undefined" && !!process.send;
@@ -26,7 +27,11 @@ function resetModules(modules, resetMocks = false) {
 		...!resetMocks ? [/^mock:/] : []
 	];
 	modules.idToModuleMap.forEach((node, path) => {
-		skipPaths.some((re) => re.test(path)) || (node.promise = void 0, node.exports = void 0, node.evaluated = false, node.importers.clear());
+		if (skipPaths.some((re) => re.test(path))) return;
+		node.promise = void 0;
+		node.exports = void 0;
+		node.evaluated = false;
+		node.importers.clear();
 	});
 }
 function waitNextTick() {
@@ -35,9 +40,13 @@ function waitNextTick() {
 }
 async function waitForImportsToResolve() {
 	await waitNextTick();
-	const state = getWorkerState(), promises = [], resolvingCount = state.resolvingModules.size;
+	const state = getWorkerState();
+	const promises = [];
+	const resolvingCount = state.resolvingModules.size;
 	for (const [_, mod] of state.evaluatedModules.idToModuleMap) if (mod.promise && !mod.evaluated) promises.push(mod.promise);
-	!promises.length && !resolvingCount || (await Promise.allSettled(promises), await waitForImportsToResolve());
+	if (!promises.length && !resolvingCount) return;
+	await Promise.allSettled(promises);
+	await waitForImportsToResolve();
 }
 
 export { getWorkerState as g, isChildProcess as i, provideWorkerState as p, resetModules as r, waitForImportsToResolve as w };