@rspack/test-tools 2.0.2 → 2.0.4

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
+});

package/dist/case/hash.js

@@ -1,12 +1,37 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHashCase = createHashCase;
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
+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__, {
+    createHashCase: ()=>createHashCase
+});
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_common_js_namespaceObject = require("./common.js");
 const REG_ERROR_CASE = /error$/;
-class HashCaseCreator extends creator_1.BasicCaseCreator {
+class HashCaseCreator extends creator_js_namespaceObject.BasicCaseCreator {
     describe(name, tester, testConfig, options) {
-        it(`should print correct hash for ${name}`, async () => {
+        it(`should print correct hash for ${name}`, async ()=>{
             await tester.prepare();
             await tester.compile();
             await tester.check(this.createEnv(testConfig, options));
@@ -17,25 +42,26 @@ class HashCaseCreator extends creator_1.BasicCaseCreator {
 const creator = new HashCaseCreator({
     clean: true,
     describe: false,
-    steps: ({ name }) => [
-        {
-            config: async (context) => {
-                (0, common_1.configMultiCompiler)(context, name, ['rspack.config.js', 'webpack.config.js'], defaultOptions, overrideOptions);
-            },
-            compiler: async (context) => {
-                await (0, common_1.compiler)(context, name);
-            },
-            build: async (context) => {
-                await (0, common_1.build)(context, name);
-            },
-            run: async (env, context) => {
-                // no need to run, just check snapshot
-            },
-            check: async (env, context) => {
-                await check(env, context, name);
-            },
-        },
-    ],
+    steps: ({ name })=>[
+            {
+                config: (context)=>{
+                    (0, external_common_js_namespaceObject.configMultiCompiler)(context, name, [
+                        'rspack.config.js',
+                        'webpack.config.js'
+                    ], defaultOptions, overrideOptions);
+                },
+                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)=>{},
+                check: async (env, context)=>{
+                    await check(env, context, name);
+                }
+            }
+        ]
 });
 function createHashCase(name, src, dist) {
     creator.create(name, src, dist);
@@ -48,49 +74,38 @@ function defaultOptions(index, context) {
                 '...',
                 {
                     test: /\.css$/i,
-                    type: 'css/auto',
-                },
-            ],
+                    type: 'css/auto'
+                }
+            ]
         },
         output: {
             path: context.getDist(),
             bundlerInfo: {
-                force: false,
-            },
-        },
+                force: false
+            }
+        }
     };
 }
 function overrideOptions(index, context, options) {
-    if (!options.entry) {
-        options.entry = './index.js';
-    }
-    if (!global.printLogger) {
-        options.infrastructureLogging = {
-            level: 'error',
-        };
-    }
+    if (!options.entry) options.entry = './index.js';
+    if (!global.printLogger) options.infrastructureLogging = {
+        level: 'error'
+    };
 }
-async function check(env, context, name) {
+function check(env, context, name) {
     const compiler = context.getCompiler();
     const stats = compiler.getStats();
     const testConfig = context.getTestConfig();
-    if (!stats) {
-        throw new Error('No stats found\n' +
-            context
-                .getError()
-                .map((e) => e.stack)
-                .join('\n'));
-    }
-    if (REG_ERROR_CASE.test(name)) {
-        env.expect(stats.hasErrors());
-    }
-    else {
-        env.expect(!stats.hasErrors());
-    }
-    if (typeof testConfig.validate === 'function') {
-        testConfig.validate(stats);
-    }
-    else {
-        throw new Error('HashTestCases should have test.config.js and a validate method');
-    }
+    if (!stats) throw new Error('No stats found\n' + context.getError().map((e)=>e.stack).join('\n'));
+    if (REG_ERROR_CASE.test(name)) env.expect(stats.hasErrors());
+    else env.expect(!stats.hasErrors());
+    if ('function' == typeof testConfig.validate) testConfig.validate(stats);
+    else throw new Error('HashTestCases should have test.config.js and a validate method');
 }
+exports.createHashCase = __webpack_exports__.createHashCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHashCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});