vitest 0.10.4 → 0.12.0

package/dist/{chunk-api-setup.0baa5b9c.js → chunk-api-setup.87a943bf.js}

@@ -1,5 +1,5 @@
 import { promises } from 'fs';
-import { c as createBirpc } from './chunk-vite-node-utils.3cb38009.js';
+import { c as createBirpc } from './chunk-vite-node-utils.20782527.js';
 import require$$0$1 from 'stream';
 import require$$0 from 'zlib';
 import require$$3 from 'net';
@@ -9,11 +9,11 @@ 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.54c46a47.js';
-import { r as interpretSourcePos, b as parseStacktrace } from './chunk-utils-timers.8a5e7cd5.js';
+import { A as API_PATH } from './chunk-constants.0567483c.js';
+import { r as interpretSourcePos, b as parseStacktrace } from './chunk-utils-timers.f25e8f44.js';
 import 'module';
 import 'vm';
-import './chunk-utils-global.eb31f3da.js';
+import './chunk-utils-global.a5a8641f.js';
 import 'tty';
 import 'local-pkg';
 import 'path';

package/dist/{chunk-constants.54c46a47.js → chunk-constants.0567483c.js}

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

package/dist/{chunk-defaults.c143550b.js → chunk-defaults.23b3ae8a.js}

@@ -1,7 +1,7 @@
 import { existsSync, promises } from 'fs';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
-import { t as toArray, k as resolve } from './chunk-utils-global.eb31f3da.js';
+import { t as toArray, h as resolve } from './chunk-utils-global.a5a8641f.js';
 
 const defaultInclude = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
 const defaultExclude = ["**/node_modules/**", "**/dist/**", "**/cypress/**", "**/.{idea,git,cache,output,temp}/**"];
@@ -119,7 +119,7 @@ async function reportCoverage(ctx) {
       })
     };
   }));
-  const offset = 203;
+  const offset = 224;
   report._getSourceMap = (coverage) => {
     const path = pathToFileURL(coverage.url).href;
     const data = sourceMapMeta[path];

package/dist/{chunk-integrations-globals.6bdc721a.js → chunk-integrations-globals.a37b2801.js}

@@ -1,22 +1,22 @@
-import { g as globalApis } from './chunk-constants.54c46a47.js';
-import { i as index } from './vendor-entry.a660e61c.js';
+import { g as globalApis } from './chunk-constants.0567483c.js';
+import { i as index } from './vendor-entry.b20b007c.js';
 import 'url';
-import './chunk-utils-global.eb31f3da.js';
+import './chunk-utils-global.a5a8641f.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
 import 'fs';
 import 'console';
 import 'stream';
-import './chunk-runtime-chain.0ac0691b.js';
+import './chunk-runtime-chain.37b69607.js';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.710f6f7f.js';
-import './chunk-utils-timers.8a5e7cd5.js';
-import './chunk-integrations-spy.f036df6f.js';
+import './chunk-runtime-rpc.63398738.js';
+import './chunk-utils-timers.f25e8f44.js';
+import './chunk-integrations-spy.bee66426.js';
 import 'tinyspy';
 import 'util';
-import './chunk-defaults.c143550b.js';
+import './chunk-defaults.23b3ae8a.js';
 import 'module';
 import 'crypto';
 

package/dist/{chunk-integrations-spy.f036df6f.js → chunk-integrations-spy.bee66426.js}

@@ -36,7 +36,7 @@ function enhanceSpy(spy) {
       });
     },
     get lastCall() {
-      return stub.calls.at(-1);
+      return stub.calls[stub.calls.length - 1];
     }
   };
   let onceImplementations = [];

package/dist/{chunk-runtime-chain.0ac0691b.js → chunk-runtime-chain.37b69607.js}

@@ -1,10 +1,10 @@
 import chai$1, { expect as expect$1, util } from 'chai';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
-import { r as rpc } from './chunk-runtime-rpc.710f6f7f.js';
-import { i as isObject, a as index, g as getCallLastIndex, s as slash, b as getWorkerState, c as getNames, d as assertTypes, p as picocolors, n as noop, t as toArray, r as resetModules } from './chunk-utils-global.eb31f3da.js';
+import { r as rpc } from './chunk-runtime-rpc.63398738.js';
+import { i as isObject, j as join, d as dirname, g as getCallLastIndex, s as slash, a as getWorkerState, b as getNames, c as assertTypes, p as picocolors, n as noop, t as toArray, r as resetModules } from './chunk-utils-global.a5a8641f.js';
 import fs, { promises } from 'fs';
-import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils, c as setTimeout, d as clearTimeout } from './chunk-utils-timers.8a5e7cd5.js';
-import { i as isMockFunction, s as spyOn, f as fn, a as spies } from './chunk-integrations-spy.f036df6f.js';
+import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils, c as setTimeout, d as clearTimeout } from './chunk-utils-timers.f25e8f44.js';
+import { i as isMockFunction, s as spyOn, f as fn, a as spies } from './chunk-integrations-spy.bee66426.js';
 import require$$0, { format } from 'util';
 
 var __defProp$4 = Object.defineProperty;
@@ -517,7 +517,7 @@ function printBacktickString(str) {
 }
 function ensureDirectoryExists(filePath) {
   try {
-    fs.mkdirSync(index.join(index.dirname(filePath)), { recursive: true });
+    fs.mkdirSync(join(dirname(filePath)), { recursive: true });
   } catch {
   }
 }
@@ -1058,15 +1058,15 @@ if (!Object.prototype.hasOwnProperty.call(global, MATCHERS_OBJECT)) {
     expectedAssertionsNumber: null,
     expectedAssertionsNumberErrorGen: null
   };
-  Object.defineProperty(global, MATCHERS_OBJECT, {
+  Object.defineProperty(globalThis, MATCHERS_OBJECT, {
     value: {
       state: defaultState
     }
   });
 }
-const getState = () => global[MATCHERS_OBJECT].state;
+const getState = () => globalThis[MATCHERS_OBJECT].state;
 const setState = (state) => {
-  Object.assign(global[MATCHERS_OBJECT].state, state);
+  Object.assign(globalThis[MATCHERS_OBJECT].state, state);
 };
 const JestChaiExpect = (chai, utils) => {
   function def(name, fn) {
@@ -4778,9 +4778,11 @@ class VitestUtils {
     return this;
   }
   stubGlobal(name, value) {
-    globalThis[name] = value;
-    if (globalThis.window)
+    if (globalThis.window) {
       globalThis.window[name] = value;
+    } else {
+      globalThis[name] = value;
+    }
     return this;
   }
   resetModules() {

package/dist/{chunk-runtime-mocker.89015cf8.js → chunk-runtime-mocker.ee72d19a.js}

@@ -1,8 +1,8 @@
-import { n as normalizeRequestId, i as isNodeBuiltin, t as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.3cb38009.js';
+import { n as normalizeRequestId, i as isNodeBuiltin, t as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.20782527.js';
 import { normalizePath } from 'vite';
-import { b as getWorkerState, D as isWindows, E as mergeSlashes, h as dirname, f as basename, k as resolve, F as getType, G as getAllProperties, s as slash } from './chunk-utils-global.eb31f3da.js';
+import { a as getWorkerState, C as isWindows, D as mergeSlashes, d as dirname, f as basename, h as resolve, E as getType, F as getAllProperties, s as slash } from './chunk-utils-global.a5a8641f.js';
 import { existsSync, readdirSync } from 'fs';
-import { d as distDir } from './chunk-constants.54c46a47.js';
+import { d as distDir } from './chunk-constants.0567483c.js';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
@@ -177,6 +177,7 @@ const _VitestMocker = class {
     await this.ensureSpy();
     await this.resolveMocks();
     const mock = this.getDependencyMock(dep);
+    const callstack = this.request.callstack;
     if (mock === null) {
       const cacheName = `${dep}__mock`;
       const cache = this.moduleCache.get(cacheName);
@@ -188,9 +189,11 @@ const _VitestMocker = class {
       this.emit("mocked", cacheName, { exports });
       return exports;
     }
-    if (typeof mock === "function")
+    if (typeof mock === "function" && !callstack.includes(`mock:${dep}`)) {
+      callstack.push(`mock:${dep}`);
       return this.callFunctionMock(dep, mock);
-    if (typeof mock === "string")
+    }
+    if (typeof mock === "string" && !callstack.includes(mock))
       dep = mock;
     return this.request(dep);
   }
@@ -224,6 +227,7 @@ class VitestRunner extends ViteNodeRunner {
   }
   prepareContext(context) {
     const request = context.__vite_ssr_import__;
+    const resolveId = context.__vitest_resolve_id__;
     const mocker = this.mocker.withRequest(request);
     mocker.on("mocked", (dep, module) => {
       this.moduleCache.set(dep, module);
@@ -233,8 +237,8 @@ class VitestRunner extends ViteNodeRunner {
       Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", { get: () => globalThis.__vitest_index__ });
     }
     return Object.assign(context, {
-      __vite_ssr_import__: (dep) => mocker.requestWithMock(dep),
-      __vite_ssr_dynamic_import__: (dep) => mocker.requestWithMock(dep),
+      __vite_ssr_import__: async (dep) => mocker.requestWithMock(await resolveId(dep)),
+      __vite_ssr_dynamic_import__: async (dep) => mocker.requestWithMock(await resolveId(dep)),
       __vitest_mocker__: mocker
     });
   }

package/dist/{chunk-runtime-rpc.710f6f7f.js → chunk-runtime-rpc.63398738.js}

@@ -1,4 +1,4 @@
-import { b as getWorkerState } from './chunk-utils-global.eb31f3da.js';
+import { a as getWorkerState } from './chunk-utils-global.a5a8641f.js';
 
 const rpc = () => {
   return getWorkerState().rpc;

package/dist/{chunk-utils-global.eb31f3da.js → chunk-utils-global.a5a8641f.js}

@@ -242,9 +242,9 @@ const _path = /*#__PURE__*/Object.freeze({
   parse: parse
 });
 
-const index = {
+({
   ..._path
-};
+});
 
 function getWorkerState() {
   return globalThis.__vitest_worker__;
@@ -457,4 +457,4 @@ function getCallLastIndex(code) {
   return null;
 }
 
-export { ensurePackageInstalled as A, stdout as B, extname as C, isWindows as D, mergeSlashes as E, getType as F, getAllProperties as G, clone as H, partitionSuiteChildren as I, hasTests as J, index as a, getWorkerState as b, getNames as c, assertTypes as d, notNullish as e, basename as f, getCallLastIndex as g, dirname as h, isObject as i, join as j, resolve as k, isAbsolute as l, relative as m, noop as n, getTests as o, picocolors as p, getFullName as q, resetModules as r, slash as s, toArray as t, hasFailed as u, hasFailedSnapshot as v, getSuites as w, normalize as x, deepMerge as y, toNamespacedPath as z };
+export { stdout as A, extname as B, isWindows as C, mergeSlashes as D, getType as E, getAllProperties as F, clone as G, partitionSuiteChildren as H, hasTests as I, getWorkerState as a, getNames as b, assertTypes as c, dirname as d, notNullish as e, basename as f, getCallLastIndex as g, resolve as h, isObject as i, join as j, isAbsolute as k, relative as l, getTests as m, noop as n, getFullName as o, picocolors as p, hasFailed as q, resetModules as r, slash as s, toArray as t, hasFailedSnapshot as u, getSuites as v, normalize as w, deepMerge as x, toNamespacedPath as y, ensurePackageInstalled as z };

package/dist/{chunk-utils-timers.8a5e7cd5.js → chunk-utils-timers.f25e8f44.js}

@@ -1,4 +1,4 @@
-import { s as slash, e as notNullish, p as picocolors } from './chunk-utils-global.eb31f3da.js';
+import { s as slash, e as notNullish, p as picocolors } from './chunk-utils-global.a5a8641f.js';
 
 const setTimeout$1 = globalThis.setTimeout;
 const setInterval = globalThis.setInterval;
@@ -7407,7 +7407,7 @@ function stringify(object, maxDepth = 10, options) {
 const printReceived = (object) => RECEIVED_COLOR(replaceTrailingSpaces(stringify(object)));
 const printExpected = (value) => EXPECTED_COLOR(replaceTrailingSpaces(stringify(value)));
 function diff(a, b, options) {
-  return unifiedDiff(stringify(a), stringify(b));
+  return unifiedDiff(stringify(b), stringify(a));
 }
 
 var matcherUtils = /*#__PURE__*/Object.freeze({

package/dist/{chunk-vite-node-externalize.92c54acc.js → chunk-vite-node-externalize.25eaf4e5.js}

@@ -5,25 +5,25 @@ import process$1 from 'process';
 import { s as signalExit, m as mergeStream, g as getStream, c as crossSpawn, o as onetime$1 } from './vendor-index.40be925a.js';
 import url, { fileURLToPath, pathToFileURL } from 'url';
 import require$$0, { constants as constants$5, cpus, hostname } from 'os';
-import { j as join, f as basename, h as dirname, k as resolve, p as picocolors, s as slash$2, l as isAbsolute, m as relative, o as getTests, q as getFullName, u as hasFailed, v as hasFailedSnapshot, w as getSuites, t as toArray, x as normalize, n as noop$1, y as deepMerge, z as toNamespacedPath, g as getCallLastIndex, e as notNullish, A as ensurePackageInstalled, B as stdout } from './chunk-utils-global.eb31f3da.js';
+import { j as join, f as basename, d as dirname, h as resolve, p as picocolors, s as slash$2, k as isAbsolute, l as relative, m as getTests, o as getFullName, q as hasFailed, u as hasFailedSnapshot, v as getSuites, t as toArray, w as normalize, n as noop$1, x as deepMerge, y as toNamespacedPath, g as getCallLastIndex, e as notNullish, z as ensurePackageInstalled, A as stdout } from './chunk-utils-global.a5a8641f.js';
 import { createServer, mergeConfig } from 'vite';
 import fs$8, { promises, existsSync, readFileSync } from 'fs';
-import { d as distDir, a as defaultPort, c as configFiles } from './chunk-constants.54c46a47.js';
+import { d as distDir, a as defaultPort, c as configFiles } from './chunk-constants.0567483c.js';
 import readline from 'readline';
 import require$$0$1 from 'util';
 import require$$0$2 from 'stream';
 import require$$2 from 'events';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
-import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toFilePath, w as withInlineSourcemap, c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-utils.3cb38009.js';
-import { c as configDefaults, r as resolveC8Options, a as cleanCoverage, b as reportCoverage } from './chunk-defaults.c143550b.js';
+import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toFilePath, w as withInlineSourcemap, c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-utils.20782527.js';
+import { c as configDefaults, r as resolveC8Options, a as cleanCoverage, b as reportCoverage } from './chunk-defaults.23b3ae8a.js';
 import { MessageChannel } from 'worker_threads';
 import { Tinypool } from 'tinypool';
 import { performance } from 'perf_hooks';
-import { e as stripAnsi, h as stringWidth, i as ansiStyles, j as sliceAnsi, k as setInterval, o as clearInterval, q as cliTruncate, c as setTimeout$1, b as parseStacktrace, r as interpretSourcePos, s as stringify$5, u as unifiedDiff, a as posToNumber, l as lineSplitRE, d as clearTimeout$1 } from './chunk-utils-timers.8a5e7cd5.js';
+import { e as stripAnsi, h as stringWidth, i as ansiStyles, j as sliceAnsi, k as setInterval, o as clearInterval, q as cliTruncate, c as setTimeout$1, b as parseStacktrace, r as interpretSourcePos, s as stringify$5, u as unifiedDiff, a as posToNumber, l as lineSplitRE, d as clearTimeout$1 } from './chunk-utils-timers.f25e8f44.js';
 import MagicString from './chunk-magic-string.d5e0e473.js';
 import { p as prompts } from './vendor-index.405e58ef.js';
 
-var version = "0.10.4";
+var version = "0.12.0";
 
 function stripFinalNewline(input) {
 	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
@@ -8487,7 +8487,7 @@ class BaseReporter {
     if (errors.length) {
       process.exitCode = 1;
       const errorMessage = picocolors.exports.red(picocolors.exports.bold(`
-Vitest catched ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} during the test run. This might cause false positive tests.
+Vitest caught ${errors.length} unhandled error${errors.length > 1 ? "s" : ""} during the test run. This might cause false positive tests.
 Please, resolve all the errors to make sure your tests are not affected.`));
       this.ctx.log(picocolors.exports.red(divider(picocolors.exports.bold(picocolors.exports.inverse(" Unhandled Errors ")))));
       this.ctx.log(errorMessage);
@@ -9838,10 +9838,10 @@ const ReportersMap = {
   "junit": JUnitReporter
 };
 
-async function loadCustomReporterModule(path, fetchModule) {
+async function loadCustomReporterModule(path, runner) {
   let customReporterModule;
   try {
-    customReporterModule = await fetchModule(path);
+    customReporterModule = await runner.executeId(path);
   } catch (customReporterModuleError) {
     throw new Error(`Failed to load custom Reporter from ${path}`, { cause: customReporterModuleError });
   }
@@ -9849,14 +9849,14 @@ async function loadCustomReporterModule(path, fetchModule) {
     throw new Error(`Custom reporter loaded from ${path} was not the default export`);
   return customReporterModule.default;
 }
-function createReporters(reporterReferences, fetchModule) {
+function createReporters(reporterReferences, runner) {
   const promisedReporters = reporterReferences.map(async (referenceOrInstance) => {
     if (typeof referenceOrInstance === "string") {
       if (referenceOrInstance in ReportersMap) {
         const BuiltinReporter = ReportersMap[referenceOrInstance];
         return new BuiltinReporter();
       } else {
-        const CustomReporter = await loadCustomReporterModule(referenceOrInstance, fetchModule);
+        const CustomReporter = await loadCustomReporterModule(referenceOrInstance, runner);
         return new CustomReporter();
       }
     }
@@ -10310,7 +10310,7 @@ class Vitest {
         return node.resolveId(id, importer);
       }
     });
-    this.reporters = await createReporters(resolved.reporters, this.runner.executeFile.bind(this.runner));
+    this.reporters = await createReporters(resolved.reporters, this.runner);
     this.runningPromise = void 0;
     this._onRestartListeners.forEach((fn) => fn());
     if (resolved.coverage.enabled)
@@ -10938,7 +10938,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
         await ctx.setServer(options, server);
         haveStarted = true;
         if (options.api && options.watch)
-          (await import('./chunk-api-setup.0baa5b9c.js')).setup(ctx);
+          (await import('./chunk-api-setup.87a943bf.js')).setup(ctx);
         if (!options.watch)
           await server.watcher.close();
       }

package/dist/{chunk-vite-node-utils.3cb38009.js → chunk-vite-node-utils.20782527.js}

@@ -1,7 +1,7 @@
 import { builtinModules, createRequire } from 'module';
 import { pathToFileURL, fileURLToPath as fileURLToPath$2, URL as URL$1 } from 'url';
 import vm from 'vm';
-import { l as isAbsolute$2, k as resolve, j as join$2, C as extname$2, h as dirname$2 } from './chunk-utils-global.eb31f3da.js';
+import { k as isAbsolute$2, h as resolve, j as join$2, B as extname$2, d as dirname$2 } from './chunk-utils-global.a5a8641f.js';
 import path from 'path';
 import fs, { realpathSync, statSync, Stats, promises, existsSync } from 'fs';
 import assert from 'assert';
@@ -8945,15 +8945,11 @@ class ViteNodeRunner {
   async directRequest(id, fsPath, _callstack) {
     const callstack = [..._callstack, normalizeModuleId(id)];
     const request = async (dep) => {
-      var _a, _b;
+      var _a;
       const getStack = () => {
         return `stack:
 ${[...callstack, dep].reverse().map((p) => `- ${p}`).join("\n")}`;
       };
-      if (this.options.resolveId && this.shouldResolveId(dep)) {
-        const resolvedDep = await this.options.resolveId(dep, id);
-        dep = ((_a = resolvedDep == null ? void 0 : resolvedDep.id) == null ? void 0 : _a.replace(this.root, "")) || dep;
-      }
       let debugTimer;
       if (this.debug)
         debugTimer = setTimeout(() => this.debugLog(() => `module ${dep} takes over 2s to load.
@@ -8961,7 +8957,7 @@ ${getStack()}`), 2e3);
       try {
         if (callstack.includes(normalizeModuleId(dep))) {
           this.debugLog(() => `circular dependency, ${getStack()}`);
-          const depExports = (_b = this.moduleCache.get(dep)) == null ? void 0 : _b.exports;
+          const depExports = (_a = this.moduleCache.get(dep)) == null ? void 0 : _a.exports;
           if (depExports)
             return depExports;
           throw new Error(`[vite-node] Failed to resolve circular dependency, ${getStack()}`);
@@ -8973,10 +8969,22 @@ ${getStack()}`), 2e3);
           clearTimeout(debugTimer);
       }
     };
+    Object.defineProperty(request, "callstack", { get: () => callstack });
+    const resolveId = async (dep, callstackPosition = 1) => {
+      if (this.options.resolveId && this.shouldResolveId(dep)) {
+        let importer = callstack[callstack.length - callstackPosition];
+        if (importer && importer.startsWith("mock:"))
+          importer = importer.slice(5);
+        const { id: id2 } = await this.options.resolveId(dep, importer) || {};
+        dep = id2 && isAbsolute$2(id2) ? `/@fs/${id2}` : id2 || dep;
+      }
+      return dep;
+    };
+    id = await resolveId(id, 2);
     const requestStubs = this.options.requestStubs || DEFAULT_REQUEST_STUBS;
     if (id in requestStubs)
       return requestStubs[id];
-    const { code: transformed, externalize } = await this.options.fetchModule(id);
+    let { code: transformed, externalize } = await this.options.fetchModule(id);
     if (externalize) {
       const mod = await this.interopedImport(externalize);
       this.moduleCache.set(fsPath, { exports: mod });
@@ -8998,18 +9006,26 @@ ${getStack()}`), 2e3);
         return exports.default;
       }
     };
+    let require;
     const context = this.prepareContext({
       __vite_ssr_import__: request,
       __vite_ssr_dynamic_import__: request,
       __vite_ssr_exports__: exports,
       __vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
       __vite_ssr_import_meta__: { url },
-      require: createRequire(url),
+      __vitest_resolve_id__: resolveId,
+      require: (path) => {
+        if (!require)
+          require = createRequire(url);
+        return require(path);
+      },
       exports,
       module: moduleProxy,
       __filename,
       __dirname: dirname$2(__filename)
     });
+    if (transformed[0] === "#")
+      transformed = transformed.replace(/^\#\!.*/, (s) => " ".repeat(s.length));
     const fn = vm.runInThisContext(`'use strict';async (${Object.keys(context).join(",")})=>{{${transformed}
 }}`, {
       filename: fsPath,
@@ -9022,7 +9038,7 @@ ${getStack()}`), 2e3);
     return context;
   }
   shouldResolveId(dep) {
-    if (isNodeBuiltin(dep) || dep in (this.options.requestStubs || DEFAULT_REQUEST_STUBS))
+    if (isNodeBuiltin(dep) || dep in (this.options.requestStubs || DEFAULT_REQUEST_STUBS) || dep.startsWith("/@vite"))
       return false;
     return !isAbsolute$2(dep) || !extname$2(dep);
   }

package/dist/cli.js

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events';
-import { p as picocolors } from './chunk-utils-global.eb31f3da.js';
-import { v as version, s as startVitest, d as divider } from './chunk-vite-node-externalize.92c54acc.js';
+import { p as picocolors } from './chunk-utils-global.a5a8641f.js';
+import { v as version, s as startVitest, d as divider } from './chunk-vite-node-externalize.25eaf4e5.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
@@ -16,16 +16,16 @@ import 'util';
 import 'url';
 import 'os';
 import 'vite';
-import './chunk-constants.54c46a47.js';
+import './chunk-constants.0567483c.js';
 import 'readline';
-import './chunk-vite-node-utils.3cb38009.js';
+import './chunk-vite-node-utils.20782527.js';
 import 'module';
 import 'vm';
-import './chunk-defaults.c143550b.js';
+import './chunk-defaults.23b3ae8a.js';
 import 'worker_threads';
 import 'tinypool';
 import 'perf_hooks';
-import './chunk-utils-timers.8a5e7cd5.js';
+import './chunk-utils-timers.f25e8f44.js';
 import './chunk-magic-string.d5e0e473.js';
 import './vendor-index.405e58ef.js';
 

package/dist/entry.js

@@ -1,20 +1,20 @@
-export { r as run } from './vendor-entry.a660e61c.js';
+export { r as run } from './vendor-entry.b20b007c.js';
 import 'fs';
-import './chunk-utils-global.eb31f3da.js';
+import './chunk-utils-global.a5a8641f.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
 import 'console';
 import 'stream';
-import './chunk-runtime-chain.0ac0691b.js';
+import './chunk-runtime-chain.37b69607.js';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.710f6f7f.js';
-import './chunk-utils-timers.8a5e7cd5.js';
-import './chunk-integrations-spy.f036df6f.js';
+import './chunk-runtime-rpc.63398738.js';
+import './chunk-utils-timers.f25e8f44.js';
+import './chunk-integrations-spy.bee66426.js';
 import 'tinyspy';
 import 'util';
-import './chunk-defaults.c143550b.js';
+import './chunk-defaults.23b3ae8a.js';
 import 'module';
 import 'url';
 import 'crypto';

package/dist/index.d.ts

@@ -636,6 +636,7 @@ interface C8Options {
     skipFull?: boolean;
     extension?: string | string[];
     all?: boolean;
+    src?: string[];
     100?: boolean;
     lines?: number;
     functions?: number;
@@ -1153,6 +1154,14 @@ interface InlineConfig {
      * Resolve custom snapshot path
      */
     resolveSnapshotPath?: (path: string, extension: string) => string;
+    /**
+     * Pass with no tests
+     */
+    passWithNoTests?: boolean;
+    /**
+     * Allow tests and suites that are marked as only
+     */
+    allowOnly?: boolean;
     /**
      * Show heap usage after each test. Usefull for debugging memory leaks.
      */
@@ -1173,14 +1182,6 @@ interface UserConfig extends InlineConfig {
      * Use happy-dom
      */
     dom?: boolean;
-    /**
-     * Pass with no tests
-     */
-    passWithNoTests?: boolean;
-    /**
-     * Allow tests and suites that are marked as only
-     */
-    allowOnly?: boolean;
     /**
      * Run tests that cover a list of source files
      */

package/dist/index.js

@@ -1,13 +1,13 @@
-export { c as afterAll, f as afterEach, b as beforeAll, e as beforeEach, g as createExpect, d as describe, h as expect, k as getRunningMode, a as isFirstRun, l as isWatchMode, i as it, r as runOnce, s as suite, t as test, j as vi, v as vitest, w as withCallback } from './chunk-runtime-chain.0ac0691b.js';
+export { c as afterAll, f as afterEach, b as beforeAll, e as beforeEach, g as createExpect, d as describe, h as expect, k as getRunningMode, a as isFirstRun, l as isWatchMode, i as it, r as runOnce, s as suite, t as test, j as vi, v as vitest, w as withCallback } from './chunk-runtime-chain.37b69607.js';
 export { assert, default as chai, should } from 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.710f6f7f.js';
-import './chunk-utils-global.eb31f3da.js';
+import './chunk-runtime-rpc.63398738.js';
+import './chunk-utils-global.a5a8641f.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
 import 'fs';
-import './chunk-utils-timers.8a5e7cd5.js';
-import './chunk-integrations-spy.f036df6f.js';
+import './chunk-utils-timers.f25e8f44.js';
+import './chunk-integrations-spy.bee66426.js';
 import 'tinyspy';
 import 'util';

package/dist/node.d.ts

@@ -405,6 +405,7 @@ interface C8Options {
     skipFull?: boolean;
     extension?: string | string[];
     all?: boolean;
+    src?: string[];
     100?: boolean;
     lines?: number;
     functions?: number;
@@ -854,6 +855,14 @@ interface InlineConfig {
      * Resolve custom snapshot path
      */
     resolveSnapshotPath?: (path: string, extension: string) => string;
+    /**
+     * Pass with no tests
+     */
+    passWithNoTests?: boolean;
+    /**
+     * Allow tests and suites that are marked as only
+     */
+    allowOnly?: boolean;
     /**
      * Show heap usage after each test. Usefull for debugging memory leaks.
      */
@@ -874,14 +883,6 @@ interface UserConfig extends InlineConfig {
      * Use happy-dom
      */
     dom?: boolean;
-    /**
-     * Pass with no tests
-     */
-    passWithNoTests?: boolean;
-    /**
-     * Allow tests and suites that are marked as only
-     */
-    allowOnly?: boolean;
     /**
      * Run tests that cover a list of source files
      */
@@ -1016,6 +1017,10 @@ interface CliOptions extends UserConfig {
 declare function startVitest(cliFilters: string[], options: CliOptions, viteOverrides?: UserConfig$1): Promise<boolean>;
 
 declare type Callback = (...args: any[]) => unknown;
+interface ViteRunnerRequest {
+    (dep: string): any;
+    callstack: string[];
+}
 declare class VitestMocker {
     options: ExecuteOptions;
     private moduleCache;
@@ -1024,7 +1029,7 @@ declare class VitestMocker {
     private request;
     private root;
     private callbacks;
-    constructor(options: ExecuteOptions, moduleCache: ModuleCacheMap, request?: (dep: string) => unknown);
+    constructor(options: ExecuteOptions, moduleCache: ModuleCacheMap, request?: ViteRunnerRequest);
     get mockMap(): MockMap;
     on(event: string, cb: Callback): void;
     private emit;
@@ -1049,7 +1054,7 @@ declare class VitestMocker {
     requestWithMock(dep: string): Promise<any>;
     queueMock(id: string, importer: string, factory?: () => unknown): void;
     queueUnmock(id: string, importer: string): void;
-    withRequest(request: (dep: string) => unknown): VitestMocker;
+    withRequest(request: ViteRunnerRequest): VitestMocker;
 }
 
 interface ExecuteOptions extends ViteNodeRunnerOptions {

package/dist/node.js

@@ -1,5 +1,5 @@
-export { V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.92c54acc.js';
-export { V as VitestRunner } from './chunk-runtime-mocker.89015cf8.js';
+export { V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.25eaf4e5.js';
+export { V as VitestRunner } from './chunk-runtime-mocker.ee72d19a.js';
 import 'buffer';
 import 'path';
 import 'child_process';
@@ -13,19 +13,19 @@ import 'stream';
 import 'util';
 import 'url';
 import 'os';
-import './chunk-utils-global.eb31f3da.js';
+import './chunk-utils-global.a5a8641f.js';
 import 'tty';
 import 'local-pkg';
 import 'vite';
-import './chunk-constants.54c46a47.js';
+import './chunk-constants.0567483c.js';
 import 'readline';
-import './chunk-vite-node-utils.3cb38009.js';
+import './chunk-vite-node-utils.20782527.js';
 import 'module';
 import 'vm';
-import './chunk-defaults.c143550b.js';
+import './chunk-defaults.23b3ae8a.js';
 import 'worker_threads';
 import 'tinypool';
 import 'perf_hooks';
-import './chunk-utils-timers.8a5e7cd5.js';
+import './chunk-utils-timers.f25e8f44.js';
 import './chunk-magic-string.d5e0e473.js';
 import './vendor-index.405e58ef.js';

package/dist/spy.js

@@ -1,2 +1,2 @@
-export { f as fn, i as isMockFunction, a as spies, s as spyOn } from './chunk-integrations-spy.f036df6f.js';
+export { f as fn, i as isMockFunction, a as spies, s as spyOn } from './chunk-integrations-spy.bee66426.js';
 import 'tinyspy';

package/dist/{vendor-entry.a660e61c.js → vendor-entry.b20b007c.js}

@@ -1,13 +1,13 @@
 import { promises } from 'fs';
-import { b as getWorkerState, t as toArray, H as clone, F as getType, m as relative, B as stdout, I as partitionSuiteChildren, J as hasTests, u as hasFailed, q as getFullName, r as resetModules } from './chunk-utils-global.eb31f3da.js';
+import { a as getWorkerState, t as toArray, G as clone, E as getType, l as relative, A as stdout, H as partitionSuiteChildren, I as hasTests, q as hasFailed, o as getFullName, r as resetModules } from './chunk-utils-global.a5a8641f.js';
 import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
-import { s as suite, t as test, d as describe, i as it, r as runOnce, a as isFirstRun, b as beforeAll, c as afterAll, e as beforeEach, f as afterEach, w as withCallback, g as createExpect, h as expect, v as vitest, j as vi, k as getRunningMode, l as isWatchMode, m as resetRunOnceCounter, R as RealDate, n as clearCollectorContext, o as defaultSuite, p as setHooks, q as getHooks, u as collectorContext, x as getSnapshotClient, y as setState, z as getFn, A as getState } from './chunk-runtime-chain.0ac0691b.js';
+import { s as suite, t as test, d as describe, i as it, r as runOnce, a as isFirstRun, b as beforeAll, c as afterAll, e as beforeEach, f as afterEach, w as withCallback, g as createExpect, h as expect, v as vitest, j as vi, k as getRunningMode, l as isWatchMode, m as resetRunOnceCounter, R as RealDate, n as clearCollectorContext, o as defaultSuite, p as setHooks, q as getHooks, u as collectorContext, x as getSnapshotClient, y as setState, z as getFn, A as getState } from './chunk-runtime-chain.37b69607.js';
 import chai, { assert, should, util } from 'chai';
-import { r as rpc } from './chunk-runtime-rpc.710f6f7f.js';
-import { d as clearTimeout, c as setTimeout, s as stringify } from './chunk-utils-timers.8a5e7cd5.js';
-import { t as takeCoverage } from './chunk-defaults.c143550b.js';
+import { r as rpc } from './chunk-runtime-rpc.63398738.js';
+import { d as clearTimeout, c as setTimeout, s as stringify } from './chunk-utils-timers.f25e8f44.js';
+import { t as takeCoverage } from './chunk-defaults.23b3ae8a.js';
 import { createHash } from 'crypto';
 import { format } from 'util';
 
@@ -212,6 +212,7 @@ const OTHER_KEYS = [
   "atob",
   "blur",
   "btoa",
+  "cancelAnimationFrame",
   "close",
   "confirm",
   "createPopup",
@@ -240,6 +241,7 @@ const OTHER_KEYS = [
   "print",
   "prompt",
   "removeEventListener",
+  "requestAnimationFrame",
   "resizeBy",
   "resizeTo",
   "screen",
@@ -262,20 +264,118 @@ const OTHER_KEYS = [
 ];
 const KEYS = LIVING_KEYS.concat(OTHER_KEYS);
 
-const allowRewrite = /* @__PURE__ */ new Set([
+const allowRewrite = [
   "Event",
   "EventTarget"
-]);
+];
+const skipKeys = [
+  "window",
+  "self",
+  "top",
+  "parent"
+];
 function getWindowKeys(global, win) {
   const keys = new Set(KEYS.concat(Object.getOwnPropertyNames(win)).filter((k) => {
-    if (k.startsWith("_"))
+    if (k.startsWith("_") || skipKeys.includes(k))
       return false;
     if (k in global)
-      return allowRewrite.has(k);
+      return allowRewrite.includes(k);
     return true;
   }));
   return keys;
 }
+function populateGlobal(global, win, options = {}) {
+  const { bindFunctions = false } = options;
+  const keys = getWindowKeys(global, win);
+  const overrideObject = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const shouldBind = bindFunctions && typeof win[key] === "function";
+    Object.defineProperty(global, key, {
+      get() {
+        if (overrideObject.has(key))
+          return overrideObject.get(key);
+        if (shouldBind)
+          return win[key].bind(win);
+        return win[key];
+      },
+      set(v) {
+        overrideObject.set(key, v);
+      },
+      configurable: true
+    });
+  }
+  const globalKeys = /* @__PURE__ */ new Set(["window", "self", "top", "parent"]);
+  const globalProxy = new Proxy(win.window, {
+    get(target, p, receiver) {
+      if (overrideObject.has(p))
+        return overrideObject.get(p);
+      return Reflect.get(target, p, receiver);
+    },
+    set(target, p, value, receiver) {
+      try {
+        Object.defineProperty(global, p, {
+          get: () => overrideObject.get(p),
+          set: (value2) => overrideObject.set(p, value2),
+          configurable: true
+        });
+        overrideObject.set(p, value);
+        Reflect.set(target, p, value, receiver);
+      } catch {
+      }
+      return true;
+    },
+    deleteProperty(target, p) {
+      Reflect.deleteProperty(global, p);
+      overrideObject.delete(p);
+      return Reflect.deleteProperty(target, p);
+    },
+    defineProperty(target, p, attributes) {
+      if (attributes.writable && "value" in attributes) ; else if (attributes.get) {
+        overrideObject.delete(p);
+        Reflect.defineProperty(global, p, attributes);
+      }
+      return Reflect.defineProperty(target, p, attributes);
+    }
+  });
+  globalKeys.forEach((key) => {
+    if (!win[key])
+      return;
+    Object.defineProperty(global, key, {
+      get() {
+        return globalProxy;
+      },
+      configurable: true
+    });
+  });
+  const globalThisProxy = new Proxy(global.globalThis, {
+    set(target, key, value, receiver) {
+      overrideObject.set(key, value);
+      return Reflect.set(target, key, value, receiver);
+    },
+    deleteProperty(target, key) {
+      overrideObject.delete(key);
+      return Reflect.deleteProperty(target, key);
+    },
+    defineProperty(target, p, attributes) {
+      if (attributes.writable && "value" in attributes) ; else if (attributes.get && !globalKeys.has(p)) {
+        globalKeys.forEach((key) => {
+          if (win[key])
+            Object.defineProperty(win[key], p, attributes);
+        });
+      }
+      return Reflect.defineProperty(target, p, attributes);
+    }
+  });
+  global.globalThis = globalThisProxy;
+  if (global.global)
+    global.global = globalThisProxy;
+  skipKeys.forEach((k) => keys.add(k));
+  return {
+    keys,
+    skipKeys,
+    allowRewrite
+  };
+}
 
 var __defProp$1 = Object.defineProperty;
 var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
@@ -348,24 +448,12 @@ var jsdom = {
       contentType,
       userAgent
     }, restOptions));
-    const keys = getWindowKeys(global, dom.window);
-    const overrideObject = /* @__PURE__ */ new Map();
-    for (const key of keys) {
-      Object.defineProperty(global, key, {
-        get() {
-          if (overrideObject.has(key))
-            return overrideObject.get(key);
-          return dom.window[key];
-        },
-        set(v) {
-          overrideObject.set(key, v);
-        },
-        configurable: true
-      });
-    }
+    const { keys, allowRewrite } = populateGlobal(global, dom.window);
+    const originals = new Map(allowRewrite.map(([key]) => [key, global[key]]));
     return {
       teardown(global2) {
         keys.forEach((key) => delete global2[key]);
+        originals.forEach((v, k) => global2[k] = v);
       }
     };
   }
@@ -376,25 +464,13 @@ var happy = {
   async setup(global) {
     const { Window, GlobalWindow } = await importModule("happy-dom");
     const win = new (GlobalWindow || Window)();
-    const keys = getWindowKeys(global, win);
-    const overrideObject = /* @__PURE__ */ new Map();
-    for (const key of keys) {
-      Object.defineProperty(global, key, {
-        get() {
-          if (overrideObject.has(key))
-            return overrideObject.get(key);
-          return win[key];
-        },
-        set(v) {
-          overrideObject.set(key, v);
-        },
-        configurable: true
-      });
-    }
+    const { keys, allowRewrite } = populateGlobal(global, win, { bindFunctions: true });
+    const originals = new Map(allowRewrite.map(([key]) => [key, global[key]]));
     return {
       teardown(global2) {
         win.happyDOM.cancelAsync();
         keys.forEach((key) => delete global2[key]);
+        originals.forEach((v, k) => global2[k] = v);
       }
     };
   }
@@ -419,7 +495,7 @@ async function setupGlobalEnv(config) {
   globalSetup = true;
   setupConsoleLogSpy();
   if (config.globals)
-    (await import('./chunk-integrations-globals.6bdc721a.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.a37b2801.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)
@@ -970,21 +1046,39 @@ function clearModuleMocks() {
 }
 
 async function run(files, config) {
-  var _a;
   await setupGlobalEnv(config);
   const workerState = getWorkerState();
-  for (const file of files) {
-    workerState.mockMap.clear();
-    resetModules();
+  const envs = ["node", "jsdom", "happy-dom"];
+  const filesWithEnv = await Promise.all(files.map(async (file) => {
+    var _a;
     const code = await promises.readFile(file, "utf-8");
     const env = ((_a = code.match(/@(?:vitest|jest)-environment\s+?([\w-]+)\b/)) == null ? void 0 : _a[1]) || config.environment || "node";
-    if (!["node", "jsdom", "happy-dom"].includes(env))
-      throw new Error(`Unsupported environment: ${env}`);
-    workerState.filepath = file;
-    await withEnv(env, config.environmentOptions || {}, async () => {
-      await startTests([file], config);
+    if (!envs.includes(env))
+      throw new Error(`Unsupported environment: "${env}" in ${file}`);
+    return {
+      file,
+      env
+    };
+  }));
+  const filesByEnv = filesWithEnv.reduce((acc, { file, env }) => {
+    acc[env] || (acc[env] = []);
+    acc[env].push(file);
+    return acc;
+  }, {});
+  for (const env of envs) {
+    const environment = env;
+    const files2 = filesByEnv[environment];
+    if (!files2 || !files2.length)
+      continue;
+    await withEnv(environment, config.environmentOptions || {}, async () => {
+      for (const file of files2) {
+        workerState.mockMap.clear();
+        resetModules();
+        workerState.filepath = file;
+        await startTests([file], config);
+        workerState.filepath = void 0;
+      }
     });
-    workerState.filepath = void 0;
   }
 }
 

package/dist/worker.js

@@ -1,8 +1,8 @@
-import { k as resolve, b as getWorkerState, B as stdout } from './chunk-utils-global.eb31f3da.js';
-import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-utils.3cb38009.js';
-import { d as distDir } from './chunk-constants.54c46a47.js';
-import { e as executeInViteNode } from './chunk-runtime-mocker.89015cf8.js';
-import { r as rpc } from './chunk-runtime-rpc.710f6f7f.js';
+import { h as resolve, a as getWorkerState, A as stdout } from './chunk-utils-global.a5a8641f.js';
+import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-utils.20782527.js';
+import { d as distDir } from './chunk-constants.0567483c.js';
+import { e as executeInViteNode } from './chunk-runtime-mocker.ee72d19a.js';
+import { r as rpc } from './chunk-runtime-rpc.63398738.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
@@ -32,7 +32,7 @@ async function startViteNode(ctx) {
     rpc().onUnhandledRejection(err);
   });
   const { config } = ctx;
-  const { run: run2, collect: collect2 } = (await executeInViteNode({
+  const { run: run2 } = (await executeInViteNode({
     files: [
       resolve(distDir, "entry.js")
     ],
@@ -48,7 +48,7 @@ async function startViteNode(ctx) {
     root: config.root,
     base: config.base
   }))[0];
-  _viteNode = { run: run2, collect: collect2 };
+  _viteNode = { run: run2 };
   return _viteNode;
 }
 function init(ctx) {
@@ -72,19 +72,18 @@ function init(ctx) {
       }
     })
   };
-  if (ctx.invalidates)
-    ctx.invalidates.forEach((i) => moduleCache.delete(i));
+  if (ctx.invalidates) {
+    ctx.invalidates.forEach((i) => {
+      moduleCache.delete(i);
+      moduleCache.delete(`${i}__mock`);
+    });
+  }
   ctx.files.forEach((i) => moduleCache.delete(i));
 }
-async function collect(ctx) {
-  init(ctx);
-  const { collect: collect2 } = await startViteNode(ctx);
-  return collect2(ctx.files, ctx.config);
-}
 async function run(ctx) {
   init(ctx);
   const { run: run2 } = await startViteNode(ctx);
   return run2(ctx.files, ctx.config);
 }
 
-export { collect, run };
+export { run };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vitest",
   "type": "module",
-  "version": "0.10.4",
+  "version": "0.12.0",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -93,7 +93,7 @@
     "@types/node": "^17.0.31",
     "@types/prompts": "^2.4.0",
     "@types/sinonjs__fake-timers": "^8.1.2",
-    "@vitest/ui": "0.10.4",
+    "@vitest/ui": "0.12.0",
     "birpc": "^0.2.2",
     "c8": "^7.11.2",
     "cac": "^6.7.12",
@@ -116,11 +116,11 @@
     "pkg-types": "^0.3.2",
     "pretty-format": "^27.5.1",
     "prompts": "^2.4.2",
-    "rollup": "^2.71.1",
+    "rollup": "^2.72.1",
     "source-map-js": "^1.0.2",
     "strip-ansi": "^7.0.1",
     "typescript": "^4.6.4",
-    "vite-node": "0.10.4",
+    "vite-node": "0.12.0",
     "ws": "^8.6.0"
   },
   "engines": {