@rspack/test-tools 2.0.2 → 2.0.4

package/dist/case/watch.js

@@ -1,23 +1,57 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWatchInitialProcessor = createWatchInitialProcessor;
-exports.createWatchStepProcessor = createWatchStepProcessor;
-exports.createWatchCase = createWatchCase;
-exports.getWatchRunnerKey = getWatchRunnerKey;
-exports.createWatchRunner = createWatchRunner;
-const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const rspack_merge_1 = __importDefault(require("rspack-merge"));
-const compiler_1 = require("../compiler");
-const helper_1 = require("../helper");
-const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-const copyDiff_1 = __importDefault(require("../helper/legacy/copyDiff"));
-const runner_1 = require("../runner");
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createWatchCase: ()=>createWatchCase,
+    createWatchInitialProcessor: ()=>createWatchInitialProcessor,
+    createWatchRunner: ()=>createWatchRunner,
+    createWatchStepProcessor: ()=>createWatchStepProcessor,
+    getWatchRunnerKey: ()=>getWatchRunnerKey
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_fs_extra_namespaceObject = require("fs-extra");
+var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
+const external_rspack_merge_namespaceObject = require("rspack-merge");
+var external_rspack_merge_default = /*#__PURE__*/ __webpack_require__.n(external_rspack_merge_namespaceObject);
+const external_compiler_js_namespaceObject = require("../compiler.js");
+const index_js_namespaceObject = require("../helper/index.js");
+const checkArrayExpectation_js_namespaceObject = require("../helper/legacy/checkArrayExpectation.js");
+const copyDiff_js_namespaceObject = require("../helper/legacy/copyDiff.js");
+const external_runner_index_js_namespaceObject = require("../runner/index.js");
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_common_js_namespaceObject = require("./common.js");
 function createWatchInitialProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false } = {}) {
     const watchContext = {
         currentTriggerFilename: null,
@@ -25,126 +59,111 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
         step,
         tempDir,
         nativeWatcher,
-        watchState,
+        watchState
     };
     return {
-        before: async (context) => {
+        before: (context)=>{
             context.setValue('watchContext', watchContext);
         },
-        config: async (context) => {
+        config: (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, {});
-            for (const [index, options] of caseOptions.entries()) {
-                const compilerOptions = (0, rspack_merge_1.default)(defaultOptions({
+            const caseOptions = (0, index_js_namespaceObject.readConfigFile)([
+                'rspack.config.js',
+                'webpack.config.js'
+            ].map((i)=>context.getSource(i)), context, {});
+            for (const [index, options] of caseOptions.entries()){
+                const compilerOptions = external_rspack_merge_default()(defaultOptions({
                     incremental,
-                    ignoreNotFriendlyForIncrementalWarnings: testConfig.ignoreNotFriendlyForIncrementalWarnings,
+                    ignoreNotFriendlyForIncrementalWarnings: testConfig.ignoreNotFriendlyForIncrementalWarnings
                 }), options);
                 overrideOptions(index, context, compilerOptions, tempDir, nativeWatcher);
                 multiCompilerOptions.push(compilerOptions);
             }
-            const compilerOptions = multiCompilerOptions.length === 1
-                ? multiCompilerOptions[0]
-                : multiCompilerOptions;
+            const compilerOptions = 1 === multiCompilerOptions.length ? multiCompilerOptions[0] : multiCompilerOptions;
             const compiler = context.getCompiler();
             compiler.setOptions(compilerOptions);
             context.setValue('multiCompilerOptions', multiCompilerOptions);
         },
-        compiler: async (context) => {
-            const c = await (0, common_1.compiler)(context, name);
-            c.hooks.invalid.tap('WatchTestCasesTest', (filename, mtime) => {
+        compiler: async (context)=>{
+            const c = await (0, external_common_js_namespaceObject.compiler)(context, name);
+            c.hooks.invalid.tap('WatchTestCasesTest', (filename, mtime)=>{
                 watchContext.currentTriggerFilename = filename;
             });
         },
-        build: async (context) => {
+        build: async (context)=>{
             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');
-            if (!fs_extra_1.default.existsSync(pkgJsonFile)) {
-                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);
+            external_fs_extra_default().mkdirSync(watchContext.tempDir, {
+                recursive: true
+            });
+            (0, copyDiff_js_namespaceObject.copyDiff)(external_node_path_default().join(context.getSource(), watchContext.step), watchContext.tempDir, true);
+            const pkgJsonFile = external_node_path_default().join(watchContext.tempDir, 'package.json');
+            if (!external_fs_extra_default().existsSync(pkgJsonFile)) {
+                external_fs_extra_default().writeJsonSync(pkgJsonFile, {
+                    name,
+                    version: '0.0.1'
+                });
+                const longTimeAgo = Date.now() - 86400000;
+                external_fs_extra_default().utimesSync(pkgJsonFile, Date.now() - longTimeAgo, Date.now() - longTimeAgo);
             }
-            const task = new Promise((resolve, reject) => {
-                compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
-                    if (e)
-                        return reject(e);
+            const task = new Promise((resolve, reject)=>{
+                compiler.getEmitter().once(external_compiler_js_namespaceObject.ECompilerEvent.Build, (e, stats)=>{
+                    if (e) return reject(e);
                     resolve(stats);
                 });
             });
             compiler.watch();
             await task;
         },
-        run: async (env, context) => {
-            await (0, common_1.run)(env, context, name, (context) => (0, common_1.findMultiCompilerBundle)(context, name, (index, context, options) => findBundle(index, context, options, step)));
+        run: async (env, context)=>{
+            await (0, external_common_js_namespaceObject.run)(env, context, name, (context)=>(0, external_common_js_namespaceObject.findMultiCompilerBundle)(context, name, (index, context, options)=>findBundle(index, context, options, step)));
         },
-        check: async (env, context) => {
+        check: async (env, context)=>{
             const testConfig = context.getTestConfig();
-            if (testConfig.noTests)
-                return;
-            const errors = (context.getError() || []).map((e) => ({
-                message: e.message,
-                stack: e.stack,
-            }));
+            if (testConfig.noTests) return;
+            const errors = (context.getError() || []).map((e)=>({
+                    message: e.message,
+                    stack: e.stack
+                }));
             const warnings = [];
             const compiler = context.getCompiler();
             const stats = compiler.getStats();
             const options = compiler.getOptions();
-            const checkStats = testConfig.checkStats || (() => true);
+            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');
-                }
-                const getJsonStats = (() => {
+                if (testConfig.writeStatsOuptut) external_fs_extra_default().writeFileSync(external_node_path_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({
-                                assets: true,
-                                chunks: true,
-                                chunkModules: true,
-                                modules: true,
-                                entrypoints: true,
-                                chunkGroups: true,
-                                errorDetails: true,
-                            });
-                        }
+                    return ()=>{
+                        if (!cached) cached = stats.toJson({
+                            assets: true,
+                            chunks: true,
+                            chunkModules: true,
+                            modules: true,
+                            entrypoints: true,
+                            chunkGroups: true,
+                            errorDetails: true
+                        });
                         return cached;
                     };
                 })();
-                const getStringStats = (() => {
+                const getStringStats = (()=>{
                     let cached = null;
-                    return () => {
-                        if (!cached) {
-                            cached = stats.toString({
-                                logging: 'verbose',
-                            });
-                        }
+                    return ()=>{
+                        if (!cached) cached = stats.toString({
+                            logging: 'verbose'
+                        });
                         return cached;
                     };
                 })();
                 if (checkStats.length > 1) {
-                    if (!checkStats(watchContext.step, getJsonStats(), getStringStats())) {
-                        throw new Error('stats check failed');
-                    }
-                }
-                else {
-                    // @ts-expect-error only one param
-                    if (!checkStats(watchContext.step)) {
-                        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');
-                }
-                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()) {
+                    if (!checkStats(watchContext.step, getJsonStats(), getStringStats())) throw new Error('stats check failed');
+                } else if (!checkStats(watchContext.step)) throw new Error('stats check failed');
+                if (testConfig.writeStatsJson) external_fs_extra_default().writeFileSync(external_node_path_default().join(context.getDist(), 'stats.json'), JSON.stringify(getJsonStats(), null, 2), 'utf-8');
+                if (external_fs_extra_default().existsSync(context.getSource(`${watchContext.step}/errors.js`)) || external_fs_extra_default().existsSync(context.getSource(`${watchContext.step}/warnings.js`)) || stats.hasErrors() || stats.hasWarnings()) {
                     const statsJson = stats.toJson({
                         assets: true,
                         chunks: true,
@@ -152,149 +171,108 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
                         modules: true,
                         entrypoints: true,
                         chunkGroups: true,
-                        errorDetails: true,
+                        errorDetails: true
                     });
-                    if (statsJson.errors) {
-                        errors.push(...statsJson.errors);
-                    }
-                    if (statsJson.warnings) {
-                        warnings.push(...statsJson.warnings);
-                    }
+                    if (statsJson.errors) errors.push(...statsJson.errors);
+                    if (statsJson.warnings) warnings.push(...statsJson.warnings);
                 }
             }
-            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'))) {
-                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`));
-            }
-            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`));
-            }
-        },
-        after: async (context) => {
-            await (0, common_1.afterExecute)(context, name);
+            await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(external_node_path_default().join(context.getSource(), watchContext.step), {
+                errors
+            }, 'error', 'errors', 'Error', options);
+            await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(external_node_path_default().join(context.getSource(), watchContext.step), {
+                warnings
+            }, 'warning', 'warnings', 'Warning', options);
+            if (external_fs_extra_default().existsSync(context.getSource('errors.js'))) context.clearError();
+            if (testConfig.writeStatsOuptut) external_fs_extra_default().renameSync(external_node_path_default().join(context.getDist(), 'stats.txt'), external_node_path_default().join(context.getDist(), `stats.${watchContext.step}.txt`));
+            if (testConfig.writeStatsJson) external_fs_extra_default().renameSync(external_node_path_default().join(context.getDist(), 'stats.json'), external_node_path_default().join(context.getDist(), `stats.${watchContext.step}.json`));
         },
+        after: async (context)=>{
+            await (0, external_common_js_namespaceObject.afterExecute)(context, name);
+        }
     };
 }
 function createWatchStepProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false } = {}) {
-    const processor = createWatchInitialProcessor(name, tempDir, step, watchState, { incremental });
-    processor.compiler = async (context) => {
-        // do nothing
-    };
-    processor.build = async (context) => {
+    const processor = createWatchInitialProcessor(name, tempDir, step, watchState, {
+        incremental
+    });
+    processor.compiler = (context)=>{};
+    processor.build = async (context)=>{
         const compiler = context.getCompiler();
-        const task = new Promise((resolve, reject) => {
-            compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
-                if (e)
-                    return reject(e);
+        const task = new Promise((resolve, reject)=>{
+            compiler.getEmitter().once(external_compiler_js_namespaceObject.ECompilerEvent.Build, (e, stats)=>{
+                if (e) return reject(e);
                 resolve(stats);
             });
         });
-        // wait compiler to ready watch the files and diretories
-        // Native Watcher using [notify](https://github.com/notify-rs/notify) to watch files.
-        // After tests, notify will cost many milliseconds to watch in windows OS when jest run concurrently.
-        // So we need to wait a while to ensure the watcher is ready.
-        // If we don't wait, copyDiff will happen before the watcher is ready,
-        // 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));
-        (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), step), tempDir, false);
+        const timeout = nativeWatcher && 'win32' === process.platform ? 400 : 100;
+        await new Promise((resolve)=>setTimeout(resolve, timeout));
+        (0, copyDiff_js_namespaceObject.copyDiff)(external_node_path_default().join(context.getSource(), step), tempDir, false);
         await task;
     };
     return processor;
 }
-const creator = new creator_1.BasicCaseCreator({
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     runner: {
         key: getWatchRunnerKey,
-        runner: createWatchRunner,
-    },
-    description: (name, index) => {
-        return index === 0
-            ? `${name} should compile`
-            : `should compile step ${index}`;
+        runner: createWatchRunner
     },
+    description: (name, index)=>0 === index ? `${name} should compile` : `should compile step ${index}`,
     describe: false,
-    steps: ({ name, src, temp }) => {
+    steps: ({ name, src, temp })=>{
         const watchState = {};
-        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 }));
-        return runs.map((run, index) => index === 0
-            ? createWatchInitialProcessor(name, temp, run.name, watchState)
-            : createWatchStepProcessor(name, temp, run.name, watchState));
+        const runs = external_fs_extra_default().readdirSync(src).sort().filter((name)=>external_fs_extra_default().statSync(external_node_path_default().join(src, name)).isDirectory()).map((name)=>({
+                name
+            }));
+        return runs.map((run, index)=>0 === index ? 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';
-    if (!options.context)
-        options.context = tempDir;
-    if (!options.entry)
-        options.entry = './index.js';
-    if (!options.target)
-        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')
-        options.output.pathinfo = false;
-    if (!options.output.filename)
-        options.output.filename = 'bundle.js';
+    if (!options.mode) options.mode = 'development';
+    if (!options.context) options.context = tempDir;
+    if (!options.entry) options.entry = './index.js';
+    if (!options.target) 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 (void 0 === options.output.pathinfo) options.output.pathinfo = false;
+    if (!options.output.filename) options.output.filename = 'bundle.js';
     options.optimization ??= {};
     options.experiments ??= {};
     options.module ??= {};
-    options.module.defaultRules ??= ['...'];
+    options.module.defaultRules ??= [
+        '...'
+    ];
     options.module.defaultRules.push({
         test: /\.css$/,
-        type: 'css/auto',
+        type: 'css/auto'
     });
-    if (nativeWatcher) {
-        options.experiments.nativeWatcher ??= true;
-    }
+    if (nativeWatcher) options.experiments.nativeWatcher ??= true;
     options.output ??= {};
     options.output.bundlerInfo ??= {};
     options.output.bundlerInfo.force ??= false;
-    // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
     options.incremental ??= 'safe';
-    if (!global.printLogger) {
-        options.infrastructureLogging = {
-            level: 'error',
-        };
-    }
+    if (!global.printLogger) options.infrastructureLogging = {
+        level: 'error'
+    };
 }
 function findBundle(index, context, options, stepName) {
     const testConfig = context.getTestConfig();
-    if (typeof testConfig.findBundle === 'function') {
-        return testConfig.findBundle(index, options, stepName);
-    }
+    if ('function' == typeof testConfig.findBundle) return testConfig.findBundle(index, options, stepName);
     return './bundle.js';
 }
-function defaultOptions({ incremental = false, ignoreNotFriendlyForIncrementalWarnings = false, } = {}) {
-    if (incremental) {
-        return {
-            incremental: 'advance',
-            ignoreWarnings: ignoreNotFriendlyForIncrementalWarnings
-                ? [/is not friendly for incremental/]
-                : undefined,
-        };
-    }
+function defaultOptions({ incremental = false, ignoreNotFriendlyForIncrementalWarnings = false } = {}) {
+    if (incremental) return {
+        incremental: 'advance',
+        ignoreWarnings: ignoreNotFriendlyForIncrementalWarnings ? [
+            /is not friendly for incremental/
+        ] : void 0
+    };
     return {};
 }
 function getWatchRunnerKey(context, name, file) {
@@ -306,19 +284,17 @@ function cachedWatchStats(context, name) {
     const compiler = context.getCompiler();
     const watchContext = context.getValue('watchContext');
     const stepName = watchContext?.step;
-    const statsGetter = (() => {
+    const statsGetter = (()=>{
         const cached = {};
-        return () => {
-            if (cached[stepName]) {
-                return cached[stepName];
-            }
+        return ()=>{
+            if (cached[stepName]) return cached[stepName];
             cached[stepName] = compiler.getStats().toJson({
                 entrypoints: true,
                 assets: true,
                 chunks: true,
                 chunkModules: true,
                 modules: true,
-                errorDetails: true,
+                errorDetails: true
             });
             return cached[stepName];
         };
@@ -330,40 +306,44 @@ function createWatchRunner(context, name, file, env) {
     const compilerOptions = compiler.getOptions();
     const watchContext = context.getValue('watchContext');
     const stepName = watchContext?.step;
-    if (!stepName) {
-        throw new Error('Can not get watch step name from context');
-    }
+    if (!stepName) 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');
-    }
-    const isWeb = Array.isArray(compilerOptions)
-        ? compilerOptions.some((option) => {
-            return option.target === 'web' || option.target === 'webworker';
-        })
-        : compilerOptions.target === 'web' ||
-            compilerOptions.target === 'webworker';
+    if (!state) throw new Error('Can not get watch state from context');
+    const isWeb = Array.isArray(compilerOptions) ? compilerOptions.some((option)=>'web' === option.target || 'webworker' === option.target) : 'web' === compilerOptions.target || 'webworker' === compilerOptions.target;
     const testConfig = context.getTestConfig();
-    return new runner_1.WebRunner({
+    return new external_runner_index_js_namespaceObject.WebRunner({
         env,
         stats: cachedWatchStats(context, name),
         name: name,
         runInNewContext: isWeb,
         cachable: false,
         testConfig: {
-            ...(testConfig || {}),
-            moduleScope: (ms, stats, options) => {
+            ...testConfig || {},
+            moduleScope: (ms, stats, options)=>{
                 ms.STATE = state;
                 ms.WATCH_STEP = stepName;
-                if (typeof testConfig.moduleScope === 'function') {
-                    return testConfig.moduleScope(ms, stats, options);
-                }
+                if ('function' == typeof testConfig.moduleScope) 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'
     });
 }
+exports.createWatchCase = __webpack_exports__.createWatchCase;
+exports.createWatchInitialProcessor = __webpack_exports__.createWatchInitialProcessor;
+exports.createWatchRunner = __webpack_exports__.createWatchRunner;
+exports.createWatchStepProcessor = __webpack_exports__.createWatchStepProcessor;
+exports.getWatchRunnerKey = __webpack_exports__.getWatchRunnerKey;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createWatchCase",
+    "createWatchInitialProcessor",
+    "createWatchRunner",
+    "createWatchStepProcessor",
+    "getWatchRunnerKey"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});