@rspack/test-tools 1.2.5 → 1.2.7-alpha.0

package/dist/case/diff.js

@@ -32,49 +32,36 @@ function createDiffCase(name, src, dist) {
         dist,
         steps: [processor]
     });
-    beforeAll(async () => {
-        (0, rimraf_1.rimrafSync)(dist);
-        await tester.prepare();
-    });
-    do {
-        const prefix = node_path_1.default.basename(name);
-        describe(`${prefix}:build`, () => {
-            beforeAll(async () => {
-                await tester.compile();
-            });
-            checkBundleFiles("webpack", node_path_1.default.join(dist, "webpack"), caseConfig.files);
-            checkBundleFiles("rspack", node_path_1.default.join(dist, "rspack"), caseConfig.files);
+    (0, rimraf_1.rimrafSync)(dist);
+    const buildTask = tester.compile();
+    const prefix = node_path_1.default.basename(name);
+    describe(`${prefix}:check`, () => {
+        beforeAll(async () => {
+            await buildTask;
+            compareMap.clear();
+            await tester.check(env);
         });
-        describe(`${prefix}:check`, () => {
-            beforeAll(async () => {
-                compareMap.clear();
-                await tester.check(env);
-            });
-            for (const file of caseConfig.files) {
-                describe(`Comparing "${file}"`, () => {
-                    let moduleResults = [];
-                    let runtimeResults = [];
-                    beforeAll(() => {
-                        const fileResult = compareMap.get(file);
-                        if (!fileResult) {
-                            throw new Error(`File ${file} has no results`);
-                        }
-                        moduleResults = fileResult.modules;
-                        runtimeResults = fileResult.runtimeModules;
-                    });
-                    if (caseConfig.modules) {
-                        checkCompareResults("modules", () => moduleResults);
-                    }
-                    if (caseConfig.runtimeModules) {
-                        checkCompareResults("runtime modules", () => runtimeResults);
+        for (const file of caseConfig.files) {
+            describe(`Comparing "${file}"`, () => {
+                let moduleResults = [];
+                let runtimeResults = [];
+                beforeAll(() => {
+                    const fileResult = compareMap.get(file);
+                    if (!fileResult) {
+                        throw new Error(`File ${file} has no results`);
                     }
+                    moduleResults = fileResult.modules;
+                    runtimeResults = fileResult.runtimeModules;
                 });
-            }
-            const env = (0, createLazyTestEnv_1.default)(1000);
-        });
-    } while (tester.next());
-    afterAll(async () => {
-        await tester.resume();
+                if (caseConfig.modules) {
+                    checkCompareResults("modules", () => moduleResults);
+                }
+                if (caseConfig.runtimeModules) {
+                    checkCompareResults("runtime modules", () => runtimeResults);
+                }
+            });
+        }
+        const env = (0, createLazyTestEnv_1.default)(1000);
     });
 }
 function createDiffProcessor(config) {
@@ -113,15 +100,6 @@ function createDiffProcessor(config) {
     });
     return [processor, fileCompareMap];
 }
-function checkBundleFiles(name, dist, files) {
-    describe(`Checking ${name} dist files`, () => {
-        for (const file of files) {
-            it(`${name}: ${file} should be generated`, () => {
-                expect(fs_extra_1.default.existsSync(node_path_1.default.join(dist, file))).toBeTruthy();
-            });
-        }
-    });
-}
 function checkCompareResults(name, getResults) {
     describe(`Comparing ${name}`, () => {
         it("should not miss any module", () => {

package/dist/case/new-incremental.js

@@ -48,6 +48,7 @@ const watchCreator = new creator_1.BasicCaseCreator({
     },
     describe: false,
     steps: ({ name, src, temp }) => {
+        const watchState = {};
         const runs = node_fs_1.default
             .readdirSync(src)
             .sort()
@@ -66,7 +67,7 @@ const watchCreator = new creator_1.BasicCaseCreator({
                 experiments: {
                     incremental: true
                 }
-            })
+            }, watchState)
             : new watch_1.WatchStepProcessor({
                 name,
                 stepName: run.name,
@@ -74,7 +75,7 @@ const watchCreator = new creator_1.BasicCaseCreator({
                 runable: true,
                 compilerType: type_1.ECompilerType.Rspack,
                 configFiles: ["rspack.config.js", "webpack.config.js"]
-            }));
+            }, watchState));
     }
 });
 function createWatchNewIncrementalCase(name, src, dist, temp) {

package/dist/case/stats-output.js

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

package/dist/case/watch.js

@@ -20,6 +20,7 @@ const creator = new creator_1.BasicCaseCreator({
     },
     describe: false,
     steps: ({ name, src, temp }) => {
+        const watchState = {};
         const runs = node_fs_1.default
             .readdirSync(src)
             .sort()
@@ -35,7 +36,7 @@ const creator = new creator_1.BasicCaseCreator({
                 runable: true,
                 compilerType: type_1.ECompilerType.Rspack,
                 configFiles: ["rspack.config.js", "webpack.config.js"]
-            })
+            }, watchState)
             : new watch_1.WatchStepProcessor({
                 name,
                 stepName: run.name,
@@ -43,7 +44,7 @@ const creator = new creator_1.BasicCaseCreator({
                 runable: true,
                 compilerType: type_1.ECompilerType.Rspack,
                 configFiles: ["rspack.config.js", "webpack.config.js"]
-            }));
+            }, watchState));
     }
 });
 function createWatchCase(name, src, dist, temp) {

package/dist/compare/compare.d.ts

@@ -1,5 +1,8 @@
 import { type TCompareModules, type TCompareResult, type TFileCompareResult, type TModuleCompareResult } from "../type";
 import { type IFormatCodeOptions } from "./format-code";
+declare global {
+    var updateSnapshot: boolean;
+}
 export interface ICompareOptions {
     modules?: TCompareModules;
     runtimeModules?: TCompareModules;
@@ -7,7 +10,8 @@ export interface ICompareOptions {
     renameModule?: (name: string) => string;
     bootstrap?: boolean;
     detail?: boolean;
+    snapshot?: string;
 }
 export declare function compareFile(sourceFile: string, distFile: string, compareOptions: ICompareOptions): TFileCompareResult;
-export declare function compareModules(modules: string[], sourceModules: Map<string, string>, distModules: Map<string, string>, compareOptions: ICompareOptions): TModuleCompareResult[];
+export declare function compareModules(modules: string[], sourceModules: Record<string, string>, distModules: Record<string, string>, compareOptions: ICompareOptions): TModuleCompareResult[];
 export declare function compareContent(sourceContent: string | false, distContent: string | false, compareOptions: ICompareOptions): TCompareResult;

package/dist/compare/compare.js

@@ -8,10 +8,12 @@ exports.compareModules = compareModules;
 exports.compareContent = compareContent;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const jest_diff_1 = require("jest-diff");
+const node_path_1 = __importDefault(require("node:path"));
 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,
@@ -22,7 +24,9 @@ function compareFile(sourceFile, distFile, compareOptions) {
         modules: {}
     };
     const sourceExists = fs_extra_1.default.existsSync(sourceFile);
-    const distExists = fs_extra_1.default.existsSync(distFile);
+    const distExists = compareOptions.snapshot
+        ? fs_extra_1.default.existsSync(compareOptions.snapshot)
+        : fs_extra_1.default.existsSync(distFile);
     if (!sourceExists && !distExists) {
         result.type = type_1.ECompareResultType.Missing;
         return result;
@@ -35,27 +39,53 @@ function compareFile(sourceFile, distFile, compareOptions) {
         result.type = type_1.ECompareResultType.OnlySource;
         return result;
     }
-    const sourceContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(sourceFile, "utf-8"));
-    const distContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(distFile, "utf-8"));
-    // const compareContentResult = compareContent(sourceContent, distContent);
-    // result.detail = compareContentResult.detail;
-    // result.lines = compareContentResult.lines;
-    result.type = type_1.ECompareResultType.Different;
+    function formatModules(modules) {
+        const res = {};
+        for (const [name, content] of Object.entries(modules)) {
+            const renamed = name.replaceAll(node_path_1.default.win32.sep, node_path_1.default.posix.sep);
+            if (!renamed.includes("node_modules/css-loader/dist")) {
+                res[renamed] = (0, format_code_1.formatCode)(renamed, content, compareOptions.format);
+            }
+        }
+        return res;
+    }
+    const sourceContent = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(fs_extra_1.default.readFileSync(sourceFile, "utf-8").replaceAll(WORKSPACE, "__WORKSPACE__"));
     const sourceModules = (0, helper_1.parseModules)(sourceContent, {
         bootstrap: compareOptions.bootstrap,
         renameModule: compareOptions.renameModule
     });
-    const distModules = (0, helper_1.parseModules)(distContent, {
-        bootstrap: compareOptions.bootstrap,
-        renameModule: compareOptions.renameModule
-    });
+    sourceModules.modules = formatModules(sourceModules.modules);
+    sourceModules.runtimeModules = formatModules(sourceModules.runtimeModules);
+    let distModules = {
+        modules: {},
+        runtimeModules: {}
+    };
+    if (!global.updateSnapshot &&
+        compareOptions.snapshot &&
+        fs_extra_1.default.existsSync(compareOptions.snapshot)) {
+        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__"));
+        distModules = (0, helper_1.parseModules)(distContent, {
+            bootstrap: compareOptions.bootstrap,
+            renameModule: compareOptions.renameModule
+        });
+        distModules.modules = formatModules(distModules.modules);
+        distModules.runtimeModules = formatModules(distModules.runtimeModules);
+        if (compareOptions.snapshot) {
+            fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(compareOptions.snapshot));
+            fs_extra_1.default.writeFileSync(compareOptions.snapshot, JSON.stringify(distModules, null, 2));
+        }
+    }
+    result.type = type_1.ECompareResultType.Different;
     for (const type of ["modules", "runtimeModules"]) {
         const t = type;
         let moduleList = [];
         if (compareOptions[t] === true) {
             moduleList = [
-                ...sourceModules[t].keys(),
-                ...distModules[t].keys()
+                ...Object.keys(sourceModules[t]),
+                ...Object.keys(distModules[t])
             ].filter((i, idx, arr) => arr.indexOf(i) === idx);
         }
         else if (Array.isArray(compareOptions[t])) {
@@ -71,11 +101,9 @@ function compareFile(sourceFile, distFile, compareOptions) {
 function compareModules(modules, sourceModules, distModules, compareOptions) {
     const compareResults = [];
     for (const name of modules) {
-        const renamed = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(name);
-        const sourceContent = sourceModules.has(renamed) &&
-            (0, format_code_1.formatCode)(name, sourceModules.get(renamed), compareOptions.format);
-        const distContent = distModules.has(renamed) &&
-            (0, format_code_1.formatCode)(name, distModules.get(renamed), compareOptions.format);
+        const renamed = (0, replace_runtime_module_name_1.replaceRuntimeModuleName)(name).replaceAll(node_path_1.default.win32.sep, node_path_1.default.posix.sep);
+        const sourceContent = sourceModules[renamed];
+        const distContent = distModules[renamed];
         compareResults.push({
             ...compareContent(sourceContent, distContent, compareOptions),
             name

package/dist/compare/format-code.js

@@ -45,6 +45,7 @@ const replace_module_argument_1 = require("./replace-module-argument");
 const SWC_HELPER_PATH_REG = /^_swc_helpers_[a-zA-Z\d_-]+__WEBPACK_IMPORTED_MODULE_xxx__$/;
 const CSS_FILE_EXT_REG = /(le|sa|c|sc)ss$/;
 const INVALID_PATH_REG = /[<>:"/\\|?*.]/g;
+const MODULE_ID_REG = /__WEBPACK_IMPORTED_MODULE_\d+__/;
 function formatCode(name, raw, options) {
     const ast = (0, parser_1.parse)(raw, {
         sourceType: "unambiguous"
@@ -73,7 +74,9 @@ function formatCode(name, raw, options) {
         },
         Identifier(path) {
             if (options.ignoreModuleId) {
-                path.node.name = path.node.name.replace(/__WEBPACK_IMPORTED_MODULE_\d+__/g, "__WEBPACK_IMPORTED_MODULE_xxx__");
+                if (MODULE_ID_REG.test(path.node.name)) {
+                    path.node.name = "__WEBPACK_IMPORTED_MODULE_xxx__";
+                }
             }
             if (options.ignoreSwcHelpersPath) {
                 if (SWC_HELPER_PATH_REG.test(path.node.name)) {

package/dist/compare/replace-runtime-module-name.d.ts

@@ -1 +1 @@
-export declare function replaceRuntimeModuleName(name: string): string;
+export declare function replaceRuntimeModuleName(content: string): string;

package/dist/compare/replace-runtime-module-name.js

@@ -1,49 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.replaceRuntimeModuleName = replaceRuntimeModuleName;
+const RUNTIME_MODULE_REGEX = /(webpack\/runtime\/)([a-z_]+)/g;
+const RUNTIME_MODULE_NAME_REPLACER = {
+    auto_public_path: "publicPath",
+    public_path: "publicPath",
+    async_module: "async module",
+    base_uri: "base uri",
+    chunk_name: "chunkName",
+    compat_get_default_export: "compat get default export",
+    compat: "compat",
+    create_fake_namespace_object: "create fake namespace object",
+    create_script_url: "trusted types script url",
+    create_script: "trusted types script",
+    define_property_getters: "define property getters",
+    ensure_chunk: "ensure chunk",
+    get_full_hash: "getFullHash",
+    get_trusted_types_policy: "trusted types policy",
+    global: "global",
+    has_own_property: "hasOwnProperty shorthand",
+    load_script: "load script",
+    make_namespace_object: "make namespace object",
+    nonce: "nonce",
+    on_chunk_loaded: "chunk loaded",
+    relative_url: "relative url",
+    runtime_id: "runtimeId",
+    startup_chunk_dependencies: "startup chunk dependencies",
+    startup_entrypoint: "startup entrypoint",
+    system_context: "__system_context__",
+    chunk_prefetch_startup: "startup prefetch",
+    chunk_prefetch_trigger: "chunk prefetch trigger",
+    chunk_preload_trigger: "chunk preload trigger",
+    css_loading: "css loading",
+    async_wasm_loading: "wasm loading",
+    hot_module_replacement: "hot module replacement",
+    readfile_chunk_loading: "readFile chunk loading",
+    require_chunk_loading: "require chunk loading",
+    import_scripts_chunk_loading: "importScripts chunk loading",
+    module_chunk_loading: "import chunk loading",
+    export_webpack_runtime: "export webpack runtime",
+    jsonp_chunk_loading: "jsonp chunk loading",
+    remote: "remotes loading",
+    share: "sharing",
+    consume_shared: "consumes",
+    esm_module_decorator: "harmony module decorator",
+    node_module_decorator: "node module decorator"
+};
 const RUNTIME_MODULE_NAME_MAPPING = {
-    "webpack/runtime/auto_public_path": "webpack/runtime/publicPath",
-    "webpack/runtime/public_path": "webpack/runtime/publicPath",
-    "webpack/runtime/async_module": "webpack/runtime/async module",
-    "webpack/runtime/base_uri": "webpack/runtime/base uri",
-    "webpack/runtime/chunk_name": "webpack/runtime/chunkName",
-    "webpack/runtime/compat_get_default_export": "webpack/runtime/compat get default export",
-    "webpack/runtime/compat": "webpack/runtime/compat",
-    "webpack/runtime/create_fake_namespace_object": "webpack/runtime/create fake namespace object",
-    "webpack/runtime/create_script_url": "webpack/runtime/trusted types script url",
-    "webpack/runtime/create_script": "webpack/runtime/trusted types script",
-    "webpack/runtime/define_property_getters": "webpack/runtime/define property getters",
-    "webpack/runtime/ensure_chunk": "webpack/runtime/ensure chunk",
-    "webpack/runtime/get_full_hash": "webpack/runtime/getFullHash",
-    "webpack/runtime/get_trusted_types_policy": "webpack/runtime/trusted types policy",
-    "webpack/runtime/global": "webpack/runtime/global",
-    "webpack/runtime/has_own_property": "webpack/runtime/hasOwnProperty shorthand",
-    "webpack/runtime/load_script": "webpack/runtime/load script",
-    "webpack/runtime/make_namespace_object": "webpack/runtime/make namespace object",
-    "webpack/runtime/nonce": "webpack/runtime/nonce",
-    "webpack/runtime/on_chunk_loaded": "webpack/runtime/chunk loaded",
-    "webpack/runtime/relative_url": "webpack/runtime/relative url",
-    "webpack/runtime/runtime_id": "webpack/runtime/runtimeId",
-    "webpack/runtime/startup_chunk_dependencies": "webpack/runtime/startup chunk dependencies",
-    "webpack/runtime/startup_entrypoint": "webpack/runtime/startup entrypoint",
-    "webpack/runtime/system_context": "webpack/runtime/__system_context__",
-    "webpack/runtime/chunk_prefetch_startup": "webpack/runtime/startup prefetch",
-    "webpack/runtime/chunk_prefetch_trigger": "webpack/runtime/chunk prefetch trigger",
-    "webpack/runtime/chunk_preload_trigger": "webpack/runtime/chunk preload trigger",
-    "webpack/runtime/css_loading": "webpack/runtime/css loading",
-    "webpack/runtime/async_wasm_loading": "webpack/runtime/wasm loading",
-    "webpack/runtime/hot_module_replacement": "webpack/runtime/hot module replacement",
-    "webpack/runtime/readfile_chunk_loading": "webpack/runtime/readFile chunk loading",
-    "webpack/runtime/require_chunk_loading": "webpack/runtime/require chunk loading",
-    "webpack/runtime/import_scripts_chunk_loading": "webpack/runtime/importScripts chunk loading",
-    "webpack/runtime/module_chunk_loading": "webpack/runtime/import chunk loading",
-    "webpack/runtime/export_webpack_runtime": "webpack/runtime/export webpack runtime",
-    "webpack/runtime/jsonp_chunk_loading": "webpack/runtime/jsonp chunk loading",
-    "webpack/runtime/remote": "webpack/runtime/remotes loading",
-    "webpack/runtime/share": "webpack/runtime/sharing",
-    "webpack/runtime/consume_shared": "webpack/runtime/consumes",
-    "webpack/runtime/esm_module_decorator": "webpack/runtime/harmony module decorator",
-    "webpack/runtime/node_module_decorator": "webpack/runtime/node module decorator",
     // module name with parameters
     "webpack/runtime/get_chunk_filename": "webpack/runtime/get $1 chunk filename",
     "webpack/runtime/get_main_filename": "webpack/runtime/get $1 filename",
@@ -54,13 +57,15 @@ const RUNTIME_MODULE_PARAM_REGEX = {
     "webpack/runtime/get_main_filename": /webpack\/runtime\/get_main_filename\/([\w.\-_\s]+)(\*\/)?/g,
     "webpack/runtime/chunk_prefetch_function": /webpack\/runtime\/chunk_prefetch_function\/([\w.\-_\s]+)(\*\/)?/g
 };
-function replaceRuntimeModuleName(name) {
-    return Object.entries(RUNTIME_MODULE_NAME_MAPPING).reduce((name, [rspackName, webpackName]) => {
+function replaceRuntimeModuleName(content) {
+    let res = content.replace(RUNTIME_MODULE_REGEX, (_, $1, $2) => `${$1}${RUNTIME_MODULE_NAME_REPLACER[$2] || $2}`);
+    res = Object.entries(RUNTIME_MODULE_NAME_MAPPING).reduce((res, [rspackName, webpackName]) => {
         if (RUNTIME_MODULE_PARAM_REGEX[rspackName]) {
-            return name.replace(RUNTIME_MODULE_PARAM_REGEX[rspackName], (_, $1, $2) => {
+            return res.replace(RUNTIME_MODULE_PARAM_REGEX[rspackName], (_, $1, $2) => {
                 return webpackName.replace("$1", $1.trim()) + ($2 ? " */" : "");
             });
         }
-        return name.split(rspackName).join(webpackName);
-    }, name);
+        return res.replaceAll(rspackName, webpackName);
+    }, res);
+    return res;
 }

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

@@ -7,14 +7,17 @@ function default_1(c) {
         content = `
 			${content}
 			let __hmr_children__ = [...module.children];
-			let __hmr_used_exports__ = __hmr_children__.reduce((res, child) => {
-				res[child] = __webpack_module_cache__[child].exports;
+      let __hmr_used_exports__ = __hmr_children__.reduce((res, child) => {
+        if (__webpack_module_cache__[child]) {
+          res[child] = __webpack_module_cache__[child].exports;
+        }
 				return res;
 			}, {});
 			module.hot.accept(__hmr_children__, () => {
 				__hmr_children__.forEach((child) => {
 					const reexports = __webpack_require__(child);
-					for (let key in reexports) {
+          for (let key in reexports) {
+            if (!__hmr_used_exports__[child]) { continue; }
 						Object.defineProperty(__hmr_used_exports__[child], key, {
 							configurable: true,
 							enumerable: true,

package/dist/helper/parse-modules.d.ts

@@ -2,6 +2,6 @@ export declare function parseModules(content: string, options?: {
     bootstrap?: boolean;
     renameModule?: (name: string) => string;
 }): {
-    modules: Map<string, string>;
-    runtimeModules: Map<string, string>;
+    modules: Record<string, string>;
+    runtimeModules: Record<string, string>;
 };

package/dist/helper/parse-modules.js

@@ -35,14 +35,14 @@ function isValidModule(name) {
     return true;
 }
 function parseModules(content, options = {}) {
-    const modules = new Map();
-    const runtimeModules = new Map();
+    const modules = {};
+    const runtimeModules = {};
     let currentPosition = 0;
     if (options.bootstrap) {
         // parse bootstrap code
         const bootstrap = getStringBetween(content, 0, BOOTSTRAP_SPLIT_LINE, BOOTSTRAP_SPLIT_LINE);
         if (bootstrap.result) {
-            runtimeModules.set("webpack/runtime/bootstrap", bootstrap.result);
+            runtimeModules["webpack/runtime/bootstrap"] = bootstrap.result;
         }
     }
     // parse module & runtime module code
@@ -56,11 +56,11 @@ function parseModules(content, options = {}) {
             ? options.renameModule(moduleName)
             : moduleName;
         if (moduleName.startsWith("webpack/runtime")) {
-            runtimeModules.set(renamedModuleName, moduleContent.result);
+            runtimeModules[renamedModuleName] = moduleContent.result;
         }
         else {
             if (isValidModule(moduleName)) {
-                modules.set(renamedModuleName, moduleContent.result);
+                modules[renamedModuleName] = moduleContent.result;
             }
         }
         currentPosition = moduleContent.remain;

package/dist/processor/basic.js

@@ -95,19 +95,29 @@ class BasicProcessor {
         const compiler = this.getCompiler(context);
         const stats = compiler.getStats();
         if (stats) {
-            node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
-                preset: "verbose",
-                colors: false
-            }), "utf-8");
-            const jsonStats = stats.toJson({
-                errorDetails: true
-            });
-            node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(jsonStats, null, 2), "utf-8");
-            if (jsonStats.errors) {
-                errors.push(...jsonStats.errors);
+            if (testConfig.writeStatsOuptut) {
+                node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
+                    preset: "verbose",
+                    colors: false
+                }), "utf-8");
             }
-            if (jsonStats.warnings) {
-                warnings.push(...jsonStats.warnings);
+            if (testConfig.writeStatsJson) {
+                const jsonStats = stats.toJson({
+                    errorDetails: true
+                });
+                node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(jsonStats, null, 2), "utf-8");
+            }
+            if (node_fs_1.default.existsSync(context.getSource("errors.js")) ||
+                node_fs_1.default.existsSync(context.getSource("warnings.js"))) {
+                const statsJson = stats.toJson({
+                    errorDetails: true
+                });
+                if (statsJson.errors) {
+                    errors.push(...statsJson.errors);
+                }
+                if (statsJson.warnings) {
+                    warnings.push(...statsJson.warnings);
+                }
             }
         }
         await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, "error", "errors", "Error");

package/dist/processor/diff.js

@@ -13,13 +13,16 @@ class DiffProcessor {
     constructor(options) {
         this.options = options;
         this.hashes = [];
-        this.webpack = new basic_1.BasicProcessor({
-            defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Webpack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Webpack)),
-            compilerType: type_1.ECompilerType.Webpack,
-            name: type_1.ECompilerType.Webpack,
-            configFiles: ["webpack.config.js", "rspack.config.js"],
-            runable: false
-        });
+        this.webpack = null;
+        if (global.updateSnapshot) {
+            this.webpack = new basic_1.BasicProcessor({
+                defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Webpack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Webpack)),
+                compilerType: type_1.ECompilerType.Webpack,
+                name: type_1.ECompilerType.Webpack,
+                configFiles: ["webpack.config.js", "rspack.config.js"],
+                runable: false
+            });
+        }
         this.rspack = new basic_1.BasicProcessor({
             defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Rspack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Rspack)),
             compilerType: type_1.ECompilerType.Rspack,
@@ -29,24 +32,32 @@ class DiffProcessor {
         });
     }
     async config(context) {
-        await this.webpack.config(context);
+        if (this.webpack) {
+            await this.webpack.config(context);
+        }
         await this.rspack.config(context);
     }
     async compiler(context) {
-        await this.webpack.compiler(context);
+        if (this.webpack) {
+            await this.webpack.compiler(context);
+        }
         await this.rspack.compiler(context);
     }
     async build(context) {
-        await this.webpack.build(context);
+        if (this.webpack) {
+            await this.webpack.build(context);
+        }
         await this.rspack.build(context);
     }
     async check(env, context) {
-        const webpackCompiler = context.getCompiler(type_1.ECompilerType.Webpack);
-        const webpackStats = webpackCompiler.getStats();
-        //TODO: handle chunk hash and content hash
-        webpackStats?.hash && this.hashes.push(webpackStats?.hash);
-        if (!this.options.errors) {
-            env.expect(webpackStats?.hasErrors()).toBe(false);
+        if (this.webpack) {
+            const webpackCompiler = context.getCompiler(type_1.ECompilerType.Webpack);
+            const webpackStats = webpackCompiler.getStats();
+            //TODO: handle chunk hash and content hash
+            webpackStats?.hash && this.hashes.push(webpackStats?.hash);
+            if (!this.options.errors) {
+                env.expect(webpackStats?.hasErrors()).toBe(false);
+            }
         }
         const rspackCompiler = context.getCompiler(type_1.ECompilerType.Rspack);
         const rspackStats = rspackCompiler.getStats();
@@ -56,16 +67,19 @@ class DiffProcessor {
             env.expect(rspackStats?.hasErrors()).toBe(false);
         }
         const dist = context.getDist();
+        const snapshot = context.getSource("__snapshot__");
         for (const file of this.options.files) {
             const rspackDist = node_path_1.default.join(dist, type_1.ECompilerType.Rspack, file);
             const webpackDist = node_path_1.default.join(dist, type_1.ECompilerType.Webpack, file);
+            const snapshotDist = node_path_1.default.join(snapshot, file.replace(/\.js$/, ".json"));
             const result = (0, compare_1.compareFile)(rspackDist, webpackDist, {
                 modules: this.options.modules,
                 runtimeModules: this.options.runtimeModules,
                 format: this.createFormatOptions(),
                 renameModule: this.options.renameModule,
                 bootstrap: this.options.bootstrap,
-                detail: this.options.detail
+                detail: this.options.detail,
+                snapshot: snapshotDist
             });
             if (typeof this.options.onCompareFile === "function") {
                 this.options.onCompareFile(file, result);

package/dist/processor/hash.js

@@ -20,12 +20,11 @@ class HashProcessor extends multi_1.MultiTaskProcessor {
             env.expect(false);
             return;
         }
-        const statsJson = stats.toJson({ assets: true });
         if (REG_ERROR_CASE.test(this._options.name)) {
-            env.expect((statsJson.errors || []).length > 0);
+            env.expect(stats.hasErrors());
         }
         else {
-            env.expect((statsJson.errors || []).length === 0);
+            env.expect(!stats.hasErrors());
         }
         if (typeof testConfig.validate === "function") {
             testConfig.validate(stats);