@rspack-debug/test-tools 1.4.11 → 1.6.2

package/dist/processor/hot.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.HotProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const core_1 = require("@rspack/core");
-const plugins_1 = require("../helper/plugins");
-const plugin_1 = require("../plugin");
-const type_1 = require("../type");
-const basic_1 = require("./basic");
-class HotProcessor extends basic_1.BasicProcessor {
-    constructor(_hotOptions) {
-        const fakeUpdateLoaderOptions = {
-            updateIndex: 0,
-            totalUpdates: 1,
-            changedFiles: []
-        };
-        super({
-            defaultOptions: HotProcessor.defaultOptions,
-            overrideOptions: HotProcessor.overrideOptions,
-            findBundle: HotProcessor.findBundle,
-            runable: true,
-            ..._hotOptions
-        });
-        this._hotOptions = _hotOptions;
-        this.runner = null;
-        this.updateOptions = fakeUpdateLoaderOptions;
-    }
-    async run(env, context) {
-        context.setValue(this._options.name, "hotUpdateContext", this.updateOptions);
-        await super.run(env, context);
-    }
-    static findBundle(context) {
-        const files = [];
-        const prefiles = [];
-        const compiler = context.getCompiler(this._hotOptions.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._hotOptions.target === "web" ||
-            this._hotOptions.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);
-        if (context.getTestConfig().checkSteps === false) {
-            return;
-        }
-        if (this.updateOptions.updateIndex + 1 !==
-            this.updateOptions.totalUpdates) {
-            throw new Error(`Should run all hot steps (${this.updateOptions.updateIndex + 1} / ${this.updateOptions.totalUpdates}): ${this._options.name}`);
-        }
-    }
-    static defaultOptions(context) {
-        const options = {
-            context: context.getSource(),
-            mode: "development",
-            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"
-            },
-            target: this._hotOptions.target,
-            experiments: {
-                css: true,
-                // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
-                incremental: "safe",
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                }
-            }
-        };
-        if (this._hotOptions.compilerType === type_1.ECompilerType.Rspack) {
-            options.plugins ??= [];
-            options.plugins.push(new core_1.rspack.HotModuleReplacementPlugin(), new plugins_1.TestHotUpdatePlugin(this.updateOptions));
-        }
-        return options;
-    }
-    static overrideOptions(context, options) {
-        if (!options.entry) {
-            options.entry = "./index.js";
-        }
-        options.module ??= {};
-        for (const cssModuleType of ["css/auto", "css/module", "css"]) {
-            options.module.generator ??= {};
-            options.module.generator[cssModuleType] ??= {};
-            options.module.generator[cssModuleType].exportsOnly ??=
-                this._hotOptions.target === "async-node";
-        }
-        options.module.rules ??= [];
-        options.module.rules.push({
-            use: [
-                {
-                    loader: node_path_1.default.resolve(__dirname, "../helper/loaders/hot-update.js"),
-                    options: this.updateOptions
-                }
-            ],
-            enforce: "pre"
-        });
-        if (this._hotOptions.compilerType === type_1.ECompilerType.Rspack) {
-            options.plugins ??= [];
-            options.plugins.push(new core_1.rspack.LoaderOptionsPlugin(this.updateOptions));
-        }
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-        if (options.experiments?.lazyCompilation) {
-            options.plugins.push(new plugin_1.LazyCompilationTestPlugin());
-        }
-    }
-}
-exports.HotProcessor = HotProcessor;

package/dist/processor/index.d.ts

@@ -1,20 +0,0 @@
-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

@@ -1,36 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-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,17 +0,0 @@
-import type { ECompilerType, ITestContext, ITestProcessor, TCompilerOptions } from "../type";
-import { BasicProcessor } from "./basic";
-export interface IMultiTaskProcessorOptions<T extends ECompilerType> {
-    defaultOptions?: (index: number, context: ITestContext) => TCompilerOptions<T>;
-    overrideOptions?: (index: number, context: ITestContext, options: TCompilerOptions<T>) => void;
-    findBundle?: (index: number, context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void;
-    compilerType: T;
-    name: string;
-    configFiles?: string[];
-    runable: boolean;
-}
-export declare class MultiTaskProcessor<T extends ECompilerType> extends BasicProcessor<T> implements ITestProcessor {
-    protected _multiOptions: IMultiTaskProcessorOptions<T>;
-    protected multiCompilerOptions: TCompilerOptions<T>[];
-    constructor(_multiOptions: IMultiTaskProcessorOptions<T>);
-    config(context: ITestContext): Promise<void>;
-}

package/dist/processor/multi.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiTaskProcessor = void 0;
-const webpack_merge_1 = require("webpack-merge");
-const helper_1 = require("../helper");
-const basic_1 = require("./basic");
-class MultiTaskProcessor extends basic_1.BasicProcessor {
-    constructor(_multiOptions) {
-        super({
-            runable: _multiOptions.runable,
-            compilerType: _multiOptions.compilerType,
-            findBundle: (context, _) => {
-                if (typeof _multiOptions.findBundle !== "function") {
-                    return [];
-                }
-                const result = [];
-                const multiFileIndexMap = context.getValue(_multiOptions.name, "multiFileIndexMap") || {};
-                for (const [index, compilerOptions] of this.multiCompilerOptions.entries()) {
-                    const curBundles = _multiOptions.findBundle(index, context, compilerOptions);
-                    const bundles = Array.isArray(curBundles)
-                        ? curBundles
-                        : curBundles
-                            ? [curBundles]
-                            : [];
-                    for (const bundle of bundles) {
-                        if (multiFileIndexMap[bundle]) {
-                            multiFileIndexMap[bundle].push(index);
-                        }
-                        else {
-                            multiFileIndexMap[bundle] = [index];
-                        }
-                    }
-                    result.push(...bundles);
-                }
-                context.setValue(_multiOptions.name, "multiFileIndexMap", multiFileIndexMap);
-                return result;
-            },
-            name: _multiOptions.name
-        });
-        this._multiOptions = _multiOptions;
-        this.multiCompilerOptions = [];
-    }
-    async config(context) {
-        this.multiCompilerOptions = [];
-        const caseOptions = Array.isArray(this._multiOptions.configFiles)
-            ? (0, helper_1.readConfigFile)(this._multiOptions.configFiles.map(i => context.getSource(i)), configs => {
-                return configs.flatMap(c => {
-                    if (typeof c === "function") {
-                        const options = {
-                            testPath: context.getDist(),
-                            env: undefined
-                        };
-                        return c(options.env, options);
-                    }
-                    return c;
-                });
-            })
-            : [{}];
-        for (const [index, options] of caseOptions.entries()) {
-            const compilerOptions = (0, webpack_merge_1.merge)(typeof this._multiOptions.defaultOptions === "function"
-                ? this._multiOptions.defaultOptions(index, context)
-                : {}, options);
-            if (typeof this._multiOptions.overrideOptions === "function") {
-                this._multiOptions.overrideOptions(index, context, compilerOptions);
-            }
-            this.multiCompilerOptions.push(compilerOptions);
-        }
-        const compiler = this.getCompiler(context);
-        compiler.setOptions(this.multiCompilerOptions);
-        context.setValue(this._options.name, "multiCompilerOptions", this.multiCompilerOptions);
-    }
-}
-exports.MultiTaskProcessor = MultiTaskProcessor;

package/dist/processor/normal.d.ts

@@ -1,12 +0,0 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
-import { BasicProcessor, type IBasicProcessorOptions } from "./basic";
-export interface INormalProcessorOptions<T extends ECompilerType> extends IBasicProcessorOptions<T> {
-    compilerOptions?: TCompilerOptions<T>;
-    root: string;
-}
-export declare class NormalProcessor<T extends ECompilerType> extends BasicProcessor<T> {
-    protected _normalOptions: INormalProcessorOptions<T>;
-    constructor(_normalOptions: INormalProcessorOptions<T>);
-    static defaultOptions<T extends ECompilerType>(this: NormalProcessor<T>, context: ITestContext): TCompilerOptions<T>;
-    static overrideOptions<T extends ECompilerType>(options: TCompilerOptions<T>): void;
-}

package/dist/processor/normal.js

@@ -1,150 +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.NormalProcessor = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const basic_1 = require("./basic");
-class NormalProcessor extends basic_1.BasicProcessor {
-    constructor(_normalOptions) {
-        super({
-            findBundle: (context, options) => {
-                const filename = options.output?.filename;
-                return typeof filename === "string" ? filename : undefined;
-            },
-            defaultOptions: NormalProcessor.defaultOptions,
-            ..._normalOptions
-        });
-        this._normalOptions = _normalOptions;
-    }
-    static defaultOptions(context) {
-        let testConfig = {};
-        const testConfigPath = node_path_1.default.join(context.getSource(), "test.config.js");
-        if (node_fs_1.default.existsSync(testConfigPath)) {
-            testConfig = require(testConfigPath);
-        }
-        const TerserPlugin = require("terser-webpack-plugin");
-        const terserForTesting = new TerserPlugin({
-            parallel: false
-        });
-        const { root, compilerOptions } = this._normalOptions;
-        return {
-            context: root,
-            entry: `./${node_path_1.default.relative(root, context.getSource())}/`,
-            target: compilerOptions?.target || "async-node",
-            devtool: compilerOptions?.devtool,
-            mode: compilerOptions?.mode || "none",
-            optimization: compilerOptions?.mode
-                ? {
-                    // emitOnErrors: true,
-                    minimizer: [terserForTesting],
-                    ...testConfig.optimization
-                }
-                : {
-                    removeAvailableModules: true,
-                    removeEmptyChunks: true,
-                    mergeDuplicateChunks: true,
-                    // CHANGE: rspack does not support `flagIncludedChunks` yet.
-                    // flagIncludedChunks: true,
-                    sideEffects: true,
-                    providedExports: true,
-                    usedExports: true,
-                    mangleExports: true,
-                    // CHANGE: rspack does not support `emitOnErrors` yet.
-                    // emitOnErrors: true,
-                    concatenateModules: !!testConfig?.optimization?.concatenateModules,
-                    innerGraph: true,
-                    // CHANGE: size is not supported yet
-                    // moduleIds: "size",
-                    // chunkIds: "size",
-                    moduleIds: "named",
-                    chunkIds: "named",
-                    minimizer: [terserForTesting],
-                    ...compilerOptions?.optimization
-                },
-            // CHANGE: rspack does not support `performance` yet.
-            // performance: {
-            // 	hints: false
-            // },
-            node: {
-                __dirname: "mock",
-                __filename: "mock"
-            },
-            cache: compilerOptions?.cache && {
-                // cacheDirectory,
-                ...compilerOptions.cache
-            },
-            output: {
-                pathinfo: "verbose",
-                path: context.getDist(),
-                filename: compilerOptions?.module ? "bundle.mjs" : "bundle.js"
-            },
-            resolve: {
-                modules: ["web_modules", "node_modules"],
-                mainFields: ["webpack", "browser", "web", "browserify", "main"],
-                aliasFields: ["browser"],
-                extensions: [".webpack.js", ".web.js", ".js", ".json"]
-            },
-            resolveLoader: {
-                modules: ["web_loaders", "web_modules", "node_loaders", "node_modules"],
-                mainFields: ["webpackLoader", "webLoader", "loader", "main"],
-                extensions: [
-                    ".webpack-loader.js",
-                    ".web-loader.js",
-                    ".loader.js",
-                    ".js"
-                ]
-            },
-            module: {
-                rules: []
-            },
-            plugins: (compilerOptions?.plugins || [])
-                // @ts-ignore
-                .concat(testConfig.plugins || [])
-                .concat(function () {
-                this.hooks.compilation.tap("TestCasesTest", compilation => {
-                    const hooks = [
-                    // CHANGE: the following hooks are not supported yet, so comment it out
-                    // "optimize",
-                    // "optimizeModules",
-                    // "optimizeChunks",
-                    // "afterOptimizeTree",
-                    // "afterOptimizeAssets"
-                    ];
-                    for (const hook of hooks) {
-                        compilation.hooks[hook].tap("TestCasesTest", () => compilation.checkConstraints());
-                    }
-                });
-            }),
-            experiments: {
-                css: true,
-                rspackFuture: {
-                    bundlerInfo: {
-                        force: false
-                    }
-                },
-                asyncWebAssembly: true,
-                topLevelAwait: true,
-                // CHANGE: rspack does not support `backCompat` yet.
-                // backCompat: false,
-                // CHANGE: Rspack enables `css` by default.
-                // Turning off here to fallback to webpack's default css processing logic.
-                ...(compilerOptions?.module ? { outputModule: true } : {})
-            }
-            // infrastructureLogging: compilerOptions?.cache && {
-            //   debug: true,
-            //   console: createLogger(infraStructureLog)
-            // }
-        };
-    }
-    static overrideOptions(options) {
-        if (!global.printLogger) {
-            options.infrastructureLogging = {
-                level: "error"
-            };
-        }
-    }
-}
-exports.NormalProcessor = NormalProcessor;

package/dist/processor/simple.d.ts

@@ -1,23 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITestProcessor, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
-export interface ISimpleProcessorOptions<T extends ECompilerType> {
-    options?: (context: ITestContext) => TCompilerOptions<T>;
-    compilerType: T;
-    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>;
-}
-export declare class SimpleTaskProcessor<T extends ECompilerType> implements ITestProcessor {
-    protected _options: ISimpleProcessorOptions<T>;
-    constructor(_options: ISimpleProcessorOptions<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/simple.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleTaskProcessor = void 0;
-class SimpleTaskProcessor {
-    constructor(_options) {
-        this._options = _options;
-    }
-    async config(context) {
-        const compiler = this.getCompiler(context);
-        if (typeof this._options.options === "function") {
-            compiler.setOptions(this._options.options(context));
-        }
-    }
-    async compiler(context) {
-        const compiler = this.getCompiler(context);
-        const instance = compiler.createCompiler();
-        if (typeof this._options.compiler === "function") {
-            await this._options.compiler(context, instance);
-        }
-    }
-    async build(context) {
-        const compiler = this.getCompiler(context);
-        if (typeof this._options.build === "function") {
-            await this._options.build(context, compiler.getCompiler());
-        }
-        else {
-            await compiler.build();
-        }
-    }
-    async run(env, context) { }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        if (typeof this._options.check === "function") {
-            await this._options.check(context, compiler.getCompiler(), stats);
-        }
-    }
-    async before(context) { }
-    async after(context) {
-        const compiler = this.getCompiler(context);
-        await compiler.close();
-    }
-    async beforeAll(context) { }
-    async afterAll(context) { }
-    getCompiler(context) {
-        return context.getCompiler(this._options.name, this._options.compilerType);
-    }
-}
-exports.SimpleTaskProcessor = SimpleTaskProcessor;

package/dist/processor/snapshot.d.ts

@@ -1,12 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv } from "../type";
-import { BasicProcessor, type IBasicProcessorOptions } from "./basic";
-export interface ISnapshotProcessorOptions<T extends ECompilerType> extends IBasicProcessorOptions<T> {
-    snapshot: string;
-    snapshotFileFilter?: (file: string) => boolean;
-}
-export declare class SnapshotProcessor<T extends ECompilerType> extends BasicProcessor<T> {
-    protected _snapshotOptions: ISnapshotProcessorOptions<T>;
-    constructor(_snapshotOptions: ISnapshotProcessorOptions<T>);
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-    serializeEachFile(content: string): string;
-}

package/dist/processor/snapshot.js

@@ -1,66 +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.SnapshotProcessor = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const basic_1 = require("./basic");
-class SnapshotProcessor extends basic_1.BasicProcessor {
-    constructor(_snapshotOptions) {
-        super(_snapshotOptions);
-        this._snapshotOptions = _snapshotOptions;
-        if (node_path_1.default.extname(_snapshotOptions.snapshot) === ".snap") {
-            throw new Error("Snapshot with `.snap` will be managed by jest, please use `.snap.txt` instead in SnapshotProcessor");
-        }
-    }
-    async check(env, context) {
-        const compiler = this.getCompiler(context);
-        const stats = compiler.getStats();
-        const c = compiler.getCompiler();
-        if (!stats || !c)
-            return;
-        if (stats.hasErrors()) {
-            const errors = [];
-            if (stats.stats) {
-                for (const s of stats.stats) {
-                    if (s.hasErrors()) {
-                        errors.push(...s.compilation.errors);
-                    }
-                }
-            }
-            else {
-                const s = stats;
-                errors.push(...s.compilation.errors);
-            }
-            throw new Error(`Failed to compile in fixture ${this._options.name}, Errors: ${errors
-                ?.map(i => `${i.message}\n${i.stack}`)
-                .join("\n\n")}`);
-        }
-        const compilation = c._lastCompilation ||
-            c._lastCompilation;
-        const snapshotFileFilter = this._snapshotOptions.snapshotFileFilter ||
-            ((file) => file.endsWith(".js") && !file.includes("runtime.js"));
-        const fileContents = Object.entries(compilation.assets)
-            .filter(([file]) => snapshotFileFilter(file))
-            .map(([file, source]) => {
-            const tag = node_path_1.default.extname(file).slice(1) || "txt";
-            let content = this.serializeEachFile(source.source().toString());
-            const testConfig = context.getTestConfig();
-            if (testConfig.snapshotContent) {
-                content = testConfig.snapshotContent(content);
-            }
-            return `\`\`\`${tag} title=${file}\n${content}\n\`\`\``;
-        });
-        fileContents.sort();
-        const content = fileContents.join("\n\n");
-        const snapshotPath = node_path_1.default.isAbsolute(this._snapshotOptions.snapshot)
-            ? this._snapshotOptions.snapshot
-            : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${this._snapshotOptions.snapshot}`);
-        env.expect(content).toMatchFileSnapshot(snapshotPath);
-    }
-    serializeEachFile(content) {
-        return content;
-    }
-}
-exports.SnapshotProcessor = SnapshotProcessor;

package/dist/processor/stats-api.d.ts

@@ -1,18 +0,0 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
-import { SimpleTaskProcessor } from "./simple";
-export interface IStatsAPIProcessorOptions<T extends ECompilerType> {
-    options?: (context: ITestContext) => TCompilerOptions<T>;
-    name: string;
-    compilerType: T;
-    snapshotName?: string;
-    compiler?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (stats: TCompilerStats<T>, compiler: TCompiler<T>) => Promise<void>;
-}
-export declare class StatsAPIProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
-    protected _statsAPIOptions: IStatsAPIProcessorOptions<T>;
-    constructor(_statsAPIOptions: IStatsAPIProcessorOptions<T>);
-    compiler(context: ITestContext): Promise<void>;
-    run(env: ITestEnv, context: ITestContext): Promise<void>;
-    check(env: ITestEnv, context: ITestContext): Promise<void>;
-}