vitest 0.10.5 → 0.11.0

package/dist/{chunk-api-setup.2c4e9375.js → chunk-api-setup.87a943bf.js}

@@ -1,5 +1,5 @@
 import { promises } from 'fs';
-import { c as createBirpc } from './chunk-vite-node-utils.6b0ec89a.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.27e0c6e9.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.d3383e75.js → chunk-integrations-globals.1ce15dfd.js}

@@ -1,22 +1,22 @@
-import { g as globalApis } from './chunk-constants.54c46a47.js';
-import { i as index } from './vendor-entry.9551d577.js';
+import { g as globalApis } from './chunk-constants.0567483c.js';
+import { i as index } from './vendor-entry.1b0b46f1.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.d0bd6df6.js';
+import './chunk-runtime-chain.8a313ffb.js';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.710f6f7f.js';
-import './chunk-utils-timers.27e0c6e9.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.d0bd6df6.js → chunk-runtime-chain.8a313ffb.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.27e0c6e9.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 {
   }
 }
@@ -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.0871693a.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.6b0ec89a.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.27e0c6e9.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;

package/dist/{chunk-vite-node-externalize.965e6527.js → chunk-vite-node-externalize.d6642729.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.6b0ec89a.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.27e0c6e9.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.5";
+var version = "0.11.0";
 
 function stripFinalNewline(input) {
 	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
@@ -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.2c4e9375.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.6b0ec89a.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,6 +8969,18 @@ ${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];
@@ -8998,13 +9006,19 @@ ${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,
@@ -9024,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.965e6527.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.d6642729.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.6b0ec89a.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.27e0c6e9.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.9551d577.js';
+export { r as run } from './vendor-entry.1b0b46f1.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.d0bd6df6.js';
+import './chunk-runtime-chain.8a313ffb.js';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
-import './chunk-runtime-rpc.710f6f7f.js';
-import './chunk-utils-timers.27e0c6e9.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;

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.d0bd6df6.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.8a313ffb.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.27e0c6e9.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;
@@ -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.965e6527.js';
-export { V as VitestRunner } from './chunk-runtime-mocker.0871693a.js';
+export { V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.d6642729.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.6b0ec89a.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.27e0c6e9.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.9551d577.js → vendor-entry.1b0b46f1.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.d0bd6df6.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.8a313ffb.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.27e0c6e9.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,109 @@ const OTHER_KEYS = [
 ];
 const KEYS = LIVING_KEYS.concat(OTHER_KEYS);
 
-const allowRewrite = /* @__PURE__ */ new Set([
+const allowRewrite = [
   "Event",
   "EventTarget"
-]);
+];
+const skipKeys = [
+  "window",
+  "self"
+];
 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) {
+  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 globalKeys = /* @__PURE__ */ new Set(["window", "self", "GLOBAL", "global"]);
+  globalKeys.forEach((key) => {
+    if (!win[key])
+      return;
+    const proxy = new Proxy(win[key], {
+      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);
+      }
+    });
+    Object.defineProperty(global, key, {
+      get() {
+        return proxy;
+      },
+      configurable: true
+    });
+  });
+  global.globalThis = 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);
+    }
+  });
+  skipKeys.forEach((k) => keys.add(k));
+  return {
+    keys,
+    skipKeys,
+    allowRewrite
+  };
+}
 
 var __defProp$1 = Object.defineProperty;
 var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
@@ -348,24 +439,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 +455,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);
+    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 +486,7 @@ async function setupGlobalEnv(config) {
   globalSetup = true;
   setupConsoleLogSpy();
   if (config.globals)
-    (await import('./chunk-integrations-globals.d3383e75.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.1ce15dfd.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)

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.6b0ec89a.js';
-import { d as distDir } from './chunk-constants.54c46a47.js';
-import { e as executeInViteNode } from './chunk-runtime-mocker.0871693a.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.5",
+  "version": "0.11.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.5",
+    "@vitest/ui": "0.11.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.5",
+    "vite-node": "0.11.0",
     "ws": "^8.6.0"
   },
   "engines": {