vitest 0.28.4 → 0.29.0

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { UserConfig as UserConfig$2, ConfigEnv } from 'vite';
 export { ConfigEnv } from 'vite';
-import { a1 as ResolvedCoverageOptions, U as UserConfig$1, a4 as CoverageC8Options, _ as CoverageProviderModule, a2 as BaseCoverageOptions, a3 as CoverageIstanbulOptions, $ as CoverageReporter, F as FakeTimerInstallOpts } from './types-aac763a5.js';
+import { a3 as ResolvedCoverageOptions, U as UserConfig$1, a6 as CoverageC8Options, a7 as CustomProviderOptions, a5 as CoverageIstanbulOptions, ah as HtmlOptions, ai as FileOptions, aj as CloverOptions, ak as CoberturaOptions, al as HtmlSpaOptions, am as LcovOptions, an as LcovOnlyOptions, ao as TeamcityOptions, ap as TextOptions, aq as ProjectOptions, F as FakeTimerInstallOpts } from './types-7cd96283.js';
 import '@vitest/expect';
 import '@vitest/runner/types';
 import '@vitest/runner';
@@ -11,6 +11,7 @@ import 'vite-node/client';
 import 'vite-node/server';
 import 'node:worker_threads';
 import 'vite-node';
+import 'source-map';
 import 'node:fs';
 
 declare const defaultInclude: string[];
@@ -44,17 +45,17 @@ declare const config: {
         include: never[];
     };
     coverage: {
-        provider?: "c8" | undefined;
+        provider: "c8";
     } & CoverageC8Options & Required<Pick<({
         provider?: undefined;
     } & CoverageC8Options) | ({
-        provider: CoverageProviderModule;
-    } & BaseCoverageOptions) | ({
-        provider?: "c8" | undefined;
+        provider: "custom";
+    } & CustomProviderOptions) | ({
+        provider: "c8";
     } & CoverageC8Options) | ({
         provider: "istanbul";
-    } & CoverageIstanbulOptions), "exclude" | "enabled" | "clean" | "cleanOnRerun" | "reportsDirectory" | "extension" | "reporter">> & {
-        reporter: CoverageReporter[];
+    } & CoverageIstanbulOptions), "exclude" | "enabled" | "clean" | "cleanOnRerun" | "reportsDirectory" | "extension">> & {
+        reporter: (["html", Partial<HtmlOptions>] | ["json", Partial<FileOptions>] | ["none", {}] | ["clover", Partial<CloverOptions>] | ["cobertura", Partial<CoberturaOptions>] | ["html-spa", Partial<HtmlSpaOptions>] | ["json-summary", Partial<FileOptions>] | ["lcov", Partial<LcovOptions>] | ["lcovonly", Partial<LcovOnlyOptions>] | ["teamcity", Partial<TeamcityOptions>] | ["text", Partial<TextOptions>] | ["text-lcov", Partial<ProjectOptions>] | ["text-summary", Partial<FileOptions>])[];
     };
     fakeTimers: FakeTimerInstallOpts;
     maxConcurrency: number;

package/dist/config.js

@@ -26,7 +26,7 @@ const coverageConfigDefaults = {
   cleanOnRerun: true,
   reportsDirectory: "./coverage",
   exclude: defaultCoverageExcludes,
-  reporter: ["text", "html", "clover", "json"],
+  reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte"]
 };
 const fakeTimersDefaults = {

package/dist/coverage.d.ts

@@ -0,0 +1,142 @@
+import { a4 as BaseCoverageOptions, a3 as ResolvedCoverageOptions } from './types-7cd96283.js';
+import '@vitest/expect';
+import 'vite';
+import '@vitest/runner/types';
+import '@vitest/runner';
+import '@vitest/runner/utils';
+import '@vitest/utils';
+import 'tinybench';
+import 'vite-node/client';
+import 'vite-node/server';
+import 'node:worker_threads';
+import 'vite-node';
+import 'source-map';
+import 'node:fs';
+
+// Type definitions for istanbul-lib-coverage 2.0
+// Project: https://istanbul.js.org, https://github.com/istanbuljs/istanbuljs
+// Definitions by: Jason Cheatham <https://github.com/jason0x43>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
+
+interface CoverageSummaryData {
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+declare class CoverageSummary {
+    constructor(data: CoverageSummary | CoverageSummaryData);
+    merge(obj: CoverageSummary): CoverageSummary;
+    toJSON(): CoverageSummaryData;
+    isEmpty(): boolean;
+    data: CoverageSummaryData;
+    lines: Totals;
+    statements: Totals;
+    branches: Totals;
+    functions: Totals;
+}
+
+interface CoverageMapData {
+    [key: string]: FileCoverage | FileCoverageData;
+}
+
+declare class CoverageMap {
+    constructor(data: CoverageMapData | CoverageMap);
+    addFileCoverage(pathOrObject: string | FileCoverage | FileCoverageData): void;
+    files(): string[];
+    fileCoverageFor(filename: string): FileCoverage;
+    filter(callback: (key: string) => boolean): void;
+    getCoverageSummary(): CoverageSummary;
+    merge(data: CoverageMapData | CoverageMap): void;
+    toJSON(): CoverageMapData;
+    data: CoverageMapData;
+}
+
+interface Location {
+    line: number;
+    column: number;
+}
+
+interface Range {
+    start: Location;
+    end: Location;
+}
+
+interface BranchMapping {
+    loc: Range;
+    type: string;
+    locations: Range[];
+    line: number;
+}
+
+interface FunctionMapping {
+    name: string;
+    decl: Range;
+    loc: Range;
+    line: number;
+}
+
+interface FileCoverageData {
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+interface Totals {
+    total: number;
+    covered: number;
+    skipped: number;
+    pct: number;
+}
+
+interface Coverage {
+    covered: number;
+    total: number;
+    coverage: number;
+}
+
+declare class FileCoverage implements FileCoverageData {
+    constructor(data: string | FileCoverage | FileCoverageData);
+    merge(other: FileCoverageData): void;
+    getBranchCoverageByLine(): { [line: number]: Coverage };
+    getLineCoverage(): { [line: number]: number };
+    getUncoveredLines(): number[];
+    resetHits(): void;
+    computeBranchTotals(): Totals;
+    computeSimpleTotals(): Totals;
+    toSummary(): CoverageSummary;
+    toJSON(): object;
+
+    data: FileCoverageData;
+    path: string;
+    statementMap: { [key: string]: Range };
+    fnMap: { [key: string]: FunctionMapping };
+    branchMap: { [key: string]: BranchMapping };
+    s: { [key: string]: number };
+    f: { [key: string]: number };
+    b: { [key: string]: number[] };
+}
+
+type Threshold = 'lines' | 'functions' | 'statements' | 'branches';
+declare class BaseCoverageProvider {
+    /**
+     * Check if current coverage is above configured thresholds and bump the thresholds if needed
+     */
+    updateThresholds({ configurationFile, coverageMap, thresholds }: {
+        coverageMap: CoverageMap;
+        thresholds: Record<Threshold, number | undefined>;
+        configurationFile?: string;
+    }): void;
+    /**
+     * Resolve reporters from various configuration options
+     */
+    resolveReporters(configReporters: NonNullable<BaseCoverageOptions['reporter']>): ResolvedCoverageOptions['reporter'];
+}
+
+export { BaseCoverageProvider };

package/dist/coverage.js

@@ -0,0 +1,49 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+
+const THRESHOLD_KEYS = ["lines", "functions", "statements", "branches"];
+class BaseCoverageProvider {
+  updateThresholds({ configurationFile, coverageMap, thresholds }) {
+    if (!configurationFile)
+      throw new Error('Missing configurationFile. The "coverage.thresholdAutoUpdate" can only be enabled when configuration file is used.');
+    const summary = coverageMap.getCoverageSummary();
+    const thresholdsToUpdate = [];
+    for (const key of THRESHOLD_KEYS) {
+      const threshold = thresholds[key] || 100;
+      const actual = summary[key].pct;
+      if (actual > threshold)
+        thresholdsToUpdate.push(key);
+    }
+    if (thresholdsToUpdate.length === 0)
+      return;
+    const originalConfig = readFileSync(configurationFile, "utf8");
+    let updatedConfig = originalConfig;
+    for (const threshold of thresholdsToUpdate) {
+      const previousThreshold = (thresholds[threshold] || 100).toString();
+      const pattern = new RegExp(`(${threshold}\\s*:\\s*)${previousThreshold.replace(".", "\\.")}`);
+      const matches = originalConfig.match(pattern);
+      if (matches)
+        updatedConfig = updatedConfig.replace(matches[0], matches[1] + summary[threshold].pct);
+      else
+        console.error(`Unable to update coverage threshold ${threshold}. No threshold found using pattern ${pattern}`);
+    }
+    if (updatedConfig !== originalConfig) {
+      console.log("Updating thresholds to configuration file. You may want to push with updated coverage thresholds.");
+      writeFileSync(configurationFile, updatedConfig, "utf-8");
+    }
+  }
+  resolveReporters(configReporters) {
+    if (!Array.isArray(configReporters))
+      return [[configReporters, {}]];
+    const resolvedReporters = [];
+    for (const reporter of configReporters) {
+      if (Array.isArray(reporter)) {
+        resolvedReporters.push([reporter[0], reporter[1] || {}]);
+      } else {
+        resolvedReporters.push([reporter, {}]);
+      }
+    }
+    return resolvedReporters;
+  }
+}
+
+export { BaseCoverageProvider };

package/dist/entry.js

@@ -1,33 +1,33 @@
-import { promises, existsSync } from 'node:fs';
-import { m as micromatch_1, t as takeCoverageInsideWorker } from './chunk-integrations-coverage.48e6286b.js';
 import { startTests } from '@vitest/runner';
-import { g as getWorkerState, r as resetModules } from './chunk-utils-global.442d1d33.js';
-import { R as RealDate, g as globalExpect, a as vi } from './chunk-utils-import.0402c9db.js';
-import { e as environments, a as envs } from './chunk-env-node.ffd1183b.js';
+import { resolve } from 'pathe';
+import { g as getWorkerState, r as resetModules } from './chunk-utils-global.727b6d25.js';
+import { R as RealDate, g as globalExpect, a as vi } from './chunk-utils-import.ec15dcad.js';
+import { d as distDir } from './chunk-constants.797d3ebf.js';
+import { s as startCoverageInsideWorker, t as takeCoverageInsideWorker, a as stopCoverageInsideWorker } from './chunk-integrations-coverage.e0a6acd2.js';
 import { createRequire } from 'node:module';
 import c from 'picocolors';
 import { installSourcemapsSupport } from 'vite-node/source-map';
 import { setColors, getSafeTimers } from '@vitest/utils';
-import { i as index } from './chunk-integrations-utils.dae69d89.js';
-import { s as setupSnapshotEnvironment } from './chunk-snapshot-env.6457638e.js';
-import { r as rpc } from './chunk-runtime-rpc.9c0386cc.js';
-import { s as setupCommonEnv } from './chunk-runtime-setup.7dfc1a6a.js';
-import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './runners-chunk.js';
-import 'local-pkg';
-import 'util';
-import 'path';
-import 'pathe';
+import { e as environments } from './chunk-env-node.affdd278.js';
+import { i as index } from './chunk-integrations-utils.233d6a3b.js';
+import { s as setupSnapshotEnvironment } from './chunk-snapshot-env.a347d647.js';
+import { promises, existsSync } from 'node:fs';
+import { r as rpc } from './chunk-runtime-rpc.971b3848.js';
+import { s as setupCommonEnv } from './chunk-runtime-setup.992bb661.js';
 import './chunk-utils-env.860d90c2.js';
 import 'std-env';
 import '@vitest/runner/utils';
 import 'chai';
 import './vendor-_commonjsHelpers.addc3445.js';
 import '@vitest/expect';
-import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.a9a8d8e1.js';
+import './chunk-utils-base.81f83dbd.js';
+import './chunk-utils-tasks.b41c8284.js';
+import 'util';
 import '@vitest/spy';
+import 'node:url';
+import 'local-pkg';
 import 'node:console';
-import './chunk-integrations-run-once.38756e30.js';
+import './chunk-integrations-run-once.9012f759.js';
 
 class NodeSnapshotEnvironment {
   resolvePath(filepath) {
@@ -175,8 +175,8 @@ async function setupConsoleLogSpy() {
     groupIndentation: 2
   });
 }
-async function loadEnvironment(name) {
-  const pkg = await import(`vitest-environment-${name}`);
+async function loadEnvironment(name, executor) {
+  const pkg = await executor.executeId(`vitest-environment-${name}`);
   if (!pkg || !pkg.default || typeof pkg.default !== "object" || typeof pkg.default.setup !== "function") {
     throw new Error(
       `Environment "${name}" is not a valid environment. Package "vitest-environment-${name}" should have default export with "setup" method.`
@@ -184,8 +184,8 @@ async function loadEnvironment(name) {
   }
   return pkg.default;
 }
-async function withEnv(name, options, fn) {
-  const config = environments[name] || await loadEnvironment(name);
+async function withEnv(name, options, executor, fn) {
+  const config = environments[name] || await loadEnvironment(name, executor);
   globalThis.__vitest_environment__ = config.name || name;
   globalExpect.setState({
     environment: config.name || name || "node"
@@ -198,25 +198,25 @@ async function withEnv(name, options, fn) {
   }
 }
 
-function groupBy(collection, iteratee) {
-  return collection.reduce((acc, item) => {
-    const key = iteratee(item);
-    acc[key] || (acc[key] = []);
-    acc[key].push(item);
-    return acc;
-  }, {});
-}
-async function getTestRunnerConstructor(config) {
-  if (!config.runner)
+const runnersFile = resolve(distDir, "runners.js");
+async function getTestRunnerConstructor(config, executor) {
+  if (!config.runner) {
+    const { VitestTestRunner, NodeBenchmarkRunner } = await executor.executeFile(runnersFile);
     return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
-  const mod = await import(config.runner);
+  }
+  const mod = await executor.executeId(config.runner);
   if (!mod.default && typeof mod.default !== "function")
     throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
   return mod.default;
 }
-async function getTestRunner(config) {
-  const TestRunner = await getTestRunnerConstructor(config);
+async function getTestRunner(config, executor) {
+  const TestRunner = await getTestRunnerConstructor(config, executor);
   const testRunner = new TestRunner(config);
+  Object.defineProperty(testRunner, "__vitest_executor", {
+    value: executor,
+    enumerable: false,
+    configurable: false
+  });
   if (!testRunner.config)
     testRunner.config = config;
   if (!testRunner.importFile)
@@ -234,65 +234,32 @@ async function getTestRunner(config) {
   };
   const originalOnAfterRun = testRunner.onAfterRun;
   testRunner.onAfterRun = async (files) => {
-    const coverage = await takeCoverageInsideWorker(config.coverage);
+    const coverage = await takeCoverageInsideWorker(config.coverage, executor);
     rpc().onAfterSuiteRun({ coverage });
     await (originalOnAfterRun == null ? void 0 : originalOnAfterRun.call(testRunner, files));
   };
   return testRunner;
 }
-async function run(files, config) {
+async function run(files, config, environment, executor) {
   await setupGlobalEnv(config);
+  await startCoverageInsideWorker(config.coverage, executor);
   const workerState = getWorkerState();
-  const runner = await getTestRunner(config);
-  const filesWithEnv = await Promise.all(files.map(async (file) => {
-    var _a, _b;
-    const code = await promises.readFile(file, "utf-8");
-    let env = (_a = code.match(/@(?:vitest|jest)-environment\s+?([\w-]+)\b/)) == null ? void 0 : _a[1];
-    if (!env) {
-      for (const [glob, target] of config.environmentMatchGlobs || []) {
-        if (micromatch_1.isMatch(file, glob)) {
-          env = target;
-          break;
-        }
+  const runner = await getTestRunner(config, executor);
+  globalThis.__vitest_environment__ = environment;
+  await withEnv(environment.name, environment.options || config.environmentOptions || {}, executor, async () => {
+    for (const file of files) {
+      if (config.isolate) {
+        workerState.mockMap.clear();
+        resetModules(workerState.moduleCache, true);
       }
+      workerState.filepath = file;
+      await startTests([file], runner);
+      workerState.filepath = void 0;
+      vi.resetConfig();
+      vi.restoreAllMocks();
     }
-    env || (env = config.environment || "node");
-    const envOptions = JSON.parse(((_b = code.match(/@(?:vitest|jest)-environment-options\s+?(.+)/)) == null ? void 0 : _b[1]) || "null");
-    return {
-      file,
-      env,
-      envOptions: envOptions ? { [env]: envOptions } : null
-    };
-  }));
-  const filesByEnv = groupBy(filesWithEnv, ({ env }) => env);
-  const orderedEnvs = envs.concat(
-    Object.keys(filesByEnv).filter((env) => !envs.includes(env))
-  );
-  for (const env of orderedEnvs) {
-    const environment = env;
-    const files2 = filesByEnv[environment];
-    if (!files2 || !files2.length)
-      continue;
-    globalThis.__vitest_environment__ = environment;
-    const filesByOptions = groupBy(files2, ({ envOptions }) => JSON.stringify(envOptions));
-    for (const options of Object.keys(filesByOptions)) {
-      const files3 = filesByOptions[options];
-      if (!files3 || !files3.length)
-        continue;
-      await withEnv(environment, files3[0].envOptions || config.environmentOptions || {}, async () => {
-        for (const { file } of files3) {
-          if (config.isolate) {
-            workerState.mockMap.clear();
-            resetModules(workerState.moduleCache, true);
-          }
-          workerState.filepath = file;
-          await startTests([file], runner);
-          workerState.filepath = void 0;
-          vi.resetConfig();
-        }
-      });
-    }
-  }
+    await stopCoverageInsideWorker(config.coverage, executor);
+  });
 }
 
 export { run };

package/dist/environments.d.ts

@@ -1,4 +1,4 @@
-import { P as Environment } from './types-aac763a5.js';
+import { X as Environment } from './types-7cd96283.js';
 import '@vitest/expect';
 import 'vite';
 import '@vitest/runner/types';
@@ -10,6 +10,7 @@ import 'vite-node/client';
 import 'vite-node/server';
 import 'node:worker_threads';
 import 'vite-node';
+import 'source-map';
 import 'node:fs';
 
 declare const environments: {

package/dist/environments.js

@@ -1,3 +1,3 @@
-export { e as builtinEnvironments, p as populateGlobal } from './chunk-env-node.ffd1183b.js';
+export { e as builtinEnvironments, p as populateGlobal } from './chunk-env-node.affdd278.js';
 import 'node:console';
 import 'local-pkg';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Test } from '@vitest/runner';
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-import { B as BenchmarkAPI, F as FakeTimerInstallOpts, M as MockFactoryWithHelper, R as RuntimeConfig, a as ResolvedConfig, b as ModuleGraphData, S as SnapshotResult, c as Reporter } from './types-aac763a5.js';
-export { u as AfterSuiteRunMeta, A as ApiConfig, z as ArgumentsType, y as Arrayable, x as Awaitable, a2 as BaseCoverageOptions, a8 as BenchFunction, a6 as Benchmark, B as BenchmarkAPI, a7 as BenchmarkResult, a5 as BenchmarkUserOptions, h as BuiltinEnvironment, i as CSSModuleScopeStrategy, C as CollectLineNumbers, e as CollectLines, K as Constructable, g as Context, a4 as CoverageC8Options, a3 as CoverageIstanbulOptions, a0 as CoverageOptions, Y as CoverageProvider, _ as CoverageProviderModule, $ as CoverageReporter, G as DeepMerge, P as Environment, E as EnvironmentOptions, O as EnvironmentReturn, I as InlineConfig, J as JSDOMOptions, D as MergeInsertions, L as ModuleCache, b as ModuleGraphData, H as MutableArray, N as Nullable, X as OnServerRestartHandler, d as RawErrsMap, Z as ReportContext, c as Reporter, t as ResolveIdFunction, a as ResolvedConfig, a1 as ResolvedCoverageOptions, f as RootAndTarget, R as RuntimeConfig, j as SequenceHooks, n as SnapshotData, q as SnapshotMatchOptions, S as SnapshotResult, p as SnapshotStateOptions, s as SnapshotSummary, o as SnapshotUpdateState, T as TscErrorInfo, l as TypecheckConfig, r as UncheckedSnapshot, U as UserConfig, Q as UserConsoleLog, m as Vitest, V as VitestEnvironment, k as VitestRunMode, W as WorkerContext, w as WorkerGlobalState, v as WorkerRPC } from './types-aac763a5.js';
+import { B as BenchmarkAPI, F as FakeTimerInstallOpts, M as MockFactoryWithHelper, R as RuntimeConfig, a as ResolvedConfig, b as ModuleGraphData, S as SnapshotResult, c as Reporter } from './types-7cd96283.js';
+export { x as AfterSuiteRunMeta, A as ApiConfig, G as ArgumentsType, D as Arrayable, z as Awaitable, a4 as BaseCoverageOptions, ab as BenchFunction, a9 as Benchmark, B as BenchmarkAPI, aa as BenchmarkResult, a8 as BenchmarkUserOptions, h as BuiltinEnvironment, i as CSSModuleScopeStrategy, C as CollectLineNumbers, e as CollectLines, O as Constructable, g as Context, o as ContextRPC, n as ContextTestEnvironment, a6 as CoverageC8Options, a5 as CoverageIstanbulOptions, a2 as CoverageOptions, _ as CoverageProvider, a0 as CoverageProviderModule, a1 as CoverageReporter, a7 as CustomProviderOptions, K as DeepMerge, X as Environment, E as EnvironmentOptions, Q as EnvironmentReturn, I as InlineConfig, J as JSDOMOptions, H as MergeInsertions, P as ModuleCache, b as ModuleGraphData, L as MutableArray, N as Nullable, Z as OnServerRestartHandler, d as RawErrsMap, $ as ReportContext, c as Reporter, w as ResolveIdFunction, a as ResolvedConfig, a3 as ResolvedCoverageOptions, f as RootAndTarget, R as RuntimeConfig, m as RuntimeRPC, j as SequenceHooks, q as SnapshotData, t as SnapshotMatchOptions, S as SnapshotResult, s as SnapshotStateOptions, v as SnapshotSummary, r as SnapshotUpdateState, T as TscErrorInfo, l as TypecheckConfig, u as UncheckedSnapshot, U as UserConfig, Y as UserConsoleLog, p as Vitest, V as VitestEnvironment, k as VitestRunMode, W as WorkerContext, y as WorkerGlobalState } from './types-7cd96283.js';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, EnhancedSpy } from '@vitest/spy';
 export { EnhancedSpy, Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject, SpyInstance } from '@vitest/spy';
 export { S as SnapshotEnvironment } from './env-afee91f0.js';
@@ -19,6 +19,7 @@ import 'vite-node/client';
 import 'vite-node/server';
 import 'node:worker_threads';
 import 'vite-node';
+import 'source-map';
 import 'node:fs';
 
 declare type Not<T extends boolean> = T extends true ? false : true;
@@ -306,7 +307,7 @@ declare class VitestUtils {
      */
     unstubAllGlobals(): this;
     /**
-     * Reset enviromental variables to the ones that were available before first `vi.stubEnv` was called.
+     * Reset environmental variables to the ones that were available before first `vi.stubEnv` was called.
      */
     unstubAllEnvs(): this;
     resetModules(): this;

package/dist/index.js

@@ -1,23 +1,23 @@
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-export { b as bench, c as createExpect, g as expect, a as vi, v as vitest } from './chunk-utils-import.0402c9db.js';
-export { i as isFirstRun, r as runOnce } from './chunk-integrations-run-once.38756e30.js';
-import { d as dist } from './chunk-integrations-utils.dae69d89.js';
-export { b as assertType, g as getRunningMode, a as isWatchMode } from './chunk-integrations-utils.dae69d89.js';
+export { b as bench, c as createExpect, g as expect, a as vi, v as vitest } from './chunk-utils-import.ec15dcad.js';
+export { i as isFirstRun, r as runOnce } from './chunk-integrations-run-once.9012f759.js';
+import { d as dist } from './chunk-integrations-utils.233d6a3b.js';
+export { b as assertType, g as getRunningMode, a as isWatchMode } from './chunk-integrations-utils.233d6a3b.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import './chunk-utils-global.442d1d33.js';
+import './chunk-utils-global.727b6d25.js';
 import 'pathe';
 import './chunk-utils-env.860d90c2.js';
 import 'std-env';
 import './vendor-_commonjsHelpers.addc3445.js';
 import '@vitest/expect';
-import './chunk-runtime-rpc.9c0386cc.js';
-import './chunk-snapshot-env.6457638e.js';
-import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.a9a8d8e1.js';
+import './chunk-runtime-rpc.971b3848.js';
+import './chunk-snapshot-env.a347d647.js';
+import './chunk-utils-base.81f83dbd.js';
+import './chunk-utils-tasks.b41c8284.js';
 import 'util';
 import '@vitest/spy';
 

package/dist/loader.js

@@ -2,7 +2,7 @@ import { pathToFileURL, fileURLToPath } from 'node:url';
 import { readFile } from 'node:fs/promises';
 import { i as isNodeBuiltin, h as hasCJSSyntax } from './vendor-index.bdee400f.js';
 import { normalizeModuleId } from 'vite-node/utils';
-import { g as getWorkerState } from './chunk-utils-global.442d1d33.js';
+import { g as getWorkerState } from './chunk-utils-global.727b6d25.js';
 import 'acorn';
 import 'node:module';
 import 'node:fs';
@@ -56,7 +56,7 @@ const resolve = async (url, context, next) => {
     return next(url, context, next);
   const id = normalizeModuleId(url);
   const importer = normalizeModuleId(parentURL);
-  const resolved = await resolver(id, importer);
+  const resolved = await resolver(id, importer, state.ctx.environment.name);
   let result;
   let filepath;
   if (resolved) {

package/dist/node.d.ts

@@ -1,5 +1,5 @@
-import { k as VitestRunMode, U as UserConfig, m as Vitest, a9 as MockFactory, aa as MockMap, ab as TestSequencer } from './types-aac763a5.js';
-export { ab as TestSequencer, ad as TestSequencerConstructor, m as Vitest, ac as startVitest } from './types-aac763a5.js';
+import { k as VitestRunMode, U as UserConfig, p as Vitest, ac as MockFactory, ad as MockMap, ae as TestSequencer } from './types-7cd96283.js';
+export { ae as TestSequencer, ag as TestSequencerConstructor, p as Vitest, af as startVitest } from './types-7cd96283.js';
 import { UserConfig as UserConfig$1, Plugin } from 'vite';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeRunnerOptions } from 'vite-node';
@@ -11,6 +11,7 @@ import '@vitest/utils';
 import 'tinybench';
 import 'vite-node/server';
 import 'node:worker_threads';
+import 'source-map';
 import 'node:fs';
 
 declare function createVitest(mode: VitestRunMode, options: UserConfig, viteOverrides?: UserConfig$1): Promise<Vitest>;
@@ -19,16 +20,15 @@ declare function VitestPlugin(options?: UserConfig, ctx?: Vitest): Promise<Plugi
 
 type Key = string | symbol;
 declare class VitestMocker {
-    runner: VitestRunner;
+    executor: VitestExecutor;
     private static pendingIds;
-    private static spyModulePath;
-    private static spyModule?;
     private resolveCache;
-    constructor(runner: VitestRunner);
+    constructor(executor: VitestExecutor);
     private get root();
     private get base();
     private get mockMap();
     private get moduleCache();
+    private deleteCachedItem;
     getSuiteFilepath(): string;
     getMocks(): {
         [x: string]: string | MockFactory | null;
@@ -45,7 +45,6 @@ declare class VitestMocker {
     mockPath(originalId: string, path: string, external: string | null, factory?: MockFactory): void;
     importActual<T>(rawId: string, importee: string): Promise<T>;
     importMock(rawId: string, importee: string): Promise<any>;
-    initializeSpyModule(): Promise<void>;
     requestWithMock(url: string, callstack: string[]): Promise<any>;
     queueMock(id: string, importer: string, factory?: MockFactory): void;
     queueUnmock(id: string, importer: string): void;
@@ -54,12 +53,12 @@ declare class VitestMocker {
 interface ExecuteOptions extends ViteNodeRunnerOptions {
     mockMap: MockMap;
 }
-declare class VitestRunner extends ViteNodeRunner {
+declare class VitestExecutor extends ViteNodeRunner {
     options: ExecuteOptions;
     mocker: VitestMocker;
     constructor(options: ExecuteOptions);
     shouldResolveId(id: string, _importee?: string | undefined): boolean;
-    resolveUrl(id: string, importee?: string): Promise<[url: string, fsPath: string]>;
+    resolveUrl(id: string, importer?: string): Promise<[url: string, fsPath: string]>;
     dependencyRequest(id: string, fsPath: string, callstack: string[]): Promise<any>;
     prepareContext(context: Record<string, any>): Record<string, any>;
 }
@@ -71,4 +70,4 @@ declare class BaseSequencer implements TestSequencer {
     sort(files: string[]): Promise<string[]>;
 }
 
-export { BaseSequencer, ExecuteOptions, VitestPlugin, VitestRunner, createVitest };
+export { BaseSequencer, ExecuteOptions, VitestExecutor, VitestPlugin, createVitest };