@rspack/test-tools 2.0.1 → 2.0.3

package/dist/case/error.js

@@ -1,139 +1,146 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createErrorCase = createErrorCase;
-const node_path_1 = __importDefault(require("node:path"));
-const webpack_merge_1 = __importDefault(require("webpack-merge"));
-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__, {
+    createErrorCase: ()=>createErrorCase
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_rspack_merge_namespaceObject = require("rspack-merge");
+var external_rspack_merge_default = /*#__PURE__*/ __webpack_require__.n(external_rspack_merge_namespaceObject);
+const creator_js_namespaceObject = require("../test/creator.js");
 let addedSerializer = false;
-const creator = new creator_1.BasicCaseCreator({
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: true,
-    steps: ({ name, caseConfig }) => {
+    steps: ({ name, caseConfig })=>{
         const config = caseConfig;
         return [
             {
-                config: async (context) => {
+                config: (context)=>{
                     const compiler = context.getCompiler();
-                    compiler.setOptions(options(context, config.options));
+                    compiler.setOptions(error_options(context, config.options));
                 },
-                compiler: async (context) => {
+                compiler: async (context)=>{
                     const compilerManager = context.getCompiler();
                     compilerManager.createCompiler();
-                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                    await error_compiler(context, compilerManager.getCompiler(), config.compiler);
                 },
-                build: async (context) => {
+                build: async (context)=>{
                     const compiler = context.getCompiler();
-                    if (typeof config.build === 'function') {
-                        await config.build(context, compiler.getCompiler());
-                    }
-                    else {
-                        await compiler.build();
-                    }
+                    if ('function' == typeof config.build) await config.build(context, compiler.getCompiler());
+                    else await compiler.build();
                 },
-                run: async (env, context) => {
-                    // no need to run, just check the snapshot of diagnostics
-                },
-                check: async (env, context) => {
-                    await check(env, context, name, config.check);
-                },
-            },
+                run: async (env, context)=>{},
+                check: async (env, context)=>{
+                    await error_check(env, context, name, config.check);
+                }
+            }
         ];
     },
-    concurrent: true,
+    concurrent: true
 });
 function createErrorCase(name, src, dist, testConfig) {
-    if (!addedSerializer) {
-        addedSerializer = true;
-    }
+    if (!addedSerializer) addedSerializer = true;
     const caseConfigList = require(testConfig);
     function createCase(caseConfig) {
-        if (caseConfig.skip) {
-            it.skip(name, () => { });
-            return;
-        }
-        creator.create(name, src, dist, undefined, {
+        if (caseConfig.skip) return void it.skip(name, ()=>{});
+        creator.create(name, src, dist, void 0, {
             caseConfig,
-            description: () => caseConfig.description,
+            description: ()=>caseConfig.description
         });
     }
-    if (Array.isArray(caseConfigList)) {
-        for (const caseConfig of caseConfigList) {
-            createCase(caseConfig);
-        }
-    }
-    else {
-        createCase(caseConfigList);
-    }
+    if (Array.isArray(caseConfigList)) for (const caseConfig of caseConfigList)createCase(caseConfig);
+    else createCase(caseConfigList);
 }
-function options(context, custom) {
+function error_options(context, custom) {
     let options = {
-        context: node_path_1.default.resolve(__TEST_FIXTURES_PATH__, 'errors'),
+        context: external_node_path_default().resolve(__TEST_FIXTURES_PATH__, 'errors'),
         mode: 'none',
         devtool: false,
         optimization: {
             minimize: false,
             moduleIds: 'named',
-            chunkIds: 'named',
+            chunkIds: 'named'
         },
         module: {
             defaultRules: [
                 {
                     test: /\.css$/i,
-                    type: 'css/auto',
-                },
-            ],
+                    type: 'css/auto'
+                }
+            ]
         },
         otuput: {
             bundlerInfo: {
-                force: false,
-            },
-        },
+                force: false
+            }
+        }
+    };
+    if ('function' == typeof custom) options = external_rspack_merge_default()(options, custom(context, options));
+    if ('production' === options.mode) if (options.optimization) options.optimization.minimize = true;
+    else options.optimization = {
+        minimize: true
     };
-    if (typeof custom === 'function') {
-        options = (0, webpack_merge_1.default)(options, custom(context, options));
-    }
-    if (options.mode === 'production') {
-        if (options.optimization)
-            options.optimization.minimize = true;
-        else
-            options.optimization = { minimize: true };
-    }
     return options;
 }
-async function compiler(context, compiler, custom) {
-    if (compiler) {
-        compiler.outputFileSystem = {
-            // CHANGE: rspack outputFileSystem `mkdirp` uses option `{ recursive: true }`, webpack's second parameter is alway a callback
-            mkdir(dir, maybeOptionOrCallback, maybeCallback) {
-                if (typeof maybeOptionOrCallback === 'function') {
-                    maybeOptionOrCallback();
-                }
-                else if (typeof maybeCallback === 'function') {
-                    maybeCallback();
-                }
-            },
-            writeFile(file, content, callback) {
-                callback();
-            },
-            stat(file, callback) {
-                callback(new Error('ENOENT'));
-            },
-            mkdirSync() { },
-            writeFileSync() { },
-        };
-    }
+async function error_compiler(context, compiler, custom) {
+    if (compiler) compiler.outputFileSystem = {
+        mkdir (dir, maybeOptionOrCallback, maybeCallback) {
+            if ('function' == typeof maybeOptionOrCallback) maybeOptionOrCallback();
+            else if ('function' == typeof maybeCallback) maybeCallback();
+        },
+        writeFile (file, content, callback) {
+            callback();
+        },
+        stat (file, callback) {
+            callback(new Error('ENOENT'));
+        },
+        mkdirSync () {},
+        writeFileSync () {}
+    };
     await custom?.(context, compiler);
 }
 class RspackStatsDiagnostics {
-    constructor(errors, warnings) {
+    errors;
+    warnings;
+    constructor(errors, warnings){
         this.errors = errors;
         this.warnings = warnings;
     }
 }
-async function check(env, context, name, check) {
+async function error_check(env, context, name, check) {
     if (context.getError().length > 0) {
         await check?.(new RspackStatsDiagnostics(context.getError(), []));
         context.clearError();
@@ -142,10 +149,19 @@ async function check(env, context, name, check) {
     const compiler = context.getCompiler();
     const stats = compiler.getStats();
     env.expect(typeof stats).toBe('object');
-    const statsResult = stats.toJson({ errorDetails: false });
+    const statsResult = stats.toJson({
+        errorDetails: false
+    });
     env.expect(typeof statsResult).toBe('object');
     const { errors, warnings } = statsResult;
     env.expect(Array.isArray(errors)).toBe(true);
     env.expect(Array.isArray(warnings)).toBe(true);
     await check?.(new RspackStatsDiagnostics(errors, warnings));
 }
+exports.createErrorCase = __webpack_exports__.createErrorCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createErrorCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/esm-output.js

@@ -1,104 +1,135 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEsmOutputCase = createEsmOutputCase;
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
-const runner_1 = require("./runner");
-const creator = new creator_1.BasicCaseCreator({
+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__, {
+    createEsmOutputCase: ()=>createEsmOutputCase
+});
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_common_js_namespaceObject = require("./common.js");
+const external_runner_js_namespaceObject = require("./runner.js");
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: false,
-    testConfig: (testConfig) => {
+    testConfig: (testConfig)=>{
         const oldModuleScope = testConfig.moduleScope;
-        testConfig.moduleScope = (ms, stats) => {
+        testConfig.moduleScope = (ms, stats)=>{
             let res = ms;
-            // TODO: modify runner module scope based on stats here
-            if (typeof oldModuleScope === 'function') {
-                res = oldModuleScope(ms, stats);
-            }
+            if ('function' == typeof oldModuleScope) res = oldModuleScope(ms, stats);
             return res;
         };
     },
-    steps: ({ name }) => [
-        {
-            config: async (context) => {
-                (0, common_1.configMultiCompiler)(context, name, ['rspack.config.cjs', 'rspack.config.js', 'webpack.config.js'], defaultOptions, () => { });
-            },
-            compiler: async (context) => {
-                await (0, common_1.compiler)(context, name);
-            },
-            build: async (context) => {
-                await (0, common_1.build)(context, name);
-            },
-            run: async (env, context) => {
-                await (0, common_1.run)(env, context, name, (context) => (0, common_1.findMultiCompilerBundle)(context, name, (_index, context, options) => {
+    steps: ({ name })=>[
+            {
+                config: (context)=>{
+                    (0, external_common_js_namespaceObject.configMultiCompiler)(context, name, [
+                        'rspack.config.cjs',
+                        'rspack.config.js',
+                        'webpack.config.js'
+                    ], defaultOptions, ()=>{});
+                },
+                compiler: async (context)=>{
+                    await (0, external_common_js_namespaceObject.compiler)(context, name);
+                },
+                build: async (context)=>{
+                    await (0, external_common_js_namespaceObject.build)(context, name);
+                },
+                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)=>{
+                            const testConfig = context.getTestConfig();
+                            if ('function' == typeof testConfig.findBundle) return testConfig.findBundle(_index, options);
+                            if (options.output?.filename === '[name].mjs') return [
+                                'main.mjs'
+                            ];
+                            return [
+                                options.output.filename
+                            ];
+                        }));
+                },
+                check: async (env, context)=>{
+                    await (0, external_common_js_namespaceObject.check)(env, context, name);
                     const testConfig = context.getTestConfig();
-                    if (typeof testConfig.findBundle === 'function') {
-                        return testConfig.findBundle(_index, options);
-                    }
-                    if (options.output?.filename === '[name].mjs') {
-                        return ['main.mjs'];
-                    }
-                    else {
-                        return [options.output.filename];
-                    }
-                }));
-            },
-            check: async (env, context) => {
-                await (0, common_1.check)(env, context, name);
-                const testConfig = context.getTestConfig();
-                await (0, common_1.checkSnapshot)(env, context, name, 'esm.snap.txt', testConfig.snapshotFileFilter);
-            },
-            after: async (context) => {
-                await (0, common_1.afterExecute)(context, name);
-            },
-        },
-    ],
+                    await (0, external_common_js_namespaceObject.checkSnapshot)(env, context, name, 'esm.snap.txt', testConfig.snapshotFileFilter);
+                },
+                after: async (context)=>{
+                    await (0, external_common_js_namespaceObject.afterExecute)(context, name);
+                }
+            }
+        ],
     runner: {
-        key: runner_1.getMultiCompilerRunnerKey,
-        runner: runner_1.createMultiCompilerRunner,
+        key: external_runner_js_namespaceObject.getMultiCompilerRunnerKey,
+        runner: external_runner_js_namespaceObject.createMultiCompilerRunner
     },
-    concurrent: 1,
+    concurrent: 1
 });
-const defaultOptions = (_index, context) => ({
-    context: context.getSource(),
-    mode: 'production',
-    target: 'async-node',
-    devtool: false,
-    entry: './index.js',
-    cache: false,
-    output: {
-        path: context.getDist(),
-        filename: '[name].mjs',
-        pathinfo: true,
-        module: true,
-        library: {
-            type: 'modern-module',
+const defaultOptions = (_index, context)=>({
+        context: context.getSource(),
+        mode: 'production',
+        target: 'async-node',
+        devtool: false,
+        entry: './index.js',
+        cache: false,
+        output: {
+            path: context.getDist(),
+            filename: '[name].mjs',
+            pathinfo: true,
+            module: true,
+            library: {
+                type: 'modern-module'
+            },
+            bundlerInfo: {
+                force: false
+            }
         },
-        bundlerInfo: {
-            force: false,
+        module: {
+            defaultRules: [
+                '...',
+                {
+                    test: /\.css$/i,
+                    type: 'css/auto'
+                }
+            ]
         },
-    },
-    module: {
-        defaultRules: [
-            '...',
-            {
-                test: /\.css$/i,
-                type: 'css/auto',
-            },
-        ],
-    },
-    bail: true,
-    optimization: {
-        minimize: false,
-        moduleIds: 'named',
-        chunkIds: 'named',
-        runtimeChunk: 'single',
-    },
-    externals: {
-        fs: 'module-import fs',
-        path: 'module-import path',
-    },
-});
+        bail: true,
+        optimization: {
+            minimize: false,
+            moduleIds: 'named',
+            chunkIds: 'named',
+            runtimeChunk: 'single'
+        },
+        externals: {
+            fs: 'fs',
+            path: 'path'
+        }
+    });
 function createEsmOutputCase(name, src, dist) {
     creator.create(name, src, dist);
 }
+exports.createEsmOutputCase = __webpack_exports__.createEsmOutputCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createEsmOutputCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/example.js

@@ -1,57 +1,95 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExampleCase = createExampleCase;
-const node_path_1 = __importDefault(require("node:path"));
-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__, {
+    createExampleCase: ()=>createExampleCase
+});
+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_common_js_namespaceObject = require("./common.js");
 function overrideOptions(index, context, options) {
     options.context = context.getSource();
     options.output = options.output || {};
     options.output.pathinfo = true;
     options.output.path = context.getDist();
     options.output.publicPath = 'dist/';
-    if (!options.entry)
-        options.entry = './example.js';
-    if (!options.plugins)
-        options.plugins = [];
+    if (!options.entry) options.entry = './example.js';
+    if (!options.plugins) options.plugins = [];
 }
 function createExampleProcessor(name) {
     return {
-        config: async (context) => {
-            (0, common_1.configMultiCompiler)(context, name, ['rspack.config.js', 'webpack.config.js'], () => ({}), overrideOptions);
+        config: (context)=>{
+            (0, external_common_js_namespaceObject.configMultiCompiler)(context, name, [
+                'rspack.config.js',
+                'webpack.config.js'
+            ], ()=>({}), overrideOptions);
         },
-        compiler: async (context) => {
-            await (0, common_1.compiler)(context, name);
+        compiler: async (context)=>{
+            await (0, external_common_js_namespaceObject.compiler)(context, name);
         },
-        build: async (context) => {
-            await (0, common_1.build)(context, name);
+        build: async (context)=>{
+            await (0, external_common_js_namespaceObject.build)(context, name);
         },
-        run: async (env, context) => {
-            // no need to run, just check the building
-        },
-        check: async (env, context) => {
+        run: async (env, context)=>{},
+        check: (env, context)=>{
             const compiler = context.getCompiler();
             const stats = compiler.getStats();
-            if (stats?.hasErrors()) {
-                console.log(stats.toString({
-                    all: false,
-                    errors: true,
-                    errorDetails: true,
-                    errorStack: true,
-                }));
-            }
+            if (stats?.hasErrors()) console.log(stats.toString({
+                all: false,
+                errors: true,
+                errorDetails: true,
+                errorStack: true
+            }));
             expect(stats?.hasErrors()).toBe(false);
-        },
+        }
     };
 }
-const creator = new creator_1.BasicCaseCreator({
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
-    steps: ({ name }) => [createExampleProcessor(name)],
-    concurrent: true,
+    steps: ({ name })=>[
+            createExampleProcessor(name)
+        ],
+    concurrent: true
 });
 function createExampleCase(name, src) {
-    creator.create(name, src, node_path_1.default.join(src, 'dist'));
+    creator.create(name, src, external_node_path_default().join(src, 'dist'));
 }
+exports.createExampleCase = __webpack_exports__.createExampleCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createExampleCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});