@rspack-canary/test-tools 1.6.0-canary-6cd722f4-20251022123039 → 1.6.0-canary-e28e40e9-20251022173516

package/dist/runner/web/index.d.ts

@@ -1,12 +1,12 @@
-import type { ECompilerType, TRunnerFile, TRunnerRequirer } from "../../type";
+import type { TRunnerFile, TRunnerRequirer } from "../../type";
 import { type INodeRunnerOptions, NodeRunner } from "../node";
-export interface IWebRunnerOptions<T extends ECompilerType = ECompilerType.Rspack> extends INodeRunnerOptions<T> {
+export interface IWebRunnerOptions extends INodeRunnerOptions {
     location: string;
 }
-export declare class WebRunner<T extends ECompilerType = ECompilerType.Rspack> extends NodeRunner<T> {
-    protected _webOptions: IWebRunnerOptions<T>;
+export declare class WebRunner extends NodeRunner {
+    protected _webOptions: IWebRunnerOptions;
     private dom;
-    constructor(_webOptions: IWebRunnerOptions<T>);
+    constructor(_webOptions: IWebRunnerOptions);
     run(file: string): Promise<unknown>;
     getGlobal(name: string): unknown;
     protected createResourceLoader(): {

package/dist/test/context.d.ts

@@ -1,18 +1,18 @@
-import { ECompilerType, type ITestCompilerManager, type ITestContext, type ITestEnv, type ITesterConfig, type ITestRunner, type TTestConfig } from "../type";
+import type { ITestCompilerManager, ITestContext, ITestEnv, ITesterConfig, ITestRunner, TTestConfig } from "../type";
 export type TTestContextOptions = Omit<ITesterConfig, "name" | "steps">;
 export declare class TestContext implements ITestContext {
     private config;
     protected errors: Map<string, Error[]>;
-    protected compilers: Map<string, ITestCompilerManager<ECompilerType>>;
+    protected compilers: Map<string, ITestCompilerManager>;
     protected store: Map<string, Record<string, unknown>>;
     protected runners: Map<string, ITestRunner>;
     constructor(config: TTestContextOptions);
     getSource(sub?: string): string;
     getDist(sub?: string): string;
     getTemp(sub?: string): string | null;
-    getCompiler<T extends ECompilerType>(name: string, type: T | void): ITestCompilerManager<T>;
+    getCompiler(name: string): ITestCompilerManager;
     getRunner(name: string, file: string, env: ITestEnv): ITestRunner;
-    getTestConfig<T extends ECompilerType>(): TTestConfig<T>;
+    getTestConfig(): TTestConfig;
     setValue<T>(name: string, key: string, value: T): void;
     getValue<T>(name: string, key: string): T | void;
     hasError(name?: string): boolean;

package/dist/test/context.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestContext = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const compiler_1 = require("../compiler");
-const type_1 = require("../type");
 class TestContext {
     constructor(config) {
         this.config = config;
@@ -35,13 +34,10 @@ class TestContext {
         }
         return this.config.temp;
     }
-    getCompiler(name, type) {
+    getCompiler(name) {
         let compiler = this.compilers.get(name);
         if (!compiler) {
-            if (!type) {
-                throw new Error("Compiler does not exists");
-            }
-            compiler = new compiler_1.TestCompilerManager(type, this.config.compilerFactories);
+            compiler = new compiler_1.TestCompilerManager();
             this.compilers.set(name, compiler);
         }
         return compiler;
@@ -105,13 +101,9 @@ class TestContext {
         }
     }
     async closeCompiler(name) {
-        const rspackCompiler = this.getCompiler(name, type_1.ECompilerType.Rspack);
-        if (rspackCompiler) {
-            await rspackCompiler.close();
-        }
-        const webpackCompiler = this.getCompiler(name, type_1.ECompilerType.Webpack);
-        if (webpackCompiler) {
-            await webpackCompiler.close();
+        const compiler = this.getCompiler(name);
+        if (compiler) {
+            await compiler.close();
         }
     }
 }

package/dist/test/creator.d.ts

@@ -1,4 +1,4 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITester, ITesterConfig, ITestProcessor, TTestConfig, TTestRunnerCreator } from "../type";
+import type { ITestContext, ITestEnv, ITester, ITesterConfig, ITestProcessor, TTestConfig, TTestRunnerCreator } from "../type";
 declare global {
     var testFilter: string | undefined;
 }
@@ -6,40 +6,40 @@ interface IConcurrentTestEnv {
     clear: () => void;
     run: () => Promise<void>;
 }
-export interface IBasicCaseCreatorOptions<T extends ECompilerType> {
+export interface IBasicCaseCreatorOptions {
     clean?: boolean;
     describe?: boolean;
     timeout?: number;
     contextValue?: Record<string, unknown>;
-    steps: (creatorConfig: IBasicCaseCreatorOptions<T> & {
+    steps: (creatorConfig: IBasicCaseCreatorOptions & {
         name: string;
         src: string;
         dist: string;
         temp: string | void;
     }) => ITestProcessor[];
-    testConfig?: (testConfig: TTestConfig<T>) => void;
+    testConfig?: (testConfig: TTestConfig) => void;
     description?: (name: string, step: number) => string;
     runner?: TTestRunnerCreator;
     createContext?: (config: ITesterConfig) => ITestContext;
     concurrent?: boolean | number;
     [key: string]: unknown;
 }
-export declare class BasicCaseCreator<T extends ECompilerType> {
-    protected _options: IBasicCaseCreatorOptions<T>;
+export declare class BasicCaseCreator {
+    protected _options: IBasicCaseCreatorOptions;
     protected currentConcurrent: number;
     protected tasks: [string, () => void][];
-    constructor(_options: IBasicCaseCreatorOptions<T>);
-    create(name: string, src: string, dist: string, temp?: string, caseOptions?: Partial<IBasicCaseCreatorOptions<T>>): ITester | undefined;
+    constructor(_options: IBasicCaseCreatorOptions);
+    create(name: string, src: string, dist: string, temp?: string, caseOptions?: Partial<IBasicCaseCreatorOptions>): ITester | undefined;
     protected shouldRun(name: string): boolean;
-    protected describeConcurrent(name: string, tester: ITester, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): void;
-    protected describe(name: string, tester: ITester, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): void;
+    protected describeConcurrent(name: string, tester: ITester, testConfig: TTestConfig, options: IBasicCaseCreatorOptions): void;
+    protected describe(name: string, tester: ITester, testConfig: TTestConfig, options: IBasicCaseCreatorOptions): void;
     protected createConcurrentEnv(): ITestEnv & IConcurrentTestEnv;
-    protected createEnv(testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): ITestEnv;
+    protected createEnv(testConfig: TTestConfig, options: IBasicCaseCreatorOptions): ITestEnv;
     protected clean(folders: string[]): void;
     protected skip(name: string, reason: string | boolean): void;
-    protected readTestConfig(src: string): TTestConfig<T>;
-    protected checkSkipped(src: string, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): boolean | string;
-    protected createTester(name: string, src: string, dist: string, temp: string | undefined, testConfig: TTestConfig<T>, options: IBasicCaseCreatorOptions<T>): ITester;
+    protected readTestConfig(src: string): TTestConfig;
+    protected checkSkipped(src: string, testConfig: TTestConfig, options: IBasicCaseCreatorOptions): boolean | string;
+    protected createTester(name: string, src: string, dist: string, temp: string | undefined, testConfig: TTestConfig, options: IBasicCaseCreatorOptions): ITester;
     protected tryRunTask(concurrent?: number): void;
     protected getMaxConcurrent(concurrent?: number): number;
     protected registerConcurrentTask(name: string, starter: () => void, concurrent?: number): () => void;

package/dist/test/creator.js

@@ -255,7 +255,8 @@ class BasicCaseCreator {
             it,
             beforeEach,
             afterEach,
-            jest
+            jest: global.jest || global.rstest,
+            rstest: global.rstest
         };
     }
     clean(folders) {
@@ -264,9 +265,7 @@ class BasicCaseCreator {
         }
     }
     skip(name, reason) {
-        describe.skip(name, () => {
-            it(typeof reason === "string" ? `filtered by ${reason}` : "filtered", () => { });
-        });
+        it(typeof reason === "string" ? `filtered by ${reason}` : "filtered", () => { });
     }
     readTestConfig(src) {
         const testConfigFile = node_path_1.default.join(src, "test.config.js");

package/dist/type.d.ts

@@ -1,13 +1,12 @@
 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>;
+    getCompiler(name: string): ITestCompilerManager;
     closeCompiler(name: string): Promise<void>;
-    getTestConfig<T extends ECompilerType>(): TTestConfig<T>;
+    getTestConfig(): TTestConfig;
     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;
@@ -17,26 +16,16 @@ export interface ITestContext {
     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>>;
+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 +39,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 +66,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 +118,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 +141,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;

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-e28e40e9-20251022173516",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -42,11 +42,8 @@
     "@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",
     "jest-diff": "^29.7.0",
     "jest-snapshot": "29.7.0",
@@ -60,19 +57,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-e28e40e9-20251022173516"
   },
   "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);
-        });
-    });
-}