@rspack/test-tools 2.0.2 → 2.0.4

package/dist/case/common.js

@@ -1,34 +1,68 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.config = config;
-exports.compiler = compiler;
-exports.build = build;
-exports.run = run;
-exports.check = check;
-exports.checkSnapshot = checkSnapshot;
-exports.afterExecute = afterExecute;
-exports.findMultiCompilerBundle = findMultiCompilerBundle;
-exports.configMultiCompiler = configMultiCompiler;
-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 helper_1 = require("../helper");
-const placeholder_1 = require("../helper/expect/placeholder");
-const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-const debug_1 = require("../test/debug");
-async function config(context, name, configFiles, defaultOptions = {}) {
+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__, {
+    afterExecute: ()=>afterExecute,
+    build: ()=>build,
+    check: ()=>check,
+    checkSnapshot: ()=>checkSnapshot,
+    compiler: ()=>common_compiler,
+    config: ()=>config,
+    configMultiCompiler: ()=>configMultiCompiler,
+    findMultiCompilerBundle: ()=>findMultiCompilerBundle,
+    run: ()=>run
+});
+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 index_js_namespaceObject = require("../helper/index.js");
+const placeholder_js_namespaceObject = require("../helper/expect/placeholder.js");
+const checkArrayExpectation_js_namespaceObject = require("../helper/legacy/checkArrayExpectation.js");
+const debug_js_namespaceObject = require("../test/debug.js");
+function config(context, name, configFiles, defaultOptions = {}) {
     const compiler = context.getCompiler();
     compiler.setOptions(defaultOptions);
     if (Array.isArray(configFiles)) {
-        const fileOptions = (0, helper_1.readConfigFile)(configFiles.map((i) => context.getSource(i)), context, defaultOptions)[0];
+        const fileOptions = (0, index_js_namespaceObject.readConfigFile)(configFiles.map((i)=>context.getSource(i)), context, defaultOptions)[0];
         compiler.mergeOptions(fileOptions);
     }
     return compiler.getOptions();
 }
-async function compiler(context, name) {
+function common_compiler(context, name) {
     const compiler = context.getCompiler();
     compiler.createCompiler();
     return compiler.getCompiler();
@@ -40,39 +74,25 @@ async function build(context, name) {
 }
 async function run(env, context, name, findBundle) {
     const testConfig = context.getTestConfig();
-    if (testConfig.noTests)
-        return;
+    if (testConfig.noTests) return;
     const compiler = context.getCompiler();
-    if (typeof testConfig.beforeExecute === 'function') {
-        testConfig.beforeExecute(compiler.getOptions());
-    }
+    if ('function' == typeof testConfig.beforeExecute) testConfig.beforeExecute(compiler.getOptions());
     let bundles;
-    if (typeof findBundle === 'function') {
-        bundles = findBundle(context, compiler.getOptions());
-    }
-    else {
-        bundles = [];
-    }
-    if (typeof bundles === 'string') {
-        bundles = [bundles];
-    }
-    if (__DEBUG__) {
-        context.setValue(debug_1.DEBUG_SCOPES.RunFindBundle, bundles);
-    }
-    if (!bundles || !bundles.length) {
-        return;
-    }
+    bundles = 'function' == typeof findBundle ? findBundle(context, compiler.getOptions()) : [];
+    if ('string' == typeof bundles) bundles = [
+        bundles
+    ];
+    if (__DEBUG__) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.RunFindBundle, bundles);
+    if (!bundles || !bundles.length) return;
     if (__DEBUG__) {
-        context.setValue(debug_1.DEBUG_SCOPES.RunLogs, []);
-        context.setValue(debug_1.DEBUG_SCOPES.RunErrors, []);
+        context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.RunLogs, []);
+        context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.RunErrors, []);
     }
-    for (const bundle of bundles) {
-        if (!bundle) {
-            continue;
-        }
+    for (const bundle of bundles){
+        if (!bundle) continue;
         const runner = context.getRunner(bundle, env);
         if (__DEBUG__) {
-            const runLogs = context.getValue(debug_1.DEBUG_SCOPES.RunLogs);
+            const runLogs = context.getValue(debug_js_namespaceObject.DEBUG_SCOPES.RunLogs);
             runLogs?.push(`Start running entry: ${bundle} in ${runner.constructor.name}(${runner.__key__})`);
         }
         const mod = runner.run(bundle);
@@ -85,37 +105,31 @@ async function run(env, context, name, findBundle) {
 }
 async function check(env, context, name) {
     const testConfig = context.getTestConfig();
-    if (testConfig.noTests)
-        return;
+    if (testConfig.noTests) return;
     const compiler = context.getCompiler();
-    const errors = (context.getError() || []).map((e) => ({
-        message: e.message,
-        stack: e.stack,
-    }));
+    const errors = (context.getError() || []).map((e)=>({
+            message: e.message,
+            stack: e.stack
+        }));
     const warnings = [];
     const stats = compiler.getStats();
     const options = compiler.getOptions();
     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');
-        }
+        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');
         if (testConfig.writeStatsJson) {
             const jsonStats = stats.toJson({
                 assets: true,
                 chunks: true,
                 entrypoints: true,
                 chunkGroups: true,
-                errorDetails: true,
+                errorDetails: true
             });
-            fs_extra_1.default.writeFileSync(node_path_1.default.join(context.getDist(), 'stats.json'), JSON.stringify(jsonStats, null, 2), 'utf-8');
+            external_fs_extra_default().writeFileSync(external_node_path_default().join(context.getDist(), 'stats.json'), JSON.stringify(jsonStats, null, 2), 'utf-8');
         }
-        if (fs_extra_1.default.existsSync(context.getSource('errors.js')) ||
-            fs_extra_1.default.existsSync(context.getSource('warnings.js')) ||
-            stats.hasErrors() ||
-            stats.hasWarnings()) {
+        if (external_fs_extra_default().existsSync(context.getSource('errors.js')) || external_fs_extra_default().existsSync(context.getSource('warnings.js')) || stats.hasErrors() || stats.hasWarnings()) {
             const statsJson = stats.toJson({
                 assets: true,
                 chunks: true,
@@ -123,106 +137,80 @@ async function check(env, context, name) {
                 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)(context.getSource(), { errors }, 'error', 'errors', 'Error', options);
-    await (0, checkArrayExpectation_1.default)(context.getSource(), { warnings }, 'warning', 'warnings', 'Warning', options);
-    // clear error if checked
-    if (fs_extra_1.default.existsSync(context.getSource('errors.js'))) {
-        context.clearError();
-    }
+    await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(context.getSource(), {
+        errors
+    }, 'error', 'errors', 'Error', options);
+    await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(context.getSource(), {
+        warnings
+    }, 'warning', 'warnings', 'Warning', options);
+    if (external_fs_extra_default().existsSync(context.getSource('errors.js'))) context.clearError();
 }
-async function checkSnapshot(env, context, name, snapshot, filter) {
-    if (node_path_1.default.extname(snapshot) === '.snap') {
-        throw new Error('Snapshot with `.snap` will be managed by rstest, please use `.snap.txt` instead');
-    }
+function checkSnapshot(env, context, name, snapshot, filter) {
+    if ('.snap' === external_node_path_default().extname(snapshot)) throw new Error('Snapshot with `.snap` will be managed by rstest, please use `.snap.txt` instead');
     const compilerManager = context.getCompiler();
     const stats = compilerManager.getStats();
     const compiler = compilerManager.getCompiler();
-    if (!stats || !compiler)
-        return;
-    const compilers = 'compilers' in compiler
-        ? compiler.compilers
-        : [compiler];
-    const totalStats = 'stats' in stats ? stats.stats : [stats];
+    if (!stats || !compiler) return;
+    const compilers = 'compilers' in compiler ? compiler.compilers : [
+        compiler
+    ];
+    const totalStats = 'stats' in stats ? stats.stats : [
+        stats
+    ];
     const total = compilers.length;
-    for (let i = 0; i < compilers.length; i++) {
+    for(let i = 0; i < compilers.length; i++){
         const c = compilers[i];
         const stats = totalStats[i];
         if (stats.hasErrors()) {
             const errors = [];
             errors.push(...stats.compilation.errors);
-            throw new Error(`Failed to compile in fixture ${name}, Errors: ${errors
-                ?.map((i) => `${i.message}\n${i.stack}`)
-                .join('\n\n')}`);
+            throw new Error(`Failed to compile in fixture ${name}, Errors: ${errors?.map((i)=>`${i.message}\n${i.stack}`).join('\n\n')}`);
         }
-        const compilation = c._lastCompilation ||
-            c._lastCompilation;
-        const snapshotFileFilter = filter ||
-            ((file) => (file.endsWith('.js') || file.endsWith('.mjs')) &&
-                !file.includes('runtime.js'));
-        const fileContents = Object.entries(compilation.assets)
-            .filter(([file]) => snapshotFileFilter(file))
-            .map(([file, source]) => {
-            const tag = node_path_1.default.extname(file).slice(1) || 'txt';
-            let content = (0, placeholder_1.normalizePlaceholder)(source.source().toString());
+        const compilation = c._lastCompilation || c._lastCompilation;
+        const snapshotFileFilter = filter || ((file)=>(file.endsWith('.js') || file.endsWith('.mjs')) && !file.includes('runtime.js'));
+        const fileContents = Object.entries(compilation.assets).filter(([file])=>snapshotFileFilter(file)).map(([file, source])=>{
+            const tag = external_node_path_default().extname(file).slice(1) || 'txt';
+            let content = (0, placeholder_js_namespaceObject.normalizePlaceholder)(source.source().toString());
             const testConfig = context.getTestConfig();
-            if (testConfig.snapshotContent) {
-                content = testConfig.snapshotContent(content);
-            }
-            const filePath = file.replaceAll(node_path_1.default.sep, '/');
+            if (testConfig.snapshotContent) content = testConfig.snapshotContent(content);
+            const filePath = file.replaceAll(external_node_path_default().sep, '/');
             return `\`\`\`${tag} title=${filePath}\n${content}\n\`\`\``;
         });
         fileContents.sort();
         const content = fileContents.join('\n\n');
-        const snapshotPath = node_path_1.default.isAbsolute(snapshot)
-            ? snapshot
-            : node_path_1.default.resolve(context.getSource(), node_path_1.default.join('__snapshots__', `${snapshot}${total > 1 ? `-${i}` : ''}`));
+        const snapshotPath = external_node_path_default().isAbsolute(snapshot) ? snapshot : external_node_path_default().resolve(context.getSource(), external_node_path_default().join('__snapshots__', `${snapshot}${total > 1 ? `-${i}` : ''}`));
         env.expect(content).toMatchFileSnapshotSync(snapshotPath);
     }
 }
-async function afterExecute(context, name) {
+function afterExecute(context, name) {
     const compiler = context.getCompiler();
     const testConfig = context.getTestConfig();
-    if (typeof testConfig.afterExecute === 'function') {
+    if ('function' == typeof testConfig.afterExecute) {
         let options = compiler.getOptions();
-        if (Array.isArray(options) && options.length === 1) {
-            options = options[0];
-        }
+        if (Array.isArray(options) && 1 === options.length) options = options[0];
         testConfig.afterExecute(options);
     }
 }
 function findMultiCompilerBundle(context, name, multiFindBundle) {
-    if (typeof multiFindBundle !== 'function') {
-        return [];
-    }
-    const multiCompilerOptions = (context.getValue('multiCompilerOptions') ||
-        []);
+    if ('function' != typeof multiFindBundle) return [];
+    const multiCompilerOptions = context.getValue('multiCompilerOptions') || [];
     const result = [];
     const multiFileIndexMap = context.getValue('multiFileIndexMap') || {};
-    for (const [index, compilerOptions] of multiCompilerOptions.entries()) {
+    for (const [index, compilerOptions] of multiCompilerOptions.entries()){
         const curBundles = multiFindBundle(index, context, compilerOptions);
-        const bundles = Array.isArray(curBundles)
-            ? curBundles
-            : curBundles
-                ? [curBundles]
-                : [];
-        for (const bundle of bundles) {
-            if (multiFileIndexMap[bundle]) {
-                multiFileIndexMap[bundle].push(index);
-            }
-            else {
-                multiFileIndexMap[bundle] = [index];
-            }
-        }
+        const bundles = Array.isArray(curBundles) ? curBundles : curBundles ? [
+            curBundles
+        ] : [];
+        for (const bundle of bundles)if (multiFileIndexMap[bundle]) multiFileIndexMap[bundle].push(index);
+        else multiFileIndexMap[bundle] = [
+            index
+        ];
         result.push(...bundles);
     }
     context.setValue('multiFileIndexMap', multiFileIndexMap);
@@ -230,30 +218,47 @@ function findMultiCompilerBundle(context, name, multiFindBundle) {
 }
 function configMultiCompiler(context, name, configFiles, defaultOptions, overrideOptions) {
     const multiCompilerOptions = [];
-    const caseOptions = Array.isArray(configFiles)
-        ? (0, helper_1.readConfigFile)(configFiles.map((i) => context.getSource(i)), context, {}, (configs) => {
-            return configs.flatMap((c) => {
-                if (typeof c === 'function') {
-                    const options = {
-                        testPath: context.getDist(),
-                        env: undefined,
-                    };
-                    return c(options.env, options);
-                }
-                return c;
-            });
-        })
-        : [{}];
-    for (const [index, options] of caseOptions.entries()) {
-        const compilerOptions = (0, rspack_merge_1.default)(typeof defaultOptions === 'function'
-            ? defaultOptions(index, context)
-            : {}, options);
-        if (typeof overrideOptions === 'function') {
-            overrideOptions(index, context, compilerOptions);
-        }
+    const caseOptions = Array.isArray(configFiles) ? (0, index_js_namespaceObject.readConfigFile)(configFiles.map((i)=>context.getSource(i)), context, {}, (configs)=>configs.flatMap((c)=>{
+            if ('function' == typeof c) {
+                const options = {
+                    testPath: context.getDist(),
+                    env: void 0
+                };
+                return c(options.env, options);
+            }
+            return c;
+        })) : [
+        {}
+    ];
+    for (const [index, options] of caseOptions.entries()){
+        const compilerOptions = external_rspack_merge_default()('function' == typeof defaultOptions ? defaultOptions(index, context) : {}, options);
+        if ('function' == typeof overrideOptions) overrideOptions(index, context, compilerOptions);
         multiCompilerOptions.push(compilerOptions);
     }
     const compiler = context.getCompiler();
     compiler.setOptions(multiCompilerOptions);
     context.setValue('multiCompilerOptions', multiCompilerOptions);
 }
+exports.afterExecute = __webpack_exports__.afterExecute;
+exports.build = __webpack_exports__.build;
+exports.check = __webpack_exports__.check;
+exports.checkSnapshot = __webpack_exports__.checkSnapshot;
+exports.compiler = __webpack_exports__.compiler;
+exports.config = __webpack_exports__.config;
+exports.configMultiCompiler = __webpack_exports__.configMultiCompiler;
+exports.findMultiCompilerBundle = __webpack_exports__.findMultiCompilerBundle;
+exports.run = __webpack_exports__.run;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "afterExecute",
+    "build",
+    "check",
+    "checkSnapshot",
+    "compiler",
+    "config",
+    "configMultiCompiler",
+    "findMultiCompilerBundle",
+    "run"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/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 createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
 export type TCompilerCaseConfig = {
     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/compiler.js

@@ -1,15 +1,40 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCompilerCase = createCompilerCase;
-const creator_1 = require("../test/creator");
+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__, {
+    createCompilerCase: ()=>createCompilerCase
+});
+const creator_js_namespaceObject = require("../test/creator.js");
 function createCompilerProcessor(name, caseConfig) {
     const logs = {
         mkdir: [],
-        writeFile: [],
+        writeFile: []
     };
     const files = {};
     return {
-        config: async (context) => {
+        config: (context)=>{
             const compiler = context.getCompiler();
             const options = caseConfig.options?.(context) || {};
             options.mode ??= 'production';
@@ -22,65 +47,48 @@ function createCompilerProcessor(name, caseConfig) {
             options.optimization.minimize ??= false;
             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 = {
-                // CHANGE: Added support for the `options` parameter to enable recursive directory creation,
-                // accommodating Rspack's requirement that differs from webpack's usage
-                mkdir(path, callback) {
+                mkdir (path, callback) {
                     const recursive = false;
-                    // if (typeof options === "function") {
-                    // 	callback = options;
-                    // } else if (options) {
-                    // 	if (options.recursive !== undefined) recursive = options.recursive;
-                    // }
                     logs.mkdir.push(path);
-                    if (recursive) {
-                        callback();
-                    }
+                    if (recursive) callback();
                     else {
                         const err = new Error();
                         err.code = 'EEXIST';
                         callback(err);
                     }
                 },
-                writeFile(name, content, callback) {
+                writeFile (name, content, callback) {
                     logs.writeFile.push(name, content);
                     files[name] = content.toString('utf-8');
                     callback();
                 },
-                stat(path, callback) {
+                stat (path, callback) {
                     callback(new Error('ENOENT'));
-                },
+                }
             };
-            c.hooks.compilation.tap('CompilerTest', (compilation) => (compilation.bail = true));
+            c.hooks.compilation.tap('CompilerTest', (compilation)=>compilation.bail = true);
             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 compiler = context.getCompiler();
             const c = compiler.getCompiler();
             const stats = compiler.getStats();
             if (caseConfig.error) {
                 const statsJson = stats?.toJson({
                     modules: true,
-                    reasons: true,
+                    reasons: true
                 });
                 const compilation = stats?.compilation;
                 await caseConfig.check?.({
@@ -88,10 +96,9 @@ function createCompilerProcessor(name, caseConfig) {
                     compiler: c,
                     stats: statsJson,
                     compilation,
-                    files,
+                    files
                 });
-            }
-            else if (stats) {
+            } else if (stats) {
                 expect(typeof stats).toBe('object');
                 const compilation = stats.compilation;
                 const statsJson = stats.toJson({
@@ -101,7 +108,7 @@ function createCompilerProcessor(name, caseConfig) {
                     modules: true,
                     entrypoints: true,
                     chunkGroups: true,
-                    reasons: true,
+                    reasons: true
                 });
                 expect(typeof statsJson).toBe('object');
                 expect(statsJson).toHaveProperty('errors');
@@ -116,44 +123,48 @@ function createCompilerProcessor(name, caseConfig) {
                     stats: statsJson,
                     files,
                     compiler: c,
-                    compilation,
-                });
-            }
-            else {
-                await caseConfig.check?.({
-                    context,
-                    files,
-                    compiler: c,
+                    compilation
                 });
-            }
+            } else await caseConfig.check?.({
+                context,
+                files,
+                compiler: c
+            });
         },
-        after: async (context) => {
+        after: async (context)=>{
             await context.closeCompiler();
-        },
+        }
     };
 }
-const creator = new creator_1.BasicCaseCreator({
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: false,
-    steps: ({ name, caseConfig }) => {
-        return [createCompilerProcessor(name, caseConfig)];
-    },
-    concurrent: false,
+    steps: ({ name, caseConfig })=>[
+            createCompilerProcessor(name, caseConfig)
+        ],
+    concurrent: false
 });
 function createCompilerCase(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.createCompilerCase = __webpack_exports__.createCompilerCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCompilerCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});