vitest 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/chunks/install-pkg.ORGzQeqb.js

@@ -0,0 +1,457 @@
+import require$$0 from 'fs';
+import p from 'path';
+import { g as getDefaultExportFromCjs } from '../vendor/_commonjsHelpers.jjO7Zipk.js';
+import require$$0$1 from 'util';
+import execa from 'execa';
+
+var findUp$1 = {exports: {}};
+
+var locatePath = {exports: {}};
+
+class Node {
+	/// value;
+	/// next;
+
+	constructor(value) {
+		this.value = value;
+
+		// TODO: Remove this when targeting Node.js 12.
+		this.next = undefined;
+	}
+}
+
+let Queue$1 = class Queue {
+	// TODO: Use private class fields when targeting Node.js 12.
+	// #_head;
+	// #_tail;
+	// #_size;
+
+	constructor() {
+		this.clear();
+	}
+
+	enqueue(value) {
+		const node = new Node(value);
+
+		if (this._head) {
+			this._tail.next = node;
+			this._tail = node;
+		} else {
+			this._head = node;
+			this._tail = node;
+		}
+
+		this._size++;
+	}
+
+	dequeue() {
+		const current = this._head;
+		if (!current) {
+			return;
+		}
+
+		this._head = this._head.next;
+		this._size--;
+		return current.value;
+	}
+
+	clear() {
+		this._head = undefined;
+		this._tail = undefined;
+		this._size = 0;
+	}
+
+	get size() {
+		return this._size;
+	}
+
+	* [Symbol.iterator]() {
+		let current = this._head;
+
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+};
+
+var yoctoQueue = Queue$1;
+
+const Queue = yoctoQueue;
+
+const pLimit$1 = concurrency => {
+	if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+	}
+
+	const queue = new Queue();
+	let activeCount = 0;
+
+	const next = () => {
+		activeCount--;
+
+		if (queue.size > 0) {
+			queue.dequeue()();
+		}
+	};
+
+	const run = async (fn, resolve, ...args) => {
+		activeCount++;
+
+		const result = (async () => fn(...args))();
+
+		resolve(result);
+
+		try {
+			await result;
+		} catch {}
+
+		next();
+	};
+
+	const enqueue = (fn, resolve, ...args) => {
+		queue.enqueue(run.bind(null, fn, resolve, ...args));
+
+		(async () => {
+			// This function needs to wait until the next microtask before comparing
+			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+			// when the run function is dequeued and called. The comparison in the if-statement
+			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+			await Promise.resolve();
+
+			if (activeCount < concurrency && queue.size > 0) {
+				queue.dequeue()();
+			}
+		})();
+	};
+
+	const generator = (fn, ...args) => new Promise(resolve => {
+		enqueue(fn, resolve, ...args);
+	});
+
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount
+		},
+		pendingCount: {
+			get: () => queue.size
+		},
+		clearQueue: {
+			value: () => {
+				queue.clear();
+			}
+		}
+	});
+
+	return generator;
+};
+
+var pLimit_1 = pLimit$1;
+
+const pLimit = pLimit_1;
+
+class EndError extends Error {
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+}
+
+// The input can also be a promise, so we await it
+const testElement = async (element, tester) => tester(await element);
+
+// The input can also be a promise, so we `Promise.all()` them both
+const finder = async element => {
+	const values = await Promise.all(element);
+	if (values[1] === true) {
+		throw new EndError(values[0]);
+	}
+
+	return false;
+};
+
+const pLocate$1 = async (iterable, tester, options) => {
+	options = {
+		concurrency: Infinity,
+		preserveOrder: true,
+		...options
+	};
+
+	const limit = pLimit(options.concurrency);
+
+	// Start all the promises concurrently with optional limit
+	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
+
+	// Check the promises either serially or concurrently
+	const checkLimit = pLimit(options.preserveOrder ? 1 : Infinity);
+
+	try {
+		await Promise.all(items.map(element => checkLimit(finder, element)));
+	} catch (error) {
+		if (error instanceof EndError) {
+			return error.value;
+		}
+
+		throw error;
+	}
+};
+
+var pLocate_1 = pLocate$1;
+
+const path = p;
+const fs$1 = require$$0;
+const {promisify: promisify$1} = require$$0$1;
+const pLocate = pLocate_1;
+
+const fsStat = promisify$1(fs$1.stat);
+const fsLStat = promisify$1(fs$1.lstat);
+
+const typeMappings = {
+	directory: 'isDirectory',
+	file: 'isFile'
+};
+
+function checkType({type}) {
+	if (type in typeMappings) {
+		return;
+	}
+
+	throw new Error(`Invalid type specified: ${type}`);
+}
+
+const matchType = (type, stat) => type === undefined || stat[typeMappings[type]]();
+
+locatePath.exports = async (paths, options) => {
+	options = {
+		cwd: process.cwd(),
+		type: 'file',
+		allowSymlinks: true,
+		...options
+	};
+
+	checkType(options);
+
+	const statFn = options.allowSymlinks ? fsStat : fsLStat;
+
+	return pLocate(paths, async path_ => {
+		try {
+			const stat = await statFn(path.resolve(options.cwd, path_));
+			return matchType(options.type, stat);
+		} catch {
+			return false;
+		}
+	}, options);
+};
+
+locatePath.exports.sync = (paths, options) => {
+	options = {
+		cwd: process.cwd(),
+		allowSymlinks: true,
+		type: 'file',
+		...options
+	};
+
+	checkType(options);
+
+	const statFn = options.allowSymlinks ? fs$1.statSync : fs$1.lstatSync;
+
+	for (const path_ of paths) {
+		try {
+			const stat = statFn(path.resolve(options.cwd, path_));
+
+			if (matchType(options.type, stat)) {
+				return path_;
+			}
+		} catch {}
+	}
+};
+
+var locatePathExports = locatePath.exports;
+
+var pathExists = {exports: {}};
+
+const fs = require$$0;
+const {promisify} = require$$0$1;
+
+const pAccess = promisify(fs.access);
+
+pathExists.exports = async path => {
+	try {
+		await pAccess(path);
+		return true;
+	} catch (_) {
+		return false;
+	}
+};
+
+pathExists.exports.sync = path => {
+	try {
+		fs.accessSync(path);
+		return true;
+	} catch (_) {
+		return false;
+	}
+};
+
+var pathExistsExports = pathExists.exports;
+
+(function (module) {
+	const path = p;
+	const locatePath = locatePathExports;
+	const pathExists = pathExistsExports;
+
+	const stop = Symbol('findUp.stop');
+
+	module.exports = async (name, options = {}) => {
+		let directory = path.resolve(options.cwd || '');
+		const {root} = path.parse(directory);
+		const paths = [].concat(name);
+
+		const runMatcher = async locateOptions => {
+			if (typeof name !== 'function') {
+				return locatePath(paths, locateOptions);
+			}
+
+			const foundPath = await name(locateOptions.cwd);
+			if (typeof foundPath === 'string') {
+				return locatePath([foundPath], locateOptions);
+			}
+
+			return foundPath;
+		};
+
+		// eslint-disable-next-line no-constant-condition
+		while (true) {
+			// eslint-disable-next-line no-await-in-loop
+			const foundPath = await runMatcher({...options, cwd: directory});
+
+			if (foundPath === stop) {
+				return;
+			}
+
+			if (foundPath) {
+				return path.resolve(directory, foundPath);
+			}
+
+			if (directory === root) {
+				return;
+			}
+
+			directory = path.dirname(directory);
+		}
+	};
+
+	module.exports.sync = (name, options = {}) => {
+		let directory = path.resolve(options.cwd || '');
+		const {root} = path.parse(directory);
+		const paths = [].concat(name);
+
+		const runMatcher = locateOptions => {
+			if (typeof name !== 'function') {
+				return locatePath.sync(paths, locateOptions);
+			}
+
+			const foundPath = name(locateOptions.cwd);
+			if (typeof foundPath === 'string') {
+				return locatePath.sync([foundPath], locateOptions);
+			}
+
+			return foundPath;
+		};
+
+		// eslint-disable-next-line no-constant-condition
+		while (true) {
+			const foundPath = runMatcher({...options, cwd: directory});
+
+			if (foundPath === stop) {
+				return;
+			}
+
+			if (foundPath) {
+				return path.resolve(directory, foundPath);
+			}
+
+			if (directory === root) {
+				return;
+			}
+
+			directory = path.dirname(directory);
+		}
+	};
+
+	module.exports.exists = pathExists;
+
+	module.exports.sync.exists = pathExists.sync;
+
+	module.exports.stop = stop; 
+} (findUp$1));
+
+var findUpExports = findUp$1.exports;
+var findUp = /*@__PURE__*/getDefaultExportFromCjs(findUpExports);
+
+// src/detect.ts
+var AGENTS = ["pnpm", "yarn", "npm", "pnpm@6", "yarn@berry", "bun"];
+var LOCKS = {
+  "bun.lockb": "bun",
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
+async function detectPackageManager(cwd = process.cwd()) {
+  let agent = null;
+  const lockPath = await findUp(Object.keys(LOCKS), { cwd });
+  let packageJsonPath;
+  if (lockPath)
+    packageJsonPath = p.resolve(lockPath, "../package.json");
+  else
+    packageJsonPath = await findUp("package.json", { cwd });
+  if (packageJsonPath && require$$0.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(require$$0.readFileSync(packageJsonPath, "utf8"));
+      if (typeof pkg.packageManager === "string") {
+        const [name, version] = pkg.packageManager.split("@");
+        if (name === "yarn" && parseInt(version) > 1)
+          agent = "yarn@berry";
+        else if (name === "pnpm" && parseInt(version) < 7)
+          agent = "pnpm@6";
+        else if (name in AGENTS)
+          agent = name;
+        else
+          console.warn("[ni] Unknown packageManager:", pkg.packageManager);
+      }
+    } catch {
+    }
+  }
+  if (!agent && lockPath)
+    agent = LOCKS[p.basename(lockPath)];
+  return agent;
+}
+async function installPackage(names, options = {}) {
+  const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm";
+  const [agent] = detectedAgent.split("@");
+  if (!Array.isArray(names))
+    names = [names];
+  const args = options.additionalArgs || [];
+  if (options.preferOffline) {
+    if (detectedAgent === "yarn@berry")
+      args.unshift("--cached");
+    else
+      args.unshift("--prefer-offline");
+  }
+  return execa(
+    agent,
+    [
+      agent === "yarn" ? "add" : "install",
+      options.dev ? "-D" : "",
+      ...args,
+      ...names
+    ].filter(Boolean),
+    {
+      stdio: options.silent ? "ignore" : "inherit",
+      cwd: options.cwd
+    }
+  );
+}
+
+export { detectPackageManager, installPackage };

package/dist/chunks/integrations-globals.-pds_Gug.js

@@ -0,0 +1,29 @@
+import { g as globalApis } from '../vendor/constants.WSvnD_fn.js';
+import { i as index } from '../vendor/index.Npc-eff0.js';
+import '@vitest/runner';
+import '../vendor/benchmark.WVm6DARl.js';
+import '@vitest/runner/utils';
+import '@vitest/utils';
+import '../vendor/index.XU72Rmy8.js';
+import 'pathe';
+import 'std-env';
+import '../vendor/global.L7JRz1qU.js';
+import '../vendor/run-once.X3E7xx3F.js';
+import '../vendor/vi.voNYQWB_.js';
+import 'chai';
+import '../vendor/_commonjsHelpers.jjO7Zipk.js';
+import '@vitest/expect';
+import '@vitest/snapshot';
+import '@vitest/utils/error';
+import '../vendor/tasks.IknbGB2n.js';
+import '@vitest/utils/source-map';
+import '../vendor/date.W90-E5kF.js';
+import '@vitest/spy';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = index[api];
+  });
+}
+
+export { registerApiGlobally };

package/dist/{chunk-node-git.6c12e560.js → chunks/node-git.Hw101KjS.js}

@@ -1,22 +1,5 @@
 import { resolve } from 'pathe';
-import { e as execa } from './vendor-index.8efe7746.js';
-import 'node:buffer';
-import 'node:path';
-import 'node:child_process';
-import 'node:process';
-import './vendor-_commonjsHelpers.7d1333e8.js';
-import 'child_process';
-import 'path';
-import 'fs';
-import 'node:url';
-import 'node:os';
-import 'assert';
-import 'events';
-import 'node:fs';
-import 'buffer';
-import 'stream';
-import 'util';
-import 'node:util';
+import { execa } from 'execa';
 
 class VitestGit {
   constructor(cwd) {

package/dist/{chunk-runtime-console.f3263f87.js → chunks/runtime-console.iCAG0Yz3.js}

@@ -2,7 +2,7 @@ import { Writable } from 'node:stream';
 import { Console } from 'node:console';
 import { relative } from 'node:path';
 import { getSafeTimers } from '@vitest/utils';
-import { R as RealDate } from './vendor-date.6e993429.js';
+import { R as RealDate } from '../vendor/date.W90-E5kF.js';
 
 const UNKNOWN_TEST_ID = "__vitest__unknown_test__";
 function getTaskIdByStack(root) {

package/dist/cli-wrapper.js

@@ -1,23 +1,7 @@
 import { fileURLToPath } from 'node:url';
 import c from 'picocolors';
-import { e as execa } from './vendor-index.8efe7746.js';
-import { E as EXIT_CODE_RESTART } from './vendor-constants.538d9b49.js';
-import 'node:buffer';
-import 'node:path';
-import 'node:child_process';
-import 'node:process';
-import './vendor-_commonjsHelpers.7d1333e8.js';
-import 'child_process';
-import 'path';
-import 'fs';
-import 'node:os';
-import 'assert';
-import 'events';
-import 'node:fs';
-import 'buffer';
-import 'stream';
-import 'util';
-import 'node:util';
+import { execa } from 'execa';
+import { E as EXIT_CODE_RESTART } from './vendor/constants.WSvnD_fn.js';
 
 const ENTRY = new URL("./cli.js", import.meta.url);
 const NODE_ARGS = [

package/dist/cli.js

@@ -1,19 +1,20 @@
 import { normalize } from 'pathe';
 import cac from 'cac';
 import c from 'picocolors';
-import { v as version, s as startVitest } from './vendor-node.327f8f1f.js';
-import './vendor-index.29282562.js';
-import { d as divider } from './vendor-reporters.b9600369.js';
-import { t as toArray } from './vendor-base.9c08bbd0.js';
+import { v as version, s as startVitest } from './vendor/node.c-kzGvOB.js';
+import './vendor/index.XU72Rmy8.js';
+import { d as divider } from './vendor/reporters.1xKxm8im.js';
+import { t as toArray } from './vendor/base._79unx2z.js';
 import 'vite';
 import 'node:path';
 import 'node:url';
 import 'node:process';
 import 'node:fs';
-import './vendor-constants.538d9b49.js';
-import './vendor-_commonjsHelpers.7d1333e8.js';
+import './vendor/constants.WSvnD_fn.js';
+import './vendor/_commonjsHelpers.jjO7Zipk.js';
 import 'os';
 import 'path';
+import './vendor/index.xL8XjTLv.js';
 import 'util';
 import 'stream';
 import 'events';
@@ -22,52 +23,49 @@ import 'vite-node/utils';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
-import './vendor-coverage.78040316.js';
-import './vendor-paths.84fc7a99.js';
+import './vendor/coverage.v6aD8iAh.js';
+import './paths.js';
 import 'node:v8';
 import 'node:os';
 import 'node:events';
 import 'tinypool';
-import './vendor-index.1ca68bd5.js';
+import './vendor/index.cAUulNDf.js';
 import 'node:worker_threads';
 import '@vitest/utils';
 import 'node:fs/promises';
 import 'node:perf_hooks';
-import './vendor-index.8efe7746.js';
-import 'node:buffer';
-import 'node:child_process';
-import 'child_process';
-import 'assert';
-import 'buffer';
-import 'node:util';
+import 'execa';
 import '@vitest/utils/source-map';
 import 'local-pkg';
 import 'std-env';
 import 'module';
-import 'acorn';
 import 'acorn-walk';
 import '@vitest/runner/utils';
 import 'node:crypto';
+import 'assert';
 import 'magic-string';
 import 'strip-literal';
-import './vendor-environments.dcc4a34e.js';
+import './vendor/environments.hpEVJZPC.js';
 import 'node:console';
 import 'node:readline';
 import 'readline';
-import './vendor-global.97e4527c.js';
-import './chunk-runtime-console.f3263f87.js';
+import './vendor/global.L7JRz1qU.js';
+import './chunks/runtime-console.iCAG0Yz3.js';
 import 'node:stream';
-import './vendor-date.6e993429.js';
-import './vendor-tasks.f9d75aed.js';
+import './vendor/date.W90-E5kF.js';
+import './vendor/tasks.IknbGB2n.js';
 import 'node:module';
 
 const cli = cac("vitest");
-cli.version(version).option("-r, --root <path>", "Root path").option("-c, --config <path>", "Path to config file").option("-u, --update", "Update snapshot").option("-w, --watch", "Enable watch mode").option("-t, --testNamePattern <pattern>", "Run tests with full names matching the specified regexp pattern").option("--dir <path>", "Base directory to scan for the test files").option("--ui", "Enable UI").option("--open", "Open UI automatically (default: !process.env.CI))").option("--api [api]", "Serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--silent", "Silent console output from tests").option("--hideSkippedTests", "Hide logs for skipped tests").option("--reporter <name>", "Specify reporters").option("--outputFile <filename/-s>", "Write test results to a file when supporter reporter is also specified, use cac's dot notation for individual outputs of multiple reporters").option("--coverage", "Enable coverage report").option("--run", "Disable watch mode").option("--mode <name>", "Override Vite mode (default: test)").option("--globals", "Inject apis globally").option("--dom", "Mock browser api with happy-dom").option("--browser [options]", "Run tests in the browser (default: false)").option("--pool <pool>", "Specify pool, if not running in the browser (default: threads)").option("--poolOptions <options>", "Specify pool options").option("--poolOptions.threads.isolate", "Isolate tests in threads pool (default: true)").option("--poolOptions.forks.isolate", "Isolate tests in forks pool (default: true)").option("--environment <env>", "Specify runner environment, if not running in the browser (default: node)").option("--passWithNoTests", "Pass when no tests found").option("--logHeapUsage", "Show the size of heap for each test").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--dangerouslyIgnoreUnhandledErrors", "Ignore any unhandled errors that occur").option("--shard <shard>", "Test suite shard to execute in a format of <index>/<count>").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").option("--sequence <options>", "Define in what order to run tests (use --sequence.shuffle to run tests in random order, use --sequence.concurrent to run tests in parallel)").option("--segfaultRetry <times>", "Return tests on segment fault (default: 0)", { default: 0 }).option("--no-color", "Removes colors from the console output").option("--inspect", "Enable Node.js inspector").option("--inspect-brk", "Enable Node.js inspector with break").option("--test-timeout <time>", "Default timeout of a test in milliseconds (default: 5000)").option("--bail <number>", "Stop test execution when given number of tests have failed", { default: 0 }).option("--retry <times>", "Retry the test specific number of times if it fails", { default: 0 }).option("--diff <path>", "Path to a diff config that will be used to generate diff interface").option("--typecheck [options]", "Custom options for typecheck pool").option("--typecheck.enabled", "Enable typechecking alongside tests (default: false)").option("--typecheck.only", "Run only typecheck tests. This automatically enables typecheck (default: false)").help();
+cli.version(version).option("-r, --root <path>", "Root path").option("-c, --config <path>", "Path to config file").option("-u, --update", "Update snapshot").option("-w, --watch", "Enable watch mode").option("-t, --testNamePattern <pattern>", "Run tests with full names matching the specified regexp pattern").option("--dir <path>", "Base directory to scan for the test files").option("--ui", "Enable UI").option("--open", "Open UI automatically (default: !process.env.CI))").option("--api [api]", "Serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--silent", "Silent console output from tests").option("--hideSkippedTests", "Hide logs for skipped tests").option("--reporter <name>", "Specify reporters").option("--outputFile <filename/-s>", "Write test results to a file when supporter reporter is also specified, use cac's dot notation for individual outputs of multiple reporters").option("--coverage", "Enable coverage report").option("--run", "Disable watch mode").option("--mode <name>", "Override Vite mode (default: test)").option("--globals", "Inject apis globally").option("--dom", "Mock browser api with happy-dom").option("--browser [options]", "Run tests in the browser (default: false)").option("--pool <pool>", "Specify pool, if not running in the browser (default: threads)").option("--poolOptions <options>", "Specify pool options").option("--poolOptions.threads.isolate", "Isolate tests in threads pool (default: true)").option("--poolOptions.forks.isolate", "Isolate tests in forks pool (default: true)").option("--environment <env>", "Specify runner environment, if not running in the browser (default: node)").option("--passWithNoTests", "Pass when no tests found").option("--logHeapUsage", "Show the size of heap for each test").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--dangerouslyIgnoreUnhandledErrors", "Ignore any unhandled errors that occur").option("--shard <shard>", "Test suite shard to execute in a format of <index>/<count>").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").option("--sequence <options>", "Define in what order to run tests (use --sequence.shuffle to run tests in random order, use --sequence.concurrent to run tests in parallel)").option("--segfaultRetry <times>", "Return tests on segment fault (default: 0)", { default: 0 }).option("--no-color", "Removes colors from the console output").option("--inspect", "Enable Node.js inspector").option("--inspect-brk", "Enable Node.js inspector with break").option("--test-timeout <time>", "Default timeout of a test in milliseconds (default: 5000)").option("--bail <number>", "Stop test execution when given number of tests have failed (default: 0)").option("--retry <times>", "Retry the test specific number of times if it fails (default: 0)").option("--diff <path>", "Path to a diff config that will be used to generate diff interface").option("--expand-snapshot-diff", "Show full diff when snapshot fails").option("--typecheck [options]", "Custom options for typecheck pool").option("--typecheck.enabled", "Enable typechecking alongside tests (default: false)").option("--typecheck.only", "Run only typecheck tests. This automatically enables typecheck (default: false)").help();
 cli.command("run [...filters]").action(run);
 cli.command("related [...filters]").action(runRelated);
 cli.command("watch [...filters]").action(watch);
 cli.command("dev [...filters]").action(watch);
 cli.command("bench [...filters]").action(benchmark);
+cli.command("typecheck [...filters]").action(() => {
+  throw new Error(`Running typecheck via "typecheck" command is removed. Please use "--typecheck" to run your regular tests alongside typechecking, or "--typecheck.only" to run only typecheck tests.`);
+});
 cli.command("[...filters]").action((filters, options) => start("test", filters, options));
 try {
   cli.parse();

package/dist/config.cjs

@@ -11,6 +11,7 @@ const defaultExclude = ["**/node_modules/**", "**/dist/**", "**/cypress/**", "**
 const defaultCoverageExcludes = [
   "coverage/**",
   "dist/**",
+  "**/[.]**",
   "packages/*/test?(s)/**",
   "**/*.d.ts",
   "**/virtual:*",
@@ -77,7 +78,7 @@ const config = {
   api: false,
   ui: false,
   uiBase: "/__vitest__/",
-  open: true,
+  open: !stdEnv.isCI,
   css: {
     include: []
   },