vitest 4.0.6 → 4.0.8

package/dist/chunks/rpc.BUV7uWKJ.js

@@ -0,0 +1,76 @@
+import { getSafeTimers } from '@vitest/utils/timers';
+import { c as createBirpc } from './index.DAL392Ss.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.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;
+		return fn();
+	} 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);
+}
+const onCancelCallbacks = [];
+function onCancel(callback) {
+	onCancelCallbacks.push(callback);
+}
+function createRuntimeRpc(options) {
+	return createSafeRpc(createBirpc({ async onCancel(reason) {
+		await Promise.all(onCancelCallbacks.map((fn) => fn(reason)));
+	} }, {
+		eventNames: [
+			"onUserConsoleLog",
+			"onCollected",
+			"onCancel"
+		],
+		timeout: -1,
+		...options
+	}));
+}
+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 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, onCancel as o, rpc as r };

package/dist/chunks/{setup-common.DR1sucx6.js → setup-common.LGjNSzXp.js}

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