vitest 3.2.0-beta.1 → 3.2.0-beta.2

package/dist/chunks/{creator.CuL7xDWI.js → creator.DGAdZ4Hj.js}

@@ -1,8 +1,8 @@
 import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { resolve, dirname, relative } from 'node:path';
-import { detectPackageManager, installPackage } from './index.Bw6JxgX8.js';
-import { p as prompt, f as findUp } from './index.DBIGubLC.js';
+import { detectPackageManager, installPackage } from './index.CK1YOQaa.js';
+import { p as prompt, f as findUp } from './index.X0nbfr6-.js';
 import { x } from 'tinyexec';
 import c from 'tinyrainbow';
 import { c as configFiles } from './constants.BZZyIeIE.js';
@@ -488,32 +488,6 @@ function sort(choices, value) {
 function fail() {
 	process.exitCode = 1;
 }
-async function generateWorkspaceFile(options) {
-	const relativeRoot = relative(dirname(options.configPath), options.rootConfig);
-	const workspaceContent = [
-		`import { defineWorkspace } from 'vitest/config'`,
-		"",
-		"export default defineWorkspace([",
-		"  // If you want to keep running your existing tests in Node.js, uncomment the next line.",
-		`  // '${relativeRoot}',`,
-		`  {`,
-		`    extends: '${relativeRoot}',`,
-		`    test: {`,
-		`      browser: {`,
-		`        enabled: true,`,
-		`        provider: '${options.provider}',`,
-		options.provider !== "preview" && `        // ${getProviderDocsLink(options.provider)}`,
-		`        instances: [`,
-		...options.browsers.map((browser) => `        { browser: '${browser}' },`),
-		`        ],`,
-		`      },`,
-		`    },`,
-		`  },`,
-		`])`,
-		""
-	].filter((c) => typeof c === "string").join("\n");
-	await writeFile(options.configPath, workspaceContent);
-}
 async function generateFrameworkConfigFile(options) {
 	const frameworkImport = options.framework === "svelte" ? `import { svelte } from '${options.frameworkPlugin}'` : `import ${options.framework} from '${options.frameworkPlugin}'`;
 	const configContent = [
@@ -648,19 +622,24 @@ async function create() {
 	let scriptCommand = "vitest";
 	log();
 	if (rootConfig) {
-		let browserWorkspaceFile = resolve(dirname(rootConfig), `vitest.workspace.${lang}`);
-		if (existsSync(browserWorkspaceFile)) {
-			log(c.yellow("⚠"), c.yellow("A workspace file already exists. Creating a new one for the browser tests - you can merge them manually if needed."));
-			browserWorkspaceFile = resolve(process.cwd(), `vitest.workspace.browser.${lang}`);
-		}
-		scriptCommand = `vitest --workspace=${relative(process.cwd(), browserWorkspaceFile)}`;
-		await generateWorkspaceFile({
-			configPath: browserWorkspaceFile,
-			rootConfig,
+		const configPath = resolve(dirname(rootConfig), `vitest.browser.config.${lang}`);
+		scriptCommand = `vitest --config=${relative(process.cwd(), configPath)}`;
+		await generateFrameworkConfigFile({
+			configPath,
+			framework,
+			frameworkPlugin,
 			provider,
 			browsers
 		});
-		log(c.green("✔"), "Created a workspace file for browser tests:", c.bold(relative(process.cwd(), browserWorkspaceFile)));
+		log(
+			c.green("✔"),
+			"Created a new config file for browser tests:",
+			c.bold(relative(process.cwd(), configPath)),
+			// TODO: Can we modify the config ourselves?
+			"\nSince you already have a Vitest config file, it is recommended to copy the contents of the new file ",
+			"into your existing config located at ",
+			c.bold(relative(process.cwd(), rootConfig))
+);
 	} else {
 		const configPath = resolve(process.cwd(), `vitest.config.${lang}`);
 		await generateFrameworkConfigFile({
@@ -670,7 +649,7 @@ async function create() {
 			provider,
 			browsers
 		});
-		log(c.green("✔"), "Created a config file for browser tests", c.bold(relative(process.cwd(), configPath)));
+		log(c.green("✔"), "Created a config file for browser tests:", c.bold(relative(process.cwd(), configPath)));
 	}
 	log();
 	await updatePkgJsonScripts(pkgJsonPath, scriptCommand);

package/dist/chunks/{execute.BpmIjFTD.js → execute.JlGHLJZT.js}

@@ -548,11 +548,9 @@ function listenForErrors(state) {
 	dispose.length = 0;
 	function catchError(err, type, event) {
 		const worker = state();
-		if (worker.current?.type === "test") {
-			const listeners = process.listeners(event);
-			if (listeners.length > 1) {
-				return;
-			}
+		const listeners = process.listeners(event);
+		if (listeners.length > 1) {
+			return;
 		}
 		const error = processError(err);
 		if (!isPrimitive(error)) {

package/dist/chunks/{global.d.BCOHQEpR.d.ts → global.d.BPa1eL3O.d.ts}

@@ -39,12 +39,12 @@ declare global {
 	}
 }
 interface SnapshotMatcher<T> {
-	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, message?: string): void;
-	(message?: string): void;
+	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;
+	(hint?: string): void;
 }
 interface InlineSnapshotMatcher<T> {
-	<U extends { [P in keyof T] : any }>(properties: Partial<U>, snapshot?: string, message?: string): void;
-	(message?: string): void;
+	<U extends { [P in keyof T] : any }>(properties: Partial<U>, snapshot?: string, hint?: string): void;
+	(hint?: string): void;
 }
 declare module "@vitest/expect" {
 	interface MatcherState {
@@ -72,35 +72,35 @@ declare module "@vitest/expect" {
 		/**
 		* Checks that an error thrown by a function matches a previously recorded snapshot.
 		*
-		* @param message - Optional custom error message.
+		* @param hint - Optional custom error message.
 		*
 		* @example
 		* expect(functionWithError).toThrowErrorMatchingSnapshot();
 		*/
-		toThrowErrorMatchingSnapshot: (message?: string) => void;
+		toThrowErrorMatchingSnapshot: (hint?: string) => void;
 		/**
 		* Checks that an error thrown by a function matches an inline snapshot within the test file.
 		* Useful for keeping snapshots close to the test code.
 		*
 		* @param snapshot - Optional inline snapshot string to match.
-		* @param message - Optional custom error message.
+		* @param hint - Optional custom error message.
 		*
 		* @example
 		* const throwError = () => { throw new Error('Error occurred') };
 		* expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
 		*/
-		toThrowErrorMatchingInlineSnapshot: (snapshot?: string, message?: string) => void;
+		toThrowErrorMatchingInlineSnapshot: (snapshot?: string, hint?: string) => void;
 		/**
 		* Compares the received value to a snapshot saved in a specified file.
 		* Useful for cases where snapshot content is large or needs to be shared across tests.
 		*
 		* @param filepath - Path to the snapshot file.
-		* @param message - Optional custom error message.
+		* @param hint - Optional custom error message.
 		*
 		* @example
 		* await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
 		*/
-		toMatchFileSnapshot: (filepath: string, message?: string) => Promise<void>;
+		toMatchFileSnapshot: (filepath: string, hint?: string) => Promise<void>;
 	}
 }
 declare module "@vitest/runner" {

package/dist/chunks/{globals.Cg4NtV4P.js → globals.CpxW8ccg.js}

@@ -1,5 +1,5 @@
 import { g as globalApis } from './constants.BZZyIeIE.js';
-import { V as VitestIndex } from './index.BPc7M5ni.js';
+import { V as VitestIndex } from './index.CfXMNXHg.js';
 import './vi.BFR5YIgu.js';
 import '@vitest/expect';
 import '@vitest/runner';
@@ -13,7 +13,6 @@ import '@vitest/utils/error';
 import '@vitest/spy';
 import '@vitest/utils/source-map';
 import './date.CDOsz-HY.js';
-import './run-once.Dimr7O9f.js';
 import './benchmark.BoF7jW0Q.js';
 import 'expect-type';
 

package/dist/chunks/{index.Bw6JxgX8.js → index.CK1YOQaa.js}

@@ -1,7 +1,7 @@
 import process from 'node:process';
 import fs, { existsSync } from 'node:fs';
 import fsPromises from 'node:fs/promises';
-import p, { resolve } from 'node:path';
+import path, { resolve } from 'node:path';
 import { x } from 'tinyexec';
 
 const AGENTS = [
@@ -27,27 +27,27 @@ async function detect(options = {}) {
   const { cwd, onUnknown } = options;
   for (const directory of lookup(cwd)) {
     for (const lock of Object.keys(LOCKS)) {
-      if (await fileExists(p.join(directory, lock))) {
+      if (await fileExists(path.join(directory, lock))) {
         const name = LOCKS[lock];
-        const result2 = await parsePackageJson(p.join(directory, "package.json"), onUnknown);
+        const result2 = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
         if (result2)
           return result2;
         else
           return { name, agent: name };
       }
     }
-    const result = await parsePackageJson(p.join(directory, "package.json"), onUnknown);
+    const result = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
     if (result)
       return result;
   }
   return null;
 }
 function* lookup(cwd = process.cwd()) {
-  let directory = p.resolve(cwd);
-  const { root } = p.parse(directory);
+  let directory = path.resolve(cwd);
+  const { root } = path.parse(directory);
   while (directory && directory !== root) {
     yield directory;
-    directory = p.dirname(directory);
+    directory = path.dirname(directory);
   }
 }
 async function parsePackageJson(filepath, onUnknown) {