@rstest/core 0.5.1 → 0.5.3

package/dist/0~816.js

@@ -18,6 +18,7 @@ export const __webpack_modules__ = {
         var core_ = __webpack_require__("@rsbuild/core");
         var dist = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs");
         var utils = __webpack_require__("./src/utils/index.ts");
+        var memory = __webpack_require__("./src/utils/memory.ts");
         const RUNTIME_CHUNK_NAME = 'runtime';
         const pluginBasic = (context)=>({
                 name: 'rstest:basic',
@@ -442,15 +443,14 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     });
                 }
             });
-        function parseInlineSourceMap(code) {
+        function parseInlineSourceMapStr(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;
+                return decodedStr;
             } catch (_error) {
                 return null;
             }
@@ -562,6 +562,13 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 deletedEntries
             };
         };
+        class AssetsMemorySafeMap extends Map {
+            set(key, value) {
+                if (this.has(key)) return this;
+                if (!(0, memory.i)()) this.clear();
+                return super.set(key, value);
+            }
+        }
         const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildInstance, inspectedConfig })=>{
             let rspackCompiler;
             const rstestCompilerPlugin = {
@@ -605,8 +612,9 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
             };
             const getRsbuildStats = async ({ environmentName, fileFilters })=>{
                 const stats = await devServer.environments[environmentName].getStats();
+                const enableAssetsCache = (0, memory.i)();
                 const manifest = devServer.environments[environmentName].context.manifest;
-                const { entrypoints, outputPath, assets, hash, time: buildTime, chunks } = stats.toJson({
+                const { entrypoints, outputPath, assets, hash, chunks } = stats.toJson({
                     all: false,
                     hash: true,
                     entrypoints: true,
@@ -641,47 +649,72 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     }
                 }
                 const inlineSourceMap = 'inline-source-map' === stats.compilation.options.devtool;
-                const sourceMaps = Object.fromEntries((await Promise.all(assets.map(async (asset)=>{
+                const sourceMapPaths = Object.fromEntries(assets.map((asset)=>{
                     const assetFilePath = dist.Ay.join(outputPath, asset.name);
-                    if (inlineSourceMap) {
-                        const content = await readFile(assetFilePath);
-                        return [
-                            assetFilePath,
-                            parseInlineSourceMap(content)
-                        ];
-                    }
+                    if (inlineSourceMap) return [
+                        assetFilePath,
+                        assetFilePath
+                    ];
                     const sourceMapPath = asset?.info.related?.sourceMap?.[0];
                     if (sourceMapPath) {
                         const filePath = dist.Ay.join(outputPath, sourceMapPath);
-                        const sourceMap = await readFile(filePath);
                         return [
                             assetFilePath,
-                            JSON.parse(sourceMap)
+                            filePath
                         ];
                     }
                     return [
                         assetFilePath,
                         null
                     ];
-                }))).filter((asset)=>null !== asset[1]));
+                }));
                 buildData[environmentName] ??= {};
                 const { affectedEntries, deletedEntries } = calcEntriesToRerun(entries, chunks, buildData[environmentName], `${environmentName}-${RUNTIME_CHUNK_NAME}`);
+                const cachedAssetFiles = new AssetsMemorySafeMap();
+                const cachedSourceMaps = new AssetsMemorySafeMap();
+                const readFileWithCache = async (name)=>{
+                    if (enableAssetsCache && cachedAssetFiles.has(name)) return cachedAssetFiles.get(name);
+                    const content = await readFile(name);
+                    enableAssetsCache && cachedAssetFiles.set(name, content);
+                    return content;
+                };
+                const getSourceMap = async (name)=>{
+                    const sourceMapPath = sourceMapPaths[name];
+                    if (!sourceMapPath) return null;
+                    if (enableAssetsCache && cachedSourceMaps.has(name)) return cachedSourceMaps.get(name);
+                    let content = null;
+                    if (inlineSourceMap) {
+                        const file = await readFile(sourceMapPath);
+                        content = parseInlineSourceMapStr(file);
+                    } else {
+                        const sourceMap = await readFile(sourceMapPath);
+                        content = sourceMap;
+                    }
+                    enableAssetsCache && content && cachedSourceMaps.set(name, content);
+                    return content;
+                };
+                const assetNames = assets.map((asset)=>dist.Ay.join(outputPath, asset.name));
                 return {
                     affectedEntries,
                     deletedEntries,
                     hash,
                     entries,
                     setupEntries,
-                    buildTime: buildTime,
-                    assetFiles: Object.fromEntries(await Promise.all(assets.map(async (a)=>{
-                        const filePath = dist.Ay.join(outputPath, a.name);
-                        return [
-                            filePath,
-                            await readFile(filePath)
-                        ];
-                    }))),
-                    sourceMaps,
-                    getSourcemap: (sourcePath)=>sourceMaps[sourcePath] || null
+                    assetNames,
+                    getAssetFiles: async (names)=>Object.fromEntries(await Promise.all(names.map(async (name)=>{
+                            const content = await readFileWithCache(name);
+                            return [
+                                name,
+                                content
+                            ];
+                        }))),
+                    getSourceMaps: async (names)=>Object.fromEntries(await Promise.all(names.map(async (name)=>{
+                            const content = await getSourceMap(name);
+                            return [
+                                name,
+                                content
+                            ];
+                        })))
                 };
             };
             return {
@@ -696,6 +729,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
         });
         var external_node_os_ = __webpack_require__("node:os");
         var utils = __webpack_require__("./src/utils/index.ts");
+        var memory = __webpack_require__("./src/utils/memory.ts");
         var external_node_url_ = __webpack_require__("node:url");
         const TYPE_REQUEST = "q";
         const TYPE_RESPONSE = "s";
@@ -941,8 +975,9 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
             return parsed > 0 ? parsed : 1;
         };
         const getRuntimeConfig = (context)=>{
-            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage, snapshotFormat } = context.normalizedConfig;
+            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage, snapshotFormat, env } = context.normalizedConfig;
             return {
+                env,
                 testNamePattern,
                 testTimeout,
                 hookTimeout,
@@ -963,9 +998,13 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 snapshotFormat
             };
         };
-        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;
+        const filterAssetsByEntry = async (entryInfo, getAssetFiles, getSourceMaps, setupAssets)=>{
+            const assetNames = Array.from(new Set([
+                ...entryInfo.files,
+                ...setupAssets
+            ]));
+            const neededFiles = await getAssetFiles(assetNames);
+            const neededSourceMaps = await getSourceMaps(assetNames);
             return {
                 assetFiles: neededFiles,
                 sourceMaps: neededSourceMaps
@@ -1008,23 +1047,17 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 },
                 onTestFileStart: async (test)=>{
                     await Promise.all(reporters.map((reporter)=>reporter.onTestFileStart?.(test)));
-                },
-                onTestFileResult: async (test)=>{
-                    await Promise.all(reporters.map((reporter)=>reporter.onTestFileResult?.(test)));
                 }
             };
             return {
-                runTests: async ({ entries, assetFiles, setupEntries, sourceMaps, project, updateSnapshot })=>{
+                runTests: async ({ entries, getAssetFiles, getSourceMaps, setupEntries, project, updateSnapshot })=>{
                     const projectName = context.normalizedConfig.name;
                     const runtimeConfig = getRuntimeConfig(project);
                     const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
-                    const entryLength = Object.keys(entries).length;
-                    const results = await Promise.all(entries.map((entryInfo)=>{
-                        const { assetFiles: neededFiles, sourceMaps: neededSourceMaps } = filterAssetsByEntry(entryInfo, assetFiles, setupAssets, sourceMaps, entryLength);
-                        return pool.runTest({
+                    const results = await Promise.all(entries.map(async (entryInfo)=>{
+                        const result = await pool.runTest({
                             options: {
                                 entryInfo,
-                                assetFiles: neededFiles,
                                 context: {
                                     project: projectName,
                                     rootPath: context.rootPath,
@@ -1032,11 +1065,14 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                     runtimeConfig: (0, utils.Ok)(runtimeConfig)
                                 },
                                 type: 'run',
-                                sourceMaps: neededSourceMaps,
                                 setupEntries,
-                                updateSnapshot
+                                updateSnapshot,
+                                assets: (0, memory.i)() ? await filterAssetsByEntry(entryInfo, getAssetFiles, getSourceMaps, setupAssets) : void 0
                             },
-                            rpcMethods
+                            rpcMethods: {
+                                ...rpcMethods,
+                                getAssetsByEntry: async ()=>filterAssetsByEntry(entryInfo, getAssetFiles, getSourceMaps, setupAssets)
+                            }
                         }).catch((err)=>{
                             err.fullStack = true;
                             return {
@@ -1050,6 +1086,8 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                 ]
                             };
                         });
+                        reporters.map((reporter)=>reporter.onTestFileResult?.(result));
+                        return result;
                     }));
                     for (const result of results)if (result.snapshotResult) context.snapshotManager.add(result.snapshotResult);
                     const testResults = results.flatMap((r)=>r.results);
@@ -1059,17 +1097,13 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         project
                     };
                 },
-                collectTests: async ({ entries, assetFiles, setupEntries, sourceMaps, project, updateSnapshot })=>{
+                collectTests: async ({ entries, getAssetFiles, getSourceMaps, setupEntries, project, updateSnapshot })=>{
                     const runtimeConfig = getRuntimeConfig(project);
                     const projectName = project.normalizedConfig.name;
                     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({
+                    return Promise.all(entries.map(async (entryInfo)=>pool.collectTests({
                             options: {
                                 entryInfo,
-                                assetFiles: neededFiles,
                                 context: {
                                     project: projectName,
                                     rootPath: context.rootPath,
@@ -1077,11 +1111,14 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                     runtimeConfig: (0, utils.Ok)(runtimeConfig)
                                 },
                                 type: 'collect',
-                                sourceMaps: neededSourceMaps,
                                 setupEntries,
-                                updateSnapshot
+                                updateSnapshot,
+                                assets: (0, memory.i)() ? await filterAssetsByEntry(entryInfo, getAssetFiles, getSourceMaps, setupAssets) : void 0
                             },
-                            rpcMethods
+                            rpcMethods: {
+                                ...rpcMethods,
+                                getAssetsByEntry: async ()=>filterAssetsByEntry(entryInfo, getAssetFiles, getSourceMaps, setupAssets)
+                            }
                         }).catch((err)=>{
                             err.fullStack = true;
                             return {
@@ -1092,13 +1129,29 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                     err
                                 ]
                             };
-                        });
-                    }));
+                        })));
                 },
                 close: ()=>pool.close()
             };
         };
     },
+    "./src/utils/memory.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            i: ()=>isMemorySufficient
+        });
+        var node_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:process");
+        const DefaultMaxHeapSize = 1073741824;
+        function isMemorySufficient(options) {
+            const { memoryThreshold = 0.7, maxHeapSize = DefaultMaxHeapSize } = options || {};
+            if (!node_process__WEBPACK_IMPORTED_MODULE_0__["default"]?.memoryUsage) return true;
+            const memoryUsage = node_process__WEBPACK_IMPORTED_MODULE_0__["default"].memoryUsage();
+            const heapUsed = memoryUsage.heapUsed;
+            const heapTotal = memoryUsage.heapTotal;
+            const memoryUsageRatio = heapUsed / heapTotal;
+            const isMemorySufficient = memoryUsageRatio < memoryThreshold && heapUsed < maxHeapSize;
+            return isMemorySufficient;
+        }
+    },
     "node:url": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__;
     }

package/dist/0~85.js

@@ -621,9 +621,6 @@ export const __webpack_modules__ = {
                 const results = [];
                 const errors = [];
                 let defaultStatus = 'pass';
-                hooks.onTestFileStart?.({
-                    testPath
-                });
                 const snapshotClient = getSnapshotClient();
                 await snapshotClient.setup(testPath, snapshotOptions);
                 const runTestsCase = async (test, parentHooks)=>{
@@ -1395,7 +1392,6 @@ export const __webpack_modules__ = {
                             hooks,
                             api
                         });
-                        hooks.onTestFileResult?.(results);
                         return results;
                     },
                     collectTests: async ()=>{

package/dist/0~971.js

@@ -54,24 +54,24 @@ export const __webpack_modules__ = {
             });
             const updateSnapshot = context.snapshotManager.options.updateSnapshot;
             const returns = await Promise.all(context.projects.map(async (project)=>{
-                const { entries, setupEntries, assetFiles, sourceMaps } = await getRsbuildStats({
+                const { entries, setupEntries, getSourceMaps, getAssetFiles, assetNames } = await getRsbuildStats({
                     environmentName: project.environmentName
                 });
                 const list = await pool.collectTests({
                     entries,
-                    sourceMaps,
                     setupEntries,
-                    assetFiles,
+                    getAssetFiles,
+                    getSourceMaps,
                     project,
                     updateSnapshot
                 });
                 return {
                     list,
-                    sourceMaps
+                    getSourceMaps,
+                    assetNames
                 };
             }));
             const list = returns.flatMap((r)=>r.list);
-            const sourceMaps = Object.assign({}, ...returns.map((r)=>r.sourceMaps));
             const tests = [];
             const traverseTests = (test)=>{
                 if ([
@@ -98,7 +98,13 @@ export const __webpack_modules__ = {
                     const relativePath = (0, node_path__WEBPACK_IMPORTED_MODULE_1__.relative)(rootPath, file.testPath);
                     if (file.errors?.length) {
                         _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(`${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.bgRed(' FAIL ')} ${relativePath}`);
-                        for (const error of file.errors)await printError(error, (name)=>sourceMaps[name] || null, rootPath);
+                        for (const error of file.errors)await printError(error, async (name)=>{
+                            const resource = returns.find((r)=>r.assetNames.includes(name));
+                            const sourceMap = (await resource?.getSourceMaps([
+                                name
+                            ]))?.[name];
+                            return sourceMap ? JSON.parse(sourceMap) : null;
+                        }, rootPath);
                     }
                 }
                 await closeServer();