@rspack/test-tools 2.0.2 → 2.0.3

package/dist/case/index.js

@@ -1,52 +1,135 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createProdNormalCase = exports.createNormalCase = exports.createHotNormalCase = exports.createDevNormalCase = exports.createNativeWatcher = exports.createMultiCompilerCase = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createExampleCase = exports.createEsmOutputCase = exports.createErrorCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
-var builtin_1 = require("./builtin");
-Object.defineProperty(exports, "createBuiltinCase", { enumerable: true, get: function () { return builtin_1.createBuiltinCase; } });
-var cache_1 = require("./cache");
-Object.defineProperty(exports, "createCacheCase", { enumerable: true, get: function () { return cache_1.createCacheCase; } });
-var compiler_1 = require("./compiler");
-Object.defineProperty(exports, "createCompilerCase", { enumerable: true, get: function () { return compiler_1.createCompilerCase; } });
-var config_1 = require("./config");
-Object.defineProperty(exports, "createConfigCase", { enumerable: true, get: function () { return config_1.createConfigCase; } });
-var defaults_1 = require("./defaults");
-Object.defineProperty(exports, "createDefaultsCase", { enumerable: true, get: function () { return defaults_1.createDefaultsCase; } });
-Object.defineProperty(exports, "getRspackDefaultConfig", { enumerable: true, get: function () { return defaults_1.getRspackDefaultConfig; } });
-var diagnostic_1 = require("./diagnostic");
-Object.defineProperty(exports, "createDiagnosticCase", { enumerable: true, get: function () { return diagnostic_1.createDiagnosticCase; } });
-var error_1 = require("./error");
-Object.defineProperty(exports, "createErrorCase", { enumerable: true, get: function () { return error_1.createErrorCase; } });
-var esm_output_1 = require("./esm-output");
-Object.defineProperty(exports, "createEsmOutputCase", { enumerable: true, get: function () { return esm_output_1.createEsmOutputCase; } });
-var example_1 = require("./example");
-Object.defineProperty(exports, "createExampleCase", { enumerable: true, get: function () { return example_1.createExampleCase; } });
-var hash_1 = require("./hash");
-Object.defineProperty(exports, "createHashCase", { enumerable: true, get: function () { return hash_1.createHashCase; } });
-var hook_1 = require("./hook");
-Object.defineProperty(exports, "createHookCase", { enumerable: true, get: function () { return hook_1.createHookCase; } });
-var hot_1 = require("./hot");
-Object.defineProperty(exports, "createHotCase", { enumerable: true, get: function () { return hot_1.createHotCase; } });
-var hot_step_1 = require("./hot-step");
-Object.defineProperty(exports, "createHotStepCase", { enumerable: true, get: function () { return hot_step_1.createHotStepCase; } });
-var incremental_1 = require("./incremental");
-Object.defineProperty(exports, "createHotIncrementalCase", { enumerable: true, get: function () { return incremental_1.createHotIncrementalCase; } });
-Object.defineProperty(exports, "createWatchIncrementalCase", { enumerable: true, get: function () { return incremental_1.createWatchIncrementalCase; } });
-var multi_compiler_1 = require("./multi-compiler");
-Object.defineProperty(exports, "createMultiCompilerCase", { enumerable: true, get: function () { return multi_compiler_1.createMultiCompilerCase; } });
-var native_watcher_1 = require("./native-watcher");
-Object.defineProperty(exports, "createNativeWatcher", { enumerable: true, get: function () { return native_watcher_1.createNativeWatcher; } });
-var normal_1 = require("./normal");
-Object.defineProperty(exports, "createDevNormalCase", { enumerable: true, get: function () { return normal_1.createDevNormalCase; } });
-Object.defineProperty(exports, "createHotNormalCase", { enumerable: true, get: function () { return normal_1.createHotNormalCase; } });
-Object.defineProperty(exports, "createNormalCase", { enumerable: true, get: function () { return normal_1.createNormalCase; } });
-Object.defineProperty(exports, "createProdNormalCase", { enumerable: true, get: function () { return normal_1.createProdNormalCase; } });
-var serial_1 = require("./serial");
-Object.defineProperty(exports, "createSerialCase", { enumerable: true, get: function () { return serial_1.createSerialCase; } });
-var stats_api_1 = require("./stats-api");
-Object.defineProperty(exports, "createStatsAPICase", { enumerable: true, get: function () { return stats_api_1.createStatsAPICase; } });
-var stats_output_1 = require("./stats-output");
-Object.defineProperty(exports, "createStatsOutputCase", { enumerable: true, get: function () { return stats_output_1.createStatsOutputCase; } });
-var treeshaking_1 = require("./treeshaking");
-Object.defineProperty(exports, "createTreeShakingCase", { enumerable: true, get: function () { return treeshaking_1.createTreeShakingCase; } });
-var watch_1 = require("./watch");
-Object.defineProperty(exports, "createWatchCase", { enumerable: true, get: function () { return watch_1.createWatchCase; } });
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    createBuiltinCase: ()=>external_builtin_js_namespaceObject.createBuiltinCase,
+    createCacheCase: ()=>external_cache_js_namespaceObject.createCacheCase,
+    createCompilerCase: ()=>external_compiler_js_namespaceObject.createCompilerCase,
+    createConfigCase: ()=>external_config_js_namespaceObject.createConfigCase,
+    createDefaultsCase: ()=>external_defaults_js_namespaceObject.createDefaultsCase,
+    createDevNormalCase: ()=>external_normal_js_namespaceObject.createDevNormalCase,
+    createDiagnosticCase: ()=>external_diagnostic_js_namespaceObject.createDiagnosticCase,
+    createErrorCase: ()=>external_error_js_namespaceObject.createErrorCase,
+    createEsmOutputCase: ()=>external_esm_output_js_namespaceObject.createEsmOutputCase,
+    createExampleCase: ()=>external_example_js_namespaceObject.createExampleCase,
+    createHashCase: ()=>external_hash_js_namespaceObject.createHashCase,
+    createHookCase: ()=>external_hook_js_namespaceObject.createHookCase,
+    createHotCase: ()=>external_hot_js_namespaceObject.createHotCase,
+    createHotIncrementalCase: ()=>external_incremental_js_namespaceObject.createHotIncrementalCase,
+    createHotNormalCase: ()=>external_normal_js_namespaceObject.createHotNormalCase,
+    createHotStepCase: ()=>external_hot_step_js_namespaceObject.createHotStepCase,
+    createMultiCompilerCase: ()=>external_multi_compiler_js_namespaceObject.createMultiCompilerCase,
+    createNativeWatcher: ()=>external_native_watcher_js_namespaceObject.createNativeWatcher,
+    createNormalCase: ()=>external_normal_js_namespaceObject.createNormalCase,
+    createProdNormalCase: ()=>external_normal_js_namespaceObject.createProdNormalCase,
+    createSerialCase: ()=>external_serial_js_namespaceObject.createSerialCase,
+    createStatsAPICase: ()=>external_stats_api_js_namespaceObject.createStatsAPICase,
+    createStatsOutputCase: ()=>external_stats_output_js_namespaceObject.createStatsOutputCase,
+    createTreeShakingCase: ()=>external_treeshaking_js_namespaceObject.createTreeShakingCase,
+    createWatchCase: ()=>external_watch_js_namespaceObject.createWatchCase,
+    createWatchIncrementalCase: ()=>external_incremental_js_namespaceObject.createWatchIncrementalCase,
+    getRspackDefaultConfig: ()=>external_defaults_js_namespaceObject.getRspackDefaultConfig
+});
+const external_builtin_js_namespaceObject = require("./builtin.js");
+const external_cache_js_namespaceObject = require("./cache.js");
+const external_compiler_js_namespaceObject = require("./compiler.js");
+const external_config_js_namespaceObject = require("./config.js");
+const external_defaults_js_namespaceObject = require("./defaults.js");
+const external_diagnostic_js_namespaceObject = require("./diagnostic.js");
+const external_error_js_namespaceObject = require("./error.js");
+const external_esm_output_js_namespaceObject = require("./esm-output.js");
+const external_example_js_namespaceObject = require("./example.js");
+const external_hash_js_namespaceObject = require("./hash.js");
+const external_hook_js_namespaceObject = require("./hook.js");
+const external_hot_js_namespaceObject = require("./hot.js");
+const external_hot_step_js_namespaceObject = require("./hot-step.js");
+const external_incremental_js_namespaceObject = require("./incremental.js");
+const external_multi_compiler_js_namespaceObject = require("./multi-compiler.js");
+const external_native_watcher_js_namespaceObject = require("./native-watcher.js");
+const external_normal_js_namespaceObject = require("./normal.js");
+const external_serial_js_namespaceObject = require("./serial.js");
+const external_stats_api_js_namespaceObject = require("./stats-api.js");
+const external_stats_output_js_namespaceObject = require("./stats-output.js");
+const external_treeshaking_js_namespaceObject = require("./treeshaking.js");
+const external_watch_js_namespaceObject = require("./watch.js");
+exports.createBuiltinCase = __webpack_exports__.createBuiltinCase;
+exports.createCacheCase = __webpack_exports__.createCacheCase;
+exports.createCompilerCase = __webpack_exports__.createCompilerCase;
+exports.createConfigCase = __webpack_exports__.createConfigCase;
+exports.createDefaultsCase = __webpack_exports__.createDefaultsCase;
+exports.createDevNormalCase = __webpack_exports__.createDevNormalCase;
+exports.createDiagnosticCase = __webpack_exports__.createDiagnosticCase;
+exports.createErrorCase = __webpack_exports__.createErrorCase;
+exports.createEsmOutputCase = __webpack_exports__.createEsmOutputCase;
+exports.createExampleCase = __webpack_exports__.createExampleCase;
+exports.createHashCase = __webpack_exports__.createHashCase;
+exports.createHookCase = __webpack_exports__.createHookCase;
+exports.createHotCase = __webpack_exports__.createHotCase;
+exports.createHotIncrementalCase = __webpack_exports__.createHotIncrementalCase;
+exports.createHotNormalCase = __webpack_exports__.createHotNormalCase;
+exports.createHotStepCase = __webpack_exports__.createHotStepCase;
+exports.createMultiCompilerCase = __webpack_exports__.createMultiCompilerCase;
+exports.createNativeWatcher = __webpack_exports__.createNativeWatcher;
+exports.createNormalCase = __webpack_exports__.createNormalCase;
+exports.createProdNormalCase = __webpack_exports__.createProdNormalCase;
+exports.createSerialCase = __webpack_exports__.createSerialCase;
+exports.createStatsAPICase = __webpack_exports__.createStatsAPICase;
+exports.createStatsOutputCase = __webpack_exports__.createStatsOutputCase;
+exports.createTreeShakingCase = __webpack_exports__.createTreeShakingCase;
+exports.createWatchCase = __webpack_exports__.createWatchCase;
+exports.createWatchIncrementalCase = __webpack_exports__.createWatchIncrementalCase;
+exports.getRspackDefaultConfig = __webpack_exports__.getRspackDefaultConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBuiltinCase",
+    "createCacheCase",
+    "createCompilerCase",
+    "createConfigCase",
+    "createDefaultsCase",
+    "createDevNormalCase",
+    "createDiagnosticCase",
+    "createErrorCase",
+    "createEsmOutputCase",
+    "createExampleCase",
+    "createHashCase",
+    "createHookCase",
+    "createHotCase",
+    "createHotIncrementalCase",
+    "createHotNormalCase",
+    "createHotStepCase",
+    "createMultiCompilerCase",
+    "createNativeWatcher",
+    "createNormalCase",
+    "createProdNormalCase",
+    "createSerialCase",
+    "createStatsAPICase",
+    "createStatsOutputCase",
+    "createTreeShakingCase",
+    "createWatchCase",
+    "createWatchIncrementalCase",
+    "getRspackDefaultConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/multi-compiler.d.ts

@@ -1,19 +1,19 @@
 import type { Compilation, Compiler, RspackOptions, Stats, StatsCompilation } from '@rspack/core';
-import type { ITestContext } from '../type';
+import type { ITestContext, MaybePromise } from '../type';
 export declare function createMultiCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
 export type TMultiCompilerCaseConfig = {
     description: string;
     error?: boolean;
     skip?: boolean;
     options?: (context: ITestContext) => RspackOptions;
-    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
-    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    compiler?: (context: ITestContext, compiler: Compiler) => MaybePromise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => MaybePromise<void>;
     check?: ({ context, stats, files, compiler, compilation, }: {
         context: ITestContext;
         stats?: StatsCompilation;
         files?: Record<string, string>;
         compiler: Compiler;
         compilation?: Compilation;
-    }) => Promise<void>;
+    }) => MaybePromise<void>;
     compilerCallback?: (error: Error | null, stats: Stats | null) => void;
 };

package/dist/case/multi-compiler.js

@@ -1,97 +1,122 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMultiCompilerCase = createMultiCompilerCase;
-const node_path_1 = __importDefault(require("node:path"));
-const memfs_1 = require("memfs");
-const creator_1 = require("../test/creator");
+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__, {
+    createMultiCompilerCase: ()=>createMultiCompilerCase
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_memfs_namespaceObject = require("memfs");
+const creator_js_namespaceObject = require("../test/creator.js");
 function createMultiCompilerProcessor(name, caseConfig) {
     return {
-        config: async (context) => {
+        config: (context)=>{
             const compiler = context.getCompiler();
             const options = Object.assign([
                 {
                     name: 'a',
-                    context: node_path_1.default.join(__dirname, 'fixtures'),
-                    entry: './a.js',
+                    context: external_node_path_default().join(__dirname, 'fixtures'),
+                    entry: './a.js'
                 },
                 {
                     name: 'b',
-                    context: node_path_1.default.join(__dirname, 'fixtures'),
-                    entry: './b.js',
-                },
+                    context: external_node_path_default().join(__dirname, 'fixtures'),
+                    entry: './b.js'
+                }
             ], caseConfig.options?.(context) || {});
             compiler.setOptions(options);
         },
-        compiler: async (context) => {
+        compiler: async (context)=>{
             const compiler = context.getCompiler();
-            if (caseConfig.compilerCallback) {
-                compiler.createCompilerWithCallback(caseConfig.compilerCallback);
-            }
-            else {
-                compiler.createCompiler();
-            }
+            if (caseConfig.compilerCallback) compiler.createCompilerWithCallback(caseConfig.compilerCallback);
+            else compiler.createCompiler();
             const c = compiler.getCompiler();
-            c.outputFileSystem = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
+            c.outputFileSystem = (0, external_memfs_namespaceObject.createFsFromVolume)(new external_memfs_namespaceObject.Volume());
             c.watchFileSystem = {
-                watch() {
-                    // watch should return a watcher instance
-                    // watcher instance should have close, pause and getInfo methods
+                watch () {
                     return {
-                        close: () => { },
-                        pause: () => { },
-                        getInfo: () => {
-                            return {
+                        close: ()=>{},
+                        pause: ()=>{},
+                        getInfo: ()=>({
                                 changes: new Set(),
                                 removals: new Set(),
                                 fileTimeInfoEntries: new Map(),
-                                directoryTimeInfoEntries: new Map(),
-                            };
-                        },
+                                directoryTimeInfoEntries: new Map()
+                            })
                     };
-                },
+                }
             };
             await caseConfig.compiler?.(context, c);
         },
-        build: async (context) => {
+        build: async (context)=>{
             const compiler = context.getCompiler();
-            if (typeof caseConfig.build === 'function') {
-                await caseConfig.build?.(context, compiler.getCompiler());
-            }
-            else {
-                await compiler.build();
-            }
+            if ('function' == typeof caseConfig.build) await caseConfig.build?.(context, compiler.getCompiler());
+            else await compiler.build();
         },
-        run: async (env, context) => { },
-        check: async (env, context) => { },
+        run: async (env, context)=>{},
+        check: async (env, context)=>{}
     };
 }
-const creator = new creator_1.BasicCaseCreator({
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: false,
-    steps: ({ name, caseConfig }) => {
-        return [
-            createMultiCompilerProcessor(name, caseConfig),
-        ];
-    },
-    concurrent: false,
+    steps: ({ name, caseConfig })=>[
+            createMultiCompilerProcessor(name, caseConfig)
+        ],
+    concurrent: false
 });
 function createMultiCompilerCase(name, src, dist, testConfig) {
     let caseConfigList = require(testConfig);
-    if (!Array.isArray(caseConfigList)) {
-        caseConfigList = [caseConfigList];
-    }
-    for (let i = 0; i < caseConfigList.length; i++) {
+    if (!Array.isArray(caseConfigList)) caseConfigList = [
+        caseConfigList
+    ];
+    for(let i = 0; i < caseConfigList.length; i++){
         const caseConfig = caseConfigList[i];
         if (caseConfig.skip) {
-            it.skip(`${name}[${i}]`, () => { });
+            it.skip(`${name}[${i}]`, ()=>{});
             continue;
         }
-        creator.create(`${name}[${i}]`, src, dist, undefined, {
+        creator.create(`${name}[${i}]`, src, dist, void 0, {
             caseConfig,
-            description: () => caseConfig.description,
+            description: ()=>caseConfig.description
         });
     }
 }
+exports.createMultiCompilerCase = __webpack_exports__.createMultiCompilerCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createMultiCompilerCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/native-watcher.js

@@ -1,42 +1,74 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNativeWatcher = createNativeWatcher;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const creator_1 = require("../test/creator");
-const watch_1 = require("./watch");
-const creator = new creator_1.BasicCaseCreator({
+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__, {
+    createNativeWatcher: ()=>createNativeWatcher
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_watch_js_namespaceObject = require("./watch.js");
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     runner: {
-        key: watch_1.getWatchRunnerKey,
-        runner: watch_1.createWatchRunner,
-    },
-    description: (name, index) => {
-        return index === 0
-            ? `${name} should compile`
-            : `should compile step ${index}`;
+        key: external_watch_js_namespaceObject.getWatchRunnerKey,
+        runner: external_watch_js_namespaceObject.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 = node_fs_1.default
-            .readdirSync(src)
-            .sort()
-            .filter((name) => node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory())
-            .map((name) => ({ name }));
-        return runs.map((run, index) => index === 0
-            ? (0, watch_1.createWatchInitialProcessor)(name, temp, run.name, watchState, {
-                nativeWatcher: true,
-            })
-            : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
-                nativeWatcher: true,
+        const runs = external_node_fs_default().readdirSync(src).sort().filter((name)=>external_node_fs_default().statSync(external_node_path_default().join(src, name)).isDirectory()).map((name)=>({
+                name
+            }));
+        return runs.map((run, index)=>0 === index ? (0, external_watch_js_namespaceObject.createWatchInitialProcessor)(name, temp, run.name, watchState, {
+                nativeWatcher: true
+            }) : (0, external_watch_js_namespaceObject.createWatchStepProcessor)(name, temp, run.name, watchState, {
+                nativeWatcher: true
             }));
     },
-    concurrent: true,
+    concurrent: true
 });
 function createNativeWatcher(name, src, dist, temp) {
     creator.create(name, src, dist, temp);
 }
+exports.createNativeWatcher = __webpack_exports__.createNativeWatcher;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNativeWatcher"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});