@vitest/runner 3.2.0-beta.2 → 3.2.0

package/dist/{tasks.d-hzpC0pGR.d.ts → tasks.d-CkscK4of.d.ts}

@@ -3,6 +3,7 @@ import { ErrorWithDiff, Awaitable } from '@vitest/utils';
 interface FixtureItem extends FixtureOptions {
 	prop: string;
 	value: any;
+	scope: "test" | "file" | "worker";
 	/**
 	* Indicates whether the fixture is a function
 	*/
@@ -156,16 +157,24 @@ interface TaskResult {
 	* `repeats` option is set. This number also contains `retryCount`.
 	*/
 	repeatCount?: number;
-	/** @private */
-	note?: string;
+}
+/** The time spent importing & executing a non-externalized file. */
+interface ImportDuration {
+	/** The time spent importing & executing the file itself, not counting all non-externalized imports that the file does. */
+	selfTime: number;
+	/** The time spent importing & executing the file and all its imports. */
+	totalTime: number;
 }
 /**
 * The tuple representing a single task update.
 * Usually reported after the task finishes.
 */
 type TaskResultPack = [id: string, result: TaskResult | undefined, meta: TaskMeta];
-type TaskEventPack = [id: string, event: TaskUpdateEvent];
-type TaskUpdateEvent = "test-failed-early" | "suite-failed-early" | "test-prepare" | "test-finished" | "test-retried" | "suite-prepare" | "suite-finished" | "before-hook-start" | "before-hook-end" | "after-hook-start" | "after-hook-end";
+interface TaskEventData {
+	annotation?: TestAnnotation | undefined;
+}
+type TaskEventPack = [id: string, event: TaskUpdateEvent, data: TaskEventData | undefined];
+type TaskUpdateEvent = "test-failed-early" | "suite-failed-early" | "test-prepare" | "test-finished" | "test-retried" | "suite-prepare" | "suite-finished" | "before-hook-start" | "before-hook-end" | "after-hook-start" | "after-hook-end" | "test-annotation";
 interface Suite extends TaskBase {
 	type: "suite";
 	/**
@@ -200,6 +209,8 @@ interface File extends Suite {
 	* The time it took to import the setup file.
 	*/
 	setupDuration?: number;
+	/** The time spent importing every non-externalized dependency that Vitest has processed. */
+	importDurations?: Record<string, ImportDuration>;
 }
 interface Test<ExtraContext = object> extends TaskPopulated {
 	type: "test";
@@ -211,6 +222,26 @@ interface Test<ExtraContext = object> extends TaskPopulated {
 	* The test timeout in milliseconds.
 	*/
 	timeout: number;
+	/**
+	* An array of custom annotations.
+	*/
+	annotations: TestAnnotation[];
+}
+interface TestAttachment {
+	contentType?: string;
+	path?: string;
+	body?: string | Uint8Array;
+}
+interface TestAnnotationLocation {
+	line: number;
+	column: number;
+	file: string;
+}
+interface TestAnnotation {
+	message: string;
+	type: string;
+	location?: TestAnnotationLocation;
+	attachment?: TestAttachment;
 }
 /**
 * @deprecated Use `Test` instead. `type: 'custom'` is not used since 2.2
@@ -222,6 +253,7 @@ type Task = Test | Suite | File;
 */
 type DoneCallback = (error?: any) => void;
 type TestFunction<ExtraContext = object> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
+// jest's ExtractEachCallbackArgs
 type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
 	1: [T[0]]
 	2: [T[0], T[1]]
@@ -257,7 +289,14 @@ interface TestForFunctionReturn<
 	(name: string | Function, options: TestCollectorOptions, fn: (args: Arg, context: Context) => Awaitable<void>): void;
 }
 interface TestForFunction<ExtraContext> {
+	// test.for([1, 2, 3])
+	// test.for([[1, 2], [3, 4, 5]])
 	<T>(cases: ReadonlyArray<T>): TestForFunctionReturn<T, TestContext & ExtraContext>;
+	// test.for`
+	//    a  |  b
+	//   {1} | {2}
+	//   {3} | {4}
+	// `
 	(strings: TemplateStringsArray, ...values: any[]): TestForFunctionReturn<any, TestContext & ExtraContext>;
 }
 interface SuiteForFunction {
@@ -339,12 +378,23 @@ type TestAPI<ExtraContext = object> = ChainableTestAPI<ExtraContext> & ExtendedA
 interface FixtureOptions {
 	/**
 	* Whether to automatically set up current fixture, even though it's not being used in tests.
+	* @default false
 	*/
 	auto?: boolean;
 	/**
 	* Indicated if the injected value from the config should be preferred over the fixture value
 	*/
 	injected?: boolean;
+	/**
+	* When should the fixture be set up.
+	* - **test**: fixture will be set up before every test
+	* - **worker**: fixture will be set up once per worker
+	* - **file**: fixture will be set up once per file
+	*
+	* **Warning:** The `vmThreads` and `vmForks` pools initiate worker fixtures once per test file.
+	* @default 'test'
+	*/
+	scope?: "test" | "worker" | "file";
 }
 type Use<T> = (value: T) => Promise<void>;
 type FixtureFn<
@@ -458,24 +508,36 @@ interface TestContext {
 	/**
 	* An [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that will be aborted if the test times out or
 	* the test run was cancelled.
+	* @see {@link https://vitest.dev/guide/test-context#signal}
 	*/
 	readonly signal: AbortSignal;
 	/**
 	* Extract hooks on test failed
+	* @see {@link https://vitest.dev/guide/test-context#ontestfailed}
 	*/
 	readonly onTestFailed: (fn: OnTestFailedHandler, timeout?: number) => void;
 	/**
 	* Extract hooks on test failed
+	* @see {@link https://vitest.dev/guide/test-context#ontestfinished}
 	*/
 	readonly onTestFinished: (fn: OnTestFinishedHandler, timeout?: number) => void;
 	/**
 	* Mark tests as skipped. All execution after this call will be skipped.
 	* This function throws an error, so make sure you are not catching it accidentally.
+	* @see {@link https://vitest.dev/guide/test-context#skip}
 	*/
 	readonly skip: {
 		(note?: string): never
 		(condition: boolean, note?: string): void
 	};
+	/**
+	* Add a test annotation that will be displayed by your reporter.
+	* @see {@link https://vitest.dev/guide/test-context#annotate}
+	*/
+	readonly annotate: {
+		(message: string, type?: string, attachment?: TestAttachment): Promise<TestAnnotation>
+		(message: string, attachment?: TestAttachment): Promise<TestAnnotation>
+	};
 }
 /**
 * Context that's always available in the test function.
@@ -493,4 +555,4 @@ type SequenceHooks = "stack" | "list" | "parallel";
 type SequenceSetupFiles = "list" | "parallel";
 
 export { createChainable as c };
-export type { AfterAllListener as A, BeforeAllListener as B, ChainableFunction as C, DoneCallback as D, ExtendedContext as E, File as F, TaskPopulated as G, HookCleanupCallback as H, InferFixturesTypes as I, TaskResult as J, TaskResultPack as K, TaskState as L, TestContext as M, TestFunction as N, OnTestFailedHandler as O, TestOptions as P, RunMode as R, Suite as S, Task as T, Use as U, Test as a, AfterEachListener as b, BeforeEachListener as d, TaskHook as e, OnTestFinishedHandler as f, Custom as g, SuiteHooks as h, TaskUpdateEvent as i, TestAPI as j, SuiteAPI as k, SuiteCollector as l, Fixture as m, FixtureFn as n, FixtureOptions as o, Fixtures as p, HookListener as q, RuntimeContext as r, SequenceHooks as s, SequenceSetupFiles as t, SuiteFactory as u, TaskBase as v, TaskContext as w, TaskCustomOptions as x, TaskEventPack as y, TaskMeta as z };
+export type { AfterAllListener as A, BeforeAllListener as B, ChainableFunction as C, DoneCallback as D, ExtendedContext as E, File as F, TaskMeta as G, HookCleanupCallback as H, ImportDuration as I, TaskPopulated as J, TaskResult as K, TaskResultPack as L, TaskState as M, TestAnnotation as N, OnTestFailedHandler as O, TestAnnotationLocation as P, TestAttachment as Q, RunMode as R, Suite as S, Task as T, TestContext as U, TestFunction as V, TestOptions as W, Use as X, Test as a, AfterEachListener as b, BeforeEachListener as d, TaskHook as e, OnTestFinishedHandler as f, Custom as g, SuiteHooks as h, TaskUpdateEvent as i, TestAPI as j, SuiteAPI as k, SuiteCollector as l, Fixture as m, FixtureFn as n, FixtureOptions as o, Fixtures as p, HookListener as q, InferFixturesTypes as r, RuntimeContext as s, SequenceHooks as t, SequenceSetupFiles as u, SuiteFactory as v, TaskBase as w, TaskContext as x, TaskCustomOptions as y, TaskEventPack as z };

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { DiffOptions } from '@vitest/utils/diff';
-import { F as File, T as Task, a as Test, S as Suite, K as TaskResultPack, y as TaskEventPack, M as TestContext, s as SequenceHooks, t as SequenceSetupFiles } from './tasks.d-hzpC0pGR.js';
-export { A as AfterAllListener, b as AfterEachListener, B as BeforeAllListener, d as BeforeEachListener, g as Custom, j as CustomAPI, D as DoneCallback, E as ExtendedContext, m as Fixture, n as FixtureFn, o as FixtureOptions, p as Fixtures, H as HookCleanupCallback, q as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, f as OnTestFinishedHandler, R as RunMode, r as RuntimeContext, k as SuiteAPI, l as SuiteCollector, u as SuiteFactory, h as SuiteHooks, v as TaskBase, w as TaskContext, x as TaskCustomOptions, e as TaskHook, z as TaskMeta, G as TaskPopulated, J as TaskResult, L as TaskState, i as TaskUpdateEvent, j as TestAPI, N as TestFunction, P as TestOptions, U as Use } from './tasks.d-hzpC0pGR.js';
+import { F as File, a as Test, S as Suite, L as TaskResultPack, z as TaskEventPack, N as TestAnnotation, U as TestContext, I as ImportDuration, t as SequenceHooks, u as SequenceSetupFiles } from './tasks.d-CkscK4of.js';
+export { A as AfterAllListener, b as AfterEachListener, B as BeforeAllListener, d as BeforeEachListener, g as Custom, j as CustomAPI, D as DoneCallback, E as ExtendedContext, m as Fixture, n as FixtureFn, o as FixtureOptions, p as Fixtures, H as HookCleanupCallback, q as HookListener, r as InferFixturesTypes, O as OnTestFailedHandler, f as OnTestFinishedHandler, R as RunMode, s as RuntimeContext, k as SuiteAPI, l as SuiteCollector, v as SuiteFactory, h as SuiteHooks, T as Task, w as TaskBase, x as TaskContext, y as TaskCustomOptions, e as TaskHook, G as TaskMeta, J as TaskPopulated, K as TaskResult, M as TaskState, i as TaskUpdateEvent, j as TestAPI, P as TestAnnotationLocation, Q as TestAttachment, V as TestFunction, W as TestOptions, X as Use } from './tasks.d-CkscK4of.js';
 import '@vitest/utils';
 
 /**
@@ -64,11 +64,11 @@ interface VitestRunner {
 	/**
 	* Called before running a single test. Doesn't have "result" yet.
 	*/
-	onBeforeRunTask?: (test: Task) => unknown;
+	onBeforeRunTask?: (test: Test) => unknown;
 	/**
 	* Called before actually running the test function. Already has "result" with "state" and "startTime".
 	*/
-	onBeforeTryTask?: (test: Task, options: {
+	onBeforeTryTask?: (test: Test, options: {
 		retry: number
 		repeats: number
 	}) => unknown;
@@ -79,11 +79,11 @@ interface VitestRunner {
 	/**
 	* Called after result and state are set.
 	*/
-	onAfterRunTask?: (test: Task) => unknown;
+	onAfterRunTask?: (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.
 	*/
-	onAfterTryTask?: (test: Task, options: {
+	onAfterTryTask?: (test: Test, options: {
 		retry: number
 		repeats: number
 	}) => unknown;
@@ -104,12 +104,16 @@ interface VitestRunner {
 	* If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
 	* "before" and "after" hooks will not be ignored.
 	*/
-	runTask?: (test: Task) => Promise<void>;
+	runTask?: (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[], events: TaskEventPack[]) => Promise<void>;
 	/**
+	* Called when annotation is added via the `context.annotate` method.
+	*/
+	onTestAnnotate?: (test: Test, annotation: TestAnnotation) => Promise<TestAnnotation>;
+	/**
 	* Called before running all tests in collected paths.
 	*/
 	onBeforeRunFiles?: (files: File[]) => unknown;
@@ -133,6 +137,10 @@ interface VitestRunner {
 	*/
 	injectValue?: (key: string) => unknown;
 	/**
+	* Gets the time spent importing each individual non-externalized file that Vitest collected.
+	*/
+	getImportDurations?: () => Record<string, ImportDuration>;
+	/**
 	* Publicly available configuration.
 	*/
 	config: VitestRunnerConfig;
@@ -140,11 +148,16 @@ interface VitestRunner {
 	* The name of the current pool. Can affect how stack trace is inferred on the server side.
 	*/
 	pool?: string;
+	/**
+	* Return the worker context for fixtures specified with `scope: 'worker'`
+	*/
+	getWorkerContext?: () => Record<string, unknown>;
+	onCleanupWorkerContext?: (cleanup: () => unknown) => void;
 	/** @private */
 	_currentTaskStartTime?: number;
 	/** @private */
 	_currentTaskTimeout?: number;
 }
 
-export { File, SequenceHooks, SequenceSetupFiles, Suite, Task, TaskEventPack, TaskResultPack, Test, TestContext };
+export { File, ImportDuration, SequenceHooks, SequenceSetupFiles, Suite, TaskEventPack, TaskResultPack, Test, TestAnnotation, TestContext };
 export type { CancelReason, FileSpecification, VitestRunner, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, F as File, T as Task, a as Test } from './tasks.d-hzpC0pGR.js';
-export { C as ChainableFunction, c as createChainable } from './tasks.d-hzpC0pGR.js';
+import { S as Suite, F as File, T as Task, a as Test } from './tasks.d-CkscK4of.js';
+export { C as ChainableFunction, c as createChainable } from './tasks.d-CkscK4of.js';
 import { Arrayable } from '@vitest/utils';
 
 /**

package/dist/utils.js

@@ -1,4 +1,5 @@
-export { a as calculateSuiteHash, c as createChainable, b as createFileTask, g as generateFileHash, d as generateHash, e as getFullName, f as getNames, h as getSuites, j as getTasks, k as getTestName, m as getTests, n as hasFailed, o as hasTests, i as interpretTaskModes, q as isAtomTest, r as isTestCase, l as limitConcurrency, p as partitionSuiteChildren, s as someTasksAreOnly } from './chunk-tasks.js';
+export { v as calculateSuiteHash, r as createChainable, w as createFileTask, x as generateFileHash, y as generateHash, D as getFullName, E as getNames, F as getSuites, G as getTasks, H as getTestName, I as getTests, J as hasFailed, K as hasTests, z as interpretTaskModes, L as isAtomTest, M as isTestCase, B as limitConcurrency, C as partitionSuiteChildren, A as someTasksAreOnly } from './chunk-hooks.js';
+import '@vitest/utils';
+import '@vitest/utils/source-map';
 import '@vitest/utils/error';
 import 'pathe';
-import '@vitest/utils';

package/package.json

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

package/dist/chunk-tasks.js

@@ -1,301 +0,0 @@
-import { processError } from '@vitest/utils/error';
-import { relative } from 'pathe';
-import { toArray } from '@vitest/utils';
-
-function createChainable(keys, fn) {
-	function create(context) {
-		const chain = function(...args) {
-			return fn.apply(context, args);
-		};
-		Object.assign(chain, fn);
-		chain.withContext = () => chain.bind(context);
-		chain.setContext = (key, value) => {
-			context[key] = value;
-		};
-		chain.mergeContext = (ctx) => {
-			Object.assign(context, ctx);
-		};
-		for (const key of keys) {
-			Object.defineProperty(chain, key, { get() {
-				return create({
-					...context,
-					[key]: true
-				});
-			} });
-		}
-		return chain;
-	}
-	const chain = create({});
-	chain.fn = fn;
-	return chain;
-}
-
-/**
-* If any tasks been marked as `only`, mark all other tasks as `skip`.
-*/
-function interpretTaskModes(file, namePattern, testLocations, onlyMode, parentIsOnly, allowOnly) {
-	const matchedLocations = [];
-	const traverseSuite = (suite, parentIsOnly, parentMatchedWithLocation) => {
-		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";
-				}
-			}
-			let hasLocationMatch = parentMatchedWithLocation;
-			if (testLocations !== undefined && testLocations.length !== 0) {
-				if (t.location && (testLocations === null || testLocations === void 0 ? void 0 : testLocations.includes(t.location.line))) {
-					t.mode = "run";
-					matchedLocations.push(t.location.line);
-					hasLocationMatch = true;
-				} else if (parentMatchedWithLocation) {
-					t.mode = "run";
-				} else if (t.type === "test") {
-					t.mode = "skip";
-				}
-			}
-			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 if (t.mode === "todo") {
-					todoAllTasks(t);
-				} else {
-					traverseSuite(t, includeTask, hasLocationMatch);
-				}
-			}
-		});
-		if (suite.mode === "run" || suite.mode === "queued") {
-			if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run" && i.mode !== "queued")) {
-				suite.mode = "skip";
-			}
-		}
-	};
-	traverseSuite(file, parentIsOnly, false);
-	const nonMatching = testLocations === null || testLocations === void 0 ? void 0 : testLocations.filter((loc) => !matchedLocations.includes(loc));
-	if (nonMatching && nonMatching.length !== 0) {
-		const message = nonMatching.length === 1 ? `line ${nonMatching[0]}` : `lines ${nonMatching.join(", ")}`;
-		if (file.result === undefined) {
-			file.result = {
-				state: "fail",
-				errors: []
-			};
-		}
-		if (file.result.errors === undefined) {
-			file.result.errors = [];
-		}
-		file.result.errors.push(processError(new Error(`No test found in ${file.name} in ${message}`)));
-	}
-}
-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 === "queued") {
-			t.mode = "skip";
-			if (t.type === "suite") {
-				skipAllTasks(t);
-			}
-		}
-	});
-}
-function todoAllTasks(suite) {
-	suite.tasks.forEach((t) => {
-		if (t.mode === "run" || t.mode === "queued") {
-			t.mode = "todo";
-			if (t.type === "suite") {
-				todoAllTasks(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",
-		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 createFileTask(filepath, root, projectName, pool) {
-	const path = relative(root, filepath);
-	const file = {
-		id: generateFileHash(path, projectName),
-		name: path,
-		type: "suite",
-		mode: "queued",
-		filepath,
-		tasks: [],
-		meta: Object.create(null),
-		projectName,
-		file: undefined,
-		pool
-	};
-	file.file = file;
-	return file;
-}
-/**
-* Generate a unique ID for a file based on its path and project name
-* @param file File relative to the root of the project to keep ID the same between different machines
-* @param projectName The name of the test project
-*/
-function generateFileHash(file, projectName) {
-	return generateHash(`${file}${projectName || ""}`);
-}
-
-/**
-* Return a function for running multiple async operations with limited concurrency.
-*/
-function limitConcurrency(concurrency = Infinity) {
-	let count = 0;
-	let head;
-	let tail;
-	const finish = () => {
-		count--;
-		if (head) {
-			head[0]();
-			head = head[1];
-			tail = head && tail;
-		}
-	};
-	return (func, ...args) => {
-		return new Promise((resolve) => {
-			if (count++ < concurrency) {
-				resolve();
-			} else if (tail) {
-				tail = tail[1] = [resolve];
-			} else {
-				head = tail = [resolve];
-			}
-		}).then(() => {
-			return func(...args);
-		}).finally(finish);
-	};
-}
-
-/**
-* Partition in tasks groups by consecutive concurrent
-*/
-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;
-}
-
-/**
-* @deprecated use `isTestCase` instead
-*/
-function isAtomTest(s) {
-	return isTestCase(s);
-}
-function isTestCase(s) {
-	return s.type === "test";
-}
-function getTests(suite) {
-	const tests = [];
-	const arraySuites = toArray(suite);
-	for (const s of arraySuites) {
-		if (isTestCase(s)) {
-			tests.push(s);
-		} else {
-			for (const task of s.tasks) {
-				if (isTestCase(task)) {
-					tests.push(task);
-				} else {
-					const taskTests = getTests(task);
-					for (const test of taskTests) {
-						tests.push(test);
-					}
-				}
-			}
-		}
-	}
-	return tests;
-}
-function getTasks(tasks = []) {
-	return toArray(tasks).flatMap((s) => isTestCase(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) => isTestCase(c) || hasTests(c)));
-}
-function hasFailed(suite) {
-	return toArray(suite).some((s) => {
-		var _s$result;
-		return ((_s$result = s.result) === null || _s$result === void 0 ? void 0 : _s$result.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
-	});
-}
-function getNames(task) {
-	const names = [task.name];
-	let current = task;
-	while (current === null || current === void 0 ? void 0 : current.suite) {
-		current = current.suite;
-		if (current === null || current === void 0 ? void 0 : current.name) {
-			names.unshift(current.name);
-		}
-	}
-	if (current !== task.file) {
-		names.unshift(task.file.name);
-	}
-	return names;
-}
-function getFullName(task, separator = " > ") {
-	return getNames(task).join(separator);
-}
-function getTestName(task, separator = " > ") {
-	return getNames(task).slice(1).join(separator);
-}
-
-export { calculateSuiteHash as a, createFileTask as b, createChainable as c, generateHash as d, getFullName as e, getNames as f, generateFileHash as g, getSuites as h, interpretTaskModes as i, getTasks as j, getTestName as k, limitConcurrency as l, getTests as m, hasFailed as n, hasTests as o, partitionSuiteChildren as p, isAtomTest as q, isTestCase as r, someTasksAreOnly as s };