@vitest/runner 1.6.0 → 2.0.0-beta.10

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) {
@@ -91,6 +92,22 @@ function calculateSuiteHash(parent) {
       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) {
@@ -160,12 +177,14 @@ function hasFailed(suite) {
 function getNames(task) {
   const names = [task.name];
   let current = task;
-  while ((current == null ? void 0 : current.suite) || (current == null ? void 0 : current.file)) {
-    current = current.suite || current.file;
+  while (current == null ? void 0 : current.suite) {
+    current = current.suite;
     if (current == null ? void 0 : current.name)
       names.unshift(current.name);
   }
+  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, getTests as b, calculateSuiteHash as c, getTasks as d, getSuites as e, hasFailed as f, generateHash as g, hasTests as h, interpretTaskModes as i, getNames as j, createChainable as k, 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-K5XERDtv.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-K5XERDtv.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-CcHkacEF.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-CcHkacEF.js';
 import { Awaitable } from '@vitest/utils';
 export { processError } from '@vitest/utils/error';
 import '@vitest/utils/diff';

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 { k as createChainable, a as createFileTask, c as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, p as partitionSuiteChildren, h as hasTests, f 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();
@@ -207,12 +207,17 @@ function getUsedProps(fn) {
   const args = splitByComma(match[1]);
   if (!args.length)
     return [];
-  const first = args[0];
+  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("..."))
@@ -271,9 +276,15 @@ function getTestFilepath() {
 function getRunner() {
   return runner;
 }
+function createDefaultSuite(runner2) {
+  const config = runner2.config.sequence;
+  const api = config.shuffle ? suite.shuffle : suite;
+  return api("", { concurrent: config.concurrent }, () => {
+  });
+}
 function clearCollectorContext(filepath, currentRunner) {
   if (!defaultSuite)
-    defaultSuite = currentRunner.config.sequence.shuffle ? suite.shuffle("") : currentRunner.config.sequence.concurrent ? suite.concurrent("") : suite("");
+    defaultSuite = createDefaultSuite(currentRunner);
   runner = currentRunner;
   currentTestFilepath = filepath;
   collectorContext.tasks.length = 0;
@@ -331,6 +342,7 @@ function createSuiteCollector(name, factory = () => {
       fails: options.fails,
       context: void 0,
       type: "custom",
+      file: void 0,
       retry: options.retry ?? runner.config.retry,
       repeats: options.repeats,
       mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
@@ -404,10 +416,11 @@ function createSuiteCollector(name, factory = () => {
       name,
       mode,
       each,
+      file: void 0,
       shuffle,
       tasks: [],
       meta: /* @__PURE__ */ Object.create(null),
-      projectName: ""
+      concurrent: suiteOptions == null ? void 0 : suiteOptions.concurrent
     };
     if (runner && includeLocation && runner.config.includeTaskLocation) {
       const limit = Error.stackTraceLimit;
@@ -426,6 +439,8 @@ function createSuiteCollector(name, factory = () => {
     initSuite(false);
   }
   async function collect(file) {
+    if (!file)
+      throw new TypeError("File is required to collect tasks.");
     factoryQueue.length = 0;
     if (factory)
       await runWithSuite(collector, () => factory(test2));
@@ -436,8 +451,7 @@ function createSuiteCollector(name, factory = () => {
     suite2.tasks = allChildren;
     allChildren.forEach((task2) => {
       task2.suite = suite2;
-      if (file)
-        task2.file = file;
+      task2.file = file;
     });
     return suite2;
   }
@@ -454,8 +468,10 @@ function createSuite() {
     );
     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);
+    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) {
@@ -515,6 +531,21 @@ 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;
   };
@@ -546,10 +577,22 @@ 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;
@@ -605,20 +648,12 @@ async function runSetupFiles(config, runner) {
 
 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
-    };
+    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();
@@ -627,20 +662,22 @@ async function collectTests(paths, runner) {
       file.setupDuration = collectStart - setupStart;
       await runner.importFile(filepath, "collect");
       const defaultTasks = await getDefaultSuite().collect(file);
-      setHooks(file, getHooks(defaultTasks));
+      const fileHooks = createSuiteHooks();
+      mergeHooks(fileHooks, getHooks(defaultTasks));
       for (const c of [...defaultTasks.tasks, ...collectorContext.tasks]) {
-        if (c.type === "test") {
-          file.tasks.push(c);
-        } else if (c.type === "custom") {
-          file.tasks.push(c);
-        } else if (c.type === "suite") {
+        if (c.type === "test" || c.type === "custom" || c.type === "suite") {
           file.tasks.push(c);
         } else if (c.type === "collector") {
           const suite = await c.collect(file);
-          if (suite.name || suite.tasks.length)
+          if (suite.name || suite.tasks.length) {
+            mergeHooks(fileHooks, getHooks(suite));
             file.tasks.push(suite);
+          }
+        } else {
+          c;
         }
       }
+      setHooks(file, fileHooks);
       file.collectDuration = now$1() - collectStart;
     } catch (e) {
       const error = processError(e);
@@ -652,10 +689,22 @@ async function collectTests(paths, runner) {
     calculateSuiteHash(file);
     const hasOnlyTasks = someTasksAreOnly(file);
     interpretTaskModes(file, config.testNamePattern, hasOnlyTasks, 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;
 }
+function mergeHooks(baseHooks, hooks) {
+  for (const _key in hooks) {
+    const key = _key;
+    baseHooks[key].push(...hooks[key]);
+  }
+  return baseHooks;
+}
 
 const now = Date.now;
 function updateSuiteHookState(suite, name, state, runner) {
@@ -689,9 +738,10 @@ async function callTaskHooks(task, hooks, sequence) {
 async function callSuiteHook(suite, currentTask, name, runner, args) {
   const sequence = runner.config.sequence.hooks;
   const callbacks = [];
-  if (name === "beforeEach" && suite.suite) {
+  const parentSuite = "filepath" in suite ? null : suite.suite || suite.file;
+  if (name === "beforeEach" && parentSuite) {
     callbacks.push(
-      ...await callSuiteHook(suite.suite, currentTask, name, runner, args)
+      ...await callSuiteHook(parentSuite, currentTask, name, runner, args)
     );
   }
   updateSuiteHookState(currentTask, name, "run", runner);
@@ -703,9 +753,9 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
       callbacks.push(await hook(...args));
   }
   updateSuiteHookState(currentTask, name, "pass", runner);
-  if (name === "afterEach" && suite.suite) {
+  if (name === "afterEach" && parentSuite) {
     callbacks.push(
-      ...await callSuiteHook(suite.suite, currentTask, name, runner, args)
+      ...await callSuiteHook(parentSuite, currentTask, name, runner, args)
     );
   }
   return callbacks;
@@ -763,6 +813,7 @@ async function runTest(test, runner) {
   };
   updateTask(test, runner);
   setCurrentTest(test);
+  const suite = test.suite || test.file;
   const repeats = test.repeats ?? 0;
   for (let repeatCount = 0; repeatCount <= repeats; repeatCount++) {
     const retry = test.retry ?? 0;
@@ -771,7 +822,7 @@ async function runTest(test, runner) {
       try {
         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]);
+        beforeEachCleanups = await callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]);
         if (runner.runTask) {
           await runner.runTask(test);
         } else {
@@ -804,7 +855,7 @@ async function runTest(test, runner) {
         return;
       }
       try {
-        await callSuiteHook(test.suite, test, "afterEach", runner, [test.context, test.suite]);
+        await callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]);
         await callCleanupHooks(beforeEachCleanups);
         await callFixtureCleanup(test.context);
       } catch (e) {
@@ -895,8 +946,7 @@ async function runSuite(suite, runner) {
       } 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) {
@@ -937,14 +987,16 @@ 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);
+    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)) {

package/dist/{tasks-K5XERDtv.d.ts → tasks-CcHkacEF.d.ts}

@@ -31,7 +31,6 @@ interface TaskBase {
     concurrent?: boolean;
     shuffle?: boolean;
     suite?: Suite;
-    file?: File;
     result?: TaskResult;
     retry?: number;
     repeats?: number;
@@ -41,7 +40,7 @@ interface TaskBase {
     };
 }
 interface TaskPopulated extends TaskBase {
-    suite: Suite;
+    file: File;
     pending?: boolean;
     result?: TaskResult;
     fails?: boolean;
@@ -67,13 +66,13 @@ interface TaskResult {
 }
 type TaskResultPack = [id: string, result: TaskResult | undefined, meta: TaskMeta];
 interface Suite extends TaskBase {
+    file: File;
     type: 'suite';
     tasks: Task[];
-    filepath?: string;
-    projectName: string;
 }
 interface File extends Suite {
     filepath: string;
+    projectName: string | undefined;
     collectDuration?: number;
     setupDuration?: number;
 }
@@ -115,6 +114,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
@@ -125,6 +132,7 @@ interface TestCollectorCallable<C = {}> {
 }
 type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'fails', TestCollectorCallable<ExtraContext>, {
     each: TestEachFunction;
+    for: TestForFunction<ExtraContext>;
 }>;
 interface TestOptions {
     /**
@@ -146,7 +154,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;
@@ -242,7 +250,7 @@ interface SuiteCollector<ExtraContext = {}> {
     test: TestAPI<ExtraContext>;
     tasks: (Suite | Custom<ExtraContext> | Test<ExtraContext> | SuiteCollector<ExtraContext>)[];
     task: (name: string, options?: TaskCustomOptions) => Custom<ExtraContext>;
-    collect: (file?: File) => Promise<Suite>;
+    collect: (file: File) => Promise<Suite>;
     clear: () => void;
     on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
 }

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-K5XERDtv.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-K5XERDtv.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-CcHkacEF.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-CcHkacEF.js';
 import { DiffOptions } from '@vitest/utils/diff';
 import '@vitest/utils';
 
@@ -37,6 +37,10 @@ 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-K5XERDtv.js';
-export { b as ChainableFunction, c as createChainable } from './tasks-K5XERDtv.js';
+import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-CcHkacEF.js';
+export { b as ChainableFunction, c as createChainable } from './tasks-CcHkacEF.js';
 import { Arrayable } from '@vitest/utils';
 
 /**
@@ -9,6 +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): File;
 
 /**
  * Partition in tasks groups by consecutive concurrent
@@ -22,4 +23,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, 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, k as createChainable, a as createFileTask, g as generateHash, j as getNames, e as getSuites, d as getTasks, b as getTests, f as hasFailed, h as hasTests, i as interpretTaskModes, 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": "1.6.0",
+  "version": "2.0.0-beta.10",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -39,8 +39,8 @@
   ],
   "dependencies": {
     "p-limit": "^5.0.0",
-    "pathe": "^1.1.1",
-    "@vitest/utils": "1.6.0"
+    "pathe": "^1.1.2",
+    "@vitest/utils": "2.0.0-beta.10"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",