vitest 3.2.4 → 4.0.0-beta.10

package/dist/chunks/index.CwejwG0H.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.Dd054P77.js';
-import { distDir } from '../path.js';
-import { r as rpc } from './rpc.-pEldfrD.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.-pEldfrD.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;
-		globalThis.setImmediate = setImmediate;
-		globalThis.clearImmediate = clearImmediate;
-		if (globalThis.process) 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(() => {
-			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.9Ij9_de-.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.CwejwG0H.js';
-import { c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './setup-common.Dd054P77.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.CdQS2e2Q.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.-pEldfrD.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 };

package/dist/chunks/vite.d.CMLlLIFP.d.ts

@@ -1,25 +0,0 @@
-import { HookHandler } from 'vite';
-import { V as Vitest, T as TestProject, b as TestProjectConfiguration, I as InlineConfig } from './reporters.d.BFLkQcL6.js';
-
-interface VitestPluginContext {
-	vitest: Vitest;
-	project: TestProject;
-	injectTestProjects: (config: TestProjectConfiguration | TestProjectConfiguration[]) => Promise<TestProject[]>;
-}
-
-/* eslint-disable unused-imports/no-unused-vars */
-
-type VitestInlineConfig = InlineConfig;
-declare module "vite" {
-	interface UserConfig {
-		/**
-		* Options for Vitest
-		*/
-		test?: VitestInlineConfig;
-	}
-	interface Plugin<A = any> {
-		configureVitest?: HookHandler<(context: VitestPluginContext) => void>;
-	}
-}
-
-export type { VitestPluginContext as V };

package/dist/execute.d.ts

@@ -1,150 +0,0 @@
-import { ViteNodeRunnerOptions } from 'vite-node';
-import { ViteNodeRunner, ModuleExecutionInfo } from 'vite-node/client';
-import { R as RuntimeRPC, W as WorkerGlobalState } from './chunks/worker.d.1GmBbd7G.js';
-import vm from 'node:vm';
-import { MockedModule, MockedModuleType } from '@vitest/mocker';
-import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './chunks/mocker.d.BE_2ls6u.js';
-import '@vitest/runner';
-import './chunks/config.d.D2ROskhv.js';
-import '@vitest/pretty-format';
-import '@vitest/snapshot';
-import '@vitest/snapshot/environment';
-import '@vitest/utils/diff';
-import './chunks/environment.d.cL3nLXbE.js';
-import 'vitest/optional-types.js';
-
-declare class FileMap {
-	private fsCache;
-	private fsBufferCache;
-	readFileAsync(path: string): Promise<string>;
-	readFile(path: string): string;
-	readBuffer(path: string): Buffer;
-}
-
-// need to copy paste types for vm
-// because they require latest @types/node which we don't bundle
-interface ModuleEvaluateOptions {
-	timeout?: vm.RunningScriptOptions["timeout"] | undefined;
-	breakOnSigint?: vm.RunningScriptOptions["breakOnSigint"] | undefined;
-}
-type ModuleLinker = (specifier: string, referencingModule: VMModule, extra: {
-	assert: object
-}) => VMModule | Promise<VMModule>;
-type ModuleStatus = "unlinked" | "linking" | "linked" | "evaluating" | "evaluated" | "errored";
-declare class VMModule {
-	dependencySpecifiers: readonly string[];
-	error: any;
-	identifier: string;
-	context: vm.Context;
-	namespace: object;
-	status: ModuleStatus;
-	evaluate(options?: ModuleEvaluateOptions): Promise<void>;
-	link(linker: ModuleLinker): Promise<void>;
-}
-
-interface ExternalModulesExecutorOptions {
-	context: vm.Context;
-	fileMap: FileMap;
-	packageCache: Map<string, any>;
-	transform: RuntimeRPC["transform"];
-	interopDefault?: boolean;
-	viteClientModule: Record<string, unknown>;
-}
-// TODO: improve Node.js strict mode support in #2854
-declare class ExternalModulesExecutor {
-	#private;
-	private options;
-	private cjs;
-	private esm;
-	private vite;
-	private context;
-	private fs;
-	private resolvers;
-	constructor(options: ExternalModulesExecutorOptions);
-	import(identifier: string): Promise<object>;
-	require(identifier: string): any;
-	createRequire(identifier: string): NodeJS.Require;
-	// dynamic import can be used in both ESM and CJS, so we have it in the executor
-	importModuleDynamically: (specifier: string, referencer: VMModule) => Promise<VMModule>;
-	resolveModule: (specifier: string, referencer: string) => Promise<VMModule>;
-	resolve(specifier: string, parent: string): string;
-	private findNearestPackageData;
-	private getModuleInformation;
-	private createModule;
-	private get isNetworkSupported();
-}
-
-interface MockContext {
-	/**
-	* When mocking with a factory, this refers to the module that imported the mock.
-	*/
-	callstack: null | string[];
-}
-declare class VitestMocker {
-	executor: VitestExecutor;
-	static pendingIds: PendingSuiteMock[];
-	private spyModule?;
-	private primitives;
-	private filterPublicKeys;
-	private registries;
-	private mockContext;
-	constructor(executor: VitestExecutor);
-	private get root();
-	private get moduleCache();
-	private get moduleDirectories();
-	initializeSpyModule(): Promise<void>;
-	private getMockerRegistry;
-	reset(): void;
-	private deleteCachedItem;
-	private isModuleDirectory;
-	getSuiteFilepath(): string;
-	private createError;
-	private resolvePath;
-	resolveMocks(): Promise<void>;
-	private callFunctionMock;
-	// public method to avoid circular dependency
-	getMockContext(): MockContext;
-	// path used to store mocked dependencies
-	getMockPath(dep: string): string;
-	getDependencyMock(id: string): MockedModule | undefined;
-	normalizePath(path: string): string;
-	resolveMockPath(mockPath: string, external: string | null): string | null;
-	mockObject(object: Record<string | symbol, any>, mockExports?: Record<string | symbol, any>, behavior?: MockedModuleType): Record<string | symbol, any>;
-	unmockPath(path: string): void;
-	mockPath(originalId: string, path: string, external: string | null, mockType: MockedModuleType | undefined, factory: MockFactory | undefined): void;
-	importActual<T>(rawId: string, importer: string, callstack?: string[] | null): Promise<T>;
-	importMock(rawId: string, importee: string): Promise<any>;
-	requestWithMock(url: string, callstack: string[]): Promise<any>;
-	queueMock(id: string, importer: string, factoryOrOptions?: MockFactory | MockOptions): void;
-	queueUnmock(id: string, importer: string): void;
-}
-
-interface ExecuteOptions extends ViteNodeRunnerOptions {
-	moduleDirectories?: string[];
-	state: WorkerGlobalState;
-	context?: vm.Context;
-	externalModulesExecutor?: ExternalModulesExecutor;
-}
-declare class VitestExecutor extends ViteNodeRunner {
-	options: ExecuteOptions;
-	mocker: VitestMocker;
-	externalModules?: ExternalModulesExecutor;
-	private primitives;
-	constructor(options: ExecuteOptions);
-	protected getContextPrimitives(): {
-		Object: typeof Object
-		Reflect: typeof Reflect
-		Symbol: typeof Symbol
-	};
-	get state(): WorkerGlobalState;
-	get moduleExecutionInfo(): ModuleExecutionInfo | undefined;
-	shouldResolveId(id: string, _importee?: string | undefined): boolean;
-	originalResolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
-	resolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
-	protected runModule(context: Record<string, any>, transformed: string): Promise<void>;
-	importExternalModule(path: string): Promise<any>;
-	dependencyRequest(id: string, fsPath: string, callstack: string[]): Promise<any>;
-	prepareContext(context: Record<string, any>): Record<string, any>;
-}
-
-export { VitestExecutor };

package/dist/execute.js

@@ -1,13 +0,0 @@
-export { V as VitestExecutor } from './chunks/execute.B7h3T_Hc.js';
-import 'node:fs';
-import 'node:url';
-import 'node:vm';
-import '@vitest/utils/error';
-import 'pathe';
-import 'vite-node/client';
-import 'vite-node/utils';
-import './path.js';
-import 'node:path';
-import '@vitest/mocker';
-import 'node:module';
-import '@vitest/utils';