@vitest/runner 0.32.1 → 0.32.3

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { V as VitestRunner } from './runner-0b317aff.js';
-export { C as CancelReason, a as VitestRunnerConfig, c as VitestRunnerConstructor, b as VitestRunnerImportSource } from './runner-0b317aff.js';
-import { T as Task, F as File, S as SuiteAPI, a as TestAPI, b as SuiteCollector, c as SuiteHooks, O as OnTestFailedHandler, d as Test } from './tasks-045d21eb.js';
-export { D as DoneCallback, n as HookCleanupCallback, H as HookListener, R as RunMode, p as RuntimeContext, r as SequenceHooks, s as SequenceSetupFiles, k as Suite, o as SuiteFactory, f as TaskBase, h as TaskCustom, g as TaskMeta, i as TaskResult, j as TaskResultPack, e as TaskState, q as TestContext, l as TestFunction, m as TestOptions } from './tasks-045d21eb.js';
+import { VitestRunner } from './types.js';
+export { CancelReason, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource } from './types.js';
+import { T as Task, F as File, d as SuiteAPI, e as TestAPI, f as SuiteCollector, g as SuiteHooks, O as OnTestFailedHandler, a as Test } from './tasks-f541c18c.js';
+export { D as DoneCallback, o as Fixtures, p as HookCleanupCallback, H as HookListener, R as RunMode, r as RuntimeContext, t as SequenceHooks, u as SequenceSetupFiles, S as Suite, q as SuiteFactory, i as TaskBase, b as TaskCustom, j as TaskMeta, k as TaskResult, l as TaskResultPack, h as TaskState, s as TestContext, m as TestFunction, n as TestOptions } from './tasks-f541c18c.js';
 import { Awaitable } from '@vitest/utils';
 
 declare function updateTask(task: Task, runner: VitestRunner): void;

package/dist/index.js

@@ -1,7 +1,7 @@
 import limit from 'p-limit';
 import { getSafeTimers, format, isObject, objDisplay, objectAttr, noop, toArray, shuffle } from '@vitest/utils';
 import { processError } from '@vitest/utils/error';
-import { c as createChainable, g as generateHash, a as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, p as partitionSuiteChildren, h as hasTests, b as hasFailed } from './chunk-tasks.js';
+import { createChainable, generateHash, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, partitionSuiteChildren, hasTests, hasFailed } from './utils.js';
 import { relative } from 'pathe';
 
 const fnMap = /* @__PURE__ */ new WeakMap();
@@ -34,7 +34,7 @@ async function runWithSuite(suite, fn) {
   collectorContext.currentSuite = prev;
 }
 function withTimeout(fn, timeout, isHook = false) {
-  if (timeout <= 0 || timeout === Infinity)
+  if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY)
     return fn;
   const { setTimeout, clearTimeout } = getSafeTimers();
   return (...args) => {
@@ -66,6 +66,110 @@ function makeTimeoutMsg(isHook, timeout) {
 If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
 }
 
+function mergeContextFixtures(fixtures, context = {}) {
+  const fixtureArray = Object.entries(fixtures).map(([prop, value], index) => {
+    const isFn = typeof value === "function";
+    return {
+      prop,
+      value,
+      index,
+      isFn
+    };
+  });
+  if (Array.isArray(context.fixtures))
+    context.fixtures = context.fixtures.concat(fixtureArray);
+  else
+    context.fixtures = fixtureArray;
+  fixtureArray.forEach((fixture) => {
+    if (fixture.isFn) {
+      const usedProps = getUsedProps(fixture.value);
+      if (usedProps.length)
+        fixture.deps = context.fixtures.filter(({ index, prop }) => index !== fixture.index && usedProps.includes(prop));
+    }
+  });
+  return context;
+}
+function withFixtures(fn, fixtures, context) {
+  if (!fixtures.length)
+    return () => fn(context);
+  const usedProps = getUsedProps(fn);
+  if (!usedProps.length)
+    return () => fn(context);
+  const usedFixtures = fixtures.filter(({ prop }) => usedProps.includes(prop));
+  const pendingFixtures = resolveDeps(usedFixtures);
+  let cursor = 0;
+  async function use(fixtureValue) {
+    const { prop } = pendingFixtures[cursor++];
+    context[prop] = fixtureValue;
+    if (cursor < pendingFixtures.length)
+      await next();
+    else
+      await fn(context);
+  }
+  async function next() {
+    const { value } = pendingFixtures[cursor];
+    typeof value === "function" ? await value(context, use) : await use(value);
+  }
+  return () => next();
+}
+function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtures = []) {
+  fixtures.forEach((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");
+    depSet.add(fixture);
+    resolveDeps(fixture.deps, depSet, pendingFixtures);
+    pendingFixtures.push(fixture);
+    depSet.clear();
+  });
+  return pendingFixtures;
+}
+function getUsedProps(fn) {
+  const match = fn.toString().match(/[^(]*\(([^)]*)/);
+  if (!match)
+    return [];
+  const args = splitByComma(match[1]);
+  if (!args.length)
+    return [];
+  const first = args[0];
+  if (!(first.startsWith("{") && first.endsWith("}")))
+    throw new Error("the first argument must use object destructuring pattern");
+  const _first = first.slice(1, -1).replace(/\s/g, "");
+  const props = splitByComma(_first).map((prop) => {
+    return prop.replace(/\:.*|\=.*/g, "");
+  });
+  const last = props.at(-1);
+  if (last && last.startsWith("..."))
+    throw new Error("Rest parameters are not supported");
+  return props;
+}
+function splitByComma(s) {
+  const result = [];
+  const stack = [];
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "{" || s[i] === "[") {
+      stack.push(s[i] === "{" ? "}" : "]");
+    } else if (s[i] === stack[stack.length - 1]) {
+      stack.pop();
+    } else if (!stack.length && s[i] === ",") {
+      const token = s.substring(start, i).trim();
+      if (token)
+        result.push(token);
+      start = i + 1;
+    }
+  }
+  const lastToken = s.substring(start).trim();
+  if (lastToken)
+    result.push(lastToken);
+  return result;
+}
+
 const suite = createSuite();
 const test = createTest(
   function(name, fn, options) {
@@ -84,7 +188,7 @@ function getRunner() {
 }
 function clearCollectorContext(currentRunner) {
   if (!defaultSuite)
-    defaultSuite = currentRunner.config.sequence.shuffle ? suite.shuffle("") : suite("");
+    defaultSuite = currentRunner.config.sequence.shuffle ? suite.shuffle("") : currentRunner.config.sequence.concurrent ? suite.concurrent("") : suite("");
   runner = currentRunner;
   collectorContext.tasks.length = 0;
   defaultSuite.clear();
@@ -121,11 +225,11 @@ function createSuiteCollector(name, factory = () => {
       mode: mode2,
       suite: void 0,
       fails: this.fails,
-      retry: options == null ? void 0 : options.retry,
+      retry: (options == null ? void 0 : options.retry) ?? runner.config.retry,
       repeats: options == null ? void 0 : options.repeats,
       meta: /* @__PURE__ */ Object.create(null)
     };
-    if (this.concurrent || concurrent)
+    if (this.concurrent || concurrent || runner.config.sequence.concurrent)
       test3.concurrent = true;
     if (shuffle)
       test3.shuffle = true;
@@ -135,7 +239,7 @@ function createSuiteCollector(name, factory = () => {
       enumerable: false
     });
     setFn(test3, withTimeout(
-      () => fn(context),
+      this.fixtures ? withFixtures(fn, this.fixtures, context) : () => fn(context),
       (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
     ));
     tasks.push(test3);
@@ -238,7 +342,7 @@ function createSuite() {
     suiteFn
   );
 }
-function createTest(fn) {
+function createTest(fn, context) {
   const testFn = fn;
   testFn.each = function(cases, ...args) {
     const test2 = this.withContext();
@@ -257,10 +361,19 @@ function createTest(fn) {
   };
   testFn.skipIf = (condition) => condition ? test.skip : test;
   testFn.runIf = (condition) => condition ? test : test.skip;
-  return createChainable(
+  testFn.extend = function(fixtures) {
+    const _context = mergeContextFixtures(fixtures, context);
+    return createTest(function fn2(name, fn2, options) {
+      getCurrentSuite().test.fn.call(this, formatName(name), fn2, options);
+    }, _context);
+  };
+  const _test = createChainable(
     ["concurrent", "skip", "only", "todo", "fails"],
     testFn
   );
+  if (context)
+    _test.mergeContext(context);
+  return _test;
 }
 function formatName(name) {
   return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
@@ -275,8 +388,8 @@ function formatTitle(template, items, idx) {
     formatted = formatted.replace(
       /\$([$\w_.]+)/g,
       (_, key) => {
-        var _a;
-        return objDisplay(objectAttr(items[0], key), (_a = runner == null ? void 0 : runner.config) == null ? void 0 : _a.chaiConfig);
+        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 });
       }
       // https://github.com/chaijs/chai/pull/1490
     );
@@ -463,18 +576,18 @@ async function runTest(test, runner) {
   const start = now();
   test.result = {
     state: "run",
-    startTime: start
+    startTime: start,
+    retryCount: 0
   };
   updateTask(test, runner);
   setCurrentTest(test);
-  const repeats = typeof test.repeats === "number" ? test.repeats : 1;
-  for (let repeatCount = 0; repeatCount < repeats; repeatCount++) {
-    const retry = test.retry || 1;
-    for (let retryCount = 0; retryCount < retry; retryCount++) {
+  const repeats = test.repeats ?? 0;
+  for (let repeatCount = 0; repeatCount <= repeats; repeatCount++) {
+    const retry = test.retry ?? 0;
+    for (let retryCount = 0; retryCount <= retry; retryCount++) {
       let beforeEachCleanups = [];
       try {
         await ((_c = runner.onBeforeTryTest) == null ? void 0 : _c.call(runner, test, { retry: retryCount, repeats: repeatCount }));
-        test.result.retryCount = retryCount;
         test.result.repeatCount = repeatCount;
         beforeEachCleanups = await callSuiteHook(test.suite, test, "beforeEach", runner, [test.context, test.suite]);
         if (runner.runTest) {
@@ -509,8 +622,9 @@ async function runTest(test, runner) {
       }
       if (test.result.state === "pass")
         break;
-      if (retryCount < retry - 1) {
+      if (retryCount < retry) {
         test.result.state = "run";
+        test.result.retryCount = (test.result.retryCount ?? 0) + 1;
       }
       updateTask(test, runner);
     }

package/dist/{tasks-045d21eb.d.ts → tasks-f541c18c.d.ts}

@@ -5,9 +5,9 @@ type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> =
 } & {
     [x in T]: ChainableFunction<T, Args, R, E>;
 } & {
-    fn: (this: Record<T, boolean | undefined>, ...args: Args) => R;
+    fn: (this: Record<T, any>, ...args: Args) => R;
 } & E;
-declare function createChainable<T extends string, Args extends any[], R = any, E = {}>(keys: T[], fn: (this: Record<T, boolean | undefined>, ...args: Args) => R): ChainableFunction<T, Args, R, E>;
+declare function createChainable<T extends string, Args extends any[], R = any, E = {}>(keys: T[], fn: (this: Record<T, any>, ...args: Args) => R): ChainableFunction<T, Args, R, E>;
 
 type RunMode = 'run' | 'skip' | 'only' | 'todo';
 type TaskState = RunMode | 'pass' | 'fail';
@@ -113,15 +113,14 @@ interface TestOptions {
      * Times to retry the test if fails. Useful for making flaky tests more stable.
      * When retries is up, the last test error will be thrown.
      *
-     * @default 1
+     * @default 0
      */
     retry?: number;
     /**
      * How many times the test will run.
      * Only inner tests will repeat if set on `describe()`, nested `describe()` will inherit parent's repeat by default.
      *
-     * @default 1
-     *
+     * @default 0
      */
     repeats?: number;
 }
@@ -129,6 +128,14 @@ type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
     each: TestEachFunction;
     skipIf(condition: any): ChainableTestAPI<ExtraContext>;
     runIf(condition: any): ChainableTestAPI<ExtraContext>;
+    extend<T extends Record<string, any> = {}>(fixtures: Fixtures<T, ExtraContext>): TestAPI<{
+        [K in keyof T | keyof ExtraContext]: K extends keyof T ? T[K] : K extends keyof ExtraContext ? ExtraContext[K] : never;
+    }>;
+};
+type Fixtures<T extends Record<string, any>, ExtraContext = {}> = {
+    [K in keyof T]: T[K] | ((context: {
+        [P in keyof T | keyof ExtraContext as P extends K ? P extends keyof ExtraContext ? P : never : P]: K extends P ? K extends keyof ExtraContext ? ExtraContext[K] : never : P extends keyof T ? T[P] : never;
+    } & TestContext, use: (fixture: T[K]) => Promise<void>) => Promise<void>);
 };
 type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'shuffle', [
     name: string | Function,
@@ -188,4 +195,4 @@ type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
 type SequenceHooks = 'stack' | 'list' | 'parallel';
 type SequenceSetupFiles = 'list' | 'parallel';
 
-export { ChainableFunction as C, DoneCallback as D, File as F, HookListener as H, OnTestFailedHandler as O, RunMode as R, SuiteAPI as S, Task as T, TestAPI as a, SuiteCollector as b, SuiteHooks as c, Test as d, TaskState as e, TaskBase as f, TaskMeta as g, TaskCustom as h, TaskResult as i, TaskResultPack as j, Suite as k, TestFunction as l, TestOptions as m, HookCleanupCallback as n, SuiteFactory as o, RuntimeContext as p, TestContext as q, SequenceHooks as r, SequenceSetupFiles as s, createChainable as t };
+export { ChainableFunction as C, DoneCallback as D, File as F, HookListener as H, OnTestFailedHandler as O, RunMode as R, Suite as S, Task as T, Test as a, TaskCustom as b, createChainable as c, SuiteAPI as d, TestAPI as e, SuiteCollector as f, SuiteHooks as g, TaskState as h, TaskBase as i, TaskMeta as j, TaskResult as k, TaskResultPack as l, TestFunction as m, TestOptions as n, Fixtures as o, HookCleanupCallback as p, SuiteFactory as q, RuntimeContext as r, TestContext as s, SequenceHooks as t, SequenceSetupFiles as u };

package/dist/types.d.ts

@@ -1,3 +1,114 @@
-export { D as DoneCallback, F as File, n as HookCleanupCallback, H as HookListener, O as OnTestFailedHandler, R as RunMode, p as RuntimeContext, r as SequenceHooks, s as SequenceSetupFiles, k as Suite, S as SuiteAPI, b as SuiteCollector, o as SuiteFactory, c as SuiteHooks, T as Task, f as TaskBase, h as TaskCustom, g as TaskMeta, i as TaskResult, j as TaskResultPack, e as TaskState, d as Test, a as TestAPI, q as TestContext, l as TestFunction, m as TestOptions } from './tasks-045d21eb.js';
-export { C as CancelReason, V as VitestRunner, a as VitestRunnerConfig, c as VitestRunnerConstructor, b as VitestRunnerImportSource } from './runner-0b317aff.js';
+import { t as SequenceHooks, u as SequenceSetupFiles, F as File, a as Test, S as Suite, l as TaskResultPack, s as TestContext } from './tasks-f541c18c.js';
+export { D as DoneCallback, o as Fixtures, p as HookCleanupCallback, H as HookListener, O as OnTestFailedHandler, R as RunMode, r as RuntimeContext, d as SuiteAPI, f as SuiteCollector, q as SuiteFactory, g as SuiteHooks, T as Task, i as TaskBase, b as TaskCustom, j as TaskMeta, k as TaskResult, h as TaskState, e as TestAPI, m as TestFunction, n as TestOptions } from './tasks-f541c18c.js';
 import '@vitest/utils';
+
+interface VitestRunnerConfig {
+    root: string;
+    setupFiles: string[] | string;
+    name: string;
+    passWithNoTests: boolean;
+    testNamePattern?: RegExp;
+    allowOnly?: boolean;
+    sequence: {
+        shuffle?: boolean;
+        concurrent?: boolean;
+        seed: number;
+        hooks: SequenceHooks;
+        setupFiles: SequenceSetupFiles;
+    };
+    chaiConfig?: {
+        truncateThreshold?: number;
+    };
+    maxConcurrency: number;
+    testTimeout: number;
+    hookTimeout: number;
+    retry: number;
+}
+type VitestRunnerImportSource = 'collect' | 'setup';
+interface VitestRunnerConstructor {
+    new (config: VitestRunnerConfig): VitestRunner;
+}
+type CancelReason = 'keyboard-input' | 'test-failure' | string & {};
+interface VitestRunner {
+    /**
+     * First thing that's getting called before actually collecting and running tests.
+     */
+    onBeforeCollect?(paths: string[]): unknown;
+    /**
+     * Called after collecting tests and before "onBeforeRun".
+     */
+    onCollected?(files: File[]): unknown;
+    /**
+     * Called when test runner should cancel next test runs.
+     * Runner should listen for this method and mark tests and suites as skipped in
+     * "onBeforeRunSuite" and "onBeforeRunTest" when called.
+     */
+    onCancel?(reason: CancelReason): unknown;
+    /**
+     * Called before running a single test. Doesn't have "result" yet.
+     */
+    onBeforeRunTest?(test: Test): unknown;
+    /**
+     * Called before actually running the test function. Already has "result" with "state" and "startTime".
+     */
+    onBeforeTryTest?(test: Test, options: {
+        retry: number;
+        repeats: number;
+    }): unknown;
+    /**
+     * Called after result and state are set.
+     */
+    onAfterRunTest?(test: Test): unknown;
+    /**
+     * Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
+     */
+    onAfterTryTest?(test: Test, options: {
+        retry: number;
+        repeats: number;
+    }): unknown;
+    /**
+     * Called before running a single suite. Doesn't have "result" yet.
+     */
+    onBeforeRunSuite?(suite: Suite): unknown;
+    /**
+     * Called after running a single suite. Has state and result.
+     */
+    onAfterRunSuite?(suite: Suite): unknown;
+    /**
+     * If defined, will be called instead of usual Vitest suite partition and handling.
+     * "before" and "after" hooks will not be ignored.
+     */
+    runSuite?(suite: Suite): Promise<void>;
+    /**
+     * If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
+     * "before" and "after" hooks will not be ignored.
+     */
+    runTest?(test: Test): Promise<void>;
+    /**
+     * Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
+     */
+    onTaskUpdate?(task: TaskResultPack[]): Promise<void>;
+    /**
+     * Called before running all tests in collected paths.
+     */
+    onBeforeRun?(files: File[]): unknown;
+    /**
+     * Called right after running all tests in collected paths.
+     */
+    onAfterRun?(files: File[]): unknown;
+    /**
+     * Called when new context for a test is defined. Useful, if you want to add custom properties to the context.
+     * If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
+     */
+    extendTestContext?(context: TestContext): TestContext;
+    /**
+     * Called, when files are imported. Can be called in two situations: when collecting tests and when importing setup files.
+     */
+    importFile(filepath: string, source: VitestRunnerImportSource): unknown;
+    /**
+     * Publicly available configuration.
+     */
+    config: VitestRunnerConfig;
+}
+
+export { CancelReason, File, SequenceHooks, SequenceSetupFiles, Suite, TaskResultPack, Test, TestContext, VitestRunner, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { k as Suite, T as Task, d as Test, h as TaskCustom } from './tasks-045d21eb.js';
-export { C as ChainableFunction, t as createChainable } from './tasks-045d21eb.js';
+import { S as Suite, T as Task, a as Test, b as TaskCustom } from './tasks-f541c18c.js';
+export { C as ChainableFunction, c as createChainable } from './tasks-f541c18c.js';
 import { Arrayable } from '@vitest/utils';
 
 /**

package/dist/utils.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "0.32.1",
+  "version": "0.32.3",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -38,10 +38,9 @@
     "*.d.ts"
   ],
   "dependencies": {
-    "concordance": "^5.0.4",
     "p-limit": "^4.0.0",
-    "pathe": "^1.1.0",
-    "@vitest/utils": "0.32.1"
+    "pathe": "^1.1.1",
+    "@vitest/utils": "0.32.3"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",

package/dist/chunk-tasks.js

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

package/dist/runner-0b317aff.d.ts

@@ -1,110 +0,0 @@
-import { r as SequenceHooks, s as SequenceSetupFiles, F as File, d as Test, k as Suite, j as TaskResultPack, q as TestContext } from './tasks-045d21eb.js';
-
-interface VitestRunnerConfig {
-    root: string;
-    setupFiles: string[] | string;
-    name: string;
-    passWithNoTests: boolean;
-    testNamePattern?: RegExp;
-    allowOnly?: boolean;
-    sequence: {
-        shuffle?: boolean;
-        seed: number;
-        hooks: SequenceHooks;
-        setupFiles: SequenceSetupFiles;
-    };
-    chaiConfig?: {
-        truncateThreshold?: number;
-    };
-    maxConcurrency: number;
-    testTimeout: number;
-    hookTimeout: number;
-}
-type VitestRunnerImportSource = 'collect' | 'setup';
-interface VitestRunnerConstructor {
-    new (config: VitestRunnerConfig): VitestRunner;
-}
-type CancelReason = 'keyboard-input' | 'test-failure' | string & {};
-interface VitestRunner {
-    /**
-     * First thing that's getting called before actually collecting and running tests.
-     */
-    onBeforeCollect?(paths: string[]): unknown;
-    /**
-     * Called after collecting tests and before "onBeforeRun".
-     */
-    onCollected?(files: File[]): unknown;
-    /**
-     * Called when test runner should cancel next test runs.
-     * Runner should listen for this method and mark tests and suites as skipped in
-     * "onBeforeRunSuite" and "onBeforeRunTest" when called.
-     */
-    onCancel?(reason: CancelReason): unknown;
-    /**
-     * Called before running a single test. Doesn't have "result" yet.
-     */
-    onBeforeRunTest?(test: Test): unknown;
-    /**
-     * Called before actually running the test function. Already has "result" with "state" and "startTime".
-     */
-    onBeforeTryTest?(test: Test, options: {
-        retry: number;
-        repeats: number;
-    }): unknown;
-    /**
-     * Called after result and state are set.
-     */
-    onAfterRunTest?(test: Test): unknown;
-    /**
-     * Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
-     */
-    onAfterTryTest?(test: Test, options: {
-        retry: number;
-        repeats: number;
-    }): unknown;
-    /**
-     * Called before running a single suite. Doesn't have "result" yet.
-     */
-    onBeforeRunSuite?(suite: Suite): unknown;
-    /**
-     * Called after running a single suite. Has state and result.
-     */
-    onAfterRunSuite?(suite: Suite): unknown;
-    /**
-     * If defined, will be called instead of usual Vitest suite partition and handling.
-     * "before" and "after" hooks will not be ignored.
-     */
-    runSuite?(suite: Suite): Promise<void>;
-    /**
-     * If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
-     * "before" and "after" hooks will not be ignored.
-     */
-    runTest?(test: Test): Promise<void>;
-    /**
-     * Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
-     */
-    onTaskUpdate?(task: TaskResultPack[]): Promise<void>;
-    /**
-     * Called before running all tests in collected paths.
-     */
-    onBeforeRun?(files: File[]): unknown;
-    /**
-     * Called right after running all tests in collected paths.
-     */
-    onAfterRun?(files: File[]): unknown;
-    /**
-     * Called when new context for a test is defined. Useful, if you want to add custom properties to the context.
-     * If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
-     */
-    extendTestContext?(context: TestContext): TestContext;
-    /**
-     * Called, when files are imported. Can be called in two situations: when collecting tests and when importing setup files.
-     */
-    importFile(filepath: string, source: VitestRunnerImportSource): unknown;
-    /**
-     * Publicly available configuration.
-     */
-    config: VitestRunnerConfig;
-}
-
-export { CancelReason as C, VitestRunner as V, VitestRunnerConfig as a, VitestRunnerImportSource as b, VitestRunnerConstructor as c };