@rstest/core 0.7.4 → 0.7.6

package/dist/0~62.js

@@ -1,7 +1,7 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-import { checkPkgInstalled } from "./913.js";
-import { installGlobal, addDefaultErrorHandler } from "./0~681.js";
+import { checkPkgInstalled } from "./7913.js";
+import { installGlobal, addDefaultErrorHandler } from "./0~3062.js";
 const environment = {
     name: 'jsdom',
     async setup (global, { jsdom = {} }) {

package/dist/{0~588.js → 0~6588.js}

@@ -1,14 +1,14 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import "./664.js";
-import { runRest } from "./131.js";
-import { isTTY } from "./157.js";
-import { logger_logger } from "./278.js";
+import "./5693.js";
+import { runRest } from "./9131.js";
+import { isTTY } from "./1157.js";
+import { logger_logger } from "./3278.js";
 const GLOB_REGEX = /[*?{}[\]()!@+|]/;
 const isGlob = (str)=>GLOB_REGEX.test(str);
 async function createChokidar(pathOrGlobs, root, options) {
-    const chokidar = await import("./0~583.js").then((mod)=>({
+    const chokidar = await import("./0~7583.js").then((mod)=>({
             watch: mod.watch
         }));
     const watchFiles = new Set();
@@ -18,7 +18,7 @@ async function createChokidar(pathOrGlobs, root, options) {
         return false;
     });
     if (globPatterns.length) {
-        const { glob } = await import("./157.js").then((mod)=>({
+        const { glob } = await import("./1157.js").then((mod)=>({
                 glob: mod.glob
             }));
         const files = await glob(globPatterns, {

package/dist/{0~907.js → 0~6907.js}

@@ -1,6 +1,6 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
-import { encode } from "./397.js";
+import { encode } from "./4397.js";
 class BitSet {
     constructor(arg){
         this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
@@ -137,7 +137,7 @@ class Chunk {
     }
 }
 function getBtoa() {
-    if ('undefined' != typeof globalThis && 'function' == typeof globalThis.btoa) return (str)=>globalThis.btoa(unescape(encodeURIComponent(str)));
+    if ("u" > typeof globalThis && 'function' == typeof globalThis.btoa) return (str)=>globalThis.btoa(unescape(encodeURIComponent(str)));
     if ('function' == typeof Buffer) return (str)=>Buffer.from(str, 'utf-8').toString('base64');
     return ()=>{
         throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');

package/dist/{0~923.js → 0~6923.js}

@@ -1,10 +1,10 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import "./664.js";
-import { pathToFileURL } from "./198.js";
-import { node_vm, interopModule, shouldInterop } from "./0~346.js";
-import { posix, logger_logger } from "./278.js";
+import "./5693.js";
+import { pathToFileURL } from "./6198.js";
+import { node_vm, interopModule, shouldInterop } from "./0~3346.js";
+import { posix, logger_logger } from "./3278.js";
 const external_node_path_ = __webpack_require__("node:path");
 var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
     EsmMode[EsmMode["Unknown"] = 0] = "Unknown";
@@ -13,10 +13,14 @@ var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
     return EsmMode;
 }({});
 const isRelativePath = (p)=>/^\.\.?\//.test(p);
+let latestAssetFiles = {};
+const updateLatestAssetFiles = (assetFiles)=>{
+    latestAssetFiles = assetFiles;
+};
 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;
-        const content = assetFiles[joinedPath];
+        const content = assetFiles[joinedPath] || latestAssetFiles[joinedPath];
         if (content) try {
             return await loadModule({
                 codeContent: content,
@@ -114,7 +118,7 @@ const loadModule = async ({ codeContent, distPath, testPath, assetFiles, interop
                 });
                 meta.readWasmFile = (wasmPath, callback)=>{
                     const joinedPath = isRelativePath(wasmPath.pathname) ? posix.join(posix.dirname(distPath), wasmPath.pathname) : wasmPath.pathname;
-                    const content = assetFiles[posix.normalize(joinedPath)];
+                    const content = assetFiles[posix.normalize(joinedPath)] || latestAssetFiles[posix.normalize(joinedPath)];
                     if (content) callback(null, Buffer.from(content, 'base64'));
                     else callback(new Error(`WASM file ${joinedPath} not found in asset files.`));
                 };
@@ -147,4 +151,4 @@ const loadModule = async ({ codeContent, distPath, testPath, assetFiles, interop
     const ns = esm.namespace;
     return ns.default && ns.default instanceof Promise ? ns.default : ns;
 };
-export { asModule, loadEsModule_EsmMode, loadModule };
+export { asModule, loadEsModule_EsmMode, loadModule, updateLatestAssetFiles };

package/dist/0~6973.js

@@ -0,0 +1,50 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./rslib-runtime.js";
+import "./5693.js";
+import { fileURLToPath } from "./6198.js";
+import { rspack } from "./9131.js";
+import { getAbsolutePath, formatTestEntryName } from "./1157.js";
+import { posix } from "./3278.js";
+const external_node_fs_ = __webpack_require__("fs");
+const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+const tryResolve = (request, rootPath)=>{
+    const { resolver } = rspack.experiments;
+    const esmFirstResolver = new resolver.ResolverFactory({
+        conditionNames: [
+            'node',
+            'import',
+            'require'
+        ]
+    });
+    const { path: resolvedPath } = esmFirstResolver.sync(rootPath, request);
+    return resolvedPath;
+};
+const getSetupFiles = (setups, rootPath)=>{
+    if (!setups.length) return {};
+    return Object.fromEntries(setups.map((filePath)=>{
+        const setupFile = filePath.startsWith('file://') ? fileURLToPath(filePath) : filePath;
+        const setupFilePath = getAbsolutePath(rootPath, setupFile);
+        try {
+            if (!(0, external_node_fs_.existsSync)(setupFilePath)) {
+                let errorMessage = `Setup file ${picocolors_default().red(setupFile)} not found`;
+                if (setupFilePath !== setupFile) errorMessage += picocolors_default().gray(` (resolved path: ${setupFilePath})`);
+                throw errorMessage;
+            }
+            const relativePath = posix.relative(rootPath, setupFilePath);
+            return [
+                formatTestEntryName(relativePath),
+                setupFilePath
+            ];
+        } catch (err) {
+            const resolvedPath = tryResolve(setupFile, rootPath);
+            if (resolvedPath) return [
+                formatTestEntryName(setupFile),
+                resolvedPath
+            ];
+            throw err;
+        }
+    }));
+};
+export { getSetupFiles };

package/dist/{0~583.js → 0~7583.js}

@@ -1,12 +1,12 @@
-/*! For license information please see 0~583.js.LICENSE.txt */
+/*! For license information please see 0~7583.js.LICENSE.txt */
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { lstat, open as promises_open, readdir, realpath as promises_realpath, stat as promises_stat } from "fs/promises";
 import { Readable } from "node:stream";
-import "./664.js";
-import { readdir as promises_readdir, lstat as promises_lstat, promises_stat as promises_promises_stat, realpath as external_node_fs_promises_realpath } from "./157.js";
-import { EventEmitter } from "./131.js";
+import "./5693.js";
+import { readdir as promises_readdir, lstat as promises_lstat, promises_stat as promises_promises_stat, realpath as external_node_fs_promises_realpath } from "./1157.js";
+import { EventEmitter } from "./9131.js";
 const external_node_path_ = __webpack_require__("node:path");
 const EntryTypes = {
     FILE_TYPE: 'files',

package/dist/{0~426.js → 0~8426.js}

@@ -1,9 +1,9 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import "./157.js";
-import "./664.js";
-import { relative } from "./278.js";
+import "./1157.js";
+import "./5693.js";
+import { relative } from "./3278.js";
 const picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js");
 var picomatch_default = /*#__PURE__*/ __webpack_require__.n(picomatch);
 const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");

package/dist/0~89.js

@@ -4,12 +4,13 @@ import { __webpack_require__ } from "./rslib-runtime.js";
 import node_events from "node:events";
 import { Tinypool } from "tinypool";
 import node_inspector from "node:inspector";
-import { isBuiltin } from "./664.js";
-import { node_process, basename, isDebug, dirname, posix, resolve as pathe_M_eThtNZ_resolve, join } from "./278.js";
-import { fileURLToPath } from "./198.js";
-import { node_v8, createBirpc } from "./216.js";
-import { serializableConfig, bgColor, TEMP_RSTEST_OUTPUT_DIR, TEMP_RSTEST_OUTPUT_DIR_GLOB, castArray, ADDITIONAL_NODE_BUILTINS, needFlagExperimentalDetectModule } from "./157.js";
-import { core_logger, createRsbuild } from "./131.js";
+import "./5693.js";
+import { node_process, basename, isDebug, dirname, posix, resolve as pathe_M_eThtNZ_resolve, join } from "./3278.js";
+import { fileURLToPath } from "./6198.js";
+import { node_v8, createBirpc } from "./3216.js";
+import { serializableConfig, bgColor, TEMP_RSTEST_OUTPUT_DIR, TEMP_RSTEST_OUTPUT_DIR_GLOB, castArray, ADDITIONAL_NODE_BUILTINS, needFlagExperimentalDetectModule } from "./1157.js";
+import { isBuiltin } from "./4881.js";
+import { core_logger, createRsbuild } from "./9131.js";
 const DefaultMaxHeapSize = 1073741824;
 function memory_isMemorySufficient(options) {
     const { memoryThreshold = 0.7, maxHeapSize = DefaultMaxHeapSize } = options || {};
@@ -561,6 +562,7 @@ const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, globalSe
                         };
                     };
                     config.watchOptions ??= {};
+                    config.watchOptions.aggregateTimeout = 5;
                     config.watchOptions.ignored = castArray(config.watchOptions.ignored || []);
                     if (0 === config.watchOptions.ignored.length) config.watchOptions.ignored.push('**/.git', '**/node_modules');
                     config.watchOptions.ignored.push(TEMP_RSTEST_OUTPUT_DIR_GLOB, context.normalizedConfig.coverage.reportsDirectory, ...Object.values(globalSetupFiles?.[environment.name] || {}), '**/*.snap');
@@ -752,7 +754,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
 const pluginCacheControl = (setupFiles)=>({
         name: 'rstest:cache-control',
         setup: (api)=>{
-            api.transform({
+            if (setupFiles.length) api.transform({
                 test: setupFiles
             }, ({ code })=>({
                     code: `
@@ -834,10 +836,10 @@ const prepareRsbuild = async (context, globTestSourceEntries, setupFiles, global
         }
     });
     if (coverage?.enabled && 'list' !== command) {
-        const { loadCoverageProvider } = await import("./734.js").then((mod)=>({
+        const { loadCoverageProvider } = await import("./5734.js").then((mod)=>({
                 loadCoverageProvider: mod.loadCoverageProvider
             }));
-        const { pluginCoverageCore } = await import("./0~255.js").then((mod)=>({
+        const { pluginCoverageCore } = await import("./0~2255.js").then((mod)=>({
                 pluginCoverageCore: mod.pluginCoverageCore
             }));
         const { pluginCoverage } = await loadCoverageProvider(coverage, context.rootPath);
@@ -849,50 +851,79 @@ const prepareRsbuild = async (context, globTestSourceEntries, setupFiles, global
     }
     return rsbuildInstance;
 };
-const calcEntriesToRerun = (entries, chunks, buildData, runtimeChunkName)=>{
-    const entryToChunkHashesMap = new Map();
-    const buildChunkHashes = (entry)=>{
+const calcEntriesToRerun = (entries, chunks, buildData, runtimeChunkName, setupEntries)=>{
+    const buildChunkHashes = (entry, map)=>{
         const validChunks = (entry.chunks || []).filter((chunk)=>chunk !== runtimeChunkName);
         validChunks.forEach((chunkName)=>{
             const chunkInfo = chunks?.find((c)=>c.names?.includes(chunkName));
             if (chunkInfo) {
-                const existing = entryToChunkHashesMap.get(entry.testPath) || {};
+                const existing = map.get(entry.testPath) || {};
                 existing[chunkName] = chunkInfo.hash ?? '';
-                entryToChunkHashesMap.set(entry.testPath, existing);
+                map.set(entry.testPath, existing);
             }
         });
     };
-    (entries || []).forEach(buildChunkHashes);
+    const processEntryChanges = (_entries, prevHashes, currentHashesMap)=>{
+        const affectedPaths = new Set();
+        const deletedPaths = [];
+        if (prevHashes) {
+            const prevMap = new Map(prevHashes.map((e)=>[
+                    e.name,
+                    e.chunks
+                ]));
+            const currentNames = new Set(currentHashesMap.keys());
+            deletedPaths.push(...Array.from(prevMap.keys()).filter((name)=>!currentNames.has(name)));
+            const findAffectedEntry = (testPath)=>{
+                const currentChunks = currentHashesMap.get(testPath);
+                const prevChunks = prevMap.get(testPath);
+                if (!currentChunks) return;
+                if (!prevChunks) return void affectedPaths.add(testPath);
+                const hasChanges = Object.entries(currentChunks).some(([chunkName, hash])=>prevChunks[chunkName] !== hash);
+                if (hasChanges) affectedPaths.add(testPath);
+            };
+            currentHashesMap.forEach((_, testPath)=>{
+                findAffectedEntry(testPath);
+            });
+        }
+        return {
+            affectedPaths,
+            deletedPaths
+        };
+    };
+    const previousSetupHashes = buildData.setupEntryToChunkHashes;
+    const previousEntryHashes = buildData.entryToChunkHashes;
+    const setupEntryToChunkHashesMap = new Map();
+    setupEntries.forEach((entry)=>{
+        buildChunkHashes(entry, setupEntryToChunkHashesMap);
+    });
+    const setupEntryToChunkHashes = Array.from(setupEntryToChunkHashesMap.entries()).map(([name, chunks])=>({
+            name,
+            chunks
+        }));
+    buildData.setupEntryToChunkHashes = setupEntryToChunkHashes;
+    const entryToChunkHashesMap = new Map();
+    (entries || []).forEach((entry)=>{
+        buildChunkHashes(entry, entryToChunkHashesMap);
+    });
     const entryToChunkHashes = Array.from(entryToChunkHashesMap.entries()).map(([name, chunks])=>({
             name,
             chunks
         }));
-    const affectedTestPaths = new Set();
-    const deletedEntries = [];
-    if (buildData.entryToChunkHashes) {
-        const prevMap = new Map(buildData.entryToChunkHashes.map((e)=>[
-                e.name,
-                e.chunks
-            ]));
-        const currentNames = new Set(entryToChunkHashesMap.keys());
-        deletedEntries.push(...Array.from(prevMap.keys()).filter((name)=>!currentNames.has(name)));
-        const findAffectedEntry = (testPath)=>{
-            const currentChunks = entryToChunkHashesMap.get(testPath);
-            const prevChunks = prevMap.get(testPath);
-            if (!currentChunks) return;
-            if (!prevChunks) return void affectedTestPaths.add(testPath);
-            const hasChanges = Object.entries(currentChunks).some(([chunkName, hash])=>prevChunks[chunkName] !== hash);
-            if (hasChanges) affectedTestPaths.add(testPath);
-        };
-        entryToChunkHashesMap.forEach((_, testPath)=>{
-            findAffectedEntry(testPath);
-        });
-    }
     buildData.entryToChunkHashes = entryToChunkHashes;
+    const isSetupChanged = ()=>{
+        const { affectedPaths: affectedSetupPaths, deletedPaths: deletedSetups } = processEntryChanges(setupEntries, previousSetupHashes, setupEntryToChunkHashesMap);
+        const affectedSetups = Array.from(affectedSetupPaths).map((testPath)=>setupEntries.find((e)=>e.testPath === testPath)).filter((entry)=>void 0 !== entry);
+        return affectedSetups.length > 0 || deletedSetups.length > 0;
+    };
+    if (isSetupChanged()) return {
+        affectedEntries: entries,
+        deletedEntries: []
+    };
+    const { affectedPaths: affectedTestPaths, deletedPaths } = processEntryChanges(entries, previousEntryHashes, entryToChunkHashesMap);
     const affectedEntries = Array.from(affectedTestPaths).map((testPath)=>entries.find((e)=>e.testPath === testPath)).filter((entry)=>void 0 !== entry);
     return {
         affectedEntries,
-        deletedEntries
+        deletedEntries: deletedPaths
     };
 };
 class AssetsMemorySafeMap extends Map {
@@ -902,7 +933,7 @@ class AssetsMemorySafeMap extends Map {
         return super.set(key, value);
     }
 }
-const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, globalSetupFiles, rsbuildInstance, inspectedConfig })=>{
+const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, globalSetupFiles, rsbuildInstance, inspectedConfig, isWatchMode })=>{
     let rspackCompiler;
     const rstestCompilerPlugin = {
         name: 'rstest:compiler',
@@ -932,13 +963,20 @@ const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, globalSe
     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 readFile = async (fileName)=>new Promise((resolve, reject)=>{
+    const cachedReadFilePromises = new Map();
+    const readFile = async (fileName)=>{
+        if (cachedReadFilePromises.has(fileName)) return cachedReadFilePromises.get(fileName);
+        const promise = new Promise((resolve, reject)=>{
             outputFileSystem.readFile(fileName, (err, data)=>{
                 if (err) reject(err);
                 const content = 'string' == typeof data ? data : fileName.endsWith('.wasm') ? data.toString('base64') : data.toString('utf-8');
                 resolve(content);
             });
         });
+        cachedReadFilePromises.set(fileName, promise);
+        promise.finally(()=>cachedReadFilePromises.delete(fileName));
+        return promise;
+    };
     const buildData = {};
     const getEntryFiles = async (manifest, outputPath)=>{
         const entryFiles = {};
@@ -1015,7 +1053,10 @@ const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, globalSe
             ];
         }));
         buildData[environmentName] ??= {};
-        const { affectedEntries, deletedEntries } = calcEntriesToRerun(entries, chunks, buildData[environmentName], `${environmentName}-${RUNTIME_CHUNK_NAME}`);
+        const { affectedEntries, deletedEntries } = isWatchMode ? calcEntriesToRerun(entries, chunks, buildData[environmentName], `${environmentName}-${RUNTIME_CHUNK_NAME}`, setupEntries) : {
+            affectedEntries: [],
+            deletedEntries: []
+        };
         const cachedAssetFiles = new AssetsMemorySafeMap();
         const cachedSourceMaps = new AssetsMemorySafeMap();
         const readFileWithCache = async (name)=>{

package/dist/0~8957.js

@@ -0,0 +1,149 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { M, T } from "./0~6151.js";
+const isMockFunction = (fn)=>'function' == typeof fn && '_isMockFunction' in fn && fn._isMockFunction;
+const initSpy = ()=>{
+    let callOrder = 0;
+    const mocks = new Set();
+    const wrapSpy = (obj, methodName, mockFn)=>{
+        const spyImpl = M(obj, methodName, mockFn);
+        const spyFn = spyImpl;
+        let mockImplementationOnce = [];
+        let implementation = mockFn;
+        let mockName = mockFn?.name;
+        const initMockState = ()=>({
+                instances: [],
+                contexts: [],
+                invocationCallOrder: []
+            });
+        let mockState = initMockState();
+        const spyState = T(spyImpl);
+        spyFn.getMockName = ()=>mockName || methodName;
+        spyFn.mockName = (name)=>{
+            mockName = name;
+            return spyFn;
+        };
+        spyFn.getMockImplementation = ()=>mockImplementationOnce.length ? mockImplementationOnce[mockImplementationOnce.length - 1] : implementation;
+        function withImplementation(fn, cb) {
+            const originalImplementation = implementation;
+            const originalMockImplementationOnce = mockImplementationOnce;
+            implementation = fn;
+            mockImplementationOnce = [];
+            spyState.willCall(willCall);
+            const reset = ()=>{
+                implementation = originalImplementation;
+                mockImplementationOnce = originalMockImplementationOnce;
+            };
+            const result = cb();
+            if (result instanceof Promise) return result.then(()=>{
+                reset();
+            });
+            reset();
+        }
+        spyFn.withImplementation = withImplementation;
+        spyFn.mockImplementation = (fn)=>{
+            implementation = fn;
+            return spyFn;
+        };
+        spyFn.mockImplementationOnce = (fn)=>{
+            mockImplementationOnce.push(fn);
+            return spyFn;
+        };
+        spyFn.mockReturnValue = (value)=>spyFn.mockImplementation(()=>value);
+        spyFn.mockReturnValueOnce = (value)=>spyFn.mockImplementationOnce(()=>value);
+        spyFn.mockResolvedValue = (value)=>spyFn.mockImplementation(()=>Promise.resolve(value));
+        spyFn.mockResolvedValueOnce = (value)=>spyFn.mockImplementationOnce(()=>Promise.resolve(value));
+        spyFn.mockRejectedValue = (value)=>spyFn.mockImplementation(()=>Promise.reject(value));
+        spyFn.mockRejectedValueOnce = (value)=>spyFn.mockImplementationOnce(()=>Promise.reject(value));
+        spyFn.mockReturnThis = ()=>spyFn.mockImplementation(function() {
+                return this;
+            });
+        function willCall(...args) {
+            let impl = implementation || spyState.getOriginal();
+            mockState.instances.push(this);
+            mockState.contexts.push(this);
+            mockState.invocationCallOrder.push(++callOrder);
+            if (mockImplementationOnce.length) impl = mockImplementationOnce.shift();
+            return impl?.apply(this, args);
+        }
+        spyState.willCall(willCall);
+        Object.defineProperty(spyFn, 'mock', {
+            get: ()=>({
+                    get calls () {
+                        return spyState.calls;
+                    },
+                    get lastCall () {
+                        return spyState.calls[spyState.callCount - 1];
+                    },
+                    get instances () {
+                        return mockState.instances;
+                    },
+                    get contexts () {
+                        return mockState.contexts;
+                    },
+                    get invocationCallOrder () {
+                        return mockState.invocationCallOrder;
+                    },
+                    get results () {
+                        return spyState.results.map(([resultType, value])=>{
+                            const type = 'error' === resultType ? 'throw' : 'return';
+                            return {
+                                type: type,
+                                value
+                            };
+                        });
+                    },
+                    get settledResults () {
+                        return spyState.resolves.map(([resultType, value])=>{
+                            const type = 'error' === resultType ? 'rejected' : 'fulfilled';
+                            return {
+                                type,
+                                value
+                            };
+                        });
+                    }
+                })
+        });
+        spyFn.mockClear = ()=>{
+            mockState = initMockState();
+            spyState.reset();
+            return spyFn;
+        };
+        spyFn.mockReset = ()=>{
+            spyFn.mockClear();
+            implementation = mockFn;
+            mockImplementationOnce = [];
+            return spyFn;
+        };
+        spyFn.mockRestore = ()=>{
+            spyFn.mockReset();
+            spyState.restore();
+            mockName = mockFn?.name;
+        };
+        mocks.add(spyFn);
+        return spyFn;
+    };
+    const fn = (mockFn)=>{
+        const defaultName = 'rstest.fn()';
+        return wrapSpy({
+            [defaultName]: mockFn
+        }, defaultName, mockFn);
+    };
+    const spyOn = (obj, methodName, accessType)=>{
+        const accessTypeMap = {
+            get: 'getter',
+            set: 'setter'
+        };
+        const method = accessType ? {
+            [accessTypeMap[accessType]]: methodName
+        } : methodName;
+        return wrapSpy(obj, method);
+    };
+    return {
+        isMockFunction: isMockFunction,
+        spyOn,
+        fn,
+        mocks
+    };
+};
+export { initSpy };

package/dist/{0~634.js → 0~9634.js}

@@ -1,15 +1,18 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import "./664.js";
+import "./5693.js";
 import { prepareRsbuild, createPool, createRsbuildServer, runGlobalTeardown, runGlobalSetup } from "./0~89.js";
-import { getTestEntries, getSetupFiles, getTaskNameWithPrefix, prettyTestPath, ROOT_SUITE_NAME, bgColor } from "./157.js";
-import { logger_logger } from "./278.js";
+import { getTestEntries, getTaskNameWithPrefix, prettyTestPath, ROOT_SUITE_NAME, bgColor } from "./1157.js";
+import { logger_logger } from "./3278.js";
 const external_node_fs_ = __webpack_require__("fs");
 const external_node_path_ = __webpack_require__("node:path");
 const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
 var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
 const collectTests = async ({ context, globTestSourceEntries })=>{
+    const { getSetupFiles } = await import("./0~6973.js").then((mod)=>({
+            getSetupFiles: mod.getSetupFiles
+        }));
     const setupFiles = Object.fromEntries(context.projects.map((project)=>{
         const { environmentName, rootPath, normalizedConfig: { setupFiles } } = project;
         return [
@@ -28,6 +31,7 @@ const collectTests = async ({ context, globTestSourceEntries })=>{
     const { getRsbuildStats, closeServer } = await createRsbuildServer({
         globTestSourceEntries,
         globalSetupFiles,
+        isWatchMode: false,
         inspectedConfig: {
             ...context.normalizedConfig,
             projects: context.projects.map((p)=>p.normalizedConfig)
@@ -152,7 +156,7 @@ async function listTests(context, { filesOnly, json, printLocation, includeSuite
     const hasError = list.some((file)=>file.errors?.length) || errors.length;
     const showProject = context.projects.length > 1;
     if (hasError) {
-        const { printError } = await import("./131.js").then((mod)=>({
+        const { printError } = await import("./9131.js").then((mod)=>({
                 printError: mod.error_printError
             }));
         process.exitCode = 1;
@@ -167,7 +171,7 @@ async function listTests(context, { filesOnly, json, printLocation, includeSuite
             }
         }
         if (errors.length) {
-            const { printError } = await import("./131.js").then((mod)=>({
+            const { printError } = await import("./9131.js").then((mod)=>({
                     printError: mod.error_printError
                 }));
             for (const error of errors || []){

package/dist/{157.js → 1157.js}

@@ -4,8 +4,8 @@ import { __webpack_require__ } from "./rslib-runtime.js";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
 import promises, { lstat, readdir, realpath, stat as promises_stat, writeFile } from "node:fs/promises";
-import { createRequire as external_node_module_createRequire } from "./664.js";
-import { normalize, isAbsolute, posix, join, parse } from "./278.js";
+import "./5693.js";
+import { normalize, isAbsolute, posix, join, parse } from "./3278.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         const pico = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js");
@@ -1377,11 +1377,11 @@ __webpack_require__.add({
         exports.escapeRegex = (str)=>str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
         exports.toPosixSlashes = (str)=>str.replace(REGEX_BACKSLASH, '/');
         exports.isWindows = ()=>{
-            if ('undefined' != typeof navigator && navigator.platform) {
+            if ("u" > typeof navigator && navigator.platform) {
                 const platform = navigator.platform.toLowerCase();
                 return 'win32' === platform || 'windows' === platform;
             }
-            if ('undefined' != typeof process && process.platform) return 'win32' === process.platform;
+            if ("u" > typeof process && process.platform) return 'win32' === process.platform;
             return false;
         };
         exports.removeBackslashes = (str)=>str.replace(REGEX_REMOVE_BACKSLASH, (match)=>'\\' === match ? '' : match);
@@ -2375,43 +2375,6 @@ const getTestEntries = async ({ include, exclude, rootPath, projectRoot, fileFil
         ];
     }));
 };
-const tryResolve = (request, rootPath)=>{
-    try {
-        const require = external_node_module_createRequire(rootPath);
-        return require.resolve(request, {
-            paths: [
-                rootPath
-            ]
-        });
-    } catch (_err) {
-        return;
-    }
-};
-const getSetupFiles = (setups, rootPath)=>{
-    if (!setups.length) return {};
-    return Object.fromEntries(setups.map((setupFile)=>{
-        const setupFilePath = getAbsolutePath(rootPath, setupFile);
-        try {
-            if (!(0, external_node_fs_.existsSync)(setupFilePath)) {
-                let errorMessage = `Setup file ${picocolors_default().red(setupFile)} not found`;
-                if (setupFilePath !== setupFile) errorMessage += picocolors_default().gray(` (resolved path: ${setupFilePath})`);
-                throw errorMessage;
-            }
-            const relativePath = posix.relative(rootPath, setupFilePath);
-            return [
-                formatTestEntryName(relativePath),
-                setupFilePath
-            ];
-        } catch (err) {
-            const resolvedPath = tryResolve(setupFile, rootPath);
-            if (resolvedPath) return [
-                formatTestEntryName(setupFile),
-                resolvedPath
-            ];
-            throw err;
-        }
-    }));
-};
 const prettyTestPath = (testPath)=>{
     const { dir, base } = parsePosix(testPath);
     return `${'.' !== dir ? picocolors_default().gray(`${dir}/`) : ''}${picocolors_default().cyan(base)}`;
@@ -2422,4 +2385,4 @@ const formatTestPath = (root, testFilePath)=>{
     return prettyTestPath(testPath);
 };
 const picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js");
-export { ADDITIONAL_NODE_BUILTINS, DEFAULT_CONFIG_EXTENSIONS, DEFAULT_CONFIG_NAME, ROOT_SUITE_NAME, TEMP_RSTEST_OUTPUT_DIR, TEMP_RSTEST_OUTPUT_DIR_GLOB, TS_CONFIG_FILE, bgColor, castArray, filterProjects, formatError, formatRootStr, formatTestPath, getAbsolutePath, getSetupFiles, getTaskNameWithPrefix, getTestEntries, glob, globalApis, isDynamicPattern, isObject, isTTY, lstat, needFlagExperimentalDetectModule, prettyTestPath, prettyTime, promises_stat, readdir, realpath, serializableConfig, undoSerializableConfig, writeFile };
+export { ADDITIONAL_NODE_BUILTINS, DEFAULT_CONFIG_EXTENSIONS, DEFAULT_CONFIG_NAME, ROOT_SUITE_NAME, TEMP_RSTEST_OUTPUT_DIR, TEMP_RSTEST_OUTPUT_DIR_GLOB, TS_CONFIG_FILE, bgColor, castArray, filterProjects, formatError, formatRootStr, formatTestEntryName, formatTestPath, getAbsolutePath, getTaskNameWithPrefix, getTestEntries, glob, globalApis, isDynamicPattern, isObject, isTTY, lstat, needFlagExperimentalDetectModule, prettyTestPath, prettyTime, promises_stat, readdir, realpath, serializableConfig, undoSerializableConfig, writeFile };