@rspack/test-tools 1.5.4 → 1.5.6

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/hot-step.js

@@ -20,7 +20,7 @@ function getCreator(target) {
                     configFiles: ["rspack.config.js", "webpack.config.js"]
                 })
             ],
-            runner: runner_1.HotStepRunnerFactory,
+            runner: runner_1.HotRunnerFactory,
             concurrent: true
         }));
     }

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.BasicRunnerFactory,
+        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/case/stats-output.js

@@ -10,6 +10,7 @@ const creator = new creator_1.BasicCaseCreator({
     steps: ({ name }) => [
         new stats_1.StatsProcessor({
             name,
+            snapshotName: "stats.txt",
             writeStatsOuptut: false,
             compilerType: type_1.ECompilerType.Rspack,
             configFiles: ["rspack.config.js", "webpack.config.js"]

package/dist/compare/format-code.d.ts

@@ -11,6 +11,6 @@ export interface IFormatCodeOptions {
 }
 export interface IFormatCodeReplacement {
     from: string | RegExp;
-    to: string;
+    to: string | ((substring: string, ...args: any[]) => string);
 }
 export declare function formatCode(name: string, raw: string, options: IFormatCodeOptions): string;

package/dist/compare/format-code.js

@@ -221,7 +221,12 @@ function formatCode(name, raw, options) {
     }
     if (options.replacements) {
         for (const { from, to } of options.replacements) {
-            result = result.replaceAll(from, to);
+            if (typeof to === "string") {
+                result = result.replaceAll(from, to);
+            }
+            else {
+                result = result.replaceAll(from, to);
+            }
         }
     }
     // result of generate() is not stable with comments sometimes

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/directory.js

@@ -54,7 +54,7 @@ function describeByWalk(testFile, createCase, options = {}) {
                 describeDirectory(caseName, currentLevel - 1);
             }
             else {
-                const name = (0, _1.escapeSep)(node_path_1.default.join(testId, caseName).split(".").shift());
+                const name = (0, _1.escapeSep)(node_path_1.default.join(`${testId}Cases`, caseName).split(".").shift());
                 describeFn(name, () => {
                     const source = node_path_1.default.join(sourceBase, caseName);
                     let dist = "";

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

@@ -1,2 +1,2 @@
-declare function _exports(testDirectory: any, object: any, kind: any, filename: any, upperCaseKind: any, done: any): Promise<true | undefined>;
+declare function _exports(testDirectory: any, object: any, kind: any, filename: any, upperCaseKind: any, options: any, done: any): Promise<true | undefined>;
 export = _exports;

package/dist/helper/legacy/checkArrayExpectation.js

@@ -59,16 +59,13 @@ ${tooMuch.map(item => `${explain(item)}`).join("\n\n")}`);
     }
     return diff.join("\n\n");
 };
-module.exports = async function checkArrayExpectation(testDirectory, object, kind, filename, upperCaseKind, done) {
-    const usePromise = typeof done === "function";
+module.exports = async function checkArrayExpectation(testDirectory, object, kind, filename, upperCaseKind, options, done) {
     done = typeof done === "function" ? done : error => {
         throw error;
     };
     let array = object[`${kind}s`];
-    if (Array.isArray(array)) {
-        if (kind === "warning") {
-            array = array.filter(item => !/from Terser/.test(item));
-        }
+    if (Array.isArray(array) && kind === "warning") {
+        array = array.filter(item => !/from Terser/.test(item));
     }
     if (fs.existsSync(path.join(testDirectory, `${filename}.js`))) {
         // CHANGE: added file for sorting messages in multi-thread environment
@@ -77,7 +74,10 @@ module.exports = async function checkArrayExpectation(testDirectory, object, kin
             array = sorter(array);
         }
         const expectedFilename = path.join(testDirectory, `${filename}.js`);
-        const expected = require(expectedFilename);
+        let expected = require(expectedFilename);
+        if (typeof expected === "function") {
+            expected = expected(options);
+        }
         const diff = diffItems(array, expected, kind);
         if (expected.length < array.length) {
             done(new Error(`More ${kind}s (${array.length} instead of ${expected.length}) while compiling than expected:\n\n${diff}\n\nCheck expected ${kind}s: ${expectedFilename}`));

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/helper/legacy/supportDefaultAssignment.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportDefaultAssignment.js

@@ -0,0 +1,13 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportDefaultAssignment() {
+    try {
+        // eslint-disable-next-line no-unused-vars
+        var E = eval("class E { toString() { return 'default' } }");
+        var f1 = eval("(function f1({a, b = E}) {return new b().toString();})");
+        return f1({ a: "test" }) === "default";
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsClassFields.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsES6() {
+    try {
+        eval("class A { #field = 1 }");
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsES6.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsES6() {
+    try {
+        eval("class A {}");
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsForOf.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportDefaultAssignment() {
+    try {
+        var f = eval("(function f() { for(var x of ['ok', 'fail']) return x; })");
+        return f() === "ok";
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsIteratorDestructuring.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsIteratorDestructuring() {
+    try {
+        var f = eval("(function f([, x, ...y]) { return x; })");
+        return f([1, 2]) === 2;
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): any;
+export = _exports;

package/dist/helper/legacy/supportsLogicalAssignment.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsLogicalAssignment() {
+    try {
+        var f = eval("(function f() { var x = null; x ??= true; x &&= true; return x ||= false; })");
+        return f();
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsObjectDestructuring.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsObjectDestructuring() {
+    try {
+        var f = eval("(function f({x, y}) { return x + y; })");
+        return f({ x: 1, y: 2 }) === 3;
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsOptionalCatchBinding.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsOptionalCatchBinding() {
+    try {
+        eval("try {} catch {}");
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsRequireInModule.js

@@ -0,0 +1,5 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsRequireInModule() {
+    return !!require("module").createRequire;
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): any;
+export = _exports;

package/dist/helper/legacy/supportsSpread.js

@@ -0,0 +1,12 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsSpread() {
+    try {
+        var x = { a: true }, y; // eslint-disable-line no-unused-vars
+        eval("y = { ...x }");
+        return y !== x && y.a;
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsTemplateStrings.js

@@ -0,0 +1,11 @@
+"use strict";
+// @ts-nocheck
+module.exports = function supportsTemplateStrings() {
+    try {
+        var f = eval("(function f() { return String.raw`a\\b`; })");
+        return f() === "a\\b";
+    }
+    catch (e) {
+        return false;
+    }
+};

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

@@ -0,0 +1,2 @@
+declare function _exports(): boolean;
+export = _exports;

package/dist/helper/legacy/supportsUsing.js

@@ -0,0 +1,26 @@
+// @ts-nocheck
+"use strict";
+module.exports = function supportsUsing() {
+    try {
+        const f = eval(`(function f() {
+			let disposed = false;
+
+			{
+				const getResource = () => {
+					return {
+						[Symbol.dispose]: () => {
+							disposed = true;
+						}
+					}
+				}
+				using resource = getResource();
+			}
+
+			return disposed;
+		})`);
+        return f() === true;
+    }
+    catch (_err) {
+        return false;
+    }
+};

package/dist/processor/basic.js

@@ -97,6 +97,7 @@ class BasicProcessor {
         const warnings = [];
         const compiler = this.getCompiler(context);
         const stats = compiler.getStats();
+        const options = compiler.getOptions();
         if (stats) {
             if (testConfig.writeStatsOuptut) {
                 node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
@@ -125,8 +126,8 @@ class BasicProcessor {
                 }
             }
         }
-        await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, "error", "errors", "Error");
-        await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, "warning", "warnings", "Warning");
+        await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, "error", "errors", "Error", options);
+        await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, "warning", "warnings", "Warning", options);
         // clear error if checked
         if (node_fs_1.default.existsSync(context.getSource("errors.js"))) {
             context.clearError(this._options.name);

package/dist/processor/cache.js

@@ -93,7 +93,9 @@ class CacheProcessor extends basic_1.BasicProcessor {
                     bundlerInfo: {
                         force: false
                     }
-                }
+                },
+                inlineConst: true,
+                lazyBarrel: true
             }
         };
         if (this._cacheOptions.compilerType === type_1.ECompilerType.Rspack) {

package/dist/processor/config.js

@@ -58,7 +58,9 @@ class ConfigProcessor extends multi_1.MultiTaskProcessor {
                     bundlerInfo: {
                         force: false
                     }
-                }
+                },
+                inlineConst: true,
+                lazyBarrel: true
             }
         };
     }