vitest 2.1.1 → 2.1.2

package/dist/chunks/index.mAqbj9F9.js

@@ -0,0 +1,140 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import { b as bench } from './benchmark.C8CRJYG4.js';
+import { i as isFirstRun, a as runOnce } from './run-once.Sxe67Wng.js';
+import { c as createExpect, a as globalExpect, v as vi, b as vitest } from './vi.DUs2eKik.js';
+import { g as getWorkerState } from './utils.Ck2hJTRs.js';
+import * as chai from 'chai';
+import { assert, should } from 'chai';
+
+var dist = {};
+
+var hasRequiredDist;
+
+function requireDist () {
+	if (hasRequiredDist) return dist;
+	hasRequiredDist = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.expectTypeOf = void 0;
+		const fn = () => true;
+		/**
+		 * Similar to Jest's `expect`, but with type-awareness.
+		 * Gives you access to a number of type-matchers that let you make assertions about the
+		 * form of a reference or generic type parameter.
+		 *
+		 * @example
+		 * import {foo, bar} from '../foo'
+		 * import {expectTypeOf} from 'expect-type'
+		 *
+		 * test('foo types', () => {
+		 *   // make sure `foo` has type {a: number}
+		 *   expectTypeOf(foo).toMatchTypeOf({a: 1})
+		 *   expectTypeOf(foo).toHaveProperty('a').toBeNumber()
+		 *
+		 *   // make sure `bar` is a function taking a string:
+		 *   expectTypeOf(bar).parameter(0).toBeString()
+		 *   expectTypeOf(bar).returns.not.toBeAny()
+		 * })
+		 *
+		 * @description
+		 * See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples.
+		 */
+		const expectTypeOf = (_actual) => {
+		    const nonFunctionProperties = [
+		        'parameters',
+		        'returns',
+		        'resolves',
+		        'not',
+		        'items',
+		        'constructorParameters',
+		        'thisParameter',
+		        'instance',
+		        'guards',
+		        'asserts',
+		        'branded',
+		    ];
+		    const obj = {
+		        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+		        toBeAny: fn,
+		        toBeUnknown: fn,
+		        toBeNever: fn,
+		        toBeFunction: fn,
+		        toBeObject: fn,
+		        toBeArray: fn,
+		        toBeString: fn,
+		        toBeNumber: fn,
+		        toBeBoolean: fn,
+		        toBeVoid: fn,
+		        toBeSymbol: fn,
+		        toBeNull: fn,
+		        toBeUndefined: fn,
+		        toBeNullable: fn,
+		        toMatchTypeOf: fn,
+		        toEqualTypeOf: fn,
+		        toBeCallableWith: fn,
+		        toBeConstructibleWith: fn,
+		        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+		        extract: exports.expectTypeOf,
+		        exclude: exports.expectTypeOf,
+		        pick: exports.expectTypeOf,
+		        omit: exports.expectTypeOf,
+		        toHaveProperty: exports.expectTypeOf,
+		        parameter: exports.expectTypeOf,
+		    };
+		    const getterProperties = nonFunctionProperties;
+		    getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
+		    return obj;
+		};
+		exports.expectTypeOf = expectTypeOf; 
+	} (dist));
+	return dist;
+}
+
+var distExports = requireDist();
+
+function noop() {
+}
+const assertType = noop;
+
+function getRunningMode() {
+  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
+}
+function isWatchMode() {
+  return getRunningMode() === "watch";
+}
+
+function inject(key) {
+  const workerState = getWorkerState();
+  return workerState.providedContext[key];
+}
+
+var VitestIndex = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    afterAll: afterAll,
+    afterEach: afterEach,
+    assert: assert,
+    assertType: assertType,
+    beforeAll: beforeAll,
+    beforeEach: beforeEach,
+    bench: bench,
+    chai: chai,
+    createExpect: createExpect,
+    describe: describe,
+    expect: globalExpect,
+    expectTypeOf: distExports.expectTypeOf,
+    getRunningMode: getRunningMode,
+    inject: inject,
+    isFirstRun: isFirstRun,
+    isWatchMode: isWatchMode,
+    it: it,
+    onTestFailed: onTestFailed,
+    onTestFinished: onTestFinished,
+    runOnce: runOnce,
+    should: should,
+    suite: suite,
+    test: test,
+    vi: vi,
+    vitest: vitest
+});
+
+export { VitestIndex as V, assertType as a, inject as b, distExports as d, getRunningMode as g, isWatchMode as i };

package/dist/chunks/{reporters.WnPwkmgA.d.ts → reporters.DAfKSDh5.d.ts}

@@ -3,10 +3,10 @@ import { File, Test, Suite, TaskResultPack, Task, CancelReason, Custom, TaskMeta
 import * as vite from 'vite';
 import { ViteDevServer, TransformResult as TransformResult$1, ServerOptions, DepOptimizationConfig, AliasOptions, UserConfig as UserConfig$1, ConfigEnv } from 'vite';
 import { PrettyFormatOptions } from '@vitest/pretty-format';
-import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.CHuotKvS.js';
+import { S as SerializedConfig, F as FakeTimerInstallOpts } from './config.Crbj2GAb.js';
 import { RawSourceMap, ViteNodeServerOptions } from 'vite-node';
 import { SnapshotSummary, SnapshotStateOptions } from '@vitest/snapshot';
-import { b as Awaitable, P as ProvidedContext, U as UserConsoleLog, A as AfterSuiteRunMeta, c as Arrayable, d as ArgumentsType, O as OnServerRestartHandler, f as EnvironmentOptions } from './environment.C5eAp3K6.js';
+import { b as Awaitable, P as ProvidedContext, U as UserConsoleLog, A as AfterSuiteRunMeta, c as Arrayable, d as ArgumentsType, O as OnServerRestartHandler, f as EnvironmentOptions } from './environment.CzISCQ7o.js';
 import { Writable } from 'node:stream';
 import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
@@ -15,7 +15,7 @@ import { ParsedStack, Awaitable as Awaitable$1, ErrorWithDiff, TestError, Arraya
 import { StackTraceParserOptions } from '@vitest/utils/source-map';
 import { Stats } from 'node:fs';
 import * as chai from 'chai';
-import { B as BenchmarkResult } from './benchmark.puBFxyfE.js';
+import { B as BenchmarkResult } from './benchmark.JVlTzojj.js';
 
 type BuiltinPool = 'browser' | 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript';
 type Pool = BuiltinPool | (string & {});
@@ -774,7 +774,7 @@ declare class ReportedTaskImplementation {
     /**
      * Creates a new reported task instance and stores it in the project's state for future use.
      */
-    static register(task: Task, project: WorkspaceProject): TestCase | TestSuite | TestModule;
+    static register(task: Task, project: WorkspaceProject): TestModule | TestCase | TestSuite;
 }
 declare class TestCase extends ReportedTaskImplementation {
     #private;
@@ -1006,7 +1006,7 @@ declare class StateManager {
     taskFileMap: WeakMap<Task, File>;
     errorsSet: Set<unknown>;
     processTimeoutCauses: Set<string>;
-    reportedTasksMap: WeakMap<Task, TestCase | TestSuite | TestModule>;
+    reportedTasksMap: WeakMap<Task, TestModule | TestCase | TestSuite>;
     catchError(err: unknown, type: string): void;
     clearErrors(): void;
     getUnhandledErrors(): unknown[];
@@ -1023,7 +1023,7 @@ declare class StateManager {
     collectFiles(project: WorkspaceProject, files?: File[]): void;
     clearFiles(project: WorkspaceProject, paths?: string[]): void;
     updateId(task: Task, project: WorkspaceProject): void;
-    getReportedEntity(task: Task): TestCase | TestSuite | TestModule | undefined;
+    getReportedEntity(task: Task): TestModule | TestCase | TestSuite | undefined;
     updateTasks(packs: TaskResultPack[]): void;
     updateUserLog(log: UserConsoleLog): void;
     getCountOfFailedTests(): number;
@@ -1071,7 +1071,7 @@ declare class VitestCache {
 }
 
 declare class VitestPackageInstaller {
-    ensureInstalled(dependency: string, root: string): Promise<boolean>;
+    ensureInstalled(dependency: string, root: string, version?: string): Promise<boolean>;
 }
 
 interface Node {
@@ -1161,6 +1161,8 @@ interface CoverageProvider {
     clean: (clean?: boolean) => void | Promise<void>;
     /** Called with coverage results after a single test file has been run */
     onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void | Promise<void>;
+    /** Callback called when test run fails */
+    onTestFailure?: () => void | Promise<void>;
     /** Callback to generate final coverage results */
     generateCoverage: (reportContext: ReportContext) => CoverageResults | Promise<CoverageResults>;
     /** Callback to convert coverage results to coverage reports. Called with results returned from `generateCoverage` */
@@ -1777,10 +1779,8 @@ declare class TableReporter extends BaseReporter {
 interface FlatBenchmarkReport {
     [id: string]: FormattedBenchmarkResult;
 }
-type FormattedBenchmarkResult = Omit<BenchmarkResult, 'samples'> & {
+type FormattedBenchmarkResult = BenchmarkResult & {
     id: string;
-    sampleCount: number;
-    median: number;
 };
 
 declare const BenchmarkReportsMap: {
@@ -1867,8 +1867,7 @@ interface BenchmarkUserOptions {
      */
     reporters?: Arrayable$1<BenchmarkBuiltinReporters | Reporter>;
     /**
-     * Write test results to a file when the `--reporter=json` option is also specified.
-     * Also definable individually per reporter by using an object instead.
+     * @deprecated Use `benchmark.outputJson` instead
      */
     outputFile?: string | (Partial<Record<BenchmarkBuiltinReporters, string>> & Record<string, string>);
     /**
@@ -1879,6 +1878,12 @@ interface BenchmarkUserOptions {
      * benchmark output file
      */
     outputJson?: string;
+    /**
+     * Include `samples` array of benchmark results for API or custom reporter usages.
+     * This is disabled by default to reduce memory usage.
+     * @default false
+     */
+    includeSamples?: boolean;
 }
 
 type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';