@vitest/runner 0.34.6 → 1.0.0-beta.0

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 SuiteHooks, O as OnTestFailedHandler, a as Test } from './tasks-e594cd24.js';
-export { D as DoneCallback, o as Fixtures, p as HookCleanupCallback, H as HookListener, R as RunMode, r as RuntimeContext, t as SequenceHooks, u as SequenceSetupFiles, S as Suite, q as SuiteFactory, i as TaskBase, b as TaskCustom, j as TaskMeta, k as TaskResult, l as TaskResultPack, h as TaskState, s as TestContext, m as TestFunction, n as TestOptions } from './tasks-e594cd24.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 } from './tasks-b31a73cb.js';
+export { D as DoneCallback, E as ExtendedContext, q as Fixture, r as Fixtures, s as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, R as RunMode, v as RuntimeContext, y as SequenceHooks, z as SequenceSetupFiles, S as Suite, u as SuiteFactory, j as TaskBase, x as TaskContext, t as TaskCustomOptions, l as TaskMeta, k as TaskPopulated, m as TaskResult, n as TaskResultPack, i as TaskState, w as TestContext, o as TestFunction, p as TestOptions } from './tasks-b31a73cb.js';
 import { Awaitable } from '@vitest/utils';
 
 declare function updateTask(task: Task, runner: VitestRunner): void;
@@ -12,6 +12,7 @@ declare const test: TestAPI;
 declare const describe: SuiteAPI;
 declare const it: TestAPI;
 declare function getCurrentSuite<ExtraContext = {}>(): SuiteCollector<ExtraContext>;
+declare function createTaskCollector(fn: (...args: any[]) => any, context?: Record<string, unknown>): CustomAPI;
 
 declare function beforeAll(fn: SuiteHooks['beforeAll'][0], timeout?: number): void;
 declare function afterAll(fn: SuiteHooks['afterAll'][0], timeout?: number): void;
@@ -19,9 +20,9 @@ declare function beforeEach<ExtraContext = {}>(fn: SuiteHooks<ExtraContext>['bef
 declare function afterEach<ExtraContext = {}>(fn: SuiteHooks<ExtraContext>['afterEach'][0], timeout?: number): void;
 declare const onTestFailed: (fn: OnTestFailedHandler) => void;
 
-declare function setFn(key: Test, fn: (() => Awaitable<void>)): void;
-declare function getFn<Task = Test>(key: Task): (() => Awaitable<void>);
+declare function setFn(key: Test | Custom, fn: (() => Awaitable<void>)): void;
+declare function getFn<Task = Test | Custom>(key: Task): (() => Awaitable<void>);
 
-declare function getCurrentTest(): Test<{}> | undefined;
+declare function getCurrentTest<T extends Test | Custom | undefined>(): T;
 
-export { File, OnTestFailedHandler, SuiteAPI, SuiteCollector, SuiteHooks, Task, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, describe, getCurrentSuite, getCurrentTest, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };
+export { Custom, CustomAPI, File, OnTestFailedHandler, SuiteAPI, SuiteCollector, SuiteHooks, Task, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };

package/dist/index.js

@@ -70,7 +70,6 @@ function createTestContext(test, runner) {
   const context = function() {
     throw new Error("done() callback is deprecated, use promise instead");
   };
-  context.meta = test;
   context.task = test;
   context.skip = () => {
     test.pending = true;
@@ -80,7 +79,7 @@ function createTestContext(test, runner) {
     test.onFailed || (test.onFailed = []);
     test.onFailed.push(fn);
   };
-  return ((_a = runner.extendTestContext) == null ? void 0 : _a.call(runner, context)) || context;
+  return ((_a = runner.extendTaskContext) == null ? void 0 : _a.call(runner, context)) || context;
 }
 function makeTimeoutMsg(isHook, timeout) {
   return `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.
@@ -274,52 +273,51 @@ function createSuiteCollector(name, factory = () => {
   const factoryQueue = [];
   let suite2;
   initSuite();
-  const test2 = createTest(function(name2, fn = noop, options) {
-    const mode2 = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
-    if (typeof options === "number")
-      options = { timeout: options };
-    if (typeof suiteOptions === "object")
-      options = Object.assign({}, suiteOptions, options);
-    const test3 = {
+  const task = function(name2 = "", options = {}) {
+    const task2 = {
       id: "",
-      type: "test",
-      name: formatName(name2),
-      each: this.each,
-      mode: mode2,
+      name: name2,
       suite: void 0,
-      fails: this.fails,
-      retry: (options == null ? void 0 : options.retry) ?? runner.config.retry,
-      repeats: options == null ? void 0 : options.repeats,
-      meta: /* @__PURE__ */ Object.create(null)
+      each: options.each,
+      fails: options.fails,
+      context: void 0,
+      type: "custom",
+      retry: options.retry ?? runner.config.retry,
+      repeats: options.repeats,
+      mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
+      meta: options.meta ?? /* @__PURE__ */ Object.create(null)
     };
-    if (this.concurrent || !sequential && (concurrent || runner.config.sequence.concurrent))
-      test3.concurrent = true;
+    const handler = options.handler;
+    if (options.concurrent || !sequential && (concurrent || runner.config.sequence.concurrent))
+      task2.concurrent = true;
     if (shuffle)
-      test3.shuffle = true;
-    const context = createTestContext(test3, runner);
-    Object.defineProperty(test3, "context", {
+      task2.shuffle = true;
+    const context = createTestContext(task2, runner);
+    Object.defineProperty(task2, "context", {
       value: context,
       enumerable: false
     });
-    setFixture(context, this.fixtures);
-    setFn(test3, withTimeout(
-      withFixtures(fn, context),
-      (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
-    ));
-    tasks.push(test3);
-  });
-  const custom = function(name2 = "") {
-    const self = this || {};
-    const task = {
-      id: "",
-      name: name2,
-      type: "custom",
-      mode: self.only ? "only" : self.skip ? "skip" : self.todo ? "todo" : "run",
-      meta: /* @__PURE__ */ Object.create(null)
-    };
-    tasks.push(task);
-    return task;
+    setFixture(context, options.fixtures);
+    if (handler) {
+      setFn(task2, withTimeout(
+        withFixtures(handler, context),
+        (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
+      ));
+    }
+    tasks.push(task2);
+    return task2;
   };
+  const test2 = createTest(function(name2, fn = noop, options) {
+    if (typeof options === "number")
+      options = { timeout: options };
+    if (typeof suiteOptions === "object")
+      options = Object.assign({}, suiteOptions, options);
+    const test3 = task(
+      formatName(name2),
+      { ...this, ...options, handler: fn }
+    );
+    test3.type = "test";
+  });
   const collector = {
     type: "collector",
     name,
@@ -328,7 +326,7 @@ function createSuiteCollector(name, factory = () => {
     test: test2,
     tasks,
     collect,
-    custom,
+    task,
     clear,
     on: addHook
   };
@@ -364,10 +362,10 @@ function createSuiteCollector(name, factory = () => {
       allChildren.push(i.type === "collector" ? await i.collect(file) : i);
     suite2.file = file;
     suite2.tasks = allChildren;
-    allChildren.forEach((task) => {
-      task.suite = suite2;
+    allChildren.forEach((task2) => {
+      task2.suite = suite2;
       if (file)
-        task.file = file;
+        task2.file = file;
     });
     return suite2;
   }
@@ -406,9 +404,9 @@ function createSuite() {
     suiteFn
   );
 }
-function createTest(fn, context) {
-  const testFn = fn;
-  testFn.each = function(cases, ...args) {
+function createTaskCollector(fn, context) {
+  const taskFn = fn;
+  taskFn.each = function(cases, ...args) {
     const test2 = this.withContext();
     this.setContext("each", true);
     if (Array.isArray(cases) && args.length)
@@ -423,9 +421,9 @@ function createTest(fn, context) {
       this.setContext("each", void 0);
     };
   };
-  testFn.skipIf = (condition) => condition ? test.skip : test;
-  testFn.runIf = (condition) => condition ? test : test.skip;
-  testFn.extend = function(fixtures) {
+  taskFn.skipIf = (condition) => condition ? test.skip : test;
+  taskFn.runIf = (condition) => condition ? test : test.skip;
+  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);
@@ -433,12 +431,15 @@ function createTest(fn, context) {
   };
   const _test = createChainable(
     ["concurrent", "skip", "only", "todo", "fails"],
-    testFn
+    taskFn
   );
   if (context)
     _test.mergeContext(context);
   return _test;
 }
+function createTest(fn, context) {
+  return createTaskCollector(fn, context);
+}
 function formatName(name) {
   return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
 }
@@ -630,7 +631,7 @@ async function callCleanupHooks(cleanups) {
 }
 async function runTest(test, runner) {
   var _a, _b, _c, _d, _e, _f, _g;
-  await ((_a = runner.onBeforeRunTest) == null ? void 0 : _a.call(runner, test));
+  await ((_a = runner.onBeforeRunTask) == null ? void 0 : _a.call(runner, test));
   if (test.mode !== "run")
     return;
   if (((_b = test.result) == null ? void 0 : _b.state) === "fail") {
@@ -651,11 +652,11 @@ async function runTest(test, runner) {
     for (let retryCount = 0; retryCount <= retry; retryCount++) {
       let beforeEachCleanups = [];
       try {
-        await ((_c = runner.onBeforeTryTest) == null ? void 0 : _c.call(runner, test, { retry: retryCount, repeats: repeatCount }));
+        await ((_c = runner.onBeforeTryTask) == null ? void 0 : _c.call(runner, test, { retry: retryCount, repeats: repeatCount }));
         test.result.repeatCount = repeatCount;
         beforeEachCleanups = await callSuiteHook(test.suite, test, "beforeEach", runner, [test.context, test.suite]);
-        if (runner.runTest) {
-          await runner.runTest(test);
+        if (runner.runTask) {
+          await runner.runTask(test);
         } else {
           const fn = getFn(test);
           if (!fn)
@@ -668,7 +669,7 @@ async function runTest(test, runner) {
           if (errors.length)
             throw errors;
         }
-        await ((_d = runner.onAfterTryTest) == null ? void 0 : _d.call(runner, test, { retry: retryCount, repeats: repeatCount }));
+        await ((_d = runner.onAfterTryTask) == null ? void 0 : _d.call(runner, test, { retry: retryCount, repeats: repeatCount }));
         if (test.result.state !== "fail") {
           if (!test.repeats)
             test.result.state = "pass";
@@ -715,7 +716,7 @@ async function runTest(test, runner) {
   }
   setCurrentTest(void 0);
   test.result.duration = now() - start;
-  await ((_g = runner.onAfterRunTest) == null ? void 0 : _g.call(runner, test));
+  await ((_g = runner.onAfterRunTask) == null ? void 0 : _g.call(runner, test));
   updateTask(test, runner);
 }
 function failTask(result, err, diffOptions) {
@@ -813,7 +814,7 @@ async function runSuite(suite, runner) {
   }
 }
 async function runSuiteChild(c, runner) {
-  if (c.type === "test")
+  if (c.type === "test" || c.type === "custom")
     return runTest(c, runner);
   else if (c.type === "suite")
     return runSuite(c, runner);
@@ -839,9 +840,9 @@ async function startTests(paths, runner) {
   await ((_a = runner.onBeforeCollect) == null ? void 0 : _a.call(runner, paths));
   const files = await collectTests(paths, runner);
   (_b = runner.onCollected) == null ? void 0 : _b.call(runner, files);
-  await ((_c = runner.onBeforeRun) == null ? void 0 : _c.call(runner, files));
+  await ((_c = runner.onBeforeRunFiles) == null ? void 0 : _c.call(runner, files));
   await runFiles(files, runner);
-  await ((_d = runner.onAfterRun) == null ? void 0 : _d.call(runner, files));
+  await ((_d = runner.onAfterRunFiles) == null ? void 0 : _d.call(runner, files));
   await sendTasksUpdate(runner);
   return files;
 }
@@ -874,4 +875,4 @@ function createTestHook(name, handler) {
   };
 }
 
-export { afterAll, afterEach, beforeAll, beforeEach, describe, getCurrentSuite, getCurrentTest, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };
+export { afterAll, afterEach, beforeAll, beforeEach, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, it, onTestFailed, setFn, startTests, suite, test, updateTask };

package/dist/{tasks-e594cd24.d.ts → tasks-b31a73cb.d.ts}

@@ -9,6 +9,20 @@ type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> =
 } & 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>;
 
+interface FixtureItem {
+    prop: string;
+    value: any;
+    index: number;
+    /**
+     * Indicates whether the fixture is a function
+     */
+    isFn: boolean;
+    /**
+     * The dependencies(fixtures) of current fixture function.
+     */
+    deps?: FixtureItem[];
+}
+
 type RunMode = 'run' | 'skip' | 'only' | 'todo';
 type TaskState = RunMode | 'pass' | 'fail';
 interface TaskBase {
@@ -25,10 +39,18 @@ interface TaskBase {
     retry?: number;
     repeats?: number;
 }
-interface TaskMeta {
+interface TaskPopulated extends TaskBase {
+    suite: Suite;
+    pending?: boolean;
+    result?: TaskResult;
+    fails?: boolean;
+    onFailed?: OnTestFailedHandler[];
+    /**
+     * Store promises (from async expects) to wait for them before finishing the test
+     */
+    promises?: Promise<any>[];
 }
-interface TaskCustom extends TaskBase {
-    type: 'custom';
+interface TaskMeta {
 }
 interface TaskResult {
     state: TaskState;
@@ -57,22 +79,17 @@ interface File extends Suite {
     collectDuration?: number;
     setupDuration?: number;
 }
-interface Test<ExtraContext = {}> extends TaskBase {
+interface Test<ExtraContext = {}> extends TaskPopulated {
     type: 'test';
-    suite: Suite;
-    pending?: boolean;
-    result?: TaskResult;
-    fails?: boolean;
-    context: TestContext & ExtraContext;
-    onFailed?: OnTestFailedHandler[];
-    /**
-     * Store promises (from async expects) to wait for them before finishing the test
-     */
-    promises?: Promise<any>[];
+    context: TaskContext<Test> & ExtraContext & TestContext;
 }
-type Task = Test | Suite | TaskCustom | File;
+interface Custom<ExtraContext = {}> extends TaskPopulated {
+    type: 'custom';
+    context: TaskContext<Custom> & ExtraContext & TestContext;
+}
+type Task = Test | Suite | Custom | File;
 type DoneCallback = (error?: any) => void;
-type TestFunction<ExtraContext = {}> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
+type TestFunction<ExtraContext = {}> = (context: ExtendedContext<Test> & ExtraContext) => Awaitable<any> | void;
 type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
     1: [T[0]];
     2: [T[0], T[1]];
@@ -125,19 +142,31 @@ interface TestOptions {
      */
     repeats?: number;
 }
-type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
+interface ExtendedAPI<ExtraContext> {
     each: TestEachFunction;
     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<{
+        [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<{
         [K in keyof T | keyof ExtraContext]: K extends keyof T ? T[K] : K extends keyof ExtraContext ? ExtraContext[K] : never;
     }>;
 };
+type FixtureType<T> = T extends (context: any, use: (fixture: infer F) => any) => any ? F : T;
+type Fixture<T, K extends keyof T, OnlyFunction, ExtraContext = {}, V = FixtureType<T[K]>, FN = (context: {
+    [P in keyof T | keyof ExtraContext as P extends K ? P extends keyof ExtraContext ? P : never : P]: K extends P ? K extends keyof ExtraContext ? ExtraContext[K] : V : P extends keyof T ? T[P] : never;
+} & TestContext, use: (fixture: V) => Promise<void>) => Promise<void>> = OnlyFunction extends true ? FN : (FN | V);
 type Fixtures<T extends Record<string, any>, ExtraContext = {}> = {
-    [K in keyof T]: T[K] | ((context: {
-        [P in keyof T | keyof ExtraContext as P extends K ? P extends keyof ExtraContext ? P : never : P]: K extends P ? K extends keyof ExtraContext ? ExtraContext[K] : never : P extends keyof T ? T[P] : never;
-    } & TestContext, use: (fixture: T[K]) => Promise<void>) => Promise<void>);
+    [K in keyof T]: Fixture<T, K, false, ExtraContext>;
+} | {
+    [K in keyof T]: Fixture<T, K, true, ExtraContext>;
 };
+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>,
@@ -156,8 +185,20 @@ type HookCleanupCallback = (() => Awaitable<unknown>) | void;
 interface SuiteHooks<ExtraContext = {}> {
     beforeAll: HookListener<[Readonly<Suite | File>], HookCleanupCallback>[];
     afterAll: HookListener<[Readonly<Suite | File>]>[];
-    beforeEach: HookListener<[TestContext & ExtraContext, Readonly<Suite>], HookCleanupCallback>[];
-    afterEach: HookListener<[TestContext & ExtraContext, Readonly<Suite>]>[];
+    beforeEach: HookListener<[ExtendedContext<Test | Custom> & ExtraContext, Readonly<Suite>], HookCleanupCallback>[];
+    afterEach: HookListener<[ExtendedContext<Test | Custom> & ExtraContext, Readonly<Suite>]>[];
+}
+interface TaskCustomOptions extends TestOptions {
+    concurrent?: boolean;
+    sequential?: boolean;
+    skip?: boolean;
+    only?: boolean;
+    todo?: boolean;
+    fails?: boolean;
+    each?: boolean;
+    meta?: Record<string, unknown>;
+    fixtures?: FixtureItem[];
+    handler?: (context: TaskContext<Custom>) => Awaitable<void>;
 }
 interface SuiteCollector<ExtraContext = {}> {
     readonly name: string;
@@ -165,8 +206,8 @@ interface SuiteCollector<ExtraContext = {}> {
     options?: TestOptions;
     type: 'collector';
     test: TestAPI<ExtraContext>;
-    tasks: (Suite | TaskCustom | Test | SuiteCollector<ExtraContext>)[];
-    custom: (name: string) => TaskCustom;
+    tasks: (Suite | Custom<ExtraContext> | Test<ExtraContext> | SuiteCollector<ExtraContext>)[];
+    task: (name: string, options?: TaskCustomOptions) => Custom<ExtraContext>;
     collect: (file?: File) => Promise<Suite>;
     clear: () => void;
     on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
@@ -177,16 +218,12 @@ interface RuntimeContext {
     currentSuite: SuiteCollector | null;
 }
 interface TestContext {
-    /**
-     * Metadata of the current test
-     *
-     * @deprecated Use `task` instead
-     */
-    meta: Readonly<Test>;
+}
+interface TaskContext<Task extends Custom | Test = Custom | Test> {
     /**
      * Metadata of the current test
      */
-    task: Readonly<Test>;
+    task: Readonly<Task>;
     /**
      * Extract hooks on test failed
      */
@@ -196,8 +233,9 @@ interface TestContext {
      */
     skip: () => void;
 }
+type ExtendedContext<T extends Custom | Test> = TaskContext<T> & TestContext;
 type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
 type SequenceHooks = 'stack' | 'list' | 'parallel';
 type SequenceSetupFiles = 'list' | 'parallel';
 
-export { ChainableFunction as C, DoneCallback as D, File as F, HookListener as H, OnTestFailedHandler as O, RunMode as R, Suite as S, Task as T, Test as a, TaskCustom as b, createChainable as c, SuiteAPI as d, TestAPI as e, SuiteCollector as f, SuiteHooks as g, TaskState as h, TaskBase as i, TaskMeta as j, TaskResult as k, TaskResultPack as l, TestFunction as m, TestOptions as n, Fixtures as o, HookCleanupCallback as p, SuiteFactory as q, RuntimeContext as r, TestContext as s, SequenceHooks as t, SequenceSetupFiles as u };
+export { Custom as C, DoneCallback as D, ExtendedContext as E, File as F, HookListener as H, InferFixturesTypes as I, OnTestFailedHandler as O, RunMode as R, Suite as S, Task as T, Test as a, ChainableFunction as b, createChainable as c, SuiteAPI as d, TestAPI as e, SuiteCollector as f, CustomAPI as g, SuiteHooks as h, TaskState as i, TaskBase as j, TaskPopulated as k, TaskMeta as l, TaskResult as m, TaskResultPack as n, TestFunction as o, TestOptions as p, Fixture as q, Fixtures as r, HookCleanupCallback as s, TaskCustomOptions as t, SuiteFactory as u, RuntimeContext as v, TestContext as w, TaskContext as x, SequenceHooks as y, SequenceSetupFiles as z };

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import { t as SequenceHooks, u as SequenceSetupFiles, F as File, a as Test, S as Suite, l as TaskResultPack, s as TestContext } from './tasks-e594cd24.js';
-export { D as DoneCallback, o as Fixtures, p as HookCleanupCallback, H as HookListener, O as OnTestFailedHandler, R as RunMode, r as RuntimeContext, d as SuiteAPI, f as SuiteCollector, q as SuiteFactory, g as SuiteHooks, T as Task, i as TaskBase, b as TaskCustom, j as TaskMeta, k as TaskResult, h as TaskState, e as TestAPI, m as TestFunction, n as TestOptions } from './tasks-e594cd24.js';
+import { y as SequenceHooks, z as SequenceSetupFiles, F as File, k as TaskPopulated, S as Suite, n as TaskResultPack, a as Test, C as Custom, x as TaskContext, E as ExtendedContext } from './tasks-b31a73cb.js';
+export { g as CustomAPI, D as DoneCallback, q as Fixture, r as Fixtures, s as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, R as RunMode, v as RuntimeContext, d as SuiteAPI, f as SuiteCollector, u as SuiteFactory, h as SuiteHooks, T as Task, j as TaskBase, t as TaskCustomOptions, l as TaskMeta, m as TaskResult, i as TaskState, e as TestAPI, w as TestContext, o as TestFunction, p as TestOptions } from './tasks-b31a73cb.js';
 import '@vitest/utils';
 
 /**
@@ -84,28 +84,28 @@ interface VitestRunner {
     /**
      * 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 "onBeforeRunTest" when called.
+     * "onBeforeRunSuite" and "onBeforeRunTask" when called.
      */
     onCancel?(reason: CancelReason): unknown;
     /**
      * Called before running a single test. Doesn't have "result" yet.
      */
-    onBeforeRunTest?(test: Test): unknown;
+    onBeforeRunTask?(test: TaskPopulated): unknown;
     /**
      * Called before actually running the test function. Already has "result" with "state" and "startTime".
      */
-    onBeforeTryTest?(test: Test, options: {
+    onBeforeTryTask?(test: TaskPopulated, options: {
         retry: number;
         repeats: number;
     }): unknown;
     /**
      * Called after result and state are set.
      */
-    onAfterRunTest?(test: Test): unknown;
+    onAfterRunTask?(test: TaskPopulated): unknown;
     /**
      * Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
      */
-    onAfterTryTest?(test: Test, options: {
+    onAfterTryTask?(test: TaskPopulated, options: {
         retry: number;
         repeats: number;
     }): unknown;
@@ -126,7 +126,7 @@ interface VitestRunner {
      * 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.
      */
-    runTest?(test: Test): Promise<void>;
+    runTask?(test: TaskPopulated): 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.
      */
@@ -134,16 +134,20 @@ interface VitestRunner {
     /**
      * Called before running all tests in collected paths.
      */
-    onBeforeRun?(files: File[]): unknown;
+    onBeforeRunFiles?(files: File[]): unknown;
     /**
      * Called right after running all tests in collected paths.
      */
-    onAfterRun?(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.
+     *
+     * This method is called for both "test" and "custom" handlers.
+     *
+     * @see https://vitest.dev/advanced/runner.html#your-task-function
      */
-    extendTestContext?(context: TestContext): TestContext;
+    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.
      */
@@ -154,4 +158,4 @@ interface VitestRunner {
     config: VitestRunnerConfig;
 }
 
-export { CancelReason, File, SequenceHooks, SequenceSetupFiles, Suite, TaskResultPack, Test, TestContext, VitestRunner, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource };
+export { CancelReason, Custom, ExtendedContext, File, SequenceHooks, SequenceSetupFiles, Suite, TaskContext, TaskPopulated, TaskResultPack, Test, VitestRunner, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, T as Task, a as Test, b as TaskCustom } from './tasks-e594cd24.js';
-export { C as ChainableFunction, c as createChainable } from './tasks-e594cd24.js';
+import { S as Suite, T as Task, a as Test, C as Custom } from './tasks-b31a73cb.js';
+export { b as ChainableFunction, c as createChainable } from './tasks-b31a73cb.js';
 import { Arrayable } from '@vitest/utils';
 
 /**
@@ -15,7 +15,7 @@ declare function calculateSuiteHash(parent: Suite): void;
  */
 declare function partitionSuiteChildren(suite: Suite): Task[][];
 
-declare function getTests(suite: Arrayable<Task>): (Test | TaskCustom)[];
+declare function getTests(suite: Arrayable<Task>): (Test | Custom)[];
 declare function getTasks(tasks?: Arrayable<Task>): Task[];
 declare function getSuites(suite: Arrayable<Task>): Suite[];
 declare function hasTests(suite: Arrayable<Suite>): boolean;

package/package.json

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