vitest 0.22.1 → 0.23.0

package/dist/chunk-integrations-coverage.99c020eb.mjs

@@ -0,0 +1,166 @@
+import { importModule } from 'local-pkg';
+
+/*
+How it works:
+`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+*/
+
+class Node {
+	value;
+	next;
+
+	constructor(value) {
+		this.value = value;
+	}
+}
+
+class Queue {
+	#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;
+		}
+	}
+}
+
+function pLimit(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_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(undefined, 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;
+}
+
+const CoverageProviderMap = {
+  c8: "@vitest/coverage-c8",
+  istanbul: "@vitest/coverage-istanbul"
+};
+async function resolveCoverageProvider(provider) {
+  if (typeof provider === "string") {
+    const pkg = CoverageProviderMap[provider];
+    if (!pkg)
+      throw new Error(`Unknown coverage provider: ${provider}`);
+    return await importModule(pkg);
+  } else {
+    return provider;
+  }
+}
+async function getCoverageProvider(options) {
+  if ((options == null ? void 0 : options.enabled) && (options == null ? void 0 : options.provider)) {
+    const { getProvider } = await resolveCoverageProvider(options.provider);
+    return await getProvider();
+  }
+  return null;
+}
+async function takeCoverageInsideWorker(options) {
+  if (options.enabled && options.provider) {
+    const { takeCoverage } = await resolveCoverageProvider(options.provider);
+    return await (takeCoverage == null ? void 0 : takeCoverage());
+  }
+}
+
+export { CoverageProviderMap as C, getCoverageProvider as g, pLimit as p, takeCoverageInsideWorker as t };

package/dist/{chunk-integrations-globals.60af7da3.mjs → chunk-integrations-globals.ef598c23.mjs}

@@ -1,19 +1,18 @@
-import { k as globalApis } from './chunk-constants.71e8a211.mjs';
-import { i as index } from './chunk-runtime-hooks.5d7073db.mjs';
+import { k as globalApis } from './chunk-constants.6196597b.mjs';
+import { i as index } from './chunk-runtime-hooks.75ce0575.mjs';
 import 'tty';
 import 'url';
 import 'path';
-import './chunk-runtime-chain.be610650.mjs';
+import './chunk-runtime-chain.2af36ddf.mjs';
 import 'util';
-import './chunk-mock-date.304e29b1.mjs';
+import './chunk-mock-date.0d86eaa5.mjs';
 import 'local-pkg';
 import 'chai';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.57586b73.mjs';
-import './chunk-utils-global.fa20c2f6.mjs';
+import './chunk-runtime-rpc.3fe371e9.mjs';
 import './chunk-utils-timers.b48455ed.mjs';
 import 'fs';
-import './chunk-utils-source-map.bbf3ad19.mjs';
+import './chunk-utils-source-map.70ee97e1.mjs';
 import './spy.mjs';
 import 'tinyspy';
 

package/dist/{chunk-magic-string.efe26975.mjs → chunk-magic-string.56b2b543.mjs}

@@ -219,15 +219,20 @@ class Chunk {
 	}
 }
 
-let btoa = () => {
-	throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
-};
-if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
-	btoa = (str) => window.btoa(unescape(encodeURIComponent(str)));
-} else if (typeof Buffer === 'function') {
-	btoa = (str) => Buffer.from(str, 'utf-8').toString('base64');
+function getBtoa () {
+	if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
+		return (str) => window.btoa(unescape(encodeURIComponent(str)));
+	} else if (typeof Buffer === 'function') {
+		return (str) => Buffer.from(str, 'utf-8').toString('base64');
+	} else {
+		return () => {
+			throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+		};
+	}
 }
 
+const btoa = /*#__PURE__*/ getBtoa();
+
 class SourceMap {
 	constructor(properties) {
 		this.version = 3;
@@ -419,7 +424,7 @@ class MagicString {
 			indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
 			sourcemapLocations: { writable: true, value: new BitSet() },
 			storedNames: { writable: true, value: {} },
-			indentStr: { writable: true, value: guessIndent(string) },
+			indentStr: { writable: true, value: undefined },
 		});
 
 		this.byStart[0] = chunk;
@@ -549,7 +554,19 @@ class MagicString {
 		return new SourceMap(this.generateDecodedMap(options));
 	}
 
+	_ensureindentStr() {
+		if (this.indentStr === undefined) {
+			this.indentStr = guessIndent(this.original);
+		}
+	}
+
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+
 	getIndentString() {
+		this._ensureindentStr();
 		return this.indentStr === null ? '\t' : this.indentStr;
 	}
 
@@ -561,7 +578,10 @@ class MagicString {
 			indentStr = undefined;
 		}
 
-		indentStr = indentStr !== undefined ? indentStr : this.indentStr || '\t';
+		if (indentStr === undefined) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || '\t';
+		}
 
 		if (indentStr === '') return this; // noop
 
@@ -1277,7 +1297,7 @@ class Bundle {
 		const indentStringCounts = {};
 
 		this.sources.forEach((source) => {
-			const indentStr = source.content.indentStr;
+			const indentStr = source.content._getRawIndentString();
 
 			if (indentStr === null) return;
 

package/dist/{chunk-mock-date.304e29b1.mjs → chunk-mock-date.0d86eaa5.mjs}

@@ -1,5 +1,5 @@
 import { relative } from 'path';
-import { r as relative$1, p as picocolors, E as EXIT_CODE_RESTART } from './chunk-constants.71e8a211.mjs';
+import { r as relative$1, p as picocolors, E as EXIT_CODE_RESTART } from './chunk-constants.6196597b.mjs';
 import { isPackageExists } from 'local-pkg';
 
 const RealDate = Date;
@@ -178,14 +178,17 @@ function shuffle(array, seed = RealDate.now()) {
   return array;
 }
 
+function isAtomTest(s) {
+  return s.type === "test" || s.type === "benchmark";
+}
 function getTests(suite) {
-  return toArray(suite).flatMap((s) => s.type === "test" ? [s] : s.tasks.flatMap((c) => c.type === "test" ? [c] : getTests(c)));
+  return toArray(suite).flatMap((s) => isAtomTest(s) ? [s] : s.tasks.flatMap((c) => isAtomTest(c) ? [c] : getTests(c)));
 }
 function getSuites(suite) {
   return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
 }
 function hasTests(suite) {
-  return toArray(suite).some((s) => s.tasks.some((c) => c.type === "test" || hasTests(c)));
+  return toArray(suite).some((s) => s.tasks.some((c) => isAtomTest(c) || hasTests(c)));
 }
 function hasFailed(suite) {
   return toArray(suite).some((s) => {
@@ -211,10 +214,17 @@ function getNames(task) {
   return names;
 }
 
+function getWorkerState() {
+  return globalThis.__vitest_worker__;
+}
+
 var _a;
 const isNode = typeof process < "u" && typeof process.stdout < "u" && !((_a = process.versions) == null ? void 0 : _a.deno) && !globalThis.window;
 const isBrowser = typeof window !== "undefined";
 const isWindows = isNode && process.platform === "win32";
+const getRunMode = () => getWorkerState().config.mode;
+const isRunningInTest = () => getRunMode() === "test";
+const isRunningInBenchmark = () => getRunMode() === "benchmark";
 const relativePath = isBrowser ? relative : relative$1;
 function partitionSuiteChildren(suite) {
   let tasksGroup = [];
@@ -263,7 +273,7 @@ async function ensurePackageInstalled(dependency, root) {
     message: picocolors.exports.reset(`Do you want to install ${picocolors.exports.green(dependency)}?`)
   });
   if (install) {
-    await (await import('./chunk-install-pkg.3aa3eae6.mjs')).installPackage(dependency, { dev: true });
+    await (await import('./chunk-install-pkg.e081fc1b.mjs')).installPackage(dependency, { dev: true });
     process.stderr.write(picocolors.exports.yellow(`
 Package ${dependency} installed, re-run the command to start.
 `));
@@ -307,5 +317,16 @@ class AggregateErrorPonyfill extends Error {
     this.errors = [...errors];
   }
 }
+function createDefer() {
+  let resolve2 = null;
+  let reject = null;
+  const p = new Promise((_resolve, _reject) => {
+    resolve2 = _resolve;
+    reject = _reject;
+  });
+  p.resolve = resolve2;
+  p.reject = reject;
+  return p;
+}
 
-export { AggregateErrorPonyfill as A, stdout as B, isWindows as C, mergeSlashes as D, getAllMockableProperties as E, RealDate as R, resetModules as a, getNames as b, assertTypes as c, getFullName as d, notNullish as e, deepClone as f, getCallLastIndex as g, getType as h, isObject as i, isNode as j, relativePath as k, isBrowser as l, mockDate as m, noop as n, shuffle as o, partitionSuiteChildren as p, hasTests as q, resetDate as r, slash as s, toArray as t, hasFailed as u, getTests as v, hasFailedSnapshot as w, getSuites as x, deepMerge as y, ensurePackageInstalled as z };
+export { AggregateErrorPonyfill as A, hasFailedSnapshot as B, getSuites as C, deepMerge as D, ensurePackageInstalled as E, stdout as F, isWindows as G, mergeSlashes as H, getAllMockableProperties as I, RealDate as R, resetModules as a, getCallLastIndex as b, getNames as c, assertTypes as d, getFullName as e, isRunningInTest as f, getWorkerState as g, isRunningInBenchmark as h, isObject as i, notNullish as j, deepClone as k, getType as l, mockDate as m, noop as n, isNode as o, relativePath as p, isBrowser as q, resetDate as r, slash as s, toArray as t, partitionSuiteChildren as u, shuffle as v, hasTests as w, hasFailed as x, createDefer as y, getTests as z };

package/dist/{chunk-node-git.9a7e3153.mjs → chunk-node-git.6f289b0a.mjs}

@@ -1,18 +1,18 @@
-import { a as resolve } from './chunk-constants.71e8a211.mjs';
-import { e as execa } from './vendor-index.fbec8a81.mjs';
+import { a as resolve } from './chunk-constants.6196597b.mjs';
+import { e as execa } from './vendor-index.4aeeb598.mjs';
 import 'tty';
 import 'url';
 import 'path';
 import 'buffer';
 import 'child_process';
 import 'process';
-import './vendor-index.2ae8040a.mjs';
+import './vendor-index.62ce5c33.mjs';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
 import 'fs';
 import 'stream';
 import 'util';
 import 'os';
-import './vendor-index.29636037.mjs';
+import './vendor-index.731a22f2.mjs';
 import 'assert';
 import 'events';
 
@@ -51,18 +51,24 @@ class VitestGit {
     return [...staged, ...unstaged];
   }
   getFilesSince(hash) {
-    return this.resolveFilesWithGitCommand(["diff", "--name-only", `${hash}...HEAD`]);
+    return this.resolveFilesWithGitCommand(
+      ["diff", "--name-only", `${hash}...HEAD`]
+    );
   }
   getStagedFiles() {
-    return this.resolveFilesWithGitCommand(["diff", "--cached", "--name-only"]);
+    return this.resolveFilesWithGitCommand(
+      ["diff", "--cached", "--name-only"]
+    );
   }
   getUnstagedFiles() {
-    return this.resolveFilesWithGitCommand([
-      "ls-files",
-      "--other",
-      "--modified",
-      "--exclude-standard"
-    ]);
+    return this.resolveFilesWithGitCommand(
+      [
+        "ls-files",
+        "--other",
+        "--modified",
+        "--exclude-standard"
+      ]
+    );
   }
   async getRoot(cwd) {
     const options = ["rev-parse", "--show-cdup"];