@rspack/test-tools 1.3.6 → 1.3.8

package/dist/case/new-incremental.d.ts

@@ -1,3 +1,6 @@
 import { ECompilerType, type EDocumentType, type TCompilerOptions } from "../type";
 export declare function createHotNewIncrementalCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], documentType: EDocumentType): void;
-export declare function createWatchNewIncrementalCase(name: string, src: string, dist: string, temp: string): void;
+export type WatchNewIncrementalOptions = {
+    ignoreNotFriendlyForIncrementalWarnings?: boolean;
+};
+export declare function createWatchNewIncrementalCase(name: string, src: string, dist: string, temp: string, options?: WatchNewIncrementalOptions): void;

package/dist/case/new-incremental.js

@@ -39,47 +39,62 @@ function createHotNewIncrementalCase(name, src, dist, target, documentType) {
     const creator = getHotCreator(target, documentType);
     creator.create(name, src, dist);
 }
-const watchCreator = new creator_1.BasicCaseCreator({
-    clean: true,
-    runner: runner_1.WatchRunnerFactory,
-    description: (name, index) => {
-        return index === 0
-            ? `${name} should compile`
-            : `should compile the next step ${index}`;
-    },
-    describe: false,
-    steps: ({ name, src, temp }) => {
-        const watchState = {};
-        const runs = node_fs_1.default
-            .readdirSync(src)
-            .sort()
-            .filter(name => {
-            return node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory();
-        })
-            .map(name => ({ name }));
-        return runs.map((run, index) => index === 0
-            ? new watch_1.WatchProcessor({
-                name,
-                stepName: run.name,
-                tempDir: temp,
-                runable: true,
-                compilerType: type_1.ECompilerType.Rspack,
-                configFiles: ["rspack.config.js", "webpack.config.js"],
-                experiments: {
-                    incremental: true
-                }
-            }, watchState)
-            : new watch_1.WatchStepProcessor({
-                name,
-                stepName: run.name,
-                tempDir: temp,
-                runable: true,
-                compilerType: type_1.ECompilerType.Rspack,
-                configFiles: ["rspack.config.js", "webpack.config.js"]
-            }, watchState));
-    },
-    concurrent: true
-});
-function createWatchNewIncrementalCase(name, src, dist, temp) {
-    watchCreator.create(name, src, dist, temp);
+const watchCreators = new Map();
+function getWatchCreator(options) {
+    const key = JSON.stringify(options);
+    if (!watchCreators.has(key)) {
+        watchCreators.set(key, new creator_1.BasicCaseCreator({
+            clean: true,
+            runner: runner_1.WatchRunnerFactory,
+            description: (name, index) => {
+                return index === 0
+                    ? `${name} should compile`
+                    : `should compile step ${index}`;
+            },
+            describe: false,
+            steps: ({ name, src, temp }) => {
+                const watchState = {};
+                const runs = node_fs_1.default
+                    .readdirSync(src)
+                    .sort()
+                    .filter(name => {
+                    return node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory();
+                })
+                    .map(name => ({ name }));
+                return runs.map((run, index) => index === 0
+                    ? new watch_1.WatchProcessor({
+                        name,
+                        stepName: run.name,
+                        tempDir: temp,
+                        runable: true,
+                        compilerType: type_1.ECompilerType.Rspack,
+                        configFiles: ["rspack.config.js", "webpack.config.js"],
+                        defaultOptions(index, context) {
+                            return {
+                                experiments: {
+                                    incremental: "advance"
+                                },
+                                ignoreWarnings: options.ignoreNotFriendlyForIncrementalWarnings
+                                    ? [/is not friendly for incremental/]
+                                    : undefined
+                            };
+                        }
+                    }, watchState)
+                    : new watch_1.WatchStepProcessor({
+                        name,
+                        stepName: run.name,
+                        tempDir: temp,
+                        runable: true,
+                        compilerType: type_1.ECompilerType.Rspack,
+                        configFiles: ["rspack.config.js", "webpack.config.js"]
+                    }, watchState));
+            },
+            concurrent: true
+        }));
+    }
+    return watchCreators.get(key);
+}
+function createWatchNewIncrementalCase(name, src, dist, temp, options = {}) {
+    const creator = getWatchCreator(options);
+    creator.create(name, src, dist, temp);
 }

package/dist/case/watch.js

@@ -16,7 +16,7 @@ const creator = new creator_1.BasicCaseCreator({
     description: (name, index) => {
         return index === 0
             ? `${name} should compile`
-            : `should compile the next step ${index}`;
+            : `should compile step ${index}`;
     },
     describe: false,
     steps: ({ name, src, temp }) => {

package/dist/compiler.js

@@ -74,6 +74,9 @@ class TestCompilerManager {
             // This is a workaround for the issue that watchpack cannot detect the file change in time
             // so we set the poll to 300ms to make it more sensitive to the file change
             poll: 300,
+            // Rspack ignored node_modules and .git by default for better performance, but for tests we
+            // want to watch all files, which aligns with webpack's default behavior
+            ignored: [],
             aggregateTimeout: timeout
         }, (error, newStats) => {
             this.emitter.emit(ECompilerEvent.Build, error, newStats);

package/dist/processor/basic.js

@@ -67,6 +67,9 @@ class BasicProcessor {
             return;
         }
         for (const bundle of bundles) {
+            if (!bundle) {
+                continue;
+            }
             const runnerFactory = context.getRunnerFactory(this._options.name);
             if (!runnerFactory) {
                 throw new Error(`Test case ${this._options.name} is not runable`);

package/dist/processor/hot-new-incremental.js

@@ -29,7 +29,7 @@ class HotNewIncrementalProcessor extends hot_1.HotProcessor {
         if (this._hotOptions.compilerType === type_1.ECompilerType.Rspack) {
             const rspackOptions = options;
             rspackOptions.experiments ??= {};
-            rspackOptions.experiments.incremental ??= true;
+            rspackOptions.experiments.incremental ??= "advance";
         }
         else {
             throw new Error("HotNewIncrementalProcessor should only used for Rspack.");

package/dist/processor/watch.d.ts

@@ -1,12 +1,8 @@
 import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
 import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
-type TRspackExperiments = TCompilerOptions<ECompilerType>["experiments"];
-type TRspackOptimization = TCompilerOptions<ECompilerType>["optimization"];
 export interface IWatchProcessorOptions<T extends ECompilerType> extends IMultiTaskProcessorOptions<T> {
     stepName: string;
     tempDir: string;
-    experiments?: TRspackExperiments;
-    optimization?: TRspackOptimization;
 }
 export declare class WatchProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
     protected _watchOptions: IWatchProcessorOptions<T>;
@@ -19,7 +15,7 @@ export declare class WatchProcessor<T extends ECompilerType> extends MultiTaskPr
     run(env: ITestEnv, context: ITestContext): Promise<void>;
     check(env: ITestEnv, context: ITestContext): Promise<void>;
     config(context: ITestContext): Promise<void>;
-    static overrideOptions<T extends ECompilerType>({ tempDir, name, experiments, optimization }: IWatchProcessorOptions<T>): (index: number, context: ITestContext, options: TCompilerOptions<ECompilerType>) => void;
+    static overrideOptions<T extends ECompilerType>({ tempDir, name }: IWatchProcessorOptions<T>): (index: number, context: ITestContext, options: TCompilerOptions<ECompilerType>) => void;
     static findBundle<T extends ECompilerType>(this: IWatchProcessorOptions<T>, index: number, context: ITestContext, options: TCompilerOptions<T>): string | string[];
 }
 export interface IWatchStepProcessorOptions<T extends ECompilerType> extends Omit<IWatchProcessorOptions<T>, "experiments" | "optimization"> {
@@ -31,4 +27,3 @@ export declare class WatchStepProcessor<T extends ECompilerType> extends WatchPr
     compiler(context: ITestContext): Promise<void>;
     build(context: ITestContext): Promise<void>;
 }
-export {};

package/dist/processor/watch.js

@@ -159,7 +159,7 @@ class WatchProcessor extends multi_1.MultiTaskProcessor {
         const compiler = this.getCompiler(context);
         compiler.setOptions(compilerOptions);
     }
-    static overrideOptions({ tempDir, name, experiments, optimization }) {
+    static overrideOptions({ tempDir, name }) {
         return (index, context, options) => {
             if (!options.mode)
                 options.mode = "development";
@@ -184,25 +184,9 @@ class WatchProcessor extends multi_1.MultiTaskProcessor {
                 options.cache.cacheDirectory = cacheDirectory;
                 options.cache.name = `config-${index}`;
             }
-            if (experiments) {
-                if (!options.experiments)
-                    options.experiments = {};
-                for (const key of Object.keys(experiments)) {
-                    if (options.experiments[key] === undefined)
-                        options.experiments[key] = experiments[key];
-                }
-            }
-            if (optimization) {
-                if (!options.optimization)
-                    options.optimization = {};
-                for (const key of Object.keys(optimization)) {
-                    if (options.optimization[key] === undefined)
-                        options.optimization[key] = optimization[key];
-                }
-            }
+            options.optimization ??= {};
             options.experiments ??= {};
-            options.experiments.css ??=
-                true;
+            options.experiments.css ??= true;
             options.experiments.rspackFuture ??= {};
             options.experiments.rspackFuture.bundlerInfo ??= {};
             options.experiments.rspackFuture.bundlerInfo.force ??= false;

package/dist/test/creator.js

@@ -79,34 +79,31 @@ class BasicCaseCreator {
         });
         const ender = this.registerConcurrentTask(name, starter);
         const env = this.createConcurrentEnv();
-        let bailout = false;
         for (let index = 0; index < tester.total; index++) {
             let stepSignalResolve = null;
-            let stepSignalReject = null;
             const stepSignal = new Promise((resolve, reject) => {
                 stepSignalResolve = resolve;
-                stepSignalReject = reject;
+            }).catch(e => {
+                // prevent unhandled rejection
             });
             const description = typeof this._options.description === "function"
                 ? this._options.description(name, index)
                 : index
                     ? `step [${index}] should pass`
                     : "should pass";
-            it(description, async () => {
-                await stepSignal;
+            it(description, cb => {
+                stepSignal.then((e) => {
+                    cb(e);
+                });
             }, this._options.timeout || 180000);
             chain = chain.then(async () => {
                 try {
-                    if (bailout) {
-                        throw `Case "${name}" step ${index + 1} bailout because ${tester.step + 1} failed`;
-                    }
                     env.clear();
                     await tester.compile();
                     await tester.check(env);
                     await env.run();
                     const context = tester.getContext();
                     if (!tester.next() && context.hasError()) {
-                        bailout = true;
                         const errors = context
                             .getError()
                             .map(i => `${i.stack}`.split("\n").join("\t\n"))
@@ -116,11 +113,21 @@ class BasicCaseCreator {
                     stepSignalResolve();
                 }
                 catch (e) {
-                    stepSignalReject(e);
+                    stepSignalResolve(e);
+                    return Promise.reject();
                 }
+            }, e => {
+                // bailout
+                stepSignalResolve();
+                return Promise.reject();
             });
         }
-        chain.finally(() => {
+        chain
+            .catch(e => {
+            // bailout error
+            // prevent unhandled rejection
+        })
+            .finally(() => {
             ender();
         });
         afterAll(async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/test-tools",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -54,12 +54,12 @@
     "source-map": "^0.7.4",
     "terser-webpack-plugin": "^5.3.14",
     "webpack": "5.99.6",
-    "webpack-merge": "5.10.0",
+    "webpack-merge": "6.0.1",
     "webpack-sources": "3.2.3"
   },
   "devDependencies": {
     "@rspack/plugin-preact-refresh": "1.1.2",
-    "@rspack/plugin-react-refresh": "^1.2.1",
+    "@rspack/plugin-react-refresh": "^1.4.1",
     "@swc/helpers": "0.5.17",
     "@swc/plugin-remove-console": "^7.0.3",
     "@types/babel__generator": "7.27.0",
@@ -94,12 +94,12 @@
     "source-map-loader": "^5.0.0",
     "style-loader": "^4.0.0",
     "terser": "5.39.0",
-    "typescript": "^5.7.3",
+    "typescript": "^5.8.3",
     "wast-loader": "^1.14.1",
     "worker-rspack-loader": "^3.1.2",
-    "@rspack/cli": "1.3.6",
-    "@rspack/core": "1.3.6",
-    "@rspack/test-tools": "1.3.6"
+    "@rspack/cli": "1.3.8",
+    "@rspack/test-tools": "1.3.8",
+    "@rspack/core": "1.3.8"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"