vitest 3.2.4 → 4.0.0-beta.10

package/LICENSE.md

@@ -3,7 +3,7 @@ Vitest is released under the MIT license:
 
 MIT License
 
-Copyright (c) 2021-Present Vitest Team
+Copyright (c) 2021-Present VoidZero Inc. and Vitest contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -329,7 +329,7 @@ Repository: lukeed/kleur
 ## local-pkg
 License: MIT
 By: Anthony Fu
-Repository: git+https://github.com/antfu/local-pkg.git
+Repository: git+https://github.com/antfu-collective/local-pkg.git
 
 > MIT License
 >

package/dist/browser.d.ts

@@ -1,34 +1,31 @@
-import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.d.D2ROskhv.js';
-import { R as RuntimeCoverageModuleLoader } from './chunks/coverage.d.S9RMNXIe.js';
+import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.d.B_LthbQq.js';
+import { R as RuntimeCoverageModuleLoader } from './chunks/coverage.d.BZtK59WP.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
-import { VitestExecutor } from './execute.js';
+import { V as VitestModuleRunner } from './chunks/moduleRunner.d.D9nBoC4p.js';
 export { collectTests, processError, startTests } from '@vitest/runner';
-import * as spy from '@vitest/spy';
-export { spy as SpyModule };
-export { LoupeOptions, ParsedStack, StringifyOptions, format, getSafeTimers, inspect, stringify } from '@vitest/utils';
+import * as _vitest_spy from '@vitest/spy';
+export { _vitest_spy as SpyModule };
+export { LoupeOptions, ParsedStack, StringifyOptions, format, getSafeTimers, getType, inspect, stringify } from '@vitest/utils';
 export { TraceMap, originalPositionFor } from '@vitest/utils/source-map';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
-import '@vitest/snapshot/environment';
-import 'vite-node/client';
-import 'vite-node';
-import './chunks/worker.d.1GmBbd7G.js';
-import './chunks/environment.d.cL3nLXbE.js';
-import 'vitest/optional-types.js';
 import 'node:vm';
+import 'vite/module-runner';
+import './chunks/worker.d.BDsXGkwh.js';
+import './chunks/environment.d.BsToaxti.js';
 import '@vitest/mocker';
 import './chunks/mocker.d.BE_2ls6u.js';
 
 declare function startCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader, runtimeOptions: {
-	isolate: boolean
+	isolate: boolean;
 }): Promise<unknown>;
 declare function takeCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader): Promise<unknown>;
 declare function stopCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader, runtimeOptions: {
-	isolate: boolean
+	isolate: boolean;
 }): Promise<unknown>;
 
 declare function setupCommonEnv(config: SerializedConfig): Promise<void>;
-declare function loadDiffConfig(config: SerializedConfig, executor: VitestExecutor): Promise<SerializedDiffOptions | undefined>;
-declare function loadSnapshotSerializers(config: SerializedConfig, executor: VitestExecutor): Promise<void>;
+declare function loadDiffConfig(config: SerializedConfig, moduleRunner: VitestModuleRunner): Promise<SerializedDiffOptions | undefined>;
+declare function loadSnapshotSerializers(config: SerializedConfig, moduleRunner: VitestModuleRunner): Promise<void>;
 
 export { loadDiffConfig, loadSnapshotSerializers, setupCommonEnv, startCoverageInsideWorker, stopCoverageInsideWorker, takeCoverageInsideWorker };

package/dist/browser.js

@@ -1,8 +1,9 @@
-export { l as loadDiffConfig, b as loadSnapshotSerializers, c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/setup-common.Dd054P77.js';
+export { l as loadDiffConfig, b as loadSnapshotSerializers, c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/setup-common.uiMcU3cv.js';
 export { collectTests, processError, startTests } from '@vitest/runner';
-import * as spy from '@vitest/spy';
-export { spy as SpyModule };
-export { format, getSafeTimers, inspect, stringify } from '@vitest/utils';
+import * as spyModule from '@vitest/spy';
+export { spyModule as SpyModule };
+export { format, getSafeTimers, getType, inspect, stringify } from '@vitest/utils';
 export { TraceMap, originalPositionFor } from '@vitest/utils/source-map';
-import './chunks/coverage.DVF1vEu8.js';
+import './chunks/coverage.D_JHT54q.js';
 import '@vitest/snapshot';
+import './chunks/utils.D2R2NiOH.js';

package/dist/chunks/base.Cjha6usc.js

@@ -0,0 +1,129 @@
+import { runInThisContext } from 'node:vm';
+import * as spyModule from '@vitest/spy';
+import { EvaluatedModules } from 'vite/module-runner';
+import { s as startVitestModuleRunner, c as createNodeImportMeta } from './startModuleRunner.p67gbNo9.js';
+import { performance } from 'node:perf_hooks';
+import { startTests, collectTests } from '@vitest/runner';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './resolveSnapshotEnvironment.Bkht6Yor.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.uiMcU3cv.js';
+import { g as globalExpect, v as vi } from './vi.ZPgvtBao.js';
+import { c as closeInspector } from './inspector.CvQD-Nie.js';
+import { createRequire } from 'node:module';
+import timers from 'node:timers';
+import timersPromises from 'node:timers/promises';
+import util from 'node:util';
+import { KNOWN_ASSET_TYPES, getSafeTimers } from '@vitest/utils';
+import { i as index } from './index.CMfqw92x.js';
+import { g as getWorkerState, r as resetModules, p as provideWorkerState } from './utils.D2R2NiOH.js';
+
+// this should only be used in Node
+let globalSetup = false;
+async function setupGlobalEnv(config, { environment }, moduleRunner) {
+	await setupCommonEnv(config), Object.defineProperty(globalThis, "__vitest_index__", {
+		value: index,
+		enumerable: false
+	});
+	const state = getWorkerState();
+	if (!state.config.snapshotOptions.snapshotEnvironment) state.config.snapshotOptions.snapshotEnvironment = await resolveSnapshotEnvironment(config, moduleRunner);
+	if (globalSetup) return;
+	globalSetup = true;
+	const viteEnvironment = environment.viteEnvironment || environment.name;
+	if (viteEnvironment === "client") {
+		const _require = createRequire(import.meta.url);
+		_require.extensions[".css"] = resolveCss, _require.extensions[".scss"] = resolveCss, _require.extensions[".sass"] = resolveCss, _require.extensions[".less"] = resolveCss, KNOWN_ASSET_TYPES.forEach((type) => {
+			_require.extensions[`.${type}`] = resolveAsset;
+		}), process.env.SSR = "";
+	} else process.env.SSR = "1";
+	if (globalThis.__vitest_required__ = {
+		util,
+		timers,
+		timersPromises
+	}, !config.disableConsoleIntercept) await setupConsoleLogSpy();
+}
+function resolveCss(mod) {
+	mod.exports = "";
+}
+function resolveAsset(mod, url) {
+	mod.exports = url;
+}
+async function setupConsoleLogSpy() {
+	const { createCustomConsole } = await import('./console.7h5kHUIf.js');
+	globalThis.console = createCustomConsole();
+}
+async function withEnv({ environment }, options, fn) {
+	globalThis.__vitest_environment__ = environment.name, globalExpect.setState({ environment: environment.name });
+	const env = await environment.setup(globalThis, options);
+	try {
+		await fn();
+	} finally {
+		// Run possible setTimeouts, e.g. the onces used by ConsoleLogSpy
+		const { setTimeout } = getSafeTimers();
+		await new Promise((resolve) => setTimeout(resolve)), await env.teardown(globalThis);
+	}
+}
+
+// browser shouldn't call this!
+async function run(method, files, config, environment, moduleRunner) {
+	const workerState = getWorkerState(), isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true), isIsolatedForks = config.pool === "forks" && (config.poolOptions?.forks?.isolate ?? true), isolate = isIsolatedThreads || isIsolatedForks;
+	if (await setupGlobalEnv(config, environment, moduleRunner), await startCoverageInsideWorker(config.coverage, moduleRunner, { isolate }), config.chaiConfig) setupChaiConfig(config.chaiConfig);
+	const runner = await resolveTestRunner(config, moduleRunner);
+	workerState.onCancel.then((reason) => {
+		closeInspector(config), runner.cancel?.(reason);
+	}), workerState.durations.prepare = performance.now() - workerState.durations.prepare, workerState.durations.environment = performance.now(), await withEnv(environment, environment.options || config.environmentOptions || {}, async () => {
+		workerState.durations.environment = performance.now() - workerState.durations.environment;
+		for (const file of files) {
+			if (isolate) moduleRunner.mocker.reset(), resetModules(workerState.evaluatedModules, true);
+			if (workerState.filepath = file.filepath, method === "run") await startTests([file], runner);
+			else await collectTests([file], runner);
+			// mocks should not affect different files
+			vi.resetConfig(), vi.restoreAllMocks();
+		}
+		await stopCoverageInsideWorker(config.coverage, moduleRunner, { isolate });
+	}), workerState.environmentTeardownRun = true;
+}
+
+let _moduleRunner;
+const evaluatedModules = new EvaluatedModules(), moduleExecutionInfo = /* @__PURE__ */ new Map();
+function startModuleRunner(options) {
+	return _moduleRunner || (_moduleRunner = startVitestModuleRunner(options), _moduleRunner);
+}
+async function runBaseTests(method, state) {
+	const { ctx } = state;
+	if (state.evaluatedModules = evaluatedModules, state.moduleExecutionInfo = moduleExecutionInfo, provideWorkerState(globalThis, state), ctx.invalidates) ctx.invalidates.forEach((filepath) => {
+		const modules = state.evaluatedModules.fileToModulesMap.get(filepath) || [];
+		modules.forEach((module) => {
+			state.evaluatedModules.invalidateModule(module);
+		});
+		// evaluatedModules.delete(fsPath)
+		// evaluatedModules.delete(`mock:${fsPath}`)
+	});
+	ctx.files.forEach((i) => {
+		const filepath = typeof i === "string" ? i : i.filepath, modules = state.evaluatedModules.fileToModulesMap.get(filepath) || [];
+		modules.forEach((module) => {
+			state.evaluatedModules.invalidateModule(module);
+		});
+	});
+	const executor = startModuleRunner({
+		state,
+		evaluatedModules: state.evaluatedModules,
+		spyModule,
+		createImportMeta: createNodeImportMeta
+	}), fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
+		filepath: f,
+		testLocations: void 0
+	} : f);
+	if (ctx.config.serializedDefines) try {
+		runInThisContext(`(() =>{\n${ctx.config.serializedDefines}})()`, {
+			lineOffset: 1,
+			filename: "virtual:load-defines.js"
+		});
+	} catch (error) {
+		throw new Error(`Failed to load custom "defines": ${error.message}`);
+	}
+	await run(method, fileSpecs, ctx.config, {
+		environment: state.environment,
+		options: ctx.environment.options
+	}, executor);
+}
+
+export { runBaseTests as r };

package/dist/chunks/{benchmark.CYdenmiT.js → benchmark.CJUa-Hsa.js}

@@ -1,10 +1,9 @@
 import { getCurrentSuite } from '@vitest/runner';
 import { createChainable } from '@vitest/runner/utils';
 import { noop } from '@vitest/utils';
-import { g as getWorkerState } from './utils.XdZDrNZV.js';
+import { g as getWorkerState } from './utils.D2R2NiOH.js';
 
-const benchFns = /* @__PURE__ */ new WeakMap();
-const benchOptsMap = /* @__PURE__ */ new WeakMap();
+const benchFns = /* @__PURE__ */ new WeakMap(), benchOptsMap = /* @__PURE__ */ new WeakMap();
 function getBenchOptions(key) {
 	return benchOptsMap.get(key);
 }
@@ -17,8 +16,9 @@ const bench = createBenchmark(function(name, fn = noop, options = {}) {
 		...this,
 		meta: { benchmark: true }
 	});
-	benchFns.set(task, fn);
-	benchOptsMap.set(task, options);
+	// vitest runner sets mode to `todo` if handler is not passed down
+	// but we store handler separetly
+	if (benchFns.set(task, fn), benchOptsMap.set(task, options), !this.todo && task.mode === "todo") task.mode = "run";
 });
 function createBenchmark(fn) {
 	const benchmark = createChainable([
@@ -26,9 +26,7 @@ function createBenchmark(fn) {
 		"only",
 		"todo"
 	], fn);
-	benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
-	benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
-	return benchmark;
+	return benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark, benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip, benchmark;
 }
 function formatName(name) {
 	return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);

package/dist/chunks/{benchmark.d.BwvBVTda.d.ts → benchmark.d.DAaHLpsq.d.ts}

@@ -4,8 +4,8 @@ import { TaskResult, Bench, Options } from 'tinybench';
 
 interface Benchmark extends Test {
 	meta: {
-		benchmark: true
-		result?: TaskResult
+		benchmark: true;
+		result?: TaskResult;
 	};
 }
 interface BenchmarkResult extends TaskResult {
@@ -17,8 +17,8 @@ interface BenchmarkResult extends TaskResult {
 type BenchFunction = (this: Bench) => Promise<void> | void;
 type ChainableBenchmarkAPI = ChainableFunction<"skip" | "only" | "todo", (name: string | Function, fn?: BenchFunction, options?: Options) => void>;
 type BenchmarkAPI = ChainableBenchmarkAPI & {
-	skipIf: (condition: any) => ChainableBenchmarkAPI
-	runIf: (condition: any) => ChainableBenchmarkAPI
+	skipIf: (condition: any) => ChainableBenchmarkAPI;
+	runIf: (condition: any) => ChainableBenchmarkAPI;
 };
 
 export type { BenchmarkResult as B, BenchFunction as a, Benchmark as b, BenchmarkAPI as c };

package/dist/chunks/browser.d.yFAklsD1.d.ts

@@ -0,0 +1,18 @@
+import { T as TestExecutionMethod } from './worker.d.BDsXGkwh.js';
+
+type SerializedTestSpecification = [project: {
+	name: string | undefined;
+	root: string;
+}, file: string, options: {
+	pool: string;
+	testLines?: number[] | undefined;
+}];
+
+interface BrowserTesterOptions {
+	method: TestExecutionMethod;
+	files: string[];
+	providedContext: string;
+	startTime: number;
+}
+
+export type { BrowserTesterOptions as B, SerializedTestSpecification as S };