@rspack/test-tools 1.3.6 → 1.3.7

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 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"],
+                        defaultOptions(index, context) {
+                            return {
+                                experiments: {
+                                    incremental: true
+                                },
+                                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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/test-tools",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -97,9 +97,9 @@
     "typescript": "^5.7.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/test-tools": "1.3.7",
+    "@rspack/core": "1.3.7",
+    "@rspack/cli": "1.3.7"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"