@rspack/test-tools 2.0.1 → 2.0.3

package/dist/case/hot-step.js

@@ -1,20 +1,53 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHotStepCase = createHotStepCase;
-const node_path_1 = __importDefault(require("node:path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const helper_1 = require("../helper");
-const placeholder_1 = require("../helper/expect/placeholder");
-const creator_1 = require("../test/creator");
-const hot_1 = require("./hot");
+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__, {
+    createHotStepCase: ()=>createHotStepCase
+});
+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 index_js_namespaceObject = require("../helper/index.js");
+const placeholder_js_namespaceObject = require("../helper/expect/placeholder.js");
+const creator_js_namespaceObject = require("../test/creator.js");
+const external_hot_js_namespaceObject = require("./hot.js");
 const NOOP_SET = new Set();
-const escapeLocalName = (str) => str.split(/[-<>:"/|?*.]/).join('_');
-const SELF_HANDLER = (file, options) => {
+const escapeLocalName = (str)=>str.split(/[-<>:"/|?*.]/).join('_');
+const SELF_HANDLER = (file, options)=>{
     let res = [];
-    const hotUpdateGlobal = (_, modules) => {
+    const hotUpdateGlobal = (_, modules)=>{
         res = Object.keys(modules);
     };
     const hotUpdateGlobalKey = escapeLocalName(`${options.output?.hotUpdateGlobal || 'rspackHotUpdate'}${options.output?.uniqueName || ''}`);
@@ -24,18 +57,16 @@ const SELF_HANDLER = (file, options) => {
     delete global.self[hotUpdateGlobalKey];
     return res;
 };
-const NODE_HANDLER = (file) => {
-    return Object.keys(require(file).modules) || [];
-};
+const NODE_HANDLER = (file)=>Object.keys(require(file).modules) || [];
 const GET_MODULE_HANDLER = {
     web: SELF_HANDLER,
     webworker: SELF_HANDLER,
     'async-node': NODE_HANDLER,
-    node: NODE_HANDLER,
+    node: NODE_HANDLER
 };
 const creators = new Map();
 function createHotStepProcessor(name, src, temp, target) {
-    const processor = (0, hot_1.createHotProcessor)(name, src, temp, target);
+    const processor = (0, external_hot_js_namespaceObject.createHotProcessor)(name, src, temp, target);
     const entries = {};
     const hashes = [];
     function matchStepSnapshot(env, context, step, options, stats, runtime) {
@@ -43,78 +74,47 @@ function createHotStepProcessor(name, src, temp, target) {
         env.expect(typeof getModuleHandler).toBe('function');
         const lastHash = hashes[hashes.length - 1];
         const snapshotPath = context.getSource(`__snapshots__/${options.target}/${step}.snap.txt`);
-        const title = `Case ${node_path_1.default.basename(name)}: Step ${step}`;
+        const title = `Case ${external_node_path_default().basename(name)}: Step ${step}`;
         const hotUpdateFile = [];
         const hotUpdateManifest = [];
-        const changedFiles = step === 0
-            ? []
-            : processor.updatePlugin
-                .getModifiedFiles()
-                .map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(temp, i)));
+        const changedFiles = 0 === step ? [] : processor.updatePlugin.getModifiedFiles().map((i)=>(0, index_js_namespaceObject.escapeSep)(external_node_path_default().relative(temp, i)));
         changedFiles.sort();
         const resultHashes = {
             [lastHash || 'LAST_HASH']: 'LAST_HASH',
-            [stats.hash]: 'CURRENT_HASH',
+            [stats.hash]: 'CURRENT_HASH'
         };
-        // TODO: find a better way
-        // replace [runtime] to [runtime of id] to prevent worker hash
         const runtimes = {};
-        for (const [id, runtime] of Object.entries(entries)) {
-            if (typeof runtime === 'string') {
-                if (runtime !== id) {
-                    runtimes[runtime] = `[runtime of ${id}]`;
-                }
-            }
-            else if (Array.isArray(runtime)) {
-                for (const r of runtime) {
-                    if (r !== id) {
-                        runtimes[r] = `[runtime of ${id}]`;
-                    }
-                }
-            }
+        for (const [id, runtime] of Object.entries(entries))if ('string' == typeof runtime) {
+            if (runtime !== id) runtimes[runtime] = `[runtime of ${id}]`;
+        } else if (Array.isArray(runtime)) {
+            for (const r of runtime)if (r !== id) runtimes[r] = `[runtime of ${id}]`;
         }
-        const replaceContent = (rawStr) => {
+        const replaceContent = (rawStr)=>{
             let str = rawStr;
             const replaceContentConfig = context.getTestConfig().snapshotContent;
-            if (replaceContentConfig) {
-                str = replaceContentConfig(str);
-            }
-            return (0, placeholder_1.normalizePlaceholder)(Object.entries(resultHashes)
-                .reduce((str, [raw, replacement]) => {
-                return str.split(raw).join(replacement);
-            }, str)
-                .replace(/\/\/ (\d+)\s+(?=var cssReload)/, '')
-                .replaceAll(/var data = "(?:.*)"/g, (match) => {
-                return decodeURIComponent(match).replaceAll(/\\/g, '/');
-            }));
+            if (replaceContentConfig) str = replaceContentConfig(str);
+            return (0, placeholder_js_namespaceObject.normalizePlaceholder)(Object.entries(resultHashes).reduce((str, [raw, replacement])=>str.split(raw).join(replacement), str).replace(/\/\/ (\d+)\s+(?=var cssReload)/, '').replaceAll(/var data = "(?:.*)"/g, (match)=>decodeURIComponent(match).replaceAll(/\\/g, '/')));
         };
-        const replaceFileName = (str) => {
-            return Object.entries({
+        const replaceFileName = (str)=>Object.entries({
                 ...resultHashes,
-                ...runtimes,
-            }).reduce((str, [raw, replacement]) => {
-                return str.split(raw).join(replacement);
-            }, str);
-        };
-        const assets = stats.assets.sort((a, b) => a.name.localeCompare(b.name));
-        const fileList = assets
-            .map((i) => {
+                ...runtimes
+            }).reduce((str, [raw, replacement])=>str.split(raw).join(replacement), str);
+        const assets = stats.assets.sort((a, b)=>a.name.localeCompare(b.name));
+        const fileList = assets.map((i)=>{
             const fileName = i.name;
             const renderName = replaceFileName(fileName);
-            const content = replaceContent(fs_extra_1.default.readFileSync(context.getDist(fileName), 'utf-8'));
+            const content = replaceContent(external_fs_extra_default().readFileSync(context.getDist(fileName), 'utf-8'));
             if (fileName.endsWith('hot-update.js')) {
                 const modules = getModuleHandler(context.getDist(fileName), options);
                 const runtime = [];
-                for (const i of content.matchAll(/\/\/ (webpack\/runtime\/[\w_-]+)\s*\n/g)) {
-                    runtime.push(i[1]);
-                }
+                for (const i of content.matchAll(/\/\/ (webpack\/runtime\/[\w_-]+)\s*\n/g))runtime.push(i[1]);
                 modules.sort();
                 runtime.sort();
                 hotUpdateFile.push({
                     name: renderName,
                     content,
                     modules,
-                    runtime,
+                    runtime
                 });
                 return `- Update: ${renderName}, size: ${content.length}`;
             }
@@ -125,70 +125,60 @@ function createHotStepProcessor(name, src, temp, target) {
                 manifest.m?.sort();
                 hotUpdateManifest.push({
                     name: renderName,
-                    content: JSON.stringify(manifest),
+                    content: JSON.stringify(manifest)
                 });
                 return `- Manifest: ${renderName}, size: ${i.size}`;
             }
-            if (fileName.endsWith('.js')) {
-                return `- Bundle: ${renderName}`;
-            }
-        })
-            .filter(Boolean);
+            if (fileName.endsWith('.js')) return `- Bundle: ${renderName}`;
+        }).filter(Boolean);
         fileList.sort();
-        hotUpdateManifest.sort((a, b) => (a.name > b.name ? 1 : -1));
-        hotUpdateFile.sort((a, b) => (a.name > b.name ? 1 : -1));
+        hotUpdateManifest.sort((a, b)=>a.name > b.name ? 1 : -1);
+        hotUpdateFile.sort((a, b)=>a.name > b.name ? 1 : -1);
         if (runtime?.javascript) {
             runtime.javascript.outdatedModules.sort();
             runtime.javascript.updatedModules.sort();
             runtime.javascript.updatedRuntime.sort();
             runtime.javascript.acceptedModules.sort();
             runtime.javascript.disposedModules.sort();
-            for (const value of Object.values(runtime.javascript.outdatedDependencies)) {
-                value.sort();
-            }
+            for (const value of Object.values(runtime.javascript.outdatedDependencies))value.sort();
         }
         const content = `
 # ${title}
 
 ## Changed Files
-${changedFiles.map((i) => `- ${i}`).join('\n')}
+${changedFiles.map((i)=>`- ${i}`).join('\n')}
 
 ## Asset Files
 ${fileList.join('\n')}
 
 ## Manifest
-${hotUpdateManifest
-            .map((i) => `
+${hotUpdateManifest.map((i)=>`
 ### ${i.name}
 
 \`\`\`json
 ${i.content}
 \`\`\`
-`)
-            .join('\n\n')}
+`).join('\n\n')}
 
 ## Update
 
-${hotUpdateFile
-            .map((i) => `
+${hotUpdateFile.map((i)=>`
 ### ${i.name}
 
 #### Changed Modules
-${i.modules.map((i) => `- ${i}`).join('\n')}
+${i.modules.map((i)=>`- ${i}`).join('\n')}
 
 #### Changed Runtime Modules
-${i.runtime.map((i) => `- ${i}`).join('\n')}
+${i.runtime.map((i)=>`- ${i}`).join('\n')}
 
 #### Changed Content
 \`\`\`js
 ${i.content}
 \`\`\`
-`)
-            .join('\n\n')}
+`).join('\n\n')}
 
 
-${runtime
-            ? `
+${runtime ? `
 ## Runtime
 ### Status
 
@@ -196,15 +186,14 @@ ${runtime
 ${runtime.statusPath.join(' => ')}
 \`\`\`
 
-${runtime.javascript
-                ? `
+${runtime.javascript ? `
 
 ### JavaScript
 
 #### Outdated
 
 Outdated Modules:
-${runtime.javascript.outdatedModules.map((i) => `- ${i}`).join('\n')}
+${runtime.javascript.outdatedModules.map((i)=>`- ${i}`).join('\n')}
 
 
 Outdated Dependencies:
@@ -215,114 +204,94 @@ ${JSON.stringify(runtime.javascript.outdatedDependencies || {}, null, 2)}
 #### Updated
 
 Updated Modules:
-${runtime.javascript.updatedModules.map((i) => `- ${i}`).join('\n')}
+${runtime.javascript.updatedModules.map((i)=>`- ${i}`).join('\n')}
 
 Updated Runtime:
-${runtime.javascript.updatedRuntime.map((i) => `- \`${i}\``).join('\n')}
+${runtime.javascript.updatedRuntime.map((i)=>`- \`${i}\``).join('\n')}
 
 
 #### Callback
 
 Accepted Callback:
-${runtime.javascript.acceptedModules.map((i) => `- ${i}`).join('\n')}
+${runtime.javascript.acceptedModules.map((i)=>`- ${i}`).join('\n')}
 
 Disposed Callback:
-${runtime.javascript.disposedModules.map((i) => `- ${i}`).join('\n')}
-`
-                : ''}
+${runtime.javascript.disposedModules.map((i)=>`- ${i}`).join('\n')}
+` : ''}
 
-`
-            : ''}
+` : ''}
 
-				`
-            .replaceAll(/%3A(\d+)%2F/g, (match, capture) => {
-            return match.replace(capture, 'PORT');
-        })
-            .trim();
+				`.replaceAll(/%3A(\d+)%2F/g, (match, capture)=>match.replace(capture, 'PORT')).trim();
         env.expect(content).toMatchFileSnapshotSync(snapshotPath);
     }
     const originRun = processor.run;
-    processor.run = async function (env, context) {
-        context.setValue('hotUpdateStepChecker', (updateIndex, stats, runtime) => {
+    processor.run = async function(env, context) {
+        context.setValue('hotUpdateStepChecker', (updateIndex, stats, runtime)=>{
             const statsJson = stats.toJson({
                 assets: true,
-                chunks: true,
+                chunks: true
             });
-            const chunks = Array.from(
-            // Some chunk fields are missing from rspack
-            stats?.compilation.chunks || NOOP_SET);
-            for (const entry of chunks.filter((i) => i.hasRuntime())) {
-                if (!entries[entry.id] && entry.runtime) {
-                    entries[entry.id] =
-                        // Webpack uses `string | SortableSet<string>` for `entry.runtime`
-                        typeof entry.runtime === 'string'
-                            ? [entry.runtime]
-                            : Array.from(entry.runtime);
-                }
-            }
+            const chunks = Array.from(stats?.compilation.chunks || NOOP_SET);
+            for (const entry of chunks.filter((i)=>i.hasRuntime()))if (!entries[entry.id] && entry.runtime) entries[entry.id] = 'string' == typeof entry.runtime ? [
+                entry.runtime
+            ] : Array.from(entry.runtime);
             const compiler = context.getCompiler();
             const compilerOptions = compiler.getOptions();
             matchStepSnapshot(env, context, updateIndex, compilerOptions, statsJson, runtime);
             hashes.push(stats.hash);
         });
-        context.setValue('hotUpdateStepErrorChecker', (updateIndex, stats, runtime) => {
+        context.setValue('hotUpdateStepErrorChecker', (updateIndex, stats, runtime)=>{
             hashes.push(stats.hash);
         });
         await originRun(env, context);
     };
-    processor.check = async function (env, context) {
+    processor.check = function(env, context) {
         const compiler = context.getCompiler();
         const stats = compiler.getStats();
-        if (!stats || !stats.hash) {
-            env.expect(false);
-            return;
-        }
-        const statsJson = stats.toJson({ assets: true, chunks: true });
-        const chunks = Array.from(
-        // Some chunk fields are missing from rspack
-        stats?.compilation.chunks || NOOP_SET);
-        for (const entry of chunks.filter((i) => i.hasRuntime())) {
-            if (entry.runtime) {
-                entries[entry.id] =
-                    // Webpack uses `string | SortableSet<string>` for `entry.runtime`
-                    typeof entry.runtime === 'string'
-                        ? [entry.runtime]
-                        : Array.from(entry.runtime);
-            }
-        }
+        if (!stats || !stats.hash) return void env.expect(false);
+        const statsJson = stats.toJson({
+            assets: true,
+            chunks: true
+        });
+        const chunks = Array.from(stats?.compilation.chunks || NOOP_SET);
+        for (const entry of chunks.filter((i)=>i.hasRuntime()))if (entry.runtime) entries[entry.id] = 'string' == typeof entry.runtime ? [
+            entry.runtime
+        ] : Array.from(entry.runtime);
         let matchFailed = null;
         try {
             matchStepSnapshot(env, context, 0, compiler.getOptions(), statsJson);
-        }
-        catch (e) {
+        } catch (e) {
             matchFailed = e;
         }
         hashes.push(stats.hash);
-        if (matchFailed) {
-            throw matchFailed;
-        }
+        if (matchFailed) throw matchFailed;
     };
     return processor;
 }
 function getCreator(target) {
-    if (!creators.has(target)) {
-        creators.set(target, new creator_1.BasicCaseCreator({
-            clean: true,
-            describe: false,
-            target,
-            steps: ({ name, target, src, temp, dist }) => [
-                createHotStepProcessor(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: false,
+        target,
+        steps: ({ name, target, src, temp, dist })=>[
+                createHotStepProcessor(name, src, temp || external_node_path_default().resolve(dist, 'temp'), target)
             ],
-            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 creators.get(target);
 }
 function createHotStepCase(name, src, dist, temp, target) {
     const creator = getCreator(target);
     creator.create(name, src, dist, temp);
 }
+exports.createHotStepCase = __webpack_exports__.createHotStepCase;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHotStepCase"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});