vitest 4.0.7 → 4.0.9

package/dist/chunks/{creator.cqqifzG7.js → creator.BzqvXeRE.js}

@@ -2,7 +2,7 @@ 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.D3XRDfWc.js';
-import { p as prompt, a as any } from './index.Dc3xnDvT.js';
+import { p as prompt, a as any } from './index.z7NPOg2E.js';
 import { x } from 'tinyexec';
 import c from 'tinyrainbow';
 import { c as configFiles } from './constants.D_Q9UYh-.js';
@@ -43,7 +43,8 @@ test('renders name', async () => {
   await expect.element(getByText('Hello Vitest!')).toBeInTheDocument()
 })
 `
-}, vueExample = {
+};
+const vueExample = {
 	name: "HelloWorld.vue",
 	js: `
 <script setup>
@@ -83,7 +84,8 @@ test('renders name', async () => {
   await expect.element(getByText('Hello Vitest!')).toBeInTheDocument()
 })
 `
-}, svelteExample = {
+};
+const svelteExample = {
 	name: "HelloWorld.svelte",
 	js: `
 <script>
@@ -109,7 +111,8 @@ test('renders name', async () => {
   await expect.element(getByText('Hello Vitest!')).toBeInTheDocument()
 })
 `
-}, markoExample = {
+};
+const markoExample = {
 	name: "HelloWorld.marko",
 	js: `
 class {
@@ -138,7 +141,8 @@ test('renders name', async () => {
   expect(element).toBeInTheDocument()
 })
 `
-}, litExample = {
+};
+const litExample = {
 	name: "HelloWorld.js",
 	js: `
 import { html, LitElement } from 'lit'
@@ -192,7 +196,8 @@ test('renders name', async () => {
   await expect.element(element).toBeInTheDocument()
 })
 `
-}, qwikExample = {
+};
+const qwikExample = {
 	name: "HelloWorld.jsx",
 	js: `
 import { component$ } from '@builder.io/qwik'
@@ -226,7 +231,8 @@ test('renders name', async () => {
   await expect.element(getByText('Hello Vitest!')).toBeInTheDocument()
 })
 `
-}, vanillaExample = {
+};
+const vanillaExample = {
 	name: "HelloWorld.js",
 	js: `
 export default function HelloWorld({ name }) {
@@ -286,14 +292,18 @@ function getExampleTest(framework) {
 async function generateExampleFiles(framework, lang) {
 	const example = getExampleTest(framework);
 	let fileName = example.name;
-	const folder = resolve(process.cwd(), "vitest-example"), fileContent = example[lang];
+	const folder = resolve(process.cwd(), "vitest-example");
+	const fileContent = example[lang];
 	if (!existsSync(folder)) await mkdir(folder, { recursive: true });
 	const isJSX = fileName.endsWith(".jsx");
 	if (isJSX && lang === "ts") fileName = fileName.replace(".jsx", ".tsx");
 	else if (fileName.endsWith(".js") && lang === "ts") fileName = fileName.replace(".js", ".ts");
 	example.test = example.test.replace("<EXT>", lang);
-	const filePath = resolve(folder, fileName), testPath = resolve(folder, `HelloWorld.test.${isJSX ? `${lang}x` : lang}`);
-	return writeFileSync(filePath, fileContent.trimStart(), "utf-8"), writeFileSync(testPath, example.test.trimStart(), "utf-8"), testPath;
+	const filePath = resolve(folder, fileName);
+	const testPath = resolve(folder, `HelloWorld.test.${isJSX ? `${lang}x` : lang}`);
+	writeFileSync(filePath, fileContent.trimStart(), "utf-8");
+	writeFileSync(testPath, example.test.trimStart(), "utf-8");
+	return testPath;
 }
 
 // eslint-disable-next-line no-console
@@ -422,7 +432,10 @@ async function installPackages(pkgManager, packages) {
 		log(c.green("✔"), c.bold("All packages are already installed."));
 		return;
 	}
-	log(c.cyan("◼"), c.bold("Installing packages...")), log(c.cyan("◼"), packages.join(", ")), log(), await installPackage(packages, {
+	log(c.cyan("◼"), c.bold("Installing packages..."));
+	log(c.cyan("◼"), packages.join(", "));
+	log();
+	await installPackage(packages, {
 		dev: true,
 		packageManager: pkgManager ?? void 0
 	});
@@ -433,19 +446,27 @@ function readPkgJson(path) {
 	return JSON.parse(content);
 }
 function getPossibleDefaults(dependencies) {
-	const provider = getPossibleProvider(dependencies), framework = getPossibleFramework(dependencies);
 	return {
 		lang: "ts",
-		provider,
-		framework
+		provider: getPossibleProvider(dependencies),
+		framework: getPossibleFramework(dependencies)
 	};
 }
 function getPossibleFramework(dependencies) {
-	return dependencies.vue || dependencies["vue-tsc"] || dependencies["@vue/reactivity"] ? "vue" : dependencies.react || dependencies["react-dom"] ? "react" : dependencies.svelte || dependencies["@sveltejs/kit"] ? "svelte" : dependencies.lit || dependencies["lit-html"] ? "lit" : dependencies.preact ? "preact" : dependencies["solid-js"] || dependencies["@solidjs/start"] ? "solid" : dependencies.marko ? "marko" : dependencies["@builder.io/qwik"] || dependencies["@qwik.dev/core"] ? "qwik" : "vanilla";
+	if (dependencies.vue || dependencies["vue-tsc"] || dependencies["@vue/reactivity"]) return "vue";
+	if (dependencies.react || dependencies["react-dom"]) return "react";
+	if (dependencies.svelte || dependencies["@sveltejs/kit"]) return "svelte";
+	if (dependencies.lit || dependencies["lit-html"]) return "lit";
+	if (dependencies.preact) return "preact";
+	if (dependencies["solid-js"] || dependencies["@solidjs/start"]) return "solid";
+	if (dependencies.marko) return "marko";
+	if (dependencies["@builder.io/qwik"] || dependencies["@qwik.dev/core"]) return "qwik";
+	return "vanilla";
 }
 function getPossibleProvider(dependencies) {
+	if (dependencies.webdriverio || dependencies["@wdio/cli"] || dependencies["@wdio/config"]) return "webdriverio";
 	// playwright is the default recommendation
-	return dependencies.webdriverio || dependencies["@wdio/cli"] || dependencies["@wdio/config"] ? "webdriverio" : "playwright";
+	return "playwright";
 }
 function getProviderDocsLink(provider) {
 	switch (provider) {
@@ -455,7 +476,8 @@ function getProviderDocsLink(provider) {
 }
 function sort(choices, value) {
 	const index = choices.findIndex((i) => i.value === value);
-	return index === -1 ? choices : [choices.splice(index, 1)[0], ...choices];
+	if (index === -1) return choices;
+	return [choices.splice(index, 1)[0], ...choices];
 }
 function fail() {
 	process.exitCode = 1;
@@ -477,7 +499,9 @@ function getFrameworkImportInfo(framework) {
 	}
 }
 async function generateFrameworkConfigFile(options) {
-	const { importName, isNamedExport } = getFrameworkImportInfo(options.framework), frameworkImport = isNamedExport ? `import { ${importName} } from '${options.frameworkPlugin}'` : `import ${importName} from '${options.frameworkPlugin}'`, configContent = [
+	const { importName, isNamedExport } = getFrameworkImportInfo(options.framework);
+	const frameworkImport = isNamedExport ? `import { ${importName} } from '${options.frameworkPlugin}'` : `import ${importName} from '${options.frameworkPlugin}'`;
+	const configContent = [
 		`import { defineConfig } from 'vitest/config'`,
 		`import { ${options.provider} } from '@vitest/browser-${options.provider}'`,
 		options.frameworkPlugin ? frameworkImport : null,
@@ -505,7 +529,9 @@ async function updatePkgJsonScripts(pkgJsonPath, vitestScript) {
 		await writeFile(pkgJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf-8");
 	} else {
 		const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-		pkg.scripts = pkg.scripts || {}, pkg.scripts["test:browser"] = vitestScript, await writeFile(pkgJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf-8");
+		pkg.scripts = pkg.scripts || {};
+		pkg.scripts["test:browser"] = vitestScript;
+		await writeFile(pkgJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf-8");
 	}
 	log(c.green("✔"), "Added \"test:browser\" script to your package.json.");
 }
@@ -531,10 +557,14 @@ function getPlaywrightRunArgs(pkgManager) {
 }
 async function create() {
 	log(c.cyan("◼"), "This utility will help you set up a browser testing environment.\n");
-	const pkgJsonPath = resolve(process.cwd(), "package.json"), pkg = readPkgJson(pkgJsonPath) || {}, dependencies = {
+	const pkgJsonPath = resolve(process.cwd(), "package.json");
+	const pkg = readPkgJson(pkgJsonPath) || {};
+	const dependencies = {
 		...pkg.dependencies,
 		...pkg.devDependencies
-	}, defaults = getPossibleDefaults(dependencies), { lang } = await prompt({
+	};
+	const defaults = getPossibleDefaults(dependencies);
+	const { lang } = await prompt({
 		type: "select",
 		name: "lang",
 		message: "Choose a language for your tests",
@@ -572,23 +602,28 @@ async function create() {
 		message: `Install Playwright browsers (can be done manually via 'pnpm exec playwright install')?`
 	}));
 	if (installPlaywright == null) return fail();
-	const dependenciesToInstall = [`@vitest/browser-${provider}`], frameworkPackage = getFrameworkTestPackage(framework);
+	const dependenciesToInstall = [`@vitest/browser-${provider}`];
+	const frameworkPackage = getFrameworkTestPackage(framework);
 	if (frameworkPackage) dependenciesToInstall.push(frameworkPackage);
 	const frameworkPlugin = getFrameworkPluginPackage(framework);
 	if (frameworkPlugin) dependenciesToInstall.push(frameworkPlugin);
 	const pkgManager = await detectPackageManager();
-	log(), await installPackages(pkgManager, dependenciesToInstall.filter((pkg) => !dependencies[pkg]));
+	log();
+	await installPackages(pkgManager, dependenciesToInstall.filter((pkg) => !dependencies[pkg]));
 	const rootConfig = any(configFiles, { cwd: process.cwd() });
 	let scriptCommand = "vitest";
-	if (log(), rootConfig) {
+	log();
+	if (rootConfig) {
 		const configPath = resolve(dirname(rootConfig), `vitest.browser.config.${lang}`);
-		scriptCommand = `vitest --config=${relative(process.cwd(), configPath)}`, await generateFrameworkConfigFile({
+		scriptCommand = `vitest --config=${relative(process.cwd(), configPath)}`;
+		await generateFrameworkConfigFile({
 			configPath,
 			framework,
 			frameworkPlugin,
 			provider,
 			browsers
-		}), log(
+		});
+		log(
 			c.green("✔"),
 			"Created a new config file for browser tests:",
 			c.bold(relative(process.cwd(), configPath)),
@@ -605,17 +640,23 @@ async function create() {
 			frameworkPlugin,
 			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)));
 	}
-	if (log(), await updatePkgJsonScripts(pkgJsonPath, scriptCommand), installPlaywright) {
+	log();
+	await updatePkgJsonScripts(pkgJsonPath, scriptCommand);
+	if (installPlaywright) {
 		log();
-		const [command, ...args] = getPlaywrightRunArgs(pkgManager), allArgs = [
+		const [command, ...args] = getPlaywrightRunArgs(pkgManager);
+		const allArgs = [
 			...args,
 			"playwright",
 			"install",
 			"--with-deps"
 		];
-		log(c.cyan("◼"), `Installing Playwright dependencies with \`${c.bold(command)} ${c.bold(allArgs.join(" "))}\`...`), log(), await x(command, allArgs, { nodeOptions: { stdio: [
+		log(c.cyan("◼"), `Installing Playwright dependencies with \`${c.bold(command)} ${c.bold(allArgs.join(" "))}\`...`);
+		log();
+		await x(command, allArgs, { nodeOptions: { stdio: [
 			"pipe",
 			"inherit",
 			"inherit"
@@ -623,7 +664,10 @@ async function create() {
 	}
 	log();
 	const exampleTestFile = await generateExampleFiles(framework, lang);
-	log(c.green("✔"), "Created example test file in", c.bold(relative(process.cwd(), exampleTestFile))), log(c.dim("  You can safely delete this file once you have written your own tests.")), log(), log(c.cyan("◼"), "All done! Run your tests with", c.bold(getRunScript(pkgManager)));
+	log(c.green("✔"), "Created example test file in", c.bold(relative(process.cwd(), exampleTestFile)));
+	log(c.dim("  You can safely delete this file once you have written your own tests."));
+	log();
+	log(c.cyan("◼"), "All done! Run your tests with", c.bold(getRunScript(pkgManager)));
 }
 
 export { create };

package/dist/chunks/{date.-jtEtIeV.js → date.Bq6ZW5rf.js}

@@ -37,23 +37,34 @@ class MockDate extends RealDate {
 				date = new RealDate(y);
 				break;
 			default:
-				d = typeof d === "undefined" ? 1 : d, h = h || 0, M = M || 0, s = s || 0, ms = ms || 0, date = new RealDate(y, m, d, h, M, s, ms);
+				d = typeof d === "undefined" ? 1 : d;
+				h = h || 0;
+				M = M || 0;
+				s = s || 0;
+				ms = ms || 0;
+				date = new RealDate(y, m, d, h, M, s, ms);
 				break;
 		}
-		return Object.setPrototypeOf(date, MockDate.prototype), date;
+		Object.setPrototypeOf(date, MockDate.prototype);
+		return date;
 	}
 }
-MockDate.UTC = RealDate.UTC, MockDate.now = function() {
+MockDate.UTC = RealDate.UTC;
+MockDate.now = function() {
 	return new MockDate().valueOf();
-}, MockDate.parse = function(dateString) {
+};
+MockDate.parse = function(dateString) {
 	return RealDate.parse(dateString);
-}, MockDate.toString = function() {
+};
+MockDate.toString = function() {
 	return RealDate.toString();
 };
 function mockDate(date) {
 	const dateObj = new RealDate(date.valueOf());
 	if (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
-	globalThis.Date = MockDate, now = dateObj.valueOf();
+	// @ts-expect-error global
+	globalThis.Date = MockDate;
+	now = dateObj.valueOf();
 }
 function resetDate() {
 	globalThis.Date = RealDate;

package/dist/chunks/{git.BFNcloKD.js → git.Bm2pzPAa.js}

@@ -11,7 +11,8 @@ class VitestGit {
 		try {
 			result = await x("git", args, { nodeOptions: { cwd: this.root } });
 		} catch (e) {
-			throw e.message = e.stderr, e;
+			e.message = e.stderr;
+			throw e;
 		}
 		return result.stdout.split("\n").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
 	}
@@ -60,8 +61,7 @@ class VitestGit {
 	async getRoot(cwd) {
 		const args = ["rev-parse", "--show-cdup"];
 		try {
-			const result = await x("git", args, { nodeOptions: { cwd } });
-			return resolve(cwd, result.stdout.trim());
+			return resolve(cwd, (await x("git", args, { nodeOptions: { cwd } })).stdout.trim());
 		} catch {
 			return null;
 		}

package/dist/chunks/{global.d.DxtanrNO.d.ts → global.d.BQDgW9Pr.d.ts}

@@ -2,7 +2,7 @@ import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
 import { Plugin } from '@vitest/pretty-format';
 import { SnapshotState } from '@vitest/snapshot';
 import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
-import { U as UserConsoleLog } from './worker.d.D25zYZ7N.js';
+import { U as UserConsoleLog } from './worker.d.ZGohxCEd.js';
 
 interface SnapshotMatcher<T> {
 	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;

package/dist/chunks/{globals.BGT_RUsD.js → globals.DBrtKPdh.js}

@@ -1,10 +1,10 @@
 import { g as globalApis } from './constants.D_Q9UYh-.js';
-import { i as index } from './index.RwjEGCQ0.js';
-import './vi.BZvkKVkM.js';
+import { i as index } from './index.CGezRSGU.js';
+import './vi.CyIUVSoU.js';
 import '@vitest/expect';
 import '@vitest/runner';
 import '@vitest/runner/utils';
-import './utils.CG9h5ccR.js';
+import './utils.DvEY5TfP.js';
 import '@vitest/utils/timers';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
@@ -13,8 +13,8 @@ import '@vitest/spy';
 import '@vitest/utils/offset';
 import '@vitest/utils/source-map';
 import './_commonjsHelpers.BFTU3MAI.js';
-import './date.-jtEtIeV.js';
-import './benchmark.DHKMYAts.js';
+import './date.Bq6ZW5rf.js';
+import './benchmark.B3N2zMcH.js';
 import './evaluatedModules.Dg1zASAC.js';
 import 'pathe';
 import 'vite/module-runner';

package/dist/chunks/index.0kCJoeWi.js

@@ -0,0 +1,220 @@
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+  return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc($functions, options) {
+  const {
+    post,
+    on,
+    off = () => {
+    },
+    eventNames = [],
+    serialize = defaultSerialize,
+    deserialize = defaultDeserialize,
+    resolver,
+    bind = "rpc",
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  let $closed = false;
+  const _rpcPromiseMap = /* @__PURE__ */ new Map();
+  let _promiseInit;
+  async function _call(method, args, event, optional) {
+    if ($closed)
+      throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+    const req = { m: method, a: args, t: TYPE_REQUEST };
+    if (optional)
+      req.o = true;
+    const send = async (_req) => post(serialize(_req));
+    if (event) {
+      await send(req);
+      return;
+    }
+    if (_promiseInit) {
+      try {
+        await _promiseInit;
+      } finally {
+        _promiseInit = void 0;
+      }
+    }
+    let { promise, resolve, reject } = createPromiseWithResolvers();
+    const id = nanoid();
+    req.i = id;
+    let timeoutId;
+    async function handler(newReq = req) {
+      if (timeout >= 0) {
+        timeoutId = setTimeout(() => {
+          try {
+            const handleResult = options.onTimeoutError?.(method, args);
+            if (handleResult !== true)
+              throw new Error(`[birpc] timeout on calling "${method}"`);
+          } catch (e) {
+            reject(e);
+          }
+          _rpcPromiseMap.delete(id);
+        }, timeout);
+        if (typeof timeoutId === "object")
+          timeoutId = timeoutId.unref?.();
+      }
+      _rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
+      await send(newReq);
+      return promise;
+    }
+    try {
+      if (options.onRequest)
+        await options.onRequest(req, handler, resolve);
+      else
+        await handler();
+    } catch (e) {
+      if (options.onGeneralError?.(e) !== true)
+        throw e;
+      return;
+    } finally {
+      clearTimeout(timeoutId);
+      _rpcPromiseMap.delete(id);
+    }
+    return promise;
+  }
+  const $call = (method, ...args) => _call(method, args, false);
+  const $callOptional = (method, ...args) => _call(method, args, false, true);
+  const $callEvent = (method, ...args) => _call(method, args, true);
+  const $callRaw = (options2) => _call(options2.method, options2.args, options2.event, options2.optional);
+  const builtinMethods = {
+    $call,
+    $callOptional,
+    $callEvent,
+    $callRaw,
+    $rejectPendingCalls,
+    get $closed() {
+      return $closed;
+    },
+    $close,
+    $functions
+  };
+  const rpc = new Proxy({}, {
+    get(_, method) {
+      if (Object.prototype.hasOwnProperty.call(builtinMethods, method))
+        return builtinMethods[method];
+      if (method === "then" && !eventNames.includes("then") && !("then" in $functions))
+        return void 0;
+      const sendEvent = (...args) => _call(method, args, true);
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = (...args) => _call(method, args, false);
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  function $close(customError) {
+    $closed = true;
+    _rpcPromiseMap.forEach(({ reject, method }) => {
+      const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+      if (customError) {
+        customError.cause ??= error;
+        return reject(customError);
+      }
+      reject(error);
+    });
+    _rpcPromiseMap.clear();
+    off(onMessage);
+  }
+  function $rejectPendingCalls(handler) {
+    const entries = Array.from(_rpcPromiseMap.values());
+    const handlerResults = entries.map(({ method, reject }) => {
+      if (!handler) {
+        return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+      }
+      return handler({ method, reject });
+    });
+    _rpcPromiseMap.clear();
+    return handlerResults;
+  }
+  async function onMessage(data, ...extra) {
+    let msg;
+    try {
+      msg = deserialize(data);
+    } catch (e) {
+      if (options.onGeneralError?.(e) !== true)
+        throw e;
+      return;
+    }
+    if (msg.t === TYPE_REQUEST) {
+      const { m: method, a: args, o: optional } = msg;
+      let result, error;
+      let fn = await (resolver ? resolver(method, $functions[method]) : $functions[method]);
+      if (optional)
+        fn ||= () => void 0;
+      if (!fn) {
+        error = new Error(`[birpc] function "${method}" not found`);
+      } else {
+        try {
+          result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+        } catch (e) {
+          error = e;
+        }
+      }
+      if (msg.i) {
+        if (error && options.onError)
+          options.onError(error, method, args);
+        if (error && options.onFunctionError) {
+          if (options.onFunctionError(error, method, args) === true)
+            return;
+        }
+        if (!error) {
+          try {
+            await post(serialize({ t: TYPE_RESPONSE, i: msg.i, r: result }), ...extra);
+            return;
+          } catch (e) {
+            error = e;
+            if (options.onGeneralError?.(e, method, args) !== true)
+              throw e;
+          }
+        }
+        try {
+          await post(serialize({ t: TYPE_RESPONSE, i: msg.i, e: error }), ...extra);
+        } catch (e) {
+          if (options.onGeneralError?.(e, method, args) !== true)
+            throw e;
+        }
+      }
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = _rpcPromiseMap.get(ack);
+      if (promise) {
+        clearTimeout(promise.timeoutId);
+        if (error)
+          promise.reject(error);
+        else
+          promise.resolve(result);
+      }
+      _rpcPromiseMap.delete(ack);
+    }
+  }
+  _promiseInit = on(onMessage);
+  return rpc;
+}
+function createPromiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[random() * 64 | 0];
+  return id;
+}
+
+export { createBirpc as c };