@vitest/runner 1.2.2 → 1.3.1

package/LICENSE

@@ -1,7 +1,6 @@
 MIT License
 
-Copyright (c) 2021-Present Anthony Fu <https://github.com/antfu>
-Copyright (c) 2021-Present Matias Capeletto <https://github.com/patak-dev>
+Copyright (c) 2021-Present Vitest Team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/chunk-tasks.js

@@ -0,0 +1,171 @@
+import { processError } from '@vitest/utils/error';
+import { toArray } from '@vitest/utils';
+
+function partitionSuiteChildren(suite) {
+  let tasksGroup = [];
+  const tasksGroups = [];
+  for (const c of suite.tasks) {
+    if (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) {
+      tasksGroup.push(c);
+    } else {
+      tasksGroups.push(tasksGroup);
+      tasksGroup = [c];
+    }
+  }
+  if (tasksGroup.length > 0)
+    tasksGroups.push(tasksGroup);
+  return tasksGroups;
+}
+
+function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnly) {
+  const suiteIsOnly = parentIsOnly || suite.mode === "only";
+  suite.tasks.forEach((t) => {
+    const includeTask = suiteIsOnly || t.mode === "only";
+    if (onlyMode) {
+      if (t.type === "suite" && (includeTask || someTasksAreOnly(t))) {
+        if (t.mode === "only") {
+          checkAllowOnly(t, allowOnly);
+          t.mode = "run";
+        }
+      } else if (t.mode === "run" && !includeTask) {
+        t.mode = "skip";
+      } else if (t.mode === "only") {
+        checkAllowOnly(t, allowOnly);
+        t.mode = "run";
+      }
+    }
+    if (t.type === "test") {
+      if (namePattern && !getTaskFullName(t).match(namePattern))
+        t.mode = "skip";
+    } else if (t.type === "suite") {
+      if (t.mode === "skip")
+        skipAllTasks(t);
+      else
+        interpretTaskModes(t, namePattern, onlyMode, includeTask, allowOnly);
+    }
+  });
+  if (suite.mode === "run") {
+    if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run"))
+      suite.mode = "skip";
+  }
+}
+function getTaskFullName(task) {
+  return `${task.suite ? `${getTaskFullName(task.suite)} ` : ""}${task.name}`;
+}
+function someTasksAreOnly(suite) {
+  return suite.tasks.some((t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t));
+}
+function skipAllTasks(suite) {
+  suite.tasks.forEach((t) => {
+    if (t.mode === "run") {
+      t.mode = "skip";
+      if (t.type === "suite")
+        skipAllTasks(t);
+    }
+  });
+}
+function checkAllowOnly(task, allowOnly) {
+  if (allowOnly)
+    return;
+  const error = processError(new Error("[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error"));
+  task.result = {
+    state: "fail",
+    errors: [error]
+  };
+}
+function generateHash(str) {
+  let hash = 0;
+  if (str.length === 0)
+    return `${hash}`;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `${hash}`;
+}
+function calculateSuiteHash(parent) {
+  parent.tasks.forEach((t, idx) => {
+    t.id = `${parent.id}_${idx}`;
+    if (t.type === "suite")
+      calculateSuiteHash(t);
+  });
+}
+
+function createChainable(keys, fn) {
+  function create(context) {
+    const chain2 = function(...args) {
+      return fn.apply(context, args);
+    };
+    Object.assign(chain2, fn);
+    chain2.withContext = () => chain2.bind(context);
+    chain2.setContext = (key, value) => {
+      context[key] = value;
+    };
+    chain2.mergeContext = (ctx) => {
+      Object.assign(context, ctx);
+    };
+    for (const key of keys) {
+      Object.defineProperty(chain2, key, {
+        get() {
+          return create({ ...context, [key]: true });
+        }
+      });
+    }
+    return chain2;
+  }
+  const chain = create({});
+  chain.fn = fn;
+  return chain;
+}
+
+function isAtomTest(s) {
+  return s.type === "test" || s.type === "custom";
+}
+function getTests(suite) {
+  const tests = [];
+  const arraySuites = toArray(suite);
+  for (const s of arraySuites) {
+    if (isAtomTest(s)) {
+      tests.push(s);
+    } else {
+      for (const task of s.tasks) {
+        if (isAtomTest(task)) {
+          tests.push(task);
+        } else {
+          const taskTests = getTests(task);
+          for (const test of taskTests)
+            tests.push(test);
+        }
+      }
+    }
+  }
+  return tests;
+}
+function getTasks(tasks = []) {
+  return toArray(tasks).flatMap((s) => isAtomTest(s) ? [s] : [s, ...getTasks(s.tasks)]);
+}
+function getSuites(suite) {
+  return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
+}
+function hasTests(suite) {
+  return toArray(suite).some((s) => s.tasks.some((c) => isAtomTest(c) || hasTests(c)));
+}
+function hasFailed(suite) {
+  return toArray(suite).some((s) => {
+    var _a;
+    return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
+  });
+}
+function getNames(task) {
+  const names = [task.name];
+  let current = task;
+  while ((current == null ? void 0 : current.suite) || (current == null ? void 0 : current.file)) {
+    current = current.suite || current.file;
+    if (current == null ? void 0 : current.name)
+      names.unshift(current.name);
+  }
+  return names;
+}
+
+export { getTests as a, getTasks as b, calculateSuiteHash as c, getSuites as d, hasFailed as e, getNames as f, generateHash as g, hasTests as h, interpretTaskModes as i, createChainable as j, partitionSuiteChildren as p, someTasksAreOnly as s };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { VitestRunner } from './types.js';
 export { CancelReason, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource } from './types.js';
-import { T as Task, F as File, d as SuiteAPI, e as TestAPI, f as SuiteCollector, g as CustomAPI, h as SuiteHooks, O as OnTestFailedHandler, a as Test, C as Custom, S as Suite } from './tasks-rsXe_qLO.js';
-export { D as DoneCallback, E as ExtendedContext, r as Fixture, q as FixtureFn, s as Fixtures, t as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, R as RunMode, w as RuntimeContext, z as SequenceHooks, A as SequenceSetupFiles, v as SuiteFactory, j as TaskBase, y as TaskContext, u as TaskCustomOptions, l as TaskMeta, k as TaskPopulated, m as TaskResult, n as TaskResultPack, i as TaskState, x as TestContext, o as TestFunction, p as TestOptions, U as Use } from './tasks-rsXe_qLO.js';
+import { T as Task, F as File, d as SuiteAPI, e as TestAPI, f as SuiteCollector, g as CustomAPI, h as SuiteHooks, O as OnTestFailedHandler, i as OnTestFinishedHandler, a as Test, C as Custom, S as Suite } from './tasks-_kyNRBhz.js';
+export { D as DoneCallback, E as ExtendedContext, t as Fixture, s as FixtureFn, r as FixtureOptions, u as Fixtures, v as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, R as RunMode, y as RuntimeContext, B as SequenceHooks, G as SequenceSetupFiles, x as SuiteFactory, k as TaskBase, A as TaskContext, w as TaskCustomOptions, m as TaskMeta, l as TaskPopulated, n as TaskResult, o as TaskResultPack, j as TaskState, z as TestContext, p as TestFunction, q as TestOptions, U as Use } from './tasks-_kyNRBhz.js';
 import { Awaitable } from '@vitest/utils';
 export { processError } from '@vitest/utils/error';
 import '@vitest/utils/diff';
@@ -21,6 +21,7 @@ declare function afterAll(fn: SuiteHooks['afterAll'][0], timeout?: number): void
 declare function beforeEach<ExtraContext = {}>(fn: SuiteHooks<ExtraContext>['beforeEach'][0], timeout?: number): void;
 declare function afterEach<ExtraContext = {}>(fn: SuiteHooks<ExtraContext>['afterEach'][0], timeout?: number): void;
 declare const onTestFailed: (fn: OnTestFailedHandler) => void;
+declare const onTestFinished: (fn: OnTestFinishedHandler) => void;
 
 declare function setFn(key: Test | Custom, fn: (() => Awaitable<void>)): void;
 declare function getFn<Task = Test | Custom>(key: Task): (() => Awaitable<void>);
@@ -29,4 +30,4 @@ declare function getHooks(key: Suite): SuiteHooks;
 
 declare function getCurrentTest<T extends Test | Custom | undefined>(): T;
 
-export { Custom, CustomAPI, File, OnTestFailedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, setFn, setHooks, startTests, suite, test, updateTask };
+export { Custom, CustomAPI, File, OnTestFailedHandler, OnTestFinishedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };

package/dist/index.js

@@ -1,8 +1,8 @@
 import limit from 'p-limit';
-import { getSafeTimers, createDefer, format, isObject, objDisplay, objectAttr, noop, toArray, shuffle } from '@vitest/utils';
+import { getSafeTimers, isObject, createDefer, format, objDisplay, objectAttr, toArray, shuffle } from '@vitest/utils';
 import { processError } from '@vitest/utils/error';
 export { processError } from '@vitest/utils/error';
-import { createChainable, generateHash, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, partitionSuiteChildren, hasTests, hasFailed } from './utils.js';
+import { j as createChainable, g as generateHash, c as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, p as partitionSuiteChildren, h as hasTests, e as hasFailed } from './chunk-tasks.js';
 import { relative } from 'pathe';
 
 const fnMap = /* @__PURE__ */ new WeakMap();
@@ -80,6 +80,10 @@ function createTestContext(test, runner) {
     test.onFailed || (test.onFailed = []);
     test.onFailed.push(fn);
   };
+  context.onTestFinished = (fn) => {
+    test.onFinished || (test.onFinished = []);
+    test.onFinished.push(fn);
+  };
   return ((_a = runner.extendTaskContext) == null ? void 0 : _a.call(runner, context)) || context;
 }
 function makeTimeoutMsg(isHook, timeout) {
@@ -88,14 +92,16 @@ If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as t
 }
 
 function mergeContextFixtures(fixtures, context = {}) {
-  const fixtureArray = Object.entries(fixtures).map(([prop, value], index) => {
-    const isFn = typeof value === "function";
-    return {
-      prop,
-      value,
-      index,
-      isFn
-    };
+  const fixtureOptionKeys = ["auto"];
+  const fixtureArray = Object.entries(fixtures).map(([prop, value]) => {
+    const fixtureItem = { value };
+    if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key) => fixtureOptionKeys.includes(key))) {
+      Object.assign(fixtureItem, value[1]);
+      fixtureItem.value = value[0];
+    }
+    fixtureItem.prop = prop;
+    fixtureItem.isFn = typeof fixtureItem.value === "function";
+    return fixtureItem;
   });
   if (Array.isArray(context.fixtures))
     context.fixtures = context.fixtures.concat(fixtureArray);
@@ -127,7 +133,8 @@ function withFixtures(fn, testContext) {
     if (!(fixtures == null ? void 0 : fixtures.length))
       return fn(context);
     const usedProps = getUsedProps(fn);
-    if (!usedProps.length)
+    const hasAutoFixture = fixtures.some(({ auto }) => auto);
+    if (!usedProps.length && !hasAutoFixture)
       return fn(context);
     if (!fixtureValueMaps.get(context))
       fixtureValueMaps.set(context, /* @__PURE__ */ new Map());
@@ -135,7 +142,7 @@ function withFixtures(fn, testContext) {
     if (!cleanupFnArrayMap.has(context))
       cleanupFnArrayMap.set(context, []);
     const cleanupFnArray = cleanupFnArrayMap.get(context);
-    const usedFixtures = fixtures.filter(({ prop }) => usedProps.includes(prop));
+    const usedFixtures = fixtures.filter(({ prop, auto }) => auto || usedProps.includes(prop));
     const pendingFixtures = resolveDeps(usedFixtures);
     if (!pendingFixtures.length)
       return fn(context);
@@ -243,10 +250,10 @@ function getCurrentTest() {
 
 const suite = createSuite();
 const test = createTest(
-  function(name, fn, options) {
+  function(name, optionsOrFn, optionsOrTest) {
     if (getCurrentTest())
       throw new Error('Calling the test function inside another test function is not allowed. Please put it inside "describe" or "suite" so it can be properly collected.');
-    getCurrentSuite().test.fn.call(this, formatName(name), fn, options);
+    getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
   }
 );
 const describe = suite;
@@ -278,8 +285,33 @@ function createSuiteHooks() {
     afterEach: []
   };
 }
+function parseArguments(optionsOrFn, optionsOrTest) {
+  let options = {};
+  let fn = () => {
+  };
+  if (typeof optionsOrTest === "object") {
+    if (typeof optionsOrFn === "object")
+      throw new TypeError("Cannot use two objects as arguments. Please provide options and a function callback in that order.");
+    options = optionsOrTest;
+  } else if (typeof optionsOrTest === "number") {
+    options = { timeout: optionsOrTest };
+  } else if (typeof optionsOrFn === "object") {
+    options = optionsOrFn;
+  }
+  if (typeof optionsOrFn === "function") {
+    if (typeof optionsOrTest === "function")
+      throw new TypeError("Cannot use two functions as arguments. Please use the second argument for options.");
+    fn = optionsOrFn;
+  } else if (typeof optionsOrTest === "function") {
+    fn = optionsOrTest;
+  }
+  return {
+    options,
+    handler: fn
+  };
+}
 function createSuiteCollector(name, factory = () => {
-}, mode, concurrent, sequential, shuffle, each, suiteOptions) {
+}, mode, shuffle, each, suiteOptions) {
   const tasks = [];
   const factoryQueue = [];
   let suite2;
@@ -318,16 +350,18 @@ function createSuiteCollector(name, factory = () => {
     tasks.push(task2);
     return task2;
   };
-  const test2 = createTest(function(name2, fn = noop, options = {}) {
-    if (typeof options === "number")
-      options = { timeout: options };
+  const test2 = createTest(function(name2, optionsOrFn, optionsOrTest) {
+    let { options, handler } = parseArguments(
+      optionsOrFn,
+      optionsOrTest
+    );
     if (typeof suiteOptions === "object")
       options = Object.assign({}, suiteOptions, options);
     options.concurrent = this.concurrent || !this.sequential && (options == null ? void 0 : options.concurrent);
     options.sequential = this.sequential || !this.concurrent && (options == null ? void 0 : options.sequential);
     const test3 = task(
       formatName(name2),
-      { ...this, ...options, handler: fn }
+      { ...this, ...options, handler }
     );
     test3.type = "test";
   });
@@ -387,28 +421,34 @@ function createSuiteCollector(name, factory = () => {
   return collector;
 }
 function createSuite() {
-  function suiteFn(name, factory, options = {}) {
+  function suiteFn(name, factoryOrOptions, optionsOrFactory = {}) {
     const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
     const currentSuite = getCurrentSuite();
-    if (typeof options === "number")
-      options = { timeout: options };
+    let { options, handler: factory } = parseArguments(
+      factoryOrOptions,
+      optionsOrFactory
+    );
     if (currentSuite == null ? void 0 : currentSuite.options)
       options = { ...currentSuite.options, ...options };
     options.concurrent = this.concurrent || !this.sequential && (options == null ? void 0 : options.concurrent);
     options.sequential = this.sequential || !this.concurrent && (options == null ? void 0 : options.sequential);
-    return createSuiteCollector(formatName(name), factory, mode, this.concurrent, this.sequential, this.shuffle, this.each, options);
+    return createSuiteCollector(formatName(name), factory, mode, this.shuffle, this.each, options);
   }
   suiteFn.each = function(cases, ...args) {
     const suite2 = this.withContext();
     this.setContext("each", true);
     if (Array.isArray(cases) && args.length)
       cases = formatTemplateString(cases, args);
-    return (name, fn, options) => {
+    return (name, optionsOrFn, fnOrOptions) => {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
+      const { options, handler } = parseArguments(
+        optionsOrFn,
+        fnOrOptions
+      );
       cases.forEach((i, idx) => {
         const items = Array.isArray(i) ? i : [i];
-        arrayOnlyCases ? suite2(formatTitle(_name, items, idx), () => fn(...items), options) : suite2(formatTitle(_name, items, idx), () => fn(i), options);
+        arrayOnlyCases ? suite2(formatTitle(_name, items, idx), options, () => handler(...items)) : suite2(formatTitle(_name, items, idx), options, () => handler(i));
       });
       this.setContext("each", void 0);
     };
@@ -427,12 +467,16 @@ function createTaskCollector(fn, context) {
     this.setContext("each", true);
     if (Array.isArray(cases) && args.length)
       cases = formatTemplateString(cases, args);
-    return (name, fn2, options) => {
+    return (name, optionsOrFn, fnOrOptions) => {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
+      const { options, handler } = parseArguments(
+        optionsOrFn,
+        fnOrOptions
+      );
       cases.forEach((i, idx) => {
         const items = Array.isArray(i) ? i : [i];
-        arrayOnlyCases ? test2(formatTitle(_name, items, idx), () => fn2(...items), options) : test2(formatTitle(_name, items, idx), () => fn2(i), options);
+        arrayOnlyCases ? test2(formatTitle(_name, items, idx), options, () => handler(...items)) : test2(formatTitle(_name, items, idx), options, () => handler(i));
       });
       this.setContext("each", void 0);
     };
@@ -445,8 +489,8 @@ function createTaskCollector(fn, context) {
   };
   taskFn.extend = function(fixtures) {
     const _context = mergeContextFixtures(fixtures, context);
-    return createTest(function fn2(name, fn2, options) {
-      getCurrentSuite().test.fn.call(this, formatName(name), fn2, options);
+    return createTest(function fn2(name, optionsOrFn, optionsOrTest) {
+      getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
     }, _context);
   };
   const _test = createChainable(
@@ -641,7 +685,7 @@ async function callCleanupHooks(cleanups) {
   }));
 }
 async function runTest(test, runner) {
-  var _a, _b, _c, _d, _e, _f, _g;
+  var _a, _b, _c, _d, _e, _f, _g, _h;
   await ((_a = runner.onBeforeRunTask) == null ? void 0 : _a.call(runner, test));
   if (test.mode !== "run")
     return;
@@ -713,8 +757,18 @@ async function runTest(test, runner) {
       updateTask(test, runner);
     }
   }
-  if (test.result.state === "fail")
-    await Promise.all(((_f = test.onFailed) == null ? void 0 : _f.map((fn) => fn(test.result))) || []);
+  try {
+    await Promise.all(((_f = test.onFinished) == null ? void 0 : _f.map((fn) => fn(test.result))) || []);
+  } catch (e) {
+    failTask(test.result, e, runner.config.diffOptions);
+  }
+  if (test.result.state === "fail") {
+    try {
+      await Promise.all(((_g = test.onFailed) == null ? void 0 : _g.map((fn) => fn(test.result))) || []);
+    } catch (e) {
+      failTask(test.result, e, runner.config.diffOptions);
+    }
+  }
   if (test.fails) {
     if (test.result.state === "pass") {
       const error = processError(new Error("Expect test to fail"));
@@ -727,7 +781,7 @@ async function runTest(test, runner) {
   }
   setCurrentTest(void 0);
   test.result.duration = now() - start;
-  await ((_g = runner.onAfterRunTask) == null ? void 0 : _g.call(runner, test));
+  await ((_h = runner.onAfterRunTask) == null ? void 0 : _h.call(runner, test));
   updateTask(test, runner);
 }
 function failTask(result, err, diffOptions) {
@@ -873,13 +927,17 @@ const onTestFailed = createTestHook("onTestFailed", (test, handler) => {
   test.onFailed || (test.onFailed = []);
   test.onFailed.push(handler);
 });
+const onTestFinished = createTestHook("onTestFinished", (test, handler) => {
+  test.onFinished || (test.onFinished = []);
+  test.onFinished.push(handler);
+});
 function createTestHook(name, handler) {
   return (fn) => {
     const current = getCurrentTest();
     if (!current)
       throw new Error(`Hook ${name}() can only be called inside a test`);
-    handler(current, fn);
+    return handler(current, fn);
   };
 }
 
-export { afterAll, afterEach, beforeAll, beforeEach, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, setFn, setHooks, startTests, suite, test, updateTask };
+export { afterAll, afterEach, beforeAll, beforeEach, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };

package/dist/{tasks-rsXe_qLO.d.ts → tasks-_kyNRBhz.d.ts}

@@ -1,18 +1,15 @@
 import { ErrorWithDiff, Awaitable } from '@vitest/utils';
 
-type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> = {
-    (...args: Args): R;
+type ChainableFunction<T extends string, F extends (...args: any) => any, C = {}> = F & {
+    [x in T]: ChainableFunction<T, F, C>;
 } & {
-    [x in T]: ChainableFunction<T, Args, R, E>;
-} & {
-    fn: (this: Record<T, any>, ...args: Args) => R;
-} & E;
-declare function createChainable<T extends string, Args extends any[], R = any, E = {}>(keys: T[], fn: (this: Record<T, any>, ...args: Args) => R): ChainableFunction<T, Args, R, E>;
+    fn: (this: Record<T, any>, ...args: Parameters<F>) => ReturnType<F>;
+} & C;
+declare function createChainable<T extends string, Args extends any[], R = any>(keys: T[], fn: (this: Record<T, any>, ...args: Args) => R): ChainableFunction<T, (...args: Args) => R>;
 
-interface FixtureItem {
+interface FixtureItem extends FixtureOptions {
     prop: string;
     value: any;
-    index: number;
     /**
      * Indicates whether the fixture is a function
      */
@@ -45,6 +42,7 @@ interface TaskPopulated extends TaskBase {
     result?: TaskResult;
     fails?: boolean;
     onFailed?: OnTestFailedHandler[];
+    onFinished?: OnTestFinishedHandler[];
     /**
      * Store promises (from async expects) to wait for them before finishing the test
      */
@@ -99,24 +97,30 @@ type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
     10: [T[0], T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8], T[9]];
     fallback: Array<T extends ReadonlyArray<infer U> ? U : any>;
 }[T extends Readonly<[any]> ? 1 : T extends Readonly<[any, any]> ? 2 : T extends Readonly<[any, any, any]> ? 3 : T extends Readonly<[any, any, any, any]> ? 4 : T extends Readonly<[any, any, any, any, any]> ? 5 : T extends Readonly<[any, any, any, any, any, any]> ? 6 : T extends Readonly<[any, any, any, any, any, any, any]> ? 7 : T extends Readonly<[any, any, any, any, any, any, any, any]> ? 8 : T extends Readonly<[any, any, any, any, any, any, any, any, any]> ? 9 : T extends Readonly<[any, any, any, any, any, any, any, any, any, any]> ? 10 : 'fallback'];
-interface SuiteEachFunction {
-    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string | Function, fn: (...args: T) => Awaitable<void>) => void;
-    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string | Function, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>) => void;
-    <T>(cases: ReadonlyArray<T>): (name: string | Function, fn: (...args: T[]) => Awaitable<void>) => void;
+interface EachFunctionReturn<T extends any[]> {
+    /**
+     * @deprecated Use options as the second argument instead
+     */
+    (name: string | Function, fn: (...args: T) => Awaitable<void>, options: TestOptions): void;
+    (name: string | Function, fn: (...args: T) => Awaitable<void>, options?: number | TestOptions): void;
+    (name: string | Function, options: TestOptions, fn: (...args: T) => Awaitable<void>): void;
 }
 interface TestEachFunction {
-    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string | Function, fn: (...args: T) => Awaitable<void>, options?: number | TestOptions) => void;
-    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string | Function, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>, options?: number | TestOptions) => void;
-    <T>(cases: ReadonlyArray<T>): (name: string | Function, fn: (...args: T[]) => Awaitable<void>, options?: number | TestOptions) => void;
-    (...args: [TemplateStringsArray, ...any]): (name: string | Function, fn: (...args: any[]) => Awaitable<void>, options?: number | TestOptions) => void;
-}
-type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'fails', [
-    name: string | Function,
-    fn?: TestFunction<ExtraContext>,
-    options?: number | TestOptions
-], void, {
+    <T extends any[] | [any]>(cases: ReadonlyArray<T>): EachFunctionReturn<T>;
+    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): EachFunctionReturn<ExtractEachCallbackArgs<T>>;
+    <T>(cases: ReadonlyArray<T>): EachFunctionReturn<T[]>;
+    (...args: [TemplateStringsArray, ...any]): EachFunctionReturn<any[]>;
+}
+interface TestCollectorCallable<C = {}> {
+    /**
+     * @deprecated Use options as the second argument instead
+     */
+    <ExtraContext extends C>(name: string | Function, fn: TestFunction<ExtraContext>, options: TestOptions): void;
+    <ExtraContext extends C>(name: string | Function, fn?: TestFunction<ExtraContext>, options?: number | TestOptions): void;
+    <ExtraContext extends C>(name: string | Function, options?: TestOptions, fn?: TestFunction<ExtraContext>): void;
+}
+type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'fails', TestCollectorCallable<ExtraContext>, {
     each: TestEachFunction;
-    <T extends ExtraContext>(name: string | Function, fn?: TestFunction<T>, options?: number | TestOptions): void;
 }>;
 interface TestOptions {
     /**
@@ -147,41 +151,64 @@ interface TestOptions {
      * Tests inherit `sequential` from `describe()` and nested `describe()` will inherit from parent's `sequential`.
      */
     sequential?: boolean;
+    /**
+     * Whether the test should be skipped.
+     */
+    skip?: boolean;
+    /**
+     * Should this test be the only one running in a suite.
+     */
+    only?: boolean;
+    /**
+     * Whether the test should be skipped and marked as a todo.
+     */
+    todo?: boolean;
+    /**
+     * Whether the test is expected to fail. If it does, the test will pass, otherwise it will fail.
+     */
+    fails?: boolean;
 }
 interface ExtendedAPI<ExtraContext> {
-    each: TestEachFunction;
-    skipIf(condition: any): ChainableTestAPI<ExtraContext>;
-    runIf(condition: any): ChainableTestAPI<ExtraContext>;
+    skipIf: (condition: any) => ChainableTestAPI<ExtraContext>;
+    runIf: (condition: any) => ChainableTestAPI<ExtraContext>;
 }
 type CustomAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & ExtendedAPI<ExtraContext> & {
-    extend<T extends Record<string, any> = {}>(fixtures: Fixtures<T, ExtraContext>): CustomAPI<{
+    extend: <T extends Record<string, any> = {}>(fixtures: Fixtures<T, ExtraContext>) => CustomAPI<{
         [K in keyof T | keyof ExtraContext]: K extends keyof T ? T[K] : K extends keyof ExtraContext ? ExtraContext[K] : never;
     }>;
 };
 type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & ExtendedAPI<ExtraContext> & {
-    extend<T extends Record<string, any> = {}>(fixtures: Fixtures<T, ExtraContext>): TestAPI<{
+    extend: <T extends Record<string, any> = {}>(fixtures: Fixtures<T, ExtraContext>) => TestAPI<{
         [K in keyof T | keyof ExtraContext]: K extends keyof T ? T[K] : K extends keyof ExtraContext ? ExtraContext[K] : never;
     }>;
 };
+interface FixtureOptions {
+    /**
+     * Whether to automatically set up current fixture, even though it's not being used in tests.
+     */
+    auto?: boolean;
+}
 type Use<T> = (value: T) => Promise<void>;
 type FixtureFn<T, K extends keyof T, ExtraContext> = (context: Omit<T, K> & ExtraContext, use: Use<T[K]>) => Promise<void>;
 type Fixture<T, K extends keyof T, ExtraContext = {}> = ((...args: any) => any) extends T[K] ? (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never) : T[K] | (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never);
 type Fixtures<T extends Record<string, any>, ExtraContext = {}> = {
-    [K in keyof T]: Fixture<T, K, ExtraContext & ExtendedContext<Test>>;
+    [K in keyof T]: Fixture<T, K, ExtraContext & ExtendedContext<Test>> | [Fixture<T, K, ExtraContext & ExtendedContext<Test>>, FixtureOptions?];
 };
 type InferFixturesTypes<T> = T extends TestAPI<infer C> ? C : T;
-type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'shuffle', [
-    name: string | Function,
-    factory?: SuiteFactory<ExtraContext>,
-    options?: number | TestOptions
-], SuiteCollector<ExtraContext>, {
+interface SuiteCollectorCallable<ExtraContext = {}> {
+    /**
+     * @deprecated Use options as the second argument instead
+     */
+    (name: string | Function, fn: SuiteFactory<ExtraContext>, options: TestOptions): SuiteCollector<ExtraContext>;
+    (name: string | Function, fn?: SuiteFactory<ExtraContext>, options?: number | TestOptions): SuiteCollector<ExtraContext>;
+    (name: string | Function, options: TestOptions, fn?: SuiteFactory<ExtraContext>): SuiteCollector<ExtraContext>;
+}
+type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'shuffle', SuiteCollectorCallable<ExtraContext>, {
     each: TestEachFunction;
-    <T extends ExtraContext>(name: string | Function, factory?: SuiteFactory<T>): SuiteCollector<T>;
 }>;
 type SuiteAPI<ExtraContext = {}> = ChainableSuiteAPI<ExtraContext> & {
-    each: SuiteEachFunction;
-    skipIf(condition: any): ChainableSuiteAPI<ExtraContext>;
-    runIf(condition: any): ChainableSuiteAPI<ExtraContext>;
+    skipIf: (condition: any) => ChainableSuiteAPI<ExtraContext>;
+    runIf: (condition: any) => ChainableSuiteAPI<ExtraContext>;
 };
 type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return>;
 type HookCleanupCallback = (() => Awaitable<unknown>) | void;
@@ -231,6 +258,10 @@ interface TaskContext<Task extends Custom | Test = Custom | Test> {
      * Extract hooks on test failed
      */
     onTestFailed: (fn: OnTestFailedHandler) => void;
+    /**
+     * Extract hooks on test failed
+     */
+    onTestFinished: (fn: OnTestFinishedHandler) => void;
     /**
      * Mark tests as skipped. All execution after this call will be skipped.
      */
@@ -238,7 +269,8 @@ interface TaskContext<Task extends Custom | Test = Custom | Test> {
 }
 type ExtendedContext<T extends Custom | Test> = TaskContext<T> & TestContext;
 type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
+type OnTestFinishedHandler = (result: TaskResult) => Awaitable<void>;
 type SequenceHooks = 'stack' | 'list' | 'parallel';
 type SequenceSetupFiles = 'list' | 'parallel';
 
-export { type SequenceSetupFiles as A, type Custom as C, type DoneCallback as D, type ExtendedContext as E, type File as F, type HookListener as H, type InferFixturesTypes as I, type OnTestFailedHandler as O, type RunMode as R, type Suite as S, type Task as T, type Use as U, type Test as a, type ChainableFunction as b, createChainable as c, type SuiteAPI as d, type TestAPI as e, type SuiteCollector as f, type CustomAPI as g, type SuiteHooks as h, type TaskState as i, type TaskBase as j, type TaskPopulated as k, type TaskMeta as l, type TaskResult as m, type TaskResultPack as n, type TestFunction as o, type TestOptions as p, type FixtureFn as q, type Fixture as r, type Fixtures as s, type HookCleanupCallback as t, type TaskCustomOptions as u, type SuiteFactory as v, type RuntimeContext as w, type TestContext as x, type TaskContext as y, type SequenceHooks as z };
+export { type TaskContext as A, type SequenceHooks as B, type Custom as C, type DoneCallback as D, type ExtendedContext as E, type File as F, type SequenceSetupFiles as G, type HookListener as H, type InferFixturesTypes as I, type OnTestFailedHandler as O, type RunMode as R, type Suite as S, type Task as T, type Use as U, type Test as a, type ChainableFunction as b, createChainable as c, type SuiteAPI as d, type TestAPI as e, type SuiteCollector as f, type CustomAPI as g, type SuiteHooks as h, type OnTestFinishedHandler as i, type TaskState as j, type TaskBase as k, type TaskPopulated as l, type TaskMeta as m, type TaskResult as n, type TaskResultPack as o, type TestFunction as p, type TestOptions as q, type FixtureOptions as r, type FixtureFn as s, type Fixture as t, type Fixtures as u, type HookCleanupCallback as v, type TaskCustomOptions as w, type SuiteFactory as x, type RuntimeContext as y, type TestContext as z };

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import { z as SequenceHooks, A as SequenceSetupFiles, F as File, k as TaskPopulated, S as Suite, n as TaskResultPack, a as Test, C as Custom, y as TaskContext, E as ExtendedContext } from './tasks-rsXe_qLO.js';
-export { g as CustomAPI, D as DoneCallback, r as Fixture, q as FixtureFn, s as Fixtures, t as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, R as RunMode, w as RuntimeContext, d as SuiteAPI, f as SuiteCollector, v as SuiteFactory, h as SuiteHooks, T as Task, j as TaskBase, u as TaskCustomOptions, l as TaskMeta, m as TaskResult, i as TaskState, e as TestAPI, x as TestContext, o as TestFunction, p as TestOptions, U as Use } from './tasks-rsXe_qLO.js';
+import { B as SequenceHooks, G as SequenceSetupFiles, F as File, T as Task, S as Suite, o as TaskResultPack, a as Test, C as Custom, A as TaskContext, E as ExtendedContext } from './tasks-_kyNRBhz.js';
+export { g as CustomAPI, D as DoneCallback, t as Fixture, s as FixtureFn, r as FixtureOptions, u as Fixtures, v as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, i as OnTestFinishedHandler, R as RunMode, y as RuntimeContext, d as SuiteAPI, f as SuiteCollector, x as SuiteFactory, h as SuiteHooks, k as TaskBase, w as TaskCustomOptions, m as TaskMeta, l as TaskPopulated, n as TaskResult, j as TaskState, e as TestAPI, z as TestContext, p as TestFunction, q as TestOptions, U as Use } from './tasks-_kyNRBhz.js';
 import { DiffOptions } from '@vitest/utils/diff';
 import '@vitest/utils';
 
@@ -35,69 +35,69 @@ interface VitestRunner {
     /**
      * First thing that's getting called before actually collecting and running tests.
      */
-    onBeforeCollect?(paths: string[]): unknown;
+    onBeforeCollect?: (paths: string[]) => unknown;
     /**
      * Called after collecting tests and before "onBeforeRun".
      */
-    onCollected?(files: File[]): unknown;
+    onCollected?: (files: File[]) => unknown;
     /**
      * Called when test runner should cancel next test runs.
      * Runner should listen for this method and mark tests and suites as skipped in
      * "onBeforeRunSuite" and "onBeforeRunTask" when called.
      */
-    onCancel?(reason: CancelReason): unknown;
+    onCancel?: (reason: CancelReason) => unknown;
     /**
      * Called before running a single test. Doesn't have "result" yet.
      */
-    onBeforeRunTask?(test: TaskPopulated): unknown;
+    onBeforeRunTask?: (test: Task) => unknown;
     /**
      * Called before actually running the test function. Already has "result" with "state" and "startTime".
      */
-    onBeforeTryTask?(test: TaskPopulated, options: {
+    onBeforeTryTask?: (test: Task, options: {
         retry: number;
         repeats: number;
-    }): unknown;
+    }) => unknown;
     /**
      * Called after result and state are set.
      */
-    onAfterRunTask?(test: TaskPopulated): unknown;
+    onAfterRunTask?: (test: Task) => unknown;
     /**
      * Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
      */
-    onAfterTryTask?(test: TaskPopulated, options: {
+    onAfterTryTask?: (test: Task, options: {
         retry: number;
         repeats: number;
-    }): unknown;
+    }) => unknown;
     /**
      * Called before running a single suite. Doesn't have "result" yet.
      */
-    onBeforeRunSuite?(suite: Suite): unknown;
+    onBeforeRunSuite?: (suite: Suite) => unknown;
     /**
      * Called after running a single suite. Has state and result.
      */
-    onAfterRunSuite?(suite: Suite): unknown;
+    onAfterRunSuite?: (suite: Suite) => unknown;
     /**
      * If defined, will be called instead of usual Vitest suite partition and handling.
      * "before" and "after" hooks will not be ignored.
      */
-    runSuite?(suite: Suite): Promise<void>;
+    runSuite?: (suite: Suite) => Promise<void>;
     /**
      * If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
      * "before" and "after" hooks will not be ignored.
      */
-    runTask?(test: TaskPopulated): Promise<void>;
+    runTask?: (test: Task) => Promise<void>;
     /**
      * Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
      */
-    onTaskUpdate?(task: TaskResultPack[]): Promise<void>;
+    onTaskUpdate?: (task: TaskResultPack[]) => Promise<void>;
     /**
      * Called before running all tests in collected paths.
      */
-    onBeforeRunFiles?(files: File[]): unknown;
+    onBeforeRunFiles?: (files: File[]) => unknown;
     /**
      * Called right after running all tests in collected paths.
      */
-    onAfterRunFiles?(files: File[]): unknown;
+    onAfterRunFiles?: (files: File[]) => unknown;
     /**
      * Called when new context for a test is defined. Useful, if you want to add custom properties to the context.
      * If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
@@ -106,15 +106,15 @@ interface VitestRunner {
      *
      * @see https://vitest.dev/advanced/runner.html#your-task-function
      */
-    extendTaskContext?<T extends Test | Custom>(context: TaskContext<T>): ExtendedContext<T>;
+    extendTaskContext?: <T extends Test | Custom>(context: TaskContext<T>) => ExtendedContext<T>;
     /**
      * Called, when files are imported. Can be called in two situations: when collecting tests and when importing setup files.
      */
-    importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+    importFile: (filepath: string, source: VitestRunnerImportSource) => unknown;
     /**
      * Publicly available configuration.
      */
     config: VitestRunnerConfig;
 }
 
-export { type CancelReason, Custom, ExtendedContext, File, SequenceHooks, SequenceSetupFiles, Suite, TaskContext, TaskPopulated, TaskResultPack, Test, type VitestRunner, type VitestRunnerConfig, type VitestRunnerConstructor, type VitestRunnerImportSource };
+export { type CancelReason, Custom, ExtendedContext, File, SequenceHooks, SequenceSetupFiles, Suite, Task, TaskContext, TaskResultPack, Test, type VitestRunner, type VitestRunnerConfig, type VitestRunnerConstructor, type VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, T as Task, a as Test, C as Custom } from './tasks-rsXe_qLO.js';
-export { b as ChainableFunction, c as createChainable } from './tasks-rsXe_qLO.js';
+import { S as Suite, T as Task, a as Test, C as Custom } from './tasks-_kyNRBhz.js';
+export { b as ChainableFunction, c as createChainable } from './tasks-_kyNRBhz.js';
 import { Arrayable } from '@vitest/utils';
 
 /**

package/dist/utils.js

@@ -1,168 +1,3 @@
-import { processError } from '@vitest/utils/error';
-import { toArray } from '@vitest/utils';
-
-function partitionSuiteChildren(suite) {
-  let tasksGroup = [];
-  const tasksGroups = [];
-  for (const c of suite.tasks) {
-    if (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) {
-      tasksGroup.push(c);
-    } else {
-      tasksGroups.push(tasksGroup);
-      tasksGroup = [c];
-    }
-  }
-  if (tasksGroup.length > 0)
-    tasksGroups.push(tasksGroup);
-  return tasksGroups;
-}
-
-function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnly) {
-  const suiteIsOnly = parentIsOnly || suite.mode === "only";
-  suite.tasks.forEach((t) => {
-    const includeTask = suiteIsOnly || t.mode === "only";
-    if (onlyMode) {
-      if (t.type === "suite" && (includeTask || someTasksAreOnly(t))) {
-        if (t.mode === "only") {
-          checkAllowOnly(t, allowOnly);
-          t.mode = "run";
-        }
-      } else if (t.mode === "run" && !includeTask) {
-        t.mode = "skip";
-      } else if (t.mode === "only") {
-        checkAllowOnly(t, allowOnly);
-        t.mode = "run";
-      }
-    }
-    if (t.type === "test") {
-      if (namePattern && !getTaskFullName(t).match(namePattern))
-        t.mode = "skip";
-    } else if (t.type === "suite") {
-      if (t.mode === "skip")
-        skipAllTasks(t);
-      else
-        interpretTaskModes(t, namePattern, onlyMode, includeTask, allowOnly);
-    }
-  });
-  if (suite.mode === "run") {
-    if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run"))
-      suite.mode = "skip";
-  }
-}
-function getTaskFullName(task) {
-  return `${task.suite ? `${getTaskFullName(task.suite)} ` : ""}${task.name}`;
-}
-function someTasksAreOnly(suite) {
-  return suite.tasks.some((t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t));
-}
-function skipAllTasks(suite) {
-  suite.tasks.forEach((t) => {
-    if (t.mode === "run") {
-      t.mode = "skip";
-      if (t.type === "suite")
-        skipAllTasks(t);
-    }
-  });
-}
-function checkAllowOnly(task, allowOnly) {
-  if (allowOnly)
-    return;
-  const error = processError(new Error("[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error"));
-  task.result = {
-    state: "fail",
-    errors: [error]
-  };
-}
-function generateHash(str) {
-  let hash = 0;
-  if (str.length === 0)
-    return `${hash}`;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return `${hash}`;
-}
-function calculateSuiteHash(parent) {
-  parent.tasks.forEach((t, idx) => {
-    t.id = `${parent.id}_${idx}`;
-    if (t.type === "suite")
-      calculateSuiteHash(t);
-  });
-}
-
-function createChainable(keys, fn) {
-  function create(context) {
-    const chain2 = function(...args) {
-      return fn.apply(context, args);
-    };
-    Object.assign(chain2, fn);
-    chain2.withContext = () => chain2.bind(context);
-    chain2.setContext = (key, value) => {
-      context[key] = value;
-    };
-    chain2.mergeContext = (ctx) => {
-      Object.assign(context, ctx);
-    };
-    for (const key of keys) {
-      Object.defineProperty(chain2, key, {
-        get() {
-          return create({ ...context, [key]: true });
-        }
-      });
-    }
-    return chain2;
-  }
-  const chain = create({});
-  chain.fn = fn;
-  return chain;
-}
-
-function isAtomTest(s) {
-  return s.type === "test" || s.type === "custom";
-}
-function getTests(suite) {
-  const tests = [];
-  const arraySuites = toArray(suite);
-  for (const s of arraySuites) {
-    if (isAtomTest(s)) {
-      tests.push(s);
-    } else {
-      for (const task of s.tasks) {
-        if (isAtomTest(task))
-          tests.push(task);
-        else
-          tests.push(...getTests(task));
-      }
-    }
-  }
-  return tests;
-}
-function getTasks(tasks = []) {
-  return toArray(tasks).flatMap((s) => isAtomTest(s) ? [s] : [s, ...getTasks(s.tasks)]);
-}
-function getSuites(suite) {
-  return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
-}
-function hasTests(suite) {
-  return toArray(suite).some((s) => s.tasks.some((c) => isAtomTest(c) || hasTests(c)));
-}
-function hasFailed(suite) {
-  return toArray(suite).some((s) => {
-    var _a;
-    return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
-  });
-}
-function getNames(task) {
-  const names = [task.name];
-  let current = task;
-  while ((current == null ? void 0 : current.suite) || (current == null ? void 0 : current.file)) {
-    current = current.suite || current.file;
-    if (current == null ? void 0 : current.name)
-      names.unshift(current.name);
-  }
-  return names;
-}
-
-export { calculateSuiteHash, createChainable, generateHash, getNames, getSuites, getTasks, getTests, hasFailed, hasTests, interpretTaskModes, partitionSuiteChildren, someTasksAreOnly };
+export { c as calculateSuiteHash, j as createChainable, g as generateHash, f as getNames, d as getSuites, b as getTasks, a as getTests, e as hasFailed, h as hasTests, i as interpretTaskModes, p as partitionSuiteChildren, s as someTasksAreOnly } from './chunk-tasks.js';
+import '@vitest/utils/error';
+import '@vitest/utils';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -40,7 +40,7 @@
   "dependencies": {
     "p-limit": "^5.0.0",
     "pathe": "^1.1.1",
-    "@vitest/utils": "1.2.2"
+    "@vitest/utils": "1.3.1"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",