vitest 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/chunks/index.D-VkfKhf.js

@@ -1,105 +0,0 @@
-import * as chai from 'chai';
-import { resolve } from 'node:path';
-import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.D7ZqXFx-.js';
-import { distDir } from '../path.js';
-import { r as rpc } from './rpc.CsFtxqeq.js';
-import { g as getWorkerState } from './utils.XdZDrNZV.js';
-
-function setupChaiConfig(config) {
-	Object.assign(chai.config, config);
-}
-
-async function resolveSnapshotEnvironment(config, executor) {
-	if (!config.snapshotEnvironment) {
-		const { VitestNodeSnapshotEnvironment } = await import('./node.fjCdwEIl.js');
-		return new VitestNodeSnapshotEnvironment();
-	}
-	const mod = await executor.executeId(config.snapshotEnvironment);
-	if (typeof mod.default !== "object" || !mod.default) throw new Error("Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`");
-	return mod.default;
-}
-
-const runnersFile = resolve(distDir, "runners.js");
-async function getTestRunnerConstructor(config, executor) {
-	if (!config.runner) {
-		const { VitestTestRunner, NodeBenchmarkRunner } = await executor.executeFile(runnersFile);
-		return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
-	}
-	const mod = await executor.executeId(config.runner);
-	if (!mod.default && typeof mod.default !== "function") throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
-	return mod.default;
-}
-async function resolveTestRunner(config, executor) {
-	const TestRunner = await getTestRunnerConstructor(config, executor);
-	const testRunner = new TestRunner(config);
-	// inject private executor to every runner
-	Object.defineProperty(testRunner, "__vitest_executor", {
-		value: executor,
-		enumerable: false,
-		configurable: false
-	});
-	if (!testRunner.config) testRunner.config = config;
-	if (!testRunner.importFile) throw new Error("Runner must implement \"importFile\" method.");
-	const [diffOptions] = await Promise.all([loadDiffConfig(config, executor), loadSnapshotSerializers(config, executor)]);
-	testRunner.config.diffOptions = diffOptions;
-	// patch some methods, so custom runners don't need to call RPC
-	const originalOnTaskUpdate = testRunner.onTaskUpdate;
-	testRunner.onTaskUpdate = async (task, events) => {
-		const p = rpc().onTaskUpdate(task, events);
-		await originalOnTaskUpdate?.call(testRunner, task, events);
-		return p;
-	};
-	// patch some methods, so custom runners don't need to call RPC
-	const originalOnTestAnnotate = testRunner.onTestAnnotate;
-	testRunner.onTestAnnotate = async (test, annotation) => {
-		const p = rpc().onTaskAnnotate(test.id, annotation);
-		const overridenResult = await originalOnTestAnnotate?.call(testRunner, test, annotation);
-		const vitestResult = await p;
-		return overridenResult || vitestResult;
-	};
-	const originalOnCollectStart = testRunner.onCollectStart;
-	testRunner.onCollectStart = async (file) => {
-		await rpc().onQueued(file);
-		await originalOnCollectStart?.call(testRunner, file);
-	};
-	const originalOnCollected = testRunner.onCollected;
-	testRunner.onCollected = async (files) => {
-		const state = getWorkerState();
-		files.forEach((file) => {
-			file.prepareDuration = state.durations.prepare;
-			file.environmentLoad = state.durations.environment;
-			// should be collected only for a single test file in a batch
-			state.durations.prepare = 0;
-			state.durations.environment = 0;
-		});
-		rpc().onCollected(files);
-		await originalOnCollected?.call(testRunner, files);
-	};
-	const originalOnAfterRun = testRunner.onAfterRunFiles;
-	testRunner.onAfterRunFiles = async (files) => {
-		const state = getWorkerState();
-		const coverage = await takeCoverageInsideWorker(config.coverage, executor);
-		if (coverage) rpc().onAfterSuiteRun({
-			coverage,
-			testFiles: files.map((file) => file.name).sort(),
-			transformMode: state.environment.transformMode,
-			projectName: state.ctx.projectName
-		});
-		await originalOnAfterRun?.call(testRunner, files);
-	};
-	const originalOnAfterRunTask = testRunner.onAfterRunTask;
-	testRunner.onAfterRunTask = async (test) => {
-		if (config.bail && test.result?.state === "fail") {
-			const previousFailures = await rpc().getCountOfFailedTests();
-			const currentFailures = 1 + previousFailures;
-			if (currentFailures >= config.bail) {
-				rpc().onCancel("test-failure");
-				testRunner.cancel?.("test-failure");
-			}
-		}
-		await originalOnAfterRunTask?.call(testRunner, test);
-	};
-	return testRunner;
-}
-
-export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };

package/dist/chunks/rpc.CsFtxqeq.js

@@ -1,83 +0,0 @@
-import { getSafeTimers } from '@vitest/utils';
-import { c as createBirpc } from './index.B521nVV-.js';
-import { g as getWorkerState } from './utils.XdZDrNZV.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;
-	try {
-		globalThis.setTimeout = setTimeout;
-		globalThis.clearTimeout = clearTimeout;
-		if (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(() => {
-			globalThis.process.nextTick = currentNextTick;
-		});
-	}
-}
-const promises = /* @__PURE__ */ new Set();
-async function rpcDone() {
-	if (!promises.size) return;
-	const awaitable = Array.from(promises);
-	return Promise.all(awaitable);
-}
-function createRuntimeRpc(options) {
-	let setCancel = (_reason) => {};
-	const onCancel = new Promise((resolve) => {
-		setCancel = resolve;
-	});
-	const rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
-		eventNames: [
-			"onUserConsoleLog",
-			"onCollected",
-			"onCancel"
-		],
-		onTimeoutError(functionName, args) {
-			let message = `[vitest-worker]: Timeout calling "${functionName}"`;
-			if (functionName === "fetch" || functionName === "transform" || functionName === "resolveId") message += ` with "${JSON.stringify(args)}"`;
-			// JSON.stringify cannot serialize Error instances
-			if (functionName === "onUnhandledError") message += ` with "${args[0]?.message || args[0]}"`;
-			throw new Error(message);
-		},
-		...options
-	}));
-	return {
-		rpc,
-		onCancel
-	};
-}
-function createSafeRpc(rpc) {
-	return new Proxy(rpc, { get(target, p, handler) {
-		const sendCall = get(target, p, handler);
-		const safeSendCall = (...args) => withSafeTimers(async () => {
-			const result = sendCall(...args);
-			promises.add(result);
-			try {
-				return await result;
-			} finally {
-				promises.delete(result);
-			}
-		});
-		safeSendCall.asEvent = sendCall.asEvent;
-		return safeSendCall;
-	} });
-}
-function rpc() {
-	const { rpc } = getWorkerState();
-	return rpc;
-}
-
-export { rpcDone as a, createRuntimeRpc as c, rpc as r };

package/dist/chunks/runBaseTests.BC7ZIH5L.js

@@ -1,129 +0,0 @@
-import { performance } from 'node:perf_hooks';
-import { startTests, collectTests } from '@vitest/runner';
-import { a as resolveSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './index.D-VkfKhf.js';
-import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.D7ZqXFx-.js';
-import { a as globalExpect, v as vi } from './vi.bdSIJ99Y.js';
-import { c as closeInspector } from './inspector.C914Efll.js';
-import { createRequire } from 'node:module';
-import timers from 'node:timers';
-import timersPromises from 'node:timers/promises';
-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.BWf_gE5n.js';
-import { g as getWorkerState, r as resetModules } from './utils.XdZDrNZV.js';
-import 'chai';
-import 'node:path';
-import '../path.js';
-import 'node:url';
-import './rpc.CsFtxqeq.js';
-import './index.B521nVV-.js';
-import './coverage.DVF1vEu8.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.Bq6ZW5rf.js';
-import './benchmark.CYdenmiT.js';
-import 'expect-type';
-
-// this should only be used in Node
-let globalSetup = false;
-async function setupGlobalEnv(config, { environment }, executor) {
-	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, executor);
-	if (globalSetup) return;
-	globalSetup = true;
-	if (environment.transformMode === "web") {
-		const _require = createRequire(import.meta.url);
-		// always mock "required" `css` files, because we cannot process them
-		_require.extensions[".css"] = resolveCss;
-		_require.extensions[".scss"] = resolveCss;
-		_require.extensions[".sass"] = resolveCss;
-		_require.extensions[".less"] = resolveCss;
-		// since we are using Vite, we can assume how these will be resolved
-		KNOWN_ASSET_TYPES.forEach((type) => {
-			_require.extensions[`.${type}`] = resolveAsset;
-		});
-		process.env.SSR = "";
-	} else process.env.SSR = "1";
-	// @ts-expect-error not typed global for patched timers
-	globalThis.__vitest_required__ = {
-		util,
-		timers,
-		timersPromises
-	};
-	installSourcemapsSupport({ getSourceMap: (source) => state.moduleCache.getSourceMap(source) });
-	if (!config.disableConsoleIntercept) await setupConsoleLogSpy();
-}
-function resolveCss(mod) {
-	mod.exports = "";
-}
-function resolveAsset(mod, url) {
-	mod.exports = url;
-}
-async function setupConsoleLogSpy() {
-	const { createCustomConsole } = await import('./console.CtFJOzRO.js');
-	globalThis.console = createCustomConsole();
-}
-async function withEnv({ environment }, options, fn) {
-	// @ts-expect-error untyped global
-	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, executor) {
-	const workerState = getWorkerState();
-	const isIsolatedThreads = config.pool === "threads" && (config.poolOptions?.threads?.isolate ?? true);
-	const isIsolatedForks = config.pool === "forks" && (config.poolOptions?.forks?.isolate ?? true);
-	const isolate = isIsolatedThreads || isIsolatedForks;
-	await setupGlobalEnv(config, environment, executor);
-	await startCoverageInsideWorker(config.coverage, executor, { isolate });
-	if (config.chaiConfig) setupChaiConfig(config.chaiConfig);
-	const runner = await resolveTestRunner(config, executor);
-	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) {
-				executor.mocker.reset();
-				resetModules(workerState.moduleCache, true);
-			}
-			workerState.filepath = file.filepath;
-			if (method === "run") await startTests([file], runner);
-			else await collectTests([file], runner);
-			// reset after tests, because user might call `vi.setConfig` in setupFile
-			vi.resetConfig();
-			// mocks should not affect different files
-			vi.restoreAllMocks();
-		}
-		await stopCoverageInsideWorker(config.coverage, executor, { isolate });
-	});
-	workerState.environmentTeardownRun = true;
-}
-
-export { run };