@rspack/test-tools 1.5.7 → 1.6.0-beta.0

package/dist/case/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createNormalCase = exports.createHotNormalCase = exports.createNativeWatcher = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createErrorCase = exports.createDiffCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
+exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createProdNormalCase = exports.createNormalCase = exports.createHotNormalCase = exports.createDevNormalCase = exports.createNativeWatcher = exports.createMultiCompilerCase = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createExampleCase = exports.createEsmOutputCase = exports.createErrorCase = exports.createDiffCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
 var builtin_1 = require("./builtin");
 Object.defineProperty(exports, "createBuiltinCase", { enumerable: true, get: function () { return builtin_1.createBuiltinCase; } });
 var cache_1 = require("./cache");
@@ -18,6 +18,10 @@ var diff_1 = require("./diff");
 Object.defineProperty(exports, "createDiffCase", { enumerable: true, get: function () { return diff_1.createDiffCase; } });
 var error_1 = require("./error");
 Object.defineProperty(exports, "createErrorCase", { enumerable: true, get: function () { return error_1.createErrorCase; } });
+var esm_output_1 = require("./esm-output");
+Object.defineProperty(exports, "createEsmOutputCase", { enumerable: true, get: function () { return esm_output_1.createEsmOutputCase; } });
+var example_1 = require("./example");
+Object.defineProperty(exports, "createExampleCase", { enumerable: true, get: function () { return example_1.createExampleCase; } });
 var hash_1 = require("./hash");
 Object.defineProperty(exports, "createHashCase", { enumerable: true, get: function () { return hash_1.createHashCase; } });
 var hook_1 = require("./hook");
@@ -29,11 +33,15 @@ Object.defineProperty(exports, "createHotStepCase", { enumerable: true, get: fun
 var incremental_1 = require("./incremental");
 Object.defineProperty(exports, "createHotIncrementalCase", { enumerable: true, get: function () { return incremental_1.createHotIncrementalCase; } });
 Object.defineProperty(exports, "createWatchIncrementalCase", { enumerable: true, get: function () { return incremental_1.createWatchIncrementalCase; } });
+var multi_compiler_1 = require("./multi-compiler");
+Object.defineProperty(exports, "createMultiCompilerCase", { enumerable: true, get: function () { return multi_compiler_1.createMultiCompilerCase; } });
 var native_watcher_1 = require("./native-watcher");
 Object.defineProperty(exports, "createNativeWatcher", { enumerable: true, get: function () { return native_watcher_1.createNativeWatcher; } });
 var normal_1 = require("./normal");
+Object.defineProperty(exports, "createDevNormalCase", { enumerable: true, get: function () { return normal_1.createDevNormalCase; } });
 Object.defineProperty(exports, "createHotNormalCase", { enumerable: true, get: function () { return normal_1.createHotNormalCase; } });
 Object.defineProperty(exports, "createNormalCase", { enumerable: true, get: function () { return normal_1.createNormalCase; } });
+Object.defineProperty(exports, "createProdNormalCase", { enumerable: true, get: function () { return normal_1.createProdNormalCase; } });
 var serial_1 = require("./serial");
 Object.defineProperty(exports, "createSerialCase", { enumerable: true, get: function () { return serial_1.createSerialCase; } });
 var stats_api_1 = require("./stats-api");

package/dist/case/multi-compiler.d.ts

@@ -0,0 +1,18 @@
+import type { ECompilerType, ITestContext, TCompilation, TCompiler, TCompilerOptions, TCompilerStats, TCompilerStatsCompilation } from "../type";
+export declare function createMultiCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
+export type TMultiCompilerCaseConfig = {
+    description: string;
+    error?: boolean;
+    skip?: boolean;
+    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+    compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    build?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    check?: ({ context, stats, files, compiler, compilation }: {
+        context: ITestContext;
+        stats?: TCompilerStatsCompilation<ECompilerType.Rspack>;
+        files?: Record<string, string>;
+        compiler: TCompiler<ECompilerType.Rspack>;
+        compilation?: TCompilation<ECompilerType.Rspack>;
+    }) => Promise<void>;
+    compilerCallback?: (error: Error | null, stats: TCompilerStats<ECompilerType.Rspack> | null) => void;
+};

package/dist/case/multi-compiler.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMultiCompilerCase = createMultiCompilerCase;
+const node_path_1 = __importDefault(require("node:path"));
+const memfs_1 = require("memfs");
+const creator_1 = require("../test/creator");
+const common_1 = require("./common");
+function createMultiCompilerProcessor(name, caseConfig) {
+    return {
+        config: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            const options = Object.assign([
+                {
+                    name: "a",
+                    context: node_path_1.default.join(__dirname, "fixtures"),
+                    entry: "./a.js"
+                },
+                {
+                    name: "b",
+                    context: node_path_1.default.join(__dirname, "fixtures"),
+                    entry: "./b.js"
+                }
+            ], caseConfig.options?.(context) || {});
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            if (caseConfig.compilerCallback) {
+                compiler.createCompilerWithCallback(caseConfig.compilerCallback);
+            }
+            else {
+                compiler.createCompiler();
+            }
+            const c = compiler.getCompiler();
+            c.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
+            c.watchFileSystem = {
+                watch() {
+                    // watch should return a watcher instance
+                    // watcher instance should have close, pause and getInfo methods
+                    return {
+                        close: () => { },
+                        pause: () => { },
+                        getInfo: () => {
+                            return {
+                                changes: new Set(),
+                                removals: new Set(),
+                                fileTimeInfoEntries: new Map(),
+                                directoryTimeInfoEntries: new Map()
+                            };
+                        }
+                    };
+                }
+            };
+            await caseConfig.compiler?.(context, c);
+        },
+        build: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            if (typeof caseConfig.build === "function") {
+                await caseConfig.build?.(context, compiler.getCompiler());
+            }
+            else {
+                await compiler.build();
+            }
+        },
+        run: async (env, context) => { },
+        check: async (env, context) => { }
+    };
+}
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name, caseConfig }) => {
+        return [
+            createMultiCompilerProcessor(name, caseConfig)
+        ];
+    },
+    concurrent: false
+});
+function createMultiCompilerCase(name, src, dist, testConfig) {
+    let caseConfigList = require(testConfig);
+    if (!Array.isArray(caseConfigList)) {
+        caseConfigList = [caseConfigList];
+    }
+    for (let i = 0; i < caseConfigList.length; i++) {
+        const caseConfig = caseConfigList[i];
+        if (caseConfig.skip) {
+            it.skip(`${name}[${i}]`, () => { });
+            continue;
+        }
+        creator.create(`${name}[${i}]`, src, dist, undefined, {
+            caseConfig,
+            description: () => caseConfig.description
+        });
+    }
+}

package/dist/case/normal.d.ts

@@ -1,2 +1,4 @@
 export declare function createNormalCase(name: string, src: string, dist: string): void;
 export declare function createHotNormalCase(name: string, src: string, dist: string): void;
+export declare function createDevNormalCase(name: string, src: string, dist: string): void;
+export declare function createProdNormalCase(name: string, src: string, dist: string): void;

package/dist/case/normal.js

@@ -5,14 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNormalCase = createNormalCase;
 exports.createHotNormalCase = createHotNormalCase;
+exports.createDevNormalCase = createDevNormalCase;
+exports.createProdNormalCase = createProdNormalCase;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const core_1 = require("@rspack/core");
 const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 const runner_1 = require("./runner");
-const NORMAL_CASES_ROOT = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/normalCases");
-const createCaseOptions = (hot) => {
+const NORMAL_CASES_ROOT = node_path_1.default.resolve(__TEST_PATH__, "normalCases");
+const createCaseOptions = (hot, mode) => {
     return {
         clean: true,
         describe: false,
@@ -22,7 +24,7 @@ const createCaseOptions = (hot) => {
                     const compiler = (0, common_1.getCompiler)(context, name);
                     let options = defaultOptions(context, {
                         plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
-                    });
+                    }, mode);
                     options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
                     overrideOptions(context, options);
                     compiler.setOptions(options);
@@ -56,6 +58,14 @@ const hotCreator = new creator_1.BasicCaseCreator(createCaseOptions(true));
 function createHotNormalCase(name, src, dist) {
     hotCreator.create(name, src, dist);
 }
+const devCreator = new creator_1.BasicCaseCreator(createCaseOptions(false, "development"));
+function createDevNormalCase(name, src, dist) {
+    devCreator.create(name, src, dist);
+}
+const prodCreator = new creator_1.BasicCaseCreator(createCaseOptions(false, "production"));
+function createProdNormalCase(name, src, dist) {
+    prodCreator.create(name, src, dist);
+}
 function findBundle(context, options) {
     const testConfig = context.getTestConfig();
     if (typeof testConfig.findBundle === "function") {
@@ -64,7 +74,7 @@ function findBundle(context, options) {
     const filename = options.output?.filename;
     return typeof filename === "string" ? filename : undefined;
 }
-function defaultOptions(context, compilerOptions) {
+function defaultOptions(context, compilerOptions, mode) {
     let testConfig = {};
     const testConfigPath = node_path_1.default.join(context.getSource(), "test.config.js");
     if (node_fs_1.default.existsSync(testConfigPath)) {
@@ -80,11 +90,12 @@ function defaultOptions(context, compilerOptions) {
         entry: `./${node_path_1.default.relative(NORMAL_CASES_ROOT, context.getSource())}/`,
         target: compilerOptions?.target || "async-node",
         devtool: compilerOptions?.devtool,
-        mode: compilerOptions?.mode || "none",
+        mode: compilerOptions?.mode || mode || "none",
         optimization: compilerOptions?.mode
             ? {
-                // emitOnErrors: true,
+                emitOnErrors: true,
                 minimizer: [terserForTesting],
+                minimize: false,
                 ...testConfig.optimization
             }
             : {
@@ -98,7 +109,7 @@ function defaultOptions(context, compilerOptions) {
                 usedExports: true,
                 mangleExports: true,
                 // CHANGE: rspack does not support `emitOnErrors` yet.
-                // emitOnErrors: true,
+                emitOnErrors: true,
                 concatenateModules: !!testConfig?.optimization?.concatenateModules,
                 innerGraph: true,
                 // CHANGE: size is not supported yet
@@ -106,6 +117,7 @@ function defaultOptions(context, compilerOptions) {
                 // chunkIds: "size",
                 moduleIds: "named",
                 chunkIds: "named",
+                minimize: false,
                 minimizer: [terserForTesting],
                 ...compilerOptions?.optimization
             },
@@ -181,17 +193,12 @@ function defaultOptions(context, compilerOptions) {
             asyncWebAssembly: true,
             topLevelAwait: true,
             inlineConst: true,
-            lazyBarrel: true,
             // CHANGE: rspack does not support `backCompat` yet.
             // backCompat: false,
             // CHANGE: Rspack enables `css` by default.
             // Turning off here to fallback to webpack's default css processing logic.
             ...(compilerOptions?.module ? { outputModule: true } : {})
         }
-        // infrastructureLogging: compilerOptions?.cache && {
-        //   debug: true,
-        //   console: createLogger(infraStructureLog)
-        // }
     };
 }
 function overrideOptions(context, options) {

package/dist/case/stats-api.d.ts

@@ -1 +1,10 @@
+import type { ECompilerType, ITestContext, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
+export type TStatsAPICaseConfig = {
+    description: string;
+    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+    snapshotName?: string;
+    compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    build?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    check?: (stats: TCompilerStats<ECompilerType.Rspack>, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+};
 export declare function createStatsAPICase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/stats-api.js

@@ -2,42 +2,53 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStatsAPICase = createStatsAPICase;
 const memfs_1 = require("memfs");
-const simple_1 = require("../test/simple");
+const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 let addedSerializer = false;
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: true,
+    steps: ({ name, caseConfig }) => {
+        const config = caseConfig;
+        return [
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    compiler.setOptions(options(context, config.options));
+                },
+                compiler: async (context) => {
+                    const compilerManager = (0, common_1.getCompiler)(context, name);
+                    compilerManager.createCompiler();
+                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                },
+                build: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    if (typeof config.build === "function") {
+                        await config.build(context, compiler.getCompiler());
+                    }
+                    else {
+                        await compiler.build();
+                    }
+                },
+                run: async (env, context) => {
+                    // no need to run, just check the snapshot of diagnostics
+                },
+                check: async (env, context) => {
+                    await check(env, context, name, config.check);
+                }
+            }
+        ];
+    },
+    concurrent: true
+});
 function createStatsAPICase(name, src, dist, testConfig) {
     if (!addedSerializer) {
         addedSerializer = true;
     }
     const caseConfig = require(testConfig);
-    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    it(caseConfig.description, async () => {
-        await runner(name, {
-            config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
-                compiler.setOptions(options(context, caseConfig.options));
-            },
-            compiler: async (context) => {
-                const compilerManager = (0, common_1.getCompiler)(context, name);
-                compilerManager.createCompiler();
-                compiler(context, compilerManager.getCompiler(), caseConfig.compiler);
-            },
-            build: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
-                if (typeof caseConfig.build === "function") {
-                    await caseConfig.build(context, compiler.getCompiler());
-                }
-                else {
-                    await compiler.build();
-                }
-            },
-            run: async (env, context) => {
-                // no need to run, just check the snapshot of diagnostics
-            },
-            check: async (env, context) => {
-                await check(env, context, name, caseConfig.check);
-            }
-        });
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description
     });
 }
 function options(context, custom) {

package/dist/case/stats-output.d.ts

@@ -1 +1,11 @@
+import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
+export declare function createStatsProcessor(name: string, defaultOptions: (index: number, context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>, overrideOptions: (index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>) => void): {
+    before: (context: ITestContext) => Promise<void>;
+    config: (context: ITestContext) => Promise<void>;
+    compiler: (context: ITestContext) => Promise<void>;
+    build: (context: ITestContext) => Promise<void>;
+    run: (env: ITestEnv, context: ITestContext) => Promise<void>;
+    check: (env: ITestEnv, context: ITestContext) => Promise<void>;
+    after: (context: ITestContext) => Promise<void>;
+};
 export declare function createStatsOutputCase(name: string, src: string, dist: string): void;

package/dist/case/stats-output.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatsProcessor = createStatsProcessor;
 exports.createStatsOutputCase = createStatsOutputCase;
 const node_path_1 = __importDefault(require("node:path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -11,7 +12,7 @@ const captureStdio_1 = __importDefault(require("../helper/legacy/captureStdio"))
 const creator_1 = require("../test/creator");
 const common_1 = require("./common");
 const REG_ERROR_CASE = /error$/;
-function createStatsProcessor(name) {
+function createStatsProcessor(name, defaultOptions, overrideOptions) {
     const writeStatsOuptut = false;
     const snapshotName = "stats.txt";
     let stderr = null;
@@ -43,14 +44,17 @@ function createStatsProcessor(name) {
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
-    steps: ({ name }) => [createStatsProcessor(name)],
+    steps: ({ name }) => [
+        createStatsProcessor(name, defaultOptions, overrideOptions)
+    ],
     description: () => "should print correct stats for"
 });
 function createStatsOutputCase(name, src, dist) {
     creator.create(name, src, dist);
 }
 function defaultOptions(index, context) {
-    if (fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), "rspack.config.js"))) {
+    if (fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), "rspack.config.js")) ||
+        fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), "webpack.config.js"))) {
         return {
             experiments: {
                 css: true,
@@ -80,8 +84,7 @@ function defaultOptions(index, context) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
 }
@@ -171,7 +174,8 @@ async function check(env, context, name, writeStatsOuptut, snapshot, stderr) {
             // CHANGE: The time unit display in Rspack is second
             .replace(/[.0-9]+(\s?s)/g, "X$1")
             // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
-            .replace(/[0-9]+\.?[0-9]+ KiB/g, "xx KiB");
+            .replace(/[0-9]+\.?[0-9]+ KiB/g, "xx KiB")
+            .replace(/[0-9]+ ms/g, "xx ms");
     }
     const snapshotPath = node_path_1.default.isAbsolute(snapshot)
         ? snapshot

package/dist/case/watch.d.ts

@@ -1,8 +1,7 @@
 import { type ECompilerType, type ITestContext, type ITestEnv, type ITestRunner } from "../type";
-export declare function createWatchInitialProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher, ignoreNotFriendlyForIncrementalWarnings }?: {
+export declare function createWatchInitialProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher }?: {
     incremental?: boolean | undefined;
     nativeWatcher?: boolean | undefined;
-    ignoreNotFriendlyForIncrementalWarnings?: boolean | undefined;
 }): {
     before: (context: ITestContext) => Promise<void>;
     config: <T extends ECompilerType.Rspack>(context: ITestContext) => Promise<void>;
@@ -11,10 +10,9 @@ export declare function createWatchInitialProcessor(name: string, tempDir: strin
     run: (env: ITestEnv, context: ITestContext) => Promise<void>;
     check: <T extends ECompilerType.Rspack>(env: ITestEnv, context: ITestContext) => Promise<void>;
 };
-export declare function createWatchStepProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher, ignoreNotFriendlyForIncrementalWarnings }?: {
+export declare function createWatchStepProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher }?: {
     incremental?: boolean | undefined;
     nativeWatcher?: boolean | undefined;
-    ignoreNotFriendlyForIncrementalWarnings?: boolean | undefined;
 }): {
     before: (context: ITestContext) => Promise<void>;
     config: <T extends ECompilerType.Rspack>(context: ITestContext) => Promise<void>;

package/dist/case/watch.js

@@ -19,9 +19,7 @@ const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
 const common_1 = require("./common");
-// This file is used to port step number to rspack.config.js/webpack.config.js
-const currentWatchStepModulePath = node_path_1.default.resolve(__dirname, "../helper/util/currentWatchStep");
-function createWatchInitialProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false, ignoreNotFriendlyForIncrementalWarnings = false } = {}) {
+function createWatchInitialProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false } = {}) {
     const watchContext = {
         currentTriggerFilename: null,
         lastHash: null,
@@ -35,12 +33,13 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             context.setValue(name, "watchContext", watchContext);
         },
         config: async (context) => {
+            const testConfig = context.getTestConfig();
             const multiCompilerOptions = [];
             const caseOptions = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)));
             for (const [index, options] of caseOptions.entries()) {
                 const compilerOptions = (0, webpack_merge_1.default)(defaultOptions({
                     incremental,
-                    ignoreNotFriendlyForIncrementalWarnings
+                    ignoreNotFriendlyForIncrementalWarnings: testConfig.ignoreNotFriendlyForIncrementalWarnings
                 }), options);
                 overrideOptions(index, context, compilerOptions, tempDir, nativeWatcher);
                 multiCompilerOptions.push(compilerOptions);
@@ -60,8 +59,6 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
         },
         build: async (context) => {
             const compiler = (0, common_1.getCompiler)(context, name);
-            const currentWatchStepModule = require(currentWatchStepModulePath);
-            currentWatchStepModule.step[name] = watchContext.step;
             node_fs_1.default.mkdirSync(watchContext.tempDir, { recursive: true });
             (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), watchContext.tempDir, true);
             const task = new Promise((resolve, reject) => {
@@ -164,16 +161,13 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
         }
     };
 }
-function createWatchStepProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false, ignoreNotFriendlyForIncrementalWarnings = false } = {}) {
-    const processor = createWatchInitialProcessor(name, tempDir, step, watchState, { incremental, ignoreNotFriendlyForIncrementalWarnings });
+function createWatchStepProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false } = {}) {
+    const processor = createWatchInitialProcessor(name, tempDir, step, watchState, { incremental });
     processor.compiler = async (context) => {
         // do nothing
     };
     processor.build = async (context) => {
-        const watchContext = context.getValue(name, "watchContext");
         const compiler = (0, common_1.getCompiler)(context, name);
-        const currentWatchStepModule = require(currentWatchStepModulePath);
-        currentWatchStepModule.step[name] = watchContext.step;
         const task = new Promise((resolve, reject) => {
             compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
                 if (e)

package/dist/compare/compare.js

@@ -13,7 +13,6 @@ const helper_1 = require("../helper");
 const type_1 = require("../type");
 const format_code_1 = require("./format-code");
 const replace_runtime_module_name_1 = require("./replace-runtime-module-name");
-const WORKSPACE = node_path_1.default.resolve(__dirname, "../../../..");
 function compareFile(sourceFile, distFile, compareOptions) {
     const result = {
         type: type_1.ECompareResultType.Same,
@@ -49,7 +48,9 @@ function compareFile(sourceFile, distFile, compareOptions) {
         }
         return res;
     }
-    const sourceContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(sourceFile, "utf-8").replaceAll(WORKSPACE, "__WORKSPACE__"));
+    const sourceContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default
+        .readFileSync(sourceFile, "utf-8")
+        .replaceAll(__ROOT_PATH__, "__WORKSPACE__"));
     const sourceModules = (0, helper_1.parseModules)(sourceContent, {
         bootstrap: compareOptions.bootstrap,
         renameModule: compareOptions.renameModule
@@ -66,7 +67,9 @@ function compareFile(sourceFile, distFile, compareOptions) {
         distModules = JSON.parse(fs_extra_1.default.readFileSync(compareOptions.snapshot, "utf-8"));
     }
     else {
-        const distContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(distFile, "utf-8").replaceAll(WORKSPACE, "__WORKSPACE__"));
+        const distContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default
+            .readFileSync(distFile, "utf-8")
+            .replaceAll(__ROOT_PATH__, "__WORKSPACE__"));
         distModules = (0, helper_1.parseModules)(distContent, {
             bootstrap: compareOptions.bootstrap,
             renameModule: compareOptions.renameModule

package/dist/helper/directory.js

@@ -31,7 +31,7 @@ function describeByWalk(testFile, createCase, options = {}) {
             .filter(folder => {
             if (options.exclude) {
                 if (options.exclude.some(exclude => {
-                    return exclude.test(folder);
+                    return exclude.test(node_path_1.default.join(dirname, folder).replace(/\\/g, "/"));
                 })) {
                     return false;
                 }

package/dist/helper/expect/error.js

@@ -19,7 +19,7 @@ const prettyFormatOptions = {
                 return `"${val
                     .replace(/\\/gm, "/")
                     .replace(/"/gm, '\\"')
-                    .replace(/\r?\n/gm, "\\n")}"`;
+                    .replace(/\r?\n/gm, "")}"`;
             }
         }
     ]

package/dist/helper/expect/placeholder.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizePlaceholder = void 0;
-const node_path_1 = __importDefault(require("node:path"));
 const path_serializer_1 = require("path-serializer");
 // 1. escapeEOL \r\n -> \n
 // 2. replace <RSPACK_ROOT> etc
@@ -13,14 +9,18 @@ const placeholderSerializer = (0, path_serializer_1.createSnapshotSerializer)({
     root: __dirname.includes("node_modules")
         ? // Use `process.cwd()` when using outside Rspack
             process.cwd()
-        : node_path_1.default.resolve(__dirname, "../../../../../"),
+        : __ROOT_PATH__,
     replace: [
         {
-            match: node_path_1.default.resolve(__dirname, "../../../../../tests/rspack-test"),
+            match: __RSPACK_TEST_TOOLS_PATH__,
             mark: "test_tools_root"
         },
         {
-            match: node_path_1.default.resolve(__dirname, "../../../../rspack"),
+            match: __TEST_PATH__,
+            mark: "test_root"
+        },
+        {
+            match: __RSPACK_PATH__,
             mark: "rspack_root"
         },
         {

package/dist/helper/expect/to-match-file-snapshot.d.ts

@@ -1,4 +1,3 @@
-import type { FileMatcherOptions } from "../../../jest";
 /**
  * Match given content against content of the specified file.
  *

package/dist/helper/hot-update/plugin.d.ts

@@ -6,10 +6,10 @@ export declare class HotUpdatePlugin {
     private updateIndex;
     private files;
     constructor(projectDir: string, tempDir: string);
-    private getModifiedFiles;
     private getContent;
     private updateFiles;
     initialize(): Promise<void>;
+    getModifiedFiles(): string[];
     getUpdateIndex(): number;
     getTotalUpdates(): number;
     goNext(): Promise<void>;

package/dist/helper/hot-update/plugin.js

@@ -29,9 +29,6 @@ class HotUpdatePlugin {
         this.updateIndex = 0;
         this.files = {};
     }
-    getModifiedFiles() {
-        return Object.keys(this.files);
-    }
     getContent(filePath, index) {
         const contents = this.files[filePath] || [];
         let content = contents[index] === undefined ? contents.at(-1) || "" : contents[index];
@@ -71,7 +68,12 @@ class HotUpdatePlugin {
             return;
         }
         this.initialized = true;
-        await promises_1.default.rmdir(this.tempDir, { recursive: true });
+        try {
+            await promises_1.default.rmdir(this.tempDir, { recursive: true });
+        }
+        catch (_e) {
+            // empty
+        }
         await promises_1.default.cp(this.projectDir, this.tempDir, { recursive: true });
         await loopFile(this.tempDir, (filePath, content) => {
             const contents = content.split(/---+\r?\n/g);
@@ -81,13 +83,16 @@ class HotUpdatePlugin {
         });
         await this.updateFiles();
     }
+    getModifiedFiles() {
+        return Object.keys(this.files);
+    }
     getUpdateIndex() {
         return this.updateIndex;
     }
     getTotalUpdates() {
         return Object.values(this.files).reduce((max, item) => {
             return Math.max(max, item.length);
-        }, 0);
+        }, 1);
     }
     async goNext() {
         this.updateIndex++;