@rspack-canary/test-tools 1.5.6-canary-e598f284-20250921173624 → 1.5.7-canary-a3406c0a-20250922173625

package/dist/processor/basic.js

@@ -15,7 +15,7 @@ class BasicProcessor {
     async config(context) {
         const compiler = this.getCompiler(context);
         if (typeof this._options.defaultOptions === "function") {
-            compiler.setOptions(this._options.defaultOptions.apply(this, [context]));
+            compiler.setOptions(this._options.defaultOptions.call(this, context));
         }
         if (Array.isArray(this._options.configFiles)) {
             const fileOptions = (0, helper_1.readConfigFile)(this._options.configFiles.map(i => context.getSource(i)))[0];
@@ -23,16 +23,24 @@ class BasicProcessor {
         }
         if (typeof this._options.overrideOptions === "function") {
             const compilerOptions = compiler.getOptions();
-            this._options.overrideOptions.apply(this, [context, compilerOptions]);
+            this._options.overrideOptions.call(this, context, compilerOptions);
         }
     }
     async compiler(context) {
         const compiler = this.getCompiler(context);
         compiler.createCompiler();
+        if (typeof this._options.compiler === "function") {
+            await this._options.compiler.call(this, context, compiler.getCompiler());
+        }
     }
     async build(context) {
         const compiler = this.getCompiler(context);
-        await compiler.build();
+        if (typeof this._options.build === "function") {
+            await this._options.build.call(this, context, compiler.getCompiler());
+        }
+        else {
+            await compiler.build();
+        }
     }
     async run(env, context) {
         if (!this._options.runable)
@@ -45,17 +53,14 @@ class BasicProcessor {
         }
         const compiler = this.getCompiler(context);
         if (typeof testConfig.beforeExecute === "function") {
-            testConfig.beforeExecute(compiler.getOptions());
+            testConfig.beforeExecute.call(this, compiler.getOptions());
         }
         let bundles;
         if (testConfig.bundlePath) {
             bundles = testConfig.bundlePath;
         }
         else if (typeof this._options.findBundle === "function") {
-            bundles = this._options.findBundle.apply(this, [
-                context,
-                compiler.getOptions()
-            ]);
+            bundles = this._options.findBundle.call(this, context, compiler.getOptions());
         }
         else {
             bundles = [];
@@ -83,19 +88,24 @@ class BasicProcessor {
         const results = context.getValue(this._options.name, "modules") || [];
         await Promise.all(results);
         if (typeof testConfig.afterExecute === "function") {
-            testConfig.afterExecute(compiler.getOptions());
+            testConfig.afterExecute.call(this, compiler.getOptions());
         }
     }
     async check(env, context) {
         const testConfig = context.getTestConfig();
         if (testConfig.noTests)
             return;
+        const compiler = this.getCompiler(context);
+        if (typeof this._options.check === "function") {
+            const stats = compiler.getStats();
+            await this._options.check.call(this, env, context, compiler.getCompiler(), stats);
+            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();
         const options = compiler.getOptions();
         if (stats) {

package/dist/processor/index.d.ts

@@ -1,20 +1,6 @@
 export * from "./basic";
-export * from "./builtin";
-export * from "./cache";
-export * from "./config";
-export * from "./defaults";
-export * from "./diagnostic";
 export * from "./diff";
-export * from "./error";
-export * from "./hash";
-export * from "./hook";
-export * from "./hot";
-export * from "./hot-incremental";
-export * from "./hot-step";
 export * from "./multi";
-export * from "./normal";
 export * from "./simple";
 export * from "./snapshot";
-export * from "./stats";
-export * from "./stats-api";
 export * from "./watch";

package/dist/processor/index.js

@@ -15,22 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./basic"), exports);
-__exportStar(require("./builtin"), exports);
-__exportStar(require("./cache"), exports);
-__exportStar(require("./config"), exports);
-__exportStar(require("./defaults"), exports);
-__exportStar(require("./diagnostic"), exports);
 __exportStar(require("./diff"), exports);
-__exportStar(require("./error"), exports);
-__exportStar(require("./hash"), exports);
-__exportStar(require("./hook"), exports);
-__exportStar(require("./hot"), exports);
-__exportStar(require("./hot-incremental"), exports);
-__exportStar(require("./hot-step"), exports);
 __exportStar(require("./multi"), exports);
-__exportStar(require("./normal"), exports);
 __exportStar(require("./simple"), exports);
 __exportStar(require("./snapshot"), exports);
-__exportStar(require("./stats"), exports);
-__exportStar(require("./stats-api"), exports);
 __exportStar(require("./watch"), exports);

package/dist/processor/multi.d.ts

@@ -1,4 +1,4 @@
-import type { ECompilerType, ITestContext, ITestProcessor, TCompilerOptions } from "../type";
+import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompiler, TCompilerMultiStats, TCompilerOptions, TCompilerStats } from "../type";
 import { BasicProcessor } from "./basic";
 export interface IMultiTaskProcessorOptions<T extends ECompilerType> {
     defaultOptions?: (index: number, context: ITestContext) => TCompilerOptions<T>;
@@ -8,6 +8,8 @@ export interface IMultiTaskProcessorOptions<T extends ECompilerType> {
     name: string;
     configFiles?: string[];
     runable: boolean;
+    compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
+    check?: (env: ITestEnv, context: ITestContext, compiler: TCompiler<T>, stats: TCompilerStats<T> | TCompilerMultiStats<T> | null) => Promise<void>;
 }
 export declare class MultiTaskProcessor<T extends ECompilerType> extends BasicProcessor<T> implements ITestProcessor {
     protected _multiOptions: IMultiTaskProcessorOptions<T>;

package/dist/processor/multi.js

@@ -35,6 +35,8 @@ class MultiTaskProcessor extends basic_1.BasicProcessor {
                 context.setValue(_multiOptions.name, "multiFileIndexMap", multiFileIndexMap);
                 return result;
             },
+            check: _multiOptions.check,
+            compiler: _multiOptions.compiler,
             name: _multiOptions.name
         });
         this._multiOptions = _multiOptions;

package/dist/processor/simple.d.ts

@@ -6,7 +6,7 @@ export interface ISimpleProcessorOptions<T extends ECompilerType> {
     name: string;
     build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
     compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (context: ITestContext, compiler: TCompiler<T>, stats: TCompilerStats<T>) => Promise<void>;
+    check?: (env: ITestEnv, context: ITestContext, compiler: TCompiler<T>, stats: TCompilerStats<T>) => Promise<void>;
 }
 export declare class SimpleTaskProcessor<T extends ECompilerType> implements ITestProcessor {
     protected _options: ISimpleProcessorOptions<T>;

package/dist/processor/simple.js

@@ -8,7 +8,7 @@ class SimpleTaskProcessor {
     async config(context) {
         const compiler = this.getCompiler(context);
         if (typeof this._options.options === "function") {
-            compiler.setOptions(this._options.options(context));
+            compiler.setOptions(this._options.options.call(this, context));
         }
     }
     async compiler(context) {
@@ -17,13 +17,13 @@ class SimpleTaskProcessor {
             ? compiler.createCompilerWithCallback(this._options.compilerCallback)
             : compiler.createCompiler();
         if (typeof this._options.compiler === "function") {
-            await this._options.compiler(context, instance);
+            await this._options.compiler.call(this, context, instance);
         }
     }
     async build(context) {
         const compiler = this.getCompiler(context);
         if (typeof this._options.build === "function") {
-            await this._options.build(context, compiler.getCompiler());
+            await this._options.build.call(this, context, compiler.getCompiler());
         }
         else {
             await compiler.build();
@@ -34,7 +34,7 @@ class SimpleTaskProcessor {
         const compiler = this.getCompiler(context);
         const stats = compiler.getStats();
         if (typeof this._options.check === "function") {
-            await this._options.check(context, compiler.getCompiler(), stats);
+            await this._options.check.call(this, env, context, compiler.getCompiler(), stats);
         }
     }
     async before(context) { }

package/dist/processor/snapshot.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnapshotProcessor = void 0;
 const node_path_1 = __importDefault(require("node:path"));
+const placeholder_1 = require("../helper/expect/placeholder");
 const basic_1 = require("./basic");
 class SnapshotProcessor extends basic_1.BasicProcessor {
     constructor(_snapshotOptions) {
@@ -42,10 +43,10 @@ class SnapshotProcessor extends basic_1.BasicProcessor {
         const snapshotFileFilter = this._snapshotOptions.snapshotFileFilter ||
             ((file) => file.endsWith(".js") && !file.includes("runtime.js"));
         const fileContents = Object.entries(compilation.assets)
-            .filter(([file]) => snapshotFileFilter(file))
+            .filter(([file]) => snapshotFileFilter.call(this, file))
             .map(([file, source]) => {
             const tag = node_path_1.default.extname(file).slice(1) || "txt";
-            let content = this.serializeEachFile(source.source().toString());
+            let content = (0, placeholder_1.normalizePlaceholder)(source.source().toString());
             const testConfig = context.getTestConfig();
             if (testConfig.snapshotContent) {
                 content = testConfig.snapshotContent(content);
@@ -60,7 +61,7 @@ class SnapshotProcessor extends basic_1.BasicProcessor {
         env.expect(content).toMatchFileSnapshot(snapshotPath);
     }
     serializeEachFile(content) {
-        return content;
+        return (0, placeholder_1.normalizePlaceholder)(content);
     }
 }
 exports.SnapshotProcessor = SnapshotProcessor;

package/dist/type.d.ts

@@ -163,7 +163,7 @@ export type TCompilerFactory<T extends ECompilerType> = (options: TCompilerOptio
 export interface TRunnerFactory<T extends ECompilerType> {
     create(file: string, compilerOptions: TCompilerOptions<T>, env: ITestEnv): ITestRunner;
 }
-export type TUpdateOptions = {
+export type THotUpdateContext = {
     updateIndex: number;
     totalUpdates: number;
     changedFiles: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack-canary/test-tools",
-  "version": "1.5.6-canary-e598f284-20250921173624",
+  "version": "1.5.7-canary-a3406c0a-20250922173625",
   "license": "MIT",
   "description": "Test tools for rspack",
   "main": "dist/index.js",
@@ -100,10 +100,10 @@
     "wast-loader": "^1.14.1",
     "worker-rspack-loader": "^3.1.2",
     "exports-loader": "^5.0.0",
-    "@rspack/cli": "npm:@rspack-canary/cli@1.5.6-canary-e598f284-20250921173624",
-    "@rspack/core": "npm:@rspack-canary/core@1.5.6-canary-e598f284-20250921173624",
+    "@rspack/cli": "npm:@rspack-canary/cli@1.5.7-canary-a3406c0a-20250922173625",
+    "@rspack/core": "npm:@rspack-canary/core@1.5.7-canary-a3406c0a-20250922173625",
     "@rspack/binding-testing": "1.4.1",
-    "@rspack/test-tools": "npm:@rspack-canary/test-tools@1.5.6-canary-e598f284-20250921173624"
+    "@rspack/test-tools": "npm:@rspack-canary/test-tools@1.5.7-canary-a3406c0a-20250922173625"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"

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,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;
-}