@vitest/runner 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/chunk-tasks.js

@@ -1,4 +1,5 @@
 import { processError } from '@vitest/utils/error';
+import { relative } from 'pathe';
 import { toArray } from '@vitest/utils';
 
 function partitionSuiteChildren(suite) {
@@ -12,8 +13,9 @@ function partitionSuiteChildren(suite) {
       tasksGroup = [c];
     }
   }
-  if (tasksGroup.length > 0)
+  if (tasksGroup.length > 0) {
     tasksGroups.push(tasksGroup);
+  }
   return tasksGroups;
 }
 
@@ -35,39 +37,50 @@ function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnl
       }
     }
     if (t.type === "test") {
-      if (namePattern && !getTaskFullName(t).match(namePattern))
+      if (namePattern && !getTaskFullName(t).match(namePattern)) {
         t.mode = "skip";
+      }
     } else if (t.type === "suite") {
-      if (t.mode === "skip")
+      if (t.mode === "skip") {
         skipAllTasks(t);
-      else
+      } else {
         interpretTaskModes(t, namePattern, onlyMode, includeTask, allowOnly);
+      }
     }
   });
   if (suite.mode === "run") {
-    if (suite.tasks.length && suite.tasks.every((i) => i.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));
+  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")
+      if (t.type === "suite") {
         skipAllTasks(t);
+      }
     }
   });
 }
 function checkAllowOnly(task, allowOnly) {
-  if (allowOnly)
+  if (allowOnly) {
     return;
-  const error = processError(new Error("[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error"));
+  }
+  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]
@@ -75,8 +88,9 @@ function checkAllowOnly(task, allowOnly) {
 }
 function generateHash(str) {
   let hash = 0;
-  if (str.length === 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;
@@ -87,10 +101,27 @@ function generateHash(str) {
 function calculateSuiteHash(parent) {
   parent.tasks.forEach((t, idx) => {
     t.id = `${parent.id}_${idx}`;
-    if (t.type === "suite")
+    if (t.type === "suite") {
       calculateSuiteHash(t);
+    }
   });
 }
+function createFileTask(filepath, root, projectName) {
+  const path = relative(root, filepath);
+  const file = {
+    id: generateHash(`${path}${projectName || ""}`),
+    name: path,
+    type: "suite",
+    mode: "run",
+    filepath,
+    tasks: [],
+    meta: /* @__PURE__ */ Object.create(null),
+    projectName,
+    file: void 0
+  };
+  file.file = file;
+  return file;
+}
 
 function createChainable(keys, fn) {
   function create(context) {
@@ -134,8 +165,9 @@ function getTests(suite) {
           tests.push(task);
         } else {
           const taskTests = getTests(task);
-          for (const test of taskTests)
+          for (const test of taskTests) {
             tests.push(test);
+          }
         }
       }
     }
@@ -143,31 +175,41 @@ function getTests(suite) {
   return tests;
 }
 function getTasks(tasks = []) {
-  return toArray(tasks).flatMap((s) => isAtomTest(s) ? [s] : [s, ...getTasks(s.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)] : []);
+  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)));
+  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);
-  });
+  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 = current.suite;
-    if (current == null ? void 0 : current.name)
+    if (current == null ? void 0 : current.name) {
       names.unshift(current.name);
+    }
   }
-  if (current !== task.file)
+  if (current !== task.file) {
     names.unshift(task.file.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 };
+export { createFileTask as a, isAtomTest as b, calculateSuiteHash as c, getTests as d, getTasks as e, getSuites as f, generateHash as g, hasTests as h, interpretTaskModes as i, hasFailed as j, getNames as k, createChainable as l, 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, i as OnTestFinishedHandler, a as Test, C as Custom, S as Suite } from './tasks-Ck0GpLiZ.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-Ck0GpLiZ.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-BP89OzIP.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-BP89OzIP.js';
 import { Awaitable } from '@vitest/utils';
 export { processError } from '@vitest/utils/error';
 import '@vitest/utils/diff';
@@ -23,8 +23,8 @@ declare function afterEach<ExtraContext = {}>(fn: SuiteHooks<ExtraContext>['afte
 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>);
+declare function setFn(key: Test | Custom, fn: () => Awaitable<void>): void;
+declare function getFn<Task = Test | Custom>(key: Task): () => Awaitable<void>;
 declare function setHooks(key: Suite, hooks: SuiteHooks): void;
 declare function getHooks(key: Suite): SuiteHooks;
 

package/dist/index.js

@@ -1,10 +1,10 @@
 import limit from 'p-limit';
-import { getSafeTimers, isObject, createDefer, format, objDisplay, objectAttr, toArray, shuffle } from '@vitest/utils';
+import { getSafeTimers, isObject, createDefer, isNegativeNaN, format, objDisplay, objectAttr, toArray, shuffle } from '@vitest/utils';
 import { processError } from '@vitest/utils/error';
 export { processError } from '@vitest/utils/error';
-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';
+import { l as createChainable, a as createFileTask, c as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, p as partitionSuiteChildren, h as hasTests, j as hasFailed } from './chunk-tasks.js';
 import { parseSingleStack } from '@vitest/utils/source-map';
+import 'pathe';
 
 const fnMap = /* @__PURE__ */ new WeakMap();
 const fixtureMap = /* @__PURE__ */ new WeakMap();
@@ -53,18 +53,22 @@ async function runWithSuite(suite, fn) {
   collectorContext.currentSuite = prev;
 }
 function withTimeout(fn, timeout, isHook = false) {
-  if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY)
+  if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {
     return fn;
+  }
   const { setTimeout, clearTimeout } = getSafeTimers();
   return (...args) => {
-    return Promise.race([fn(...args), new Promise((resolve, reject) => {
-      var _a;
-      const timer = setTimeout(() => {
-        clearTimeout(timer);
-        reject(new Error(makeTimeoutMsg(isHook, timeout)));
-      }, timeout);
-      (_a = timer.unref) == null ? void 0 : _a.call(timer);
-    })]);
+    return Promise.race([
+      fn(...args),
+      new Promise((resolve, reject) => {
+        var _a;
+        const timer = setTimeout(() => {
+          clearTimeout(timer);
+          reject(new Error(makeTimeoutMsg(isHook, timeout)));
+        }, timeout);
+        (_a = timer.unref) == null ? void 0 : _a.call(timer);
+      })
+    ]);
   };
 }
 function createTestContext(test, runner) {
@@ -94,25 +98,31 @@ If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as t
 
 function mergeContextFixtures(fixtures, context = {}) {
   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];
+  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;
     }
-    fixtureItem.prop = prop;
-    fixtureItem.isFn = typeof fixtureItem.value === "function";
-    return fixtureItem;
-  });
-  if (Array.isArray(context.fixtures))
+  );
+  if (Array.isArray(context.fixtures)) {
     context.fixtures = context.fixtures.concat(fixtureArray);
-  else
+  } else {
     context.fixtures = fixtureArray;
+  }
   fixtureArray.forEach((fixture) => {
     if (fixture.isFn) {
       const usedProps = getUsedProps(fixture.value);
-      if (usedProps.length)
-        fixture.deps = context.fixtures.filter(({ prop }) => prop !== fixture.prop && usedProps.includes(prop));
+      if (usedProps.length) {
+        fixture.deps = context.fixtures.filter(
+          ({ prop }) => prop !== fixture.prop && usedProps.includes(prop)
+        );
+      }
     }
   });
   return context;
@@ -121,36 +131,46 @@ const fixtureValueMaps = /* @__PURE__ */ new Map();
 const cleanupFnArrayMap = /* @__PURE__ */ new Map();
 async function callFixtureCleanup(context) {
   const cleanupFnArray = cleanupFnArrayMap.get(context) ?? [];
-  for (const cleanup of cleanupFnArray.reverse())
+  for (const cleanup of cleanupFnArray.reverse()) {
     await cleanup();
+  }
   cleanupFnArrayMap.delete(context);
 }
 function withFixtures(fn, testContext) {
   return (hookContext) => {
     const context = hookContext || testContext;
-    if (!context)
+    if (!context) {
       return fn({});
+    }
     const fixtures = getFixture(context);
-    if (!(fixtures == null ? void 0 : fixtures.length))
+    if (!(fixtures == null ? void 0 : fixtures.length)) {
       return fn(context);
+    }
     const usedProps = getUsedProps(fn);
     const hasAutoFixture = fixtures.some(({ auto }) => auto);
-    if (!usedProps.length && !hasAutoFixture)
+    if (!usedProps.length && !hasAutoFixture) {
       return fn(context);
-    if (!fixtureValueMaps.get(context))
+    }
+    if (!fixtureValueMaps.get(context)) {
       fixtureValueMaps.set(context, /* @__PURE__ */ new Map());
+    }
     const fixtureValueMap = fixtureValueMaps.get(context);
-    if (!cleanupFnArrayMap.has(context))
+    if (!cleanupFnArrayMap.has(context)) {
       cleanupFnArrayMap.set(context, []);
+    }
     const cleanupFnArray = cleanupFnArrayMap.get(context);
-    const usedFixtures = fixtures.filter(({ prop, auto }) => auto || usedProps.includes(prop));
+    const usedFixtures = fixtures.filter(
+      ({ prop, auto }) => auto || usedProps.includes(prop)
+    );
     const pendingFixtures = resolveDeps(usedFixtures);
-    if (!pendingFixtures.length)
+    if (!pendingFixtures.length) {
       return fn(context);
+    }
     async function resolveFixtures() {
       for (const fixture of pendingFixtures) {
-        if (fixtureValueMap.has(fixture))
+        if (fixtureValueMap.has(fixture)) {
           continue;
+        }
         const resolvedValue = fixture.isFn ? await resolveFixtureFunction(fixture.value, context, cleanupFnArray) : fixture.value;
         context[fixture.prop] = resolvedValue;
         fixtureValueMap.set(fixture, resolvedValue);
@@ -185,14 +205,18 @@ async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
 }
 function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtures = []) {
   fixtures.forEach((fixture) => {
-    if (pendingFixtures.includes(fixture))
+    if (pendingFixtures.includes(fixture)) {
       return;
+    }
     if (!fixture.isFn || !fixture.deps) {
       pendingFixtures.push(fixture);
       return;
     }
-    if (depSet.has(fixture))
-      throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d) => d.prop).join(" <- ")}`);
+    if (depSet.has(fixture)) {
+      throw new Error(
+        `Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d) => d.prop).join(" <- ")}`
+      );
+    }
     depSet.add(fixture);
     resolveDeps(fixture.deps, depSet, pendingFixtures);
     pendingFixtures.push(fixture);
@@ -202,21 +226,35 @@ function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtur
 }
 function getUsedProps(fn) {
   const match = fn.toString().match(/[^(]*\(([^)]*)/);
-  if (!match)
+  if (!match) {
     return [];
+  }
   const args = splitByComma(match[1]);
-  if (!args.length)
+  if (!args.length) {
     return [];
-  const first = args[0];
-  if (!(first.startsWith("{") && first.endsWith("}")))
-    throw new Error(`The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`);
+  }
+  let first = args[0];
+  if ("__VITEST_FIXTURE_INDEX__" in fn) {
+    first = args[fn.__VITEST_FIXTURE_INDEX__];
+    if (!first) {
+      return [];
+    }
+  }
+  if (!(first.startsWith("{") && first.endsWith("}"))) {
+    throw new Error(
+      `The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`
+    );
+  }
   const _first = first.slice(1, -1).replace(/\s/g, "");
   const props = splitByComma(_first).map((prop) => {
-    return prop.replace(/\:.*|\=.*/g, "");
+    return prop.replace(/:.*|=.*/g, "");
   });
   const last = props.at(-1);
-  if (last && last.startsWith("..."))
-    throw new Error(`Rest parameters are not supported in fixtures, received "${last}".`);
+  if (last && last.startsWith("...")) {
+    throw new Error(
+      `Rest parameters are not supported in fixtures, received "${last}".`
+    );
+  }
   return props;
 }
 function splitByComma(s) {
@@ -230,14 +268,16 @@ function splitByComma(s) {
       stack.pop();
     } else if (!stack.length && s[i] === ",") {
       const token = s.substring(start, i).trim();
-      if (token)
+      if (token) {
         result.push(token);
+      }
       start = i + 1;
     }
   }
   const lastToken = s.substring(start).trim();
-  if (lastToken)
+  if (lastToken) {
     result.push(lastToken);
+  }
   return result;
 }
 
@@ -250,13 +290,19 @@ function getCurrentTest() {
 }
 
 const suite = createSuite();
-const test = createTest(
-  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), optionsOrFn, optionsOrTest);
+const test = createTest(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),
+    optionsOrFn,
+    optionsOrTest
+  );
+});
 const describe = suite;
 const it = test;
 let runner;
@@ -278,8 +324,9 @@ function createDefaultSuite(runner2) {
   });
 }
 function clearCollectorContext(filepath, currentRunner) {
-  if (!defaultSuite)
+  if (!defaultSuite) {
     defaultSuite = createDefaultSuite(currentRunner);
+  }
   runner = currentRunner;
   currentTestFilepath = filepath;
   collectorContext.tasks.length = 0;
@@ -302,8 +349,11 @@ function parseArguments(optionsOrFn, optionsOrTest) {
   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.");
+    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 };
@@ -311,8 +361,11 @@ function parseArguments(optionsOrFn, optionsOrTest) {
     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.");
+    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;
@@ -344,10 +397,12 @@ function createSuiteCollector(name, factory = () => {
       meta: options.meta ?? /* @__PURE__ */ Object.create(null)
     };
     const handler = options.handler;
-    if (options.concurrent || !options.sequential && runner.config.sequence.concurrent)
+    if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
       task2.concurrent = true;
-    if (shuffle)
+    }
+    if (shuffle) {
       task2.shuffle = true;
+    }
     const context = createTestContext(task2, runner);
     Object.defineProperty(task2, "context", {
       value: context,
@@ -355,10 +410,13 @@ function createSuiteCollector(name, factory = () => {
     });
     setFixture(context, options.fixtures);
     if (handler) {
-      setFn(task2, withTimeout(
-        withFixtures(handler, context),
-        (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
-      ));
+      setFn(
+        task2,
+        withTimeout(
+          withFixtures(handler, context),
+          (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
+        )
+      );
     }
     if (runner.config.includeTaskLocation) {
       const limit = Error.stackTraceLimit;
@@ -366,25 +424,25 @@ function createSuiteCollector(name, factory = () => {
       const error = new Error("stacktrace").stack;
       Error.stackTraceLimit = limit;
       const stack = findTestFileStackTrace(error, task2.each ?? false);
-      if (stack)
+      if (stack) {
         task2.location = stack;
+      }
     }
     tasks.push(task2);
     return task2;
   };
   const test2 = createTest(function(name2, optionsOrFn, optionsOrTest) {
-    let { options, handler } = parseArguments(
-      optionsOrFn,
-      optionsOrTest
-    );
-    if (typeof suiteOptions === "object")
+    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 }
-    );
+    const test3 = task(formatName(name2), {
+      ...this,
+      ...options,
+      handler
+    });
     test3.type = "test";
   });
   const collector = {
@@ -403,8 +461,9 @@ function createSuiteCollector(name, factory = () => {
     getHooks(suite2)[name2].push(...fn);
   }
   function initSuite(includeLocation) {
-    if (typeof suiteOptions === "number")
+    if (typeof suiteOptions === "number") {
       suiteOptions = { timeout: suiteOptions };
+    }
     suite2 = {
       id: "",
       type: "suite",
@@ -414,7 +473,8 @@ function createSuiteCollector(name, factory = () => {
       file: void 0,
       shuffle,
       tasks: [],
-      meta: /* @__PURE__ */ Object.create(null)
+      meta: /* @__PURE__ */ Object.create(null),
+      concurrent: suiteOptions == null ? void 0 : suiteOptions.concurrent
     };
     if (runner && includeLocation && runner.config.includeTaskLocation) {
       const limit = Error.stackTraceLimit;
@@ -422,8 +482,9 @@ function createSuiteCollector(name, factory = () => {
       const error = new Error("stacktrace").stack;
       Error.stackTraceLimit = limit;
       const stack = findTestFileStackTrace(error, suite2.each ?? false);
-      if (stack)
+      if (stack) {
         suite2.location = stack;
+      }
     }
     setHooks(suite2, createSuiteHooks());
   }
@@ -433,14 +494,17 @@ function createSuiteCollector(name, factory = () => {
     initSuite(false);
   }
   async function collect(file) {
-    if (!file)
+    if (!file) {
       throw new TypeError("File is required to collect tasks.");
+    }
     factoryQueue.length = 0;
-    if (factory)
+    if (factory) {
       await runWithSuite(collector, () => factory(test2));
+    }
     const allChildren = [];
-    for (const i of [...factoryQueue, ...tasks])
+    for (const i of [...factoryQueue, ...tasks]) {
       allChildren.push(i.type === "collector" ? await i.collect(file) : i);
+    }
     suite2.file = file;
     suite2.tasks = allChildren;
     allChildren.forEach((task2) => {
@@ -460,29 +524,41 @@ function createSuite() {
       factoryOrOptions,
       optionsOrFactory
     );
-    if (currentSuite == null ? void 0 : currentSuite.options)
+    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.shuffle, this.each, options);
+    }
+    const isConcurrent = options.concurrent || this.concurrent && !this.sequential;
+    const isSequential = options.sequential || this.sequential && !this.concurrent;
+    options.concurrent = isConcurrent && !isSequential;
+    options.sequential = isSequential && !isConcurrent;
+    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)
+    if (Array.isArray(cases) && args.length) {
       cases = formatTemplateString(cases, args);
+    }
     return (name, optionsOrFn, fnOrOptions) => {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
-      const { options, handler } = parseArguments(
-        optionsOrFn,
-        fnOrOptions
-      );
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
       const fnFirst = typeof optionsOrFn === "function";
       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);
+          arrayOnlyCases ? suite2(
+            formatTitle(_name, items, idx),
+            () => handler(...items),
+            options
+          ) : 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));
         }
@@ -502,20 +578,22 @@ function createTaskCollector(fn, context) {
   taskFn.each = function(cases, ...args) {
     const test2 = this.withContext();
     this.setContext("each", true);
-    if (Array.isArray(cases) && args.length)
+    if (Array.isArray(cases) && args.length) {
       cases = formatTemplateString(cases, args);
+    }
     return (name, optionsOrFn, fnOrOptions) => {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
-      const { options, handler } = parseArguments(
-        optionsOrFn,
-        fnOrOptions
-      );
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
       const fnFirst = typeof optionsOrFn === "function";
       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);
+          arrayOnlyCases ? test2(
+            formatTitle(_name, items, idx),
+            () => handler(...items),
+            options
+          ) : 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));
         }
@@ -523,6 +601,22 @@ function createTaskCollector(fn, context) {
       this.setContext("each", void 0);
     };
   };
+  taskFn.for = function(cases, ...args) {
+    const test2 = this.withContext();
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const _name = formatName(name);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      cases.forEach((item, idx) => {
+        const handlerWrapper = (ctx) => handler(item, ctx);
+        handlerWrapper.__VITEST_FIXTURE_INDEX__ = 1;
+        handlerWrapper.toString = () => handler.toString();
+        test2(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
+      });
+    };
+  };
   taskFn.skipIf = function(condition) {
     return condition ? this.skip : this;
   };
@@ -532,15 +626,21 @@ function createTaskCollector(fn, context) {
   taskFn.extend = function(fixtures) {
     const _context = mergeContextFixtures(fixtures, context);
     return createTest(function fn2(name, optionsOrFn, optionsOrTest) {
-      getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+      getCurrentSuite().test.fn.call(
+        this,
+        formatName(name),
+        optionsOrFn,
+        optionsOrTest
+      );
     }, _context);
   };
   const _test = createChainable(
     ["concurrent", "sequential", "skip", "only", "todo", "fails"],
     taskFn
   );
-  if (context)
+  if (context) {
     _test.mergeContext(context);
+  }
   return _test;
 }
 function createTest(fn, context) {
@@ -554,14 +654,28 @@ function formatTitle(template, items, idx) {
     template = template.replace(/%%/g, "__vitest_escaped_%__").replace(/%#/g, `${idx}`).replace(/__vitest_escaped_%__/g, "%%");
   }
   const count = template.split("%").length - 1;
+  if (template.includes("%f")) {
+    const placeholders = template.match(/%f/g) || [];
+    placeholders.forEach((_, i) => {
+      if (isNegativeNaN(items[i]) || Object.is(items[i], -0)) {
+        let occurrence = 0;
+        template = template.replace(/%f/g, (match) => {
+          occurrence++;
+          return occurrence === i + 1 ? "-%f" : match;
+        });
+      }
+    });
+  }
   let formatted = format(template, ...items.slice(0, count));
   if (isObject(items[0])) {
     formatted = formatted.replace(
-      /\$([$\w_.]+)/g,
+      /\$([$\w.]+)/g,
       // https://github.com/chaijs/chai/pull/1490
       (_, key) => {
         var _a, _b;
-        return objDisplay(objectAttr(items[0], key), { truncate: (_b = (_a = runner == null ? void 0 : runner.config) == null ? void 0 : _a.chaiConfig) == null ? void 0 : _b.truncateThreshold });
+        return objDisplay(objectAttr(items[0], key), {
+          truncate: (_b = (_a = runner == null ? void 0 : runner.config) == null ? void 0 : _a.chaiConfig) == null ? void 0 : _b.truncateThreshold
+        });
       }
     );
   }
@@ -572,8 +686,9 @@ function formatTemplateString(cases, args) {
   const res = [];
   for (let i = 0; i < Math.floor(args.length / header.length); i++) {
     const oneCase = {};
-    for (let j = 0; j < header.length; j++)
+    for (let j = 0; j < header.length; j++) {
       oneCase[header[j]] = args[i * header.length + j];
+    }
     res.push(oneCase);
   }
   return res;
@@ -606,29 +721,20 @@ async function runSetupFiles(config, runner) {
       })
     );
   } else {
-    for (const fsPath of files)
+    for (const fsPath of files) {
       await runner.importFile(fsPath, "setup");
+    }
   }
 }
 
 const now$1 = Date.now;
 async function collectTests(paths, runner) {
+  var _a;
   const files = [];
   const config = runner.config;
   for (const filepath of paths) {
-    const path = relative(config.root, filepath);
-    const file = {
-      id: generateHash(`${path}${config.name || ""}`),
-      name: path,
-      type: "suite",
-      mode: "run",
-      filepath,
-      tasks: [],
-      meta: /* @__PURE__ */ Object.create(null),
-      projectName: config.name,
-      file: void 0
-    };
-    file.file = file;
+    const file = createFileTask(filepath, config.root, config.name);
+    (_a = runner.onCollectStart) == null ? void 0 : _a.call(runner, file);
     clearCollectorContext(filepath, runner);
     try {
       const setupStart = now$1();
@@ -663,11 +769,18 @@ async function collectTests(paths, runner) {
     }
     calculateSuiteHash(file);
     const hasOnlyTasks = someTasksAreOnly(file);
-    interpretTaskModes(file, config.testNamePattern, hasOnlyTasks, false, config.allowOnly);
+    interpretTaskModes(
+      file,
+      config.testNamePattern,
+      hasOnlyTasks,
+      false,
+      config.allowOnly
+    );
     file.tasks.forEach((task) => {
-      var _a;
-      if (((_a = task.suite) == null ? void 0 : _a.id) === "")
+      var _a2;
+      if (((_a2 = task.suite) == null ? void 0 : _a2.id) === "") {
         delete task.suite;
+      }
     });
     files.push(file);
   }
@@ -684,10 +797,12 @@ function mergeHooks(baseHooks, hooks) {
 const now = Date.now;
 function updateSuiteHookState(suite, name, state, runner) {
   var _a;
-  if (!suite.result)
+  if (!suite.result) {
     suite.result = { state: "run" };
-  if (!((_a = suite.result) == null ? void 0 : _a.hooks))
+  }
+  if (!((_a = suite.result) == null ? void 0 : _a.hooks)) {
     suite.result.hooks = {};
+  }
   const suiteHooks = suite.result.hooks;
   if (suiteHooks) {
     suiteHooks[name] = state;
@@ -696,18 +811,21 @@ function updateSuiteHookState(suite, name, state, runner) {
 }
 function getSuiteHooks(suite, name, sequence) {
   const hooks = getHooks(suite)[name];
-  if (sequence === "stack" && (name === "afterAll" || name === "afterEach"))
+  if (sequence === "stack" && (name === "afterAll" || name === "afterEach")) {
     return hooks.slice().reverse();
+  }
   return hooks;
 }
 async function callTaskHooks(task, hooks, sequence) {
-  if (sequence === "stack")
+  if (sequence === "stack") {
     hooks = hooks.slice().reverse();
+  }
   if (sequence === "parallel") {
     await Promise.all(hooks.map((fn) => fn(task.result)));
   } else {
-    for (const fn of hooks)
+    for (const fn of hooks) {
       await fn(task.result);
+    }
   }
 }
 async function callSuiteHook(suite, currentTask, name, runner, args) {
@@ -722,10 +840,13 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
   updateSuiteHookState(currentTask, name, "run", runner);
   const hooks = getSuiteHooks(suite, name, sequence);
   if (sequence === "parallel") {
-    callbacks.push(...await Promise.all(hooks.map((fn) => fn(...args))));
+    callbacks.push(
+      ...await Promise.all(hooks.map((fn) => fn(...args)))
+    );
   } else {
-    for (const hook of hooks)
+    for (const hook of hooks) {
       callbacks.push(await hook(...args));
+    }
   }
   updateSuiteHookState(currentTask, name, "pass", runner);
   if (name === "afterEach" && parentSuite) {
@@ -753,11 +874,7 @@ async function sendTasksUpdate(runner) {
   await previousUpdate;
   if (packs.size) {
     const taskPacks = Array.from(packs).map(([id, task]) => {
-      return [
-        id,
-        task[0],
-        task[1]
-      ];
+      return [id, task[0], task[1]];
     });
     const p = (_a = runner.onTaskUpdate) == null ? void 0 : _a.call(runner, taskPacks);
     packs.clear();
@@ -765,17 +882,21 @@ async function sendTasksUpdate(runner) {
   }
 }
 async function callCleanupHooks(cleanups) {
-  await Promise.all(cleanups.map(async (fn) => {
-    if (typeof fn !== "function")
-      return;
-    await fn();
-  }));
+  await Promise.all(
+    cleanups.map(async (fn) => {
+      if (typeof fn !== "function") {
+        return;
+      }
+      await fn();
+    })
+  );
 }
 async function runTest(test, runner) {
   var _a, _b, _c, _d, _e, _f;
   await ((_a = runner.onBeforeRunTask) == null ? void 0 : _a.call(runner, test));
-  if (test.mode !== "run")
+  if (test.mode !== "run") {
     return;
+  }
   if (((_b = test.result) == null ? void 0 : _b.state) === "fail") {
     updateTask(test, runner);
     return;
@@ -795,29 +916,46 @@ async function runTest(test, runner) {
     for (let retryCount = 0; retryCount <= retry; retryCount++) {
       let beforeEachCleanups = [];
       try {
-        await ((_c = runner.onBeforeTryTask) == 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(suite, test, "beforeEach", runner, [test.context, suite]);
+        beforeEachCleanups = await callSuiteHook(
+          suite,
+          test,
+          "beforeEach",
+          runner,
+          [test.context, suite]
+        );
         if (runner.runTask) {
           await runner.runTask(test);
         } else {
           const fn = getFn(test);
-          if (!fn)
-            throw new Error("Test function is not found. Did you add it using `setFn`?");
+          if (!fn) {
+            throw new Error(
+              "Test function is not found. Did you add it using `setFn`?"
+            );
+          }
           await fn();
         }
         if (test.promises) {
           const result = await Promise.allSettled(test.promises);
           const errors = result.map((r) => r.status === "rejected" ? r.reason : void 0).filter(Boolean);
-          if (errors.length)
+          if (errors.length) {
             throw errors;
+          }
         }
-        await ((_d = runner.onAfterTryTask) == 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)
+          if (!test.repeats) {
             test.result.state = "pass";
-          else if (test.repeats && retry === retryCount)
+          } else if (test.repeats && retry === retryCount) {
             test.result.state = "pass";
+          }
         }
       } catch (e) {
         failTask(test.result, e, runner.config.diffOptions);
@@ -830,14 +968,18 @@ async function runTest(test, runner) {
         return;
       }
       try {
-        await callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]);
+        await callSuiteHook(suite, test, "afterEach", runner, [
+          test.context,
+          suite
+        ]);
         await callCleanupHooks(beforeEachCleanups);
         await callFixtureCleanup(test.context);
       } catch (e) {
         failTask(test.result, e, runner.config.diffOptions);
       }
-      if (test.result.state === "pass")
+      if (test.result.state === "pass") {
         break;
+      }
       if (retryCount < retry) {
         test.result.state = "run";
         test.result.retryCount = (test.result.retryCount ?? 0) + 1;
@@ -852,7 +994,11 @@ async function runTest(test, runner) {
   }
   if (test.result.state === "fail") {
     try {
-      await callTaskHooks(test, test.onFailed || [], runner.config.sequence.hooks);
+      await callTaskHooks(
+        test,
+        test.onFailed || [],
+        runner.config.sequence.hooks
+      );
     } catch (e) {
       failTask(test.result, e, runner.config.diffOptions);
     }
@@ -890,8 +1036,9 @@ function markTasksAsSkipped(suite, runner) {
     t.mode = "skip";
     t.result = { ...t.result, state: "skip" };
     updateTask(t, runner);
-    if (t.type === "suite")
+    if (t.type === "suite") {
       markTasksAsSkipped(t, runner);
+    }
   });
 }
 async function runSuite(suite, runner) {
@@ -915,24 +1062,34 @@ async function runSuite(suite, runner) {
     suite.result.state = "todo";
   } else {
     try {
-      beforeAllCleanups = await callSuiteHook(suite, suite, "beforeAll", runner, [suite]);
+      beforeAllCleanups = await callSuiteHook(
+        suite,
+        suite,
+        "beforeAll",
+        runner,
+        [suite]
+      );
       if (runner.runSuite) {
         await runner.runSuite(suite);
       } else {
         for (let tasksGroup of partitionSuiteChildren(suite)) {
           if (tasksGroup[0].concurrent === true) {
-            const mutex = limit(runner.config.maxConcurrency);
-            await Promise.all(tasksGroup.map((c) => mutex(() => runSuiteChild(c, runner))));
+            await Promise.all(tasksGroup.map((c) => runSuiteChild(c, runner)));
           } else {
             const { sequence } = runner.config;
             if (sequence.shuffle || suite.shuffle) {
-              const suites = tasksGroup.filter((group) => group.type === "suite");
+              const suites = tasksGroup.filter(
+                (group) => group.type === "suite"
+              );
               const tests = tasksGroup.filter((group) => group.type === "test");
               const groups = shuffle([suites, tests], sequence.seed);
-              tasksGroup = groups.flatMap((group) => shuffle(group, sequence.seed));
+              tasksGroup = groups.flatMap(
+                (group) => shuffle(group, sequence.seed)
+              );
             }
-            for (const c of tasksGroup)
+            for (const c of tasksGroup) {
               await runSuiteChild(c, runner);
+            }
           }
         }
       }
@@ -949,7 +1106,9 @@ async function runSuite(suite, runner) {
       if (!runner.config.passWithNoTests && !hasTests(suite)) {
         suite.result.state = "fail";
         if (!((_c = suite.result.errors) == null ? void 0 : _c.length)) {
-          const error = processError(new Error(`No test found in suite ${suite.name}`));
+          const error = processError(
+            new Error(`No test found in suite ${suite.name}`)
+          );
           suite.result.errors = [error];
         }
       } else if (hasFailed(suite)) {
@@ -963,18 +1122,23 @@ async function runSuite(suite, runner) {
     await ((_d = runner.onAfterRunSuite) == null ? void 0 : _d.call(runner, suite));
   }
 }
+let limitMaxConcurrency;
 async function runSuiteChild(c, runner) {
-  if (c.type === "test" || c.type === "custom")
-    return runTest(c, runner);
-  else if (c.type === "suite")
+  if (c.type === "test" || c.type === "custom") {
+    return limitMaxConcurrency(() => runTest(c, runner));
+  } else if (c.type === "suite") {
     return runSuite(c, runner);
+  }
 }
 async function runFiles(files, runner) {
   var _a, _b;
+  limitMaxConcurrency ?? (limitMaxConcurrency = limit(runner.config.maxConcurrency));
   for (const file of files) {
     if (!file.tasks.length && !runner.config.passWithNoTests) {
       if (!((_b = (_a = file.result) == null ? void 0 : _a.errors) == null ? void 0 : _b.length)) {
-        const error = processError(new Error(`No test suite found in file ${file.filepath}`));
+        const error = processError(
+          new Error(`No test suite found in file ${file.filepath}`)
+        );
         file.result = {
           state: "fail",
           errors: [error]
@@ -1000,30 +1164,49 @@ function getDefaultHookTimeout() {
   return getRunner().config.hookTimeout;
 }
 function beforeAll(fn, timeout) {
-  return getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+  return getCurrentSuite().on(
+    "beforeAll",
+    withTimeout(fn, timeout ?? getDefaultHookTimeout(), true)
+  );
 }
 function afterAll(fn, timeout) {
-  return getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+  return getCurrentSuite().on(
+    "afterAll",
+    withTimeout(fn, timeout ?? getDefaultHookTimeout(), true)
+  );
 }
 function beforeEach(fn, timeout) {
-  return getCurrentSuite().on("beforeEach", withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true));
+  return getCurrentSuite().on(
+    "beforeEach",
+    withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true)
+  );
 }
 function afterEach(fn, timeout) {
-  return getCurrentSuite().on("afterEach", withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true));
+  return getCurrentSuite().on(
+    "afterEach",
+    withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true)
+  );
 }
-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);
-});
+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)
+    if (!current) {
       throw new Error(`Hook ${name}() can only be called inside a test`);
+    }
     return handler(current, fn);
   };
 }

package/dist/{tasks-Ck0GpLiZ.d.ts → tasks-BP89OzIP.d.ts}

@@ -64,7 +64,11 @@ interface TaskResult {
     retryCount?: number;
     repeatCount?: number;
 }
-type TaskResultPack = [id: string, result: TaskResult | undefined, meta: TaskMeta];
+type TaskResultPack = [
+    id: string,
+    result: TaskResult | undefined,
+    meta: TaskMeta
+];
 interface Suite extends TaskBase {
     file: File;
     type: 'suite';
@@ -72,7 +76,7 @@ interface Suite extends TaskBase {
 }
 interface File extends Suite {
     filepath: string;
-    projectName: string;
+    projectName: string | undefined;
     collectDuration?: number;
     setupDuration?: number;
 }
@@ -114,6 +118,14 @@ interface TestEachFunction {
     <T>(cases: ReadonlyArray<T>): EachFunctionReturn<T[]>;
     (...args: [TemplateStringsArray, ...any]): EachFunctionReturn<any[]>;
 }
+interface TestForFunctionReturn<Arg, Context> {
+    (name: string | Function, fn: (arg: Arg, context: Context) => Awaitable<void>): void;
+    (name: string | Function, options: TestOptions, fn: (args: Arg, context: Context) => Awaitable<void>): void;
+}
+interface TestForFunction<ExtraContext> {
+    <T>(cases: ReadonlyArray<T>): TestForFunctionReturn<T, ExtendedContext<Test> & ExtraContext>;
+    (strings: TemplateStringsArray, ...values: any[]): TestForFunctionReturn<any, ExtendedContext<Test> & ExtraContext>;
+}
 interface TestCollectorCallable<C = {}> {
     /**
      * @deprecated Use options as the second argument instead
@@ -124,6 +136,7 @@ interface TestCollectorCallable<C = {}> {
 }
 type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'fails', TestCollectorCallable<ExtraContext>, {
     each: TestEachFunction;
+    for: TestForFunction<ExtraContext>;
 }>;
 interface TestOptions {
     /**
@@ -145,7 +158,7 @@ interface TestOptions {
      */
     repeats?: number;
     /**
-     * Whether tests run concurrently.
+     * Whether suites and tests run concurrently.
      * Tests inherit `concurrent` from `describe()` and nested `describe()` will inherit from parent's `concurrent`.
      */
     concurrent?: boolean;
@@ -193,7 +206,7 @@ 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 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>> | [Fixture<T, K, ExtraContext & ExtendedContext<Test>>, FixtureOptions?];
 };
@@ -218,8 +231,14 @@ 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>]>[];
+    beforeEach: HookListener<[
+        ExtendedContext<Test | Custom> & ExtraContext,
+        Readonly<Suite>
+    ], HookCleanupCallback>[];
+    afterEach: HookListener<[
+        ExtendedContext<Test | Custom> & ExtraContext,
+        Readonly<Suite>
+    ]>[];
 }
 interface TaskCustomOptions extends TestOptions {
     concurrent?: boolean;

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-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-Ck0GpLiZ.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-Ck0GpLiZ.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-BP89OzIP.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-BP89OzIP.js';
 import { DiffOptions } from '@vitest/utils/diff';
 import '@vitest/utils';
 
@@ -31,12 +31,16 @@ type VitestRunnerImportSource = 'collect' | 'setup';
 interface VitestRunnerConstructor {
     new (config: VitestRunnerConfig): VitestRunner;
 }
-type CancelReason = 'keyboard-input' | 'test-failure' | string & Record<string, never>;
+type CancelReason = 'keyboard-input' | 'test-failure' | (string & Record<string, never>);
 interface VitestRunner {
     /**
      * First thing that's getting called before actually collecting and running tests.
      */
     onBeforeCollect?: (paths: string[]) => unknown;
+    /**
+     * Called after the file task was created but not collected yet.
+     */
+    onCollectStart?: (file: File) => unknown;
     /**
      * Called after collecting tests and before "onBeforeRun".
      */

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, T as Task, a as Test, C as Custom } from './tasks-Ck0GpLiZ.js';
-export { b as ChainableFunction, c as createChainable } from './tasks-Ck0GpLiZ.js';
+import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-BP89OzIP.js';
+export { b as ChainableFunction, c as createChainable } from './tasks-BP89OzIP.js';
 import { Arrayable } from '@vitest/utils';
 
 /**
@@ -9,12 +9,14 @@ 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): File;
 
 /**
  * Partition in tasks groups by consecutive concurrent
  */
 declare function partitionSuiteChildren(suite: Suite): Task[][];
 
+declare function isAtomTest(s: Task): s is Test | Custom;
 declare function getTests(suite: Arrayable<Task>): (Test | Custom)[];
 declare function getTasks(tasks?: Arrayable<Task>): Task[];
 declare function getSuites(suite: Arrayable<Task>): Suite[];
@@ -22,4 +24,4 @@ declare function hasTests(suite: Arrayable<Suite>): boolean;
 declare function hasFailed(suite: Arrayable<Task>): boolean;
 declare function getNames(task: Task): string[];
 
-export { calculateSuiteHash, generateHash, getNames, getSuites, getTasks, getTests, hasFailed, hasTests, interpretTaskModes, partitionSuiteChildren, someTasksAreOnly };
+export { calculateSuiteHash, createFileTask, generateHash, getNames, getSuites, getTasks, getTests, hasFailed, hasTests, interpretTaskModes, isAtomTest, partitionSuiteChildren, someTasksAreOnly };

package/dist/utils.js

@@ -1,3 +1,4 @@
-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';
+export { c as calculateSuiteHash, l as createChainable, a as createFileTask, g as generateHash, k as getNames, f as getSuites, e as getTasks, d as getTests, j as hasFailed, h as hasTests, i as interpretTaskModes, b as isAtomTest, p as partitionSuiteChildren, s as someTasksAreOnly } from './chunk-tasks.js';
 import '@vitest/utils/error';
+import 'pathe';
 import '@vitest/utils';

package/package.json

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