@rspack-debug/test-tools 1.4.11 → 1.6.4

package/dist/plugin/webpack-diff-config-plugin.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebpackDiffConfigPlugin = void 0;
-const webpack_module_placeholder_plugin_1 = require("./webpack-module-placeholder-plugin");
-const PLUGIN_NAME = "WebpackDiffConfigPlugin";
-class WebpackDiffConfigPlugin {
-    constructor(modifier) {
-        this.modifier = modifier;
-        this.name = PLUGIN_NAME;
-    }
-    apply(compiler) {
-        const { options } = compiler;
-        options.mode = "development";
-        options.devtool = false;
-        options.optimization ??= {};
-        options.optimization.minimize = false;
-        options.optimization.chunkIds = "named";
-        options.optimization.moduleIds = "named";
-        options.optimization.mangleExports ??= false;
-        options.optimization.concatenateModules ??= false;
-        options.output ??= {};
-        options.output.pathinfo ??= false;
-        options.output.environment ??= {};
-        options.output.environment.arrowFunction ??= false;
-        options.output.environment.bigIntLiteral ??= false;
-        options.output.environment.const ??= false;
-        options.output.environment.destructuring ??= false;
-        options.output.environment.dynamicImport ??= false;
-        options.output.environment.dynamicImportInWorker ??= false;
-        options.output.environment.forOf ??= false;
-        options.output.environment.globalThis ??= false;
-        options.output.environment.module ??= false;
-        options.output.environment.optionalChaining ??= false;
-        options.output.environment.templateLiteral ??= false;
-        if (typeof this.modifier === "function") {
-            this.modifier(compiler.options);
-        }
-        new webpack_module_placeholder_plugin_1.WebpackModulePlaceholderPlugin().apply(compiler);
-    }
-}
-exports.WebpackDiffConfigPlugin = WebpackDiffConfigPlugin;

package/dist/plugin/webpack-module-placeholder-plugin.d.ts

@@ -1,3 +0,0 @@
-export declare class WebpackModulePlaceholderPlugin {
-    apply(compiler: any): void;
-}

package/dist/plugin/webpack-module-placeholder-plugin.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebpackModulePlaceholderPlugin = void 0;
-// @ts-nocheck
-const { ConcatSource, RawSource, CachedSource, PrefixSource } = require("webpack-sources");
-function createRenderRuntimeModulesFn(Template) {
-    return function renderRuntimeModules(runtimeModules, renderContext) {
-        const source = new ConcatSource();
-        for (const module of runtimeModules) {
-            const codeGenerationResults = renderContext.codeGenerationResults;
-            let runtimeSource;
-            if (codeGenerationResults) {
-                runtimeSource = codeGenerationResults.getSource(module, renderContext.chunk.runtime, "runtime");
-            }
-            else {
-                const codeGenResult = module.codeGeneration({
-                    chunkGraph: renderContext.chunkGraph,
-                    dependencyTemplates: renderContext.dependencyTemplates,
-                    moduleGraph: renderContext.moduleGraph,
-                    runtimeTemplate: renderContext.runtimeTemplate,
-                    runtime: renderContext.chunk.runtime,
-                    codeGenerationResults
-                });
-                if (!codeGenResult)
-                    continue;
-                runtimeSource = codeGenResult.sources.get("runtime");
-            }
-            if (runtimeSource) {
-                const identifier = module.identifier();
-                source.add(`${Template.toNormalComment(`start::${identifier}`)}\n`);
-                if (!module.shouldIsolate()) {
-                    source.add(runtimeSource);
-                    source.add("\n\n");
-                }
-                else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
-                    source.add("(() => {\n");
-                    source.add(new PrefixSource("\t", runtimeSource));
-                    source.add("\n})();\n\n");
-                }
-                else {
-                    source.add("!function() {\n");
-                    source.add(new PrefixSource("\t", runtimeSource));
-                    source.add("\n}();\n\n");
-                }
-                source.add(`${Template.toNormalComment(`end::${identifier}`)}\n`);
-            }
-        }
-        return source;
-    };
-}
-const caches = new WeakMap();
-class WebpackModulePlaceholderPlugin {
-    apply(compiler) {
-        const { webpack } = compiler;
-        const { Template, javascript: { JavascriptModulesPlugin } } = webpack;
-        Template.renderRuntimeModules = createRenderRuntimeModulesFn(Template);
-        compiler.hooks.compilation.tap("RuntimeDiffPlugin", compilation => {
-            const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-            hooks.inlineInRuntimeBailout.tap("RuntimeDiffPlugin", () => "not allow inline startup");
-            hooks.renderModulePackage.tap("RuntimeDiffPlugin", (moduleSource, module) => {
-                let cacheEntry;
-                let cache = caches.get(compilation);
-                if (cache === undefined) {
-                    caches.set(compilation, (cache = new WeakMap()));
-                    cache.set(module, (cacheEntry = {
-                        header: undefined,
-                        footer: undefined,
-                        full: new WeakMap()
-                    }));
-                }
-                else {
-                    cacheEntry = cache.get(module);
-                    if (cacheEntry === undefined) {
-                        cache.set(module, (cacheEntry = {
-                            header: undefined,
-                            footer: undefined,
-                            full: new WeakMap()
-                        }));
-                    }
-                    else {
-                        const cachedSource = cacheEntry.full.get(moduleSource);
-                        if (cachedSource !== undefined)
-                            return cachedSource;
-                    }
-                }
-                const source = new ConcatSource();
-                let header = cacheEntry.header;
-                let footer = cacheEntry.footer;
-                if (header === undefined) {
-                    const identifier = module.identifier();
-                    header = new RawSource(`\n${Template.toNormalComment(`start::${identifier}`)}\n`);
-                    footer = new RawSource(`\n${Template.toNormalComment(`end::${identifier}`)}\n`);
-                    cacheEntry.header = header;
-                    cacheEntry.footer = footer;
-                }
-                source.add(header);
-                source.add(moduleSource);
-                source.add(footer);
-                const cachedSource = new CachedSource(source);
-                cacheEntry.full.set(moduleSource, cachedSource);
-                return cachedSource;
-            });
-        });
-    }
-}
-exports.WebpackModulePlaceholderPlugin = WebpackModulePlaceholderPlugin;

package/dist/processor/basic.d.ts

@@ -1,24 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompilerOptions } from "../type";
-export interface IBasicProcessorOptions<T extends ECompilerType> {
-    defaultOptions?: (context: ITestContext) => TCompilerOptions<T>;
-    configFiles?: string[];
-    overrideOptions?: (context: ITestContext, options: TCompilerOptions<T>) => void;
-    findBundle?: (context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void;
-    compilerType: T;
-    runable: boolean;
-    name: string;
-}
-export declare class BasicProcessor<T extends ECompilerType> implements ITestProcessor {
-    protected _options: IBasicProcessorOptions<T>;
-    constructor(_options: IBasicProcessorOptions<T>);
-    config(context: ITestContext): Promise<void>;
-    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>;
-}

package/dist/processor/basic.js

@@ -1,146 +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.BasicProcessor = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const helper_1 = require("../helper");
-const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-class BasicProcessor {
-    constructor(_options) {
-        this._options = _options;
-    }
-    async config(context) {
-        const compiler = this.getCompiler(context);
-        if (typeof this._options.defaultOptions === "function") {
-            compiler.setOptions(this._options.defaultOptions.apply(this, [context]));
-        }
-        if (Array.isArray(this._options.configFiles)) {
-            const fileOptions = (0, helper_1.readConfigFile)(this._options.configFiles.map(i => context.getSource(i)))[0];
-            compiler.mergeOptions(fileOptions);
-        }
-        if (typeof this._options.overrideOptions === "function") {
-            const compilerOptions = compiler.getOptions();
-            this._options.overrideOptions.apply(this, [context, compilerOptions]);
-        }
-    }
-    async compiler(context) {
-        const compiler = this.getCompiler(context);
-        compiler.createCompiler();
-    }
-    async build(context) {
-        const compiler = this.getCompiler(context);
-        await compiler.build();
-    }
-    async run(env, context) {
-        if (!this._options.runable)
-            return;
-        const testConfig = context.getTestConfig();
-        if (testConfig.noTest)
-            return;
-        if (testConfig.documentType) {
-            context.setValue(this._options.name, "documentType", testConfig.documentType);
-        }
-        if (typeof testConfig.beforeExecute === "function") {
-            testConfig.beforeExecute();
-        }
-        const compiler = this.getCompiler(context);
-        let bundles;
-        if (testConfig.bundlePath) {
-            bundles = testConfig.bundlePath;
-        }
-        else if (typeof this._options.findBundle === "function") {
-            bundles = this._options.findBundle.apply(this, [
-                context,
-                compiler.getOptions()
-            ]);
-        }
-        else {
-            bundles = [];
-        }
-        if (typeof bundles === "string") {
-            bundles = [bundles];
-        }
-        if (!bundles || !bundles.length) {
-            return;
-        }
-        for (const bundle of bundles) {
-            if (!bundle) {
-                continue;
-            }
-            const runnerFactory = context.getRunnerFactory(this._options.name);
-            if (!runnerFactory) {
-                throw new Error(`Test case ${this._options.name} is not runable`);
-            }
-            const runner = runnerFactory.create(bundle, compiler.getOptions(), env);
-            const mod = runner.run(bundle);
-            const result = context.getValue(this._options.name, "modules") || [];
-            result.push(mod);
-            context.setValue(this._options.name, "modules", result);
-        }
-        const results = context.getValue(this._options.name, "modules") || [];
-        await Promise.all(results);
-        if (typeof testConfig.afterExecute === "function") {
-            testConfig.afterExecute();
-        }
-    }
-    async check(env, context) {
-        const testConfig = context.getTestConfig();
-        if (testConfig.noTest)
-            return;
-        const errors = (context.getError(this._options.name) || []).map(e => ({
-            message: e.message,
-            stack: e.stack
-        }));
-        const warnings = [];
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        if (stats) {
-            if (testConfig.writeStatsOuptut) {
-                node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
-                    preset: "verbose",
-                    colors: false
-                }), "utf-8");
-            }
-            if (testConfig.writeStatsJson) {
-                const jsonStats = stats.toJson({
-                    errorDetails: true
-                });
-                node_fs_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(jsonStats, null, 2), "utf-8");
-            }
-            if (node_fs_1.default.existsSync(context.getSource("errors.js")) ||
-                node_fs_1.default.existsSync(context.getSource("warnings.js")) ||
-                stats.hasErrors() ||
-                stats.hasWarnings()) {
-                const statsJson = stats.toJson({
-                    errorDetails: true
-                });
-                if (statsJson.errors) {
-                    errors.push(...statsJson.errors);
-                }
-                if (statsJson.warnings) {
-                    warnings.push(...statsJson.warnings);
-                }
-            }
-        }
-        await (0, checkArrayExpectation_1.default)(context.getSource(), { errors }, "error", "errors", "Error");
-        await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, "warning", "warnings", "Warning");
-        // clear error if checked
-        if (node_fs_1.default.existsSync(context.getSource("errors.js"))) {
-            context.clearError(this._options.name);
-        }
-    }
-    async before(context) { }
-    async after(context) { }
-    async beforeAll(context) { }
-    async afterAll(context) {
-        const compiler = this.getCompiler(context);
-        await compiler.close();
-    }
-    getCompiler(context) {
-        return context.getCompiler(this._options.name, this._options.compilerType);
-    }
-}
-exports.BasicProcessor = BasicProcessor;

package/dist/processor/builtin.d.ts

@@ -1,9 +0,0 @@
-import { ECompilerType, type ITestContext, type TCompilerOptions } from "../type";
-import { type ISnapshotProcessorOptions, SnapshotProcessor } from "./snapshot";
-export interface IBuiltinProcessorOptions<T extends ECompilerType> extends Omit<ISnapshotProcessorOptions<T>, "runable"> {
-}
-export declare class BuiltinProcessor<T extends ECompilerType> extends SnapshotProcessor<T> {
-    protected _builtinOptions: IBuiltinProcessorOptions<T>;
-    constructor(_builtinOptions: IBuiltinProcessorOptions<T>);
-    static defaultOptions<T extends ECompilerType>(this: BuiltinProcessor<T>, context: ITestContext): TCompilerOptions<T>;
-}

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,128 +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 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 (file.name.endsWith(".js")) {
-                    files.push(file.name);
-                }
-                else {
-                    prefiles.push(file.name);
-                }
-            }
-        }
-        else {
-            const assets = info.entrypoints.main.assets.filter(s => s.name.endsWith(".js"));
-            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
-                    }
-                }
-            }
-        };
-        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;
-}