@rspack-debug/test-tools 1.4.11 → 1.6.4

package/dist/processor/stats-api.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatsAPIProcessor = void 0;
-const memfs_1 = require("memfs");
-const simple_1 = require("./simple");
-class StatsAPIProcessor extends simple_1.SimpleTaskProcessor {
-    constructor(_statsAPIOptions) {
-        super({
-            options: context => {
-                const res = (_statsAPIOptions.options?.(context) ||
-                    {});
-                res.experiments ??= {};
-                res.experiments.css ??= true;
-                res.experiments.rspackFuture ??= {};
-                res.experiments.rspackFuture.bundlerInfo ??= {};
-                res.experiments.rspackFuture.bundlerInfo.force ??= false;
-                if (!global.printLogger) {
-                    res.infrastructureLogging = {
-                        level: "error"
-                    };
-                }
-                return res;
-            },
-            build: _statsAPIOptions.build,
-            compilerType: _statsAPIOptions.compilerType,
-            name: _statsAPIOptions.name,
-            compiler: _statsAPIOptions.compiler
-        });
-        this._statsAPIOptions = _statsAPIOptions;
-    }
-    async compiler(context) {
-        await super.compiler(context);
-        const compiler = this.getCompiler(context).getCompiler();
-        if (compiler) {
-            compiler.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
-        }
-    }
-    async run(env, context) {
-        // do nothing
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        env.expect(typeof stats).toBe("object");
-        await this._statsAPIOptions.check?.(stats, compiler.getCompiler());
-    }
-}
-exports.StatsAPIProcessor = StatsAPIProcessor;

package/dist/processor/stats.d.ts

@@ -1,18 +0,0 @@
-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

@@ -1,206 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,33 +0,0 @@
-"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

@@ -1,30 +0,0 @@
-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;
-    nativeWatcher?: boolean;
-}
-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, nativeWatcher }: 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

@@ -1,241 +0,0 @@
-"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, nativeWatcher }) {
-        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;
-            if (nativeWatcher) {
-                options.experiments.nativeWatcher ??= true;
-            }
-            options.experiments.rspackFuture ??= {};
-            options.experiments.rspackFuture.bundlerInfo ??= {};
-            options.experiments.rspackFuture.bundlerInfo.force ??= false;
-            // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
-            options.experiments.incremental ??= "safe";
-            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);
-            });
-        });
-        // wait compiler to ready watch the files and diretories
-        await new Promise(resolve => setTimeout(resolve, 100));
-        (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

@@ -1,15 +0,0 @@
-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

@@ -1,69 +0,0 @@
-"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;