@rspack-canary/test-tools 1.5.4-canary-8cc7f155-20250915173802 → 1.5.5-canary-03ab52ad-20250916180415

package/dist/case/compiler.d.ts

@@ -1,6 +1,15 @@
 import { type ISimpleProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TCompilerCaseConfig = Omit<ISimpleProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+import { ECompilerType, type ITestContext, type TCompilation, type TCompiler, type TCompilerStatsCompilation } from "../type";
+export type TCompilerCaseConfig = Omit<ISimpleProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType" | "check"> & {
     description: string;
+    error?: boolean;
+    skip?: boolean;
+    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>;
 };
 export declare function createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/compiler.js

@@ -5,13 +5,116 @@ const processor_1 = require("../processor");
 const simple_1 = require("../test/simple");
 const type_1 = require("../type");
 function createCompilerCase(name, src, dist, testConfig) {
-    const caseConfig = require(testConfig);
+    let caseConfigList = require(testConfig);
+    if (!Array.isArray(caseConfigList)) {
+        caseConfigList = [caseConfigList];
+    }
     const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    it(caseConfig.description, async () => {
-        await runner(name, new processor_1.SimpleTaskProcessor({
-            name: name,
-            compilerType: type_1.ECompilerType.Rspack,
-            ...caseConfig
-        }));
-    });
+    for (const caseConfig of caseConfigList) {
+        const testFn = caseConfig.skip ? it.skip : it;
+        testFn(caseConfig.description, async () => {
+            const logs = {
+                mkdir: [],
+                writeFile: []
+            };
+            const files = {};
+            await runner(name, new processor_1.SimpleTaskProcessor({
+                name: name,
+                compilerType: type_1.ECompilerType.Rspack,
+                compilerCallback: caseConfig.compilerCallback,
+                build: caseConfig.build,
+                options: context => {
+                    const options = caseConfig.options?.(context) || {};
+                    options.mode ??= "production";
+                    options.context ??= context.getSource();
+                    options.entry ??= "./a.js";
+                    options.output ??= {};
+                    options.output.path ??= "/";
+                    options.output.pathinfo ??= true;
+                    options.optimization ??= {};
+                    options.optimization.minimize ??= false;
+                    return options;
+                },
+                async compiler(context, compiler) {
+                    compiler.outputFileSystem = {
+                        // CHANGE: Added support for the `options` parameter to enable recursive directory creation,
+                        // accommodating Rspack's requirement that differs from webpack's usage
+                        mkdir(path, callback) {
+                            const recursive = false;
+                            // if (typeof options === "function") {
+                            // 	callback = options;
+                            // } else if (options) {
+                            // 	if (options.recursive !== undefined) recursive = options.recursive;
+                            // }
+                            logs.mkdir.push(path);
+                            if (recursive) {
+                                callback();
+                            }
+                            else {
+                                const err = new Error();
+                                err.code = "EEXIST";
+                                callback(err);
+                            }
+                        },
+                        writeFile(name, content, callback) {
+                            logs.writeFile.push(name, content);
+                            files[name] = content.toString("utf-8");
+                            callback();
+                        },
+                        stat(path, callback) {
+                            callback(new Error("ENOENT"));
+                        }
+                    };
+                    compiler.hooks.compilation.tap("CompilerTest", compilation => (compilation.bail = true));
+                    await caseConfig.compiler?.(context, compiler);
+                },
+                async check(context, compiler, stats) {
+                    if (caseConfig.error) {
+                        const statsJson = stats?.toJson({
+                            modules: true,
+                            reasons: true
+                        });
+                        const compilation = stats?.compilation;
+                        await caseConfig.check?.({
+                            context,
+                            compiler,
+                            stats: statsJson,
+                            compilation,
+                            files
+                        });
+                    }
+                    else if (stats) {
+                        expect(typeof stats).toBe("object");
+                        const compilation = stats.compilation;
+                        const statsJson = stats.toJson({
+                            modules: true,
+                            reasons: true
+                        });
+                        expect(typeof statsJson).toBe("object");
+                        expect(statsJson).toHaveProperty("errors");
+                        expect(Array.isArray(statsJson.errors)).toBe(true);
+                        if (statsJson.errors.length > 0) {
+                            expect(statsJson.errors[0]).toBeInstanceOf(Object);
+                            throw statsJson.errors[0];
+                        }
+                        statsJson.logs = logs;
+                        await caseConfig.check?.({
+                            context,
+                            stats: statsJson,
+                            files,
+                            compiler,
+                            compilation
+                        });
+                    }
+                    else {
+                        await caseConfig.check?.({
+                            context,
+                            files,
+                            compiler
+                        });
+                    }
+                }
+            }));
+        });
+    }
 }

package/dist/case/normal.d.ts

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

package/dist/case/normal.js

@@ -4,26 +4,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNormalCase = createNormalCase;
+exports.createHotNormalCase = createHotNormalCase;
 const node_path_1 = __importDefault(require("node:path"));
+const core_1 = require("@rspack/core");
 const normal_1 = require("../processor/normal");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
-const creator = new creator_1.BasicCaseCreator({
-    clean: true,
-    describe: false,
-    steps: ({ name }) => [
-        new normal_1.NormalProcessor({
-            name,
-            root: node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/normalCases"),
-            compilerOptions: {}, // do not used in rspack
-            runable: true,
-            compilerType: type_1.ECompilerType.Rspack
-        })
-    ],
-    runner: runner_1.NormalRunnerFactory,
-    concurrent: true
-});
+const NORMAL_CASES_ROOT = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/normalCases");
+const createCaseOptions = (hot) => {
+    return {
+        clean: true,
+        describe: false,
+        steps: ({ name }) => [
+            new normal_1.NormalProcessor({
+                name,
+                root: NORMAL_CASES_ROOT,
+                compilerOptions: {
+                    plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
+                },
+                runable: true,
+                compilerType: type_1.ECompilerType.Rspack
+            })
+        ],
+        runner: runner_1.NormalRunnerFactory,
+        concurrent: true
+    };
+};
+const creator = new creator_1.BasicCaseCreator(createCaseOptions(false));
 function createNormalCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+const hotCreator = new creator_1.BasicCaseCreator(createCaseOptions(true));
+function createHotNormalCase(name, src, dist) {
+    hotCreator.create(name, src, dist);
+}

package/dist/compiler.d.ts

@@ -6,20 +6,21 @@ export declare enum ECompilerEvent {
     Create = "create",
     Close = "close"
 }
-export declare const COMPILER_FACTORIES: TCompilerFactories;
+export declare const COMPILER_FACTORIES: TCompilerFactories<ECompilerType>;
 export declare class TestCompilerManager<T extends ECompilerType> implements ITestCompilerManager<T> {
     protected type: T;
-    protected factories: TCompilerFactories;
+    protected factories: TCompilerFactories<T>;
     protected compilerOptions: TCompilerOptions<T>;
     protected compilerInstance: TCompiler<T> | null;
     protected compilerStats: TCompilerStats<T> | null;
     protected emitter: EventEmitter;
-    constructor(type: T, factories?: TCompilerFactories);
+    constructor(type: T, factories?: TCompilerFactories<T>);
     getOptions(): TCompilerOptions<T>;
     setOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
     mergeOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
     getCompiler(): TCompiler<T> | null;
     createCompiler(): TCompiler<T>;
+    createCompilerWithCallback(callback: (error: Error | null, stats: TCompilerStats<T> | null) => void): TCompiler<T>;
     build(): Promise<TCompilerStats<T>>;
     watch(timeout?: number): void;
     getStats(): TCompilerStats<T> | null;

package/dist/compiler.js

@@ -15,8 +15,8 @@ var ECompilerEvent;
     ECompilerEvent["Close"] = "close";
 })(ECompilerEvent || (exports.ECompilerEvent = ECompilerEvent = {}));
 exports.COMPILER_FACTORIES = {
-    [type_1.ECompilerType.Rspack]: ((options) => require("@rspack/core")(options)),
-    [type_1.ECompilerType.Webpack]: ((options) => require("webpack")(options))
+    [type_1.ECompilerType.Rspack]: ((options, callback) => require("@rspack/core")(options, callback)),
+    [type_1.ECompilerType.Webpack]: ((options, callback) => require("webpack")(options, callback))
 };
 class TestCompilerManager {
     constructor(type, factories = exports.COMPILER_FACTORIES) {
@@ -48,6 +48,11 @@ class TestCompilerManager {
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }
+    createCompilerWithCallback(callback) {
+        this.compilerInstance = this.factories[this.type](this.compilerOptions, callback);
+        this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
+        return this.compilerInstance;
+    }
     build() {
         if (!this.compilerInstance)
             throw new Error("Compiler should be created before build");

package/dist/helper/legacy/deprecationTracking.d.ts

@@ -0,0 +1 @@
+export function start(handler: any): () => any[];

package/dist/helper/legacy/deprecationTracking.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+/*
+    MIT License http://www.opensource.org/licenses/mit-license.php
+    Author Tobias Koppers @sokra
+*/
+"use strict";
+const util = require("util");
+let interception = undefined;
+const originalDeprecate = util.deprecate;
+util.deprecate = (fn, message, code) => {
+    const original = originalDeprecate(fn, message, code);
+    return function (...args) {
+        if (interception) {
+            interception.set(`${code}: ${message}`, {
+                code,
+                message,
+                stack: new Error(message).stack
+            });
+            return fn.apply(this, args);
+        }
+        else {
+            return original.apply(this, args);
+        }
+    };
+};
+exports.start = handler => {
+    interception = new Map();
+    return () => {
+        const map = interception;
+        interception = undefined;
+        return Array.from(map || [])
+            .sort(([a], [b]) => {
+            if (a < b)
+                return -1;
+            if (a > b)
+                return 1;
+            return 0;
+        })
+            .map(([key, data]) => data);
+    };
+};

package/dist/processor/simple.d.ts

@@ -1,6 +1,7 @@
 import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
 export interface ISimpleProcessorOptions<T extends ECompilerType> {
     options?: (context: ITestContext) => TCompilerOptions<T>;
+    compilerCallback?: (error: Error | null, stats: TCompilerStats<T> | null) => void;
     compilerType: T;
     name: string;
     build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;

package/dist/processor/simple.js

@@ -13,7 +13,9 @@ class SimpleTaskProcessor {
     }
     async compiler(context) {
         const compiler = this.getCompiler(context);
-        const instance = compiler.createCompiler();
+        const instance = this._options.compilerCallback
+            ? compiler.createCompilerWithCallback(this._options.compilerCallback)
+            : compiler.createCompiler();
         if (typeof this._options.compiler === "function") {
             await this._options.compiler(context, instance);
         }

package/dist/type.d.ts

@@ -1,6 +1,6 @@
 import type EventEmitter from "node:events";
-import type { Compiler as RspackCompiler, MultiStats as RspackMultiStats, RspackOptions, Stats as RspackStats, StatsCompilation as RspackStatsCompilation } from "@rspack/core";
-import type { Compiler as WebpackCompiler, MultiStats as WebpackMultiStats, Configuration as WebpackOptions, Stats as WebpackStats, StatsCompilation as WebpackStatsCompilation } from "webpack";
+import type { Compilation as RspackCompilation, Compiler as RspackCompiler, MultiStats as RspackMultiStats, RspackOptions, Stats as RspackStats, StatsCompilation as RspackStatsCompilation } from "@rspack/core";
+import type { Compilation as WebpackCompilation, Compiler as WebpackCompiler, MultiStats as WebpackMultiStats, Configuration as WebpackOptions, Stats as WebpackStats, StatsCompilation as WebpackStatsCompilation } from "webpack";
 import type { IBasicModuleScope, TRunnerRequirer } from "./runner/type";
 export interface ITestContext {
     getSource(sub?: string): string;
@@ -25,6 +25,7 @@ export declare enum ECompilerType {
 }
 export type TCompilerOptions<T> = T extends ECompilerType.Rspack ? RspackOptions : WebpackOptions;
 export type TCompiler<T> = T extends ECompilerType.Rspack ? RspackCompiler : WebpackCompiler;
+export type TCompilation<T> = T extends ECompilerType.Rspack ? RspackCompilation : WebpackCompilation;
 export type TCompilerStats<T> = T extends ECompilerType.Rspack ? RspackStats : WebpackStats;
 export type TCompilerMultiStats<T> = T extends ECompilerType.Rspack ? RspackMultiStats : WebpackMultiStats;
 export type TCompilerStatsCompilation<T> = T extends ECompilerType.Rspack ? RspackStatsCompilation : WebpackStatsCompilation;
@@ -34,6 +35,7 @@ export interface ITestCompilerManager<T extends ECompilerType> {
     mergeOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
     getCompiler(): TCompiler<T> | null;
     createCompiler(): TCompiler<T>;
+    createCompilerWithCallback(callback: (error: Error | null, stats: TCompilerStats<T> | null) => void): TCompiler<T>;
     build(): Promise<TCompilerStats<T>>;
     watch(timeout?: number): void;
     getStats(): TCompilerStats<T> | TCompilerMultiStats<T> | null;
@@ -51,7 +53,7 @@ export interface ITesterConfig {
     temp?: string;
     steps?: ITestProcessor[];
     testConfig?: TTestConfig<ECompilerType>;
-    compilerFactories?: TCompilerFactories;
+    compilerFactories?: TCompilerFactories<ECompilerType>;
     contextValue?: Record<string, unknown>;
     runnerFactory?: new (name: string, context: ITestContext) => TRunnerFactory<ECompilerType>;
 }
@@ -157,7 +159,7 @@ export interface ITestRunner {
     getRequire(): TRunnerRequirer;
     getGlobal(name: string): unknown;
 }
-export type TCompilerFactory<T extends ECompilerType> = (options: TCompilerOptions<T> | TCompilerOptions<T>[]) => TCompiler<T>;
+export type TCompilerFactory<T extends ECompilerType> = (options: TCompilerOptions<T> | TCompilerOptions<T>[], callback?: (error: Error | null, stats: TCompilerStats<T> | null) => void) => TCompiler<T>;
 export interface TRunnerFactory<T extends ECompilerType> {
     create(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }
@@ -166,4 +168,4 @@ export type TUpdateOptions = {
     totalUpdates: number;
     changedFiles: string[];
 };
-export type TCompilerFactories = Record<ECompilerType, TCompilerFactory<ECompilerType>>;
+export type TCompilerFactories<T extends ECompilerType> = Record<T, TCompilerFactory<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack-canary/test-tools",
-  "version": "1.5.4-canary-8cc7f155-20250915173802",
+  "version": "1.5.5-canary-03ab52ad-20250916180415",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -35,15 +35,15 @@
     "directory": "packages/rspack-test-tools"
   },
   "dependencies": {
-    "@babel/generator": "7.28.0",
-    "@babel/parser": "7.28.0",
-    "@babel/traverse": "7.28.0",
-    "@babel/types": "7.28.2",
+    "@babel/generator": "7.28.3",
+    "@babel/parser": "7.28.4",
+    "@babel/traverse": "7.28.4",
+    "@babel/types": "7.28.4",
     "cross-env": "^7.0.3",
     "csv-to-markdown-table": "^1.5.0",
     "deepmerge": "^4.3.1",
     "filenamify": "4.3.0",
-    "fs-extra": "^11.3.0",
+    "fs-extra": "^11.3.2",
     "glob": "^11.0.3",
     "graceful-fs": "^4.2.11",
     "iconv-lite": "^0.6.3",
@@ -52,7 +52,7 @@
     "jsdom": "^26.1.0",
     "memfs": "4.38.2",
     "loader-utils": "^2.0.4",
-    "path-serializer": "0.5.0",
+    "path-serializer": "0.5.1",
     "pretty-format": "29.7.0",
     "rimraf": "^5.0.10",
     "source-map": "^0.7.6",
@@ -63,33 +63,33 @@
   },
   "devDependencies": {
     "@rspack/plugin-preact-refresh": "1.1.2",
-    "@rspack/plugin-react-refresh": "^1.5.0",
+    "@rspack/plugin-react-refresh": "^1.5.1",
     "@swc/helpers": "0.5.17",
     "@swc/plugin-remove-console": "^9.0.0",
     "@types/babel__generator": "7.27.0",
     "@types/babel__traverse": "7.28.0",
     "@types/fs-extra": "11.0.4",
     "@types/jsdom": "^21.1.7",
-    "@types/react": "^19.1.8",
-    "@types/react-dom": "^19.1.6",
+    "@types/react": "^19.1.13",
+    "@types/react-dom": "^19.1.9",
     "@webdiscus/pug-loader": "^2.11.1",
     "acorn": "^8.15.0",
     "babel-loader": "^10.0.0",
     "babel-plugin-import": "^1.13.8",
     "chalk": "^4.1.2",
-    "core-js": "3.45.0",
+    "core-js": "3.45.1",
     "css-loader": "^7.1.2",
     "file-loader": "^6.2.0",
     "graceful-fs": "^4.2.11",
     "html-loader": "^5.1.0",
-    "html-webpack-plugin": "^5.6.3",
+    "html-webpack-plugin": "^5.6.4",
     "less-loader": "^12.3.0",
     "lodash": "^4.17.21",
     "postcss-loader": "^8.2.0",
     "postcss-pxtorem": "^6.1.0",
     "raw-loader": "^4.0.2",
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
     "react-refresh": "^0.17.0",
     "sass-loader": "^16.0.5",
     "source-map": "^0.7.6",
@@ -100,10 +100,10 @@
     "wast-loader": "^1.14.1",
     "worker-rspack-loader": "^3.1.2",
     "exports-loader": "^5.0.0",
-    "@rspack/cli": "npm:@rspack-canary/cli@1.5.4-canary-8cc7f155-20250915173802",
+    "@rspack/cli": "npm:@rspack-canary/cli@1.5.5-canary-03ab52ad-20250916180415",
     "@rspack/binding-testing": "1.4.1",
-    "@rspack/core": "npm:@rspack-canary/core@1.5.4-canary-8cc7f155-20250915173802",
-    "@rspack/test-tools": "npm:@rspack-canary/test-tools@1.5.4-canary-8cc7f155-20250915173802"
+    "@rspack/test-tools": "npm:@rspack-canary/test-tools@1.5.5-canary-03ab52ad-20250916180415",
+    "@rspack/core": "npm:@rspack-canary/core@1.5.5-canary-03ab52ad-20250916180415"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"