@rspack-debug/test-tools 1.4.11 → 1.6.4

package/dist/processor/config.js

@@ -1,81 +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
-                    }
-                }
-            }
-        };
-    }
-    static overrideOptions(index, context, options) {
-        if (!options.entry) {
-            options.entry = "./index.js";
-        }
-        if (!options.output?.filename) {
-            const outputModule = options.experiments?.outputModule;
-            options.output ??= {};
-            options.output.filename = `bundle${index}${outputModule ? ".mjs" : ".js"}`;
-        }
-        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,102 +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
-                    }
-                }
-            }
-        };
-    }
-    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;
-}

package/dist/processor/diff.js

@@ -1,140 +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.DiffProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const compare_1 = require("../compare");
-const plugin_1 = require("../plugin");
-const type_1 = require("../type");
-const basic_1 = require("./basic");
-class DiffProcessor {
-    constructor(options) {
-        this.options = options;
-        this.hashes = [];
-        this.webpack = null;
-        if (global.updateSnapshot) {
-            this.webpack = new basic_1.BasicProcessor({
-                defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Webpack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Webpack)),
-                compilerType: type_1.ECompilerType.Webpack,
-                name: type_1.ECompilerType.Webpack,
-                configFiles: ["webpack.config.js", "rspack.config.js"],
-                runable: false
-            });
-        }
-        this.rspack = new basic_1.BasicProcessor({
-            defaultOptions: context => this.getDefaultOptions(type_1.ECompilerType.Rspack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Rspack)),
-            compilerType: type_1.ECompilerType.Rspack,
-            name: type_1.ECompilerType.Rspack,
-            configFiles: ["rspack.config.js", "webpack.config.js"],
-            runable: false
-        });
-    }
-    async config(context) {
-        if (this.webpack) {
-            await this.webpack.config(context);
-        }
-        await this.rspack.config(context);
-    }
-    async compiler(context) {
-        if (this.webpack) {
-            await this.webpack.compiler(context);
-        }
-        await this.rspack.compiler(context);
-    }
-    async build(context) {
-        if (this.webpack) {
-            await this.webpack.build(context);
-        }
-        await this.rspack.build(context);
-    }
-    async check(env, context) {
-        if (this.webpack) {
-            const webpackCompiler = context.getCompiler(type_1.ECompilerType.Webpack);
-            const webpackStats = webpackCompiler.getStats();
-            //TODO: handle chunk hash and content hash
-            webpackStats?.hash && this.hashes.push(webpackStats?.hash);
-            if (!this.options.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 && this.hashes.push(rspackStats?.hash);
-        if (!this.options.errors) {
-            env.expect(rspackStats?.hasErrors()).toBe(false);
-        }
-        const dist = context.getDist();
-        const snapshot = context.getSource("__snapshot__");
-        for (const file of this.options.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: this.options.modules,
-                runtimeModules: this.options.runtimeModules,
-                format: this.createFormatOptions(),
-                renameModule: this.options.renameModule,
-                bootstrap: this.options.bootstrap,
-                detail: this.options.detail,
-                snapshot: snapshotDist
-            });
-            if (typeof this.options.onCompareFile === "function") {
-                this.options.onCompareFile(file, result);
-            }
-            if (typeof this.options.onCompareModules === "function" &&
-                result.modules.modules) {
-                this.options.onCompareModules(file, result.modules.modules);
-            }
-            if (typeof this.options.onCompareRuntimeModules === "function" &&
-                result.modules.runtimeModules) {
-                this.options.onCompareRuntimeModules(file, result.modules.runtimeModules);
-            }
-        }
-    }
-    getDefaultOptions(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
-                        }
-                    }
-                }
-                : {}
-        };
-    }
-    createFormatOptions() {
-        const formatOptions = {
-            ignoreModuleArguments: this.options.ignoreModuleArguments,
-            ignoreModuleId: this.options.ignoreModuleId,
-            ignorePropertyQuotationMark: this.options.ignorePropertyQuotationMark,
-            ignoreBlockOnlyStatement: this.options.ignoreBlockOnlyStatement,
-            ignoreIfCertainCondition: this.options.ignoreIfCertainCondition,
-            ignoreSwcHelpersPath: this.options.ignoreSwcHelpersPath,
-            ignoreObjectPropertySequence: this.options.ignoreObjectPropertySequence,
-            ignoreCssFilePath: this.options.ignoreCssFilePath,
-            replacements: this.options.replacements || []
-        };
-        for (const hash of this.hashes) {
-            formatOptions.replacements.push({ from: hash, to: "fullhash" });
-        }
-        return formatOptions;
-    }
-}
-exports.DiffProcessor = DiffProcessor;

package/dist/processor/error.d.ts

@@ -1,23 +0,0 @@
-import type { StatsError } from "@rspack/core";
-import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions } from "../type";
-import { SimpleTaskProcessor } from "./simple";
-declare class RspackStatsDiagnostics {
-    errors: StatsError[];
-    warnings: StatsError[];
-    constructor(errors: StatsError[], warnings: StatsError[]);
-}
-export interface IErrorProcessorOptions<T extends ECompilerType> {
-    name: string;
-    compilerType: T;
-    options?: (options: TCompilerOptions<T>, context: ITestContext) => TCompilerOptions<T>;
-    build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (stats: RspackStatsDiagnostics) => Promise<void>;
-}
-export declare class ErrorProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
-    protected _errorOptions: IErrorProcessorOptions<T>;
-    constructor(_errorOptions: IErrorProcessorOptions<T>);
-    compiler(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-}
-export {};

package/dist/processor/error.js

@@ -1,95 +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.ErrorProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const simple_1 = require("./simple");
-class RspackStatsDiagnostics {
-    constructor(errors, warnings) {
-        this.errors = errors;
-        this.warnings = warnings;
-    }
-}
-class ErrorProcessor extends simple_1.SimpleTaskProcessor {
-    constructor(_errorOptions) {
-        super({
-            options: (context) => {
-                let options = {
-                    context: node_path_1.default.resolve(__dirname, "../../tests/fixtures/errors"),
-                    mode: "none",
-                    devtool: false,
-                    optimization: {
-                        minimize: false,
-                        moduleIds: "named",
-                        chunkIds: "named"
-                    },
-                    experiments: {
-                        css: true,
-                        rspackFuture: {
-                            bundlerInfo: {
-                                force: false
-                            }
-                        }
-                    }
-                };
-                if (typeof _errorOptions.options === "function") {
-                    options = (0, webpack_merge_1.default)(options, _errorOptions.options(options, context));
-                }
-                if (options.mode === "production") {
-                    if (options.optimization)
-                        options.optimization.minimize = true;
-                    else
-                        options.optimization = { minimize: true };
-                }
-                return options;
-            },
-            build: _errorOptions.build,
-            compilerType: _errorOptions.compilerType,
-            name: _errorOptions.name
-        });
-        this._errorOptions = _errorOptions;
-    }
-    async compiler(context) {
-        await super.compiler(context);
-        const compiler = this.getCompiler(context).getCompiler();
-        if (compiler) {
-            compiler.outputFileSystem = {
-                // CHANGE: rspack outputFileSystem `mkdirp` uses option `{ recursive: true }`, webpack's second parameter is alway a callback
-                mkdir(dir, maybeOptionOrCallback, maybeCallback) {
-                    if (typeof maybeOptionOrCallback === "function") {
-                        maybeOptionOrCallback();
-                    }
-                    else if (typeof maybeCallback === "function") {
-                        maybeCallback();
-                    }
-                },
-                writeFile(file, content, callback) {
-                    callback();
-                },
-                stat(file, callback) {
-                    callback(new Error("ENOENT"));
-                },
-                mkdirSync() { },
-                writeFileSync() { }
-            };
-        }
-    }
-    async run(env, context) {
-        // do nothing
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        env.expect(typeof stats).toBe("object");
-        const statsResult = stats.toJson({ errorDetails: false });
-        env.expect(typeof statsResult).toBe("object");
-        const { errors, warnings } = statsResult;
-        env.expect(Array.isArray(errors)).toBe(true);
-        env.expect(Array.isArray(warnings)).toBe(true);
-        await this._errorOptions.check?.(new RspackStatsDiagnostics(errors, warnings));
-    }
-}
-exports.ErrorProcessor = ErrorProcessor;

package/dist/processor/hash.d.ts

@@ -1,10 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-import { type IMultiTaskProcessorOptions, MultiTaskProcessor } from "./multi";
-export interface IHashProcessorOptions<T extends ECompilerType> extends Omit<IMultiTaskProcessorOptions<T>, "runable"> {
-}
-export declare class HashProcessor<T extends ECompilerType> extends MultiTaskProcessor<T> {
-    constructor(_hashOptions: IHashProcessorOptions<T>);
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    static defaultOptions<T extends ECompilerType>(index: number, context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(index: number, context: ITestContext, options: TCompilerOptions<T>): void;
-}

package/dist/processor/hash.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashProcessor = void 0;
-const multi_1 = require("./multi");
-const REG_ERROR_CASE = /error$/;
-class HashProcessor extends multi_1.MultiTaskProcessor {
-    constructor(_hashOptions) {
-        super({
-            defaultOptions: (HashProcessor.defaultOptions),
-            overrideOptions: (HashProcessor.overrideOptions),
-            runable: false,
-            ..._hashOptions
-        });
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const testConfig = context.getTestConfig();
-        const stats = compiler.getStats();
-        if (!stats) {
-            env.expect(false);
-            return;
-        }
-        if (REG_ERROR_CASE.test(this._options.name)) {
-            env.expect(stats.hasErrors());
-        }
-        else {
-            env.expect(!stats.hasErrors());
-        }
-        if (typeof testConfig.validate === "function") {
-            testConfig.validate(stats);
-        }
-        else {
-            throw new Error("HashTestCases should have test.config.js and a validate method");
-        }
-    }
-    static defaultOptions(index, context) {
-        return {
-            context: context.getSource(),
-            output: {
-                path: context.getDist()
-            },
-            experiments: {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                }
-            }
-        };
-    }
-    static overrideOptions(index, context, options) {
-        if (!options.entry) {
-            options.entry = "./index.js";
-        }
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.HashProcessor = HashProcessor;