vitest 0.24.4 → 0.25.0

package/dist/{vendor-index.12d51d29.js → vendor-index.22806ffb.js}

@@ -2,6 +2,8 @@ import childProcess from 'child_process';
 import path$3 from 'path';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
 import fs$1 from 'fs';
+import assert$1 from 'assert';
+import require$$2 from 'events';
 import require$$0$1 from 'buffer';
 import require$$0 from 'stream';
 import util from 'util';
@@ -454,7 +456,7 @@ const resolveCommand = resolveCommand_1;
 const escape = _escape;
 const readShebang = readShebang_1;
 
-const isWin$1 = process.platform === 'win32';
+const isWin$2 = process.platform === 'win32';
 const isExecutableRegExp = /\.(?:com|exe)$/i;
 const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
 
@@ -474,7 +476,7 @@ function detectShebang(parsed) {
 }
 
 function parseNonShell(parsed) {
-    if (!isWin$1) {
+    if (!isWin$2) {
         return parsed;
     }
 
@@ -539,7 +541,7 @@ function parse$1(command, args, options) {
 
 var parse_1 = parse$1;
 
-const isWin = process.platform === 'win32';
+const isWin$1 = process.platform === 'win32';
 
 function notFoundError(original, syscall) {
     return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
@@ -552,7 +554,7 @@ function notFoundError(original, syscall) {
 }
 
 function hookChildProcess(cp, parsed) {
-    if (!isWin) {
+    if (!isWin$1) {
         return;
     }
 
@@ -575,7 +577,7 @@ function hookChildProcess(cp, parsed) {
 }
 
 function verifyENOENT(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
+    if (isWin$1 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, 'spawn');
     }
 
@@ -583,7 +585,7 @@ function verifyENOENT(status, parsed) {
 }
 
 function verifyENOENTSync(status, parsed) {
-    if (isWin && status === 1 && !parsed.file) {
+    if (isWin$1 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, 'spawnSync');
     }
 
@@ -635,6 +637,276 @@ crossSpawn.exports.sync = spawnSync;
 crossSpawn.exports._parse = parse;
 crossSpawn.exports._enoent = enoent;
 
+var signalExit = {exports: {}};
+
+var signals$1 = {exports: {}};
+
+var hasRequiredSignals;
+
+function requireSignals () {
+	if (hasRequiredSignals) return signals$1.exports;
+	hasRequiredSignals = 1;
+	(function (module) {
+		// This is not the set of all possible signals.
+		//
+		// It IS, however, the set of all signals that trigger
+		// an exit on either Linux or BSD systems.  Linux is a
+		// superset of the signal names supported on BSD, and
+		// the unknown signals just fail to register, so we can
+		// catch that easily enough.
+		//
+		// Don't bother with SIGKILL.  It's uncatchable, which
+		// means that we can't fire any callbacks anyway.
+		//
+		// If a user does happen to register a handler on a non-
+		// fatal signal like SIGWINCH or something, and then
+		// exit, it'll end up firing `process.emit('exit')`, so
+		// the handler will be fired anyway.
+		//
+		// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+		// artificially, inherently leave the process in a
+		// state from which it is not safe to try and enter JS
+		// listeners.
+		module.exports = [
+		  'SIGABRT',
+		  'SIGALRM',
+		  'SIGHUP',
+		  'SIGINT',
+		  'SIGTERM'
+		];
+
+		if (process.platform !== 'win32') {
+		  module.exports.push(
+		    'SIGVTALRM',
+		    'SIGXCPU',
+		    'SIGXFSZ',
+		    'SIGUSR2',
+		    'SIGTRAP',
+		    'SIGSYS',
+		    'SIGQUIT',
+		    'SIGIOT'
+		    // should detect profiler and enable/disable accordingly.
+		    // see #21
+		    // 'SIGPROF'
+		  );
+		}
+
+		if (process.platform === 'linux') {
+		  module.exports.push(
+		    'SIGIO',
+		    'SIGPOLL',
+		    'SIGPWR',
+		    'SIGSTKFLT',
+		    'SIGUNUSED'
+		  );
+		}
+} (signals$1));
+	return signals$1.exports;
+}
+
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+// grab a reference to node's real process object right away
+var process$1 = commonjsGlobal.process;
+
+const processOk = function (process) {
+  return process &&
+    typeof process === 'object' &&
+    typeof process.removeListener === 'function' &&
+    typeof process.emit === 'function' &&
+    typeof process.reallyExit === 'function' &&
+    typeof process.listeners === 'function' &&
+    typeof process.kill === 'function' &&
+    typeof process.pid === 'number' &&
+    typeof process.on === 'function'
+};
+
+// some kind of non-node environment, just no-op
+/* istanbul ignore if */
+if (!processOk(process$1)) {
+  signalExit.exports = function () {
+    return function () {}
+  };
+} else {
+  var assert = assert$1;
+  var signals = requireSignals();
+  var isWin = /^win/i.test(process$1.platform);
+
+  var EE = require$$2;
+  /* istanbul ignore if */
+  if (typeof EE !== 'function') {
+    EE = EE.EventEmitter;
+  }
+
+  var emitter;
+  if (process$1.__signal_exit_emitter__) {
+    emitter = process$1.__signal_exit_emitter__;
+  } else {
+    emitter = process$1.__signal_exit_emitter__ = new EE();
+    emitter.count = 0;
+    emitter.emitted = {};
+  }
+
+  // Because this emitter is a global, we have to check to see if a
+  // previous version of this library failed to enable infinite listeners.
+  // I know what you're about to say.  But literally everything about
+  // signal-exit is a compromise with evil.  Get used to it.
+  if (!emitter.infinite) {
+    emitter.setMaxListeners(Infinity);
+    emitter.infinite = true;
+  }
+
+  signalExit.exports = function (cb, opts) {
+    /* istanbul ignore if */
+    if (!processOk(commonjsGlobal.process)) {
+      return function () {}
+    }
+    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
+
+    if (loaded === false) {
+      load();
+    }
+
+    var ev = 'exit';
+    if (opts && opts.alwaysLast) {
+      ev = 'afterexit';
+    }
+
+    var remove = function () {
+      emitter.removeListener(ev, cb);
+      if (emitter.listeners('exit').length === 0 &&
+          emitter.listeners('afterexit').length === 0) {
+        unload();
+      }
+    };
+    emitter.on(ev, cb);
+
+    return remove
+  };
+
+  var unload = function unload () {
+    if (!loaded || !processOk(commonjsGlobal.process)) {
+      return
+    }
+    loaded = false;
+
+    signals.forEach(function (sig) {
+      try {
+        process$1.removeListener(sig, sigListeners[sig]);
+      } catch (er) {}
+    });
+    process$1.emit = originalProcessEmit;
+    process$1.reallyExit = originalProcessReallyExit;
+    emitter.count -= 1;
+  };
+  signalExit.exports.unload = unload;
+
+  var emit = function emit (event, code, signal) {
+    /* istanbul ignore if */
+    if (emitter.emitted[event]) {
+      return
+    }
+    emitter.emitted[event] = true;
+    emitter.emit(event, code, signal);
+  };
+
+  // { <signal>: <listener fn>, ... }
+  var sigListeners = {};
+  signals.forEach(function (sig) {
+    sigListeners[sig] = function listener () {
+      /* istanbul ignore if */
+      if (!processOk(commonjsGlobal.process)) {
+        return
+      }
+      // If there are no other listeners, an exit is coming!
+      // Simplest way: remove us and then re-send the signal.
+      // We know that this will kill the process, so we can
+      // safely emit now.
+      var listeners = process$1.listeners(sig);
+      if (listeners.length === emitter.count) {
+        unload();
+        emit('exit', null, sig);
+        /* istanbul ignore next */
+        emit('afterexit', null, sig);
+        /* istanbul ignore next */
+        if (isWin && sig === 'SIGHUP') {
+          // "SIGHUP" throws an `ENOSYS` error on Windows,
+          // so use a supported signal instead
+          sig = 'SIGINT';
+        }
+        /* istanbul ignore next */
+        process$1.kill(process$1.pid, sig);
+      }
+    };
+  });
+
+  signalExit.exports.signals = function () {
+    return signals
+  };
+
+  var loaded = false;
+
+  var load = function load () {
+    if (loaded || !processOk(commonjsGlobal.process)) {
+      return
+    }
+    loaded = true;
+
+    // This is the number of onSignalExit's that are in play.
+    // It's important so that we can count the correct number of
+    // listeners on signals, and don't wait for the other one to
+    // handle it instead of us.
+    emitter.count += 1;
+
+    signals = signals.filter(function (sig) {
+      try {
+        process$1.on(sig, sigListeners[sig]);
+        return true
+      } catch (er) {
+        return false
+      }
+    });
+
+    process$1.emit = processEmit;
+    process$1.reallyExit = processReallyExit;
+  };
+  signalExit.exports.load = load;
+
+  var originalProcessReallyExit = process$1.reallyExit;
+  var processReallyExit = function processReallyExit (code) {
+    /* istanbul ignore if */
+    if (!processOk(commonjsGlobal.process)) {
+      return
+    }
+    process$1.exitCode = code || /* istanbul ignore next */ 0;
+    emit('exit', process$1.exitCode, null);
+    /* istanbul ignore next */
+    emit('afterexit', process$1.exitCode, null);
+    /* istanbul ignore next */
+    originalProcessReallyExit.call(process$1, process$1.exitCode);
+  };
+
+  var originalProcessEmit = process$1.emit;
+  var processEmit = function processEmit (ev, arg) {
+    if (ev === 'exit' && processOk(commonjsGlobal.process)) {
+      /* istanbul ignore else */
+      if (arg !== undefined) {
+        process$1.exitCode = arg;
+      }
+      var ret = originalProcessEmit.apply(this, arguments);
+      /* istanbul ignore next */
+      emit('exit', process$1.exitCode, null);
+      /* istanbul ignore next */
+      emit('afterexit', process$1.exitCode, null);
+      /* istanbul ignore next */
+      return ret
+    } else {
+      return originalProcessEmit.apply(this, arguments)
+    }
+  };
+}
+
 var getStream$1 = {exports: {}};
 
 const {PassThrough: PassThroughStream} = require$$0;
@@ -790,4 +1062,4 @@ var mergeStream = function (/*streams...*/) {
   }
 };
 
-export { crossSpawn as c, getStream$1 as g, mergeStream as m, pathKey$1 as p };
+export { crossSpawn as c, getStream$1 as g, mergeStream as m, pathKey$1 as p, signalExit as s };

package/dist/worker.js

@@ -1,22 +1,25 @@
-import { b as resolve, e as distDir } from './chunk-utils-env.b1281522.js';
-import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-client.9fbd5d5b.js';
+import { b as resolve, e as distDir } from './chunk-utils-env.7fe285cc.js';
+import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-client.13ea0a59.js';
 import { workerId } from 'tinypool';
-import { g as getWorkerState } from './chunk-mock-date.9fe2b438.js';
-import { e as executeInViteNode } from './chunk-runtime-mocker.f994e23a.js';
-import { r as rpc } from './chunk-runtime-rpc.e583f5e7.js';
+import { g as getWorkerState } from './chunk-typecheck-constants.410fa7b2.js';
+import { e as executeInViteNode } from './chunk-runtime-mocker.a5d87666.js';
+import { r as rpc } from './chunk-runtime-rpc.4a2d45ab.js';
+import { p as processError } from './chunk-runtime-error.3cc15c6f.js';
 import 'tty';
 import 'url';
 import 'path';
 import 'module';
 import 'vm';
-import './chunk-vite-node-utils.5096a80d.js';
+import './chunk-vite-node-utils.b89230f3.js';
 import 'fs';
+import 'acorn';
 import 'assert';
 import 'util';
 import 'debug';
 import 'local-pkg';
 import 'vite';
-import './chunk-utils-timers.ab764c0c.js';
+import './chunk-utils-timers.d1fcc6bb.js';
+import 'chai';
 
 let _viteNode;
 const moduleCache = new ModuleCacheMap();
@@ -33,7 +36,7 @@ async function startViteNode(ctx) {
     return processExit(code);
   };
   process.on("unhandledRejection", (err) => {
-    rpc().onUnhandledRejection(err);
+    rpc().onUnhandledRejection(processError(err));
   });
   const { config } = ctx;
   const { run: run2 } = (await executeInViteNode({

package/globals.d.ts

@@ -3,6 +3,8 @@ declare global {
   const test: typeof import('vitest')['test']
   const describe: typeof import('vitest')['describe']
   const it: typeof import('vitest')['it']
+  const expectTypeOf: typeof import('vitest')['expectTypeOf']
+  const assertType: typeof import('vitest')['assertType']
   const expect: typeof import('vitest')['expect']
   const assert: typeof import('vitest')['assert']
   const vitest: typeof import('vitest')['vitest']

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vitest",
   "type": "module",
-  "version": "0.24.4",
+  "version": "0.25.0",
   "description": "A blazing fast unit test framework powered by Vite",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -103,9 +103,12 @@
     "@types/chai": "^4.3.3",
     "@types/chai-subset": "^1.3.3",
     "@types/node": "*",
+    "acorn": "^8.8.0",
+    "acorn-walk": "^8.2.0",
     "chai": "^4.3.6",
     "debug": "^4.3.4",
     "local-pkg": "^0.4.2",
+    "source-map": "^0.6.1",
     "strip-literal": "^0.4.2",
     "tinybench": "^2.3.1",
     "tinypool": "^0.3.0",
@@ -114,7 +117,7 @@
   },
   "devDependencies": {
     "@antfu/install-pkg": "^0.1.1",
-    "@edge-runtime/vm": "1.1.0",
+    "@edge-runtime/vm": "2.0.1",
     "@sinonjs/fake-timers": "^9.1.2",
     "@types/diff": "^5.0.2",
     "@types/jsdom": "^20.0.0",
@@ -122,7 +125,7 @@
     "@types/natural-compare": "^1.4.1",
     "@types/prompts": "^2.4.1",
     "@types/sinonjs__fake-timers": "^8.1.2",
-    "@vitest/ui": "0.24.4",
+    "@vitest/ui": "0.25.0",
     "birpc": "^0.2.3",
     "cac": "^6.7.14",
     "chai-subset": "^1.6.0",
@@ -130,11 +133,13 @@
     "diff": "^5.1.0",
     "event-target-polyfill": "^0.0.3",
     "execa": "^6.1.0",
+    "expect-type": "^0.15.0",
     "fast-glob": "^3.2.12",
     "find-up": "^6.3.0",
     "flatted": "^3.2.7",
-    "happy-dom": "^6.0.4",
-    "jsdom": "^20.0.1",
+    "get-tsconfig": "^4.2.0",
+    "happy-dom": "^7.6.6",
+    "jsdom": "^20.0.2",
     "log-update": "^5.0.1",
     "magic-string": "^0.26.7",
     "micromatch": "^4.0.5",
@@ -143,15 +148,14 @@
     "p-limit": "^4.0.0",
     "pathe": "^0.2.0",
     "picocolors": "^1.0.0",
-    "pkg-types": "^0.3.5",
+    "pkg-types": "^0.3.6",
     "pretty-format": "^27.5.1",
     "prompts": "^2.4.2",
     "rollup": "^2.79.1",
-    "source-map-js": "^1.0.2",
     "strip-ansi": "^7.0.1",
     "typescript": "^4.8.4",
-    "vite-node": "0.24.4",
-    "ws": "^8.10.0"
+    "vite-node": "0.25.0",
+    "ws": "^8.11.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",

package/dist/chunk-integrations-globals.88fd2e64.js

@@ -1,25 +0,0 @@
-import { m as globalApis } from './chunk-utils-env.b1281522.js';
-import { i as index } from './chunk-runtime-hooks.66004497.js';
-import 'tty';
-import 'url';
-import 'path';
-import './chunk-runtime-chain.a5cd236b.js';
-import 'util';
-import './chunk-mock-date.9fe2b438.js';
-import 'local-pkg';
-import 'chai';
-import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.e583f5e7.js';
-import './chunk-utils-timers.ab764c0c.js';
-import 'fs';
-import './chunk-utils-source-map.d9d36eb0.js';
-import './spy.js';
-import 'tinyspy';
-
-function registerApiGlobally() {
-  globalApis.forEach((api) => {
-    globalThis[api] = index[api];
-  });
-}
-
-export { registerApiGlobally };