@rspack-canary/test-tools 1.6.0-canary-6cd722f4-20251022123039 → 1.6.0-canary-4ad8b49f-20251023175711

package/dist/test/tester.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tester = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const context_1 = require("./context");
+const debug_1 = require("./debug");
 class Tester {
     constructor(config) {
         this.config = config;
@@ -20,7 +21,7 @@ class Tester {
         this.total = config.steps?.length || 0;
         if (config.contextValue) {
             for (const [key, value] of Array.from(Object.entries(config.contextValue))) {
-                this.context.setValue(config.name, key, value);
+                this.context.setValue(key, value);
             }
         }
     }
@@ -79,11 +80,19 @@ class Tester {
             }
         }
         try {
-            await this.context.closeCompiler(this.config.name);
+            await this.context.closeCompiler();
         }
         catch (e) {
             console.warn(`Error occured while closing compilers of '${this.config.name}':\n${e.stack}`);
         }
+        if (__DEBUG__) {
+            try {
+                (0, debug_1.generateDebugReport)(this.context);
+            }
+            catch (e) {
+                console.warn(`Generate debug report failed: ${e.message}`);
+            }
+        }
     }
     async runStepMethods(step, methods, force = false) {
         for (const i of methods) {
@@ -94,7 +103,7 @@ class Tester {
                     await step[i](this.context);
                 }
                 catch (e) {
-                    this.context.emitError(this.config.name, e);
+                    this.context.emitError(e);
                 }
             }
         }
@@ -108,7 +117,7 @@ class Tester {
             }
         }
         catch (e) {
-            const errors = this.context.getError(this.config.name);
+            const errors = this.context.getError();
             console.error(new Error([...errors, e].map(e => e.message).join("\n")));
             throw e;
         }

package/dist/type.d.ts

@@ -1,42 +1,30 @@
 import type EventEmitter from "node:events";
-import type { Compilation as RspackCompilation, Compiler as RspackCompiler, MultiStats as RspackMultiStats, RspackOptions, Stats as RspackStats, StatsCompilation as RspackStatsCompilation } from "@rspack/core";
-import type { Compilation as WebpackCompilation, Compiler as WebpackCompiler, MultiStats as WebpackMultiStats, Configuration as WebpackOptions, Stats as WebpackStats, StatsCompilation as WebpackStatsCompilation } from "webpack";
+import type { Compiler, MultiStats, RspackOptions, Stats, StatsCompilation } from "@rspack/core";
 export interface ITestContext {
     getSource(sub?: string): string;
     getDist(sub?: string): string;
     getTemp(sub?: string): string | null;
-    getCompiler<T extends ECompilerType>(name: string, type: T | void): ITestCompilerManager<T>;
-    closeCompiler(name: string): Promise<void>;
-    getTestConfig<T extends ECompilerType>(): TTestConfig<T>;
-    getRunner(name: string, file: string, env: ITestEnv): ITestRunner;
-    setValue<T>(name: string, key: string, value: T): void;
-    getValue<T>(name: string, key: string): T | void;
-    getNames(): string[];
-    hasError(name?: string): boolean;
-    emitError(name: string, err: Error | string): void;
-    getError(name?: string): Error[];
-    clearError(name?: string): void;
-}
-export declare enum ECompilerType {
-    Rspack = "rspack",
-    Webpack = "webpack"
-}
-export type TCompilerOptions<T> = T extends ECompilerType.Rspack ? RspackOptions : WebpackOptions;
-export type TCompiler<T> = T extends ECompilerType.Rspack ? RspackCompiler : WebpackCompiler;
-export type TCompilation<T> = T extends ECompilerType.Rspack ? RspackCompilation : WebpackCompilation;
-export type TCompilerStats<T> = T extends ECompilerType.Rspack ? RspackStats : WebpackStats;
-export type TCompilerMultiStats<T> = T extends ECompilerType.Rspack ? RspackMultiStats : WebpackMultiStats;
-export type TCompilerStatsCompilation<T> = T extends ECompilerType.Rspack ? RspackStatsCompilation : WebpackStatsCompilation;
-export interface ITestCompilerManager<T extends ECompilerType> {
-    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>>;
+    getCompiler(): ITestCompilerManager;
+    closeCompiler(): Promise<void>;
+    getTestConfig(): TTestConfig;
+    getRunner(file: string, env: ITestEnv): ITestRunner;
+    setValue<T>(key: string, value: T): void;
+    getValue<T>(key: string): T | void;
+    hasError(): boolean;
+    emitError(err: Error | string): void;
+    getError(): Error[];
+    clearError(): void;
+}
+export interface ITestCompilerManager {
+    getOptions(): RspackOptions;
+    setOptions(newOptions: RspackOptions): RspackOptions;
+    mergeOptions(newOptions: RspackOptions): RspackOptions;
+    getCompiler(): Compiler | null;
+    createCompiler(): Compiler;
+    createCompilerWithCallback(callback: (error: Error | null, stats: Stats | null) => void): Compiler;
+    build(): Promise<Stats>;
     watch(timeout?: number): void;
-    getStats(): TCompilerStats<T> | TCompilerMultiStats<T> | null;
+    getStats(): Stats | MultiStats | null;
     getEmitter(): EventEmitter;
     close(): Promise<void>;
 }
@@ -50,8 +38,7 @@ export interface ITesterConfig {
     dist: string;
     temp?: string;
     steps?: ITestProcessor[];
-    testConfig?: TTestConfig<ECompilerType>;
-    compilerFactories?: TCompilerFactories<ECompilerType>;
+    testConfig?: TTestConfig;
     contextValue?: Record<string, unknown>;
     runnerCreator?: TTestRunnerCreator;
     createContext?: (config: ITesterConfig) => ITestContext;
@@ -78,9 +65,9 @@ export interface ITestProcessor {
     run(env: ITestEnv, context: ITestContext): Promise<void>;
     check(env: ITestEnv, context: ITestContext): Promise<unknown>;
 }
-export interface ITestReporter<T> {
-    init(data?: T): Promise<void>;
-    increment(id: string, data: T): Promise<void>;
+export interface ITestReporter {
+    init<T>(data?: T): Promise<void>;
+    increment<T>(id: string, data: T): Promise<void>;
     failure(id: string): Promise<void>;
     output(): Promise<void>;
 }
@@ -130,17 +117,17 @@ export interface ITestEnv {
     afterEach: (...args: any[]) => void;
     [key: string]: unknown;
 }
-export type TTestConfig<T extends ECompilerType> = {
+export type TTestConfig = {
     location?: string;
-    validate?: (stats: TCompilerStats<T> | TCompilerMultiStats<T>, stderr?: string) => void;
+    validate?: (stats: Stats | MultiStats, stderr?: string) => void;
     noTests?: boolean;
     writeStatsOuptut?: boolean;
     writeStatsJson?: boolean;
-    beforeExecute?: (options: TCompilerOptions<T>) => void;
-    afterExecute?: (options: TCompilerOptions<T>) => void;
-    moduleScope?: (ms: IModuleScope, stats?: TCompilerStatsCompilation<T>, options?: TCompilerOptions<T>) => IModuleScope;
-    checkStats?: (stepName: string, jsonStats: TCompilerStatsCompilation<T> | undefined, stringStats: String) => boolean;
-    findBundle?: (index: number, options: TCompilerOptions<T>, stepName?: string) => string | string[];
+    beforeExecute?: (options: RspackOptions) => void;
+    afterExecute?: (options: RspackOptions) => void;
+    moduleScope?: (ms: IModuleScope, stats?: StatsCompilation, options?: RspackOptions) => IModuleScope;
+    checkStats?: (stepName: string, jsonStats: StatsCompilation | undefined, stringStats: String) => boolean;
+    findBundle?: (index: number, options: RspackOptions, stepName?: string) => string | string[];
     bundlePath?: string[];
     nonEsmThis?: (p: string | string[]) => Object;
     modules?: Record<string, Object>;
@@ -153,22 +140,21 @@ export type TTestConfig<T extends ECompilerType> = {
         preserveModules?: string;
     };
 };
-export type TTestFilter<T extends ECompilerType> = (creatorConfig: Record<string, unknown>, testConfig: TTestConfig<T>) => boolean | string;
+export type TTestFilter = (creatorConfig: Record<string, unknown>, testConfig: TTestConfig) => boolean | string;
 export interface ITestRunner {
     run(file: string): Promise<unknown>;
     getRequire(): TRunnerRequirer;
     getGlobal(name: string): unknown;
 }
-export type TCompilerFactory<T extends ECompilerType> = (options: TCompilerOptions<T> | TCompilerOptions<T>[], callback?: (error: Error | null, stats: TCompilerStats<T> | null) => void) => TCompiler<T>;
-export interface TRunnerFactory<T extends ECompilerType> {
-    create(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
+export type TCompilerFactory = (options: RspackOptions | RspackOptions[], callback?: (error: Error | null, stats: Stats | null) => void) => Compiler;
+export interface TRunnerFactory {
+    create(file: string, compilerOptions: RspackOptions, env: ITestEnv): ITestRunner;
 }
 export type THotUpdateContext = {
     updateIndex: number;
     totalUpdates: number;
     changedFiles: string[];
 };
-export type TCompilerFactories<T extends ECompilerType> = Record<T, TCompilerFactory<T>>;
 export type TRunnerRequirer = (currentDirectory: string, modulePath: string[] | string, context?: {
     file?: TRunnerFile;
     esmMode?: EEsmMode;
@@ -202,6 +188,7 @@ export type TTestRunnerCreator = {
     runner: (context: ITestContext, name: string, file: string, env: ITestEnv) => ITestRunner;
 };
 declare global {
+    var __DEBUG__: boolean;
     var __TEST_PATH__: string;
     var __TEST_FIXTURES_PATH__: string;
     var __TEST_DIST_PATH__: string;

package/dist/type.js

@@ -1,12 +1,7 @@
 "use strict";
 /// <reference types="../jest.d.ts" />
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EEsmMode = exports.ECompareResultType = exports.ECompilerType = void 0;
-var ECompilerType;
-(function (ECompilerType) {
-    ECompilerType["Rspack"] = "rspack";
-    ECompilerType["Webpack"] = "webpack";
-})(ECompilerType || (exports.ECompilerType = ECompilerType = {}));
+exports.EEsmMode = exports.ECompareResultType = void 0;
 var ECompareResultType;
 (function (ECompareResultType) {
     ECompareResultType["Same"] = "same";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack-canary/test-tools",
-  "version": "1.6.0-canary-6cd722f4-20251022123039",
+  "version": "1.6.0-canary-4ad8b49f-20251023175711",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -42,12 +42,10 @@
     "@babel/types": "7.28.4",
     "@jest/reporters": "29.7.0",
     "cross-env": "^10.1.0",
-    "csv-to-markdown-table": "1.5.0",
-    "deepmerge": "^4.3.1",
     "filenamify": "4.3.0",
     "fs-extra": "^11.3.2",
-    "graceful-fs": "^4.2.11",
     "iconv-lite": "^0.6.3",
+    "javascript-stringify": "^2.1.0",
     "jest-diff": "^29.7.0",
     "jest-snapshot": "29.7.0",
     "jest-environment-node": "29.7.0",
@@ -60,19 +58,17 @@
     "terser-webpack-plugin": "^5.3.14",
     "webpack": "5.102.1",
     "webpack-merge": "6.0.1",
-    "webpack-sources": "3.3.3"
+    "webpack-sources": "3.3.3",
+    "chalk": "^4.1.2"
   },
   "devDependencies": {
     "@types/babel__generator": "7.27.0",
     "@types/babel__traverse": "7.28.0",
     "@types/fs-extra": "11.0.4",
     "@types/jsdom": "^21.1.7",
-    "chalk": "^4.1.2",
-    "source-map": "^0.7.6",
-    "terser": "5.43.1",
     "typescript": "^5.9.3",
     "wast-loader": "^1.14.1",
-    "@rspack/core": "npm:@rspack-canary/core@1.6.0-canary-6cd722f4-20251022123039"
+    "@rspack/core": "npm:@rspack-canary/core@1.6.0-canary-4ad8b49f-20251023175711"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"

package/dist/case/diff.d.ts

@@ -1,19 +0,0 @@
-import { type IFormatCodeOptions, type IFormatCodeReplacement } from "../compare";
-import { type TCompareModules, type TFileCompareResult, type TModuleCompareResult } from "../type";
-export type TDiffCaseConfig = IDiffProcessorOptions;
-export declare function createDiffCase(name: string, src: string, dist: string): void;
-export interface IDiffProcessorOptions extends IFormatCodeOptions {
-    webpackPath: string;
-    rspackPath: string;
-    files?: string[];
-    modules?: TCompareModules;
-    runtimeModules?: TCompareModules;
-    bootstrap?: boolean;
-    detail?: boolean;
-    errors?: boolean;
-    replacements?: IFormatCodeReplacement[];
-    renameModule?: (file: string) => string;
-    onCompareFile?: (file: string, result: TFileCompareResult) => void;
-    onCompareModules?: (file: string, results: TModuleCompareResult[]) => void;
-    onCompareRuntimeModules?: (file: string, results: TModuleCompareResult[]) => void;
-}

package/dist/case/diff.js

@@ -1,274 +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.createDiffCase = createDiffCase;
-const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const rimraf_1 = require("rimraf");
-const compare_1 = require("../compare");
-const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
-const plugin_1 = require("../plugin");
-const tester_1 = require("../test/tester");
-const type_1 = require("../type");
-const common_1 = require("./common");
-const DEFAULT_CASE_CONFIG = {
-    webpackPath: require.resolve("webpack"),
-    rspackPath: require.resolve("@rspack/core"),
-    files: ["bundle.js"],
-    bootstrap: true,
-    detail: true,
-    errors: false
-};
-function createDiffCase(name, src, dist) {
-    const caseConfigFile = node_path_1.default.join(src, "test.config.js");
-    if (!fs_extra_1.default.existsSync(caseConfigFile)) {
-        return;
-    }
-    const caseConfig = Object.assign({}, DEFAULT_CASE_CONFIG, require(caseConfigFile));
-    const [processor, compareMap] = createDiffProcessor(caseConfig);
-    const tester = new tester_1.Tester({
-        name,
-        src,
-        dist,
-        steps: [processor]
-    });
-    (0, rimraf_1.rimrafSync)(dist);
-    const prefix = node_path_1.default.basename(name);
-    describe(`${prefix}:check`, () => {
-        beforeAll(async () => {
-            await tester.compile();
-            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);
-                }
-            });
-        }
-        const env = (0, createLazyTestEnv_1.default)(1000);
-    });
-}
-function defaultOptions(type, src, dist) {
-    return {
-        entry: node_path_1.default.join(src, "./src/index.js"),
-        context: src,
-        output: {
-            path: dist,
-            filename: "bundle.js",
-            chunkFilename: "[name].chunk.js"
-        },
-        plugins: [
-            type === type_1.ECompilerType.Webpack && new plugin_1.WebpackDiffConfigPlugin(),
-            type === type_1.ECompilerType.Rspack && new plugin_1.RspackDiffConfigPlugin()
-        ].filter(Boolean),
-        experiments: type === type_1.ECompilerType.Rspack
-            ? {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                }
-            }
-            : {}
-    };
-}
-function createFormatOptions(options, hashes) {
-    const formatOptions = {
-        ignoreModuleArguments: options.ignoreModuleArguments,
-        ignoreModuleId: options.ignoreModuleId,
-        ignorePropertyQuotationMark: options.ignorePropertyQuotationMark,
-        ignoreBlockOnlyStatement: options.ignoreBlockOnlyStatement,
-        ignoreIfCertainCondition: options.ignoreIfCertainCondition,
-        ignoreSwcHelpersPath: options.ignoreSwcHelpersPath,
-        ignoreObjectPropertySequence: options.ignoreObjectPropertySequence,
-        ignoreCssFilePath: options.ignoreCssFilePath,
-        replacements: options.replacements || []
-    };
-    for (const hash of hashes) {
-        formatOptions.replacements.push({ from: hash, to: "fullhash" });
-    }
-    return formatOptions;
-}
-function createDiffProcessor(options) {
-    const fileCompareMap = new Map();
-    const createCompareResultHandler = (type) => {
-        return (file, results) => {
-            const fileResult = fileCompareMap.get(file) || {
-                modules: [],
-                runtimeModules: []
-            };
-            fileResult[type] = results;
-            fileCompareMap.set(file, fileResult);
-        };
-    };
-    const diffOptions = {
-        webpackPath: options.webpackPath,
-        rspackPath: options.rspackPath,
-        files: options.files,
-        modules: options.modules,
-        runtimeModules: options.runtimeModules,
-        renameModule: options.renameModule,
-        ignoreModuleId: options.ignoreModuleId ?? true,
-        ignoreModuleArguments: options.ignoreModuleArguments ?? true,
-        ignorePropertyQuotationMark: options.ignorePropertyQuotationMark ?? true,
-        ignoreBlockOnlyStatement: options.ignoreBlockOnlyStatement ?? true,
-        ignoreIfCertainCondition: options.ignoreIfCertainCondition ?? true,
-        ignoreSwcHelpersPath: options.ignoreSwcHelpersPath ?? true,
-        ignoreObjectPropertySequence: options.ignoreObjectPropertySequence ?? true,
-        ignoreCssFilePath: options.ignoreCssFilePath ?? true,
-        onCompareModules: createCompareResultHandler("modules"),
-        onCompareRuntimeModules: createCompareResultHandler("runtimeModules"),
-        bootstrap: options.bootstrap ?? true,
-        detail: options.detail ?? true,
-        errors: options.errors ?? false,
-        replacements: options.replacements
-    };
-    const hashes = [];
-    const webpackProcessor = global.updateSnapshot &&
-        {
-            config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, type_1.ECompilerType.Webpack);
-                let options = defaultOptions(type_1.ECompilerType.Webpack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Webpack));
-                options = await (0, common_1.config)(context, type_1.ECompilerType.Webpack, ["webpack.config.js", "rspack.config.js"], options);
-                compiler.setOptions(options);
-            },
-            compiler: async (context) => {
-                await (0, common_1.compiler)(context, type_1.ECompilerType.Webpack);
-            },
-            build: async (context) => {
-                await (0, common_1.build)(context, type_1.ECompilerType.Webpack);
-            },
-            run: async (env, context) => { },
-            check: async (env, context) => {
-                await (0, common_1.check)(env, context, type_1.ECompilerType.Webpack);
-            }
-        };
-    const rspackProcessor = {
-        config: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, type_1.ECompilerType.Rspack);
-            let options = defaultOptions(type_1.ECompilerType.Rspack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Rspack));
-            options = await (0, common_1.config)(context, type_1.ECompilerType.Rspack, ["rspack.config.js", "webpack.config.js"], options);
-            compiler.setOptions(options);
-        },
-        compiler: async (context) => {
-            await (0, common_1.compiler)(context, type_1.ECompilerType.Rspack);
-        },
-        build: async (context) => {
-            await (0, common_1.build)(context, type_1.ECompilerType.Rspack);
-        },
-        run: async (env, context) => { },
-        check: async (env, context) => {
-            await (0, common_1.check)(env, context, type_1.ECompilerType.Rspack);
-        }
-    };
-    const processor = {
-        config: async (context) => {
-            if (webpackProcessor) {
-                await webpackProcessor.config(context);
-            }
-            await rspackProcessor.config(context);
-        },
-        compiler: async (context) => {
-            if (webpackProcessor) {
-                await webpackProcessor.compiler(context);
-            }
-            await rspackProcessor.compiler(context);
-        },
-        build: async (context) => {
-            if (webpackProcessor) {
-                await webpackProcessor.build(context);
-            }
-            await rspackProcessor.build(context);
-        },
-        run: async (env, context) => { },
-        check: async (env, context) => {
-            if (webpackProcessor) {
-                const webpackCompiler = context.getCompiler(type_1.ECompilerType.Webpack);
-                const webpackStats = webpackCompiler.getStats();
-                //TODO: handle chunk hash and content hash
-                webpackStats?.hash && hashes.push(webpackStats?.hash);
-                if (!diffOptions.errors) {
-                    env.expect(webpackStats?.hasErrors()).toBe(false);
-                }
-            }
-            const rspackCompiler = context.getCompiler(type_1.ECompilerType.Rspack);
-            const rspackStats = rspackCompiler.getStats();
-            //TODO: handle chunk hash and content hash
-            rspackStats?.hash && hashes.push(rspackStats?.hash);
-            if (!diffOptions.errors) {
-                env.expect(rspackStats?.hasErrors()).toBe(false);
-            }
-            const dist = context.getDist();
-            const snapshot = context.getSource("__snapshot__");
-            for (const file of diffOptions.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: diffOptions.modules,
-                    runtimeModules: diffOptions.runtimeModules,
-                    format: createFormatOptions(diffOptions, hashes),
-                    renameModule: diffOptions.renameModule,
-                    bootstrap: diffOptions.bootstrap,
-                    detail: diffOptions.detail,
-                    snapshot: snapshotDist
-                });
-                if (typeof diffOptions.onCompareFile === "function") {
-                    diffOptions.onCompareFile(file, result);
-                }
-                if (typeof diffOptions.onCompareModules === "function" &&
-                    result.modules.modules) {
-                    diffOptions.onCompareModules(file, result.modules.modules);
-                }
-                if (typeof diffOptions.onCompareRuntimeModules === "function" &&
-                    result.modules.runtimeModules) {
-                    diffOptions.onCompareRuntimeModules(file, result.modules.runtimeModules);
-                }
-            }
-        }
-    };
-    return [processor, fileCompareMap];
-}
-function checkCompareResults(name, getResults) {
-    describe(`Comparing ${name}`, () => {
-        it("should not miss any module", () => {
-            expect(getResults()
-                .filter(i => i.type === type_1.ECompareResultType.Missing)
-                .map(i => i.name)).toEqual([]);
-        });
-        it("should not have any rspack-only module", () => {
-            expect(getResults()
-                .filter(i => i.type === type_1.ECompareResultType.OnlySource)
-                .map(i => i.name)).toEqual([]);
-        });
-        it("should not have any webpack-only module", () => {
-            expect(getResults()
-                .filter(i => i.type === type_1.ECompareResultType.OnlyDist)
-                .map(i => i.name)).toEqual([]);
-        });
-        it("all modules should be the same", () => {
-            for (const result of getResults().filter(i => i.type === type_1.ECompareResultType.Different)) {
-                console.log(`${result.name}:\n${result.detail}`);
-            }
-            expect(getResults().every(i => i.type === type_1.ECompareResultType.Same)).toEqual(true);
-        });
-    });
-}

package/dist/compare/comparator.d.ts

@@ -1,17 +0,0 @@
-import type { ITestReporter, TCompareModules } from "../type";
-import type { IFormatCodeOptions } from "./format-code";
-export interface IDiffComparatorOptions {
-    rspackDist: string;
-    webpackDist: string;
-    files: string[];
-    modules?: TCompareModules;
-    runtimeModules?: TCompareModules;
-    reporters: ITestReporter<unknown>[];
-    formatOptions?: IFormatCodeOptions;
-    bootstrap?: boolean;
-}
-export declare class DiffComparator {
-    private options;
-    constructor(options: IDiffComparatorOptions);
-    compare(): Promise<void>;
-}

package/dist/compare/comparator.js

@@ -1,52 +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.DiffComparator = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const deepmerge_1 = __importDefault(require("deepmerge"));
-const compare_1 = require("./compare");
-const replace_runtime_module_name_1 = require("./replace-runtime-module-name");
-class DiffComparator {
-    constructor(options) {
-        this.options = options;
-    }
-    async compare() {
-        for (const file of this.options.files) {
-            try {
-                const result = (0, compare_1.compareFile)(node_path_1.default.join(this.options.rspackDist, file), node_path_1.default.join(this.options.webpackDist, file), {
-                    modules: this.options.modules,
-                    runtimeModules: this.options.runtimeModules,
-                    format: (0, deepmerge_1.default)({
-                        replacements: {},
-                        ignorePropertyQuotationMark: true,
-                        ignoreModuleId: true,
-                        ignoreModuleArguments: true,
-                        ignoreBlockOnlyStatement: true,
-                        ignoreIfCertainCondition: true,
-                        ignoreSwcHelpersPath: true,
-                        ignoreObjectPropertySequence: true,
-                        ignoreCssFilePath: true
-                    }, this.options.formatOptions || {}),
-                    renameModule: replace_runtime_module_name_1.replaceRuntimeModuleName,
-                    bootstrap: this.options.bootstrap
-                });
-                for (const reporter of this.options.reporters) {
-                    reporter.increment(file, result.modules.modules || []);
-                }
-                for (const reporter of this.options.reporters) {
-                    reporter.increment(file, result.modules.runtimeModules || []);
-                }
-            }
-            catch (e) {
-                console.error(e);
-                for (const reporter of this.options.reporters) {
-                    reporter.failure(file);
-                }
-            }
-        }
-        await Promise.all(this.options.reporters.map(r => r.output()));
-    }
-}
-exports.DiffComparator = DiffComparator;

package/dist/compare/compare.d.ts

@@ -1,17 +0,0 @@
-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;
-    format: IFormatCodeOptions;
-    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: Record<string, string>, distModules: Record<string, string>, compareOptions: ICompareOptions): TModuleCompareResult[];
-export declare function compareContent(sourceContent: string | false, distContent: string | false, compareOptions: ICompareOptions): TCompareResult;