vitest 0.9.2 → 0.10.0

package/LICENSE.md

@@ -465,6 +465,13 @@ Repository: git://github.com/kpdecker/jsdiff.git
 
 ---------------------------------------
 
+## eastasianwidth
+License: MIT
+By: Masaki Komagata
+Repository: git://github.com/komagata/eastasianwidth.git
+
+---------------------------------------
+
 ## emoji-regex
 License: MIT
 By: Mathias Bynens

package/dist/{chunk-api-setup.7290422e.js → chunk-api-setup.d70fc960.js}

@@ -1,5 +1,5 @@
 import { promises } from 'fs';
-import { c as createBirpc } from './chunk-vite-node-utils.7f0053fb.js';
+import { c as createBirpc } from './chunk-vite-node-utils.33447cc0.js';
 import require$$0$1 from 'stream';
 import require$$0 from 'zlib';
 import require$$3 from 'net';
@@ -9,14 +9,14 @@ import require$$2 from 'events';
 import require$$1 from 'https';
 import require$$2$1 from 'http';
 import url from 'url';
-import { A as API_PATH } from './chunk-constants.e59013dc.js';
-import { r as interpretSourcePos, b as parseStacktrace } from './chunk-utils-timers.4800834c.js';
+import { A as API_PATH } from './chunk-constants.d540b1d1.js';
+import { r as interpretSourcePos, b as parseStacktrace } from './chunk-utils-timers.12bc05d1.js';
 import 'module';
 import 'vm';
-import './chunk-utils-global.10dcdfa6.js';
-import 'path';
+import './chunk-utils-global.37a7c822.js';
 import 'tty';
 import 'local-pkg';
+import 'path';
 import 'assert';
 import 'util';
 

package/dist/{chunk-constants.e59013dc.js → chunk-constants.d540b1d1.js}

@@ -1,5 +1,5 @@
 import { fileURLToPath } from 'url';
-import { w as resolve } from './chunk-utils-global.10dcdfa6.js';
+import { k as resolve } from './chunk-utils-global.37a7c822.js';
 
 const distDir = resolve(fileURLToPath(import.meta.url), "../../dist");
 const defaultPort = 51204;

package/dist/{chunk-defaults.9aa0ce42.js → chunk-defaults.04d5d90b.js}

@@ -1,7 +1,7 @@
 import { existsSync, promises } from 'fs';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
-import { t as toArray, w as resolve } from './chunk-utils-global.10dcdfa6.js';
+import { t as toArray, k as resolve } from './chunk-utils-global.37a7c822.js';
 
 const defaultInclude = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
 const defaultExclude = ["**/node_modules/**", "**/dist/**", "**/cypress/**", "**/.{idea,git,cache,output,temp}/**"];

package/dist/{chunk-install-pkg.7dd40977.js → chunk-install-pkg.73b84ae1.js}

@@ -2,9 +2,9 @@ import path$2 from 'path';
 import fs$2 from 'fs';
 import require$$0 from 'util';
 import childProcess$1 from 'child_process';
-import { p as pathKey, s as signalExit, m as mergeStream$1, b as getStream$1, d as crossSpawn$1, e as onetime$1 } from './vendor-index.87b2fc14.js';
+import { p as pathKey, s as signalExit, m as mergeStream$1, g as getStream$1, c as crossSpawn$1, o as onetime$1 } from './vendor-index.40be925a.js';
 import require$$0$1 from 'os';
-import './vendor-_commonjsHelpers.34b404ce.js';
+import './vendor-_commonjsHelpers.addc3445.js';
 import 'assert';
 import 'events';
 import 'buffer';
@@ -298,99 +298,99 @@ pathExists.exports.sync = path => {
 };
 
 (function (module) {
-const path = path$2;
-const locatePath$1 = locatePath.exports;
-const pathExists$1 = pathExists.exports;
+	const path = path$2;
+	const locatePath$1 = locatePath.exports;
+	const pathExists$1 = pathExists.exports;
 
-const stop = Symbol('findUp.stop');
+	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);
+	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$1(paths, locateOptions);
-		}
+		const runMatcher = async locateOptions => {
+			if (typeof name !== 'function') {
+				return locatePath$1(paths, locateOptions);
+			}
 
-		const foundPath = await name(locateOptions.cwd);
-		if (typeof foundPath === 'string') {
-			return locatePath$1([foundPath], locateOptions);
-		}
+			const foundPath = await name(locateOptions.cwd);
+			if (typeof foundPath === 'string') {
+				return locatePath$1([foundPath], locateOptions);
+			}
 
-		return foundPath;
-	};
+			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});
+		// 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 === stop) {
+				return;
+			}
 
-		if (foundPath) {
-			return path.resolve(directory, foundPath);
-		}
+			if (foundPath) {
+				return path.resolve(directory, foundPath);
+			}
 
-		if (directory === root) {
-			return;
+			if (directory === root) {
+				return;
+			}
+
+			directory = path.dirname(directory);
 		}
+	};
 
-		directory = path.dirname(directory);
-	}
-};
+	module.exports.sync = (name, options = {}) => {
+		let directory = path.resolve(options.cwd || '');
+		const {root} = path.parse(directory);
+		const paths = [].concat(name);
 
-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$1.sync(paths, locateOptions);
+			}
 
-	const runMatcher = locateOptions => {
-		if (typeof name !== 'function') {
-			return locatePath$1.sync(paths, locateOptions);
-		}
+			const foundPath = name(locateOptions.cwd);
+			if (typeof foundPath === 'string') {
+				return locatePath$1.sync([foundPath], locateOptions);
+			}
 
-		const foundPath = name(locateOptions.cwd);
-		if (typeof foundPath === 'string') {
-			return locatePath$1.sync([foundPath], locateOptions);
-		}
+			return foundPath;
+		};
 
-		return foundPath;
-	};
+		// eslint-disable-next-line no-constant-condition
+		while (true) {
+			const foundPath = runMatcher({...options, cwd: directory});
 
-	// eslint-disable-next-line no-constant-condition
-	while (true) {
-		const foundPath = runMatcher({...options, cwd: directory});
+			if (foundPath === stop) {
+				return;
+			}
 
-		if (foundPath === stop) {
-			return;
-		}
+			if (foundPath) {
+				return path.resolve(directory, foundPath);
+			}
 
-		if (foundPath) {
-			return path.resolve(directory, foundPath);
-		}
+			if (directory === root) {
+				return;
+			}
 
-		if (directory === root) {
-			return;
+			directory = path.dirname(directory);
 		}
+	};
 
-		directory = path.dirname(directory);
-	}
-};
-
-module.exports.exists = pathExists$1;
+	module.exports.exists = pathExists$1;
 
-module.exports.sync.exists = pathExists$1.sync;
+	module.exports.sync.exists = pathExists$1.sync;
 
-module.exports.stop = stop;
-}(findUp$1));
+	module.exports.stop = stop;
+} (findUp$1));
 
 var findUp = findUp$1.exports;
 
-var execa$2 = {exports: {}};
+var execa$1 = {exports: {}};
 
 var stripFinalNewline$1 = input => {
 	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
@@ -410,53 +410,53 @@ var stripFinalNewline$1 = input => {
 var npmRunPath$1 = {exports: {}};
 
 (function (module) {
-const path = path$2;
-const pathKey$1 = pathKey.exports;
-
-const npmRunPath = options => {
-	options = {
-		cwd: process.cwd(),
-		path: process.env[pathKey$1()],
-		execPath: process.execPath,
-		...options
-	};
+	const path = path$2;
+	const pathKey$1 = pathKey.exports;
+
+	const npmRunPath = options => {
+		options = {
+			cwd: process.cwd(),
+			path: process.env[pathKey$1()],
+			execPath: process.execPath,
+			...options
+		};
 
-	let previous;
-	let cwdPath = path.resolve(options.cwd);
-	const result = [];
+		let previous;
+		let cwdPath = path.resolve(options.cwd);
+		const result = [];
 
-	while (previous !== cwdPath) {
-		result.push(path.join(cwdPath, 'node_modules/.bin'));
-		previous = cwdPath;
-		cwdPath = path.resolve(cwdPath, '..');
-	}
+		while (previous !== cwdPath) {
+			result.push(path.join(cwdPath, 'node_modules/.bin'));
+			previous = cwdPath;
+			cwdPath = path.resolve(cwdPath, '..');
+		}
 
-	// Ensure the running `node` binary is used
-	const execPathDir = path.resolve(options.cwd, options.execPath, '..');
-	result.push(execPathDir);
+		// Ensure the running `node` binary is used
+		const execPathDir = path.resolve(options.cwd, options.execPath, '..');
+		result.push(execPathDir);
 
-	return result.concat(options.path).join(path.delimiter);
-};
+		return result.concat(options.path).join(path.delimiter);
+	};
 
-module.exports = npmRunPath;
-// TODO: Remove this for the next major release
-module.exports.default = npmRunPath;
+	module.exports = npmRunPath;
+	// TODO: Remove this for the next major release
+	module.exports.default = npmRunPath;
 
-module.exports.env = options => {
-	options = {
-		env: process.env,
-		...options
-	};
+	module.exports.env = options => {
+		options = {
+			env: process.env,
+			...options
+		};
 
-	const env = {...options.env};
-	const path = pathKey$1({env});
+		const env = {...options.env};
+		const path = pathKey$1({env});
 
-	options.path = env[path];
-	env[path] = module.exports(options);
+		options.path = env[path];
+		env[path] = module.exports(options);
 
-	return env;
-};
-}(npmRunPath$1));
+		return env;
+	};
+} (npmRunPath$1));
 
 var main = {};
 
@@ -1501,9 +1501,9 @@ const execa = (file, args, options) => {
 	return mergePromise(spawned, handlePromiseOnce);
 };
 
-execa$2.exports = execa;
+execa$1.exports = execa;
 
-execa$2.exports.sync = (file, args, options) => {
+execa$1.exports.sync = (file, args, options) => {
 	const parsed = handleArguments(file, args, options);
 	const command = joinCommand(file, args);
 	const escapedCommand = getEscapedCommand(file, args);
@@ -1566,17 +1566,17 @@ execa$2.exports.sync = (file, args, options) => {
 	};
 };
 
-execa$2.exports.command = (command, options) => {
+execa$1.exports.command = (command, options) => {
 	const [file, ...args] = parseCommand(command);
 	return execa(file, args, options);
 };
 
-execa$2.exports.commandSync = (command, options) => {
+execa$1.exports.commandSync = (command, options) => {
 	const [file, ...args] = parseCommand(command);
 	return execa.sync(file, args, options);
 };
 
-execa$2.exports.node = (scriptPath, args, options = {}) => {
+execa$1.exports.node = (scriptPath, args, options = {}) => {
 	if (args && !Array.isArray(args) && typeof args === 'object') {
 		options = args;
 		args = [];
@@ -1608,8 +1608,6 @@ execa$2.exports.node = (scriptPath, args, options = {}) => {
 	);
 };
 
-var execa$1 = execa$2.exports;
-
 // src/detect.ts
 var LOCKS = {
   "pnpm-lock.yaml": "pnpm",
@@ -1628,7 +1626,7 @@ async function installPackage(names, options = {}) {
   const args = options.additionalArgs || [];
   if (options.preferOffline)
     args.unshift("--prefer-offline");
-  return execa$1(agent, [
+  return execa$1.exports(agent, [
     agent === "yarn" ? "add" : "install",
     options.dev ? "-D" : "",
     ...args,

package/dist/chunk-integrations-globals.d2c09cd2.js

@@ -0,0 +1,29 @@
+import { g as globalApis } from './chunk-constants.d540b1d1.js';
+import { i as index } from './vendor-entry.369fd6c9.js';
+import 'url';
+import './chunk-utils-global.37a7c822.js';
+import 'tty';
+import 'local-pkg';
+import 'path';
+import 'fs';
+import 'console';
+import 'stream';
+import './chunk-runtime-chain.f863f182.js';
+import 'chai';
+import './vendor-_commonjsHelpers.addc3445.js';
+import './chunk-runtime-rpc.8f648236.js';
+import './chunk-utils-timers.12bc05d1.js';
+import './chunk-integrations-spy.f036df6f.js';
+import 'tinyspy';
+import 'util';
+import './chunk-defaults.04d5d90b.js';
+import 'module';
+import 'crypto';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = index[api];
+  });
+}
+
+export { registerApiGlobally };

package/dist/chunk-integrations-spy.f036df6f.js

@@ -0,0 +1,102 @@
+import * as tinyspy from 'tinyspy';
+
+const spies = /* @__PURE__ */ new Set();
+function isMockFunction(fn2) {
+  return typeof fn2 === "function" && "_isMockFunction" in fn2 && fn2._isMockFunction;
+}
+function spyOn(obj, method, accessType) {
+  const dictionary = {
+    get: "getter",
+    set: "setter"
+  };
+  const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
+  const stub = tinyspy.spyOn(obj, objMethod);
+  return enhanceSpy(stub);
+}
+let callOrder = 0;
+function enhanceSpy(spy) {
+  const stub = spy;
+  let implementation;
+  let instances = [];
+  let invocations = [];
+  const mockContext = {
+    get calls() {
+      return stub.calls;
+    },
+    get instances() {
+      return instances;
+    },
+    get invocationCallOrder() {
+      return invocations;
+    },
+    get results() {
+      return stub.results.map(([callType, value]) => {
+        const type = callType === "error" ? "throw" : "return";
+        return { type, value };
+      });
+    },
+    get lastCall() {
+      return stub.calls.at(-1);
+    }
+  };
+  let onceImplementations = [];
+  let name = stub.name;
+  stub.getMockName = () => name || "vi.fn()";
+  stub.mockName = (n) => {
+    name = n;
+    return stub;
+  };
+  stub.mockClear = () => {
+    stub.reset();
+    instances = [];
+    invocations = [];
+    return stub;
+  };
+  stub.mockReset = () => {
+    stub.mockClear();
+    implementation = () => void 0;
+    onceImplementations = [];
+    return stub;
+  };
+  stub.mockRestore = () => {
+    stub.mockReset();
+    implementation = void 0;
+    return stub;
+  };
+  stub.getMockImplementation = () => implementation;
+  stub.mockImplementation = (fn2) => {
+    implementation = fn2;
+    return stub;
+  };
+  stub.mockImplementationOnce = (fn2) => {
+    onceImplementations.push(fn2);
+    return stub;
+  };
+  stub.mockReturnThis = () => stub.mockImplementation(function() {
+    return this;
+  });
+  stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
+  stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
+  stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
+  stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
+  stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
+  stub.mockRejectedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.reject(val));
+  Object.defineProperty(stub, "mock", {
+    get: () => mockContext
+  });
+  stub.willCall(function(...args) {
+    instances.push(this);
+    invocations.push(++callOrder);
+    const impl = onceImplementations.shift() || implementation || stub.getOriginal() || (() => {
+    });
+    return impl.apply(this, args);
+  });
+  spies.add(stub);
+  return stub;
+}
+function fn(implementation) {
+  return enhanceSpy(tinyspy.spyOn({ fn: implementation || (() => {
+  }) }, "fn"));
+}
+
+export { spies as a, fn as f, isMockFunction as i, spyOn as s };