vitest 2.1.1 → 2.1.3

package/dist/chunks/{vite.D2yAwzwa.d.ts → vite.YH7MrecS.d.ts}

@@ -1,4 +1,4 @@
-import { I as InlineConfig } from './reporters.WnPwkmgA.js';
+import { I as InlineConfig } from './reporters.C4ZHgdxQ.js';
 
 type VitestInlineConfig = InlineConfig;
 declare module 'vite' {

package/dist/chunks/{vm.CPXwWp4C.js → vm.DB_hLchi.js}

@@ -1,7 +1,7 @@
 import vm, { isContext } from 'node:vm';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, basename, extname, normalize, join, resolve } from 'pathe';
-import { createCustomConsole } from './console.DI3gHgtH.js';
+import { createCustomConsole } from './console.CfT1Wjed.js';
 import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute._eQQfgI8.js';
 import { distDir } from '../path.js';
 import { dirname as dirname$1 } from 'node:path';

package/dist/chunks/{worker.CmPmTxgH.d.ts → worker.B6RjTtbk.d.ts}

@@ -1,32 +1,8 @@
-import { FetchResult, ViteNodeResolveId, RawSourceMap, ModuleCacheMap } from 'vite-node';
+import { ViteNodeResolveId, ModuleCacheMap } from 'vite-node';
 import { File, TaskResultPack, CancelReason, Task } from '@vitest/runner';
-import { S as SerializedConfig } from './config.CHuotKvS.js';
+import { S as SerializedConfig } from './config.Crbj2GAb.js';
 import { SnapshotResult } from '@vitest/snapshot';
-import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.C5eAp3K6.js';
-
-interface RuntimeRPC {
-    fetch: (id: string, transformMode: TransformMode) => Promise<{
-        externalize?: string;
-        id?: string;
-    }>;
-    transform: (id: string, transformMode: TransformMode) => Promise<FetchResult>;
-    resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<ViteNodeResolveId | null>;
-    getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap | undefined>;
-    onFinished: (files: File[], errors?: unknown[]) => void;
-    onPathsCollected: (paths: string[]) => void;
-    onUserConsoleLog: (log: UserConsoleLog) => void;
-    onUnhandledError: (err: unknown, type: string) => void;
-    onCollected: (files: File[]) => Promise<void>;
-    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
-    onTaskUpdate: (pack: TaskResultPack[]) => Promise<void>;
-    onCancel: (reason: CancelReason) => void;
-    getCountOfFailedTests: () => number;
-    snapshotSaved: (snapshot: SnapshotResult) => void;
-    resolveSnapshotPath: (testPath: string) => string;
-}
-interface RunnerRPC {
-    onCancel: (reason: CancelReason) => void;
-}
+import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.CzISCQ7o.js';
 
 type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
 type ReturnType<T> = T extends (...args: any) => infer R ? R : never;
@@ -93,6 +69,44 @@ type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
     $functions: LocalFunctions;
 };
 
+interface RuntimeRPC {
+    fetch: (id: string, transformMode: TransformMode) => Promise<{
+        externalize?: string;
+        id?: string;
+    }>;
+    transform: (id: string, transformMode: TransformMode) => Promise<{
+        code?: string;
+    }>;
+    resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
+        external?: boolean | 'absolute' | 'relative';
+        id: string;
+        /** @deprecated */
+        meta?: Record<string, any> | null;
+        /** @deprecated */
+        moduleSideEffects?: boolean | 'no-treeshake' | null;
+        /** @deprecated */
+        syntheticNamedExports?: boolean | string | null;
+    } | null>;
+    /**
+     * @deprecated unused
+     */
+    getSourceMap: (id: string, force?: boolean) => Promise<any>;
+    onFinished: (files: File[], errors?: unknown[]) => void;
+    onPathsCollected: (paths: string[]) => void;
+    onUserConsoleLog: (log: UserConsoleLog) => void;
+    onUnhandledError: (err: unknown, type: string) => void;
+    onCollected: (files: File[]) => Promise<void>;
+    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+    onTaskUpdate: (pack: TaskResultPack[]) => Promise<void>;
+    onCancel: (reason: CancelReason) => void;
+    getCountOfFailedTests: () => number;
+    snapshotSaved: (snapshot: SnapshotResult) => void;
+    resolveSnapshotPath: (testPath: string) => string;
+}
+interface RunnerRPC {
+    onCancel: (reason: CancelReason) => void;
+}
+
 /** @deprecated unused */
 type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
@@ -129,4 +143,4 @@ interface WorkerGlobalState {
     };
 }
 
-export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, WorkerGlobalState as W, BirpcReturn as a, RunnerRPC as b, ResolveIdFunction as c, WorkerRPC as d, ContextTestEnvironment as e };
+export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, WorkerGlobalState as W, BirpcReturn as a, WorkerRPC as b, RunnerRPC as c, ResolveIdFunction as d, ContextTestEnvironment as e };

package/dist/chunks/{worker.Bws9Zuxu.d.ts → worker.CcJLfX8w.d.ts}

@@ -1,5 +1,5 @@
 import { MessagePort } from 'node:worker_threads';
-import { C as ContextRPC } from './worker.CmPmTxgH.js';
+import { C as ContextRPC } from './worker.B6RjTtbk.js';
 
 interface WorkerContext extends ContextRPC {
     port: MessagePort;

package/dist/cli.js

@@ -1,8 +1,8 @@
-import { c as createCLI } from './chunks/cac.BVmpoFAv.js';
+import { c as createCLI } from './chunks/cac.BSMVokHR.js';
 import 'pathe';
 import 'events';
 import 'tinyrainbow';
-import './chunks/base.BlXpj3e_.js';
+import './chunks/base.DwXGwWst.js';
 import '@vitest/utils';
 import './chunks/constants.fzPh7AOq.js';
 

package/dist/config.cjs

@@ -68,7 +68,8 @@ const coverageConfigDefaults = {
     ".jsx",
     ".vue",
     ".svelte",
-    ".marko"
+    ".marko",
+    ".astro"
   ],
   allowExternal: false,
   excludeAfterRemap: false,

package/dist/config.d.ts

@@ -1,14 +1,14 @@
-import './chunks/vite.D2yAwzwa.js';
-import { ConfigEnv, UserConfig } from 'vite';
-export { ConfigEnv, Plugin, UserConfig, mergeConfig } from 'vite';
-import { R as ResolvedCoverageOptions, b as CoverageV8Options, U as UserWorkspaceConfig, c as UserProjectConfigFn, d as UserProjectConfigExport, W as WorkspaceProjectConfiguration } from './chunks/reporters.WnPwkmgA.js';
+import './chunks/vite.YH7MrecS.js';
+import { UserConfig as UserConfig$1, ConfigEnv } from 'vite';
+export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
+import { R as ResolvedCoverageOptions, c as CoverageV8Options, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport, W as WorkspaceProjectConfiguration } from './chunks/reporters.C4ZHgdxQ.js';
 import '@vitest/runner';
 import '@vitest/pretty-format';
-import './chunks/config.CHuotKvS.js';
+import './chunks/config.Crbj2GAb.js';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
 import 'vite-node';
-import './chunks/environment.C5eAp3K6.js';
+import './chunks/environment.CzISCQ7o.js';
 import 'node:stream';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
@@ -17,7 +17,7 @@ import '@vitest/utils';
 import '@vitest/utils/source-map';
 import 'node:fs';
 import 'chai';
-import './chunks/benchmark.puBFxyfE.js';
+import './chunks/benchmark.JVlTzojj.js';
 import '@vitest/runner/utils';
 import 'tinybench';
 
@@ -71,12 +71,17 @@ declare const configDefaults: Readonly<{
     disableConsoleIntercept: false;
 }>;
 
-type UserConfigFnObject = (env: ConfigEnv) => UserConfig;
-type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>;
-type UserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
-type UserConfigExport = UserConfig | Promise<UserConfig> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
-declare function defineConfig(config: UserConfig): UserConfig;
-declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+/**
+ * @deprecated Use `ViteUserConfig` instead
+ */
+type UserConfig = UserConfig$1;
+
+type UserConfigFnObject = (env: ConfigEnv) => UserConfig$1;
+type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig$1>;
+type UserConfigFn = (env: ConfigEnv) => UserConfig$1 | Promise<UserConfig$1>;
+type UserConfigExport = UserConfig$1 | Promise<UserConfig$1> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
+declare function defineConfig(config: UserConfig$1): UserConfig$1;
+declare function defineConfig(config: Promise<UserConfig$1>): Promise<UserConfig$1>;
 declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
 declare function defineConfig(config: UserConfigExport): UserConfigExport;
 declare function defineProject(config: UserWorkspaceConfig): UserWorkspaceConfig;
@@ -85,4 +90,4 @@ declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn
 declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
 declare function defineWorkspace(config: WorkspaceProjectConfiguration[]): WorkspaceProjectConfiguration[];
 
-export { type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, WorkspaceProjectConfiguration, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };
+export { type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, WorkspaceProjectConfiguration, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };

package/dist/config.js

@@ -66,7 +66,8 @@ const coverageConfigDefaults = {
     ".jsx",
     ".vue",
     ".svelte",
-    ".marko"
+    ".marko",
+    ".astro"
   ],
   allowExternal: false,
   excludeAfterRemap: false,

package/dist/coverage.d.ts

@@ -1,12 +1,12 @@
 import * as vite from 'vite';
-import { B as BaseCoverageOptions, R as ResolvedCoverageOptions, V as Vitest } from './chunks/reporters.WnPwkmgA.js';
+import { A as AfterSuiteRunMeta } from './chunks/environment.CzISCQ7o.js';
+import { R as ResolvedCoverageOptions, V as Vitest, a as ReportContext } from './chunks/reporters.C4ZHgdxQ.js';
 import '@vitest/runner';
 import '@vitest/pretty-format';
-import './chunks/config.CHuotKvS.js';
+import './chunks/config.Crbj2GAb.js';
 import '@vitest/snapshot';
 import '@vitest/snapshot/environment';
 import 'vite-node';
-import './chunks/environment.C5eAp3K6.js';
 import 'node:stream';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
@@ -15,7 +15,7 @@ import '@vitest/utils';
 import '@vitest/utils/source-map';
 import 'node:fs';
 import 'chai';
-import './chunks/benchmark.puBFxyfE.js';
+import './chunks/benchmark.JVlTzojj.js';
 import '@vitest/runner/utils';
 import 'tinybench';
 
@@ -129,39 +129,76 @@ interface ResolvedThreshold {
     name: string;
     thresholds: Partial<Record<Threshold, number | undefined>>;
 }
-declare class BaseCoverageProvider {
-    /**
-     * Check if current coverage is above configured thresholds and bump the thresholds if needed
-     */
-    updateThresholds({ thresholds: allThresholds, perFile, configurationFile, onUpdate, }: {
-        thresholds: ResolvedThreshold[];
-        perFile?: boolean;
-        configurationFile: unknown;
-        onUpdate: () => void;
-    }): void;
-    /**
-     * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
-     */
-    checkThresholds({ thresholds: allThresholds, perFile, onError, }: {
-        thresholds: ResolvedThreshold[];
-        perFile?: boolean;
-        onError: (error: string) => void;
-    }): void;
+/**
+ * Holds info about raw coverage results that are stored on file system:
+ *
+ * ```json
+ * "project-a": {
+ *   "web": {
+ *     "tests/math.test.ts": "coverage-1.json",
+ *     "tests/utils.test.ts": "coverage-2.json",
+ * //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
+ *   },
+ *   "ssr": { ... },
+ *   "browser": { ... },
+ * },
+ * "project-b": ...
+ * ```
+ */
+type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta['projectName']> | symbol, Record<AfterSuiteRunMeta['transformMode'], {
+    [TestFilenames: string]: string;
+}>>;
+declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istanbul' | 'v8'>> {
+    ctx: Vitest;
+    readonly name: 'v8' | 'istanbul';
+    version: string;
+    options: Options;
+    coverageFiles: CoverageFiles;
+    pendingPromises: Promise<void>[];
+    coverageFilesDirectory: string;
+    _initialize(ctx: Vitest): void;
+    createCoverageMap(): CoverageMap;
+    generateReports(_: CoverageMap, __: boolean | undefined): Promise<void>;
+    parseConfigModule(_: string): Promise<{
+        generate: () => {
+            code: string;
+        };
+    }>;
+    resolveOptions(): Options;
+    clean(clean?: boolean): Promise<void>;
+    onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+    readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
+        /** Callback invoked with a single coverage result */
+        onFileRead: (data: CoverageType) => void;
+        /** Callback invoked once all results of a project for specific transform mode are read */
+        onFinished: (project: Vitest['projects'][number], transformMode: AfterSuiteRunMeta['transformMode']) => Promise<void>;
+        onDebug: ((...logs: any[]) => void) & {
+            enabled: boolean;
+        };
+    }): Promise<void>;
+    cleanAfterRun(): Promise<void>;
+    onTestFailure(): Promise<void>;
+    reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
+    reportThresholds(coverageMap: CoverageMap, allTestsRun: boolean | undefined): Promise<void>;
     /**
      * Constructs collected coverage and users' threshold options into separate sets
      * where each threshold set holds their own coverage maps. Threshold set is either
      * for specific files defined by glob pattern or global for all other files.
      */
-    resolveThresholds({ coverageMap, thresholds, createCoverageMap, root, }: {
-        coverageMap: CoverageMap;
-        thresholds: NonNullable<BaseCoverageOptions['thresholds']>;
-        createCoverageMap: () => CoverageMap;
-        root: string;
-    }): ResolvedThreshold[];
+    private resolveThresholds;
+    /**
+     * Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+     */
+    private checkThresholds;
     /**
-     * Resolve reporters from various configuration options
+     * Check if current coverage is above configured thresholds and bump the thresholds if needed
      */
-    resolveReporters(configReporters: NonNullable<BaseCoverageOptions['reporter']>): ResolvedCoverageOptions['reporter'];
+    updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }: {
+        thresholds: ResolvedThreshold[];
+        configurationFile: unknown;
+        onUpdate: () => void;
+    }): Promise<void>;
+    mergeReports(coverageMaps: unknown[]): Promise<void>;
     hasTerminalReporter(reporters: ResolvedCoverageOptions['reporter']): boolean;
     toSlices<T>(array: T[], size: number): T[][];
     createUncoveredFileTransformer(ctx: Vitest): (filename: string) => Promise<vite.TransformResult | null | undefined>;