vitest 4.0.0-beta.4 → 4.0.0-beta.6

package/dist/chunks/resolver.Bx6lE0iq.js

@@ -0,0 +1,119 @@
+import fs from 'node:fs';
+
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/, _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/, _DRIVE_LETTER_RE = /^[A-Za-z]:$/, normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX), isPathAbsolute = isAbsolute(path), trailingSeparator = path[path.length - 1] === "/";
+	if (path = normalizeString(path, !isPathAbsolute), path.length === 0) return isPathAbsolute ? "/" : trailingSeparator ? "./" : ".";
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	return isUNCPath ? isPathAbsolute ? `//${path}` : `//./${path}` : isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+}, join = function(...segments) {
+	let path = "";
+	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);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) res = "", lastSegmentLength = 0;
+						else res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						lastSlash = index, dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "", lastSegmentLength = 0, lastSlash = index, dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) res += res.length > 0 ? "/.." : "..", lastSegmentLength = 2;
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index, dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+}, dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+
+const packageCache = /* @__PURE__ */ new Map();
+function findNearestPackageData(basedir) {
+	const originalBasedir = basedir;
+	while (basedir) {
+		var _tryStatSync;
+		const cached = getCachedData(packageCache, basedir, originalBasedir);
+		if (cached) return cached;
+		const pkgPath = join(basedir, "package.json");
+		if ((_tryStatSync = tryStatSync(pkgPath)) === null || _tryStatSync === void 0 ? void 0 : _tryStatSync.isFile()) {
+			const pkgData = JSON.parse(stripBomTag(fs.readFileSync(pkgPath, "utf8")));
+			if (packageCache) setCacheData(packageCache, pkgData, basedir, originalBasedir);
+			return pkgData;
+		}
+		const nextBasedir = dirname(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return {};
+}
+function stripBomTag(content) {
+	return content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+}
+function tryStatSync(file) {
+	try {
+		// The "throwIfNoEntry" is a performance optimization for cases where the file does not exist
+		return fs.statSync(file, { throwIfNoEntry: false });
+	} catch {}
+}
+function getCachedData(cache, basedir, originalBasedir) {
+	const pkgData = cache.get(getFnpdCacheKey(basedir));
+	if (pkgData) return traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+		cache.set(getFnpdCacheKey(dir), pkgData);
+	}), pkgData;
+}
+function setCacheData(cache, data, basedir, originalBasedir) {
+	cache.set(getFnpdCacheKey(basedir), data), traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+		cache.set(getFnpdCacheKey(dir), data);
+	});
+}
+function getFnpdCacheKey(basedir) {
+	return `fnpd_${basedir}`;
+}
+/**
+* Traverse between `longerDir` (inclusive) and `shorterDir` (exclusive) and call `cb` for each dir.
+* @param longerDir Longer dir path, e.g. `/User/foo/bar/baz`
+* @param shorterDir Shorter dir path, e.g. `/User/foo`
+*/
+function traverseBetweenDirs(longerDir, shorterDir, cb) {
+	while (longerDir !== shorterDir) cb(longerDir), longerDir = dirname(longerDir);
+}
+
+export { findNearestPackageData as f };

package/dist/chunks/{rpc.jnQO9F8a.js → rpc.RpPylpp0.js}

@@ -1,29 +1,18 @@
 import { getSafeTimers } from '@vitest/utils';
 import { c as createBirpc } from './index.Bgo3tNWt.js';
-import { g as getWorkerState } from './utils.XdZDrNZV.js';
+import { g as getWorkerState } from './utils.C7__0Iv5.js';
 
 const { get } = Reflect;
 function withSafeTimers(fn) {
-	const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
-	const currentSetTimeout = globalThis.setTimeout;
-	const currentClearTimeout = globalThis.clearTimeout;
-	const currentSetImmediate = globalThis.setImmediate;
-	const currentClearImmediate = globalThis.clearImmediate;
-	const currentNextTick = globalThis.process?.nextTick;
+	const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers(), currentSetTimeout = globalThis.setTimeout, currentClearTimeout = globalThis.clearTimeout, currentSetImmediate = globalThis.setImmediate, currentClearImmediate = globalThis.clearImmediate, currentNextTick = globalThis.process?.nextTick;
 	try {
-		globalThis.setTimeout = setTimeout;
-		globalThis.clearTimeout = clearTimeout;
-		if (setImmediate) globalThis.setImmediate = setImmediate;
+		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;
 	} finally {
-		globalThis.setTimeout = currentSetTimeout;
-		globalThis.clearTimeout = currentClearTimeout;
-		globalThis.setImmediate = currentSetImmediate;
-		globalThis.clearImmediate = currentClearImmediate;
-		if (globalThis.process && nextTick) nextTick(() => {
+		if (globalThis.setTimeout = currentSetTimeout, globalThis.clearTimeout = currentClearTimeout, globalThis.setImmediate = currentSetImmediate, globalThis.clearImmediate = currentClearImmediate, globalThis.process && nextTick) nextTick(() => {
 			globalThis.process.nextTick = currentNextTick;
 		});
 	}
@@ -38,8 +27,7 @@ function createRuntimeRpc(options) {
 	let setCancel = (_reason) => {};
 	const onCancel = new Promise((resolve) => {
 		setCancel = resolve;
-	});
-	const rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
+	}), rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
 		eventNames: [
 			"onUserConsoleLog",
 			"onCollected",
@@ -57,8 +45,7 @@ function createSafeRpc(rpc) {
 	return new Proxy(rpc, { get(target, p, handler) {
 		// keep $rejectPendingCalls as sync function
 		if (p === "$rejectPendingCalls") return rpc.$rejectPendingCalls;
-		const sendCall = get(target, p, handler);
-		const safeSendCall = (...args) => withSafeTimers(async () => {
+		const sendCall = get(target, p, handler), safeSendCall = (...args) => withSafeTimers(async () => {
 			const result = sendCall(...args);
 			promises.add(result);
 			try {
@@ -67,8 +54,7 @@ function createSafeRpc(rpc) {
 				promises.delete(result);
 			}
 		});
-		safeSendCall.asEvent = sendCall.asEvent;
-		return safeSendCall;
+		return safeSendCall.asEvent = sendCall.asEvent, safeSendCall;
 	} });
 }
 function rpc() {

package/dist/chunks/runBaseTests.D6sfuWBM.js

@@ -0,0 +1,99 @@
+import { performance } from 'node:perf_hooks';
+import { startTests, collectTests } from '@vitest/runner';
+import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.CsFXYRkW.js';
+import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.hLGRxhC8.js';
+import { a as globalExpect, v as vi } from './vi.BfdOiD4j.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 { V as VitestIndex } from './index.AR8aAkCC.js';
+import { g as getWorkerState, r as resetModules } from './utils.C7__0Iv5.js';
+import 'chai';
+import 'node:path';
+import '../path.js';
+import 'node:url';
+import './rpc.RpPylpp0.js';
+import './index.Bgo3tNWt.js';
+import './coverage.D_JHT54q.js';
+import '@vitest/snapshot';
+import '@vitest/expect';
+import '@vitest/runner/utils';
+import './_commonjsHelpers.BFTU3MAI.js';
+import '@vitest/utils/error';
+import '@vitest/spy';
+import '@vitest/utils/source-map';
+import './date.-jtEtIeV.js';
+import './benchmark.UW6Ezvxy.js';
+import 'expect-type';
+import 'vite/module-runner';
+
+// 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: VitestIndex,
+		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.B0quX7yH.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;
+}
+
+export { run };

package/dist/chunks/{setup-common.Ebx5x0eP.js → setup-common.hLGRxhC8.js}

@@ -1,54 +1,42 @@
-import { r as resolveCoverageProviderModule } from './coverage.DVF1vEu8.js';
+import { r as resolveCoverageProviderModule } from './coverage.D_JHT54q.js';
 import { addSerializer } from '@vitest/snapshot';
 import { setSafeTimers } from '@vitest/utils';
+import { g as getWorkerState } from './utils.C7__0Iv5.js';
 
 async function startCoverageInsideWorker(options, loader, runtimeOptions) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
-	if (coverageModule) return coverageModule.startCoverage?.(runtimeOptions);
-	return null;
+	return coverageModule ? coverageModule.startCoverage?.(runtimeOptions) : null;
 }
 async function takeCoverageInsideWorker(options, loader) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
-	if (coverageModule) return coverageModule.takeCoverage?.({ moduleExecutionInfo: loader.moduleExecutionInfo });
-	return null;
+	return coverageModule ? coverageModule.takeCoverage?.({ moduleExecutionInfo: loader.moduleExecutionInfo }) : null;
 }
 async function stopCoverageInsideWorker(options, loader, runtimeOptions) {
 	const coverageModule = await resolveCoverageProviderModule(options, loader);
-	if (coverageModule) return coverageModule.stopCoverage?.(runtimeOptions);
-	return null;
+	return coverageModule ? coverageModule.stopCoverage?.(runtimeOptions) : null;
 }
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
-	setupDefines(config.defines);
-	setupEnv(config.env);
-	if (globalSetup) return;
-	globalSetup = true;
-	setSafeTimers();
-	if (config.globals) (await import('./globals.Dgo-vS5G.js')).registerApiGlobally();
+	if (setupDefines(config.defines), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.lgsmH00r.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
 	for (const key in defines) globalThis[key] = defines[key];
 }
 function setupEnv(env) {
-	if (typeof process === "undefined") return;
-	// same boolean-to-string assignment as VitestPlugin.configResolved
-	const { PROD, DEV,...restEnvs } = env;
-	process.env.PROD = PROD ? "1" : "";
-	process.env.DEV = DEV ? "1" : "";
-	for (const key in restEnvs) process.env[key] = env[key];
-}
-async function loadDiffConfig(config, executor) {
+	const state = getWorkerState(), { PROD, DEV,...restEnvs } = env;
+	for (const key in state.metaEnv.PROD = PROD, state.metaEnv.DEV = DEV, restEnvs) state.metaEnv[key] = env[key];
+}
+async function loadDiffConfig(config, moduleRunner) {
 	if (typeof config.diff === "object") return config.diff;
 	if (typeof config.diff !== "string") return;
-	const diffModule = await executor.executeId(config.diff);
+	const diffModule = await moduleRunner.import(config.diff);
 	if (diffModule && typeof diffModule.default === "object" && diffModule.default != null) return diffModule.default;
-	else throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
+	throw new Error(`invalid diff config file ${config.diff}. Must have a default export with config object`);
 }
-async function loadSnapshotSerializers(config, executor) {
-	const files = config.snapshotSerializers;
-	const snapshotSerializers = await Promise.all(files.map(async (file) => {
-		const mo = await executor.executeId(file);
+async function loadSnapshotSerializers(config, moduleRunner) {
+	const files = config.snapshotSerializers, 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.`);