vitest 4.0.0-beta.18 → 4.0.0-beta.19

package/dist/chunks/{index.Bcjk8TKX.js → index.RwjEGCQ0.js}

@@ -1,15 +1,15 @@
 import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.BZvkKVkM.js';
 import { b as bench } from './benchmark.DHKMYAts.js';
+import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 import { expectTypeOf } from 'expect-type';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
-import { EvaluatedModules } from 'vite/module-runner';
 import { chai } from '@vitest/expect';
 
 const assertType = function assertType() {};
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  EvaluatedModules: EvaluatedModules,
+  EvaluatedModules: VitestEvaluatedModules,
   afterAll: afterAll,
   afterEach: afterEach,
   assert: assert,

package/dist/chunks/init-forks.DSafeltJ.js

@@ -0,0 +1,54 @@
+import v8 from 'node:v8';
+import { i as init } from './init.B2EESLQM.js';
+
+if (!process.send) throw new Error("Expected worker to be run in node:child_process");
+// Store globals in case tests overwrite them
+const processExit = process.exit.bind(process), processSend = process.send.bind(process), processOn = process.on.bind(process), processOff = process.off.bind(process), processRemoveAllListeners = process.removeAllListeners.bind(process);
+// Work-around for nodejs/node#55094
+if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"))) processOn("SIGTERM", () => processExit());
+function workerInit(options) {
+	const { runTests } = options;
+	init({
+		post: (v) => processSend(v),
+		on: (cb) => processOn("message", cb),
+		off: (cb) => processOff("message", cb),
+		teardown: () => processRemoveAllListeners("message"),
+		serialize: v8.serialize,
+		deserialize: (v) => v8.deserialize(Buffer.from(v)),
+		runTests: (state) => executeTests("run", state),
+		collectTests: (state) => executeTests("collect", state)
+	});
+	async function executeTests(method, state) {
+		state.ctx.config = unwrapSerializableConfig(state.ctx.config);
+		try {
+			await runTests(method, state);
+		} finally {
+			process.exit = processExit;
+		}
+	}
+}
+/**
+* Reverts the wrapping done by `wrapSerializableConfig` in {@link file://./../../node/pool/runtimes/forks.ts}
+*/
+function unwrapSerializableConfig(config) {
+	if (config.testNamePattern && typeof config.testNamePattern === "string") {
+		const testNamePattern = config.testNamePattern;
+		if (testNamePattern.startsWith("$$vitest:")) config.testNamePattern = parseRegexp(testNamePattern.slice(9));
+	}
+	if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
+		const { keys, original } = config.defines, defines = {};
+		// Apply all keys from the original. Entries which had undefined value are missing from original now
+		for (const key of keys) defines[key] = original[key];
+		config.defines = defines;
+	}
+	return config;
+}
+function parseRegexp(input) {
+	// Parse input
+	// eslint-disable-next-line regexp/no-misleading-capturing-group
+	const m = input.match(/(\/?)(.+)\1([a-z]*)/i);
+	// Create the regular expression
+	return m ? m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3]) ? new RegExp(input) : new RegExp(m[2], m[3]) : /$^/;
+}
+
+export { workerInit as w };

package/dist/chunks/init-threads.SUtZ-067.js

@@ -0,0 +1,17 @@
+import { isMainThread, parentPort } from 'node:worker_threads';
+import { i as init } from './init.B2EESLQM.js';
+
+if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
+function workerInit(options) {
+	const { runTests } = options;
+	init({
+		post: (response) => parentPort.postMessage(response),
+		on: (callback) => parentPort.on("message", callback),
+		off: (callback) => parentPort.off("message", callback),
+		teardown: () => parentPort.removeAllListeners("message"),
+		runTests: async (state) => runTests("run", state),
+		collectTests: async (state) => runTests("collect", state)
+	});
+}
+
+export { workerInit as w };

package/dist/chunks/{worker.CdzokOSx.js → init.B2EESLQM.js}

@@ -1,14 +1,15 @@
+import { serializeError } from '@vitest/utils/error';
 import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
-import { ModuleRunner, EvaluatedModules } from 'vite/module-runner';
 import { readFileSync } from 'node:fs';
 import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
-import { b as VitestTransport } from './startModuleRunner.DPBo3mme.js';
+import { ModuleRunner } from 'vite/module-runner';
+import { b as VitestTransport } from './startModuleRunner.C2tTvmF9.js';
 import { e as environments } from './index.CbWINfS7.js';
-import { s as setupInspect } from './inspector.Br76Q2Mb.js';
+import { s as setupInspect } from './inspector.DLZxSeU3.js';
+import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 import { c as createRuntimeRpc, a as rpcDone } from './rpc.cD77ENhU.js';
-import { i as isChildProcess } from './utils.CG9h5ccR.js';
 
 function isBuiltinEnvironment(env) {
 	return env in environments;
@@ -59,82 +60,13 @@ async function loadEnvironment(ctx, rpc) {
 	};
 }
 
-const REGEXP_WRAP_PREFIX = "$$vitest:", processSend = process.send?.bind(process), processOn = process.on?.bind(process), processOff = process.off?.bind(process), dispose = [];
-function createThreadsRpcOptions({ port }) {
-	return {
-		post: (v) => {
-			port.postMessage(v);
-		},
-		on: (fn) => {
-			port.addListener("message", fn);
-		}
-	};
-}
-function disposeInternalListeners() {
-	for (const fn of dispose) try {
-		fn();
-	} catch {}
-	dispose.length = 0;
-}
-function createForksRpcOptions(nodeV8) {
-	return {
-		serialize: nodeV8.serialize,
-		deserialize: (v) => nodeV8.deserialize(Buffer.from(v)),
-		post(v) {
-			processSend(v);
-		},
-		on(fn) {
-			const handler = (message, ...extras) => {
-				if (!message?.__tinypool_worker_message__) return fn(message, ...extras);
-			};
-			processOn("message", handler), dispose.push(() => processOff("message", handler));
-		}
-	};
-}
-/**
-* Reverts the wrapping done by `utils/config-helpers.ts`'s `wrapSerializableConfig`
-*/
-function unwrapSerializableConfig(config) {
-	if (config.testNamePattern && typeof config.testNamePattern === "string") {
-		const testNamePattern = config.testNamePattern;
-		if (testNamePattern.startsWith(REGEXP_WRAP_PREFIX)) config.testNamePattern = parseRegexp(testNamePattern.slice(9));
-	}
-	if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
-		const { keys, original } = config.defines, defines = {};
-		// Apply all keys from the original. Entries which had undefined value are missing from original now
-		for (const key of keys) defines[key] = original[key];
-		config.defines = defines;
-	}
-	return config;
-}
-function parseRegexp(input) {
-	// Parse input
-	// eslint-disable-next-line regexp/no-misleading-capturing-group
-	const m = input.match(/(\/?)(.+)\1([a-z]*)/i);
-	// Create the regular expression
-	return m ? m[3] && !/^(?!.*?(.).*?\1)[gmixXsuUAJ]+$/.test(m[3]) ? new RegExp(input) : new RegExp(m[2], m[3]) : /$^/;
-}
-
-if (isChildProcess()) {
-	if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir")))
- // Work-around for nodejs/node#55094
-	process.on("SIGTERM", () => {
-		process.exit();
-	});
-}
 const resolvingModules = /* @__PURE__ */ new Set(), globalListeners = /* @__PURE__ */ new Set();
-// this is what every pool executes when running tests
 async function execute(method, ctx, worker) {
-	disposeInternalListeners();
 	const prepareStart = performance.now(), cleanups = [setupInspect(ctx)];
-	process.env.VITEST_WORKER_ID = String(ctx.workerId);
-	const poolId = process.__tinypool_state__?.workerId;
-	process.env.VITEST_POOL_ID = String(poolId);
 	let environmentLoader;
+	// RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
+	const { rpc, onCancel } = createRuntimeRpc(worker);
 	try {
-		if (!worker.getRpcOptions || typeof worker.getRpcOptions !== "function") throw new TypeError(`Test worker should expose "getRpcOptions" method. Received "${typeof worker.getRpcOptions}".`);
-		// RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
-		const { rpc, onCancel } = createRuntimeRpc(worker.getRpcOptions(ctx));
 		// do not close the RPC channel so that we can get the error messages sent to the main thread
 		cleanups.push(async () => {
 			await Promise.all(rpc.$rejectPendingCalls(({ method, reject }) => {
@@ -145,7 +77,7 @@ async function execute(method, ctx, worker) {
 		environmentLoader = loader;
 		const state = {
 			ctx,
-			evaluatedModules: new EvaluatedModules(),
+			evaluatedModules: new VitestEvaluatedModules(),
 			resolvingModules,
 			moduleExecutionInfo: /* @__PURE__ */ new Map(),
 			config: ctx.config,
@@ -166,12 +98,17 @@ async function execute(method, ctx, worker) {
 		if (!worker[methodName] || typeof worker[methodName] !== "function") throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
 		await worker[methodName](state);
 	} finally {
-		await Promise.all(cleanups.map((fn) => fn())), await rpcDone().catch(() => {}), environmentLoader?.close();
+		await Promise.all(cleanups.map((fn) => fn())), await rpcDone().catch(() => {}), await environmentLoader?.close(), rpc.$close();
 	}
 }
+function run(ctx, worker) {
+	return execute("run", ctx, worker);
+}
+function collect(ctx, worker) {
+	return execute("collect", ctx, worker);
+}
 async function teardown() {
-	const promises = [...globalListeners].map((l) => l());
-	await Promise.all(promises);
+	await Promise.all([...globalListeners].map((l) => l()));
 }
 function createImportMetaEnvProxy() {
 	// packages/vitest/src/node/plugins/index.ts:146
@@ -193,4 +130,84 @@ function createImportMetaEnvProxy() {
 	});
 }
 
-export { createThreadsRpcOptions as a, createForksRpcOptions as c, execute as e, teardown as t, unwrapSerializableConfig as u };
+const __vitest_worker_response__ = true, memoryUsage = process.memoryUsage.bind(process);
+let reportMemory = false;
+/** @experimental */
+function init(worker) {
+	worker.on(onMessage);
+	let runPromise, isRunning = false;
+	function send(response) {
+		worker.post(worker.serialize ? worker.serialize(response) : response);
+	}
+	async function onMessage(rawMessage) {
+		const message = worker.deserialize ? worker.deserialize(rawMessage) : rawMessage;
+		if (message?.__vitest_worker_request__ === true) switch (message.type) {
+			case "start":
+				reportMemory = message.options.reportMemory, send({
+					type: "started",
+					__vitest_worker_response__
+				});
+				break;
+			case "run":
+				// Prevent concurrent execution if worker is already running
+				if (isRunning) {
+					send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error: serializeError(/* @__PURE__ */ new Error("[vitest-worker]: Worker is already running tests"))
+					});
+					return;
+				}
+				isRunning = true, process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
+				try {
+					runPromise = run(message.context, worker).catch((error) => serializeError(error));
+					const error = await runPromise;
+					send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error,
+						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+					});
+				} finally {
+					runPromise = void 0, isRunning = false;
+				}
+				break;
+			case "collect":
+				// Prevent concurrent execution if worker is already running
+				if (isRunning) {
+					send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error: serializeError(/* @__PURE__ */ new Error("[vitest-worker]: Worker is already running tests"))
+					});
+					return;
+				}
+				isRunning = true, process.env.VITEST_POOL_ID = String(message.poolId), process.env.VITEST_WORKER_ID = String(message.context.workerId);
+				try {
+					runPromise = collect(message.context, worker).catch((error) => serializeError(error));
+					const error = await runPromise;
+					send({
+						type: "testfileFinished",
+						__vitest_worker_response__,
+						error,
+						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
+					});
+				} finally {
+					runPromise = void 0, isRunning = false;
+				}
+				break;
+			case "stop": {
+				await runPromise;
+				const error = await teardown().catch((error) => serializeError(error));
+				send({
+					type: "stopped",
+					error,
+					__vitest_worker_response__
+				}), worker.teardown?.();
+				break;
+			}
+		}
+	}
+}
+
+export { init as i };

package/dist/chunks/{inspector.Br76Q2Mb.js → inspector.DLZxSeU3.js}

@@ -32,8 +32,7 @@ function closeInspector(config) {
 }
 function shouldKeepOpen(config) {
 	// In watch mode the inspector can persist re-runs if isolation is disabled and a single worker is used
-	const isIsolatedSingleThread = config.pool === "threads" && config.poolOptions?.threads?.isolate === false && config.poolOptions?.threads?.singleThread, isIsolatedSingleFork = config.pool === "forks" && config.poolOptions?.forks?.isolate === false && config.poolOptions?.forks?.singleFork;
-	return config.watch && (isIsolatedSingleFork || isIsolatedSingleThread);
+	return config.watch && config.isolate === false && config.maxWorkers === 1;
 }
 
 export { closeInspector as c, setupInspect as s };

package/dist/chunks/{moduleRunner.d.aXWuQhZN.d.ts → moduleRunner.d.YtNsMIoJ.d.ts}

@@ -2,7 +2,7 @@ import * as _vitest_spy from '@vitest/spy';
 import vm from 'node:vm';
 import * as viteModuleRunner from 'vite/module-runner';
 import { ModuleEvaluator, ModuleRunnerImportMeta, ModuleRunnerContext, EvaluatedModuleNode, FetchFunction, EvaluatedModules } from 'vite/module-runner';
-import { a as RuntimeRPC, c as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.DSgBAZPX.js';
+import { R as RuntimeRPC, d as ResolveFunctionResult, W as WorkerGlobalState } from './worker.d.BFk-vvBU.js';
 import { MockedModule, MockedModuleType } from '@vitest/mocker';
 import { P as PendingSuiteMock, b as MockFactory, a as MockOptions } from './mocker.d.BE_2ls6u.js';
 

package/dist/chunks/{plugin.d.XtKKWlOO.d.ts → plugin.d.BB__S31E.d.ts}

@@ -1,4 +1,4 @@
-import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.BJ_OuJGZ.js';
+import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.C6nGyY9_.js';
 
 interface VitestPluginContext {
 	vitest: Vitest;