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

package/dist/chunks/resolveSnapshotEnvironment.DQVamkje.js

@@ -0,0 +1,81 @@
+import { chai } from '@vitest/expect';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.NAWRuMRP.js';
+import { r as rpc } from './rpc.jKGRSXIH.js';
+import { g as getWorkerState } from './utils.DGKhod2J.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.KC5tH8hC.js';
+
+function setupChaiConfig(config) {
+	Object.assign(chai.config, config);
+}
+
+async function getTestRunnerConstructor(config, moduleRunner) {
+	if (!config.runner) return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
+	const mod = await moduleRunner.import(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, moduleRunner) {
+	const TestRunner = await getTestRunnerConstructor(config, moduleRunner), testRunner = new TestRunner(config);
+	if (Object.defineProperty(testRunner, "moduleRunner", {
+		value: moduleRunner,
+		enumerable: false,
+		configurable: false
+	}), !testRunner.config) testRunner.config = config;
+	if (!testRunner.importFile) throw new Error("Runner must implement \"importFile\" method.");
+	const [diffOptions] = await Promise.all([loadDiffConfig(config, moduleRunner), loadSnapshotSerializers(config, moduleRunner)]);
+	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);
+		return await originalOnTaskUpdate?.call(testRunner, task, events), 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), overriddenResult = await originalOnTestAnnotate?.call(testRunner, test, annotation), vitestResult = await p;
+		return overriddenResult || 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, 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(), coverage = await takeCoverageInsideWorker(config.coverage, moduleRunner);
+		if (coverage) rpc().onAfterSuiteRun({
+			coverage,
+			testFiles: files.map((file) => file.name).sort(),
+			environment: state.environment.viteEnvironment || state.environment.name,
+			projectName: state.ctx.projectName
+		});
+		await originalOnAfterRun?.call(testRunner, files);
+	};
+	const originalOnAfterRunTask = testRunner.onAfterRunTask;
+	return testRunner.onAfterRunTask = async (test) => {
+		if (config.bail && test.result?.state === "fail") {
+			const previousFailures = await rpc().getCountOfFailedTests(), currentFailures = 1 + previousFailures;
+			if (currentFailures >= config.bail) rpc().onCancel("test-failure"), testRunner.cancel?.("test-failure");
+		}
+		await originalOnAfterRunTask?.call(testRunner, test);
+	}, testRunner;
+}
+
+async function resolveSnapshotEnvironment(config, executor) {
+	if (!config.snapshotEnvironment) {
+		const { VitestNodeSnapshotEnvironment } = await import('./node.BsdMi6DV.js');
+		return new VitestNodeSnapshotEnvironment();
+	}
+	const mod = await executor.import(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;
+}
+
+export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };

package/dist/chunks/rpc.jKGRSXIH.js

@@ -0,0 +1,65 @@
+import { getSafeTimers } from '@vitest/utils/timers';
+import { c as createBirpc } from './index.Bgo3tNWt.js';
+import { g as getWorkerState } from './utils.DGKhod2J.js';
+
+const { get } = Reflect;
+function withSafeTimers(fn) {
+	const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers(), currentSetTimeout = globalThis.setTimeout, currentClearTimeout = globalThis.clearTimeout, currentSetImmediate = globalThis.setImmediate, currentClearImmediate = globalThis.clearImmediate, currentNextTick = globalThis.process?.nextTick;
+	try {
+		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 {
+		if (globalThis.setTimeout = currentSetTimeout, globalThis.clearTimeout = currentClearTimeout, globalThis.setImmediate = currentSetImmediate, globalThis.clearImmediate = currentClearImmediate, 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;
+	}), rpc = createSafeRpc(createBirpc({ onCancel: setCancel }, {
+		eventNames: [
+			"onUserConsoleLog",
+			"onCollected",
+			"onCancel"
+		],
+		timeout: -1,
+		...options
+	}));
+	return {
+		rpc,
+		onCancel
+	};
+}
+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), safeSendCall = (...args) => withSafeTimers(async () => {
+			const result = sendCall(...args);
+			promises.add(result);
+			try {
+				return await result;
+			} finally {
+				promises.delete(result);
+			}
+		});
+		return safeSendCall.asEvent = sendCall.asEvent, safeSendCall;
+	} });
+}
+function rpc() {
+	const { rpc } = getWorkerState();
+	return rpc;
+}
+
+export { rpcDone as a, createRuntimeRpc as c, rpc as r };

package/dist/chunks/{setup-common.D7ZqXFx-.js → setup-common.NAWRuMRP.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 { setSafeTimers } from '@vitest/utils/timers';
+import { g as getWorkerState } from './utils.DGKhod2J.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.Cxal6MLI.js')).registerApiGlobally();
+	if (setupDefines(config), setupEnv(config.env), !globalSetup && (globalSetup = true, setSafeTimers(), config.globals)) (await import('./globals.BjvYA-AD.js')).registerApiGlobally();
 }
-function setupDefines(defines) {
-	for (const key in defines) globalThis[key] = defines[key];
+function setupDefines(config) {
+	for (const key in config.defines) globalThis[key] = config.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.`);