vitest 0.0.90 → 0.0.91

package/dist/cli.js

@@ -1,17 +1,17 @@
 import readline from 'readline';
 import { EventEmitter } from 'events';
-import { c } from './utils-385e2d09.js';
-import { c as createVitest } from './index-733e7378.js';
+import { c } from './utils-5d0cec8a.js';
+import { c as createVitest } from './index-25bef3dd.js';
 import 'module';
 import 'tty';
 import 'path';
 import 'vite';
 import 'process';
 import 'fs';
-import './constants-adef7ffb.js';
+import './constants-9cfa4d7b.js';
 import 'url';
 import 'perf_hooks';
-import './error-309196c9.js';
+import './error-abd1f726.js';
 import 'source-map';
 import 'assert';
 import 'worker_threads';
@@ -632,7 +632,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "0.0.90";
+var version = "0.0.91";
 
 const cli = cac("vitest");
 cli.version(version).option("-r, --root <path>", "root path").option("-c, --config <path>", "path to config file").option("-u, --update", "update snapshot").option("-w, --watch", "watch mode").option("-o, --open", "open Vitest UI").option("--api", "listen to port and serve API").option("--threads", "enabled threads", { default: true }).option("--silent", "silent").option("--global", "inject apis globally").option("--dom", "mock browser api with happy-dom").option("--environment <env>", "runner environment", {

package/dist/{constants-adef7ffb.js → constants-9cfa4d7b.js}

@@ -22,9 +22,8 @@ const globalApis = [
   "chai",
   "expect",
   "assert",
-  "spy",
-  "spyOn",
   "vitest",
+  "vi",
   "beforeAll",
   "afterAll",
   "beforeEach",

package/dist/entry.js

@@ -5,9 +5,9 @@ import chai, { expect, util } from 'chai';
 import Subset from 'chai-subset';
 import path, { basename } from 'path';
 import { r as rpc, s as send } from './rpc-7de86f29.js';
-import { g as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, d as hasTests, h as hasFailed } from './utils-385e2d09.js';
+import { g as getNames, c as c$1, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, d as hasTests, h as hasFailed } from './utils-5d0cec8a.js';
 import fs from 'fs';
-import { u as unifiedDiff } from './error-309196c9.js';
+import { u as unifiedDiff } from './error-abd1f726.js';
 import { performance } from 'perf_hooks';
 import { b as setHooks, c as createSuiteHooks, e as clearContext, f as defaultSuite, h as context, j as getHooks, k as getFn } from './suite-b8c6cb53.js';
 import { n as nanoid } from './index-9e71c815.js';
@@ -3628,8 +3628,22 @@ class StringContaining extends AsymmetricMatcher {
     return "string";
   }
 }
+class Anything extends AsymmetricMatcher {
+  asymmetricMatch(other) {
+    return other !== void 0 && other !== null;
+  }
+  toString() {
+    return "Anything";
+  }
+  toAsymmetricMatcher() {
+    return "Anything";
+  }
+}
 const JestAsymmetricMatchers = (chai, utils) => {
   utils.addMethod(chai.expect, "stringContaining", (expected) => new StringContaining(expected));
+  utils.addMethod(chai.expect, "anything", () => {
+    return new Anything();
+  });
 };
 
 let installed = false;
@@ -3652,7 +3666,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-f3eab75a.js')).registerApiGlobally();
+    (await import('./global-c40aeb86.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3768,14 +3782,6 @@ async function collectTests(paths, config) {
   }
   const tasks = files.reduce((tasks2, file) => tasks2.concat(file.tasks), []);
   interpretOnlyMode(tasks);
-  tasks.forEach((i) => {
-    if (i.type === "suite") {
-      if (i.mode === "skip")
-        i.tasks.forEach((c) => c.mode === "run" && (c.mode = "skip"));
-      else
-        interpretOnlyMode(i.tasks);
-    }
-  });
   return files;
 }
 

package/dist/{error-309196c9.js → error-abd1f726.js}

@@ -1,6 +1,6 @@
 import { existsSync, promises } from 'fs';
 import { relative } from 'path';
-import { n as notNullish, c } from './utils-385e2d09.js';
+import { n as notNullish, c } from './utils-5d0cec8a.js';
 import { SourceMapConsumer } from 'source-map';
 
 function Diff() {}

package/dist/{global-f3eab75a.js → global-c40aeb86.js}

@@ -1,5 +1,5 @@
-import { g as globalApis } from './constants-adef7ffb.js';
-import { i as index } from './index-722fb5a5.js';
+import { g as globalApis } from './constants-9cfa4d7b.js';
+import { i as index } from './index-708135df.js';
 import 'path';
 import 'url';
 import './suite-b8c6cb53.js';

package/dist/{index-733e7378.js → index-25bef3dd.js}

@@ -2,10 +2,10 @@ import path, { isAbsolute, relative, dirname, basename, resolve } from 'path';
 import { createServer, mergeConfig } from 'vite';
 import process$2 from 'process';
 import { promises } from 'fs';
-import { d as defaultInclude, a as defaultExclude, b as defaultPort, c as distDir, e as configFiles } from './constants-adef7ffb.js';
-import { c, g as getNames, s as slash, a as getTests, b as getSuites, t as toArray, h as hasFailed } from './utils-385e2d09.js';
+import { d as defaultInclude, a as defaultExclude, b as defaultPort, c as distDir, e as configFiles } from './constants-9cfa4d7b.js';
+import { c, g as getNames, s as slash, a as getTests, b as getSuites, t as toArray, h as hasFailed } from './utils-5d0cec8a.js';
 import { performance } from 'perf_hooks';
-import { s as stringWidth, a as ansiStyles, b as stripAnsi, c as sliceAnsi, F as F_POINTER, d as F_DOWN, e as F_LONG_DASH, f as F_DOWN_RIGHT, g as F_DOT, h as F_CHECK, i as F_CROSS, j as cliTruncate, k as F_RIGHT, p as printError } from './error-309196c9.js';
+import { s as stringWidth, a as ansiStyles, b as stripAnsi, c as sliceAnsi, F as F_POINTER, d as F_DOWN, e as F_LONG_DASH, f as F_DOWN_RIGHT, g as F_DOT, h as F_CHECK, i as F_CROSS, j as cliTruncate, k as F_RIGHT, p as printError } from './error-abd1f726.js';
 import assert$1 from 'assert';
 import require$$2 from 'events';
 import { MessageChannel } from 'worker_threads';
@@ -1872,7 +1872,7 @@ async function createVitest(options, viteOverrides = {}) {
           ctx.setServer(options, server2);
           haveStarted = true;
           if (options.api)
-            server2.middlewares.use((await import('./middleware-650c5fa0.js')).default());
+            server2.middlewares.use((await import('./middleware-52c3b35a.js')).default());
         }
       }
     ],

package/dist/index-708135df.js

@@ -0,0 +1,333 @@
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-b8c6cb53.js';
+import chai, { util, assert, should, expect } from 'chai';
+import * as tinyspy from 'tinyspy';
+import { spy, spyOn as spyOn$1 } from 'tinyspy';
+
+const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+
+function spyOn(obj, method, accessType) {
+  const dictionary = {
+    get: "getter",
+    set: "setter"
+  };
+  const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
+  const stub = tinyspy.spyOn(obj, objMethod);
+  return enhanceSpy(stub);
+}
+function enhanceSpy(spy) {
+  const stub = spy;
+  let implementation;
+  const instances = [];
+  const mockContext = {
+    get calls() {
+      return stub.calls;
+    },
+    get instances() {
+      return instances;
+    },
+    get invocationCallOrder() {
+      return [];
+    },
+    get results() {
+      return stub.results.map(([callType, value]) => {
+        const type = callType === "error" ? "throw" : "return";
+        return { type, value };
+      });
+    }
+  };
+  let onceImplementations = [];
+  let name = "";
+  Object.defineProperty(stub, "name", {
+    get: () => name
+  });
+  stub.getMockName = () => name || "vi.fn()";
+  stub.mockName = (n) => {
+    name = n;
+    return stub;
+  };
+  stub.mockClear = () => {
+    stub.reset();
+    return stub;
+  };
+  stub.mockReset = () => {
+    stub.reset();
+    return stub;
+  };
+  stub.mockRestore = () => {
+    implementation = void 0;
+    onceImplementations = [];
+    stub.reset();
+    stub.restore();
+    return stub;
+  };
+  stub.getMockImplementation = () => implementation;
+  stub.mockImplementation = (fn2) => {
+    implementation = fn2;
+    return stub;
+  };
+  stub.mockImplementationOnce = (fn2) => {
+    onceImplementations.push(fn2);
+    return stub;
+  };
+  stub.mockReturnThis = () => stub.mockImplementation(function() {
+    return this;
+  });
+  stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
+  stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
+  stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
+  stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
+  stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
+  stub.mockRejectedValueOnce = (val) => stub.mockImplementation(() => Promise.reject(val));
+  util.addProperty(stub, "mock", () => mockContext);
+  stub.willCall(function(...args) {
+    instances.push(this);
+    const impl = onceImplementations.shift() || implementation || stub.getOriginal() || (() => {
+    });
+    return impl.apply(this, args);
+  });
+  return stub;
+}
+function fn(implementation) {
+  return enhanceSpy(tinyspy.spyOn({ fn: implementation || (() => {
+  }) }, "fn"));
+}
+
+const originalSetTimeout = global.setTimeout;
+const originalSetInterval = global.setInterval;
+const originalClearTimeout = global.clearTimeout;
+const originalClearInterval = global.clearInterval;
+const MAX_LOOPS = 1e4;
+const assertEvery = (assertions, message) => {
+  if (assertions.some((a) => !a))
+    throw new Error(message);
+};
+const assertMaxLoop = (times) => {
+  if (times >= MAX_LOOPS)
+    throw new Error("setTimeout/setInterval called 10 000 times. It's possible it stuck in an infinite loop.");
+};
+const getNodeTimeout = (id) => {
+  const timer = {
+    ref: () => timer,
+    unref: () => timer,
+    hasRef: () => true,
+    refresh: () => timer,
+    [Symbol.toPrimitive]: () => id
+  };
+  return timer;
+};
+class FakeTimers {
+  constructor() {
+    this._advancedTime = 0;
+    this._nestedTime = {};
+    this._scopeId = 0;
+    this._isNested = false;
+    this._isOnlyPending = false;
+    this._spyid = 0;
+    this._isMocked = false;
+    this._tasksQueue = [];
+    this._queueCount = 0;
+  }
+  useFakeTimers() {
+    this._isMocked = true;
+    this.reset();
+    const spyFactory = (spyType, resultBuilder) => {
+      return (cb, ms = 0) => {
+        const id = ++this._spyid;
+        const nestedMs = ms + (this._nestedTime[this._scopeId] ?? 0);
+        const call = { id, cb, ms, nestedMs, scopeId: this._scopeId };
+        const task = { type: spyType, call, nested: this._isNested };
+        this.pushTask(task);
+        return resultBuilder(id, cb);
+      };
+    };
+    this._setTimeout = spyOn(global, "setTimeout").mockImplementation(spyFactory("timeout" /* Timeout */, getNodeTimeout));
+    this._setInterval = spyOn(global, "setInterval").mockImplementation(spyFactory("interval" /* Interval */, getNodeTimeout));
+    const clearTimerFactory = (spyType) => (id) => {
+      if (id === void 0)
+        return;
+      const index = this._tasksQueue.findIndex(({ call, type }) => type === spyType && call.id === Number(id));
+      if (index !== -1)
+        this._tasksQueue.splice(index, 1);
+    };
+    this._clearTimeout = spyOn(global, "clearTimeout").mockImplementation(clearTimerFactory("timeout" /* Timeout */));
+    this._clearInterval = spyOn(global, "clearInterval").mockImplementation(clearTimerFactory("interval" /* Interval */));
+  }
+  useRealTimers() {
+    this._isMocked = false;
+    this.reset();
+    global.setTimeout = originalSetTimeout;
+    global.setInterval = originalSetInterval;
+    global.clearTimeout = originalClearTimeout;
+    global.clearInterval = originalClearInterval;
+  }
+  runOnlyPendingTimers() {
+    this.assertMocked();
+    this._isOnlyPending = true;
+    this.runQueue();
+  }
+  runAllTimers() {
+    this.assertMocked();
+    this.runQueue();
+  }
+  advanceTimersByTime(ms) {
+    this.assertMocked();
+    this._advancedTime += ms;
+    this.runQueue();
+  }
+  advanceTimersToNextTimer() {
+    throw new Error("advanceTimersToNextTimer is not implemented");
+  }
+  runAllTicks() {
+    throw new Error("runAllTicks is not implemented");
+  }
+  setSystemTime(now) {
+    throw new Error("setSystemTime is not implemented");
+  }
+  getRealSystemTime() {
+    return Date.now();
+  }
+  getTimerCount() {
+    this.assertMocked();
+    return this._tasksQueue.length;
+  }
+  reset() {
+    var _a, _b, _c, _d;
+    this._advancedTime = 0;
+    this._nestedTime = {};
+    this._isNested = false;
+    this._isOnlyPending = false;
+    this._spyid = 0;
+    this._queueCount = 0;
+    this._tasksQueue = [];
+    (_a = this._clearInterval) == null ? void 0 : _a.mockRestore();
+    (_b = this._clearTimeout) == null ? void 0 : _b.mockRestore();
+    (_c = this._setInterval) == null ? void 0 : _c.mockRestore();
+    (_d = this._setTimeout) == null ? void 0 : _d.mockRestore();
+  }
+  runQueue() {
+    var _a, _b;
+    let index = 0;
+    while (this._tasksQueue[index]) {
+      assertMaxLoop(this._queueCount);
+      const task = this._tasksQueue[index];
+      const { call, nested, type } = task;
+      if (this._advancedTime && call.nestedMs > this._advancedTime)
+        break;
+      if (this._isOnlyPending && nested) {
+        index++;
+        continue;
+      }
+      this._scopeId = call.id;
+      this._isNested = true;
+      (_a = this._nestedTime)[_b = call.id] ?? (_a[_b] = 0);
+      this._nestedTime[call.id] += call.ms;
+      if (type === "timeout") {
+        this.removeTask(index);
+      } else if (type === "interval") {
+        call.nestedMs += call.ms;
+        const nestedMs = call.nestedMs;
+        const closestTask = this._tasksQueue.findIndex(({ type: type2, call: call2 }) => type2 === "interval" && call2.nestedMs < nestedMs);
+        if (closestTask !== -1 && closestTask !== index)
+          this.ensureQueueOrder();
+      }
+      call.cb();
+      this._queueCount++;
+    }
+  }
+  removeTask(index) {
+    if (index === 0)
+      this._tasksQueue.shift();
+    else
+      this._tasksQueue.splice(index, 1);
+  }
+  pushTask(task) {
+    this._tasksQueue.push(task);
+    this.ensureQueueOrder();
+  }
+  ensureQueueOrder() {
+    this._tasksQueue.sort((t1, t2) => {
+      const diff = t1.call.nestedMs - t2.call.nestedMs;
+      if (diff === 0) {
+        if (t1.type === "immediate" /* Immediate */ && t2.type !== "immediate" /* Immediate */)
+          return 1;
+        return 0;
+      }
+      return diff;
+    });
+  }
+  assertMocked() {
+    assertEvery([
+      this._isMocked,
+      this._setTimeout,
+      this._setInterval,
+      this._clearTimeout,
+      this._clearInterval
+    ], 'timers are not mocked. try calling "vitest.useFakeTimers()" first');
+  }
+}
+
+class VitestUtils {
+  constructor() {
+    this.spyOn = spyOn;
+    this.fn = fn;
+    this.mock = (path) => path;
+    this._timers = new FakeTimers();
+  }
+  useFakeTimers() {
+    return this._timers.useFakeTimers();
+  }
+  useRealTimers() {
+    return this._timers.useRealTimers();
+  }
+  runOnlyPendingTimers() {
+    return this._timers.runOnlyPendingTimers();
+  }
+  runAllTimers() {
+    return this._timers.runAllTimers();
+  }
+  advanceTimersByTime(ms) {
+    return this._timers.advanceTimersByTime(ms);
+  }
+  advanceTimersToNextTimer() {
+    return this._timers.advanceTimersToNextTimer();
+  }
+  runAllTicks() {
+    return this._timers.runAllTicks();
+  }
+  setSystemTime(time) {
+    return this._timers.setSystemTime(time);
+  }
+  getRealSystemTime() {
+    return this._timers.getRealSystemTime();
+  }
+  getTimerCount() {
+    return this._timers.getTimerCount();
+  }
+}
+const vitest = new VitestUtils();
+const vi = vitest;
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  suite: suite,
+  test: test,
+  describe: describe,
+  it: it,
+  beforeAll: beforeAll,
+  afterAll: afterAll,
+  beforeEach: beforeEach,
+  afterEach: afterEach,
+  assert: assert,
+  should: should,
+  expect: expect,
+  chai: chai,
+  spy: spy,
+  spyOn: spyOn$1,
+  vitest: vitest,
+  vi: vi
+});
+
+export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, vi as e, index as i, vitest as v };

package/dist/index.d.ts

@@ -108,6 +108,28 @@ declare type MatchersObject<T extends MatcherState = MatcherState> = {
     [id: string]: RawMatcherFn<T>;
 };
 
+interface AsymmetricMatcherInterface {
+    asymmetricMatch(other: unknown): boolean;
+    toString(): string;
+    getExpectedType?(): string;
+    toAsymmetricMatcher?(): string;
+}
+declare abstract class AsymmetricMatcher<T, State extends MatcherState = MatcherState> implements AsymmetricMatcherInterface {
+    protected sample: T;
+    protected inverse: boolean;
+    constructor(sample: T, inverse?: boolean);
+    protected getMatcherContext(): State;
+    abstract asymmetricMatch(other: unknown): boolean;
+    abstract toString(): string;
+    getExpectedType?(): string;
+    toAsymmetricMatcher?(): string;
+}
+declare class Anything extends AsymmetricMatcher<void> {
+    asymmetricMatch(other: unknown): boolean;
+    toString(): string;
+    toAsymmetricMatcher(): string;
+}
+
 declare type Awaitable<T> = T | PromiseLike<T>;
 declare type Nullable<T> = T | null | undefined;
 declare type Arrayable<T> = T | Array<T>;
@@ -585,10 +607,25 @@ declare type Awaited<T> = T extends Promise<infer R> ? R : never;
 declare function fn<TArgs extends any[] = any[], R = any>(): JestMockCompatFn<TArgs, R>;
 declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...args: TArgs) => R): JestMockCompatFn<TArgs, R>;
 
-declare const vitest: {
+declare class VitestUtils {
     spyOn: typeof spyOn;
     fn: typeof fn;
-};
+    mock: (path: string) => string;
+    private _timers;
+    constructor();
+    useFakeTimers(): void;
+    useRealTimers(): void;
+    runOnlyPendingTimers(): void;
+    runAllTimers(): void;
+    advanceTimersByTime(ms: number): void;
+    advanceTimersToNextTimer(): void;
+    runAllTicks(): void;
+    setSystemTime(time?: number | Date): void;
+    getRealSystemTime(): number;
+    getTimerCount(): number;
+}
+declare const vitest: VitestUtils;
+declare const vi: VitestUtils;
 
 declare module 'vite' {
     interface UserConfig {
@@ -603,6 +640,7 @@ declare global {
         interface ExpectStatic {
             extend(expects: MatchersObject): void;
             stringContaining(expected: string): void;
+            anything(): Anything;
         }
         interface Assertion {
             chaiEqual(expected: any): void;
@@ -657,4 +695,4 @@ declare global {
     }
 }
 
-export { ArgumentsType, Arrayable, Awaitable, ComputeMode, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, ModuleCache, Nullable, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, it, suite, test, vitest };
+export { ArgumentsType, Arrayable, Awaitable, ComputeMode, DoneCallback, Environment, EnvironmentReturn, File, HookListener, InlineConfig, ModuleCache, Nullable, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConfig, UserConsoleLog, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, it, suite, test, vi, vitest };

package/dist/index.js

@@ -1,5 +1,5 @@
 export { d as describe, i as it, s as suite, t as test } from './suite-b8c6cb53.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, v as vitest } from './index-722fb5a5.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, e as vi, v as vitest } from './index-708135df.js';
 export { assert, default as chai, expect, should } from 'chai';
 export { spy, spyOn } from 'tinyspy';
 import './index-9e71c815.js';

package/dist/{middleware-650c5fa0.js → middleware-52c3b35a.js}

@@ -1,5 +1,5 @@
 import { stringify } from 'flatted';
-import { A as API_PATH } from './constants-adef7ffb.js';
+import { A as API_PATH } from './constants-9cfa4d7b.js';
 import 'path';
 import 'url';
 

package/dist/node.js

@@ -1,15 +1,15 @@
-export { c as createVitest } from './index-733e7378.js';
+export { c as createVitest } from './index-25bef3dd.js';
 import 'path';
 import 'vite';
 import 'process';
 import 'fs';
-import './constants-adef7ffb.js';
+import './constants-9cfa4d7b.js';
 import 'url';
-import './utils-385e2d09.js';
+import './utils-5d0cec8a.js';
 import 'module';
 import 'tty';
 import 'perf_hooks';
-import './error-309196c9.js';
+import './error-abd1f726.js';
 import 'source-map';
 import 'assert';
 import 'events';

package/dist/{utils-385e2d09.js → utils-5d0cec8a.js}

@@ -91,15 +91,23 @@ function partitionSuiteChildren(suite) {
     tasksGroups.push(tasksGroup);
   return tasksGroups;
 }
-function interpretOnlyMode(items) {
-  if (items.some((i) => i.mode === "only")) {
-    items.forEach((i) => {
-      if (i.mode === "run")
-        i.mode = "skip";
-      else if (i.mode === "only")
-        i.mode = "run";
+function interpretOnlyMode(tasks) {
+  if (tasks.some((t) => t.mode === "only")) {
+    tasks.forEach((t) => {
+      if (t.mode === "run")
+        t.mode = "skip";
+      else if (t.mode === "only")
+        t.mode = "run";
     });
   }
+  tasks.forEach((t) => {
+    if (t.type === "suite") {
+      if (t.mode === "skip")
+        t.tasks.forEach((c2) => c2.mode === "run" && (c2.mode = "skip"));
+      else
+        interpretOnlyMode(t.tasks);
+    }
+  });
 }
 function getTests(suite) {
   return toArray(suite).flatMap((s) => s.tasks.flatMap((c2) => c2.type === "test" ? [c2] : getTests(c2)));

package/dist/utils.js

@@ -1,3 +1,3 @@
 import 'module';
-export { f as checkPeerDependency, g as getNames, b as getSuites, e as getTasks, a as getTests, h as hasFailed, d as hasTests, i as interpretOnlyMode, n as notNullish, p as partitionSuiteChildren, s as slash, t as toArray } from './utils-385e2d09.js';
+export { f as checkPeerDependency, g as getNames, b as getSuites, e as getTasks, a as getTests, h as hasFailed, d as hasTests, i as interpretOnlyMode, n as notNullish, p as partitionSuiteChildren, s as slash, t as toArray } from './utils-5d0cec8a.js';
 import 'tty';

package/dist/worker.js

@@ -1,10 +1,10 @@
 import path, { resolve as resolve$3, dirname as dirname$3 } from 'path';
 import { n as nanoid } from './index-9e71c815.js';
-import { c as distDir } from './constants-adef7ffb.js';
+import { c as distDir } from './constants-9cfa4d7b.js';
 import { builtinModules, createRequire } from 'module';
 import { pathToFileURL, fileURLToPath, URL as URL$1 } from 'url';
 import vm from 'vm';
-import { s as slash } from './utils-385e2d09.js';
+import { s as slash } from './utils-5d0cec8a.js';
 import fs, { realpathSync, statSync, Stats, promises } from 'fs';
 import assert from 'assert';
 import { format as format$3, inspect } from 'util';
@@ -8392,11 +8392,10 @@ async function shouldExternalize(id, config) {
   return id.includes("/node_modules/") && await isValidNodeImport(id);
 }
 function toFilePath(id, root) {
-  id = slash(id);
-  let absolute = id.startsWith("/@fs/") ? id.slice(4) : id.startsWith(dirname$3(root)) ? id : id.startsWith("/") ? slash(resolve$3(root, id.slice(1))) : id;
+  let absolute = slash(id).startsWith("/@fs/") ? id.slice(4) : id.startsWith(dirname$3(root)) ? id : id.startsWith("/") ? slash(resolve$3(root, id.slice(1))) : id;
   if (absolute.startsWith("//"))
     absolute = absolute.slice(1);
-  return isWindows && absolute.startsWith("/") ? pathToFileURL(absolute.slice(1)).href : absolute;
+  return isWindows && absolute.startsWith("/") ? fileURLToPath(pathToFileURL(absolute.slice(1)).href) : absolute;
 }
 function matchExternalizePattern(id, patterns) {
   for (const ex of patterns) {
@@ -8411,8 +8410,8 @@ function matchExternalizePattern(id, patterns) {
   return false;
 }
 function patchWindowsImportPath(path) {
-  if (path.match(/^\w:\//))
-    return `/${path}`;
+  if (path.match(/^\w:\\/))
+    return `file:///${slash(path)}`;
   else
     return path;
 }

package/global.d.ts

@@ -5,9 +5,8 @@ declare global {
   const it: typeof import('vitest')['it']
   const expect: typeof import('vitest')['expect']
   const assert: typeof import('vitest')['assert']
-  const spy: typeof import('vitest')['spy']
-  const spyOn: typeof import('vitest')['spyOn']
   const vitest: typeof import('vitest')['vitest']
+  const vi: typeof import('vitest')['vitest']
   const beforeAll: typeof import('vitest')['beforeAll']
   const afterAll: typeof import('vitest')['afterAll']
   const beforeEach: typeof import('vitest')['beforeEach']

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.90",
+  "version": "0.0.91",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -63,7 +63,7 @@
     "@types/jsdom": "^16.2.13",
     "@types/micromatch": "^4.0.2",
     "@types/natural-compare": "^1.4.1",
-    "@types/node": "^16.11.13",
+    "@types/node": "^17.0.0",
     "c8": "^7.10.0",
     "cac": "^6.7.12",
     "cli-truncate": "^3.1.0",

package/dist/index-722fb5a5.js

@@ -1,122 +0,0 @@
-import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-b8c6cb53.js';
-import chai, { util, assert, should, expect } from 'chai';
-import * as tinyspy from 'tinyspy';
-import { spy, spyOn as spyOn$1 } from 'tinyspy';
-
-const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
-
-function spyOn(obj, method, accessType) {
-  const dictionary = {
-    get: "getter",
-    set: "setter"
-  };
-  const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
-  const stub = tinyspy.spyOn(obj, objMethod);
-  return enhanceSpy(stub);
-}
-function enhanceSpy(spy) {
-  const stub = spy;
-  let implementation;
-  const instances = [];
-  const mockContext = {
-    get calls() {
-      return stub.calls;
-    },
-    get instances() {
-      return instances;
-    },
-    get invocationCallOrder() {
-      return [];
-    },
-    get results() {
-      return stub.results.map(([callType, value]) => {
-        const type = callType === "error" ? "throw" : "return";
-        return { type, value };
-      });
-    }
-  };
-  let onceImplementations = [];
-  let name = "";
-  Object.defineProperty(stub, "name", {
-    get: () => name
-  });
-  stub.getMockName = () => name || "vi.fn()";
-  stub.mockName = (n) => {
-    name = n;
-    return stub;
-  };
-  stub.mockClear = () => {
-    stub.reset();
-    return stub;
-  };
-  stub.mockReset = () => {
-    stub.reset();
-    return stub;
-  };
-  stub.mockRestore = () => {
-    implementation = void 0;
-    onceImplementations = [];
-    stub.reset();
-    stub.restore();
-    return stub;
-  };
-  stub.getMockImplementation = () => implementation;
-  stub.mockImplementation = (fn2) => {
-    implementation = fn2;
-    return stub;
-  };
-  stub.mockImplementationOnce = (fn2) => {
-    onceImplementations.push(fn2);
-    return stub;
-  };
-  stub.mockReturnThis = () => stub.mockImplementation(function() {
-    return this;
-  });
-  stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
-  stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
-  stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
-  stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
-  stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
-  stub.mockRejectedValueOnce = (val) => stub.mockImplementation(() => Promise.reject(val));
-  util.addProperty(stub, "mock", () => mockContext);
-  stub.willCall(function(...args) {
-    instances.push(this);
-    const impl = onceImplementations.shift() || implementation || stub.getOriginal() || (() => {
-    });
-    return impl.apply(this, args);
-  });
-  return stub;
-}
-function fn(implementation) {
-  return enhanceSpy(tinyspy.spyOn({ fn: implementation || (() => {
-  }) }, "fn"));
-}
-
-const vitest = {
-  spyOn,
-  fn
-};
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  suite: suite,
-  test: test,
-  describe: describe,
-  it: it,
-  beforeAll: beforeAll,
-  afterAll: afterAll,
-  beforeEach: beforeEach,
-  afterEach: afterEach,
-  assert: assert,
-  should: should,
-  expect: expect,
-  chai: chai,
-  spy: spy,
-  spyOn: spyOn$1,
-  vitest: vitest
-});
-
-export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, index as i, vitest as v };