@rstest/core 0.6.0 → 0.6.2

package/dist-types/index.d.ts

@@ -318,6 +318,7 @@ declare type CommonOptions = {
     coverage?: boolean;
     passWithNoTests?: boolean;
     printConsoleTrace?: boolean;
+    logHeapUsage?: boolean;
     disableConsoleIntercept?: boolean;
     update?: boolean;
     testNamePattern?: RegExp | string;
@@ -613,7 +614,7 @@ declare type DefaultReporterOptions = {
 
 /**
  * This function helps you to autocomplete configuration types.
- * It accepts a Rsbuild config object, or a function that returns a config.
+ * It accepts a Rstest config object, or a function that returns a config.
  */
 export declare function defineConfig(config: RstestConfig): RstestConfig;
 
@@ -623,6 +624,16 @@ export declare function defineConfig(config: RstestConfigAsyncFn): RstestConfigA
 
 export declare function defineConfig(config: RstestConfigExport): RstestConfigExport;
 
+/**
+ * This function helps you to autocomplete configuration types.
+ * It accepts a Rstest project config object, or a function that returns a config.
+ */
+export declare function defineProject(config: ProjectConfig): ProjectConfig;
+
+export declare function defineProject(config: ProjectConfigSyncFn): ProjectConfigSyncFn;
+
+export declare function defineProject(config: ProjectConfigAsyncFn): ProjectConfigAsyncFn;
+
 export declare const describe: Rstest['describe'];
 
 declare type DescribeAPI = DescribeFn & {
@@ -1996,7 +2007,11 @@ declare type Project = {
     configFilePath?: string;
 };
 
-export declare type ProjectConfig = Omit<RstestConfig, 'projects' | 'reporters' | 'pool' | 'isolate' | 'coverage'>;
+export declare type ProjectConfig = Omit<RstestConfig, 'projects' | 'reporters' | 'pool' | 'isolate' | 'coverage' | 'resolveSnapshotPath' | 'onConsoleLog' | 'hideSkippedTests'>;
+
+declare type ProjectConfigAsyncFn = () => Promise<ProjectConfig>;
+
+declare type ProjectConfigSyncFn = () => ProjectConfig;
 
 declare type ProjectContext = {
     name: string;
@@ -2282,6 +2297,11 @@ export declare interface RstestConfig {
      * @default 5
      */
     maxConcurrency?: number;
+    /**
+     * Log heap usage after each test
+     * @default false
+     */
+    logHeapUsage?: boolean;
     /**
      * Custom handler for console log in tests
      */
@@ -2503,7 +2523,7 @@ declare type RunnerAPI = {
     onTestFailed: (fn: OnTestFailedHandler, timeout?: number) => void;
 };
 
-declare type RuntimeConfig = Pick<RstestContext['normalizedConfig'], 'testTimeout' | 'testNamePattern' | 'globals' | 'passWithNoTests' | 'retry' | 'clearMocks' | 'resetMocks' | 'restoreMocks' | 'unstubEnvs' | 'unstubGlobals' | 'maxConcurrency' | 'printConsoleTrace' | 'disableConsoleIntercept' | 'testEnvironment' | 'isolate' | 'hookTimeout' | 'coverage' | 'snapshotFormat' | 'env'>;
+declare type RuntimeConfig = Pick<RstestContext['normalizedConfig'], 'testTimeout' | 'testNamePattern' | 'globals' | 'passWithNoTests' | 'retry' | 'clearMocks' | 'resetMocks' | 'restoreMocks' | 'unstubEnvs' | 'unstubGlobals' | 'maxConcurrency' | 'printConsoleTrace' | 'disableConsoleIntercept' | 'testEnvironment' | 'isolate' | 'hookTimeout' | 'coverage' | 'snapshotFormat' | 'env' | 'logHeapUsage'>;
 
 declare type RuntimeOptions = Partial<Pick<RuntimeConfig, 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'resetMocks' | 'restoreMocks' | 'maxConcurrency' | 'retry'>>;
 
@@ -2746,6 +2766,7 @@ declare type TestContext = {
 declare interface TestEachFn {
     <T extends Record<string, unknown>>(cases: readonly T[]): (description: string, fn?: (param: T) => MaybePromise<void>, timeout?: number) => void;
     <T extends readonly [unknown, ...unknown[]]>(cases: readonly T[]): (description: string, fn: (...args: [...T]) => MaybePromise<void>, timeout?: number) => void;
+    <T>(cases: readonly T[]): (description: string, fn: (...args: T[]) => MaybePromise<void>, timeout?: number) => void;
 }
 
 declare type Tester = (this: TesterContext, a: any, b: any, customTesters: Array<Tester>) => boolean | undefined;
@@ -2787,6 +2808,7 @@ export declare type TestResult = {
     errors?: FormattedError[];
     retryCount?: number;
     project: string;
+    heap?: number;
 };
 
 declare type TestResultStatus = 'skip' | 'pass' | 'fail' | 'todo';

package/dist-types/worker.d.ts

@@ -1664,7 +1664,7 @@ declare function printWithType<T>(name: string, value: T, print: (value: T) => s
 
 declare type Procedure = (...args: any[]) => any;
 
-declare type ProjectConfig = Omit<RstestConfig, 'projects' | 'reporters' | 'pool' | 'isolate' | 'coverage'>;
+declare type ProjectConfig = Omit<RstestConfig, 'projects' | 'reporters' | 'pool' | 'isolate' | 'coverage' | 'resolveSnapshotPath' | 'onConsoleLog' | 'hideSkippedTests'>;
 
 declare type ProjectContext = {
     name: string;
@@ -1937,6 +1937,11 @@ declare interface RstestConfig {
      * @default 5
      */
     maxConcurrency?: number;
+    /**
+     * Log heap usage after each test
+     * @default false
+     */
+    logHeapUsage?: boolean;
     /**
      * Custom handler for console log in tests
      */
@@ -2026,7 +2031,7 @@ declare type RunnerAPI = {
     onTestFailed: (fn: OnTestFailedHandler, timeout?: number) => void;
 };
 
-declare type RuntimeConfig = Pick<RstestContext['normalizedConfig'], 'testTimeout' | 'testNamePattern' | 'globals' | 'passWithNoTests' | 'retry' | 'clearMocks' | 'resetMocks' | 'restoreMocks' | 'unstubEnvs' | 'unstubGlobals' | 'maxConcurrency' | 'printConsoleTrace' | 'disableConsoleIntercept' | 'testEnvironment' | 'isolate' | 'hookTimeout' | 'coverage' | 'snapshotFormat' | 'env'>;
+declare type RuntimeConfig = Pick<RstestContext['normalizedConfig'], 'testTimeout' | 'testNamePattern' | 'globals' | 'passWithNoTests' | 'retry' | 'clearMocks' | 'resetMocks' | 'restoreMocks' | 'unstubEnvs' | 'unstubGlobals' | 'maxConcurrency' | 'printConsoleTrace' | 'disableConsoleIntercept' | 'testEnvironment' | 'isolate' | 'hookTimeout' | 'coverage' | 'snapshotFormat' | 'env' | 'logHeapUsage'>;
 
 /** Runtime to Server */
 declare type RuntimeRPC = {
@@ -2342,6 +2347,7 @@ declare type TestContext = {
 declare interface TestEachFn {
     <T extends Record<string, unknown>>(cases: readonly T[]): (description: string, fn?: (param: T) => MaybePromise<void>, timeout?: number) => void;
     <T extends readonly [unknown, ...unknown[]]>(cases: readonly T[]): (description: string, fn: (...args: [...T]) => MaybePromise<void>, timeout?: number) => void;
+    <T>(cases: readonly T[]): (description: string, fn: (...args: T[]) => MaybePromise<void>, timeout?: number) => void;
 }
 
 declare type Tester = (this: TesterContext, a: any, b: any, customTesters: Array<Tester>) => boolean | undefined;
@@ -2383,6 +2389,7 @@ declare type TestResult = {
     errors?: FormattedError[];
     retryCount?: number;
     project: string;
+    heap?: number;
 };
 
 declare type TestResultStatus = 'skip' | 'pass' | 'fail' | 'todo';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/core",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "The Rsbuild-based test tool.",
   "bugs": {
     "url": "https://github.com/web-infra-dev/rstest/issues"
@@ -59,8 +59,8 @@
     "@vitest/snapshot": "^3.2.4",
     "@babel/code-frame": "^7.27.1",
     "@jridgewell/trace-mapping": "0.3.31",
-    "@microsoft/api-extractor": "^7.53.2",
-    "@rslib/core": "0.16.0",
+    "@microsoft/api-extractor": "^7.53.3",
+    "@rslib/core": "0.17.0",
     "@sinonjs/fake-timers": "^14.0.0",
     "@types/babel__code-frame": "^7.0.6",
     "@types/istanbul-reports": "^3.0.4",

package/dist/0~33.js

@@ -1,425 +0,0 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
-export const __webpack_id__ = "33";
-export const __webpack_ids__ = [
-    "33"
-];
-export const __webpack_modules__ = {
-    "./src/core/runTests.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            runTests: ()=>runTests
-        });
-        var src_coverage = __webpack_require__("./src/coverage/index.ts");
-        var src_pool = __webpack_require__("./src/pool/index.ts");
-        var utils = __webpack_require__("./src/utils/index.ts");
-        const isCliShortcutsEnabled = ()=>(0, utils.Un)('stdin');
-        async function setupCliShortcuts({ closeServer, runAll, updateSnapshot, runFailedTests, runWithTestNamePattern, runWithFileFilters }) {
-            const { createInterface, emitKeypressEvents } = await import("node:readline");
-            const rl = createInterface({
-                input: process.stdin,
-                output: process.stdout
-            });
-            emitKeypressEvents(process.stdin);
-            process.stdin.setRawMode(true);
-            process.stdin.resume();
-            process.stdin.setEncoding('utf8');
-            let isPrompting = false;
-            const clearCurrentInputLine = ()=>{
-                try {
-                    process.stdout.write('\r\x1b[2K');
-                } catch  {}
-            };
-            const promptInput = async (promptText, onComplete)=>{
-                if (isPrompting) return;
-                isPrompting = true;
-                let buffer = '';
-                const render = ()=>{
-                    process.stdout.write(`\r\x1b[2K${promptText}${buffer}`);
-                };
-                render();
-                const onPromptKey = async (str, key)=>{
-                    if (!isPrompting) return;
-                    if (key.ctrl && 'c' === key.name) process.exit(0);
-                    if ('return' === key.name || 'enter' === key.name) {
-                        process.stdin.off('keypress', onPromptKey);
-                        process.stdout.write('\n');
-                        const value = '' === buffer.trim() ? void 0 : buffer.trim();
-                        isPrompting = false;
-                        await onComplete(value);
-                        return;
-                    }
-                    if ('escape' === key.name) {
-                        clearCurrentInputLine();
-                        process.stdin.off('keypress', onPromptKey);
-                        isPrompting = false;
-                        return;
-                    }
-                    if ('backspace' === key.name) {
-                        buffer = buffer.slice(0, -1);
-                        render();
-                        return;
-                    }
-                    if ('string' == typeof str && 1 === str.length) {
-                        buffer += str;
-                        render();
-                    }
-                };
-                process.stdin.on('keypress', onPromptKey);
-            };
-            const shortcuts = [
-                {
-                    key: 'f',
-                    description: `${utils.yW.bold('f')}  ${utils.yW.dim('rerun failed tests')}`,
-                    action: async ()=>{
-                        await runFailedTests();
-                    }
-                },
-                {
-                    key: 'a',
-                    description: `${utils.yW.bold('a')}  ${utils.yW.dim('rerun all tests')}`,
-                    action: async ()=>{
-                        await runAll();
-                    }
-                },
-                {
-                    key: 'u',
-                    description: `${utils.yW.bold('u')}  ${utils.yW.dim('update snapshot')}`,
-                    action: async ()=>{
-                        await updateSnapshot();
-                    }
-                },
-                {
-                    key: 't',
-                    description: `${utils.yW.bold('t')}  ${utils.yW.dim('filter by a test name regex pattern')}`,
-                    action: async ()=>{
-                        clearCurrentInputLine();
-                        await promptInput('Enter test name pattern (empty to clear): ', async (pattern)=>{
-                            await runWithTestNamePattern(pattern);
-                        });
-                    }
-                },
-                {
-                    key: 'p',
-                    description: `${utils.yW.bold('p')}  ${utils.yW.dim('filter by a filename regex pattern')}`,
-                    action: async ()=>{
-                        clearCurrentInputLine();
-                        await promptInput('Enter file name pattern (empty to clear): ', async (input)=>{
-                            const filters = input ? input.split(/\s+/).filter(Boolean) : void 0;
-                            await runWithFileFilters(filters);
-                        });
-                    }
-                },
-                {
-                    key: 'c',
-                    description: `${utils.yW.bold('c')}  ${utils.yW.dim('clear screen')}`,
-                    action: ()=>{
-                        (0, utils.mT)(true);
-                    }
-                },
-                {
-                    key: 'q',
-                    description: `${utils.yW.bold('q')}  ${utils.yW.dim('quit process')}`,
-                    action: async ()=>{
-                        try {
-                            await closeServer();
-                        } finally{
-                            process.exit(0);
-                        }
-                    }
-                }
-            ];
-            const handleKeypress = (str, key)=>{
-                if (isPrompting) return;
-                if (key.ctrl && 'c' === key.name) process.exit(0);
-                for (const shortcut of shortcuts)if (str === shortcut.key) {
-                    clearCurrentInputLine();
-                    shortcut.action();
-                    return;
-                }
-                if ('h' === str) {
-                    clearCurrentInputLine();
-                    let message = `  ${utils.yW.bold(utils.yW.blue('Shortcuts:'))}\n`;
-                    for (const shortcut of shortcuts)message += `  ${shortcut.description}\n`;
-                    utils.vF.log(message);
-                }
-            };
-            process.stdin.on('keypress', handleKeypress);
-            return ()=>{
-                try {
-                    process.stdin.setRawMode(false);
-                    process.stdin.pause();
-                } catch  {}
-                process.stdin.off('keypress', handleKeypress);
-                rl.close();
-            };
-        }
-        var rsbuild = __webpack_require__("./src/core/rsbuild.ts");
-        async function runTests(context) {
-            const { rootPath, reporters, projects, snapshotManager, command, normalizedConfig: { coverage } } = context;
-            const entriesCache = new Map();
-            const globTestSourceEntries = async (name)=>{
-                const { include, exclude, includeSource, root } = projects.find((p)=>p.environmentName === name).normalizedConfig;
-                const entries = await (0, utils.tG)({
-                    include,
-                    exclude: exclude.patterns,
-                    includeSource,
-                    rootPath,
-                    projectRoot: root,
-                    fileFilters: context.fileFilters || []
-                });
-                entriesCache.set(name, {
-                    entries,
-                    fileFilters: context.fileFilters
-                });
-                return entries;
-            };
-            const setupFiles = Object.fromEntries(context.projects.map((project)=>{
-                const { environmentName, rootPath, normalizedConfig: { setupFiles } } = project;
-                return [
-                    environmentName,
-                    (0, utils.pr)(setupFiles, rootPath)
-                ];
-            }));
-            const rsbuildInstance = await (0, rsbuild.zh)(context, globTestSourceEntries, setupFiles);
-            const { getRsbuildStats, closeServer } = await (0, rsbuild.XD)({
-                inspectedConfig: {
-                    ...context.normalizedConfig,
-                    projects: context.projects.map((p)=>p.normalizedConfig)
-                },
-                globTestSourceEntries: 'watch' === command ? globTestSourceEntries : async (name)=>{
-                    if (entriesCache.has(name)) return entriesCache.get(name).entries;
-                    return globTestSourceEntries(name);
-                },
-                setupFiles,
-                rsbuildInstance,
-                rootPath
-            });
-            const recommendWorkerCount = 'watch' === command ? 1 / 0 : Array.from(entriesCache.values()).reduce((acc, entry)=>acc + Object.keys(entry.entries).length, 0);
-            const pool = await (0, src_pool.b)({
-                context,
-                recommendWorkerCount
-            });
-            const coverageProvider = coverage.enabled ? await (0, src_coverage.e)(coverage, context.rootPath) : null;
-            if (coverageProvider) utils.vF.log(` ${utils.yW.gray('Coverage enabled with')} %s\n`, utils.yW.yellow(coverage.provider));
-            const run = async ({ fileFilters, mode = 'all' } = {})=>{
-                let testStart;
-                const buildStart = Date.now();
-                const currentEntries = [];
-                const currentDeletedEntries = [];
-                const returns = await Promise.all(context.projects.map(async (p)=>{
-                    const { assetNames, entries, setupEntries, getAssetFiles, getSourceMaps, affectedEntries, deletedEntries } = await getRsbuildStats({
-                        environmentName: p.environmentName,
-                        fileFilters
-                    });
-                    testStart ??= Date.now();
-                    currentDeletedEntries.push(...deletedEntries);
-                    let finalEntries = entries;
-                    if ('on-demand' === mode) {
-                        if (0 === affectedEntries.length) utils.vF.debug(utils.yW.yellow(`No test files need re-run in project(${p.environmentName}).`));
-                        else utils.vF.debug(utils.yW.yellow(`Test files to re-run in project(${p.environmentName}):\n`) + affectedEntries.map((e)=>e.testPath).join('\n') + '\n');
-                        finalEntries = affectedEntries;
-                    } else utils.vF.debug(utils.yW.yellow(fileFilters?.length ? `Run filtered tests in project(${p.environmentName}).\n` : `Run all tests in project(${p.environmentName}).\n`));
-                    currentEntries.push(...finalEntries);
-                    const { results, testResults } = await pool.runTests({
-                        entries: finalEntries,
-                        getSourceMaps,
-                        setupEntries,
-                        getAssetFiles,
-                        project: p,
-                        updateSnapshot: context.snapshotManager.options.updateSnapshot
-                    });
-                    return {
-                        results,
-                        testResults,
-                        assetNames,
-                        getSourceMaps
-                    };
-                }));
-                const buildTime = testStart - buildStart;
-                const testTime = Date.now() - testStart;
-                const duration = {
-                    totalTime: testTime + buildTime,
-                    buildTime,
-                    testTime
-                };
-                const results = returns.flatMap((r)=>r.results);
-                const testResults = returns.flatMap((r)=>r.testResults);
-                context.updateReporterResultState(results, testResults, currentDeletedEntries);
-                if (0 === results.length) {
-                    if ('watch' === command) if ('on-demand' === mode) utils.vF.log(utils.yW.yellow('No test files need re-run.'));
-                    else utils.vF.log(utils.yW.yellow('No test files found.'));
-                    else {
-                        const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
-                        utils.vF.log(utils.yW[code ? 'red' : 'yellow'](`No test files found, exiting with code ${code}.`));
-                        process.exitCode = code;
-                    }
-                    if ('all' === mode) {
-                        if (context.fileFilters?.length) utils.vF.log(utils.yW.gray('filter: '), context.fileFilters.join(utils.yW.gray(', ')));
-                        context.projects.forEach((p)=>{
-                            if (context.projects.length > 1) {
-                                utils.vF.log('');
-                                utils.vF.log(utils.yW.gray('project:'), p.name);
-                            }
-                            utils.vF.log(utils.yW.gray('include:'), p.normalizedConfig.include.join(utils.yW.gray(', ')));
-                            utils.vF.log(utils.yW.gray('exclude:'), p.normalizedConfig.exclude.patterns.join(utils.yW.gray(', ')));
-                        });
-                    }
-                }
-                const isFailure = results.some((r)=>'fail' === r.status);
-                if (isFailure) process.exitCode = 1;
-                for (const reporter of reporters)await reporter.onTestRunEnd?.({
-                    results: context.reporterResults.results,
-                    testResults: context.reporterResults.testResults,
-                    snapshotSummary: snapshotManager.summary,
-                    duration,
-                    getSourcemap: async (name)=>{
-                        const resource = returns.find((r)=>r.assetNames.includes(name));
-                        const sourceMap = (await resource?.getSourceMaps([
-                            name
-                        ]))?.[name];
-                        return sourceMap ? JSON.parse(sourceMap) : null;
-                    },
-                    filterRerunTestPaths: currentEntries.length ? currentEntries.map((e)=>e.testPath) : void 0
-                });
-                if (coverageProvider && (!isFailure || coverage.reportOnFailure)) {
-                    const { generateCoverage } = await __webpack_require__.e("204").then(__webpack_require__.bind(__webpack_require__, "./src/coverage/generate.ts"));
-                    await generateCoverage(context, results, coverageProvider);
-                }
-            };
-            if ('watch' === command) {
-                const enableCliShortcuts = isCliShortcutsEnabled();
-                const afterTestsWatchRun = ()=>{
-                    utils.vF.log(utils.yW.green('  Waiting for file changes...'));
-                    if (enableCliShortcuts) if (snapshotManager.summary.unmatched) utils.vF.log(`  ${utils.yW.dim('press')} ${utils.yW.yellow(utils.yW.bold('u'))} ${utils.yW.dim('to update snapshot')}${utils.yW.dim(', press')} ${utils.yW.bold('h')} ${utils.yW.dim('to show help')}\n`);
-                    else utils.vF.log(`  ${utils.yW.dim('press')} ${utils.yW.bold('h')} ${utils.yW.dim('to show help')}${utils.yW.dim(', press')} ${utils.yW.bold('q')} ${utils.yW.dim('to quit')}\n`);
-                };
-                const { onBeforeRestart } = await __webpack_require__.e("967").then(__webpack_require__.bind(__webpack_require__, "./src/core/restart.ts"));
-                onBeforeRestart(async ()=>{
-                    await pool.close();
-                    await closeServer();
-                });
-                rsbuildInstance.onBeforeDevCompile(({ isFirstCompile })=>{
-                    if (!isFirstCompile) (0, utils.mT)();
-                });
-                rsbuildInstance.onAfterDevCompile(async ({ isFirstCompile })=>{
-                    snapshotManager.clear();
-                    await run({
-                        mode: isFirstCompile ? 'all' : 'on-demand'
-                    });
-                    if (isFirstCompile && enableCliShortcuts) {
-                        const closeCliShortcuts = await setupCliShortcuts({
-                            closeServer: async ()=>{
-                                await pool.close();
-                                await closeServer();
-                            },
-                            runAll: async ()=>{
-                                (0, utils.mT)();
-                                snapshotManager.clear();
-                                context.normalizedConfig.testNamePattern = void 0;
-                                context.fileFilters = void 0;
-                                await run({
-                                    mode: 'all'
-                                });
-                                afterTestsWatchRun();
-                            },
-                            runWithTestNamePattern: async (pattern)=>{
-                                (0, utils.mT)();
-                                context.normalizedConfig.testNamePattern = pattern;
-                                if (pattern) utils.vF.log(`\n${utils.yW.dim('Applied testNamePattern:')} ${utils.yW.bold(pattern)}\n`);
-                                else utils.vF.log(`\n${utils.yW.dim('Cleared testNamePattern filter')}\n`);
-                                snapshotManager.clear();
-                                await run();
-                                afterTestsWatchRun();
-                            },
-                            runWithFileFilters: async (filters)=>{
-                                (0, utils.mT)();
-                                if (filters && filters.length > 0) utils.vF.log(`\n${utils.yW.dim('Applied file filters:')} ${utils.yW.bold(filters.join(', '))}\n`);
-                                else utils.vF.log(`\n${utils.yW.dim('Cleared file filters')}\n`);
-                                snapshotManager.clear();
-                                context.fileFilters = filters;
-                                const entries = await Promise.all(projects.map(async (p)=>globTestSourceEntries(p.environmentName))).then((entries)=>entries.reduce((acc, entry)=>acc.concat(...Object.values(entry)), []));
-                                if (!entries.length) return void utils.vF.log(filters ? utils.yW.yellow(`\nNo matching test files to run with current file filters: ${filters.join(',')}\n`) : utils.yW.yellow('\nNo matching test files to run.\n'));
-                                await run({
-                                    fileFilters: entries
-                                });
-                                afterTestsWatchRun();
-                            },
-                            runFailedTests: async ()=>{
-                                const failedTests = context.reporterResults.results.filter((result)=>'fail' === result.status).map((r)=>r.testPath);
-                                if (!failedTests.length) return void utils.vF.log(utils.yW.yellow('\nNo failed tests were found that needed to be rerun.'));
-                                (0, utils.mT)();
-                                snapshotManager.clear();
-                                await run({
-                                    fileFilters: failedTests,
-                                    mode: 'all'
-                                });
-                                afterTestsWatchRun();
-                            },
-                            updateSnapshot: async ()=>{
-                                if (!snapshotManager.summary.unmatched) return void utils.vF.log(utils.yW.yellow('\nNo snapshots were found that needed to be updated.'));
-                                const failedTests = context.reporterResults.results.filter((result)=>result.snapshotResult?.unmatched).map((r)=>r.testPath);
-                                (0, utils.mT)();
-                                const originalUpdateSnapshot = snapshotManager.options.updateSnapshot;
-                                snapshotManager.clear();
-                                snapshotManager.options.updateSnapshot = 'all';
-                                await run({
-                                    fileFilters: failedTests
-                                });
-                                afterTestsWatchRun();
-                                snapshotManager.options.updateSnapshot = originalUpdateSnapshot;
-                            }
-                        });
-                        onBeforeRestart(closeCliShortcuts);
-                    }
-                    afterTestsWatchRun();
-                });
-            } else {
-                await run();
-                await pool.close();
-                await closeServer();
-            }
-        }
-    },
-    "./src/coverage/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            e: ()=>createCoverageProvider,
-            loadCoverageProvider: ()=>loadCoverageProvider
-        });
-        var node_module__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:module");
-        var node_url__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("node:url");
-        var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/utils/index.ts");
-        const CoverageProviderMap = {
-            istanbul: '@rstest/coverage-istanbul'
-        };
-        const loadCoverageProvider = async (options, root)=>{
-            const rootPath = (0, node_url__WEBPACK_IMPORTED_MODULE_1__.pathToFileURL)(root).toString();
-            const moduleName = CoverageProviderMap[options.provider || 'istanbul'];
-            if (!moduleName) throw new Error(`Unknown coverage provider: ${options.provider}`);
-            try {
-                const require = (0, node_module__WEBPACK_IMPORTED_MODULE_0__.createRequire)(rootPath);
-                const modulePath = require.resolve(moduleName, {
-                    paths: [
-                        rootPath
-                    ]
-                });
-                const { pluginCoverage, CoverageProvider } = await import((0, node_url__WEBPACK_IMPORTED_MODULE_1__.pathToFileURL)(modulePath).toString());
-                return {
-                    pluginCoverage,
-                    CoverageProvider
-                };
-            } catch  {
-                const error = new Error(`Failed to load coverage provider module: ${_utils__WEBPACK_IMPORTED_MODULE_2__.yW.cyan(moduleName)} in ${_utils__WEBPACK_IMPORTED_MODULE_2__.yW.underline(root)}, please make sure it is installed.\n`);
-                error.stack = '';
-                throw error;
-            }
-        };
-        async function createCoverageProvider(options, root) {
-            if (!options.enabled) return null;
-            if (!options.provider || CoverageProviderMap[options.provider]) {
-                const { CoverageProvider } = await loadCoverageProvider(options, root);
-                return new CoverageProvider(options);
-            }
-            throw new Error(`Unknown coverage provider: ${options.provider}`);
-        }
-    }
-};

package/dist/0~414.js

@@ -1,16 +0,0 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
-import * as __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__ from "fs/promises";
-import * as __WEBPACK_EXTERNAL_MODULE_node_stream_444d1c2b__ from "node:stream";
-export const __webpack_id__ = "414";
-export const __webpack_ids__ = [
-    "414"
-];
-export const __webpack_modules__ = {
-    "fs/promises": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE_fs_promises_400951f8__;
-    },
-    "node:stream": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE_node_stream_444d1c2b__;
-    }
-};