vitest 0.9.4 → 0.10.2

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.49283db8.js → chunk-api-setup.b55307fb.js}

@@ -1,5 +1,5 @@
 import { promises } from 'fs';
-import { c as createBirpc } from './chunk-vite-node-utils.b4debb0b.js';
+import { c as createBirpc } from './chunk-vite-node-utils.c160b239.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.c8f1d38c.js';
-import { r as interpretSourcePos, b as parseStacktrace } from './chunk-utils-timers.b26e7c5c.js';
+import { A as API_PATH } from './chunk-constants.90075174.js';
+import { r as interpretSourcePos, b as parseStacktrace } from './chunk-utils-timers.c50fec92.js';
 import 'module';
 import 'vm';
-import './chunk-utils-global.a3293dce.js';
-import 'path';
+import './chunk-utils-global.9b434e81.js';
 import 'tty';
 import 'local-pkg';
+import 'path';
 import 'assert';
 import 'util';
 
@@ -2526,10 +2526,11 @@ const {
 const { format, parse: parse$1 } = extension$1;
 const { toBuffer } = bufferUtil$1.exports;
 
+const closeTimeout = 30 * 1000;
+const kAborted = Symbol('kAborted');
+const protocolVersions = [8, 13];
 const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
 const subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-const protocolVersions = [8, 13];
-const closeTimeout = 30 * 1000;
 
 /**
  * Class representing a WebSocket.
@@ -3143,7 +3144,7 @@ function initAsClient(websocket, address, protocols, options) {
     hostname: undefined,
     protocol: undefined,
     timeout: undefined,
-    method: undefined,
+    method: 'GET',
     host: undefined,
     path: undefined,
     port: undefined
@@ -3197,7 +3198,7 @@ function initAsClient(websocket, address, protocols, options) {
 
   const defaultPort = isSecure ? 443 : 80;
   const key = randomBytes(16).toString('base64');
-  const get = isSecure ? https.get : http$1.get;
+  const request = isSecure ? https.request : http$1.request;
   const protocolSet = new Set();
   let perMessageDeflate;
 
@@ -3262,6 +3263,8 @@ function initAsClient(websocket, address, protocols, options) {
     opts.path = parts[1];
   }
 
+  let req;
+
   if (opts.followRedirects) {
     if (websocket._redirects === 0) {
       websocket._originalHost = parsedUrl.host;
@@ -3279,7 +3282,10 @@ function initAsClient(websocket, address, protocols, options) {
           options.headers[key.toLowerCase()] = value;
         }
       }
-    } else if (parsedUrl.host !== websocket._originalHost) {
+    } else if (
+      websocket.listenerCount('redirect') === 0 &&
+      parsedUrl.host !== websocket._originalHost
+    ) {
       //
       // Match curl 7.77.0 behavior and drop the following headers. These
       // headers are also dropped when following a redirect to a subdomain.
@@ -3299,9 +3305,24 @@ function initAsClient(websocket, address, protocols, options) {
       options.headers.authorization =
         'Basic ' + Buffer.from(opts.auth).toString('base64');
     }
-  }
 
-  let req = (websocket._req = get(opts));
+    req = websocket._req = request(opts);
+
+    if (websocket._redirects) {
+      //
+      // Unlike what is done for the `'upgrade'` event, no early exit is
+      // triggered here if the user calls `websocket.close()` or
+      // `websocket.terminate()` from a listener of the `'redirect'` event. This
+      // is because the user can also call `request.destroy()` with an error
+      // before calling `websocket.close()` or `websocket.terminate()` and this
+      // would result in an error being emitted on the `request` object with no
+      // `'error'` event listeners attached.
+      //
+      websocket.emit('redirect', websocket.url, req);
+    }
+  } else {
+    req = websocket._req = request(opts);
+  }
 
   if (opts.timeout) {
     req.on('timeout', () => {
@@ -3310,7 +3331,7 @@ function initAsClient(websocket, address, protocols, options) {
   }
 
   req.on('error', (err) => {
-    if (req === null || req.aborted) return;
+    if (req === null || req[kAborted]) return;
 
     req = websocket._req = null;
     emitErrorAndClose(websocket, err);
@@ -3357,8 +3378,8 @@ function initAsClient(websocket, address, protocols, options) {
     websocket.emit('upgrade', res);
 
     //
-    // The user may have closed the connection from a listener of the `upgrade`
-    // event.
+    // The user may have closed the connection from a listener of the
+    // `'upgrade'` event.
     //
     if (websocket.readyState !== WebSocket$1.CONNECTING) return;
 
@@ -3443,10 +3464,12 @@ function initAsClient(websocket, address, protocols, options) {
       skipUTF8Validation: opts.skipUTF8Validation
     });
   });
+
+  req.end();
 }
 
 /**
- * Emit the `'error'` and `'close'` event.
+ * Emit the `'error'` and `'close'` events.
  *
  * @param {WebSocket} websocket The WebSocket instance
  * @param {Error} The error to emit
@@ -3503,6 +3526,7 @@ function abortHandshake$1(websocket, stream, message) {
   Error.captureStackTrace(err, abortHandshake$1);
 
   if (stream.setHeader) {
+    stream[kAborted] = true;
     stream.abort();
 
     if (stream.socket && !stream.socket.destroyed) {
@@ -3514,8 +3538,7 @@ function abortHandshake$1(websocket, stream, message) {
       stream.socket.destroy();
     }
 
-    stream.once('abort', websocket.emitClose.bind(websocket));
-    websocket.emit('error', err);
+    process.nextTick(emitErrorAndClose, websocket, err);
   } else {
     stream.destroy(err);
     stream.once('error', websocket.emit.bind(websocket, 'error'));

package/dist/{chunk-constants.c8f1d38c.js → chunk-constants.90075174.js}

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

package/dist/{chunk-defaults.43e746f3.js → chunk-defaults.fd5b939d.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.a3293dce.js';
+import { t as toArray, k as resolve } from './chunk-utils-global.9b434e81.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.cbf3a38b.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, a as signalExit, m as mergeStream$1, b as getStream$1, d as crossSpawn$1, e as onetime$1 } from './vendor-index.bd255bc8.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.16d9702f.js

@@ -0,0 +1,29 @@
+import { g as globalApis } from './chunk-constants.90075174.js';
+import { i as index } from './vendor-entry.17835032.js';
+import 'url';
+import './chunk-utils-global.9b434e81.js';
+import 'tty';
+import 'local-pkg';
+import 'path';
+import 'fs';
+import 'console';
+import 'stream';
+import './chunk-runtime-chain.6292a3de.js';
+import 'chai';
+import './vendor-_commonjsHelpers.addc3445.js';
+import './chunk-runtime-rpc.8e14ae4f.js';
+import './chunk-utils-timers.c50fec92.js';
+import './chunk-integrations-spy.f036df6f.js';
+import 'tinyspy';
+import 'util';
+import './chunk-defaults.fd5b939d.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 };