@rspack/test-tools 2.0.2 → 2.0.3

package/dist/compiler.js

@@ -1,221 +1,248 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestCompilerManager = exports.ECompilerEvent = void 0;
-const node_events_1 = __importDefault(require("node:events"));
-const core_1 = require("@rspack/core");
-const rspack_merge_1 = __importDefault(require("rspack-merge"));
-const debug_1 = require("./test/debug");
-var ECompilerEvent;
-(function (ECompilerEvent) {
-    ECompilerEvent["Build"] = "build";
-    ECompilerEvent["Option"] = "option";
-    ECompilerEvent["Create"] = "create";
-    ECompilerEvent["Close"] = "close";
-})(ECompilerEvent || (exports.ECompilerEvent = ECompilerEvent = {}));
-class TestCompilerManager {
-    constructor(context) {
-        this.context = context;
-        this.compilerOptions = {};
-        this.compilerInstance = null;
-        this.compilerStats = null;
-        this.emitter = new node_events_1.default();
-    }
-    getOptions() {
-        return this.compilerOptions;
-    }
-    setOptions(newOptions) {
-        this.compilerOptions = newOptions;
-        this.emitter.emit(ECompilerEvent.Option, this.compilerOptions);
-        return this.compilerOptions;
+var __webpack_modules__ = {
+    "@rspack/core" (module) {
+        module.exports = require("@rspack/core");
     }
-    mergeOptions(newOptions) {
-        this.compilerOptions = (0, rspack_merge_1.default)(this.compilerOptions, newOptions);
-        this.emitter.emit(ECompilerEvent.Option, this.compilerOptions);
-        return this.compilerOptions;
-    }
-    getCompiler() {
-        return this.compilerInstance;
-    }
-    createCompiler() {
-        this.compilerInstance = require('@rspack/core')(this.compilerOptions);
-        if (__DEBUG__) {
-            const context = this.context;
-            this.compilerInstance = new Proxy(this.compilerInstance, {
-                get(target, p, receiver) {
-                    const value = Reflect.get(target, p, receiver);
-                    if (typeof value === 'function' &&
-                        core_1.Compiler.prototype.hasOwnProperty(p)) {
-                        return value.bind(target);
-                    }
-                    return value;
-                },
-                set(target, p, value, receiver) {
-                    const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
-                    debugSetProperties.push(`${p} ${new Error().stack?.split('\n')[2]?.trim()}`);
-                    context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
-                    return Reflect.set(target, p, value, receiver);
-                },
-            });
-            this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
-                path: require.resolve('@rspack/core'),
-                mode: 'no-callback',
-            });
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__, {
+        ECompilerEvent: ()=>compiler_ECompilerEvent,
+        TestCompilerManager: ()=>TestCompilerManager
+    });
+    const external_node_events_namespaceObject = require("node:events");
+    var external_node_events_default = /*#__PURE__*/ __webpack_require__.n(external_node_events_namespaceObject);
+    var core_ = __webpack_require__("@rspack/core");
+    const external_rspack_merge_namespaceObject = require("rspack-merge");
+    var external_rspack_merge_default = /*#__PURE__*/ __webpack_require__.n(external_rspack_merge_namespaceObject);
+    const debug_js_namespaceObject = require("./test/debug.js");
+    var compiler_ECompilerEvent = /*#__PURE__*/ function(ECompilerEvent) {
+        ECompilerEvent["Build"] = "build";
+        ECompilerEvent["Option"] = "option";
+        ECompilerEvent["Create"] = "create";
+        ECompilerEvent["Close"] = "close";
+        return ECompilerEvent;
+    }({});
+    class TestCompilerManager {
+        context;
+        compilerOptions = {};
+        compilerInstance = null;
+        compilerStats = null;
+        emitter = new (external_node_events_default())();
+        constructor(context){
+            this.context = context;
         }
-        this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
-        return this.compilerInstance;
-    }
-    createCompilerWithCallback(callback) {
-        this.compilerInstance = require('@rspack/core')(this.compilerOptions, callback);
-        if (__DEBUG__) {
-            const context = this.context;
-            this.compilerInstance = new Proxy(this.compilerInstance, {
-                get(target, p, receiver) {
-                    const value = Reflect.get(target, p, receiver);
-                    if (typeof value === 'function' &&
-                        core_1.Compiler.prototype.hasOwnProperty(p)) {
-                        return value.bind(target);
+        getOptions() {
+            return this.compilerOptions;
+        }
+        setOptions(newOptions) {
+            this.compilerOptions = newOptions;
+            this.emitter.emit("option", this.compilerOptions);
+            return this.compilerOptions;
+        }
+        mergeOptions(newOptions) {
+            this.compilerOptions = external_rspack_merge_default()(this.compilerOptions, newOptions);
+            this.emitter.emit("option", this.compilerOptions);
+            return this.compilerOptions;
+        }
+        getCompiler() {
+            return this.compilerInstance;
+        }
+        createCompiler() {
+            this.compilerInstance = __webpack_require__("@rspack/core")(this.compilerOptions);
+            if (__DEBUG__) {
+                const context = this.context;
+                this.compilerInstance = new Proxy(this.compilerInstance, {
+                    get (target, p, receiver) {
+                        const value = Reflect.get(target, p, receiver);
+                        if ('function' == typeof value && core_.Compiler.prototype.hasOwnProperty(p)) return value.bind(target);
+                        return value;
+                    },
+                    set (target, p, value, receiver) {
+                        const debugSetProperties = context.getValue(debug_js_namespaceObject.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
+                        debugSetProperties.push(`${p} ${new Error().stack?.split('\n')[2]?.trim()}`);
+                        context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
+                        return Reflect.set(target, p, value, receiver);
                     }
-                    return value;
-                },
-                set(target, p, value, receiver) {
-                    const debugSetProperties = context.getValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
-                    debugSetProperties.push(`${p} ${new Error().stack?.split('\n')[2]?.trim()}`);
-                    context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
-                    return Reflect.set(target, p, value, receiver);
-                },
-            });
-            this.context.setValue(debug_1.DEBUG_SCOPES.CreateCompilerInstance, {
-                path: require.resolve('@rspack/core'),
-                mode: 'callback',
-            });
+                });
+                this.context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.CreateCompilerInstance, {
+                    path: require.resolve('@rspack/core'),
+                    mode: 'no-callback'
+                });
+            }
+            this.emitter.emit("create", this.compilerInstance);
+            return this.compilerInstance;
         }
-        this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
-        return this.compilerInstance;
-    }
-    build() {
-        if (!this.compilerInstance)
-            throw new Error('Compiler should be created before build');
-        return new Promise((resolve, reject) => {
-            try {
+        createCompilerWithCallback(callback) {
+            this.compilerInstance = __webpack_require__("@rspack/core")(this.compilerOptions, callback);
+            if (__DEBUG__) {
                 const context = this.context;
-                if (__DEBUG__) {
-                    context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
-                        method: 'run',
+                this.compilerInstance = new Proxy(this.compilerInstance, {
+                    get (target, p, receiver) {
+                        const value = Reflect.get(target, p, receiver);
+                        if ('function' == typeof value && core_.Compiler.prototype.hasOwnProperty(p)) return value.bind(target);
+                        return value;
+                    },
+                    set (target, p, value, receiver) {
+                        const debugSetProperties = context.getValue(debug_js_namespaceObject.DEBUG_SCOPES.CreateCompilerSetProperties) || [];
+                        debugSetProperties.push(`${p} ${new Error().stack?.split('\n')[2]?.trim()}`);
+                        context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.CreateCompilerSetProperties, debugSetProperties);
+                        return Reflect.set(target, p, value, receiver);
+                    }
+                });
+                this.context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.CreateCompilerInstance, {
+                    path: require.resolve('@rspack/core'),
+                    mode: 'callback'
+                });
+            }
+            this.emitter.emit("create", this.compilerInstance);
+            return this.compilerInstance;
+        }
+        build() {
+            if (!this.compilerInstance) throw new Error('Compiler should be created before build');
+            return new Promise((resolve, reject)=>{
+                try {
+                    const context = this.context;
+                    if (__DEBUG__) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.BuildMethod, {
+                        method: 'run'
                     });
-                }
-                this.compilerInstance.run((error, newStats) => {
-                    this.emitter.emit(ECompilerEvent.Build, error, newStats);
-                    if (error) {
-                        if (__DEBUG__) {
-                            context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                    this.compilerInstance.run((error, newStats)=>{
+                        this.emitter.emit("build", error, newStats);
+                        if (error) {
+                            if (__DEBUG__) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.BuildError, {
                                 type: 'fatal',
-                                errors: [error],
+                                errors: [
+                                    error
+                                ]
                             });
+                            return reject(error);
                         }
-                        return reject(error);
-                    }
-                    this.compilerStats = newStats;
-                    if (__DEBUG__) {
-                        if (newStats?.hasErrors()) {
-                            context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                        this.compilerStats = newStats;
+                        if (__DEBUG__) {
+                            if (newStats?.hasErrors()) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.BuildError, {
                                 type: 'stats',
                                 errors: newStats.toJson({
-                                    errors: true,
-                                }).errors || [],
+                                    errors: true
+                                }).errors || []
                             });
-                        }
-                        if (newStats?.hasWarnings()) {
-                            context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
-                                warnings: true,
+                            if (newStats?.hasWarnings()) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.BuildWarning, newStats.toJson({
+                                warnings: true
                             }).warnings || []);
                         }
-                    }
-                    resolve(newStats);
-                });
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-    }
-    watch(timeout = 1000) {
-        if (!this.compilerInstance)
-            throw new Error('Compiler should be created before watch');
-        const context = this.context;
-        const watchOptions = {
-            // IMPORTANT:
-            // This is a workaround for the issue that watchpack cannot detect the file change in time
-            // so we set the poll to 300ms to make it more sensitive to the file change
-            poll: 300,
-            // Rspack ignored node_modules and .git by default for better performance, but for tests we
-            // want to watch all files, which aligns with webpack's default behavior
-            ignored: [],
-            aggregateTimeout: timeout,
-        };
-        if (__DEBUG__) {
-            context.setValue(debug_1.DEBUG_SCOPES.BuildMethod, {
-                method: 'watch',
-                options: watchOptions,
-            });
-        }
-        this.compilerInstance.watch(watchOptions, (error, newStats) => {
-            this.emitter.emit(ECompilerEvent.Build, error, newStats);
-            if (__DEBUG__) {
-                if (error) {
-                    context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
-                        type: 'fatal',
-                        errors: [error],
+                        resolve(newStats);
                     });
-                    return error;
+                } catch (e) {
+                    reject(e);
                 }
-            }
-            if (newStats) {
+            });
+        }
+        watch(timeout = 1000) {
+            if (!this.compilerInstance) throw new Error('Compiler should be created before watch');
+            const context = this.context;
+            const watchOptions = {
+                poll: 300,
+                ignored: [],
+                aggregateTimeout: timeout
+            };
+            if (__DEBUG__) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.BuildMethod, {
+                method: 'watch',
+                options: watchOptions
+            });
+            this.compilerInstance.watch(watchOptions, (error, newStats)=>{
+                this.emitter.emit("build", error, newStats);
                 if (__DEBUG__) {
-                    if (newStats.hasErrors()) {
-                        context.setValue(debug_1.DEBUG_SCOPES.BuildError, {
+                    if (error) {
+                        context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.BuildError, {
+                            type: 'fatal',
+                            errors: [
+                                error
+                            ]
+                        });
+                        return error;
+                    }
+                }
+                if (newStats) {
+                    if (__DEBUG__) {
+                        if (newStats.hasErrors()) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.BuildError, {
                             type: 'stats',
                             errors: newStats.toJson({
-                                errors: true,
-                            }).errors || [],
+                                errors: true
+                            }).errors || []
                         });
-                    }
-                    if (newStats.hasWarnings()) {
-                        context.setValue(debug_1.DEBUG_SCOPES.BuildWarning, newStats.toJson({
-                            warnings: true,
+                        if (newStats.hasWarnings()) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.BuildWarning, newStats.toJson({
+                            warnings: true
                         }).warnings || []);
                     }
+                    this.compilerStats = newStats;
                 }
-                this.compilerStats = newStats;
-            }
-            return newStats;
-        });
-    }
-    getStats() {
-        return this.compilerStats;
-    }
-    getEmitter() {
-        return this.emitter;
-    }
-    close() {
-        return new Promise((resolve, reject) => {
-            if (this.compilerInstance) {
-                this.compilerInstance.close((e) => {
-                    this.emitter.emit(ECompilerEvent.Close, e);
-                    if (e) {
-                        reject(e);
-                    }
-                    else {
-                        resolve();
-                    }
+                return newStats;
+            });
+        }
+        getStats() {
+            return this.compilerStats;
+        }
+        getEmitter() {
+            return this.emitter;
+        }
+        close() {
+            return new Promise((resolve, reject)=>{
+                if (this.compilerInstance) this.compilerInstance.close((e)=>{
+                    this.emitter.emit("close", e);
+                    if (e) reject(e);
+                    else resolve();
                 });
-            }
-            else {
-                resolve();
-            }
-        });
+                else resolve();
+            });
+        }
     }
-}
-exports.TestCompilerManager = TestCompilerManager;
+})();
+exports.ECompilerEvent = __webpack_exports__.ECompilerEvent;
+exports.TestCompilerManager = __webpack_exports__.TestCompilerManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ECompilerEvent",
+    "TestCompilerManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/helper/directory.js

@@ -1,98 +1,110 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidCaseDirectory = exports.isFile = exports.isDirectory = void 0;
-exports.describeByWalk = describeByWalk;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const _1 = require(".");
-const isDirectory = (p) => node_fs_1.default.lstatSync(p).isDirectory();
-exports.isDirectory = isDirectory;
-const isFile = (p) => node_fs_1.default.lstatSync(p).isFile();
-exports.isFile = isFile;
-const isValidCaseDirectory = (name) => !name.startsWith('_') && !name.startsWith('.') && name !== 'node_modules';
-exports.isValidCaseDirectory = isValidCaseDirectory;
-function describeByWalk(
-/**
- * The test file absolute path.
- */
-testFile, createCase, options = {}) {
+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__, {
+    describeByWalk: ()=>describeByWalk,
+    isDirectory: ()=>isDirectory,
+    isFile: ()=>isFile,
+    isValidCaseDirectory: ()=>isValidCaseDirectory
+});
+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 external_index_js_namespaceObject = require("./index.js");
+const isDirectory = (p)=>external_node_fs_default().lstatSync(p).isDirectory();
+const isFile = (p)=>external_node_fs_default().lstatSync(p).isFile();
+const isValidCaseDirectory = (name)=>!name.startsWith('_') && !name.startsWith('.') && 'node_modules' !== name;
+function describeByWalk(testFile, createCase, options = {}) {
     const describeFn = options.describe || describe;
-    const testBasename = node_path_1.default
-        .basename(testFile)
-        .replace(/(\.part\d+)?\.(diff|hot)?test\.(j|t)s/, '');
+    const testBasename = external_node_path_default().basename(testFile).replace(/(\.part\d+)?\.(diff|hot)?test\.(j|t)s/, '');
     const testId = testBasename.charAt(0).toLowerCase() + testBasename.slice(1);
-    const sourceBase = options.source || node_path_1.default.join(node_path_1.default.dirname(testFile), `${testId}Cases`);
-    const testSourceId = node_path_1.default.basename(sourceBase);
-    const absoluteTestDir = node_path_1.default.dirname(testFile);
-    const distBase = options.dist || node_path_1.default.join(node_path_1.default.dirname(testFile), 'js', testId);
+    const sourceBase = options.source || external_node_path_default().join(external_node_path_default().dirname(testFile), `${testId}Cases`);
+    const testSourceId = external_node_path_default().basename(sourceBase);
+    const absoluteTestDir = external_node_path_default().dirname(testFile);
+    const distBase = options.dist || external_node_path_default().join(external_node_path_default().dirname(testFile), 'js', testId);
     const level = options.level || 2;
     const type = options.type || 'directory';
     const absoluteDist = options.absoluteDist ?? true;
     function describeDirectory(dirname, currentLevel) {
-        node_fs_1.default.readdirSync(node_path_1.default.join(sourceBase, dirname))
-            .filter(exports.isValidCaseDirectory)
-            .filter((folder) => {
+        external_node_fs_default().readdirSync(external_node_path_default().join(sourceBase, dirname)).filter(isValidCaseDirectory).filter((folder)=>{
             if (options.exclude) {
-                if (options.exclude.some((exclude) => {
-                    return exclude.test(node_path_1.default.join(dirname, folder).replace(/\\/g, '/'));
-                })) {
-                    return false;
-                }
+                if (options.exclude.some((exclude)=>exclude.test(external_node_path_default().join(dirname, folder).replace(/\\/g, '/')))) return false;
             }
             return true;
-        })
-            .filter((folder) => {
-            const p = node_path_1.default.join(sourceBase, dirname, folder);
-            if (type === 'file' && currentLevel === 1) {
-                return (0, exports.isFile)(p);
-            }
-            if (type === 'directory' || currentLevel > 1) {
-                return (0, exports.isDirectory)(p);
-            }
+        }).filter((folder)=>{
+            const p = external_node_path_default().join(sourceBase, dirname, folder);
+            if ('file' === type && 1 === currentLevel) return isFile(p);
+            if ('directory' === type || currentLevel > 1) return isDirectory(p);
             return false;
-        })
-            .map((folder) => {
-            const caseName = node_path_1.default.join(dirname, folder);
-            if (currentLevel > 1) {
-                describeDirectory(caseName, currentLevel - 1);
-            }
+        }).map((folder)=>{
+            const caseName = external_node_path_default().join(dirname, folder);
+            if (currentLevel > 1) describeDirectory(caseName, currentLevel - 1);
             else {
-                const name = (0, _1.escapeSep)(node_path_1.default
-                    .join(`${testId}Cases-${testSourceId}`, caseName)
-                    .split('.')
-                    .shift());
+                const name = (0, external_index_js_namespaceObject.escapeSep)(external_node_path_default().join(`${testId}Cases-${testSourceId}`, caseName).split('.').shift());
                 let suiteName = name;
-                // support filter test by absolute path
                 if (process.env.testFilter?.includes(absoluteTestDir)) {
-                    const fullCasePath = node_path_1.default.join(absoluteTestDir, testSourceId, caseName);
-                    if (fullCasePath.includes(process.env.testFilter)) {
-                        suiteName = fullCasePath;
-                    }
+                    const fullCasePath = external_node_path_default().join(absoluteTestDir, testSourceId, caseName);
+                    if (fullCasePath.includes(process.env.testFilter)) suiteName = fullCasePath;
                 }
-                describeFn(suiteName, () => {
-                    const source = node_path_1.default.join(sourceBase, caseName);
+                describeFn(suiteName, ()=>{
+                    const source = external_node_path_default().join(sourceBase, caseName);
                     let dist = '';
-                    if (absoluteDist) {
-                        dist = node_path_1.default.join(distBase, caseName);
-                    }
+                    if (absoluteDist) dist = external_node_path_default().join(distBase, caseName);
                     else {
                         const relativeDist = options.dist || 'dist';
-                        if (node_path_1.default.isAbsolute(relativeDist)) {
-                            dist = node_path_1.default.join(relativeDist, caseName);
-                        }
-                        else {
-                            dist = node_path_1.default.join(sourceBase, caseName, relativeDist);
-                        }
+                        dist = external_node_path_default().isAbsolute(relativeDist) ? external_node_path_default().join(relativeDist, caseName) : external_node_path_default().join(sourceBase, caseName, relativeDist);
                     }
                     createCase(suiteName, source, dist);
                 });
             }
         });
     }
-    describeFn(testId, () => {
+    describeFn(testId, ()=>{
         describeDirectory('', level);
     });
 }
+exports.describeByWalk = __webpack_exports__.describeByWalk;
+exports.isDirectory = __webpack_exports__.isDirectory;
+exports.isFile = __webpack_exports__.isFile;
+exports.isValidCaseDirectory = __webpack_exports__.isValidCaseDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "describeByWalk",
+    "isDirectory",
+    "isFile",
+    "isValidCaseDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});