@rspack/test-tools 1.7.0-beta.1 → 1.7.0

package/dist/case/stats-output.js

@@ -14,14 +14,14 @@ const common_1 = require("./common");
 const REG_ERROR_CASE = /error$/;
 function createStatsProcessor(name, defaultOptions, overrideOptions) {
     const writeStatsOuptut = false;
-    const snapshotName = "stats.txt";
+    const snapshotName = 'stats.txt';
     let stderr = null;
     return {
         before: async (context) => {
             stderr = (0, captureStdio_1.default)(process.stderr, true);
         },
         config: async (context) => {
-            (0, common_1.configMultiCompiler)(context, name, ["rspack.config.js", "webpack.config.js"], defaultOptions, overrideOptions);
+            (0, common_1.configMultiCompiler)(context, name, ['rspack.config.js', 'webpack.config.js'], defaultOptions, overrideOptions);
         },
         compiler: async (context) => {
             const c = await (0, common_1.compiler)(context, name);
@@ -38,53 +38,53 @@ function createStatsProcessor(name, defaultOptions, overrideOptions) {
         },
         after: async (context) => {
             stderr.restore();
-        }
+        },
     };
 }
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: false,
     steps: ({ name }) => [
-        createStatsProcessor(name, defaultOptions, overrideOptions)
+        createStatsProcessor(name, defaultOptions, overrideOptions),
     ],
-    description: () => "should print correct stats for"
+    description: () => 'should print correct stats for',
 });
 function createStatsOutputCase(name, src, dist) {
     creator.create(name, src, dist);
 }
 function defaultOptions(index, context) {
-    if (fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), "rspack.config.js")) ||
-        fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), "webpack.config.js"))) {
+    if (fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), 'rspack.config.js')) ||
+        fs_extra_1.default.existsSync(node_path_1.default.join(context.getSource(), 'webpack.config.js'))) {
         return {
             experiments: {
                 css: true,
                 rspackFuture: {
                     bundlerInfo: {
-                        force: false
-                    }
-                }
-            }
+                        force: false,
+                    },
+                },
+            },
         };
     }
     return {
         context: context.getSource(),
-        mode: "development",
-        entry: "./index.js",
+        mode: 'development',
+        entry: './index.js',
         output: {
-            filename: "bundle.js",
-            path: context.getDist()
+            filename: 'bundle.js',
+            path: context.getDist(),
         },
         optimization: {
-            minimize: false
+            minimize: false,
         },
         experiments: {
             css: true,
             rspackFuture: {
                 bundlerInfo: {
-                    force: false
-                }
-            }
-        }
+                    force: false,
+                },
+            },
+        },
     };
 }
 function overrideOptions(index, context, options) {
@@ -103,7 +103,7 @@ function overrideOptions(index, context, options) {
     }
     if (!global.printLogger) {
         options.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
 }
@@ -121,7 +121,7 @@ async function check(env, context, name, writeStatsOuptut, snapshot, stderr) {
     for (const compilation of []
         .concat(stats.stats || stats)
         .map((s) => s.compilation)) {
-        compilation.logging.delete("webpack.Compilation.ModuleProfile");
+        compilation.logging.delete('webpack.Compilation.ModuleProfile');
     }
     if (REG_ERROR_CASE.test(name)) {
         env.expect(stats.hasErrors()).toBe(true);
@@ -129,64 +129,64 @@ async function check(env, context, name, writeStatsOuptut, snapshot, stderr) {
     else if (stats.hasErrors()) {
         throw new Error(stats.toString({
             all: false,
-            errors: true
+            errors: true,
             // errorStack: true,
             // errorDetails: true
         }));
     }
     else if (writeStatsOuptut) {
-        fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
-            preset: "verbose",
+        fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), 'stats.txt'), stats.toString({
+            preset: 'verbose',
             // context: context.getSource(),
-            colors: false
-        }), "utf-8");
+            colors: false,
+        }), 'utf-8');
     }
     let toStringOptions = {
         context: context.getSource(),
-        colors: false
+        colors: false,
     };
     let hasColorSetting = false;
-    if (typeof options.stats !== "undefined") {
+    if (typeof options.stats !== 'undefined') {
         toStringOptions = options.stats;
-        if (toStringOptions === null || typeof toStringOptions !== "object")
+        if (toStringOptions === null || typeof toStringOptions !== 'object')
             toStringOptions = { preset: toStringOptions };
         if (!toStringOptions.context)
             toStringOptions.context = context.getSource();
-        hasColorSetting = typeof toStringOptions.colors !== "undefined";
+        hasColorSetting = typeof toStringOptions.colors !== 'undefined';
     }
     if (Array.isArray(options) && !toStringOptions.children) {
-        toStringOptions.children = options.map(o => o.stats);
+        toStringOptions.children = options.map((o) => o.stats);
     }
     // mock timestamps
     for (const { compilation: s } of [].concat(stats.stats || stats)) {
         env.expect(s.startTime).toBeGreaterThan(0);
         env.expect(s.endTime).toBeGreaterThan(0);
-        s.endTime = new Date("04/20/1970, 12:42:42 PM").getTime();
+        s.endTime = new Date('04/20/1970, 12:42:42 PM').getTime();
         s.startTime = s.endTime - 1234;
     }
     let actual = stats.toString(toStringOptions);
-    env.expect(typeof actual).toBe("string");
+    env.expect(typeof actual).toBe('string');
     actual = stderr.toString() + actual;
     if (!hasColorSetting) {
         actual = actual
-            .replace(/\u001b\[[0-9;]*m/g, "")
+            .replace(/\u001b\[[0-9;]*m/g, '')
             // CHANGE: The time unit display in Rspack is second
-            .replace(/[.0-9]+(\s?s)/g, "X$1")
+            .replace(/[.0-9]+(\s?s)/g, 'X$1')
             // CHANGE: Replace bundle size, since bundle sizes may differ between platforms
-            .replace(/[0-9]+(\.[0-9]+)? KiB/g, "xx KiB")
-            .replace(/[0-9]+(\.[0-9]+)? bytes/g, "xx bytes")
-            .replace(/[0-9]+(\.[0-9]+)? ms/g, "xx ms");
+            .replace(/[0-9]+(\.[0-9]+)? KiB/g, 'xx KiB')
+            .replace(/[0-9]+(\.[0-9]+)? bytes/g, 'xx bytes')
+            .replace(/[0-9]+(\.[0-9]+)? ms/g, 'xx ms');
     }
     actual = actual
-        .split("\n")
-        .filter(line => !line.includes("@rstest/core/dist"))
-        .join("\n");
+        .split('\n')
+        .filter((line) => !line.includes('@rstest/core/dist'))
+        .join('\n');
     const snapshotPath = node_path_1.default.isAbsolute(snapshot)
         ? snapshot
         : node_path_1.default.resolve(context.getSource(), `./__snapshots__/${snapshot}`);
     env.expect(new RspackStats(actual)).toMatchFileSnapshotSync(snapshotPath);
     const testConfig = context.getTestConfig();
-    if (typeof testConfig?.validate === "function") {
+    if (typeof testConfig?.validate === 'function') {
         testConfig.validate(stats, stderr.toString());
     }
 }
@@ -209,8 +209,8 @@ async function statsCompiler(context, compiler) {
                         return callback(err);
                     if (!/\.(js|json|txt)$/.test(args[0]))
                         return callback(null, result);
-                    callback(null, (0, placeholder_1.normalizePlaceholder)(result.toString("utf-8")));
-                }
+                    callback(null, (0, placeholder_1.normalizePlaceholder)(result.toString('utf-8')));
+                },
             ]));
         };
     }

package/dist/case/treeshaking.js

@@ -28,23 +28,23 @@ const creator = new creator_1.BasicCaseCreator({
                 // no need to run, just check snapshot
             },
             check: async (env, context) => {
-                await (0, common_1.checkSnapshot)(env, context, name, "treeshaking.snap.txt");
-            }
-        }
-    ]
+                await (0, common_1.checkSnapshot)(env, context, name, 'treeshaking.snap.txt');
+            },
+        },
+    ],
 });
 function createTreeShakingCase(name, src, dist) {
     creator.create(name, src, dist);
 }
 function overrideOptions(context, options) {
-    options.target = options.target || ["web", "es2022"];
+    options.target = options.target || ['web', 'es2022'];
     options.optimization ??= {};
     options.optimization.providedExports = true;
     options.optimization.innerGraph = true;
     options.optimization.usedExports = true;
     if (!global.printLogger) {
         options.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
 }

package/dist/case/watch.d.ts

@@ -1,4 +1,4 @@
-import type { ITestContext, ITestEnv, ITestRunner } from "../type";
+import type { ITestContext, ITestEnv, ITestRunner } from '../type';
 export declare function createWatchInitialProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher }?: {
     incremental?: boolean | undefined;
     nativeWatcher?: boolean | undefined;

package/dist/case/watch.js

@@ -25,20 +25,20 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
         step,
         tempDir,
         nativeWatcher,
-        watchState
+        watchState,
     };
     return {
         before: async (context) => {
-            context.setValue("watchContext", watchContext);
+            context.setValue('watchContext', watchContext);
         },
         config: async (context) => {
             const testConfig = context.getTestConfig();
             const multiCompilerOptions = [];
-            const caseOptions = (0, helper_1.readConfigFile)(["rspack.config.js", "webpack.config.js"].map(i => context.getSource(i)), context, {});
+            const caseOptions = (0, helper_1.readConfigFile)(['rspack.config.js', 'webpack.config.js'].map((i) => context.getSource(i)), context, {});
             for (const [index, options] of caseOptions.entries()) {
                 const compilerOptions = (0, webpack_merge_1.default)(defaultOptions({
                     incremental,
-                    ignoreNotFriendlyForIncrementalWarnings: testConfig.ignoreNotFriendlyForIncrementalWarnings
+                    ignoreNotFriendlyForIncrementalWarnings: testConfig.ignoreNotFriendlyForIncrementalWarnings,
                 }), options);
                 overrideOptions(index, context, compilerOptions, tempDir, nativeWatcher);
                 multiCompilerOptions.push(compilerOptions);
@@ -48,11 +48,11 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
                 : multiCompilerOptions;
             const compiler = context.getCompiler();
             compiler.setOptions(compilerOptions);
-            context.setValue("multiCompilerOptions", multiCompilerOptions);
+            context.setValue('multiCompilerOptions', multiCompilerOptions);
         },
         compiler: async (context) => {
             const c = await (0, common_1.compiler)(context, name);
-            c.hooks.invalid.tap("WatchTestCasesTest", (filename, mtime) => {
+            c.hooks.invalid.tap('WatchTestCasesTest', (filename, mtime) => {
                 watchContext.currentTriggerFilename = filename;
             });
         },
@@ -60,9 +60,9 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             const compiler = context.getCompiler();
             fs_extra_1.default.mkdirSync(watchContext.tempDir, { recursive: true });
             (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), watchContext.tempDir, true);
-            const pkgJsonFile = node_path_1.default.join(watchContext.tempDir, "package.json");
+            const pkgJsonFile = node_path_1.default.join(watchContext.tempDir, 'package.json');
             if (!fs_extra_1.default.existsSync(pkgJsonFile)) {
-                fs_extra_1.default.writeJsonSync(pkgJsonFile, { name, version: "0.0.1" });
+                fs_extra_1.default.writeJsonSync(pkgJsonFile, { name, version: '0.0.1' });
                 const longTimeAgo = Date.now() - 1000 * 60 * 60 * 24;
                 fs_extra_1.default.utimesSync(pkgJsonFile, Date.now() - longTimeAgo, Date.now() - longTimeAgo);
             }
@@ -83,9 +83,9 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             const testConfig = context.getTestConfig();
             if (testConfig.noTests)
                 return;
-            const errors = (context.getError() || []).map(e => ({
+            const errors = (context.getError() || []).map((e) => ({
                 message: e.message,
-                stack: e.stack
+                stack: e.stack,
             }));
             const warnings = [];
             const compiler = context.getCompiler();
@@ -94,17 +94,17 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             const checkStats = testConfig.checkStats || (() => true);
             if (stats) {
                 if (testConfig.writeStatsOuptut) {
-                    fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.txt"), stats.toString({
-                        preset: "verbose",
-                        colors: false
-                    }), "utf-8");
+                    fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), 'stats.txt'), stats.toString({
+                        preset: 'verbose',
+                        colors: false,
+                    }), 'utf-8');
                 }
                 const getJsonStats = (() => {
                     let cached = null;
                     return () => {
                         if (!cached) {
                             cached = stats.toJson({
-                                errorDetails: true
+                                errorDetails: true,
                             });
                         }
                         return cached;
@@ -115,7 +115,7 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
                     return () => {
                         if (!cached) {
                             cached = stats.toString({
-                                logging: "verbose"
+                                logging: 'verbose',
                             });
                         }
                         return cached;
@@ -123,24 +123,24 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
                 })();
                 if (checkStats.length > 1) {
                     if (!checkStats(watchContext.step, getJsonStats(), getStringStats())) {
-                        throw new Error("stats check failed");
+                        throw new Error('stats check failed');
                     }
                 }
                 else {
                     // @ts-expect-error only one param
                     if (!checkStats(watchContext.step)) {
-                        throw new Error("stats check failed");
+                        throw new Error('stats check failed');
                     }
                 }
                 if (testConfig.writeStatsJson) {
-                    fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), "stats.json"), JSON.stringify(getJsonStats(), null, 2), "utf-8");
+                    fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), 'stats.json'), JSON.stringify(getJsonStats(), null, 2), 'utf-8');
                 }
                 if (fs_extra_1.default.existsSync(context.getSource(`${watchContext.step}/errors.js`)) ||
                     fs_extra_1.default.existsSync(context.getSource(`${watchContext.step}/warnings.js`)) ||
                     stats.hasErrors() ||
                     stats.hasWarnings()) {
                     const statsJson = stats.toJson({
-                        errorDetails: true
+                        errorDetails: true,
                     });
                     if (statsJson.errors) {
                         errors.push(...statsJson.errors);
@@ -150,23 +150,23 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
                     }
                 }
             }
-            await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { errors }, "error", "errors", "Error", options);
-            await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { warnings }, "warning", "warnings", "Warning", options);
+            await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { errors }, 'error', 'errors', 'Error', options);
+            await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { warnings }, 'warning', 'warnings', 'Warning', options);
             // clear error if checked
-            if (fs_extra_1.default.existsSync(context.getSource("errors.js"))) {
+            if (fs_extra_1.default.existsSync(context.getSource('errors.js'))) {
                 context.clearError();
             }
             // check hash
             if (testConfig.writeStatsOuptut) {
-                fs_extra_1.default.renameSync(node_path_1.default.join(context.getDist(), "stats.txt"), node_path_1.default.join(context.getDist(), `stats.${watchContext.step}.txt`));
+                fs_extra_1.default.renameSync(node_path_1.default.join(context.getDist(), 'stats.txt'), node_path_1.default.join(context.getDist(), `stats.${watchContext.step}.txt`));
             }
             if (testConfig.writeStatsJson) {
-                fs_extra_1.default.renameSync(node_path_1.default.join(context.getDist(), "stats.json"), node_path_1.default.join(context.getDist(), `stats.${watchContext.step}.json`));
+                fs_extra_1.default.renameSync(node_path_1.default.join(context.getDist(), 'stats.json'), node_path_1.default.join(context.getDist(), `stats.${watchContext.step}.json`));
             }
         },
         after: async (context) => {
             await (0, common_1.afterExecute)(context, name);
-        }
+        },
     };
 }
 function createWatchStepProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false } = {}) {
@@ -191,8 +191,8 @@ function createWatchStepProcessor(name, tempDir, step, watchState, { incremental
         // which will cause the compiler not rebuild when the files change.
         // The timeout is set to 400ms for windows OS and 100ms for other OS.
         // TODO: This is a workaround, we can remove it when notify support windows better.
-        const timeout = nativeWatcher && process.platform === "win32" ? 400 : 100;
-        await new Promise(resolve => setTimeout(resolve, timeout));
+        const timeout = nativeWatcher && process.platform === 'win32' ? 400 : 100;
+        await new Promise((resolve) => setTimeout(resolve, timeout));
         (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), step), tempDir, false);
         await task;
     };
@@ -202,7 +202,7 @@ const creator = new creator_1.BasicCaseCreator({
     clean: true,
     runner: {
         key: getWatchRunnerKey,
-        runner: createWatchRunner
+        runner: createWatchRunner,
     },
     description: (name, index) => {
         return index === 0
@@ -215,38 +215,38 @@ const creator = new creator_1.BasicCaseCreator({
         const runs = fs_extra_1.default
             .readdirSync(src)
             .sort()
-            .filter(name => fs_extra_1.default.statSync(node_path_1.default.join(src, name)).isDirectory())
-            .map(name => ({ name }));
+            .filter((name) => fs_extra_1.default.statSync(node_path_1.default.join(src, name)).isDirectory())
+            .map((name) => ({ name }));
         return runs.map((run, index) => index === 0
             ? createWatchInitialProcessor(name, temp, run.name, watchState)
             : createWatchStepProcessor(name, temp, run.name, watchState));
     },
-    concurrent: true
+    concurrent: true,
 });
 function createWatchCase(name, src, dist, temp) {
     creator.create(name, src, dist, temp);
 }
 function overrideOptions(index, context, options, tempDir, nativeWatcher) {
     if (!options.mode)
-        options.mode = "development";
+        options.mode = 'development';
     if (!options.context)
         options.context = tempDir;
     if (!options.entry)
-        options.entry = "./index.js";
+        options.entry = './index.js';
     if (!options.target)
-        options.target = "async-node";
+        options.target = 'async-node';
     if (!options.devtool)
         options.devtool = false;
     if (!options.output)
         options.output = {};
     if (!options.output.path)
         options.output.path = context.getDist();
-    if (typeof options.output.pathinfo === "undefined")
+    if (typeof options.output.pathinfo === 'undefined')
         options.output.pathinfo = false;
     if (!options.output.filename)
-        options.output.filename = "bundle.js";
-    if (options.cache && options.cache.type === "filesystem") {
-        const cacheDirectory = node_path_1.default.join(tempDir, ".cache");
+        options.output.filename = 'bundle.js';
+    if (options.cache && options.cache.type === 'filesystem') {
+        const cacheDirectory = node_path_1.default.join(tempDir, '.cache');
         options.cache.cacheDirectory = cacheDirectory;
         options.cache.name = `config-${index}`;
     }
@@ -261,41 +261,41 @@ function overrideOptions(index, context, options, tempDir, nativeWatcher) {
     options.experiments.rspackFuture.bundlerInfo.force ??=
         false;
     // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
-    options.experiments.incremental ??= "safe";
+    options.experiments.incremental ??= 'safe';
     if (!global.printLogger) {
         options.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
 }
 function findBundle(index, context, options, stepName) {
     const testConfig = context.getTestConfig();
-    if (typeof testConfig.findBundle === "function") {
+    if (typeof testConfig.findBundle === 'function') {
         return testConfig.findBundle(index, options, stepName);
     }
-    return "./bundle.js";
+    return './bundle.js';
 }
-function defaultOptions({ incremental = false, ignoreNotFriendlyForIncrementalWarnings = false } = {}) {
+function defaultOptions({ incremental = false, ignoreNotFriendlyForIncrementalWarnings = false, } = {}) {
     if (incremental) {
         return {
             experiments: {
-                incremental: "advance"
+                incremental: 'advance',
             },
             ignoreWarnings: ignoreNotFriendlyForIncrementalWarnings
                 ? [/is not friendly for incremental/]
-                : undefined
+                : undefined,
         };
     }
     return {};
 }
 function getWatchRunnerKey(context, name, file) {
-    const watchContext = context.getValue("watchContext");
+    const watchContext = context.getValue('watchContext');
     const stepName = watchContext?.step;
     return `${name}-${stepName}`;
 }
 function cachedWatchStats(context, name) {
     const compiler = context.getCompiler();
-    const watchContext = context.getValue("watchContext");
+    const watchContext = context.getValue('watchContext');
     const stepName = watchContext?.step;
     const statsGetter = (() => {
         const cached = {};
@@ -304,7 +304,7 @@ function cachedWatchStats(context, name) {
                 return cached[stepName];
             }
             cached[stepName] = compiler.getStats().toJson({
-                errorDetails: true
+                errorDetails: true,
             });
             return cached[stepName];
         };
@@ -314,21 +314,21 @@ function cachedWatchStats(context, name) {
 function createWatchRunner(context, name, file, env) {
     const compiler = context.getCompiler();
     const compilerOptions = compiler.getOptions();
-    const watchContext = context.getValue("watchContext");
+    const watchContext = context.getValue('watchContext');
     const stepName = watchContext?.step;
     if (!stepName) {
-        throw new Error("Can not get watch step name from context");
+        throw new Error('Can not get watch step name from context');
     }
     const state = watchContext?.watchState;
     if (!state) {
-        throw new Error("Can not get watch state from context");
+        throw new Error('Can not get watch state from context');
     }
     const isWeb = Array.isArray(compilerOptions)
-        ? compilerOptions.some(option => {
-            return option.target === "web" || option.target === "webworker";
+        ? compilerOptions.some((option) => {
+            return option.target === 'web' || option.target === 'webworker';
         })
-        : compilerOptions.target === "web" ||
-            compilerOptions.target === "webworker";
+        : compilerOptions.target === 'web' ||
+            compilerOptions.target === 'webworker';
     const testConfig = context.getTestConfig();
     return new runner_1.WebRunner({
         env,
@@ -341,15 +341,15 @@ function createWatchRunner(context, name, file, env) {
             moduleScope: (ms, stats, options) => {
                 ms.STATE = state;
                 ms.WATCH_STEP = stepName;
-                if (typeof testConfig.moduleScope === "function") {
+                if (typeof testConfig.moduleScope === 'function') {
                     return testConfig.moduleScope(ms, stats, options);
                 }
                 return ms;
-            }
+            },
         },
         source: context.getSource(),
         dist: context.getDist(),
         compilerOptions,
-        location: testConfig.location || "https://test.cases/path/index.html"
+        location: testConfig.location || 'https://test.cases/path/index.html',
     });
 }

package/dist/compiler.d.ts

@@ -1,6 +1,6 @@
-import EventEmitter from "node:events";
-import { Compiler, type RspackOptions, type Stats } from "@rspack/core";
-import type { ITestCompilerManager, ITestContext } from "./type";
+import EventEmitter from 'node:events';
+import { Compiler, type RspackOptions, type Stats } from '@rspack/core';
+import type { ITestCompilerManager, ITestContext } from './type';
 export declare enum ECompilerEvent {
     Build = "build",
     Option = "option",