@rspack-canary/test-tools 1.5.6-canary-e598f284-20250921173624 → 1.5.8-canary-e350b761-20250924173613

package/dist/processor/builtin.js

@@ -1,171 +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.BuiltinProcessor = void 0;
-const core_1 = require("@rspack/core");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const webpack_merge_1 = require("webpack-merge");
-const type_1 = require("../type");
-const snapshot_1 = require("./snapshot");
-class BuiltinProcessor extends snapshot_1.SnapshotProcessor {
-    constructor(_builtinOptions) {
-        super({
-            defaultOptions: BuiltinProcessor.defaultOptions,
-            runable: false,
-            ..._builtinOptions
-        });
-        this._builtinOptions = _builtinOptions;
-    }
-    static defaultOptions(context) {
-        let defaultOptions = {
-            entry: {
-                main: {
-                    import: "./index"
-                }
-            },
-            output: {
-                publicPath: "/",
-                path: context.getDist(),
-                filename: "[name].js",
-                chunkFilename: "[name].js",
-                chunkFormat: "array-push",
-                cssFilename: "[name].css",
-                cssChunkFilename: "[name].css",
-                assetModuleFilename: "[hash][ext][query]",
-                sourceMapFilename: "[file].map",
-                chunkLoadingGlobal: "webpackChunkwebpack",
-                chunkLoading: "jsonp",
-                uniqueName: "__rspack_test__",
-                enabledLibraryTypes: ["system"],
-                strictModuleErrorHandling: false,
-                iife: true,
-                module: false,
-                asyncChunks: true,
-                scriptType: false,
-                globalObject: "self",
-                importFunctionName: "import",
-                wasmLoading: "fetch",
-                webassemblyModuleFilename: "[hash].module.wasm",
-                workerChunkLoading: "import-scripts",
-                workerWasmLoading: "fetch"
-            },
-            module: {
-                rules: [
-                    {
-                        test: /\.json$/,
-                        type: "json"
-                    },
-                    {
-                        test: /\.mjs$/,
-                        type: "javascript/esm"
-                    },
-                    {
-                        test: /\.cjs$/,
-                        type: "javascript/dynamic"
-                    },
-                    {
-                        test: /\.js$/,
-                        type: "javascript/auto"
-                    },
-                    {
-                        test: /\.css$/,
-                        type: "css"
-                    },
-                    {
-                        test: /\.wasm$/,
-                        type: "webassembly/async"
-                    }
-                ]
-            },
-            node: {
-                __dirname: "mock",
-                __filename: "mock",
-                global: "warn"
-            },
-            optimization: {
-                runtimeChunk: {
-                    name: "runtime"
-                },
-                minimize: false,
-                removeAvailableModules: true,
-                removeEmptyChunks: true,
-                moduleIds: "named",
-                chunkIds: "named",
-                sideEffects: false,
-                mangleExports: false,
-                usedExports: false,
-                concatenateModules: false,
-                nodeEnv: false
-            },
-            resolve: {
-                extensions: [
-                    ".js",
-                    ".jsx",
-                    ".ts",
-                    ".tsx",
-                    ".json",
-                    ".d.ts",
-                    ".css",
-                    ".wasm"
-                ]
-            },
-            resolveLoader: {
-                extensions: [".js"]
-            },
-            experiments: {
-                css: true,
-                futureDefaults: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                }
-            },
-            devtool: false,
-            context: context.getSource(),
-            plugins: []
-        };
-        if (this._options.compilerType === type_1.ECompilerType.Rspack) {
-            let rspackDefaultOptions = defaultOptions;
-            const testConfigFile = context.getSource("rspack.config.js");
-            if (fs_extra_1.default.existsSync(testConfigFile)) {
-                const caseOptions = require(testConfigFile);
-                if (caseOptions.entry) {
-                    delete rspackDefaultOptions.entry;
-                }
-                rspackDefaultOptions = (0, webpack_merge_1.merge)(rspackDefaultOptions, caseOptions);
-            }
-            // TODO: remove builtin compatible code
-            const defineOptions = rspackDefaultOptions.builtins?.define;
-            if (defineOptions) {
-                rspackDefaultOptions.plugins.push(new core_1.rspack.DefinePlugin(defineOptions));
-            }
-            const provideOptions = rspackDefaultOptions.builtins?.provide;
-            if (provideOptions) {
-                rspackDefaultOptions.plugins.push(new core_1.rspack.ProvidePlugin(provideOptions));
-            }
-            const htmlOptions = rspackDefaultOptions.builtins?.html;
-            if (htmlOptions) {
-                if (Array.isArray(htmlOptions)) {
-                    for (const item of htmlOptions) {
-                        rspackDefaultOptions.plugins.push(new core_1.rspack.HtmlRspackPlugin(item));
-                    }
-                }
-                else {
-                    rspackDefaultOptions.plugins.push(new core_1.rspack.HtmlRspackPlugin(htmlOptions));
-                }
-            }
-            delete rspackDefaultOptions.builtins;
-            defaultOptions = rspackDefaultOptions;
-        }
-        if (!global.printLogger) {
-            defaultOptions.infrastructureLogging = {
-                level: "error"
-            };
-        }
-        return defaultOptions;
-    }
-}
-exports.BuiltinProcessor = BuiltinProcessor;

package/dist/processor/cache.d.ts

@@ -1,20 +0,0 @@
-import { HotUpdatePlugin } from "../helper/hot-update";
-import { ECompilerType, type ITestContext, type ITestEnv, type ITestRunner, type TCompilerOptions } from "../type";
-import { BasicProcessor, type IBasicProcessorOptions } from "./basic";
-export interface ICacheProcessorOptions<T extends ECompilerType> extends Omit<IBasicProcessorOptions<T>, "runable"> {
-    target: TCompilerOptions<T>["target"];
-    tempDir: string;
-    sourceDir: string;
-}
-export declare class CacheProcessor<T extends ECompilerType> extends BasicProcessor<T> {
-    protected _cacheOptions: ICacheProcessorOptions<T>;
-    protected updatePlugin: HotUpdatePlugin;
-    protected runner: ITestRunner | null;
-    constructor(_cacheOptions: ICacheProcessorOptions<T>);
-    config(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    static findBundle<T extends ECompilerType>(this: CacheProcessor<T>, context: ITestContext): string[];
-    afterAll(context: ITestContext): Promise<void>;
-    static defaultOptions<T extends ECompilerType>(this: CacheProcessor<T>, context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(this: CacheProcessor<T>, context: ITestContext, options: TCompilerOptions<T>): void;
-}

package/dist/processor/cache.js

@@ -1,131 +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.CacheProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const core_1 = require("@rspack/core");
-const helper_1 = require("../helper");
-const hot_update_1 = require("../helper/hot-update");
-const type_1 = require("../type");
-const basic_1 = require("./basic");
-class CacheProcessor extends basic_1.BasicProcessor {
-    constructor(_cacheOptions) {
-        super({
-            defaultOptions: CacheProcessor.defaultOptions,
-            overrideOptions: CacheProcessor.overrideOptions,
-            findBundle: CacheProcessor.findBundle,
-            runable: true,
-            ..._cacheOptions
-        });
-        this._cacheOptions = _cacheOptions;
-        this.runner = null;
-        this.updatePlugin = new hot_update_1.HotUpdatePlugin(_cacheOptions.sourceDir, _cacheOptions.tempDir);
-    }
-    async config(context) {
-        await this.updatePlugin.initialize();
-        this._options.configFiles = this._options.configFiles?.map(item => {
-            return node_path_1.default.resolve(this._cacheOptions.tempDir, item);
-        });
-        super.config(context);
-    }
-    async run(env, context) {
-        context.setValue(this._options.name, "hotUpdateContext", this.updatePlugin);
-        await super.run(env, context);
-    }
-    static findBundle(context) {
-        const files = [];
-        const prefiles = [];
-        const compiler = context.getCompiler(this._cacheOptions.name);
-        if (!compiler)
-            throw new Error("Compiler should exists when find bundle");
-        const stats = compiler.getStats();
-        if (!stats)
-            throw new Error("Stats should exists when find bundle");
-        const info = stats.toJson({ all: false, entrypoints: true });
-        if (this._cacheOptions.target === "web" ||
-            this._cacheOptions.target === "webworker") {
-            for (const file of info.entrypoints.main.assets) {
-                if ((0, helper_1.isJavaScript)(file.name)) {
-                    files.push(file.name);
-                }
-                else {
-                    prefiles.push(file.name);
-                }
-            }
-        }
-        else {
-            const assets = info.entrypoints.main.assets.filter(s => (0, helper_1.isJavaScript)(s.name));
-            files.push(assets[assets.length - 1].name);
-        }
-        return [...prefiles, ...files];
-    }
-    async afterAll(context) {
-        await super.afterAll(context);
-        const updateIndex = this.updatePlugin.getUpdateIndex();
-        const totalUpdates = this.updatePlugin.getTotalUpdates();
-        if (updateIndex + 1 !== totalUpdates) {
-            throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${this._options.name}`);
-        }
-    }
-    static defaultOptions(context) {
-        const options = {
-            context: this._cacheOptions.tempDir,
-            mode: "production",
-            cache: true,
-            devtool: false,
-            output: {
-                path: context.getDist(),
-                filename: "bundle.js",
-                chunkFilename: "[name].chunk.[fullhash].js",
-                publicPath: "https://test.cases/path/",
-                library: { type: "commonjs2" }
-            },
-            optimization: {
-                moduleIds: "named",
-                emitOnErrors: true
-            },
-            target: this._cacheOptions.target,
-            experiments: {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                inlineConst: true,
-                lazyBarrel: true
-            }
-        };
-        if (this._cacheOptions.compilerType === type_1.ECompilerType.Rspack) {
-            options.plugins ??= [];
-            options.plugins.push(new core_1.rspack.HotModuleReplacementPlugin());
-        }
-        return options;
-    }
-    static overrideOptions(context, options) {
-        if (!options.entry) {
-            options.entry = "./index.js";
-        }
-        // rewrite context to temp dir
-        options.context = this._cacheOptions.tempDir;
-        options.module ??= {};
-        for (const cssModuleType of ["css/auto", "css/module", "css"]) {
-            options.module.generator ??= {};
-            options.module.generator[cssModuleType] ??= {};
-            options.module.generator[cssModuleType].exportsOnly ??=
-                this._cacheOptions.target === "async-node";
-        }
-        if (this._cacheOptions.compilerType === type_1.ECompilerType.Rspack) {
-            options.plugins ??= [];
-            options.plugins.push(this.updatePlugin);
-        }
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.CacheProcessor = CacheProcessor;

package/dist/processor/config.d.ts

@@ -1,11 +0,0 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
-import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
-export interface IConfigProcessorOptions<T extends ECompilerType> extends IMultiTaskProcessorOptions<T> {
-}
-export declare class ConfigProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
-    protected _configOptions: IConfigProcessorOptions<T>;
-    constructor(_configOptions: IConfigProcessorOptions<T>);
-    static findBundle<T extends ECompilerType>(index: number, context: ITestContext, options: TCompilerOptions<T>): string | string[];
-    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/config.js

@@ -1,88 +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.ConfigProcessor = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const parseResource_1 = require("../helper/legacy/parseResource");
-const multi_1 = require("./multi");
-class ConfigProcessor extends multi_1.MultiTaskProcessor {
-    constructor(_configOptions) {
-        super({
-            defaultOptions: (ConfigProcessor.defaultOptions),
-            overrideOptions: (ConfigProcessor.overrideOptions),
-            findBundle: (ConfigProcessor.findBundle),
-            ..._configOptions
-        });
-        this._configOptions = _configOptions;
-    }
-    static findBundle(index, context, options) {
-        const testConfig = context.getTestConfig();
-        if (typeof testConfig.findBundle === "function") {
-            return testConfig.findBundle(index, options);
-        }
-        const ext = node_path_1.default.extname((0, parseResource_1.parseResource)(options.output?.filename).path);
-        const bundlePath = [];
-        if (options.output?.path &&
-            node_fs_1.default.existsSync(node_path_1.default.join(options.output.path, `bundle${index}${ext}`))) {
-            if (options.experiments?.css) {
-                const cssOutputPath = node_path_1.default.join(options.output.path, (typeof options.output?.cssFilename === "string" &&
-                    options.output?.cssFilename) ||
-                    `bundle${index}.css`);
-                if (node_fs_1.default.existsSync(cssOutputPath)) {
-                    bundlePath.push(`./bundle${index}.css`);
-                }
-            }
-            bundlePath.push(`./bundle${index}${ext}`);
-        }
-        return bundlePath;
-    }
-    static defaultOptions(index, context) {
-        return {
-            context: context.getSource(),
-            mode: "production",
-            target: "async-node",
-            devtool: false,
-            cache: false,
-            output: {
-                path: context.getDist()
-            },
-            optimization: {
-                minimize: false
-            },
-            experiments: {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                inlineConst: true,
-                lazyBarrel: true
-            }
-        };
-    }
-    static overrideOptions(index, context, options) {
-        if (!options.entry) {
-            options.entry = "./index.js";
-        }
-        if (options.amd === undefined) {
-            options.amd = {};
-        }
-        if (!options.output?.filename) {
-            const outputModule = options.experiments?.outputModule;
-            options.output ??= {};
-            options.output.filename = `bundle${index}${outputModule ? ".mjs" : ".js"}`;
-        }
-        if (options.cache === undefined)
-            options.cache = false;
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.ConfigProcessor = ConfigProcessor;

package/dist/processor/defaults.d.ts

@@ -1,30 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-import { SimpleTaskProcessor } from "./simple";
-declare class RspackTestDiff {
-    value: string;
-    constructor(value: string);
-}
-export interface IDefaultsConfigProcessorOptions<T extends ECompilerType> {
-    options?: (context: ITestContext) => TCompilerOptions<T>;
-    cwd?: string;
-    name: string;
-    diff: (diff: jest.JestMatchers<RspackTestDiff>, defaults: jest.JestMatchers<TCompilerOptions<T>>) => Promise<void>;
-    compilerType: T;
-}
-export declare class DefaultsConfigProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
-    protected _defaultsConfigOptions: IDefaultsConfigProcessorOptions<T>;
-    private defaultConfig;
-    constructor(_defaultsConfigOptions: IDefaultsConfigProcessorOptions<T>);
-    compiler(context: ITestContext): Promise<void>;
-    build(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    before(context: ITestContext): Promise<void>;
-    after(context: ITestContext): Promise<void>;
-    beforeAll(context: ITestContext): Promise<void>;
-    afterAll(context: ITestContext): Promise<void>;
-    protected getCompiler(context: ITestContext): import("../type").ITestCompilerManager<T>;
-    static getDefaultConfig(cwd: string, config: TCompilerOptions<ECompilerType>): TCompilerOptions<ECompilerType>;
-    static overrideOptions<T extends ECompilerType>(options: TCompilerOptions<T>): void;
-}
-export {};

package/dist/processor/defaults.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultsConfigProcessor = void 0;
-const node_util_1 = require("node:util");
-const jest_diff_1 = require("jest-diff");
-const simple_1 = require("./simple");
-const CURRENT_CWD = process.cwd();
-class RspackTestDiff {
-    constructor(value) {
-        this.value = value;
-    }
-}
-class DefaultsConfigProcessor extends simple_1.SimpleTaskProcessor {
-    constructor(_defaultsConfigOptions) {
-        super({
-            options: context => {
-                let res;
-                if (typeof _defaultsConfigOptions.options === "function") {
-                    res = _defaultsConfigOptions.options(context);
-                }
-                else {
-                    res = {};
-                }
-                if (!("mode" in res)) {
-                    res.mode = "none";
-                }
-                return res;
-            },
-            compilerType: _defaultsConfigOptions.compilerType,
-            name: _defaultsConfigOptions.name
-        });
-        this._defaultsConfigOptions = _defaultsConfigOptions;
-        this.defaultConfig = DefaultsConfigProcessor.getDefaultConfig(CURRENT_CWD, {
-            mode: "none"
-        });
-    }
-    async compiler(context) { }
-    async build(context) { }
-    async run(env, context) { }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const config = DefaultsConfigProcessor.getDefaultConfig(this._defaultsConfigOptions.cwd || CURRENT_CWD, compiler.getOptions());
-        const diff = (0, node_util_1.stripVTControlCharacters)((0, jest_diff_1.diff)(this.defaultConfig, config, { expand: false, contextLines: 0 }));
-        await this._defaultsConfigOptions.diff(env.expect(new RspackTestDiff(diff)), env.expect(this.defaultConfig));
-    }
-    async before(context) { }
-    async after(context) { }
-    async beforeAll(context) { }
-    async afterAll(context) { }
-    getCompiler(context) {
-        return context.getCompiler(this._options.name, this._options.compilerType);
-    }
-    static getDefaultConfig(cwd, config) {
-        process.chdir(cwd);
-        const { applyWebpackOptionsDefaults, getNormalizedWebpackOptions } = require("@rspack/core").config;
-        const normalizedConfig = getNormalizedWebpackOptions(config);
-        applyWebpackOptionsDefaults(normalizedConfig);
-        // make snapshot stable
-        normalizedConfig.experiments.rspackFuture.bundlerInfo.version =
-            "$version$";
-        process.chdir(CURRENT_CWD);
-        return normalizedConfig;
-    }
-    static overrideOptions(options) {
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.DefaultsConfigProcessor = DefaultsConfigProcessor;

package/dist/processor/diagnostic.d.ts

@@ -1,15 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-import { BasicProcessor, type IBasicProcessorOptions } from "./basic";
-export interface IDiagnosticProcessorOptions<T extends ECompilerType> extends Omit<IBasicProcessorOptions<T>, "runable"> {
-    snapshot: string;
-    snapshotErrors: string;
-    snapshotWarning: string;
-    format?: (output: string) => string;
-}
-export declare class DiagnosticProcessor<T extends ECompilerType> extends BasicProcessor<T> {
-    protected _diagnosticOptions: IDiagnosticProcessorOptions<T>;
-    constructor(_diagnosticOptions: IDiagnosticProcessorOptions<T>);
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    static defaultOptions<T extends ECompilerType>(context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(options: TCompilerOptions<T>): void;
-}

package/dist/processor/diagnostic.js

@@ -1,104 +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.DiagnosticProcessor = void 0;
-const node_assert_1 = __importDefault(require("node:assert"));
-const node_path_1 = __importDefault(require("node:path"));
-const placeholder_1 = require("../helper/expect/placeholder");
-const basic_1 = require("./basic");
-class DiagnosticProcessor extends basic_1.BasicProcessor {
-    constructor(_diagnosticOptions) {
-        super({
-            defaultOptions: (DiagnosticProcessor.defaultOptions),
-            runable: false,
-            ..._diagnosticOptions
-        });
-        this._diagnosticOptions = _diagnosticOptions;
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        if (!stats) {
-            throw new Error("Stats should exists");
-        }
-        (0, node_assert_1.default)(stats.hasErrors() || stats.hasWarnings());
-        let output = (0, placeholder_1.normalizePlaceholder)(stats.toString({
-            all: false,
-            errors: true,
-            warnings: true
-        })).replaceAll("\\", "/"); // stats has some win32 paths that path-serializer can not handle
-        const statsJson = stats.toJson({
-            all: false,
-            errors: true,
-            warnings: true
-        });
-        const errors = (statsJson.errors || []).map(e => {
-            // @ts-expect-error error message is already serialized in `stats.err`
-            delete e.message;
-            delete e.stack;
-            return e;
-        });
-        const warnings = (statsJson.warnings || []).map(e => {
-            // @ts-expect-error error message is already serialized in `stats.err`
-            delete e.message;
-            delete e.stack;
-            return e;
-        });
-        if (typeof this._diagnosticOptions.format === "function") {
-            output = this._diagnosticOptions.format(output);
-        }
-        env.expect.addSnapshotSerializer({
-            test(received) {
-                return typeof received === "string";
-            },
-            serialize(received) {
-                return (0, placeholder_1.normalizePlaceholder)(received.trim());
-            }
-        });
-        const errorOutputPath = node_path_1.default.resolve(context.getSource(this._diagnosticOptions.snapshot));
-        const errorStatsOutputPath = node_path_1.default.resolve(context.getSource(this._diagnosticOptions.snapshotErrors));
-        const warningStatsOutputPath = node_path_1.default.resolve(context.getSource(this._diagnosticOptions.snapshotWarning));
-        env.expect(output).toMatchFileSnapshot(errorOutputPath);
-        env.expect(errors).toMatchFileSnapshot(errorStatsOutputPath);
-        env.expect(warnings).toMatchFileSnapshot(warningStatsOutputPath);
-    }
-    static defaultOptions(context) {
-        return {
-            target: "node",
-            context: context.getSource(),
-            entry: {
-                main: "./"
-            },
-            mode: "development",
-            devServer: {
-                hot: false
-            },
-            infrastructureLogging: {
-                debug: false
-            },
-            output: {
-                path: context.getDist()
-            },
-            experiments: {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                inlineConst: true,
-                lazyBarrel: true
-            }
-        };
-    }
-    static overrideOptions(options) {
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.DiagnosticProcessor = DiagnosticProcessor;

package/dist/processor/diff.d.ts

@@ -1,30 +0,0 @@
-import { type IFormatCodeOptions, type IFormatCodeReplacement } from "../compare";
-import { type ITestContext, type ITestEnv, type ITestProcessor, type TCompareModules, type TFileCompareResult, type TModuleCompareResult } from "../type";
-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;
-}
-export declare class DiffProcessor implements ITestProcessor {
-    private options;
-    private hashes;
-    private webpack;
-    private rspack;
-    constructor(options: IDiffProcessorOptions);
-    config(context: ITestContext): Promise<void>;
-    compiler(context: ITestContext): Promise<void>;
-    build(context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    private getDefaultOptions;
-    private createFormatOptions;
-}