vitest 0.10.5 → 0.12.1

package/dist/node.d.ts

@@ -211,6 +211,72 @@ declare type OldPlugin = {
 declare type Plugin = NewPlugin | OldPlugin;
 declare type Plugins = Array<Plugin>;
 
+// Type definitions for @sinonjs/fake-timers 8.1
+// Project: https://github.com/sinonjs/fake-timers
+// Definitions by: Wim Looman <https://github.com/Nemo157>
+//                 Rogier Schouten <https://github.com/rogierschouten>
+//                 Yishai Zehavi <https://github.com/zyishai>
+//                 Remco Haszing <https://github.com/remcohaszing>
+//                 Jaden Simon <https://github.com/JadenSimon>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+/**
+ * Names of clock methods that may be faked by install.
+ */
+type FakeMethod =
+    | 'setTimeout'
+    | 'clearTimeout'
+    | 'setImmediate'
+    | 'clearImmediate'
+    | 'setInterval'
+    | 'clearInterval'
+    | 'Date'
+    | 'nextTick'
+    | 'hrtime'
+    | 'requestAnimationFrame'
+    | 'cancelAnimationFrame'
+    | 'requestIdleCallback'
+    | 'cancelIdleCallback'
+    | 'performance'
+    | 'queueMicrotask';
+
+interface FakeTimerInstallOpts {
+    /**
+     * Installs fake timers with the specified unix epoch (default: 0)
+     */
+    now?: number | Date | undefined;
+
+    /**
+     * An array with names of global methods and APIs to fake. By default, `@sinonjs/fake-timers` does not replace `nextTick()` and `queueMicrotask()`.
+     * For instance, `FakeTimers.install({ toFake: ['setTimeout', 'nextTick'] })` will fake only `setTimeout()` and `nextTick()`
+     */
+    toFake?: FakeMethod[] | undefined;
+
+    /**
+     * The maximum number of timers that will be run when calling runAll() (default: 1000)
+     */
+    loopLimit?: number | undefined;
+
+    /**
+     * Tells @sinonjs/fake-timers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by
+     * 20ms for every 20ms change in the real system time) (default: false)
+     */
+    shouldAdvanceTime?: boolean | undefined;
+
+    /**
+     * Relevant only when using with shouldAdvanceTime: true. increment mocked time by advanceTimeDelta ms every advanceTimeDelta ms change
+     * in the real system time (default: 20)
+     */
+    advanceTimeDelta?: number | undefined;
+
+    /**
+     * Tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers. These are not cleared by
+     * default, leading to potentially unexpected behavior if timers existed prior to installing FakeTimers. (default: false)
+     */
+    shouldClearNativeTimers?: boolean | undefined;
+}
+
 declare abstract class BaseReporter implements Reporter {
     start: number;
     end: number;
@@ -405,6 +471,7 @@ interface C8Options {
     skipFull?: boolean;
     extension?: string | string[];
     all?: boolean;
+    src?: string[];
     100?: boolean;
     lines?: number;
     functions?: number;
@@ -520,6 +587,7 @@ declare type TaskResultPack = [id: string, result: TaskResult | undefined];
 interface Suite extends TaskBase {
     type: 'suite';
     tasks: Task[];
+    filepath?: string;
 }
 interface File extends Suite {
     filepath: string;
@@ -535,8 +603,8 @@ interface Test<ExtraContext = {}> extends TaskBase {
 declare type Task = Test | Suite | File;
 declare type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return | void>;
 interface SuiteHooks {
-    beforeAll: HookListener<[Suite], () => Awaitable<void>>[];
-    afterAll: HookListener<[Suite]>[];
+    beforeAll: HookListener<[Suite | File], () => Awaitable<void>>[];
+    afterAll: HookListener<[Suite | File]>[];
     beforeEach: HookListener<[TestContext, Suite], () => Awaitable<void>>[];
     afterEach: HookListener<[TestContext, Suite]>[];
 }
@@ -769,7 +837,7 @@ interface InlineConfig {
     /**
      * Pattern of file paths to be ignore from triggering watch rerun
      *
-     * @default ['**\/node_modules\/**', '**\/dist/**']
+     * @default [/\/node_modules\//, /\/dist\//]
      */
     watchIgnore?: (string | RegExp)[];
     /**
@@ -854,10 +922,22 @@ 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.
      */
     logHeapUsage?: boolean;
+    /**
+     * Options for @sinon/fake-timers
+     */
+    fakeTimers?: FakeTimerInstallOpts;
 }
 interface UserConfig extends InlineConfig {
     /**
@@ -874,14 +954,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
      */
@@ -926,7 +998,6 @@ declare class SnapshotManager {
 declare type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
 interface WorkerPool {
     runTests: RunWithFiles;
-    collectTests: RunWithFiles;
     close: () => Promise<void>;
 }
 
@@ -1016,6 +1087,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 +1099,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 +1124,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,10 +1,10 @@
-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.dcc18b18.js';
+export { V as VitestRunner } from './chunk-runtime-mocker.c6de56c0.js';
 import 'buffer';
 import 'path';
 import 'child_process';
 import 'process';
-import './vendor-index.40be925a.js';
+import './vendor-index.6c69a0a8.js';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'fs';
 import 'assert';
@@ -13,19 +13,19 @@ import 'stream';
 import 'util';
 import 'url';
 import 'os';
-import './chunk-utils-global.eb31f3da.js';
+import './chunk-utils-global.7092f9ed.js';
 import 'tty';
 import 'local-pkg';
 import 'vite';
-import './chunk-constants.54c46a47.js';
+import './chunk-constants.07c1f709.js';
 import 'readline';
-import './chunk-vite-node-utils.6b0ec89a.js';
+import './chunk-vite-node-utils.ebc9e052.js';
 import 'module';
 import 'vm';
-import './chunk-defaults.c143550b.js';
+import './chunk-defaults.9b4b1577.js';
 import 'worker_threads';
 import 'tinypool';
 import 'perf_hooks';
-import './chunk-utils-timers.27e0c6e9.js';
+import './chunk-utils-timers.d1b169ca.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.3062f869.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.7092f9ed.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.da3a4a85.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.5148195e.js';
+import { d as clearTimeout, c as setTimeout, s as stringify } from './chunk-utils-timers.d1b169ca.js';
+import { t as takeCoverage } from './chunk-defaults.9b4b1577.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.d3383e75.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.bc12987e.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)
@@ -446,33 +522,39 @@ function setupConsoleLogSpy() {
   }
   function sendStdout(taskId) {
     const buffer = stdoutBuffer.get(taskId);
-    if (buffer) {
-      const timer = timers.get(taskId);
-      rpc().onUserConsoleLog({
-        type: "stdout",
-        content: buffer.map((i) => String(i)).join(""),
-        taskId,
-        time: timer.stdoutTime || RealDate.now(),
-        size: buffer.length
-      });
-      stdoutBuffer.set(taskId, []);
-      timer.stdoutTime = 0;
-    }
+    if (!buffer)
+      return;
+    const content = buffer.map((i) => String(i)).join("");
+    if (!content.trim())
+      return;
+    const timer = timers.get(taskId);
+    rpc().onUserConsoleLog({
+      type: "stdout",
+      content,
+      taskId,
+      time: timer.stdoutTime || RealDate.now(),
+      size: buffer.length
+    });
+    stdoutBuffer.set(taskId, []);
+    timer.stdoutTime = 0;
   }
   function sendStderr(taskId) {
     const buffer = stderrBuffer.get(taskId);
-    if (buffer) {
-      const timer = timers.get(taskId);
-      rpc().onUserConsoleLog({
-        type: "stderr",
-        content: buffer.map((i) => String(i)).join(""),
-        taskId,
-        time: timer.stderrTime || RealDate.now(),
-        size: buffer.length
-      });
-      stderrBuffer.set(taskId, []);
-      timer.stderrTime = 0;
-    }
+    if (!buffer)
+      return;
+    const content = buffer.map((i) => String(i)).join("");
+    if (!content.trim())
+      return;
+    const timer = timers.get(taskId);
+    rpc().onUserConsoleLog({
+      type: "stderr",
+      content,
+      taskId,
+      time: timer.stderrTime || RealDate.now(),
+      size: buffer.length
+    });
+    stderrBuffer.set(taskId, []);
+    timer.stderrTime = 0;
   }
   const stdout = new Writable({
     write(data, encoding, callback) {
@@ -576,6 +658,9 @@ function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
     return clone2;
   }
 }
+function normalizeErrorMessage(message) {
+  return message.replace(/__vite_ssr_import_\d+__\./g, "");
+}
 function processError(err) {
   if (!err)
     return err;
@@ -592,6 +677,10 @@ function processError(err) {
     err.expected = stringify(err.expected);
   if (typeof err.actual !== "string")
     err.actual = stringify(err.actual);
+  if (typeof err.message === "string")
+    err.message = normalizeErrorMessage(err.message);
+  if (typeof err.cause === "object" && err.cause.message === "string")
+    err.cause.message = normalizeErrorMessage(err.cause.message);
   try {
     return serializeError(err);
   } catch (e) {
@@ -970,21 +1059,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.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.7092f9ed.js';
+import { c as createBirpc, M as ModuleCacheMap } from './chunk-vite-node-utils.ebc9e052.js';
+import { d as distDir } from './chunk-constants.07c1f709.js';
+import { e as executeInViteNode } from './chunk-runtime-mocker.c6de56c0.js';
+import { r as rpc } from './chunk-runtime-rpc.5148195e.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.12.1",
   "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.12.1",
     "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.12.1",
     "ws": "^8.6.0"
   },
   "engines": {