@rstest/core 0.1.1 → 0.1.3

package/dist/285.js

@@ -25,7 +25,7 @@ export const __webpack_modules__ = {
             const globTestSourceEntries = async ()=>testEntries;
             const setupFiles = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.aA)(setups, rootPath);
             const rsbuildInstance = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.z)(context, globTestSourceEntries, setupFiles);
-            const getRsbuildStats = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.r)({
+            const { getRsbuildStats, closeServer } = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.r)({
                 name,
                 globTestSourceEntries,
                 normalizedConfig: context.normalizedConfig,
@@ -33,15 +33,17 @@ export const __webpack_modules__ = {
                 rsbuildInstance,
                 rootPath
             });
-            const { entries, setupEntries, assetFiles, sourceMaps, close, getSourcemap } = await getRsbuildStats();
+            const { entries, setupEntries, assetFiles, sourceMaps, getSourcemap } = await getRsbuildStats();
             const pool = await (0, _pool__WEBPACK_IMPORTED_MODULE_2__.K)({
+                context
+            });
+            const list = await pool.collectTests({
                 entries,
                 sourceMaps,
                 setupEntries,
                 assetFiles,
-                context
+                updateSnapshot: context.snapshotManager.options.updateSnapshot
             });
-            const list = await pool.collectTests();
             const tests = [];
             const traverseTests = (test)=>{
                 if ([
@@ -68,7 +70,7 @@ export const __webpack_modules__ = {
                         for (const error of file.errors)await printError(error, getSourcemap, rootPath);
                     }
                 }
-                await close();
+                await closeServer();
                 await pool.close();
                 return;
             }
@@ -94,7 +96,7 @@ export const __webpack_modules__ = {
                 const shortPath = (0, node_path__WEBPACK_IMPORTED_MODULE_1__.relative)(rootPath, test.file);
                 _utils__WEBPACK_IMPORTED_MODULE_3__.kg.log(test.name ? `${_utils__WEBPACK_IMPORTED_MODULE_3__.$_.dim(`${shortPath} > `)}${test.name}` : (0, _utils__WEBPACK_IMPORTED_MODULE_3__.aj)(shortPath));
             }
-            await close();
+            await closeServer();
             await pool.close();
         }
     }

package/dist/359.js

@@ -256,7 +256,7 @@ export const __webpack_modules__ = {
                 this.windowHeight = 0;
             }
             interceptStream(stream, type) {
-                const original = stream.write;
+                const original = stream.write.bind(stream);
                 stream.write = (chunk, _, callback)=>{
                     if (chunk) if (this.finished) this.write(chunk.toString(), type);
                     else this.buffer.push({
@@ -411,7 +411,7 @@ export const __webpack_modules__ = {
         };
         const logFileTitle = (test, relativePath, slowTestThreshold, alwaysShowTime = false)=>{
             let title = ` ${utils.$_.bold(statusColorfulStr[test.status])} ${(0, utils.aj)(relativePath)}`;
-            const formatDuration = (duration)=>utils.$_[duration > slowTestThreshold ? 'yellow' : 'green'](`${(0, utils.AS)(duration)}`);
+            const formatDuration = (duration)=>utils.$_[duration > slowTestThreshold ? 'yellow' : 'green']((0, utils.AS)(duration));
             title += ` ${utils.$_.gray(`(${test.results.length})`)}`;
             const isTooSlow = test.duration && test.duration > slowTestThreshold;
             if (alwaysShowTime || isTooSlow) title += ` ${formatDuration(test.duration)}`;
@@ -581,7 +581,7 @@ export const __webpack_modules__ = {
             });
             return {
                 command,
-                version: "0.1.1",
+                version: "0.1.3",
                 rootPath,
                 reporters,
                 snapshotManager,
@@ -596,14 +596,14 @@ export const __webpack_modules__ = {
             }, config);
             const runTests = async ()=>{
                 const { runTests } = await Promise.all([
-                    __webpack_require__.e("562"),
-                    __webpack_require__.e("629")
+                    __webpack_require__.e("854"),
+                    __webpack_require__.e("920")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/runTests.ts"));
                 await runTests(context, fileFilters);
             };
             const listTests = async (options)=>{
                 const { listTests } = await Promise.all([
-                    __webpack_require__.e("562"),
+                    __webpack_require__.e("854"),
                     __webpack_require__.e("285")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/listTests.ts"));
                 await listTests(context, fileFilters, options);

package/dist/{562.js → 854.js}

@@ -1,7 +1,7 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 export const __webpack_ids__ = [
-    "562"
+    "854"
 ];
 export const __webpack_modules__ = {
     "./src/core/rsbuild.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -9,7 +9,6 @@ export const __webpack_modules__ = {
             r: ()=>createRsbuildServer,
             z: ()=>prepareRsbuild
         });
-        var external_node_fs_ = __webpack_require__("fs");
         var core_ = __webpack_require__("@rsbuild/core");
         var external_pathe_ = __webpack_require__("pathe");
         var utils = __webpack_require__("./src/utils/index.ts");
@@ -237,6 +236,22 @@ export const __webpack_modules__ = {
                 });
             }
         };
+        var external_node_inspector_ = __webpack_require__("node:inspector");
+        const enable = void 0 !== external_node_inspector_["default"].url();
+        const pluginInspect = ()=>enable ? {
+                name: 'rstest:inspect',
+                setup: (api)=>{
+                    api.modifyRspackConfig(async (config)=>{
+                        config.devtool = 'inline-source-map';
+                        config.optimization ??= {};
+                        config.optimization.splitChunks = {
+                            ...config.optimization.splitChunks || {},
+                            maxSize: 1048576,
+                            chunks: 'all'
+                        };
+                    });
+                }
+            } : null;
         class MockRuntimeRspackPlugin {
             apply(compiler) {
                 const { RuntimeModule } = compiler.webpack;
@@ -412,6 +427,19 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     });
                 }
             });
+        function parseInlineSourceMap(code) {
+            const inlineSourceMapRegex = /\/\/# sourceMappingURL=data:application\/json(?:;charset=utf-8)?;base64,(.+)\s*$/m;
+            const match = code.match(inlineSourceMapRegex);
+            if (!match || !match[1]) return null;
+            try {
+                const base64Data = match[1];
+                const decodedStr = Buffer.from(base64Data, 'base64').toString('utf-8');
+                const sourceMap = JSON.parse(decodedStr);
+                return sourceMap;
+            } catch (_error) {
+                return null;
+            }
+        }
         const isMultiCompiler = (compiler)=>'compilers' in compiler && Array.isArray(compiler.compilers);
         const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
             const { command, normalizedConfig: { isolate, plugins, resolve, source, output, tools, testEnvironment, performance, dev = {} } } = context;
@@ -450,7 +478,8 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                             isWatch: 'watch' === command
                         }),
                         pluginExternal(testEnvironment),
-                        !isolate ? pluginCacheControl(Object.values(setupFiles)) : null
+                        !isolate ? pluginCacheControl(Object.values(setupFiles)) : null,
+                        pluginInspect()
                     ].filter(Boolean)
                 }
             });
@@ -478,12 +507,15 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     rstest: normalizedConfig
                 }
             });
-            const outputFileSystem = (isMultiCompiler(rspackCompiler) ? rspackCompiler.compilers[0].outputFileSystem : rspackCompiler.outputFileSystem) || external_node_fs_["default"];
-            const getRsbuildStats = async ()=>{
+            if (!rspackCompiler) throw new Error('rspackCompiler was not initialized');
+            const outputFileSystem = isMultiCompiler(rspackCompiler) ? rspackCompiler.compilers[0].outputFileSystem : rspackCompiler.outputFileSystem;
+            if (!outputFileSystem) throw new Error(`Expect outputFileSystem to be defined, but got ${outputFileSystem}`);
+            const getRsbuildStats = async ({ fileFilters } = {})=>{
                 const stats = await devServer.environments[name].getStats();
                 const manifest = devServer.environments[name].context.manifest;
-                const { entrypoints, outputPath, assets, time: buildTime } = stats.toJson({
+                const { entrypoints, outputPath, assets, hash, time: buildTime } = stats.toJson({
                     all: false,
+                    hash: true,
                     entrypoints: true,
                     outputPath: true,
                     assets: true,
@@ -518,15 +550,26 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         testPath: setupFiles[entry],
                         files: entryFiles[entry]
                     });
-                    else if (sourceEntries[entry]) entries.push({
-                        distPath,
-                        testPath: sourceEntries[entry],
-                        files: entryFiles[entry]
-                    });
+                    else if (sourceEntries[entry]) {
+                        if (fileFilters?.length && !fileFilters.includes(sourceEntries[entry])) continue;
+                        entries.push({
+                            distPath,
+                            testPath: sourceEntries[entry],
+                            files: entryFiles[entry]
+                        });
+                    }
                 }
+                const inlineSourceMap = 'inline-source-map' === stats.compilation.options.devtool;
                 const sourceMaps = Object.fromEntries((await Promise.all(assets.map(async (asset)=>{
-                    const sourceMapPath = asset?.info.related?.sourceMap?.[0];
                     const assetFilePath = external_pathe_["default"].join(outputPath, asset.name);
+                    if (inlineSourceMap) {
+                        const content = await readFile(assetFilePath);
+                        return [
+                            assetFilePath,
+                            parseInlineSourceMap(content)
+                        ];
+                    }
+                    const sourceMapPath = asset?.info.related?.sourceMap?.[0];
                     if (sourceMapPath) {
                         const filePath = external_pathe_["default"].join(outputPath, sourceMapPath);
                         const sourceMap = await readFile(filePath);
@@ -541,6 +584,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     ];
                 }))).filter((asset)=>null !== asset[1]));
                 return {
+                    hash,
                     entries,
                     setupEntries,
                     buildTime: buildTime,
@@ -552,11 +596,13 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         ];
                     }))),
                     sourceMaps,
-                    getSourcemap: (sourcePath)=>sourceMaps[sourcePath] || null,
-                    close: devServer.close
+                    getSourcemap: (sourcePath)=>sourceMaps[sourcePath] || null
                 };
             };
-            return getRsbuildStats;
+            return {
+                closeServer: devServer.close,
+                getRsbuildStats
+            };
         };
     },
     "./src/pool/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -651,12 +697,41 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
             }
             return parsed > 0 ? parsed : 1;
         };
-        const createPool = async ({ entries, context, assetFiles, setupEntries, sourceMaps })=>{
+        const getRuntimeConfig = (context)=>{
+            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate } = context.normalizedConfig;
+            return {
+                testNamePattern,
+                testTimeout,
+                hookTimeout,
+                passWithNoTests,
+                retry,
+                globals,
+                clearMocks,
+                resetMocks,
+                restoreMocks,
+                unstubEnvs,
+                unstubGlobals,
+                maxConcurrency,
+                printConsoleTrace,
+                disableConsoleIntercept,
+                testEnvironment,
+                isolate
+            };
+        };
+        const filterAssetsByEntry = (entryInfo, assetFiles, setupAssets, sourceMaps, entryLength)=>{
+            const neededFiles = entryLength > 1 && entryInfo.files ? Object.fromEntries(Object.entries(assetFiles).filter(([key])=>entryInfo.files.includes(key) || setupAssets.includes(key))) : assetFiles;
+            const neededSourceMaps = entryLength > 1 ? Object.fromEntries(Object.entries(sourceMaps).filter(([key])=>neededFiles[key])) : sourceMaps;
+            return {
+                assetFiles: neededFiles,
+                sourceMaps: neededSourceMaps
+            };
+        };
+        const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
             const execArgv = process.execArgv.filter((execArg)=>execArg.startsWith('--perf') || execArg.startsWith('--cpu-prof') || execArg.startsWith('--heap-prof') || execArg.startsWith('--diagnostic-dir'));
             const numCpus = getNumCpus();
             const { normalizedConfig: { pool: poolOptions, isolate }, reporters } = context;
             const threadsCount = 'watch' === context.command ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-            const recommendCount = 'watch' === context.command ? threadsCount : Math.min(Object.keys(entries).length, threadsCount);
+            const recommendCount = 'watch' === context.command ? threadsCount : Math.min(recommendWorkerCount, threadsCount);
             const maxWorkers = poolOptions.maxWorkers ? parseWorkers(poolOptions.maxWorkers) : recommendCount;
             const minWorkers = poolOptions.minWorkers ? parseWorkers(poolOptions.minWorkers) : maxWorkers < recommendCount ? maxWorkers : recommendCount;
             if (maxWorkers < minWorkers) throw `Invalid pool configuration: maxWorkers(${maxWorkers}) cannot be less than minWorkers(${minWorkers}).`;
@@ -679,26 +754,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     ...process.env
                 }
             });
-            const { updateSnapshot } = context.snapshotManager.options;
-            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout } = context.normalizedConfig;
-            const runtimeConfig = {
-                testNamePattern,
-                testTimeout,
-                hookTimeout,
-                passWithNoTests,
-                retry,
-                globals,
-                clearMocks,
-                resetMocks,
-                restoreMocks,
-                unstubEnvs,
-                unstubGlobals,
-                maxConcurrency,
-                printConsoleTrace,
-                disableConsoleIntercept,
-                testEnvironment,
-                isolate
-            };
+            const runtimeConfig = getRuntimeConfig(context);
             const rpcMethods = {
                 onTestCaseResult: async (result)=>{
                     await Promise.all(reporters.map((reporter)=>reporter.onTestCaseResult?.(result)));
@@ -713,30 +769,22 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     await Promise.all(reporters.map((reporter)=>reporter.onTestFileResult?.(test)));
                 }
             };
-            const setupAssets = setupEntries.flatMap((entry)=>entry.files);
-            const entryLength = Object.keys(entries).length;
-            const filterAssetsByEntry = (entryInfo)=>{
-                const neededFiles = entryLength > 1 && entryInfo.files ? Object.fromEntries(Object.entries(assetFiles).filter(([key])=>entryInfo.files.includes(key) || setupAssets.includes(key))) : assetFiles;
-                const neededSourceMaps = entryLength > 1 ? Object.fromEntries(Object.entries(sourceMaps).filter(([key])=>neededFiles[key])) : sourceMaps;
-                return {
-                    assetFiles: neededFiles,
-                    sourceMaps: neededSourceMaps
-                };
-            };
             return {
-                runTests: async ()=>{
+                runTests: async ({ entries, assetFiles, setupEntries, sourceMaps, updateSnapshot })=>{
+                    const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
+                    const entryLength = Object.keys(entries).length;
                     const results = await Promise.all(entries.map((entryInfo)=>{
-                        const { assetFiles, sourceMaps } = filterAssetsByEntry(entryInfo);
+                        const { assetFiles: neededFiles, sourceMaps: neededSourceMaps } = filterAssetsByEntry(entryInfo, assetFiles, setupAssets, sourceMaps, entryLength);
                         return pool.runTest({
                             options: {
                                 entryInfo,
-                                assetFiles,
+                                assetFiles: neededFiles,
                                 context: {
                                     rootPath: context.rootPath,
                                     runtimeConfig: (0, utils.v8)(runtimeConfig)
                                 },
                                 type: 'run',
-                                sourceMaps,
+                                sourceMaps: neededSourceMaps,
                                 setupEntries,
                                 updateSnapshot
                             },
@@ -761,18 +809,21 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         testResults
                     };
                 },
-                collectTests: async ()=>Promise.all(entries.map((entryInfo)=>{
-                        const { assetFiles, sourceMaps } = filterAssetsByEntry(entryInfo);
+                collectTests: async ({ entries, assetFiles, setupEntries, sourceMaps, updateSnapshot })=>{
+                    const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
+                    const entryLength = Object.keys(entries).length;
+                    return Promise.all(entries.map((entryInfo)=>{
+                        const { assetFiles: neededFiles, sourceMaps: neededSourceMaps } = filterAssetsByEntry(entryInfo, assetFiles, setupAssets, sourceMaps, entryLength);
                         return pool.collectTests({
                             options: {
                                 entryInfo,
-                                assetFiles,
+                                assetFiles: neededFiles,
                                 context: {
                                     rootPath: context.rootPath,
                                     runtimeConfig: (0, utils.v8)(runtimeConfig)
                                 },
                                 type: 'collect',
-                                sourceMaps,
+                                sourceMaps: neededSourceMaps,
                                 setupEntries,
                                 updateSnapshot
                             },
@@ -787,7 +838,8 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                 ]
                             };
                         });
-                    })),
+                    }));
+                },
                 close: ()=>pool.close()
             };
         };

package/dist/920.js

@@ -0,0 +1,208 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+export const __webpack_ids__ = [
+    "920"
+];
+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_pool = __webpack_require__("./src/pool/index.ts");
+        var utils = __webpack_require__("./src/utils/index.ts");
+        const isCliShortcutsEnabled = ()=>(0, utils._l)('stdin');
+        async function setupCliShortcuts({ closeServer, runAll, updateSnapshot, runFailedTests }) {
+            const shortcuts = [
+                {
+                    key: 'c',
+                    description: `${utils.$_.bold('c')}  ${utils.$_.dim('clear console')}`,
+                    action: ()=>{
+                        console.clear();
+                    }
+                },
+                {
+                    key: 'f',
+                    description: `${utils.$_.bold('f')}  ${utils.$_.dim('rerun failed tests')}`,
+                    action: async ()=>{
+                        await runFailedTests();
+                    }
+                },
+                {
+                    key: 'a',
+                    description: `${utils.$_.bold('a')}  ${utils.$_.dim('rerun all tests')}`,
+                    action: async ()=>{
+                        await runAll();
+                    }
+                },
+                {
+                    key: 'u',
+                    description: `${utils.$_.bold('u')}  ${utils.$_.dim('update snapshot')}`,
+                    action: async ()=>{
+                        await updateSnapshot();
+                    }
+                },
+                {
+                    key: 'q',
+                    description: `${utils.$_.bold('q')}  ${utils.$_.dim('quit process')}`,
+                    action: async ()=>{
+                        try {
+                            await closeServer();
+                        } finally{
+                            process.exit(0);
+                        }
+                    }
+                }
+            ];
+            const { createInterface } = await import("node:readline");
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            const handleKeypress = (str, key)=>{
+                if (key.ctrl && 'c' === key.name) process.exit(0);
+                for (const shortcut of shortcuts)if (str === shortcut.key) return void shortcut.action();
+                if ('h' === str) {
+                    let message = `\n  ${utils.$_.bold(utils.$_.blue('Shortcuts:'))}\n`;
+                    for (const shortcut of shortcuts)message += `  ${shortcut.description}\n`;
+                    utils.kg.log(message);
+                }
+            };
+            process.stdin.on('keypress', handleKeypress);
+            return ()=>{
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+                rl.close();
+            };
+        }
+        var rsbuild = __webpack_require__("./src/core/rsbuild.ts");
+        async function runTests(context, fileFilters) {
+            const { normalizedConfig: { include, exclude, root, name, setupFiles: setups, includeSource }, rootPath, reporters, snapshotManager, command } = context;
+            const entriesCache = new Map();
+            const globTestSourceEntries = async ()=>{
+                const entries = await (0, utils.GL)({
+                    include,
+                    exclude,
+                    includeSource,
+                    root,
+                    fileFilters
+                });
+                entriesCache.set(name, entries);
+                if (!Object.keys(entries).length) {
+                    utils.kg.log(utils.$_.red('No test files found.'));
+                    utils.kg.log('');
+                    if (fileFilters.length) utils.kg.log(utils.$_.gray('filter: '), fileFilters.join(utils.$_.gray(', ')));
+                    utils.kg.log(utils.$_.gray('include:'), include.join(utils.$_.gray(', ')));
+                    utils.kg.log(utils.$_.gray('exclude:'), exclude.join(utils.$_.gray(', ')));
+                    utils.kg.log('');
+                }
+                return entries;
+            };
+            const setupFiles = (0, utils.aA)(setups, rootPath);
+            const rsbuildInstance = await (0, rsbuild.z)(context, globTestSourceEntries, setupFiles);
+            const { getRsbuildStats, closeServer } = await (0, rsbuild.r)({
+                name,
+                normalizedConfig: context.normalizedConfig,
+                globTestSourceEntries: 'watch' === command ? globTestSourceEntries : async ()=>{
+                    if (entriesCache.has(name)) return entriesCache.get(name);
+                    return globTestSourceEntries();
+                },
+                setupFiles,
+                rsbuildInstance,
+                rootPath
+            });
+            const recommendWorkerCount = 'watch' === command ? 1 / 0 : Array.from(entriesCache.values()).reduce((acc, entries)=>acc + Object.keys(entries).length, 0);
+            const pool = await (0, src_pool.K)({
+                context,
+                recommendWorkerCount
+            });
+            let testFileResult = [];
+            let buildHash;
+            const run = async ({ fileFilters } = {})=>{
+                const { entries, setupEntries, assetFiles, sourceMaps, getSourcemap, buildTime, hash } = await getRsbuildStats({
+                    fileFilters
+                });
+                const testStart = Date.now();
+                const { results, testResults } = await pool.runTests({
+                    entries,
+                    sourceMaps,
+                    setupEntries,
+                    assetFiles,
+                    updateSnapshot: snapshotManager.options.updateSnapshot
+                });
+                const actualBuildTime = buildHash === hash ? 0 : buildTime;
+                const testTime = Date.now() - testStart;
+                const duration = {
+                    totalTime: testTime + actualBuildTime,
+                    buildTime: actualBuildTime,
+                    testTime
+                };
+                buildHash = hash;
+                testFileResult = results;
+                if (results.some((r)=>'fail' === r.status)) process.exitCode = 1;
+                for (const reporter of reporters)await reporter.onTestRunEnd?.({
+                    results,
+                    testResults,
+                    snapshotSummary: snapshotManager.summary,
+                    duration,
+                    getSourcemap
+                });
+            };
+            if ('watch' === command) {
+                const enableCliShortcuts = isCliShortcutsEnabled();
+                const afterTestsWatchRun = ()=>{
+                    utils.kg.log(utils.$_.green('  Waiting for file changes...'));
+                    if (enableCliShortcuts) if (snapshotManager.summary.unmatched) utils.kg.log(`  ${utils.$_.dim('press')} ${utils.$_.yellow(utils.$_.bold('u'))} ${utils.$_.dim('to update snapshot')}${utils.$_.dim(', press')} ${utils.$_.bold('h')} ${utils.$_.dim('to show help')}\n`);
+                    else utils.kg.log(`  ${utils.$_.dim('press')} ${utils.$_.bold('h')} ${utils.$_.dim('to show help')}${utils.$_.dim(', press')} ${utils.$_.bold('q')} ${utils.$_.dim('to quit')}\n`);
+                };
+                const clearLogs = ()=>{
+                    console.clear();
+                };
+                rsbuildInstance.onDevCompileDone(async ({ isFirstCompile })=>{
+                    if (!isFirstCompile) clearLogs();
+                    snapshotManager.clear();
+                    await run();
+                    if (isFirstCompile && enableCliShortcuts) await setupCliShortcuts({
+                        closeServer: async ()=>{
+                            await pool.close();
+                            await closeServer();
+                        },
+                        runAll: async ()=>{
+                            clearLogs();
+                            snapshotManager.clear();
+                            await run();
+                            afterTestsWatchRun();
+                        },
+                        runFailedTests: async ()=>{
+                            const failedTests = testFileResult.filter((result)=>'fail' === result.status).map((r)=>r.testPath);
+                            if (!failedTests.length) return void utils.kg.log(utils.$_.yellow('\nNo failed tests were found that needed to be rerun.'));
+                            clearLogs();
+                            snapshotManager.clear();
+                            await run({
+                                fileFilters: failedTests
+                            });
+                            afterTestsWatchRun();
+                        },
+                        updateSnapshot: async ()=>{
+                            if (!snapshotManager.summary.unmatched) return void utils.kg.log(utils.$_.yellow('\nNo snapshots were found that needed to be updated.'));
+                            clearLogs();
+                            const originalUpdateSnapshot = snapshotManager.options.updateSnapshot;
+                            snapshotManager.clear();
+                            snapshotManager.options.updateSnapshot = 'all';
+                            await run();
+                            afterTestsWatchRun();
+                            snapshotManager.options.updateSnapshot = originalUpdateSnapshot;
+                        }
+                    });
+                    afterTestsWatchRun();
+                });
+            } else {
+                await run();
+                await pool.close();
+                await closeServer();
+            }
+        }
+    }
+};

package/dist/cli.js

@@ -6,6 +6,7 @@ import * as __WEBPACK_EXTERNAL_MODULE_birpc__ from "birpc";
 import * as __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__ from "node:events";
 import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
 import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/promises";
+import * as __WEBPACK_EXTERNAL_MODULE_node_inspector_dd9822d6__ from "node:inspector";
 import * as __WEBPACK_EXTERNAL_MODULE_node_module_ab9f2194__ from "node:module";
 import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
 import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
@@ -2301,6 +2302,7 @@ var __webpack_modules__ = {
             Yz: ()=>getTaskNameWithPrefix,
             Z: ()=>formatError,
             ZY: ()=>getAbsolutePath,
+            _l: ()=>isTTY,
             v8: ()=>serializableConfig
         });
         var pathe__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("pathe");
@@ -2442,12 +2444,14 @@ var __webpack_modules__ = {
             /^node:/,
             'pnpapi'
         ];
+        const isTTY = (type = 'stdout')=>('stdin' === type ? process.stdin.isTTY : process.stdout.isTTY) && !process.env.CI;
     },
     "./src/utils/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             F7: ()=>constants.F7,
             GL: ()=>getTestEntries,
             aj: ()=>prettyTestPath,
+            _l: ()=>helper._l,
             aA: ()=>getSetupFiles,
             kg: ()=>logger.k,
             Io: ()=>constants.Io,
@@ -2638,6 +2642,7 @@ var __webpack_modules__ = {
             if ('TEAMCITY_VERSION' in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
             if ('truecolor' === env.COLORTERM) return 3;
             if ('xterm-kitty' === env.TERM) return 3;
+            if ('xterm-ghostty' === env.TERM) return 3;
             if ('TERM_PROGRAM' in env) {
                 const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
                 switch(env.TERM_PROGRAM){
@@ -2835,7 +2840,7 @@ var __webpack_modules__ = {
         src_logger.override({
             debug: (message, ...args)=>{
                 if ('verbose' !== src_logger.level) return;
-                const time = helper.$_.gray(`${getTime()}`);
+                const time = helper.$_.gray(getTime());
                 console.log(`  ${helper.$_.magenta('rstest')} ${time} ${message}`, ...args);
             }
         });
@@ -2855,6 +2860,9 @@ var __webpack_modules__ = {
     "node:fs/promises": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__;
     },
+    "node:inspector": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_inspector_dd9822d6__;
+    },
     "node:module": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_module_ab9f2194__;
     },
@@ -3678,7 +3686,6 @@ class CAC extends EventEmitter {
 const cac = (name = "")=>new CAC(name);
 const dist = cac;
 var external_pathe_ = __webpack_require__("pathe");
-var external_std_env_ = __webpack_require__("std-env");
 var src_config = __webpack_require__("./src/config.ts");
 var helper = __webpack_require__("./src/utils/helper.ts");
 function initNodeEnv() {
@@ -3691,7 +3698,7 @@ function prepareCli() {
     if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
 }
 function showRstest() {
-    logger.k.greet("  Rstest v0.1.1");
+    logger.k.greet("  Rstest v0.1.3");
     logger.k.log('');
 }
 const applyCommonOptions = (cli)=>{
@@ -3740,12 +3747,12 @@ async function initCli(options) {
 function setupCommands() {
     const cli = dist('rstest');
     cli.help();
-    cli.version("0.1.1");
+    cli.version("0.1.3");
     applyCommonOptions(cli);
-    cli.command('[...filters]', 'run tests').action(async (filters, options)=>{
+    cli.command('[...filters]', 'run tests').option('--watch', 'Run tests in watch mode').action(async (filters, options)=>{
         showRstest();
-        if (external_std_env_.isCI) await runRest(options, filters, 'run');
-        else await runRest(options, filters, 'watch');
+        if (options.watch) await runRest(options, filters, 'watch');
+        else await runRest(options, filters, 'run');
     });
     const runRest = async (options, filters, command)=>{
         let rstest;

package/dist/worker.js

@@ -5200,6 +5200,7 @@ var __webpack_modules__ = {
             if ('TEAMCITY_VERSION' in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
             if ('truecolor' === env.COLORTERM) return 3;
             if ('xterm-kitty' === env.TERM) return 3;
+            if ('xterm-ghostty' === env.TERM) return 3;
             if ('TERM_PROGRAM' in env) {
                 const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
                 switch(env.TERM_PROGRAM){
@@ -5397,7 +5398,7 @@ var __webpack_modules__ = {
         src_logger.override({
             debug: (message, ...args)=>{
                 if ('verbose' !== src_logger.level) return;
-                const time = helper.$_.gray(`${getTime()}`);
+                const time = helper.$_.gray(getTime());
                 console.log(`  ${helper.$_.magenta('rstest')} ${time} ${message}`, ...args);
             }
         });
@@ -5576,7 +5577,7 @@ var external_node_path_ = __webpack_require__("node:path");
 var external_pathe_ = __webpack_require__("pathe");
 var logger = __webpack_require__("./src/utils/logger.ts");
 const shouldInterop = ({ interopDefault = true, modulePath, mod })=>{
-    if (false === interopDefault) return false;
+    if (!interopDefault) return false;
     return !modulePath.endsWith('.mjs') && 'default' in mod;
 };
 const isPrimitive = (v)=>v !== Object(v);
@@ -5650,7 +5651,7 @@ const createRequire = (filename, distPath, rstestContext, assetFiles, interopDef
     return require;
 };
 const defineRstestDynamicImport = ({ testPath, interopDefault, returnModule = false })=>async (specifier, importAttributes)=>{
-        const resolvedPath = (0, external_node_path_.isAbsolute)(specifier) ? pathToFileURL(specifier) : await import.meta.resolve(specifier, pathToFileURL(testPath));
+        const resolvedPath = (0, external_node_path_.isAbsolute)(specifier) ? pathToFileURL(specifier) : import.meta.resolve(specifier, pathToFileURL(testPath));
         const modulePath = 'string' == typeof resolvedPath ? resolvedPath : resolvedPath.pathname;
         if (importAttributes?.with?.rstest) delete importAttributes.with.rstest;
         const importedModule = await import(modulePath, importAttributes);
@@ -5885,7 +5886,7 @@ const preparePool = async ({ entryInfo: { distPath, testPath }, sourceMaps, upda
             {
                 const { environment } = await __webpack_require__.e("44").then(__webpack_require__.bind(__webpack_require__, "./src/runtime/worker/env/happyDom.ts"));
                 const { teardown } = await environment.setup(global, {});
-                cleanupFns.push(async ()=>await teardown(global));
+                cleanupFns.push(async ()=>teardown(global));
                 break;
             }
         default:
@@ -5948,7 +5949,7 @@ const runInPool = async (options)=>{
     isTeardown = false;
     const { entryInfo: { distPath, testPath }, setupEntries, assetFiles, type, context: { runtimeConfig: { isolate } } } = options;
     const cleanups = [];
-    const exit = process.exit;
+    const exit = process.exit.bind(process);
     process.exit = (code = process.exitCode || 0)=>{
         throw new Error(`process.exit unexpectedly called with "${code}"`);
     };

package/dist-types/public.d.ts

@@ -430,13 +430,13 @@ declare type DescribeAPI = DescribeFn & {
 };
 
 declare interface DescribeEachFn {
-    <T extends Record<string, unknown>>(cases: ReadonlyArray<T>): (description: string, fn?: (param: T) => MaybePromise<void>) => void;
-    <T extends readonly [unknown, ...Array<unknown>]>(cases: ReadonlyArray<T>): (description: string, fn: (...args: [...T]) => MaybePromise<void>) => void;
+    <T extends Record<string, unknown>>(cases: readonly T[]): (description: string, fn?: (param: T) => MaybePromise<void>) => void;
+    <T extends readonly [unknown, ...unknown[]]>(cases: readonly T[]): (description: string, fn: (...args: [...T]) => MaybePromise<void>) => void;
 }
 
 declare type DescribeFn = (description: string, fn?: () => void) => void;
 
-declare type DescribeForFn = <T>(cases: ReadonlyArray<T>) => (description: string, fn?: (param: T) => MaybePromise<void>) => void;
+declare type DescribeForFn = <T>(cases: readonly T[]) => (description: string, fn?: (param: T) => MaybePromise<void>) => void;
 
 /**
  * @param a Expected value
@@ -514,7 +514,7 @@ declare interface ExpectStatic extends ExpectStatic_2 {
     unreachable: (message?: string) => never;
     soft: <T>(actual: T, message?: string) => Assertion<T>;
     poll: <T>(actual: () => T, options?: ExpectPollOptions) => Omit<PromisifyAssertion_2<Awaited<T>>, 'rejects' | 'resolves' | 'toThrow' | 'toThrowError' | 'throw' | 'throws' | 'matchSnapshot' | 'toMatchSnapshot' | 'toMatchInlineSnapshot' | 'toThrowErrorMatchingSnapshot' | 'toThrowErrorMatchingInlineSnapshot'>;
-    addEqualityTesters: (testers: Array<Tester>) => void;
+    addEqualityTesters: (testers: Tester[]) => void;
     assertions: (expected: number) => void;
     hasAssertions: () => void;
     addSnapshotSerializer: typeof addSerializer;
@@ -1225,21 +1225,21 @@ declare type MockContext_2<T extends FunctionLike = FunctionLike> = {
     /**
      * List of the call arguments of all calls that have been made to the mock.
      */
-    calls: Array<Parameters<T>>;
+    calls: Parameters<T>[];
     /**
      * List of all the object instances that have been instantiated from the mock.
      */
-    instances: Array<ReturnType<T>>;
+    instances: ReturnType<T>[];
     /**
      * List of all the function contexts that have been applied to calls to the mock.
      */
-    contexts: Array<ThisParameterType<T>>;
+    contexts: ThisParameterType<T>[];
     /**
      * The order of mock's execution.
      * This returns an array of numbers which are shared between all defined mocks.
      * The index is starting with `1`.
      */
-    invocationCallOrder: Array<number>;
+    invocationCallOrder: number[];
     /**
      * List of the call arguments of the last call that was made to the mock.
      * If the function was not called, it will return `undefined`.
@@ -1248,7 +1248,7 @@ declare type MockContext_2<T extends FunctionLike = FunctionLike> = {
     /**
      * List of the results of all calls that have been made to the mock.
      */
-    results: Array<MockResult_2<ReturnType<T>>>;
+    results: MockResult_2<ReturnType<T>>[];
     /**
      * List of the results of all values that were `resolved` or `rejected` from the function.
      */
@@ -2270,8 +2270,8 @@ declare type TestContext = {
 };
 
 declare interface TestEachFn {
-    <T extends Record<string, unknown>>(cases: ReadonlyArray<T>): (description: string, fn?: (param: T) => MaybePromise<void>, timeout?: number) => void;
-    <T extends readonly [unknown, ...Array<unknown>]>(cases: ReadonlyArray<T>): (description: string, fn: (...args: [...T]) => MaybePromise<void>, timeout?: number) => void;
+    <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;
 }
 
 declare type Tester = (this: TesterContext, a: any, b: any, customTesters: Array<Tester>) => boolean | undefined;
@@ -2291,7 +2291,7 @@ declare type TestFileResult = TestResult & {
 
 declare type TestFn<ExtraContext = object> = (description: string, fn?: TestCallbackFn<ExtraContext>, timeout?: number) => void;
 
-declare type TestForFn<ExtraContext = object> = <T>(cases: ReadonlyArray<T>) => (description: string, fn?: (param: T, context: TestContext & ExtraContext) => MaybePromise<void>, timeout?: number) => void;
+declare type TestForFn<ExtraContext = object> = <T>(cases: readonly T[]) => (description: string, fn?: (param: T, context: TestContext & ExtraContext) => MaybePromise<void>, timeout?: number) => void;
 
 /** The test file original path */
 declare type TestPath = string;

package/dist-types/worker.d.ts

@@ -475,7 +475,7 @@ declare interface ExpectStatic extends ExpectStatic_2 {
     unreachable: (message?: string) => never;
     soft: <T>(actual: T, message?: string) => Assertion_2<T>;
     poll: <T>(actual: () => T, options?: ExpectPollOptions) => Omit<PromisifyAssertion_2<Awaited<T>>, 'rejects' | 'resolves' | 'toThrow' | 'toThrowError' | 'throw' | 'throws' | 'matchSnapshot' | 'toMatchSnapshot' | 'toMatchInlineSnapshot' | 'toThrowErrorMatchingSnapshot' | 'toThrowErrorMatchingInlineSnapshot'>;
-    addEqualityTesters: (testers: Array<Tester>) => void;
+    addEqualityTesters: (testers: Tester[]) => void;
     assertions: (expected: number) => void;
     hasAssertions: () => void;
     addSnapshotSerializer: typeof addSerializer;
@@ -1962,7 +1962,7 @@ declare type TestSuite = {
     sequential?: boolean;
     testPath: TestPath;
     /** nested cases and suite could in a suite */
-    tests: Array<TestSuite | TestCase>;
+    tests: (TestSuite | TestCase)[];
     type: 'suite';
     afterAllListeners?: AfterAllListener[];
     beforeAllListeners?: BeforeAllListener[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/core",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "The Rsbuild-based test tool.",
   "bugs": {
     "url": "https://github.com/web-infra-dev/rstest/issues"
@@ -50,7 +50,7 @@
   "dependencies": {
     "chai": "^5.2.1",
     "@types/chai": "^5.2.2",
-    "@rsbuild/core": "1.4.12",
+    "@rsbuild/core": "1.4.15",
     "birpc": "2.5.0",
     "pathe": "^2.0.3",
     "std-env": "^3.9.0",
@@ -62,7 +62,7 @@
     "@babel/code-frame": "^7.27.1",
     "@jridgewell/trace-mapping": "0.3.29",
     "@microsoft/api-extractor": "^7.52.10",
-    "@rslib/core": "0.11.0",
+    "@rslib/core": "0.11.2",
     "@sinonjs/fake-timers": "^14.0.0",
     "@types/babel__code-frame": "^7.0.6",
     "@types/jsdom": "^21.1.7",
@@ -74,7 +74,7 @@
     "jsdom": "^26.1.0",
     "license-webpack-plugin": "^4.0.2",
     "picocolors": "^1.1.1",
-    "rslog": "^1.2.9",
+    "rslog": "^1.2.11",
     "source-map-support": "^0.5.21",
     "stacktrace-parser": "0.1.11",
     "tinyglobby": "^0.2.14",
@@ -104,6 +104,6 @@
     "build": "rslib build && npx prettier ./LICENSE.md --write",
     "typecheck": "tsc --noEmit",
     "dev": "rslib build --watch",
-    "test": "npx rstest run --globals"
+    "test": "npx rstest --globals"
   }
 }

package/dist/629.js

@@ -1,84 +0,0 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
-export const __webpack_ids__ = [
-    "629"
-];
-export const __webpack_modules__ = {
-    "./src/core/runTests.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            runTests: ()=>runTests
-        });
-        var _pool__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/pool/index.ts");
-        var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/utils/index.ts");
-        var _rsbuild__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/core/rsbuild.ts");
-        async function runTests(context, fileFilters) {
-            const { normalizedConfig: { include, exclude, root, name, setupFiles: setups, includeSource }, rootPath, reporters, snapshotManager, command } = context;
-            const globTestSourceEntries = async ()=>{
-                const entries = await (0, _utils__WEBPACK_IMPORTED_MODULE_1__.GL)({
-                    include,
-                    exclude,
-                    includeSource,
-                    root,
-                    fileFilters
-                });
-                if (!Object.keys(entries).length) {
-                    _utils__WEBPACK_IMPORTED_MODULE_1__.kg.log(_utils__WEBPACK_IMPORTED_MODULE_1__.$_.red('No test files found.'));
-                    _utils__WEBPACK_IMPORTED_MODULE_1__.kg.log('');
-                    if (fileFilters.length) _utils__WEBPACK_IMPORTED_MODULE_1__.kg.log(_utils__WEBPACK_IMPORTED_MODULE_1__.$_.gray('filter: '), fileFilters.join(_utils__WEBPACK_IMPORTED_MODULE_1__.$_.gray(', ')));
-                    _utils__WEBPACK_IMPORTED_MODULE_1__.kg.log(_utils__WEBPACK_IMPORTED_MODULE_1__.$_.gray('include:'), include.join(_utils__WEBPACK_IMPORTED_MODULE_1__.$_.gray(', ')));
-                    _utils__WEBPACK_IMPORTED_MODULE_1__.kg.log(_utils__WEBPACK_IMPORTED_MODULE_1__.$_.gray('exclude:'), exclude.join(_utils__WEBPACK_IMPORTED_MODULE_1__.$_.gray(', ')));
-                    _utils__WEBPACK_IMPORTED_MODULE_1__.kg.log('');
-                }
-                return entries;
-            };
-            const setupFiles = (0, _utils__WEBPACK_IMPORTED_MODULE_1__.aA)(setups, rootPath);
-            const rsbuildInstance = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_2__.z)(context, globTestSourceEntries, setupFiles);
-            const getRsbuildStats = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_2__.r)({
-                name,
-                normalizedConfig: context.normalizedConfig,
-                globTestSourceEntries,
-                setupFiles,
-                rsbuildInstance,
-                rootPath
-            });
-            const run = async ()=>{
-                const { entries, setupEntries, assetFiles, sourceMaps, getSourcemap, close, buildTime } = await getRsbuildStats();
-                const testStart = Date.now();
-                const pool = await (0, _pool__WEBPACK_IMPORTED_MODULE_0__.K)({
-                    entries,
-                    sourceMaps,
-                    setupEntries,
-                    assetFiles,
-                    context
-                });
-                const { results, testResults } = await pool.runTests();
-                const testTime = Date.now() - testStart;
-                const duration = {
-                    totalTime: testTime + buildTime,
-                    buildTime,
-                    testTime
-                };
-                if (results.some((r)=>'fail' === r.status)) process.exitCode = 1;
-                for (const reporter of reporters)await reporter.onTestRunEnd?.({
-                    results,
-                    testResults,
-                    snapshotSummary: snapshotManager.summary,
-                    duration,
-                    getSourcemap
-                });
-                return async ()=>{
-                    await close();
-                    await pool.close();
-                };
-            };
-            if ('watch' === command) rsbuildInstance.onDevCompileDone(async ()=>{
-                await run();
-                _utils__WEBPACK_IMPORTED_MODULE_1__.kg.log(_utils__WEBPACK_IMPORTED_MODULE_1__.$_.green('  Waiting for file changes...'));
-            });
-            else {
-                const close = await run();
-                await close();
-            }
-        }
-    }
-};