@rspack/test-tools 2.0.2 → 2.0.3

package/dist/case/config.js

@@ -1,62 +1,98 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConfigProcessor = createConfigProcessor;
-exports.createConfigCase = createConfigCase;
-exports.defaultOptions = defaultOptions;
-exports.enableEsmLibraryPlugin = enableEsmLibraryPlugin;
-exports.overrideOptions = overrideOptions;
-exports.findBundle = findBundle;
-const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const parseResource_1 = require("../helper/legacy/parseResource");
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
-const runner_1 = require("./runner");
+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__, {
+    createConfigCase: ()=>createConfigCase,
+    createConfigProcessor: ()=>createConfigProcessor,
+    defaultOptions: ()=>defaultOptions,
+    enableEsmLibraryPlugin: ()=>enableEsmLibraryPlugin,
+    findBundle: ()=>findBundle,
+    overrideOptions: ()=>overrideOptions
+});
+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 parseResource_js_namespaceObject = require("../helper/legacy/parseResource.js");
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_common_js_namespaceObject = require("./common.js");
+const external_runner_js_namespaceObject = require("./runner.js");
 function createConfigProcessor(name) {
     return {
-        config: async (context) => {
-            (0, common_1.configMultiCompiler)(context, name, ['rspack.config.cjs', 'rspack.config.js', 'webpack.config.js'], defaultOptions, overrideOptions);
-        },
-        compiler: async (context) => {
-            await (0, common_1.compiler)(context, name);
+        config: (context)=>{
+            (0, external_common_js_namespaceObject.configMultiCompiler)(context, name, [
+                'rspack.config.cjs',
+                'rspack.config.js',
+                'webpack.config.js'
+            ], defaultOptions, overrideOptions);
         },
-        build: async (context) => {
-            await (0, common_1.build)(context, name);
+        compiler: async (context)=>{
+            await (0, external_common_js_namespaceObject.compiler)(context, name);
         },
-        run: async (env, context) => {
-            await (0, common_1.run)(env, context, name, (context) => (0, common_1.findMultiCompilerBundle)(context, name, findBundle));
+        build: async (context)=>{
+            await (0, external_common_js_namespaceObject.build)(context, name);
         },
-        check: async (env, context) => {
-            await (0, common_1.check)(env, 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, findBundle));
         },
-        after: async (context) => {
-            await (0, common_1.afterExecute)(context, name);
+        check: async (env, context)=>{
+            await (0, external_common_js_namespaceObject.check)(env, context, name);
         },
+        after: async (context)=>{
+            await (0, external_common_js_namespaceObject.afterExecute)(context, name);
+        }
     };
 }
-const creator = new creator_1.BasicCaseCreator({
+const creator = new creator_js_namespaceObject.BasicCaseCreator({
     clean: true,
     describe: false,
-    testConfig: (testConfig) => {
+    testConfig: (testConfig)=>{
         const oldModuleScope = testConfig.moduleScope;
-        testConfig.moduleScope = (ms, stats, compilerOptions) => {
+        testConfig.moduleScope = (ms, stats, compilerOptions)=>{
             let res = ms;
-            // TODO: modify runner module scope based on stats here
-            if (typeof oldModuleScope === 'function') {
-                res = oldModuleScope(ms, stats, compilerOptions);
-            }
+            if ('function' == typeof oldModuleScope) res = oldModuleScope(ms, stats, compilerOptions);
             return res;
         };
     },
-    steps: ({ name }) => [createConfigProcessor(name)],
+    steps: ({ name })=>[
+            createConfigProcessor(name)
+        ],
     runner: {
-        key: runner_1.getMultiCompilerRunnerKey,
-        runner: runner_1.createMultiCompilerRunner,
+        key: external_runner_js_namespaceObject.getMultiCompilerRunnerKey,
+        runner: external_runner_js_namespaceObject.createMultiCompilerRunner
     },
-    concurrent: true,
+    concurrent: true
 });
 function createConfigCase(name, src, dist) {
     creator.create(name, src, dist);
@@ -71,61 +107,63 @@ function defaultOptions(index, context) {
         output: {
             path: context.getDist(),
             bundlerInfo: {
-                force: false,
-            },
+                force: false
+            }
         },
         optimization: {
-            minimize: false,
-        },
+            minimize: false
+        }
     };
 }
 function enableEsmLibraryPlugin(options) {
-    return (options.output?.library === 'modern-module' ||
-        (typeof options.output?.library === 'object' &&
-            (options.output?.library).type === 'modern-module'));
+    return options.output?.library === 'modern-module' || 'object' == typeof options.output?.library && 'modern-module' === (options.output?.library).type;
 }
 function overrideOptions(index, context, options) {
-    if (!options.entry) {
-        options.entry = './index.js';
-    }
-    if (options.amd === undefined) {
-        options.amd = {};
-    }
+    if (!options.entry) options.entry = './index.js';
+    if (void 0 === options.amd) options.amd = {};
     if (!options.output?.filename) {
-        const runtimeChunkForModernModule = options.optimization?.runtimeChunk === undefined &&
-            enableEsmLibraryPlugin(options);
+        const runtimeChunkForModernModule = options.optimization?.runtimeChunk === void 0 && enableEsmLibraryPlugin(options);
         const outputModule = options.output?.module || enableEsmLibraryPlugin(options);
         options.output ??= {};
         options.output.filename = `${runtimeChunkForModernModule ? `[name]${outputModule ? '.mjs' : '.js'}` : `bundle${index}${outputModule ? '.mjs' : '.js'}`}`;
     }
     if (enableEsmLibraryPlugin(options)) {
         options.optimization ??= {};
-        options.optimization.runtimeChunk ??= { name: `runtime~${index}` };
-    }
-    if (options.cache === undefined)
-        options.cache = false;
-    if (!global.printLogger) {
-        options.infrastructureLogging = {
-            level: 'error',
+        options.optimization.runtimeChunk ??= {
+            name: `runtime~${index}`
         };
     }
+    if (void 0 === options.cache) options.cache = false;
+    if (!global.printLogger) options.infrastructureLogging = {
+        level: 'error'
+    };
 }
 function findBundle(index, context, options) {
     const testConfig = context.getTestConfig();
-    if (typeof testConfig.findBundle === 'function') {
-        return testConfig.findBundle(index, options);
-    }
-    const ext = node_path_1.default.extname((0, parseResource_1.parseResource)(options.output?.filename).path);
+    if ('function' == typeof testConfig.findBundle) return testConfig.findBundle(index, options);
+    const ext = external_node_path_default().extname((0, parseResource_js_namespaceObject.parseResource)(options.output?.filename).path);
     const bundlePath = [];
-    if (options.output?.path &&
-        fs_extra_1.default.existsSync(node_path_1.default.join(options.output.path, `bundle${index}${ext}`))) {
-        const cssOutputPath = node_path_1.default.join(options.output.path, (typeof options.output?.cssFilename === 'string' &&
-            options.output?.cssFilename) ||
-            `bundle${index}.css`);
-        if (fs_extra_1.default.existsSync(cssOutputPath)) {
-            bundlePath.push(node_path_1.default.relative(options.output.path, cssOutputPath));
-        }
+    if (options.output?.path && external_fs_extra_default().existsSync(external_node_path_default().join(options.output.path, `bundle${index}${ext}`))) {
+        const cssOutputPath = external_node_path_default().join(options.output.path, 'string' == typeof options.output?.cssFilename && options.output?.cssFilename || `bundle${index}.css`);
+        if (external_fs_extra_default().existsSync(cssOutputPath)) bundlePath.push(external_node_path_default().relative(options.output.path, cssOutputPath));
         bundlePath.push(`./bundle${index}${ext}`);
     }
     return bundlePath;
 }
+exports.createConfigCase = __webpack_exports__.createConfigCase;
+exports.createConfigProcessor = __webpack_exports__.createConfigProcessor;
+exports.defaultOptions = __webpack_exports__.defaultOptions;
+exports.enableEsmLibraryPlugin = __webpack_exports__.enableEsmLibraryPlugin;
+exports.findBundle = __webpack_exports__.findBundle;
+exports.overrideOptions = __webpack_exports__.overrideOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createConfigCase",
+    "createConfigProcessor",
+    "defaultOptions",
+    "enableEsmLibraryPlugin",
+    "findBundle",
+    "overrideOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/defaults.js

@@ -1,93 +1,146 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __webpack_modules__ = {
+    "@rspack/core" (module) {
+        module.exports = require("@rspack/core");
+    }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDefaultsCase = createDefaultsCase;
-exports.getRspackDefaultConfig = getRspackDefaultConfig;
-const node_path_1 = __importDefault(require("node:path"));
-const node_util_1 = require("node:util");
-const jest_diff_1 = require("jest-diff");
-const context_1 = require("../test/context");
-const CURRENT_CWD = process.cwd();
-function createDefaultsCase(name, src) {
-    const caseConfig = require(src);
-    it(`should generate the correct defaults from ${caseConfig.description}`, async () => {
-        await run(name, {
-            config: async (context) => {
-                const compiler = context.getCompiler();
-                compiler.setOptions(options(context, caseConfig.options));
-            },
-            compiler: async (context) => {
-                const compiler = context.getCompiler();
-                compiler.createCompiler();
-            },
-            build: async (context) => {
-                // no need to build, just check the snapshot of compiler options
-            },
-            run: async (env, context) => {
-                // no need to run, just check the snapshot of compiler options
-            },
-            check: async (env, context) => {
-                await check(env, context, name, caseConfig);
-            },
+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__, {
+        createDefaultsCase: ()=>createDefaultsCase,
+        getRspackDefaultConfig: ()=>getRspackDefaultConfig
     });
-}
-function getRspackDefaultConfig(cwd, config) {
-    process.chdir(cwd);
-    const { applyWebpackOptionsDefaults, getNormalizedWebpackOptions } = require('@rspack/core').config;
-    const normalizedConfig = getNormalizedWebpackOptions(config);
-    applyWebpackOptionsDefaults(normalizedConfig);
-    // make snapshot stable
-    normalizedConfig.output.bundlerInfo.version = '$version$';
-    process.chdir(CURRENT_CWD);
-    return normalizedConfig;
-}
-const srcDir = node_path_1.default.resolve(__dirname, '../../tests/fixtures');
-const distDir = node_path_1.default.resolve(__dirname, '../../tests/js/defaults');
-function options(context, custom) {
-    let res;
-    if (typeof custom === 'function') {
-        res = custom(context);
+    const external_node_path_namespaceObject = require("node:path");
+    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+    const external_node_util_namespaceObject = require("node:util");
+    const external_jest_diff_namespaceObject = require("jest-diff");
+    const context_js_namespaceObject = require("../test/context.js");
+    const CURRENT_CWD = process.cwd();
+    function createDefaultsCase(name, src) {
+        const caseConfig = require(src);
+        it(`should generate the correct defaults from ${caseConfig.description}`, async ()=>{
+            await run(name, {
+                config: (context)=>{
+                    const compiler = context.getCompiler();
+                    compiler.setOptions(defaults_options(context, caseConfig.options));
+                },
+                compiler: (context)=>{
+                    const compiler = context.getCompiler();
+                    compiler.createCompiler();
+                },
+                build: async (context)=>{},
+                run: async (env, context)=>{},
+                check: async (env, context)=>{
+                    await check(env, context, name, caseConfig);
+                }
+            });
+        });
     }
-    else {
-        res = {};
+    function getRspackDefaultConfig(cwd, config) {
+        process.chdir(cwd);
+        const { applyWebpackOptionsDefaults, getNormalizedWebpackOptions } = __webpack_require__("@rspack/core").config;
+        const normalizedConfig = getNormalizedWebpackOptions(config);
+        applyWebpackOptionsDefaults(normalizedConfig);
+        normalizedConfig.output.bundlerInfo.version = '$version$';
+        process.chdir(CURRENT_CWD);
+        return normalizedConfig;
     }
-    if (!('mode' in res)) {
-        res.mode = 'none';
+    const srcDir = external_node_path_default().resolve(__dirname, '../../tests/fixtures');
+    const distDir = external_node_path_default().resolve(__dirname, '../../tests/js/defaults');
+    function defaults_options(context, custom) {
+        let res;
+        res = 'function' == typeof custom ? custom(context) : {};
+        if (!('mode' in res)) res.mode = 'none';
+        return res;
     }
-    return res;
-}
-class RspackTestDiff {
-    constructor(value) {
-        this.value = value;
+    class RspackTestDiff {
+        value;
+        constructor(value){
+            this.value = value;
+        }
     }
-}
-async function check(env, context, name, options) {
-    const compiler = context.getCompiler();
-    const config = getRspackDefaultConfig(options.cwd || CURRENT_CWD, compiler.getOptions());
-    const defaultConfig = getRspackDefaultConfig(options.cwd || CURRENT_CWD, {
-        mode: 'none',
-    });
-    const diff = (0, node_util_1.stripVTControlCharacters)((0, jest_diff_1.diff)(defaultConfig, config, { expand: false, contextLines: 0 }));
-    await options.diff(env.expect(new RspackTestDiff(diff)), env.expect(defaultConfig));
-}
-async function run(name, processor) {
-    const context = new context_1.TestContext({
-        name: name,
-        src: srcDir,
-        dist: distDir,
-    });
-    try {
-        await processor.before?.(context);
-        await processor.config?.(context);
-    }
-    catch (e) {
-        context.emitError(e);
+    async function check(env, context, name, options) {
+        const compiler = context.getCompiler();
+        const config = getRspackDefaultConfig(options.cwd || CURRENT_CWD, compiler.getOptions());
+        const defaultConfig = getRspackDefaultConfig(options.cwd || CURRENT_CWD, {
+            mode: 'none'
+        });
+        const diff = (0, external_node_util_namespaceObject.stripVTControlCharacters)((0, external_jest_diff_namespaceObject.diff)(defaultConfig, config, {
+            expand: false,
+            contextLines: 0
+        }));
+        await options.diff(env.expect(new RspackTestDiff(diff)), env.expect(defaultConfig));
     }
-    finally {
-        await processor.check?.({ expect, it, beforeEach, afterEach, rstest }, context);
-        await processor.after?.(context);
+    async function run(name, processor) {
+        const context = new context_js_namespaceObject.TestContext({
+            name: name,
+            src: srcDir,
+            dist: distDir
+        });
+        try {
+            await processor.before?.(context);
+            await processor.config?.(context);
+        } catch (e) {
+            context.emitError(e);
+        } finally{
+            await processor.check?.({
+                expect,
+                it,
+                beforeEach,
+                afterEach,
+                rstest
+            }, context);
+            await processor.after?.(context);
+        }
     }
-}
+})();
+exports.createDefaultsCase = __webpack_exports__.createDefaultsCase;
+exports.getRspackDefaultConfig = __webpack_exports__.getRspackDefaultConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDefaultsCase",
+    "getRspackDefaultConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});