@rspack/test-tools 1.7.0-beta.1 → 1.7.0

package/dist/case/hot-step.js

@@ -11,13 +11,13 @@ const placeholder_1 = require("../helper/expect/placeholder");
 const creator_1 = require("../test/creator");
 const hot_1 = require("./hot");
 const NOOP_SET = new Set();
-const escapeLocalName = (str) => str.split(/[-<>:"/|?*.]/).join("_");
+const escapeLocalName = (str) => str.split(/[-<>:"/|?*.]/).join('_');
 const SELF_HANDLER = (file, options) => {
     let res = [];
     const hotUpdateGlobal = (_, modules) => {
         res = Object.keys(modules);
     };
-    const hotUpdateGlobalKey = escapeLocalName(`${options.output?.hotUpdateGlobal || "webpackHotUpdate"}${options.output?.uniqueName || ""}`);
+    const hotUpdateGlobalKey = escapeLocalName(`${options.output?.hotUpdateGlobal || 'webpackHotUpdate'}${options.output?.uniqueName || ''}`);
     global.self ??= {};
     global.self[hotUpdateGlobalKey] = hotUpdateGlobal;
     require(file);
@@ -30,8 +30,8 @@ const NODE_HANDLER = (file) => {
 const GET_MODULE_HANDLER = {
     web: SELF_HANDLER,
     webworker: SELF_HANDLER,
-    "async-node": NODE_HANDLER,
-    node: NODE_HANDLER
+    'async-node': NODE_HANDLER,
+    node: NODE_HANDLER,
 };
 const creators = new Map();
 function createHotStepProcessor(name, src, temp, target) {
@@ -40,7 +40,7 @@ function createHotStepProcessor(name, src, temp, target) {
     const hashes = [];
     function matchStepSnapshot(env, context, step, options, stats, runtime) {
         const getModuleHandler = GET_MODULE_HANDLER[options.target];
-        env.expect(typeof getModuleHandler).toBe("function");
+        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}`;
@@ -53,14 +53,14 @@ function createHotStepProcessor(name, src, temp, target) {
                 .map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(temp, i)));
         changedFiles.sort();
         const resultHashes = {
-            [lastHash || "LAST_HASH"]: "LAST_HASH",
-            [stats.hash]: "CURRENT_HASH"
+            [lastHash || 'LAST_HASH']: 'LAST_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 (typeof runtime === 'string') {
                 if (runtime !== id) {
                     runtimes[runtime] = `[runtime of ${id}]`;
                 }
@@ -83,26 +83,26 @@ function createHotStepProcessor(name, src, temp, target) {
                 .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, "/");
+                .replace(/\/\/ (\d+)\s+(?=var cssReload)/, '')
+                .replaceAll(/var data = "(?:.*)"/g, (match) => {
+                return decodeURIComponent(match).replaceAll(/\\/g, '/');
             }));
         };
         const replaceFileName = (str) => {
             return Object.entries({
                 ...resultHashes,
-                ...runtimes
+                ...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 => {
+            .map((i) => {
             const fileName = i.name;
             const renderName = replaceFileName(fileName);
-            const content = replaceContent(fs_extra_1.default.readFileSync(context.getDist(fileName), "utf-8"));
-            if (fileName.endsWith("hot-update.js")) {
+            const content = replaceContent(fs_extra_1.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)) {
@@ -114,22 +114,22 @@ function createHotStepProcessor(name, src, temp, target) {
                     name: renderName,
                     content,
                     modules,
-                    runtime
+                    runtime,
                 });
                 return `- Update: ${renderName}, size: ${content.length}`;
             }
-            if (fileName.endsWith("hot-update.json")) {
+            if (fileName.endsWith('hot-update.json')) {
                 const manifest = JSON.parse(content);
                 manifest.c?.sort();
                 manifest.r?.sort();
                 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")) {
+            if (fileName.endsWith('.js')) {
                 return `- Bundle: ${renderName}`;
             }
         })
@@ -151,40 +151,40 @@ function createHotStepProcessor(name, src, temp, target) {
 # ${title}
 
 ## Changed Files
-${changedFiles.map(i => `- ${i}`).join("\n")}
+${changedFiles.map((i) => `- ${i}`).join('\n')}
 
 ## Asset Files
-${fileList.join("\n")}
+${fileList.join('\n')}
 
 ## Manifest
 ${hotUpdateManifest
-            .map(i => `
+            .map((i) => `
 ### ${i.name}
 
 \`\`\`json
 ${i.content}
 \`\`\`
 `)
-            .join("\n\n")}
+            .join('\n\n')}
 
 ## Update
 
 ${hotUpdateFile
-            .map(i => `
+            .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
@@ -193,7 +193,7 @@ ${runtime
 ### Status
 
 \`\`\`txt
-${runtime.statusPath.join(" => ")}
+${runtime.statusPath.join(' => ')}
 \`\`\`
 
 ${runtime.javascript
@@ -204,7 +204,7 @@ ${runtime.javascript
 #### Outdated
 
 Outdated Modules:
-${runtime.javascript.outdatedModules.map(i => `- ${i}`).join("\n")}
+${runtime.javascript.outdatedModules.map((i) => `- ${i}`).join('\n')}
 
 
 Outdated Dependencies:
@@ -215,47 +215,47 @@ ${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");
+            return 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) => {
+        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())) {
+            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"
+                        typeof entry.runtime === 'string'
                             ? [entry.runtime]
                             : Array.from(entry.runtime);
                 }
@@ -265,7 +265,7 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
             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);
@@ -281,11 +281,11 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
         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())) {
+        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"
+                    typeof entry.runtime === 'string'
                         ? [entry.runtime]
                         : Array.from(entry.runtime);
             }
@@ -311,13 +311,13 @@ function getCreator(target) {
             describe: false,
             target,
             steps: ({ name, target, src, temp, dist }) => [
-                createHotStepProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
+                createHotStepProcessor(name, src, temp || node_path_1.default.resolve(dist, 'temp'), target),
             ],
             runner: {
                 key: (context, name, file) => name,
-                runner: hot_1.createHotRunner
+                runner: hot_1.createHotRunner,
             },
-            concurrent: true
+            concurrent: true,
         }));
     }
     return creators.get(target);

package/dist/case/hot.d.ts

@@ -1,9 +1,9 @@
-import { type RspackOptions } from "@rspack/core";
-import { HotUpdatePlugin } from "../helper/hot-update/plugin";
-import type { ITestContext, ITestEnv, ITestProcessor, ITestRunner } from "../type";
-type TTarget = RspackOptions["target"];
+import { type RspackOptions } from '@rspack/core';
+import { HotUpdatePlugin } from '../helper/hot-update/plugin';
+import type { ITestContext, ITestEnv, ITestProcessor, ITestRunner } from '../type';
+type TTarget = RspackOptions['target'];
 export declare function createHotProcessor(name: string, src: string, temp: string, target: TTarget, incremental?: boolean): THotProcessor;
-export declare function createHotCase(name: string, src: string, dist: string, temp: string, target: RspackOptions["target"]): void;
+export declare function createHotCase(name: string, src: string, dist: string, temp: string, target: RspackOptions['target']): void;
 type THotProcessor = ITestProcessor & {
     updatePlugin: HotUpdatePlugin;
 };

package/dist/case/hot.js

@@ -22,16 +22,16 @@ function createHotProcessor(name, src, temp, target, incremental = false) {
     const processor = {
         before: async (context) => {
             await updatePlugin.initialize();
-            context.setValue("hotUpdatePlugin", updatePlugin);
+            context.setValue('hotUpdatePlugin', updatePlugin);
         },
         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, common_1.config)(context, name, ['rspack.config.js', 'webpack.config.js'], options);
             overrideOptions(context, options, target, updatePlugin);
             if (incremental) {
                 options.experiments ??= {};
-                options.experiments.incremental ??= "advance-silent";
+                options.experiments.incremental ??= 'advance-silent';
             }
             compiler.setOptions(options);
         },
@@ -42,7 +42,7 @@ function createHotProcessor(name, src, temp, target, incremental = false) {
             await (0, common_1.build)(context, name);
         },
         run: async (env, context) => {
-            await (0, common_1.run)(env, context, name, context => findBundle(context, name, target, updatePlugin));
+            await (0, common_1.run)(env, context, name, (context) => findBundle(context, name, target, updatePlugin));
         },
         check: async (env, context) => {
             await (0, common_1.check)(env, context, name);
@@ -59,7 +59,7 @@ function createHotProcessor(name, src, temp, target, incremental = false) {
             if (updateIndex + 1 !== totalUpdates) {
                 throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
             }
-        }
+        },
     };
     processor.updatePlugin = updatePlugin;
     return processor;
@@ -71,13 +71,13 @@ function getCreator(target) {
             describe: true,
             target,
             steps: ({ name, target, src, dist, temp }) => [
-                createHotProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
+                createHotProcessor(name, src, temp || node_path_1.default.resolve(dist, 'temp'), target),
             ],
             runner: {
                 key: (context, name, file) => name,
-                runner: createHotRunner
+                runner: createHotRunner,
             },
-            concurrent: true
+            concurrent: true,
         }));
     }
     return creators.get(target);
@@ -89,29 +89,29 @@ function createHotCase(name, src, dist, temp, target) {
 function defaultOptions(context, target) {
     const options = {
         context: context.getSource(),
-        mode: "development",
+        mode: 'development',
         devtool: false,
         output: {
             path: context.getDist(),
-            filename: "bundle.js",
-            chunkFilename: "[name].chunk.[fullhash].js",
-            publicPath: "https://test.cases/path/",
-            library: { type: "commonjs2" }
+            filename: 'bundle.js',
+            chunkFilename: '[name].chunk.[fullhash].js',
+            publicPath: 'https://test.cases/path/',
+            library: { type: 'commonjs2' },
         },
         optimization: {
-            moduleIds: "named"
+            moduleIds: 'named',
         },
         target,
         experiments: {
             css: true,
             // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
-            incremental: "safe",
+            incremental: 'safe',
             rspackFuture: {
                 bundlerInfo: {
-                    force: false
-                }
-            }
-        }
+                    force: false,
+                },
+            },
+        },
     };
     options.plugins ??= [];
     options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
@@ -119,20 +119,20 @@ function defaultOptions(context, target) {
 }
 function overrideOptions(context, options, target, updatePlugin) {
     if (!options.entry) {
-        options.entry = "./index.js";
+        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";
+            target === 'async-node';
     }
     options.plugins ??= [];
     options.plugins.push(updatePlugin);
     if (!global.printLogger) {
         options.infrastructureLogging = {
-            level: "error"
+            level: 'error',
         };
     }
     if (options.lazyCompilation) {
@@ -142,18 +142,18 @@ function overrideOptions(context, options, target, updatePlugin) {
 function findBundle(context, name, target, updatePlugin) {
     const compiler = context.getCompiler();
     if (!compiler)
-        throw new Error("Compiler should exists when find bundle");
+        throw new Error('Compiler should exists when find bundle');
     const testConfig = context.getTestConfig();
-    if (typeof testConfig.findBundle === "function") {
+    if (typeof testConfig.findBundle === 'function') {
         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");
+        throw new Error('Stats should exists when find bundle');
     const info = stats.toJson({ all: false, entrypoints: true });
-    if (target === "web" || target === "webworker") {
+    if (target === 'web' || target === 'webworker') {
         for (const file of info.entrypoints.main.assets) {
             if ((0, helper_1.isJavaScript)(file.name)) {
                 files.push(file.name);
@@ -164,7 +164,7 @@ function findBundle(context, name, target, updatePlugin) {
         }
     }
     else {
-        const assets = info.entrypoints.main.assets.filter(s => (0, helper_1.isJavaScript)(s.name));
+        const assets = info.entrypoints.main.assets.filter((s) => (0, helper_1.isJavaScript)(s.name));
         files.push(assets[assets.length - 1].name);
     }
     return [...prefiles, ...files];
@@ -175,28 +175,28 @@ function createHotRunner(context, name, file, env) {
     const testConfig = context.getTestConfig();
     const source = context.getSource();
     const dist = context.getDist();
-    const updatePlugin = context.getValue("hotUpdatePlugin");
+    const updatePlugin = context.getValue('hotUpdatePlugin');
     const nextHMR = async (m, options) => {
         await updatePlugin.goNext();
         const stats = await compiler.build();
         if (!stats) {
-            throw new Error("Should generate stats during build");
+            throw new Error('Should generate stats during build');
         }
         const jsonStats = stats.toJson({
         // errorDetails: true
         });
         const compilerOptions = compiler.getOptions();
         const checker = context.getValue(jsonStats.errors?.length
-            ? "hotUpdateStepErrorChecker"
-            : "hotUpdateStepChecker");
+            ? 'hotUpdateStepErrorChecker'
+            : 'hotUpdateStepChecker');
         if (checker) {
-            checker(updatePlugin.getUpdateIndex(), stats, runner.getGlobal("__HMR_UPDATED_RUNTIME__"));
+            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);
+        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 updatedModules = await m.hot.check(options || true);
         if (!updatedModules) {
-            throw new Error("No update available");
+            throw new Error('No update available');
         }
         return jsonStats;
     };
@@ -209,24 +209,24 @@ function createHotRunner(context, name, file, env) {
             ...testConfig,
             moduleScope(ms, stats, options) {
                 const moduleScope = ms;
-                if (typeof testConfig.moduleScope === "function") {
+                if (typeof testConfig.moduleScope === 'function') {
                     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") {
+    if (compilerOptions.target === 'web' ||
+        compilerOptions.target === 'webworker') {
         runner = new runner_1.WebRunner({
-            location: testConfig.location || "https://test.cases/path/index.html",
-            ...commonOptions
+            location: testConfig.location || 'https://test.cases/path/index.html',
+            ...commonOptions,
         });
     }
     else {

package/dist/case/incremental.d.ts

@@ -1,5 +1,5 @@
-import type { RspackOptions } from "@rspack/core";
-export declare function createHotIncrementalCase(name: string, src: string, dist: string, temp: string, target: RspackOptions["target"], webpackCases: boolean): void;
+import type { RspackOptions } from '@rspack/core';
+export declare function createHotIncrementalCase(name: string, src: string, dist: string, temp: string, target: RspackOptions['target'], webpackCases: boolean): void;
 export type WatchIncrementalOptions = {
     ignoreNotFriendlyForIncrementalWarnings?: boolean;
 };

package/dist/case/incremental.js

@@ -22,13 +22,13 @@ function getHotCreator(target, webpackCases) {
             describe: true,
             target,
             steps: ({ name, target, src, temp, dist }) => [
-                createHotIncrementalProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target, webpackCases)
+                createHotIncrementalProcessor(name, src, temp || node_path_1.default.resolve(dist, 'temp'), target, webpackCases),
             ],
             runner: {
                 key: (context, name, file) => name,
-                runner: hot_1.createHotRunner
+                runner: hot_1.createHotRunner,
             },
-            concurrent: true
+            concurrent: true,
         }));
     }
     return hotCreators.get(key);
@@ -45,7 +45,7 @@ function getWatchCreator(options) {
             clean: true,
             runner: {
                 key: watch_1.getWatchRunnerKey,
-                runner: watch_1.createWatchRunner
+                runner: watch_1.createWatchRunner,
             },
             description: (name, index) => {
                 return index === 0
@@ -58,17 +58,17 @@ function getWatchCreator(options) {
                 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 }));
+                    .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
+                        incremental: true,
                     })
                     : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
-                        incremental: true
+                        incremental: true,
                     }));
             },
-            concurrent: true
+            concurrent: true,
         }));
     }
     return watchCreators.get(key);

package/dist/case/index.d.ts

@@ -1,31 +1,31 @@
-export { createBuiltinCase } from "./builtin";
-export { createCacheCase } from "./cache";
-export type { TCompilerCaseConfig } from "./compiler";
-export { createCompilerCase } from "./compiler";
-export type { TConfigCaseConfig } from "./config";
-export { createConfigCase } from "./config";
-export type { TDefaultsCaseConfig } from "./defaults";
-export { createDefaultsCase, getRspackDefaultConfig } from "./defaults";
-export type { TDiagnosticOptions } from "./diagnostic";
-export { createDiagnosticCase } from "./diagnostic";
-export type { TErrorCaseConfig } from "./error";
-export { createErrorCase } from "./error";
-export { createEsmOutputCase } from "./esm-output";
-export { createExampleCase } from "./example";
-export type { THashCaseConfig } from "./hash";
-export { createHashCase } from "./hash";
-export type { THookCaseConfig } from "./hook";
-export { createHookCase } from "./hook";
-export { createHotCase } from "./hot";
-export { createHotStepCase } from "./hot-step";
-export { createHotIncrementalCase, createWatchIncrementalCase } from "./incremental";
-export type { TMultiCompilerCaseConfig } from "./multi-compiler";
-export { createMultiCompilerCase } from "./multi-compiler";
-export { createNativeWatcher } from "./native-watcher";
-export { createDevNormalCase, createHotNormalCase, createNormalCase, createProdNormalCase } from "./normal";
-export { createSerialCase } from "./serial";
-export type { TStatsAPICaseConfig } from "./stats-api";
-export { createStatsAPICase } from "./stats-api";
-export { createStatsOutputCase } from "./stats-output";
-export { createTreeShakingCase } from "./treeshaking";
-export { createWatchCase } from "./watch";
+export { createBuiltinCase } from './builtin';
+export { createCacheCase } from './cache';
+export type { TCompilerCaseConfig } from './compiler';
+export { createCompilerCase } from './compiler';
+export type { TConfigCaseConfig } from './config';
+export { createConfigCase } from './config';
+export type { TDefaultsCaseConfig } from './defaults';
+export { createDefaultsCase, getRspackDefaultConfig } from './defaults';
+export type { TDiagnosticOptions } from './diagnostic';
+export { createDiagnosticCase } from './diagnostic';
+export type { TErrorCaseConfig } from './error';
+export { createErrorCase } from './error';
+export { createEsmOutputCase } from './esm-output';
+export { createExampleCase } from './example';
+export type { THashCaseConfig } from './hash';
+export { createHashCase } from './hash';
+export type { THookCaseConfig } from './hook';
+export { createHookCase } from './hook';
+export { createHotCase } from './hot';
+export { createHotStepCase } from './hot-step';
+export { createHotIncrementalCase, createWatchIncrementalCase, } from './incremental';
+export type { TMultiCompilerCaseConfig } from './multi-compiler';
+export { createMultiCompilerCase } from './multi-compiler';
+export { createNativeWatcher } from './native-watcher';
+export { createDevNormalCase, createHotNormalCase, createNormalCase, createProdNormalCase, } from './normal';
+export { createSerialCase } from './serial';
+export type { TStatsAPICaseConfig } from './stats-api';
+export { createStatsAPICase } from './stats-api';
+export { createStatsOutputCase } from './stats-output';
+export { createTreeShakingCase } from './treeshaking';
+export { createWatchCase } from './watch';