@vitest/runner 2.0.3 → 2.0.5

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, i as OnTestFinishedHandler, a as Test, C as Custom, S as Suite } from './tasks-WAKtRuk9.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-WAKtRuk9.js';
+import { T as Task, F as File, d as SuiteAPI, e as TestAPI, f as SuiteCollector, g as CustomAPI, B as BeforeAllListener, A as AfterAllListener, h as BeforeEachListener, i as AfterEachListener, j as TaskHook, O as OnTestFailedHandler, k as OnTestFinishedHandler, a as Test, C as Custom, S as Suite, l as SuiteHooks } from './tasks-zB5uPauP.js';
+export { D as DoneCallback, L as ExtendedContext, w as Fixture, v as FixtureFn, u as FixtureOptions, x as Fixtures, y as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, R as RunMode, G as RuntimeContext, M as SequenceHooks, N as SequenceSetupFiles, E as SuiteFactory, n as TaskBase, K as TaskContext, z as TaskCustomOptions, p as TaskMeta, o as TaskPopulated, q as TaskResult, r as TaskResultPack, m as TaskState, J as TestContext, s as TestFunction, t as TestOptions, U as Use } from './tasks-zB5uPauP.js';
 import { Awaitable } from '@vitest/utils';
 export { processError } from '@vitest/utils/error';
 import '@vitest/utils/diff';
@@ -10,19 +10,244 @@ declare function updateTask(task: Task, runner: VitestRunner): void;
 declare function startTests(paths: string[], runner: VitestRunner): Promise<File[]>;
 declare function publicCollect(paths: string[], runner: VitestRunner): Promise<File[]>;
 
+/**
+ * Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
+ * Suites can contain both tests and other suites, enabling complex test structures.
+ *
+ * @param {string} name - The name of the suite, used for identification and reporting.
+ * @param {Function} fn - A function that defines the tests and suites within this suite.
+ * @example
+ * ```ts
+ * // Define a suite with two tests
+ * suite('Math operations', () => {
+ *   test('should add two numbers', () => {
+ *     expect(add(1, 2)).toBe(3);
+ *   });
+ *
+ *   test('should subtract two numbers', () => {
+ *     expect(subtract(5, 2)).toBe(3);
+ *   });
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Define nested suites
+ * suite('String operations', () => {
+ *   suite('Trimming', () => {
+ *     test('should trim whitespace from start and end', () => {
+ *       expect('  hello  '.trim()).toBe('hello');
+ *     });
+ *   });
+ *
+ *   suite('Concatenation', () => {
+ *     test('should concatenate two strings', () => {
+ *       expect('hello' + ' ' + 'world').toBe('hello world');
+ *     });
+ *   });
+ * });
+ * ```
+ */
 declare const suite: SuiteAPI;
+/**
+ * Defines a test case with a given name and test function. The test function can optionally be configured with test options.
+ *
+ * @param {string | Function} name - The name of the test or a function that will be used as a test name.
+ * @param {TestOptions | TestFunction} [optionsOrFn] - Optional. The test options or the test function if no explicit name is provided.
+ * @param {number | TestOptions | TestFunction} [optionsOrTest] - Optional. The test function or options, depending on the previous parameters.
+ * @throws {Error} If called inside another test function.
+ * @example
+ * ```ts
+ * // Define a simple test
+ * test('should add two numbers', () => {
+ *   expect(add(1, 2)).toBe(3);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Define a test with options
+ * test('should subtract two numbers', { retry: 3 }, () => {
+ *   expect(subtract(5, 2)).toBe(3);
+ * });
+ * ```
+ */
 declare const test: TestAPI;
+/**
+ * Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
+ * Suites can contain both tests and other suites, enabling complex test structures.
+ *
+ * @param {string} name - The name of the suite, used for identification and reporting.
+ * @param {Function} fn - A function that defines the tests and suites within this suite.
+ * @example
+ * ```ts
+ * // Define a suite with two tests
+ * describe('Math operations', () => {
+ *   test('should add two numbers', () => {
+ *     expect(add(1, 2)).toBe(3);
+ *   });
+ *
+ *   test('should subtract two numbers', () => {
+ *     expect(subtract(5, 2)).toBe(3);
+ *   });
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Define nested suites
+ * describe('String operations', () => {
+ *   describe('Trimming', () => {
+ *     test('should trim whitespace from start and end', () => {
+ *       expect('  hello  '.trim()).toBe('hello');
+ *     });
+ *   });
+ *
+ *   describe('Concatenation', () => {
+ *     test('should concatenate two strings', () => {
+ *       expect('hello' + ' ' + 'world').toBe('hello world');
+ *     });
+ *   });
+ * });
+ * ```
+ */
 declare const describe: SuiteAPI;
+/**
+ * Defines a test case with a given name and test function. The test function can optionally be configured with test options.
+ *
+ * @param {string | Function} name - The name of the test or a function that will be used as a test name.
+ * @param {TestOptions | TestFunction} [optionsOrFn] - Optional. The test options or the test function if no explicit name is provided.
+ * @param {number | TestOptions | TestFunction} [optionsOrTest] - Optional. The test function or options, depending on the previous parameters.
+ * @throws {Error} If called inside another test function.
+ * @example
+ * ```ts
+ * // Define a simple test
+ * it('adds two numbers', () => {
+ *   expect(add(1, 2)).toBe(3);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Define a test with options
+ * it('subtracts two numbers', { retry: 3 }, () => {
+ *   expect(subtract(5, 2)).toBe(3);
+ * });
+ * ```
+ */
 declare const it: TestAPI;
-declare function getCurrentSuite<ExtraContext = {}>(): SuiteCollector<ExtraContext>;
+declare function getCurrentSuite<ExtraContext = object>(): 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;
-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;
+/**
+ * Registers a callback function to be executed once before all tests within the current suite.
+ * This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
+ *
+ * **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed before all tests.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using beforeAll to set up a database connection
+ * beforeAll(async () => {
+ *   await database.connect();
+ * });
+ * ```
+ */
+declare function beforeAll(fn: BeforeAllListener, timeout?: number): void;
+/**
+ * Registers a callback function to be executed once after all tests within the current suite have completed.
+ * This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
+ *
+ * **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed after all tests.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using afterAll to close a database connection
+ * afterAll(async () => {
+ *   await database.disconnect();
+ * });
+ * ```
+ */
+declare function afterAll(fn: AfterAllListener, timeout?: number): void;
+/**
+ * Registers a callback function to be executed before each test within the current suite.
+ * This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
+ *
+ * **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using beforeEach to reset a database state
+ * beforeEach(async () => {
+ *   await database.reset();
+ * });
+ * ```
+ */
+declare function beforeEach<ExtraContext = object>(fn: BeforeEachListener<ExtraContext>, timeout?: number): void;
+/**
+ * Registers a callback function to be executed after each test within the current suite has completed.
+ * This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
+ *
+ * **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using afterEach to delete temporary files created during a test
+ * afterEach(async () => {
+ *   await fileSystem.deleteTempFiles();
+ * });
+ * ```
+ */
+declare function afterEach<ExtraContext = object>(fn: AfterEachListener<ExtraContext>, timeout?: number): void;
+/**
+ * Registers a callback function to be executed when a test fails within the current suite.
+ * This function allows for custom actions to be performed in response to test failures, such as logging, cleanup, or additional diagnostics.
+ *
+ * **Note:** The `onTestFailed` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed upon a test failure. The function receives the test result (including errors).
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @throws {Error} Throws an error if the function is not called within a test.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using onTestFailed to log failure details
+ * onTestFailed(({ errors }) => {
+ *   console.log(`Test failed: ${test.name}`, errors);
+ * });
+ * ```
+ */
+declare const onTestFailed: TaskHook<OnTestFailedHandler>;
+/**
+ * Registers a callback function to be executed when the current test finishes, regardless of the outcome (pass or fail).
+ * This function is ideal for performing actions that should occur after every test execution, such as cleanup, logging, or resetting shared resources.
+ *
+ * This hook is useful if you have access to a resource in the test itself and you want to clean it up after the test finishes. It is a more compact way to clean up resources than using the combination of `beforeEach` and `afterEach`.
+ *
+ * **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+ *
+ * @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.
+ * @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+ * @throws {Error} Throws an error if the function is not called within a test.
+ * @returns {void}
+ * @example
+ * ```ts
+ * // Example of using onTestFinished for cleanup
+ * const db = await connectToDatabase();
+ * onTestFinished(async () => {
+ *   await db.disconnect();
+ * });
+ * ```
+ */
+declare const onTestFinished: TaskHook<OnTestFinishedHandler>;
 
 declare function setFn(key: Test | Custom, fn: () => Awaitable<void>): void;
 declare function getFn<Task = Test | Custom>(key: Task): () => Awaitable<void>;
@@ -31,4 +256,4 @@ declare function getHooks(key: Suite): SuiteHooks;
 
 declare function getCurrentTest<T extends Test | Custom | undefined>(): T;
 
-export { Custom, CustomAPI, File, OnTestFailedHandler, OnTestFinishedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };
+export { AfterAllListener, AfterEachListener, BeforeAllListener, BeforeEachListener, Custom, CustomAPI, File, OnTestFailedHandler, OnTestFinishedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, TaskHook, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };

package/dist/index.js

@@ -553,13 +553,21 @@ function createSuite() {
       cases.forEach((i, idx) => {
         const items = Array.isArray(i) ? i : [i];
         if (fnFirst) {
-          arrayOnlyCases ? suite2(
-            formatTitle(_name, items, idx),
-            () => handler(...items),
-            options
-          ) : suite2(formatTitle(_name, items, idx), () => handler(i), options);
+          if (arrayOnlyCases) {
+            suite2(
+              formatTitle(_name, items, idx),
+              () => handler(...items),
+              options
+            );
+          } else {
+            suite2(formatTitle(_name, items, idx), () => handler(i), options);
+          }
         } else {
-          arrayOnlyCases ? suite2(formatTitle(_name, items, idx), options, () => handler(...items)) : suite2(formatTitle(_name, items, idx), options, () => handler(i));
+          if (arrayOnlyCases) {
+            suite2(formatTitle(_name, items, idx), options, () => handler(...items));
+          } else {
+            suite2(formatTitle(_name, items, idx), options, () => handler(i));
+          }
         }
       });
       this.setContext("each", void 0);
@@ -588,13 +596,21 @@ function createTaskCollector(fn, context) {
       cases.forEach((i, idx) => {
         const items = Array.isArray(i) ? i : [i];
         if (fnFirst) {
-          arrayOnlyCases ? test2(
-            formatTitle(_name, items, idx),
-            () => handler(...items),
-            options
-          ) : test2(formatTitle(_name, items, idx), () => handler(i), options);
+          if (arrayOnlyCases) {
+            test2(
+              formatTitle(_name, items, idx),
+              () => handler(...items),
+              options
+            );
+          } else {
+            test2(formatTitle(_name, items, idx), () => handler(i), options);
+          }
         } else {
-          arrayOnlyCases ? test2(formatTitle(_name, items, idx), options, () => handler(...items)) : test2(formatTitle(_name, items, idx), options, () => handler(i));
+          if (arrayOnlyCases) {
+            test2(formatTitle(_name, items, idx), options, () => handler(...items));
+          } else {
+            test2(formatTitle(_name, items, idx), options, () => handler(i));
+          }
         }
       });
       this.setContext("each", void 0);
@@ -711,8 +727,7 @@ function findTestFileStackTrace(error, each) {
   }
 }
 
-async function runSetupFiles(config, runner) {
-  const files = toArray(config.setupFiles);
+async function runSetupFiles(config, files, runner) {
   if (config.sequence.setupFiles === "parallel") {
     await Promise.all(
       files.map(async (fsPath) => {
@@ -736,10 +751,16 @@ async function collectTests(paths, runner) {
     (_a = runner.onCollectStart) == null ? void 0 : _a.call(runner, file);
     clearCollectorContext(filepath, runner);
     try {
-      const setupStart = now$1();
-      await runSetupFiles(config, runner);
+      const setupFiles = toArray(config.setupFiles);
+      if (setupFiles.length) {
+        const setupStart = now$1();
+        await runSetupFiles(config, setupFiles, runner);
+        const setupEnd = now$1();
+        file.setupDuration = setupEnd - setupStart;
+      } else {
+        file.setupDuration = 0;
+      }
       const collectStart = now$1();
-      file.setupDuration = collectStart - setupStart;
       await runner.importFile(filepath, "collect");
       const defaultTasks = await getDefaultSuite().collect(file);
       const fileHooks = createSuiteHooks();
@@ -767,6 +788,12 @@ async function collectTests(paths, runner) {
       };
     }
     calculateSuiteHash(file);
+    file.tasks.forEach((task) => {
+      var _a2;
+      if (((_a2 = task.suite) == null ? void 0 : _a2.id) === "") {
+        delete task.suite;
+      }
+    });
     const hasOnlyTasks = someTasksAreOnly(file);
     interpretTaskModes(
       file,
@@ -775,12 +802,6 @@ async function collectTests(paths, runner) {
       false,
       config.allowOnly
     );
-    file.tasks.forEach((task) => {
-      var _a2;
-      if (((_a2 = task.suite) == null ? void 0 : _a2.id) === "") {
-        delete task.suite;
-      }
-    });
     files.push(file);
   }
   return files;
@@ -840,7 +861,7 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
   const hooks = getSuiteHooks(suite, name, sequence);
   if (sequence === "parallel") {
     callbacks.push(
-      ...await Promise.all(hooks.map((fn) => fn(...args)))
+      ...await Promise.all(hooks.map((hook) => hook(...args)))
     );
   } else {
     for (const hook of hooks) {
@@ -1200,25 +1221,29 @@ function afterEach(fn, timeout) {
 }
 const onTestFailed = createTestHook(
   "onTestFailed",
-  (test, handler) => {
+  (test, handler, timeout) => {
     test.onFailed || (test.onFailed = []);
-    test.onFailed.push(handler);
+    test.onFailed.push(
+      withTimeout(handler, timeout ?? getDefaultHookTimeout(), true)
+    );
   }
 );
 const onTestFinished = createTestHook(
   "onTestFinished",
-  (test, handler) => {
+  (test, handler, timeout) => {
     test.onFinished || (test.onFinished = []);
-    test.onFinished.push(handler);
+    test.onFinished.push(
+      withTimeout(handler, timeout ?? getDefaultHookTimeout(), true)
+    );
   }
 );
 function createTestHook(name, handler) {
-  return (fn) => {
+  return (fn, timeout) => {
     const current = getCurrentTest();
     if (!current) {
       throw new Error(`Hook ${name}() can only be called inside a test`);
     }
-    return handler(current, fn);
+    return handler(current, fn, timeout);
   };
 }
 

package/dist/{tasks-WAKtRuk9.d.ts → tasks-zB5uPauP.d.ts}

@@ -1,6 +1,6 @@
 import { ErrorWithDiff, Awaitable } from '@vitest/utils';
 
-type ChainableFunction<T extends string, F extends (...args: any) => any, C = {}> = F & {
+type ChainableFunction<T extends string, F extends (...args: any) => any, C = object> = F & {
     [x in T]: ChainableFunction<T, F, C>;
 } & {
     fn: (this: Record<T, any>, ...args: Parameters<F>) => ReturnType<F>;
@@ -85,17 +85,17 @@ interface File extends Suite {
      */
     local?: boolean;
 }
-interface Test<ExtraContext = {}> extends TaskPopulated {
+interface Test<ExtraContext = object> extends TaskPopulated {
     type: 'test';
     context: TaskContext<Test> & ExtraContext & TestContext;
 }
-interface Custom<ExtraContext = {}> extends TaskPopulated {
+interface Custom<ExtraContext = object> extends TaskPopulated {
     type: 'custom';
     context: TaskContext<Custom> & ExtraContext & TestContext;
 }
 type Task = Test | Suite | Custom | File;
 type DoneCallback = (error?: any) => void;
-type TestFunction<ExtraContext = {}> = (context: ExtendedContext<Test> & ExtraContext) => Awaitable<any> | void;
+type TestFunction<ExtraContext = object> = (context: ExtendedContext<Test> & ExtraContext) => Awaitable<any> | void;
 type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
     1: [T[0]];
     2: [T[0], T[1]];
@@ -131,7 +131,7 @@ interface TestForFunction<ExtraContext> {
     <T>(cases: ReadonlyArray<T>): TestForFunctionReturn<T, ExtendedContext<Test> & ExtraContext>;
     (strings: TemplateStringsArray, ...values: any[]): TestForFunctionReturn<any, ExtendedContext<Test> & ExtraContext>;
 }
-interface TestCollectorCallable<C = {}> {
+interface TestCollectorCallable<C = object> {
     /**
      * @deprecated Use options as the second argument instead
      */
@@ -139,7 +139,7 @@ interface TestCollectorCallable<C = {}> {
     <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>, {
+type ChainableTestAPI<ExtraContext = object> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'fails', TestCollectorCallable<ExtraContext>, {
     each: TestEachFunction;
     for: TestForFunction<ExtraContext>;
 }>;
@@ -193,13 +193,13 @@ interface ExtendedAPI<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<{
+type CustomAPI<ExtraContext = object> = ChainableTestAPI<ExtraContext> & ExtendedAPI<ExtraContext> & {
+    extend: <T extends Record<string, any> = object>(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<{
+type TestAPI<ExtraContext = object> = ChainableTestAPI<ExtraContext> & ExtendedAPI<ExtraContext> & {
+    extend: <T extends Record<string, any> = object>(fixtures: Fixtures<T, ExtraContext>) => TestAPI<{
         [K in keyof T | keyof ExtraContext]: K extends keyof T ? T[K] : K extends keyof ExtraContext ? ExtraContext[K] : never;
     }>;
 };
@@ -211,12 +211,12 @@ interface FixtureOptions {
 }
 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 = {}> = {
+type Fixture<T, K extends keyof T, ExtraContext = object> = ((...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 = object> = {
     [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;
-interface SuiteCollectorCallable<ExtraContext = {}> {
+interface SuiteCollectorCallable<ExtraContext = object> {
     /**
      * @deprecated Use options as the second argument instead
      */
@@ -224,26 +224,35 @@ interface SuiteCollectorCallable<ExtraContext = {}> {
     <OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, fn?: SuiteFactory<OverrideExtraContext>, options?: number | TestOptions): SuiteCollector<OverrideExtraContext>;
     <OverrideExtraContext extends ExtraContext = ExtraContext>(name: string | Function, options: TestOptions, fn?: SuiteFactory<OverrideExtraContext>): SuiteCollector<OverrideExtraContext>;
 }
-type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'shuffle', SuiteCollectorCallable<ExtraContext>, {
+type ChainableSuiteAPI<ExtraContext = object> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'shuffle', SuiteCollectorCallable<ExtraContext>, {
     each: TestEachFunction;
 }>;
-type SuiteAPI<ExtraContext = {}> = ChainableSuiteAPI<ExtraContext> & {
+type SuiteAPI<ExtraContext = object> = ChainableSuiteAPI<ExtraContext> & {
     skipIf: (condition: any) => ChainableSuiteAPI<ExtraContext>;
     runIf: (condition: any) => ChainableSuiteAPI<ExtraContext>;
 };
+/**
+ * @deprecated
+ */
 type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return>;
 type HookCleanupCallback = (() => Awaitable<unknown>) | void;
-interface SuiteHooks<ExtraContext = {}> {
-    beforeAll: HookListener<[Readonly<Suite | File>], HookCleanupCallback>[];
-    afterAll: HookListener<[Readonly<Suite | File>]>[];
-    beforeEach: HookListener<[
-        ExtendedContext<Test | Custom> & ExtraContext,
-        Readonly<Suite>
-    ], HookCleanupCallback>[];
-    afterEach: HookListener<[
-        ExtendedContext<Test | Custom> & ExtraContext,
-        Readonly<Suite>
-    ]>[];
+interface BeforeAllListener {
+    (suite: Readonly<Suite | File>): Awaitable<HookCleanupCallback>;
+}
+interface AfterAllListener {
+    (suite: Readonly<Suite | File>): Awaitable<void>;
+}
+interface BeforeEachListener<ExtraContext = object> {
+    (context: ExtendedContext<Test | Custom> & ExtraContext, suite: Readonly<Suite>): Awaitable<HookCleanupCallback>;
+}
+interface AfterEachListener<ExtraContext = object> {
+    (context: ExtendedContext<Test | Custom> & ExtraContext, suite: Readonly<Suite>): Awaitable<void>;
+}
+interface SuiteHooks<ExtraContext = object> {
+    beforeAll: BeforeAllListener[];
+    afterAll: AfterAllListener[];
+    beforeEach: BeforeEachListener<ExtraContext>[];
+    afterEach: AfterEachListener<ExtraContext>[];
 }
 interface TaskCustomOptions extends TestOptions {
     concurrent?: boolean;
@@ -257,7 +266,7 @@ interface TaskCustomOptions extends TestOptions {
     fixtures?: FixtureItem[];
     handler?: (context: TaskContext<Custom>) => Awaitable<void>;
 }
-interface SuiteCollector<ExtraContext = {}> {
+interface SuiteCollector<ExtraContext = object> {
     readonly name: string;
     readonly mode: RunMode;
     options?: TestOptions;
@@ -269,7 +278,7 @@ interface SuiteCollector<ExtraContext = {}> {
     clear: () => void;
     on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
 }
-type SuiteFactory<ExtraContext = {}> = (test: TestAPI<ExtraContext>) => Awaitable<void>;
+type SuiteFactory<ExtraContext = object> = (test: TestAPI<ExtraContext>) => Awaitable<void>;
 interface RuntimeContext {
     tasks: (SuiteCollector | Test)[];
     currentSuite: SuiteCollector | null;
@@ -297,7 +306,10 @@ 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>;
+interface TaskHook<HookListener> {
+    (fn: HookListener, timeout?: number): void;
+}
 type SequenceHooks = 'stack' | 'list' | 'parallel';
 type SequenceSetupFiles = 'list' | 'parallel';
 
-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 };
+export { type AfterAllListener as A, type BeforeAllListener as B, type Custom as C, type DoneCallback as D, type SuiteFactory as E, type File as F, type RuntimeContext as G, type HookListener as H, type InferFixturesTypes as I, type TestContext as J, type TaskContext as K, type ExtendedContext as L, type SequenceHooks as M, type SequenceSetupFiles as N, 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 BeforeEachListener as h, type AfterEachListener as i, type TaskHook as j, type OnTestFinishedHandler as k, type SuiteHooks as l, type TaskState as m, type TaskBase as n, type TaskPopulated as o, type TaskMeta as p, type TaskResult as q, type TaskResultPack as r, type TestFunction as s, type TestOptions as t, type FixtureOptions as u, type FixtureFn as v, type Fixture as w, type Fixtures as x, type HookCleanupCallback as y, type TaskCustomOptions as z };

package/dist/types.d.ts

@@ -1,12 +1,12 @@
-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-WAKtRuk9.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-WAKtRuk9.js';
+import { M as SequenceHooks, N as SequenceSetupFiles, F as File, T as Task, S as Suite, r as TaskResultPack, a as Test, C as Custom, K as TaskContext, L as ExtendedContext } from './tasks-zB5uPauP.js';
+export { A as AfterAllListener, i as AfterEachListener, B as BeforeAllListener, h as BeforeEachListener, g as CustomAPI, D as DoneCallback, w as Fixture, v as FixtureFn, u as FixtureOptions, x as Fixtures, y as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, k as OnTestFinishedHandler, R as RunMode, G as RuntimeContext, d as SuiteAPI, f as SuiteCollector, E as SuiteFactory, l as SuiteHooks, n as TaskBase, z as TaskCustomOptions, j as TaskHook, p as TaskMeta, o as TaskPopulated, q as TaskResult, m as TaskState, e as TestAPI, J as TestContext, s as TestFunction, t as TestOptions, U as Use } from './tasks-zB5uPauP.js';
 import { DiffOptions } from '@vitest/utils/diff';
 import '@vitest/utils';
 
 interface VitestRunnerConfig {
     root: string;
-    setupFiles: string[] | string;
-    name: string;
+    setupFiles: string[];
+    name?: string;
     passWithNoTests: boolean;
     testNamePattern?: RegExp;
     allowOnly?: boolean;

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-WAKtRuk9.js';
-export { b as ChainableFunction, c as createChainable } from './tasks-WAKtRuk9.js';
+import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-zB5uPauP.js';
+export { b as ChainableFunction, c as createChainable } from './tasks-zB5uPauP.js';
 import { Arrayable } from '@vitest/utils';
 
 /**
@@ -9,7 +9,7 @@ declare function interpretTaskModes(suite: Suite, namePattern?: string | RegExp,
 declare function someTasksAreOnly(suite: Suite): boolean;
 declare function generateHash(str: string): string;
 declare function calculateSuiteHash(parent: Suite): void;
-declare function createFileTask(filepath: string, root: string, projectName: string, pool?: string): File;
+declare function createFileTask(filepath: string, root: string, projectName: string | undefined, pool?: string): File;
 
 /**
  * Partition in tasks groups by consecutive concurrent

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "pathe": "^1.1.2",
-    "@vitest/utils": "2.0.3"
+    "@vitest/utils": "2.0.5"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",