@rspack/test-tools 2.0.1 → 2.0.3

package/dist/case/hot.js

@@ -1,84 +1,112 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHotProcessor = createHotProcessor;
-exports.createHotCase = createHotCase;
-exports.createHotRunner = createHotRunner;
-const node_path_1 = __importDefault(require("node:path"));
-const core_1 = __importDefault(require("@rspack/core"));
-const helper_1 = require("../helper");
-const plugin_1 = require("../helper/hot-update/plugin");
-const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-const plugin_2 = require("../plugin");
-const runner_1 = require("../runner");
-const creator_1 = require("../test/creator");
-const common_1 = require("./common");
-const runner_2 = 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__, {
+    createHotCase: ()=>createHotCase,
+    createHotProcessor: ()=>createHotProcessor,
+    createHotRunner: ()=>createHotRunner
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const core_namespaceObject = require("@rspack/core");
+var core_default = /*#__PURE__*/ __webpack_require__.n(core_namespaceObject);
+const index_js_namespaceObject = require("../helper/index.js");
+const plugin_js_namespaceObject = require("../helper/hot-update/plugin.js");
+const checkArrayExpectation_js_namespaceObject = require("../helper/legacy/checkArrayExpectation.js");
+const external_plugin_index_js_namespaceObject = require("../plugin/index.js");
+const external_runner_index_js_namespaceObject = require("../runner/index.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");
 const creators = new Map();
 function createHotProcessor(name, src, temp, target, incremental = false) {
-    const updatePlugin = new plugin_1.HotUpdatePlugin(src, temp);
+    const updatePlugin = new plugin_js_namespaceObject.HotUpdatePlugin(src, temp);
     const processor = {
-        before: async (context) => {
+        before: async (context)=>{
             await updatePlugin.initialize();
             context.setValue('hotUpdatePlugin', updatePlugin);
         },
-        config: async (context) => {
+        config: async (context)=>{
             const compiler = context.getCompiler();
             let options = defaultOptions(context, target);
-            options = await (0, common_1.config)(context, name, ['rspack.config.js', 'webpack.config.js'], options);
+            options = await (0, external_common_js_namespaceObject.config)(context, name, [
+                'rspack.config.js',
+                'webpack.config.js'
+            ], options);
             overrideOptions(context, options, target, updatePlugin);
-            if (incremental) {
-                options.incremental ??= 'advance-silent';
-            }
+            if (incremental) options.incremental ??= 'advance-silent';
             compiler.setOptions(options);
         },
-        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) => {
-            await (0, common_1.run)(env, context, name, (context) => findBundle(context, name, target, updatePlugin));
+        run: async (env, context)=>{
+            await (0, external_common_js_namespaceObject.run)(env, context, name, (context)=>findBundle(context, name, target, updatePlugin));
         },
-        check: async (env, context) => {
-            await (0, common_1.check)(env, context, name);
+        check: async (env, context)=>{
+            await (0, external_common_js_namespaceObject.check)(env, context, name);
         },
-        after: async (context) => {
-            await (0, common_1.afterExecute)(context, name);
+        after: async (context)=>{
+            await (0, external_common_js_namespaceObject.afterExecute)(context, name);
         },
-        afterAll: async (context) => {
-            if (context.getTestConfig().checkSteps === false) {
-                return;
-            }
+        afterAll: (context)=>{
+            if (false === context.getTestConfig().checkSteps) return;
             const updateIndex = updatePlugin.getUpdateIndex();
             const totalUpdates = updatePlugin.getTotalUpdates();
-            if (updateIndex + 1 !== totalUpdates) {
-                throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
-            }
-        },
+            if (updateIndex + 1 !== totalUpdates) throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
+        }
     };
     processor.updatePlugin = updatePlugin;
     return processor;
 }
 function getCreator(target) {
-    if (!creators.has(target)) {
-        creators.set(target, new creator_1.BasicCaseCreator({
-            clean: true,
-            describe: true,
-            target,
-            steps: ({ name, target, src, dist, temp }) => [
-                createHotProcessor(name, src, temp || node_path_1.default.resolve(dist, 'temp'), target),
+    if (!creators.has(target)) creators.set(target, new creator_js_namespaceObject.BasicCaseCreator({
+        clean: true,
+        describe: true,
+        target,
+        steps: ({ name, target, src, dist, temp })=>[
+                createHotProcessor(name, src, temp || external_node_path_default().resolve(dist, 'temp'), target)
             ],
-            runner: {
-                key: (context, name, file) => name,
-                runner: createHotRunner,
-            },
-            concurrent: true,
-        }));
-    }
+        runner: {
+            key: (context, name, file)=>name,
+            runner: createHotRunner
+        },
+        concurrent: true
+    }));
     return creators.get(target);
 }
 function createHotCase(name, src, dist, temp, target) {
@@ -95,82 +123,74 @@ function defaultOptions(context, target) {
             filename: 'bundle.js',
             chunkFilename: '[name].chunk.[fullhash].js',
             publicPath: 'https://test.cases/path/',
-            library: { type: 'commonjs2' },
-            bundlerInfo: {
-                force: false,
+            library: {
+                type: 'commonjs2'
             },
+            bundlerInfo: {
+                force: false
+            }
         },
         module: {
             defaultRules: [
                 '...',
                 {
                     test: /\.css$/i,
-                    type: 'css/auto',
-                },
-            ],
+                    type: 'css/auto'
+                }
+            ]
         },
         optimization: {
-            moduleIds: 'named',
+            moduleIds: 'named'
         },
         target,
-        // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
-        incremental: 'safe',
+        incremental: 'safe'
     };
     options.plugins ??= [];
-    options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
+    options.plugins.push(new (core_default()).HotModuleReplacementPlugin());
     return options;
 }
 function overrideOptions(context, options, target, updatePlugin) {
-    if (!options.entry) {
-        options.entry = './index.js';
-    }
+    if (!options.entry) options.entry = './index.js';
     options.module ??= {};
-    for (const cssModuleType of ['css/auto', 'css/module', 'css']) {
+    for (const cssModuleType of [
+        'css/auto',
+        'css/module',
+        'css'
+    ]){
         options.module.generator ??= {};
         options.module.generator[cssModuleType] ??= {};
-        options.module.generator[cssModuleType].exportsOnly ??=
-            target === 'async-node';
+        options.module.generator[cssModuleType].exportsOnly ??= 'async-node' === target;
     }
     options.plugins ??= [];
     options.plugins.push(updatePlugin);
-    if (!global.printLogger) {
-        options.infrastructureLogging = {
-            level: 'error',
-        };
-    }
-    if (options.lazyCompilation) {
-        options.plugins.push(new plugin_2.LazyCompilationTestPlugin());
-    }
+    if (!global.printLogger) options.infrastructureLogging = {
+        level: 'error'
+    };
+    if (options.lazyCompilation) options.plugins.push(new external_plugin_index_js_namespaceObject.LazyCompilationTestPlugin());
 }
 function findBundle(context, name, target, updatePlugin) {
     const compiler = context.getCompiler();
-    if (!compiler)
-        throw new Error('Compiler should exists when find bundle');
+    if (!compiler) throw new Error('Compiler should exists when find bundle');
     const testConfig = context.getTestConfig();
-    if (typeof testConfig.findBundle === 'function') {
-        return testConfig.findBundle(updatePlugin.getUpdateIndex(), compiler.getOptions());
-    }
+    if ('function' == typeof testConfig.findBundle) return testConfig.findBundle(updatePlugin.getUpdateIndex(), compiler.getOptions());
     const files = [];
     const prefiles = [];
     const stats = compiler.getStats();
-    if (!stats)
-        throw new Error('Stats should exists when find bundle');
-    const info = stats.toJson({ all: false, entrypoints: true });
-    if (target === 'web' || target === 'webworker') {
-        for (const file of info.entrypoints.main.assets) {
-            if ((0, helper_1.isJavaScript)(file.name)) {
-                files.push(file.name);
-            }
-            else {
-                prefiles.push(file.name);
-            }
-        }
-    }
+    if (!stats) throw new Error('Stats should exists when find bundle');
+    const info = stats.toJson({
+        all: false,
+        entrypoints: true
+    });
+    if ('web' === target || 'webworker' === target) for (const file of info.entrypoints.main.assets)if ((0, index_js_namespaceObject.isJavaScript)(file.name)) files.push(file.name);
+    else prefiles.push(file.name);
     else {
-        const assets = info.entrypoints.main.assets.filter((s) => (0, helper_1.isJavaScript)(s.name));
+        const assets = info.entrypoints.main.assets.filter((s)=>(0, index_js_namespaceObject.isJavaScript)(s.name));
         files.push(assets[assets.length - 1].name);
     }
-    return [...prefiles, ...files];
+    return [
+        ...prefiles,
+        ...files
+    ];
 }
 function createHotRunner(context, name, file, env) {
     const compiler = context.getCompiler();
@@ -179,67 +199,61 @@ function createHotRunner(context, name, file, env) {
     const source = context.getSource();
     const dist = context.getDist();
     const updatePlugin = context.getValue('hotUpdatePlugin');
-    const nextHMR = async (m, options) => {
+    const nextHMR = async (m, options)=>{
         await updatePlugin.goNext();
         const stats = await compiler.build();
-        if (!stats) {
-            throw new Error('Should generate stats during build');
-        }
+        if (!stats) throw new Error('Should generate stats during build');
         const jsonStats = stats.toJson({
             assets: true,
             chunks: true,
             chunkModules: true,
             modules: true,
             entrypoints: true,
-            chunkGroups: true,
-            // errorDetails: true
+            chunkGroups: true
         });
         const compilerOptions = compiler.getOptions();
-        const checker = context.getValue(jsonStats.errors?.length
-            ? 'hotUpdateStepErrorChecker'
-            : 'hotUpdateStepChecker');
-        if (checker) {
-            checker(updatePlugin.getUpdateIndex(), stats, runner.getGlobal('__HMR_UPDATED_RUNTIME__'));
-        }
-        await (0, checkArrayExpectation_1.default)(source, jsonStats, 'error', `errors${updatePlugin.getUpdateIndex()}`, 'Error', compilerOptions);
-        await (0, checkArrayExpectation_1.default)(source, jsonStats, 'warning', `warnings${updatePlugin.getUpdateIndex()}`, 'Warning', compilerOptions);
+        const checker = context.getValue(jsonStats.errors?.length ? 'hotUpdateStepErrorChecker' : 'hotUpdateStepChecker');
+        if (checker) checker(updatePlugin.getUpdateIndex(), stats, runner.getGlobal('__HMR_UPDATED_RUNTIME__'));
+        await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(source, jsonStats, 'error', `errors${updatePlugin.getUpdateIndex()}`, 'Error', compilerOptions);
+        await (0, checkArrayExpectation_js_namespaceObject.checkArrayExpectation)(source, jsonStats, 'warning', `warnings${updatePlugin.getUpdateIndex()}`, 'Warning', compilerOptions);
         const updatedModules = await m.hot.check(options || true);
-        if (!updatedModules) {
-            throw new Error('No update available');
-        }
+        if (!updatedModules) throw new Error('No update available');
         return jsonStats;
     };
     const commonOptions = {
         env,
-        stats: (0, runner_2.cachedStats)(context, name),
+        stats: (0, external_runner_js_namespaceObject.cachedStats)(context, name),
         name: name,
         runInNewContext: false,
         testConfig: {
             ...testConfig,
-            moduleScope(ms, stats, options) {
+            moduleScope (ms, stats, options) {
                 const moduleScope = ms;
-                if (typeof testConfig.moduleScope === 'function') {
-                    testConfig.moduleScope(moduleScope, stats, compilerOptions);
-                }
+                if ('function' == typeof testConfig.moduleScope) testConfig.moduleScope(moduleScope, stats, compilerOptions);
                 moduleScope.NEXT_HMR = nextHMR;
                 return moduleScope;
-            },
+            }
         },
         cachable: true,
         source,
         dist,
-        compilerOptions,
+        compilerOptions
     };
     let runner;
-    if (compilerOptions.target === 'web' ||
-        compilerOptions.target === 'webworker') {
-        runner = new runner_1.WebRunner({
-            location: testConfig.location || 'https://test.cases/path/index.html',
-            ...commonOptions,
-        });
-    }
-    else {
-        runner = new runner_1.NodeRunner(commonOptions);
-    }
+    runner = 'web' === compilerOptions.target || 'webworker' === compilerOptions.target ? new external_runner_index_js_namespaceObject.WebRunner({
+        location: testConfig.location || 'https://test.cases/path/index.html',
+        ...commonOptions
+    }) : new external_runner_index_js_namespaceObject.NodeRunner(commonOptions);
     return runner;
 }
+exports.createHotCase = __webpack_exports__.createHotCase;
+exports.createHotProcessor = __webpack_exports__.createHotProcessor;
+exports.createHotRunner = __webpack_exports__.createHotRunner;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHotCase",
+    "createHotProcessor",
+    "createHotRunner"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/case/incremental.js

@@ -1,36 +1,70 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHotIncrementalCase = createHotIncrementalCase;
-exports.createWatchIncrementalCase = createWatchIncrementalCase;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const creator_1 = require("../test/creator");
-const hot_1 = require("./hot");
-const watch_1 = require("./watch");
+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__, {
+    createHotIncrementalCase: ()=>createHotIncrementalCase,
+    createWatchIncrementalCase: ()=>createWatchIncrementalCase
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_hot_js_namespaceObject = require("./hot.js");
+const external_watch_js_namespaceObject = require("./watch.js");
 const hotCreators = new Map();
 function createHotIncrementalProcessor(name, src, temp, target, webpackCases) {
-    return (0, hot_1.createHotProcessor)(name, src, temp, target, true);
+    return (0, external_hot_js_namespaceObject.createHotProcessor)(name, src, temp, target, true);
 }
 function getHotCreator(target, webpackCases) {
-    const key = JSON.stringify({ target, webpackCases });
-    if (!hotCreators.has(key)) {
-        hotCreators.set(key, new creator_1.BasicCaseCreator({
-            clean: true,
-            describe: true,
-            target,
-            steps: ({ name, target, src, temp, dist }) => [
-                createHotIncrementalProcessor(name, src, temp || node_path_1.default.resolve(dist, 'temp'), target, webpackCases),
+    const key = JSON.stringify({
+        target,
+        webpackCases
+    });
+    if (!hotCreators.has(key)) hotCreators.set(key, new creator_js_namespaceObject.BasicCaseCreator({
+        clean: true,
+        describe: true,
+        target,
+        steps: ({ name, target, src, temp, dist })=>[
+                createHotIncrementalProcessor(name, src, temp || external_node_path_default().resolve(dist, 'temp'), target, webpackCases)
             ],
-            runner: {
-                key: (context, name, file) => name,
-                runner: hot_1.createHotRunner,
-            },
-            concurrent: true,
-        }));
-    }
+        runner: {
+            key: (context, name, file)=>name,
+            runner: external_hot_js_namespaceObject.createHotRunner
+        },
+        concurrent: true
+    }));
     return hotCreators.get(key);
 }
 function createHotIncrementalCase(name, src, dist, temp, target, webpackCases) {
@@ -40,40 +74,39 @@ function createHotIncrementalCase(name, src, dist, temp, target, webpackCases) {
 const watchCreators = new Map();
 function getWatchCreator(options) {
     const key = JSON.stringify(options);
-    if (!watchCreators.has(key)) {
-        watchCreators.set(key, new creator_1.BasicCaseCreator({
-            clean: true,
-            runner: {
-                key: watch_1.getWatchRunnerKey,
-                runner: watch_1.createWatchRunner,
-            },
-            description: (name, index) => {
-                return index === 0
-                    ? `${name} should compile`
-                    : `should compile step ${index}`;
-            },
-            describe: false,
-            steps: ({ name, src, temp }) => {
-                const watchState = {};
-                const runs = node_fs_1.default
-                    .readdirSync(src)
-                    .sort()
-                    .filter((name) => node_fs_1.default.statSync(node_path_1.default.join(src, name)).isDirectory())
-                    .map((name) => ({ name }));
-                return runs.map((run, index) => index === 0
-                    ? (0, watch_1.createWatchInitialProcessor)(name, temp, run.name, watchState, {
-                        incremental: true,
-                    })
-                    : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
-                        incremental: true,
-                    }));
-            },
-            concurrent: true,
-        }));
-    }
+    if (!watchCreators.has(key)) watchCreators.set(key, new creator_js_namespaceObject.BasicCaseCreator({
+        clean: true,
+        runner: {
+            key: external_watch_js_namespaceObject.getWatchRunnerKey,
+            runner: external_watch_js_namespaceObject.createWatchRunner
+        },
+        description: (name, index)=>0 === index ? `${name} should compile` : `should compile step ${index}`,
+        describe: false,
+        steps: ({ name, src, temp })=>{
+            const watchState = {};
+            const runs = external_node_fs_default().readdirSync(src).sort().filter((name)=>external_node_fs_default().statSync(external_node_path_default().join(src, name)).isDirectory()).map((name)=>({
+                    name
+                }));
+            return runs.map((run, index)=>0 === index ? (0, external_watch_js_namespaceObject.createWatchInitialProcessor)(name, temp, run.name, watchState, {
+                    incremental: true
+                }) : (0, external_watch_js_namespaceObject.createWatchStepProcessor)(name, temp, run.name, watchState, {
+                    incremental: true
+                }));
+        },
+        concurrent: true
+    }));
     return watchCreators.get(key);
 }
 function createWatchIncrementalCase(name, src, dist, temp, options = {}) {
     const creator = getWatchCreator(options);
     creator.create(name, src, dist, temp);
 }
+exports.createHotIncrementalCase = __webpack_exports__.createHotIncrementalCase;
+exports.createWatchIncrementalCase = __webpack_exports__.createWatchIncrementalCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHotIncrementalCase",
+    "createWatchIncrementalCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});