@rspack/test-tools 1.6.0-beta.0 → 1.6.0

package/dist/test/debug.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEBUG_SCOPES = void 0;
+exports.generateDebugReport = generateDebugReport;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const javascript_stringify_1 = require("javascript-stringify");
+const stringify_config_1 = __importDefault(require("../helper/stringify-config"));
+function generateDebugReport(context) {
+    const report = `
+## Case Meta
+
+${generateCaseMetaPathReport(context)}
+
+${generateCaseMetaTestConfigReport(context)}
+
+## Compiler Options
+
+${generateReadConfigFileReport(context)}
+
+${generateFinalOptionsReport(context)}
+
+## Create Compiler
+
+${generateCreateCompilerInstanceReport(context)}
+
+${generateCreateCompilerSetPropertiesReport(context)}
+
+## Build
+
+${generateBuildMethodReport(context)}
+
+${generateBuildErrorReport(context)}
+
+${generateBuildWarningReport(context)}
+
+## Run
+
+${generateRunFindBundleReport(context)}
+
+${generateRunGetRunnerReport(context)}
+
+${generateRunLogsReport(context)}
+
+${generateRunErrorsReport(context)}
+
+  `;
+    const dist = context.getDist("debug.md");
+    fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(dist));
+    fs_extra_1.default.writeFileSync(dist, report);
+}
+function generateCaseMetaPathReport(context) {
+    return `
+### Case Path
+
+- Source: ${context.getSource()}
+- Dist: ${context.getDist()}
+- Temp: ${context.getTemp()}
+  `;
+}
+function generateCaseMetaTestConfigReport(context) {
+    return `
+### Test Config
+
+\`\`\`js
+// ${node_path_1.default.resolve(context.getSource(), "./test.config.js")}
+${(0, javascript_stringify_1.stringify)(context.getTestConfig(), null, 2)}
+\`\`\`
+  `;
+}
+function generateReadConfigFileReport(context) {
+    const configFileInfo = context.getValue(exports.DEBUG_SCOPES.CompilerOptionsReadConfigFile);
+    if (!configFileInfo)
+        return "";
+    return `
+### Read Config File
+
+\`\`\`js
+// ${configFileInfo.file}
+${(0, stringify_config_1.default)(configFileInfo.config)}
+\`\`\`
+  `;
+}
+function generateFinalOptionsReport(context) {
+    const finalOptions = context.getCompiler().getOptions();
+    return `
+### Final Options
+
+\`\`\`js
+${(0, stringify_config_1.default)(finalOptions)}
+\`\`\`
+`;
+}
+function generateCreateCompilerInstanceReport(context) {
+    const instanceInfo = context.getValue(exports.DEBUG_SCOPES.CreateCompilerInstance);
+    if (!instanceInfo)
+        return "";
+    return `
+### Create Compiler Instance
+
+- Rspack Path: ${instanceInfo.path}
+- Callback Mode: ${instanceInfo.mode}
+`;
+}
+function generateCreateCompilerSetPropertiesReport(context) {
+    const setPropertiesInfo = context.getValue(exports.DEBUG_SCOPES.CreateCompilerSetProperties);
+    if (!setPropertiesInfo || setPropertiesInfo.length === 0)
+        return "";
+    return `
+### Set Properties
+
+${setPropertiesInfo.map(p => `- ${p}`).join("\n")}
+`;
+}
+function generateBuildMethodReport(context) {
+    const buildMethod = context.getValue(exports.DEBUG_SCOPES.BuildMethod);
+    if (!buildMethod)
+        return "";
+    return `
+### Build Method
+
+- Method: \`compiler.${buildMethod.method}()\`
+${buildMethod.options ? `- Options:\n\`\`\`js\n${(0, javascript_stringify_1.stringify)(buildMethod.options, null, 2)}\n\`\`\`` : ""}
+`;
+}
+function generateBuildErrorReport(context) {
+    const buildError = context.getValue(exports.DEBUG_SCOPES.BuildError);
+    if (!buildError)
+        return "";
+    return `
+### Build Error
+
+type: ${buildError.type}
+
+${buildError.errors.map(e => `\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join("\n\n")}
+`;
+}
+function generateBuildWarningReport(context) {
+    const buildWarning = context.getValue(exports.DEBUG_SCOPES.BuildWarning);
+    if (!buildWarning)
+        return "";
+    return `
+### Build Warning
+
+${buildWarning.map(w => `\`\`\`\n// message:\n${w.message}\n// stack:\n${w.stack}\n\`\`\``).join("\n\n")}
+`;
+}
+function generateRunFindBundleReport(context) {
+    const runFindBundle = context.getValue(exports.DEBUG_SCOPES.RunFindBundle);
+    if (!runFindBundle)
+        return "";
+    return `
+### Find Bundle
+
+${runFindBundle.map(b => `- ${context.getDist(b)}`).join("\n")}
+`;
+}
+function generateRunGetRunnerReport(context) {
+    const getRunnerInfo = context.getValue(exports.DEBUG_SCOPES.RunGetRunner);
+    if (!getRunnerInfo)
+        return "";
+    return `
+### Get Runner
+
+${Object.entries(getRunnerInfo)
+        .map(([file, info]) => `- ${file}: ${info.runnerKey} (Reused: ${info.reused}, Type: \`${info.runnerType}\`)`)
+        .join("\n")}
+`;
+}
+function generateRunLogsReport(context) {
+    const runLogs = context.getValue(exports.DEBUG_SCOPES.RunLogs);
+    if (!runLogs)
+        return "";
+    return `
+### Run Logs
+
+${runLogs.map(l => `- ${l}`).join("\n")}
+`;
+}
+function generateRunErrorsReport(context) {
+    const runErrors = context.getValue(exports.DEBUG_SCOPES.RunErrors);
+    if (!runErrors)
+        return "";
+    return `
+### Run Errors
+
+${runErrors.map(e => `\`\`\`\n// message:\n${e.message}\n// stack:\n${e.stack}\n\`\`\``).join("\n\n")}
+`;
+}
+exports.DEBUG_SCOPES = {
+    CompilerOptionsReadConfigFile: "compiler-options:read-config-file",
+    CompilerOptionsFinalOptions: "compiler-options:final-options",
+    CreateCompilerInstance: "create-compiler:instance",
+    CreateCompilerSetProperties: "create-compiler:set-properties",
+    BuildMethod: "build:method",
+    BuildError: "build:error",
+    BuildWarning: "build:warning",
+    RunFindBundle: "run:find-bundle",
+    RunGetRunner: "run:get-runner",
+    RunLogs: "run:logs",
+    RunErrors: "run:errors"
+};

package/dist/test/tester.d.ts

@@ -10,6 +10,7 @@ export declare class Tester implements ITester {
     prepare(): Promise<void>;
     compile(): Promise<void>;
     check(env: ITestEnv): Promise<void>;
+    after(): Promise<void>;
     next(): boolean;
     resume(): Promise<void>;
     private runStepMethods;

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);
             }
         }
     }
@@ -55,6 +56,11 @@ class Tester {
         if (!currentStep)
             return;
         await this.runCheckStepMethods(currentStep, env, this.context.hasError() ? ["check"] : ["run", "check"]);
+    }
+    async after() {
+        const currentStep = this.steps[this.step];
+        if (!currentStep)
+            return;
         await this.runStepMethods(currentStep, ["after"], true);
     }
     next() {
@@ -73,7 +79,20 @@ class Tester {
                 await i.afterAll(this.context);
             }
         }
-        await this.context.closeCompiler(this.config.name);
+        try {
+            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) {
@@ -84,7 +103,7 @@ class Tester {
                     await step[i](this.context);
                 }
                 catch (e) {
-                    this.context.emitError(this.config.name, e);
+                    this.context.emitError(e);
                 }
             }
         }
@@ -98,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;
@@ -63,6 +50,7 @@ export interface ITester {
     prepare(): Promise<void>;
     compile(): Promise<void>;
     check(env: ITestEnv): Promise<void>;
+    after(): Promise<void>;
     next(): boolean;
     resume(): Promise<void>;
 }
@@ -77,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>;
 }
@@ -129,21 +117,17 @@ export interface ITestEnv {
     afterEach: (...args: any[]) => void;
     [key: string]: unknown;
 }
-export declare enum EDocumentType {
-    Fake = "fake",
-    JSDOM = "jsdom"
-}
-export type TTestConfig<T extends ECompilerType> = {
-    documentType?: EDocumentType;
-    validate?: (stats: TCompilerStats<T> | TCompilerMultiStats<T>, stderr?: string) => void;
+export type TTestConfig = {
+    location?: string;
+    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>;
@@ -152,23 +136,25 @@ export type TTestConfig<T extends ECompilerType> = {
     snapshotContent?(content: string): string;
     checkSteps?: boolean;
     ignoreNotFriendlyForIncrementalWarnings?: boolean;
+    esmLibPluginOptions?: {
+        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.EDocumentType = 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";
@@ -15,11 +10,6 @@ var ECompareResultType;
     ECompareResultType["OnlySource"] = "only-source";
     ECompareResultType["Different"] = "different";
 })(ECompareResultType || (exports.ECompareResultType = ECompareResultType = {}));
-var EDocumentType;
-(function (EDocumentType) {
-    EDocumentType["Fake"] = "fake";
-    EDocumentType["JSDOM"] = "jsdom";
-})(EDocumentType || (exports.EDocumentType = EDocumentType = {}));
 var EEsmMode;
 (function (EEsmMode) {
     EEsmMode[EEsmMode["Unknown"] = 0] = "Unknown";

package/jest.d.ts

@@ -22,4 +22,6 @@ declare global {
 			) => void;
 		}
 	}
+
+	var rstest = jest;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/test-tools",
-  "version": "1.6.0-beta.0",
+  "version": "1.6.0",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -36,77 +36,39 @@
     "directory": "packages/rspack-test-tools"
   },
   "dependencies": {
-    "@babel/generator": "7.28.3",
-    "@babel/parser": "7.28.4",
-    "@babel/traverse": "7.28.4",
-    "@babel/types": "7.28.4",
+    "@babel/generator": "7.28.5",
+    "@babel/parser": "7.28.5",
+    "@babel/traverse": "7.28.5",
+    "@babel/types": "7.28.5",
     "@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",
-    "glob": "^11.0.3",
-    "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",
     "jsdom": "^26.1.0",
     "memfs": "4.48.1",
-    "loader-utils": "^2.0.4",
     "path-serializer": "0.5.1",
     "pretty-format": "29.7.0",
     "rimraf": "^5.0.10",
     "source-map": "^0.7.6",
     "terser-webpack-plugin": "^5.3.14",
-    "webpack": "5.99.9",
+    "webpack": "5.102.1",
     "webpack-merge": "6.0.1",
-    "webpack-sources": "3.3.3"
+    "webpack-sources": "3.3.3",
+    "chalk": "^4.1.2"
   },
   "devDependencies": {
-    "@rspack/plugin-preact-refresh": "1.1.3",
-    "@rspack/plugin-react-refresh": "^1.5.1",
-    "@swc/helpers": "0.5.17",
-    "@swc/plugin-remove-console": "^9.1.0",
     "@types/babel__generator": "7.27.0",
     "@types/babel__traverse": "7.28.0",
     "@types/fs-extra": "11.0.4",
     "@types/jsdom": "^21.1.7",
-    "@types/react": "^19.1.13",
-    "@types/react-dom": "^19.1.9",
-    "@webdiscus/pug-loader": "^2.11.1",
-    "acorn": "^8.15.0",
-    "babel-loader": "^10.0.0",
-    "babel-plugin-import": "^1.13.8",
-    "chalk": "^4.1.2",
-    "core-js": "3.45.1",
-    "css-loader": "^7.1.2",
-    "file-loader": "^6.2.0",
-    "graceful-fs": "^4.2.11",
-    "html-loader": "^5.1.0",
-    "html-webpack-plugin": "^5.6.4",
-    "less-loader": "^12.3.0",
-    "lodash": "^4.17.21",
-    "postcss-loader": "^8.2.0",
-    "postcss-pxtorem": "^6.1.0",
-    "raw-loader": "^4.0.2",
-    "react": "^19.1.1",
-    "react-dom": "^19.1.1",
-    "react-refresh": "^0.17.0",
-    "sass-loader": "^16.0.5",
-    "source-map": "^0.7.6",
-    "source-map-loader": "^5.0.0",
-    "style-loader": "^4.0.0",
-    "terser": "5.43.1",
     "typescript": "^5.9.3",
     "wast-loader": "^1.14.1",
-    "worker-rspack-loader": "^3.1.2",
-    "exports-loader": "^5.0.0",
-    "@rspack/core": "1.6.0-beta.0",
-    "@rspack/cli": "1.6.0-beta.0",
-    "@rspack/binding-testing": "1.4.1",
-    "@rspack/test-tools": "1.6.0-beta.0"
+    "@rspack/core": "1.6.0"
   },
   "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;
-}