@rspack-debug/test-tools 1.3.14

package/dist/processor/stats.d.ts

@@ -0,0 +1,18 @@
+import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
+import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
+export interface IStatsProcessorOptions<T extends ECompilerType> extends Omit<IMultiTaskProcessorOptions<T>, "runable"> {
+    snapshotName?: string;
+    writeStatsOuptut?: boolean;
+}
+export declare class StatsProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
+    private stderr;
+    private snapshotName?;
+    private writeStatsOuptut?;
+    constructor(_statsOptions: IStatsProcessorOptions<T>);
+    before(context: ITestContext): Promise<void>;
+    after(context: ITestContext): Promise<void>;
+    compiler(context: ITestContext): Promise<void>;
+    check(env: ITestEnv, context: ITestContext): Promise<void>;
+    static defaultOptions<T extends ECompilerType>(index: number, context: ITestContext): TCompilerOptions<T>;
+    static overrideOptions<T extends ECompilerType>(index: number, context: ITestContext, options: TCompilerOptions<T>): void;
+}

package/dist/processor/stats.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsProcessor = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const placeholder_1 = require("../helper/expect/placeholder");
+const captureStdio_1 = __importDefault(require("../helper/legacy/captureStdio"));
+const multi_1 = require("./multi");
+const REG_ERROR_CASE = /error$/;
+class RspackStats {
+    constructor(value) {
+        this.value = value;
+    }
+}
+class StatsProcessor extends multi_1.MultiTaskProcessor {
+    constructor(_statsOptions) {
+        super({
+            defaultOptions: (StatsProcessor.defaultOptions),
+            overrideOptions: (StatsProcessor.overrideOptions),
+            runable: false,
+            ..._statsOptions
+        });
+        this.snapshotName = _statsOptions.snapshotName;
+        this.writeStatsOuptut = _statsOptions.writeStatsOuptut;
+    }
+    async before(context) {
+        this.stderr = (0, captureStdio_1.default)(process.stderr, true);
+    }
+    async after(context) {
+        this.stderr.restore();
+    }
+    async compiler(context) {
+        await super.compiler(context);
+        const instance = this.getCompiler(context).getCompiler();
+        const compilers = instance.compilers
+            ? instance.compilers
+            : [instance];
+        for (const compiler of compilers) {
+            if (!compiler.inputFileSystem) {
+                continue;
+            }
+            const ifs = compiler.inputFileSystem;
+            const inputFileSystem = Object.create(ifs);
+            compiler.inputFileSystem = inputFileSystem;
+            inputFileSystem.readFile = (...args) => {
+                const callback = args.pop();
+                ifs.readFile.apply(ifs, args.concat([
+                    (err, result) => {
+                        if (err)
+                            return callback(err);
+                        if (!/\.(js|json|txt)$/.test(args[0]))
+                            return callback(null, result);
+                        callback(null, (0, placeholder_1.normalizePlaceholder)(result.toString("utf-8")));
+                    }
+                ]));
+            };
+            // CHANGE: The checkConstraints() function is currently not implemented in rspack
+            // compiler.hooks.compilation.tap("StatsTestCasesTest", compilation => {
+            // 	[
+            // 		"optimize",
+            // 		"optimizeModules",
+            // 		"optimizeChunks",
+            // 		"afterOptimizeTree",
+            // 		"afterOptimizeAssets",
+            // 		"beforeHash"
+            // 	].forEach(hook => {
+            // 		compilation.hooks[hook].tap("TestCasesTest", () =>
+            // 			compilation.checkConstraints()
+            // 		);
+            // 	});
+            // });
+        }
+    }
+    async check(env, context) {
+        const compiler = this.getCompiler(context);
+        const stats = compiler.getStats();
+        const c = compiler.getCompiler();
+        if (!stats || !c)
+            return;
+        for (const compilation of []
+            .concat(stats.stats || stats)
+            .map((s) => s.compilation)) {
+            compilation.logging.delete("webpack.Compilation.ModuleProfile");
+        }
+        if (REG_ERROR_CASE.test(this._options.name)) {
+            env.expect(stats.hasErrors()).toBe(true);
+        }
+        else if (stats.hasErrors()) {
+            throw new Error(stats.toString({
+                all: false,
+                errors: true
+                // errorStack: true,
+                // errorDetails: true
+            }));
+        }
+        else if (this.writeStatsOuptut) {
+            node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
+                preset: "verbose",
+                // context: context.getSource(),
+                colors: false
+            }), "utf-8");
+        }
+        let toStringOptions = {
+            context: context.getSource(),
+            colors: false
+        };
+        let hasColorSetting = false;
+        if (typeof c.options.stats !== "undefined") {
+            toStringOptions = c.options.stats;
+            if (toStringOptions === null || typeof toStringOptions !== "object")
+                toStringOptions = { preset: toStringOptions };
+            if (!toStringOptions.context)
+                toStringOptions.context = context.getSource();
+            hasColorSetting = typeof toStringOptions.colors !== "undefined";
+        }
+        if (Array.isArray(c.options) && !toStringOptions.children) {
+            toStringOptions.children = c.options.map(o => o.stats);
+        }
+        // mock timestamps
+        for (const { compilation: s } of [].concat(stats.stats || stats)) {
+            env.expect(s.startTime).toBeGreaterThan(0);
+            env.expect(s.endTime).toBeGreaterThan(0);
+            s.endTime = new Date("04/20/1970, 12:42:42 PM").getTime();
+            s.startTime = s.endTime - 1234;
+        }
+        let actual = stats.toString(toStringOptions);
+        env.expect(typeof actual).toBe("string");
+        actual = this.stderr.toString() + actual;
+        if (!hasColorSetting) {
+            actual = actual
+                .replace(/\u001b\[[0-9;]*m/g, "")
+                // CHANGE: The time unit display in Rspack is second
+                .replace(/[.0-9]+(\s?s)/g, "X$1")
+                // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
+                .replace(/[0-9]+\.?[0-9]+ KiB/g, "xx KiB");
+        }
+        if (this.snapshotName) {
+            env.expect(new RspackStats(actual)).toMatchSnapshot(this.snapshotName);
+        }
+        else {
+            env.expect(new RspackStats(actual)).toMatchSnapshot();
+        }
+        const testConfig = context.getTestConfig();
+        if (typeof testConfig?.validate === "function") {
+            testConfig.validate(stats, this.stderr.toString());
+        }
+    }
+    static defaultOptions(index, context) {
+        if (node_fs_1.default.existsSync(node_path_1.default.join(context.getSource(), "rspack.config.js"))) {
+            return {
+                experiments: {
+                    css: true,
+                    rspackFuture: {
+                        bundlerInfo: {
+                            force: false
+                        }
+                    }
+                }
+            };
+        }
+        return {
+            context: context.getSource(),
+            mode: "development",
+            entry: "./index.js",
+            output: {
+                filename: "bundle.js",
+                path: context.getDist()
+            },
+            optimization: {
+                minimize: false
+            },
+            experiments: {
+                css: true,
+                rspackFuture: {
+                    bundlerInfo: {
+                        force: false
+                    }
+                }
+            }
+        };
+    }
+    static overrideOptions(index, context, options) {
+        if (!options.context)
+            options.context = context.getSource();
+        if (!options.output)
+            options.output = options.output || {};
+        if (!options.output.path)
+            options.output.path = context.getDist();
+        if (!options.plugins)
+            options.plugins = [];
+        if (!options.optimization)
+            options.optimization = {};
+        if (options.optimization.minimize === undefined) {
+            options.optimization.minimize = false;
+        }
+        if (!global.printLogger) {
+            options.infrastructureLogging = {
+                level: "error"
+            };
+        }
+    }
+}
+exports.StatsProcessor = StatsProcessor;

package/dist/processor/treeshaking.d.ts

@@ -0,0 +1,10 @@
+import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
+import { type ISnapshotProcessorOptions, SnapshotProcessor } from "./snapshot";
+export interface ITreeShakingProcessorOptions<T extends ECompilerType> extends Omit<ISnapshotProcessorOptions<T>, "runable"> {
+}
+export declare class TreeShakingProcessor<T extends ECompilerType> extends SnapshotProcessor<T> {
+    protected _treeShakingOptions: ITreeShakingProcessorOptions<T>;
+    constructor(_treeShakingOptions: ITreeShakingProcessorOptions<T>);
+    static overrideOptions<T extends ECompilerType>(context: ITestContext, options: TCompilerOptions<T>): void;
+    serializeEachFile(content: string): string;
+}

package/dist/processor/treeshaking.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeShakingProcessor = void 0;
+const placeholder_1 = require("../helper/expect/placeholder");
+const builtin_1 = require("./builtin");
+const snapshot_1 = require("./snapshot");
+class TreeShakingProcessor extends snapshot_1.SnapshotProcessor {
+    constructor(_treeShakingOptions) {
+        super({
+            defaultOptions: builtin_1.BuiltinProcessor.defaultOptions,
+            overrideOptions: (TreeShakingProcessor.overrideOptions),
+            runable: false,
+            ..._treeShakingOptions
+        });
+        this._treeShakingOptions = _treeShakingOptions;
+    }
+    static overrideOptions(context, options) {
+        options.target = options.target || ["web", "es2022"];
+        options.optimization ??= {};
+        options.optimization.providedExports = true;
+        options.optimization.innerGraph = true;
+        options.optimization.usedExports = true;
+        if (!global.printLogger) {
+            options.infrastructureLogging = {
+                level: "error"
+            };
+        }
+    }
+    serializeEachFile(content) {
+        return (0, placeholder_1.normalizePlaceholder)(content);
+    }
+}
+exports.TreeShakingProcessor = TreeShakingProcessor;

package/dist/processor/watch.d.ts

@@ -0,0 +1,29 @@
+import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
+import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
+export interface IWatchProcessorOptions<T extends ECompilerType> extends IMultiTaskProcessorOptions<T> {
+    stepName: string;
+    tempDir: string;
+}
+export declare class WatchProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
+    protected _watchOptions: IWatchProcessorOptions<T>;
+    protected _watchState: Record<string, any>;
+    protected currentTriggerFilename: string | null;
+    protected lastHash: string | null;
+    constructor(_watchOptions: IWatchProcessorOptions<T>, _watchState: Record<string, any>);
+    compiler(context: ITestContext): Promise<void>;
+    build(context: ITestContext): Promise<void>;
+    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 }: 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"> {
+}
+export declare class WatchStepProcessor<T extends ECompilerType> extends WatchProcessor<T> {
+    protected _watchOptions: IWatchStepProcessorOptions<T>;
+    protected _watchState: Record<string, any>;
+    constructor(_watchOptions: IWatchStepProcessorOptions<T>, _watchState: Record<string, any>);
+    compiler(context: ITestContext): Promise<void>;
+    build(context: ITestContext): Promise<void>;
+}

package/dist/processor/watch.js

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchStepProcessor = exports.WatchProcessor = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const webpack_merge_1 = require("webpack-merge");
+const compiler_1 = require("../compiler");
+const helper_1 = require("../helper");
+const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
+const copyDiff_1 = __importDefault(require("../helper/legacy/copyDiff"));
+const multi_1 = require("./multi");
+// This file is used to port step number to rspack.config.js/webpack.config.js
+const currentWatchStepModulePath = node_path_1.default.resolve(__dirname, "../helper/util/currentWatchStep");
+class WatchProcessor extends multi_1.MultiTaskProcessor {
+    constructor(_watchOptions, _watchState) {
+        super({
+            overrideOptions: WatchProcessor.overrideOptions(_watchOptions),
+            findBundle: (WatchProcessor.findBundle),
+            ..._watchOptions
+        });
+        this._watchOptions = _watchOptions;
+        this._watchState = _watchState;
+        this.currentTriggerFilename = null;
+        this.lastHash = null;
+    }
+    async compiler(context) {
+        await super.compiler(context);
+        const compiler = this.getCompiler(context).getCompiler();
+        compiler.hooks.invalid.tap("WatchTestCasesTest", (filename, mtime) => {
+            this.currentTriggerFilename = filename;
+        });
+    }
+    async build(context) {
+        const compiler = this.getCompiler(context);
+        const currentWatchStepModule = require(currentWatchStepModulePath);
+        currentWatchStepModule.step[this._options.name] =
+            this._watchOptions.stepName;
+        node_fs_1.default.mkdirSync(this._watchOptions.tempDir, { recursive: true });
+        (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), this._watchOptions.stepName), this._watchOptions.tempDir, true);
+        const task = new Promise((resolve, reject) => {
+            compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
+                if (e)
+                    return reject(e);
+                resolve(stats);
+            });
+        });
+        compiler.watch();
+        await task;
+    }
+    async run(env, context) {
+        context.setValue(this._options.name, "watchStepName", this._watchOptions.stepName);
+        context.setValue(this._options.name, "watchState", this._watchState);
+        await super.run(env, context);
+    }
+    async check(env, context) {
+        const testConfig = context.getTestConfig();
+        if (testConfig.noTest)
+            return;
+        const errors = (context.getError(this._options.name) || []).map(e => ({
+            message: e.message,
+            stack: e.stack
+        }));
+        const warnings = [];
+        const compiler = this.getCompiler(context);
+        const stats = compiler.getStats();
+        const checkStats = testConfig.checkStats || (() => true);
+        if (stats) {
+            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");
+            }
+            const getJsonStats = (() => {
+                let cached = null;
+                return () => {
+                    if (!cached) {
+                        cached = stats.toJson({
+                            errorDetails: true
+                        });
+                    }
+                    return cached;
+                };
+            })();
+            const getStringStats = (() => {
+                let cached = null;
+                return () => {
+                    if (!cached) {
+                        cached = stats.toString({
+                            logging: "verbose"
+                        });
+                    }
+                    return cached;
+                };
+            })();
+            if (checkStats.length > 1) {
+                if (!checkStats(this._watchOptions.stepName, getJsonStats(), getStringStats())) {
+                    throw new Error("stats check failed");
+                }
+            }
+            else {
+                // @ts-expect-error only one param
+                if (!checkStats(this._watchOptions.stepName)) {
+                    throw new Error("stats check failed");
+                }
+            }
+            if (testConfig.writeStatsJson) {
+                node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(getJsonStats(), null, 2), "utf-8");
+            }
+            if (node_fs_1.default.existsSync(context.getSource(`${this._watchOptions.stepName}/errors.js`)) ||
+                node_fs_1.default.existsSync(context.getSource(`${this._watchOptions.stepName}/warnings.js`)) ||
+                stats.hasErrors() ||
+                stats.hasWarnings()) {
+                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)(node_path_1.default.join(context.getSource(), this._watchOptions.stepName), { errors }, "error", "errors", "Error");
+        await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), this._watchOptions.stepName), { warnings }, "warning", "warnings", "Warning");
+        // clear error if checked
+        if (node_fs_1.default.existsSync(context.getSource("errors.js"))) {
+            context.clearError(this._options.name);
+        }
+        // check hash
+        if (testConfig.writeStatsOuptut) {
+            node_fs_1.default.renameSync(node_path_1.default.join(context.getDist(), "stats.txt"), node_path_1.default.join(context.getDist(), `stats.${this._watchOptions.stepName}.txt`));
+        }
+        if (testConfig.writeStatsJson) {
+            node_fs_1.default.renameSync(node_path_1.default.join(context.getDist(), "stats.json"), node_path_1.default.join(context.getDist(), `stats.${this._watchOptions.stepName}.json`));
+        }
+    }
+    async config(context) {
+        this.multiCompilerOptions = [];
+        const caseOptions = Array.isArray(this._multiOptions.configFiles)
+            ? (0, helper_1.readConfigFile)(this._multiOptions.configFiles.map(i => context.getSource(i)))
+            : [{}];
+        for (const [index, options] of caseOptions.entries()) {
+            const compilerOptions = (0, webpack_merge_1.merge)(typeof this._multiOptions.defaultOptions === "function"
+                ? this._multiOptions.defaultOptions(index, context)
+                : {}, options);
+            if (typeof this._multiOptions.overrideOptions === "function") {
+                this._multiOptions.overrideOptions(index, context, compilerOptions);
+            }
+            this.multiCompilerOptions.push(compilerOptions);
+        }
+        const compilerOptions = this.multiCompilerOptions.length === 1
+            ? this.multiCompilerOptions[0]
+            : this.multiCompilerOptions;
+        const compiler = this.getCompiler(context);
+        compiler.setOptions(compilerOptions);
+    }
+    static overrideOptions({ tempDir, name }) {
+        return (index, context, options) => {
+            if (!options.mode)
+                options.mode = "development";
+            if (!options.context)
+                options.context = tempDir;
+            if (!options.entry)
+                options.entry = "./index.js";
+            if (!options.target)
+                options.target = "async-node";
+            if (!options.devtool)
+                options.devtool = false;
+            if (!options.output)
+                options.output = {};
+            if (!options.output.path)
+                options.output.path = context.getDist();
+            if (typeof options.output.pathinfo === "undefined")
+                options.output.pathinfo = false;
+            if (!options.output.filename)
+                options.output.filename = "bundle.js";
+            if (options.cache && options.cache.type === "filesystem") {
+                const cacheDirectory = node_path_1.default.join(tempDir, ".cache");
+                options.cache.cacheDirectory = cacheDirectory;
+                options.cache.name = `config-${index}`;
+            }
+            options.optimization ??= {};
+            options.experiments ??= {};
+            options.experiments.css ??= true;
+            options.experiments.rspackFuture ??= {};
+            options.experiments.rspackFuture.bundlerInfo ??= {};
+            options.experiments.rspackFuture.bundlerInfo.force ??= false;
+            if (!global.printLogger) {
+                options.infrastructureLogging = {
+                    level: "error"
+                };
+            }
+        };
+    }
+    static findBundle(index, context, options) {
+        const testConfig = context.getTestConfig();
+        if (typeof testConfig.findBundle === "function") {
+            return testConfig.findBundle(index, options, this.stepName);
+        }
+        return "./bundle.js";
+    }
+}
+exports.WatchProcessor = WatchProcessor;
+class WatchStepProcessor extends WatchProcessor {
+    constructor(_watchOptions, _watchState) {
+        super(_watchOptions, _watchState);
+        this._watchOptions = _watchOptions;
+        this._watchState = _watchState;
+    }
+    async compiler(context) {
+        // do nothing
+    }
+    async build(context) {
+        const compiler = this.getCompiler(context);
+        const currentWatchStepModule = require(currentWatchStepModulePath);
+        currentWatchStepModule.step[this._options.name] =
+            this._watchOptions.stepName;
+        const task = new Promise((resolve, reject) => {
+            compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
+                if (e)
+                    return reject(e);
+                resolve(stats);
+            });
+        });
+        (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), this._watchOptions.stepName), this._watchOptions.tempDir, false);
+        await task;
+    }
+}
+exports.WatchStepProcessor = WatchStepProcessor;

package/dist/reporter/diff-html.d.ts

@@ -0,0 +1,15 @@
+import type { ITestReporter, TModuleCompareResult } from "../type";
+export interface IDiffHtmlReporterOptions {
+    dist: string;
+    ignore?: RegExp;
+}
+export declare class DiffHtmlReporter implements ITestReporter<TModuleCompareResult[]> {
+    private options;
+    private failed;
+    private results;
+    constructor(options: IDiffHtmlReporterOptions);
+    init(data?: TModuleCompareResult[]): Promise<void>;
+    failure(id: string): Promise<void>;
+    increment(id: string, data: TModuleCompareResult[]): Promise<void>;
+    output(): Promise<void>;
+}

package/dist/reporter/diff-html.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffHtmlReporter = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const VIEWER_DIR = node_path_1.default.join(__dirname, "../../template");
+const DIFF_STATS_PLACEHOLDER = "$$RSPACK_DIFF_STATS_PLACEHOLDER$$";
+const DEFAULT_IGNORE = /node_modules/;
+class DiffHtmlReporter {
+    constructor(options) {
+        this.options = options;
+        this.failed = new Set();
+        this.results = new Map();
+    }
+    async init(data = []) { }
+    async failure(id) {
+        this.failed.add(id);
+        this.results.delete(id);
+    }
+    async increment(id, data) {
+        if (this.failed.has(id))
+            return;
+        if (!this.results.has(id)) {
+            this.results.set(id, []);
+        }
+        const ignore = this.options.ignore || DEFAULT_IGNORE;
+        const current = this.results.get(id);
+        for (const i of data) {
+            if (!ignore.test(i.name)) {
+                current.push({
+                    name: i.name,
+                    source: i.source || "",
+                    dist: i.dist || "",
+                    type: i.type
+                });
+            }
+        }
+    }
+    async output() {
+        fs_extra_1.default.ensureDirSync(this.options.dist);
+        for (const viewerFile of fs_extra_1.default
+            .readdirSync(VIEWER_DIR)
+            .filter(file => file.startsWith("diff"))) {
+            const sourceFile = node_path_1.default.join(VIEWER_DIR, viewerFile);
+            if (node_path_1.default.extname(viewerFile) === ".html") {
+                const template = fs_extra_1.default.readFileSync(sourceFile, "utf-8");
+                for (const [id, items] of this.results.entries()) {
+                    const data = {
+                        root: id,
+                        data: items
+                    };
+                    const casename = node_path_1.default.basename(id);
+                    const extname = node_path_1.default.extname(viewerFile);
+                    const filename = node_path_1.default.basename(viewerFile, extname);
+                    const content = template.replace(`<script id="${DIFF_STATS_PLACEHOLDER}"></script>`, `<script src="${filename}_${casename}.js"></script>`);
+                    fs_extra_1.default.writeFileSync(node_path_1.default.join(this.options.dist, `${filename}_${casename}${extname}`), content, "utf-8");
+                    fs_extra_1.default.writeFileSync(node_path_1.default.join(this.options.dist, `${filename}_${casename}.js`), `window.$$diff_detail$$ = ${JSON.stringify(data)}`, "utf-8");
+                }
+            }
+            else {
+                fs_extra_1.default.copyFileSync(sourceFile, node_path_1.default.join(this.options.dist, viewerFile));
+            }
+        }
+    }
+}
+exports.DiffHtmlReporter = DiffHtmlReporter;

package/dist/reporter/diff-stats.d.ts

@@ -0,0 +1,24 @@
+import { ECompilerType, type ITestReporter, type TModuleCompareResult } from "../type";
+export interface IDiffStatsReporterOptions {
+    header?: string[];
+    footer?: string[];
+    file: string;
+    report?: boolean;
+}
+export type TCompilerTypeId = ECompilerType.Rspack | ECompilerType.Webpack | "common";
+export type TModuleTypeId = "normal" | "runtime";
+export type TDimenTypeId = "modules" | "lines" | "lines-in-common";
+export type TCaseSummaryId = `${TCompilerTypeId}|${TModuleTypeId}|${TDimenTypeId}`;
+export type TCaseSummary = Record<TCaseSummaryId, number>;
+export declare class DiffStatsReporter implements ITestReporter<TModuleCompareResult[]> {
+    private options;
+    private summary;
+    private failed;
+    constructor(options: IDiffStatsReporterOptions);
+    init(data?: TModuleCompareResult[]): Promise<void>;
+    failure(id: string): Promise<void>;
+    increment(id: string, data: TModuleCompareResult[]): Promise<void>;
+    output(): Promise<void>;
+    private stringifySummary;
+    private createSummary;
+}