@rstest/core 0.9.3 → 0.9.5

package/dist/0~generate.js

@@ -27,7 +27,7 @@ async function generateCoverage(context, results, coverageProvider) {
             return normalizedFile.startsWith(normalize(rootPath));
         });
         if (coverage.include?.length) {
-            const coveredFiles = finalCoverageMap.files().map(normalize);
+            const coveredFilesSet = new Set(finalCoverageMap.files().map(normalize));
             let isTimeout = false;
             const timeoutId = setTimeout(()=>{
                 isTimeout = true;
@@ -35,13 +35,14 @@ async function generateCoverage(context, results, coverageProvider) {
             }, 1000);
             const allFiles = (await Promise.all(projects.map(async (p)=>{
                 const includedFiles = await getIncludedFiles(coverage, p.rootPath);
-                const uncoveredFiles = includedFiles.filter((file)=>!coveredFiles.includes(normalize(file)));
+                const uncoveredFiles = includedFiles.filter((file)=>!coveredFilesSet.has(normalize(file)));
                 if (uncoveredFiles.length) await generateCoverageForUntestedFiles(p.environmentName, uncoveredFiles, finalCoverageMap, coverageProvider);
                 return includedFiles;
             }))).flat();
             clearTimeout(timeoutId);
             if (isTimeout) logger_logger.info('Coverage for untested files generated.');
-            finalCoverageMap.filter((file)=>allFiles.includes(normalize(file)));
+            const allFilesSet = new Set(allFiles.map(normalize));
+            finalCoverageMap.filter((file)=>allFilesSet.has(normalize(file)));
         }
         await coverageProvider.generateReports(finalCoverageMap, coverage);
         if (coverage.thresholds) {

package/dist/0~happyDom.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { checkPkgInstalled } from "./7552.js";
 import { installGlobal, addDefaultErrorHandler } from "./0~utils.js";
+import { checkPkgInstalled } from "./7552.js";
 const environment = {
     name: 'happy-dom',
     setup: async (global, options = {})=>{

package/dist/0~jsdom.js

@@ -1,6 +1,6 @@
 import "node:module";
-import { checkPkgInstalled } from "./7552.js";
 import { installGlobal, addDefaultErrorHandler } from "./0~utils.js";
+import { checkPkgInstalled } from "./7552.js";
 const environment = {
     name: 'jsdom',
     setup: async (global, options)=>{

package/dist/0~listTests.js

@@ -2,8 +2,8 @@ import "node:module";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { prepareRsbuild, createPool, createRsbuildServer, runGlobalTeardown, runGlobalSetup } from "./0~8843.js";
-import { getTestEntries, resolveShardedEntries, prettyTestPath, ROOT_SUITE_NAME } from "./4411.js";
-import { logger as logger_logger, getTaskNameWithPrefix, color as logger_color, bgColor } from "./6830.js";
+import { resolveShardedEntries, getTestEntries, prettyTestPath } from "./4411.js";
+import { getTaskNameWithPrefix, logger as logger_logger, color as logger_color, ROOT_SUITE_NAME, bgColor } from "./6830.js";
 const collectNodeTests = async ({ context, nodeProjects, globTestSourceEntries })=>{
     const { getSetupFiles } = await import("./255.js");
     if (0 === nodeProjects.length) return {
@@ -25,7 +25,7 @@ const collectNodeTests = async ({ context, nodeProjects, globTestSourceEntries }
             getSetupFiles(globalSetup, rootPath)
         ];
     }));
-    const rsbuildInstance = await prepareRsbuild(context, globTestSourceEntries, setupFiles, globalSetupFiles);
+    const rsbuildInstance = await prepareRsbuild(context, globTestSourceEntries, setupFiles, globalSetupFiles, nodeProjects);
     const { getRsbuildStats, closeServer } = await createRsbuildServer({
         globTestSourceEntries,
         globalSetupFiles,
@@ -49,8 +49,12 @@ const collectNodeTests = async ({ context, nodeProjects, globTestSourceEntries }
         if (entries.length && globalSetupEntries.length && !project._globalSetups) {
             project._globalSetups = true;
             const files = globalSetupEntries.flatMap((e)=>e.files);
-            const assetFiles = await getAssetFiles(files);
-            const sourceMaps = await getSourceMaps(files);
+            const assetFilesPromise = getAssetFiles(files);
+            const sourceMapsPromise = getSourceMaps(files);
+            const [assetFiles, sourceMaps] = await Promise.all([
+                assetFilesPromise,
+                sourceMapsPromise
+            ]);
             const { success, errors } = await runGlobalSetup({
                 globalSetupEntries,
                 assetFiles,
@@ -111,15 +115,15 @@ const collectBrowserTests = async ({ context, browserProjects, shardedEntries })
     });
 };
 const collectTestFiles = async ({ context, globTestSourceEntries })=>{
-    const list = [];
-    for (const project of context.projects){
+    const projectLists = await Promise.all(context.projects.map(async (project)=>{
         const files = await globTestSourceEntries(project.environmentName);
-        list.push(...Object.values(files).map((testPath)=>({
+        return Object.values(files).map((testPath)=>({
                 testPath,
                 project: project.name,
                 tests: []
-            })));
-    }
+            }));
+    }));
+    const list = projectLists.flat();
     return {
         close: async ()=>void 0,
         errors: [],

package/dist/0~loadEsModule.js

@@ -1,4 +1,5 @@
 import "node:module";
+import { builtinModules } from "node:module";
 import { isAbsolute } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import node_vm from "node:vm";
@@ -12,6 +13,7 @@ var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
     return EsmMode;
 }({});
 const isRelativePath = (p)=>/^\.\.?\//.test(p);
+const isBuiltinSpecifier = (specifier)=>specifier.startsWith('node:') || builtinModules.includes(specifier);
 const defineRstestDynamicImport = ({ distPath, testPath, assetFiles, interopDefault, returnModule, esmMode })=>async (specifier, importAttributes)=>{
         const currentDirectory = posix.dirname(distPath);
         const joinedPath = isRelativePath(specifier) ? posix.join(currentDirectory, specifier) : specifier;
@@ -37,7 +39,7 @@ const defineRstestDynamicImport = ({ distPath, testPath, assetFiles, interopDefa
         } catch (err) {
             logger_logger.error(`load file ${joinedPath} failed:\n`, err instanceof Error ? err.message : err);
         }
-        const resolvedPath = isAbsolute(specifier) ? pathToFileURL(specifier) : import.meta.resolve(specifier, pathToFileURL(testPath));
+        const resolvedPath = isAbsolute(specifier) ? pathToFileURL(specifier) : isBuiltinSpecifier(specifier) ? specifier : import.meta.resolve(specifier, pathToFileURL(testPath));
         const modulePath = 'string' == typeof resolvedPath ? resolvedPath : resolvedPath.pathname;
         if (importAttributes?.with?.rstest) delete importAttributes.with.rstest;
         if (modulePath.endsWith('.json')) {

package/dist/0~loadModule.js

@@ -11,7 +11,7 @@ const loadModule_createRequire = (filename, distPath, rstestContext, assetFiles,
     const _require = (()=>{
         try {
             return createRequire(filename);
-        } catch (_err) {
+        } catch  {
             return createRequire(distPath);
         }
     })();

package/dist/0~runTests.js

@@ -212,9 +212,16 @@ async function runTests(context) {
     };
     let browserProjectsToRun = browserProjects;
     let nodeProjectsToRun = nodeProjects;
-    if (shard) {
-        browserProjectsToRun = browserProjects.filter((p)=>Object.keys(entriesCache.get(p.environmentName)?.entries || {}).length > 0);
-        nodeProjectsToRun = nodeProjects.filter((p)=>Object.keys(entriesCache.get(p.environmentName)?.entries || {}).length > 0);
+    if (isWatchMode) {
+        if (shard) {
+            browserProjectsToRun = browserProjects.filter((p)=>Object.keys(entriesCache.get(p.environmentName)?.entries || {}).length > 0);
+            nodeProjectsToRun = nodeProjects.filter((p)=>Object.keys(entriesCache.get(p.environmentName)?.entries || {}).length > 0);
+        }
+    } else {
+        await Promise.all(allProjects.map((p)=>globTestSourceEntries(p.environmentName)));
+        const hasEntries = (env)=>Object.keys(entriesCache.get(env)?.entries || {}).length > 0;
+        browserProjectsToRun = browserProjects.filter((p)=>hasEntries(p.environmentName));
+        nodeProjectsToRun = nodeProjects.filter((p)=>hasEntries(p.environmentName));
     }
     const hasBrowserTestsToRun = browserProjectsToRun.length > 0;
     const hasNodeTestsToRun = nodeProjectsToRun.length > 0;
@@ -248,7 +255,7 @@ async function runTests(context) {
             getSetupFiles(globalSetup, rootPath)
         ];
     }));
-    const rsbuildInstance = await prepareRsbuild(context, globTestSourceEntries, setupFiles, globalSetupFiles);
+    const rsbuildInstance = await prepareRsbuild(context, globTestSourceEntries, setupFiles, globalSetupFiles, projects);
     const { getRsbuildStats, closeServer } = await createRsbuildServer({
         inspectedConfig: {
             ...context.normalizedConfig,
@@ -292,8 +299,12 @@ async function runTests(context) {
             if (entries.length && globalSetupEntries.length && !p._globalSetups) {
                 p._globalSetups = true;
                 const files = globalSetupEntries.flatMap((e)=>e.files);
-                const assetFiles = await getAssetFiles(files);
-                const sourceMaps = await getSourceMaps(files);
+                const assetFilesPromise = getAssetFiles(files);
+                const sourceMapsPromise = getSourceMaps(files);
+                const [assetFiles, sourceMaps] = await Promise.all([
+                    assetFilesPromise,
+                    sourceMapsPromise
+                ]);
                 const { success, errors } = await runGlobalSetup({
                     globalSetupEntries,
                     assetFiles,