@rspack/test-tools 1.5.8 → 1.6.0-beta.0

package/dist/case/builtin.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinCase = createBuiltinCase;
 exports.defaultOptions = defaultOptions;
 const node_path_1 = __importDefault(require("node:path"));
-const core_1 = require("@rspack/core");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const webpack_merge_1 = require("webpack-merge");
 const helper_1 = require("../helper");
@@ -164,27 +163,6 @@ function defaultOptions(context) {
         }
         defaultOptions = (0, webpack_merge_1.merge)(defaultOptions, caseOptions);
     }
-    // TODO: remove builtin compatible code
-    const defineOptions = defaultOptions.builtins?.define;
-    if (defineOptions) {
-        defaultOptions.plugins.push(new core_1.rspack.DefinePlugin(defineOptions));
-    }
-    const provideOptions = defaultOptions.builtins?.provide;
-    if (provideOptions) {
-        defaultOptions.plugins.push(new core_1.rspack.ProvidePlugin(provideOptions));
-    }
-    const htmlOptions = defaultOptions.builtins?.html;
-    if (htmlOptions) {
-        if (Array.isArray(htmlOptions)) {
-            for (const item of htmlOptions) {
-                defaultOptions.plugins.push(new core_1.rspack.HtmlRspackPlugin(item));
-            }
-        }
-        else {
-            defaultOptions.plugins.push(new core_1.rspack.HtmlRspackPlugin(htmlOptions));
-        }
-    }
-    delete defaultOptions.builtins;
     if (!global.printLogger) {
         defaultOptions.infrastructureLogging = {
             level: "error"

package/dist/case/cache.js

@@ -98,8 +98,7 @@ function defaultOptions(context, temp, target) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
     options.plugins ??= [];

package/dist/case/common.js

@@ -81,7 +81,11 @@ async function run(env, context, name, findBundle) {
     const results = context.getValue(name, "modules") || [];
     await Promise.all(results);
     if (typeof testConfig.afterExecute === "function") {
-        testConfig.afterExecute(compiler.getOptions());
+        let options = compiler.getOptions();
+        if (Array.isArray(options) && options.length === 1) {
+            options = options[0];
+        }
+        testConfig.afterExecute(options);
     }
 }
 async function check(env, context, name) {

package/dist/case/config.js

@@ -77,8 +77,7 @@ function defaultOptions(index, context) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
 }

package/dist/case/diagnostic.d.ts

@@ -1,7 +1,7 @@
 export declare function createDiagnosticCase(name: string, src: string, dist: string): void;
-export interface IDiagnosticOptions {
+export type TDiagnosticOptions = {
     snapshot: string;
     snapshotErrors: string;
     snapshotWarning: string;
     format?: (output: string) => string;
-}
+};

package/dist/case/diagnostic.js

@@ -84,8 +84,7 @@ function defaultOptions(context) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
 }

package/dist/case/error.d.ts

@@ -8,6 +8,7 @@ declare class RspackStatsDiagnostics {
 }
 export type TErrorCaseConfig = {
     description: string;
+    skip?: boolean;
     options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
     compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
     build?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;

package/dist/case/error.js

@@ -49,15 +49,29 @@ function createErrorCase(name, src, dist, testConfig) {
     if (!addedSerializer) {
         addedSerializer = true;
     }
-    const caseConfig = require(testConfig);
-    creator.create(name, src, dist, undefined, {
-        caseConfig,
-        description: () => caseConfig.description
-    });
+    const caseConfigList = require(testConfig);
+    function createCase(caseConfig) {
+        if (caseConfig.skip) {
+            it.skip(name, () => { });
+            return;
+        }
+        creator.create(name, src, dist, undefined, {
+            caseConfig,
+            description: () => caseConfig.description
+        });
+    }
+    if (Array.isArray(caseConfigList)) {
+        for (const caseConfig of caseConfigList) {
+            createCase(caseConfig);
+        }
+    }
+    else {
+        createCase(caseConfigList);
+    }
 }
 function options(context, custom) {
     let options = {
-        context: node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/fixtures/errors"),
+        context: node_path_1.default.resolve(__TEST_FIXTURES_PATH__, "errors"),
         mode: "none",
         devtool: false,
         optimization: {
@@ -116,6 +130,11 @@ class RspackStatsDiagnostics {
     }
 }
 async function check(env, context, name, check) {
+    if (context.getError(name).length > 0) {
+        await check?.(new RspackStatsDiagnostics(context.getError(name), []));
+        context.clearError(name);
+        return;
+    }
     const compiler = (0, common_1.getCompiler)(context, name);
     const stats = compiler.getStats();
     env.expect(typeof stats).toBe("object");

package/dist/case/example.d.ts

@@ -0,0 +1 @@
+export declare function createExampleCase(name: string, src: string): void;

package/dist/case/example.js

@@ -0,0 +1,57 @@
+"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");
+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 = [];
+}
+function createExampleProcessor(name) {
+    return {
+        config: async (context) => {
+            (0, common_1.configMultiCompiler)(context, name, ["rspack.config.js", "webpack.config.js"], () => ({}), 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 the building
+        },
+        check: async (env, context) => {
+            const compiler = (0, common_1.getCompiler)(context, name);
+            const stats = compiler.getStats();
+            if (stats?.hasErrors()) {
+                console.log(stats.toString({
+                    all: false,
+                    errors: true,
+                    errorDetails: true,
+                    errorStacks: true
+                }));
+            }
+            expect(stats?.hasErrors()).toBe(false);
+        }
+    };
+}
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    steps: ({ name }) => [createExampleProcessor(name)],
+    concurrent: true
+});
+function createExampleCase(name, src) {
+    creator.create(name, src, node_path_1.default.join(src, "dist"));
+}

package/dist/case/hash.js

@@ -53,8 +53,7 @@ function defaultOptions(index, context) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
 }

package/dist/case/hook.js

@@ -14,8 +14,8 @@ const webpack_merge_1 = __importDefault(require("webpack-merge"));
 const context_1 = require("../test/context");
 const creator_1 = require("../test/creator");
 const common_1 = require("./common");
-const srcDir = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/fixtures");
-const distDir = node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/js/hook");
+const srcDir = __TEST_FIXTURES_PATH__;
+const distDir = node_path_1.default.resolve(__TEST_DIST_PATH__, "hook");
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
     describe: true,
@@ -213,8 +213,7 @@ function defaultOptions(context, custom) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
     if (custom) {

package/dist/case/hot-step.d.ts

@@ -1,2 +1,2 @@
 import { ECompilerType, type TCompilerOptions } from "../type";
-export declare function createHotStepCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
+export declare function createHotStepCase(name: string, src: string, dist: string, temp: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;

package/dist/case/hot-step.js

@@ -39,8 +39,8 @@ const GET_MODULE_HANDLER = {
     node: NODE_HANDLER
 };
 const creators = new Map();
-function createHotStepProcessor(name, target) {
-    const processor = (0, hot_1.createHotProcessor)(name, target);
+function createHotStepProcessor(name, src, temp, target) {
+    const processor = (0, hot_1.createHotProcessor)(name, src, temp, target);
     const entries = {};
     const hashes = [];
     function matchStepSnapshot(env, context, step, options, stats, runtime) {
@@ -53,7 +53,9 @@ function createHotStepProcessor(name, target) {
         const hotUpdateManifest = [];
         const changedFiles = step === 0
             ? []
-            : processor.hotUpdateContext.changedFiles.map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(context.getSource(), i)));
+            : processor.updatePlugin
+                .getModifiedFiles()
+                .map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(temp, i)));
         changedFiles.sort();
         const resultHashes = {
             [lastHash || "LAST_HASH"]: "LAST_HASH",
@@ -245,7 +247,7 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
     }
     const originRun = processor.run;
     processor.run = async function (env, context) {
-        context.setValue(name, "hotUpdateStepChecker", (hotUpdateContext, stats, runtime) => {
+        context.setValue(name, "hotUpdateStepChecker", (updateIndex, stats, runtime) => {
             const statsJson = stats.toJson({
                 assets: true,
                 chunks: true
@@ -264,10 +266,10 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
             }
             const compiler = context.getCompiler(name, type_1.ECompilerType.Rspack);
             const compilerOptions = compiler.getOptions();
-            matchStepSnapshot(env, context, hotUpdateContext.updateIndex, compilerOptions, statsJson, runtime);
+            matchStepSnapshot(env, context, updateIndex, compilerOptions, statsJson, runtime);
             hashes.push(stats.hash);
         });
-        context.setValue(name, "hotUpdateStepErrorChecker", (_, stats, runtime) => {
+        context.setValue(name, "hotUpdateStepErrorChecker", (updateIndex, stats, runtime) => {
             hashes.push(stats.hash);
         });
         await originRun(env, context);
@@ -312,8 +314,8 @@ function getCreator(target) {
             clean: true,
             describe: false,
             target,
-            steps: ({ name, target }) => [
-                createHotStepProcessor(name, target)
+            steps: ({ name, target, src, temp, dist }) => [
+                createHotStepProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
             ],
             runner: {
                 key: (context, name, file) => name,
@@ -324,7 +326,7 @@ function getCreator(target) {
     }
     return creators.get(target);
 }
-function createHotStepCase(name, src, dist, target) {
+function createHotStepCase(name, src, dist, temp, target) {
     const creator = getCreator(target);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }

package/dist/case/hot.d.ts

@@ -1,9 +1,10 @@
-import { type ECompilerType, type ITestContext, type ITestEnv, type ITestProcessor, type ITestRunner, type TCompilerOptions, type THotUpdateContext } from "../type";
+import { HotUpdatePlugin } from "../helper/hot-update/plugin";
+import { type ECompilerType, type ITestContext, type ITestEnv, type ITestProcessor, type ITestRunner, type TCompilerOptions } from "../type";
 type TTarget = TCompilerOptions<ECompilerType.Rspack>["target"];
-export declare function createHotProcessor(name: string, target: TTarget, incremental?: boolean): THotProcessor;
-export declare function createHotCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
+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: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
 type THotProcessor = ITestProcessor & {
-    hotUpdateContext: THotUpdateContext;
+    updatePlugin: HotUpdatePlugin;
 };
 export declare function createHotRunner<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
 export {};

package/dist/case/hot.js

@@ -9,27 +9,27 @@ 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 plugins_1 = require("../helper/plugins");
-const plugin_1 = require("../plugin");
+const plugin_2 = require("../plugin");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
 const common_1 = require("./common");
 const runner_2 = require("./runner");
 const creators = new Map();
-function createHotProcessor(name, target, incremental = false) {
-    const hotUpdateContext = {
-        updateIndex: 0,
-        totalUpdates: 1,
-        changedFiles: []
-    };
+function createHotProcessor(name, src, temp, target, incremental = false) {
+    const updatePlugin = new plugin_1.HotUpdatePlugin(src, temp);
     const processor = {
+        before: async (context) => {
+            await updatePlugin.initialize();
+            context.setValue(name, "hotUpdatePlugin", updatePlugin);
+        },
         config: async (context) => {
             const compiler = (0, common_1.getCompiler)(context, name);
-            let options = defaultOptions(context, target, hotUpdateContext);
+            let options = defaultOptions(context, target);
             options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
-            overrideOptions(context, options, target, hotUpdateContext);
+            overrideOptions(context, options, target, updatePlugin);
             if (incremental) {
                 options.experiments ??= {};
                 options.experiments.incremental ??= "advance-silent";
@@ -43,8 +43,7 @@ function createHotProcessor(name, target, incremental = false) {
             await (0, common_1.build)(context, name);
         },
         run: async (env, context) => {
-            context.setValue(name, "hotUpdateContext", hotUpdateContext);
-            await (0, common_1.run)(env, context, name, context => findBundle(context, name, target, hotUpdateContext));
+            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);
@@ -53,12 +52,14 @@ function createHotProcessor(name, target, incremental = false) {
             if (context.getTestConfig().checkSteps === false) {
                 return;
             }
-            if (hotUpdateContext.updateIndex + 1 !== hotUpdateContext.totalUpdates) {
-                throw new Error(`Should run all hot steps (${hotUpdateContext.updateIndex + 1} / ${hotUpdateContext.totalUpdates}): ${name}`);
+            const updateIndex = updatePlugin.getUpdateIndex();
+            const totalUpdates = updatePlugin.getTotalUpdates();
+            if (updateIndex + 1 !== totalUpdates) {
+                throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
             }
         }
     };
-    processor.hotUpdateContext = hotUpdateContext;
+    processor.updatePlugin = updatePlugin;
     return processor;
 }
 function getCreator(target) {
@@ -67,8 +68,8 @@ function getCreator(target) {
             clean: true,
             describe: true,
             target,
-            steps: ({ name, target }) => [
-                createHotProcessor(name, target)
+            steps: ({ name, target, src, dist, temp }) => [
+                createHotProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
             ],
             runner: {
                 key: (context, name, file) => name,
@@ -79,11 +80,11 @@ function getCreator(target) {
     }
     return creators.get(target);
 }
-function createHotCase(name, src, dist, target) {
+function createHotCase(name, src, dist, temp, target) {
     const creator = getCreator(target);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }
-function defaultOptions(context, target, updateOptions) {
+function defaultOptions(context, target) {
     const options = {
         context: context.getSource(),
         mode: "development",
@@ -108,15 +109,14 @@ function defaultOptions(context, target, updateOptions) {
                     force: false
                 }
             },
-            inlineConst: true,
-            lazyBarrel: true
+            inlineConst: true
         }
     };
     options.plugins ??= [];
-    options.plugins.push(new core_1.default.HotModuleReplacementPlugin(), new plugins_1.TestHotUpdatePlugin(updateOptions));
+    options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
     return options;
 }
-function overrideOptions(context, options, target, updateOptions) {
+function overrideOptions(context, options, target, updatePlugin) {
     if (!options.entry) {
         options.entry = "./index.js";
     }
@@ -127,34 +127,24 @@ function overrideOptions(context, options, target, updateOptions) {
         options.module.generator[cssModuleType].exportsOnly ??=
             target === "async-node";
     }
-    options.module.rules ??= [];
-    options.module.rules.push({
-        use: [
-            {
-                loader: node_path_1.default.resolve(__dirname, "../helper/loaders/hot-update.js"),
-                options: updateOptions
-            }
-        ],
-        enforce: "pre"
-    });
     options.plugins ??= [];
-    options.plugins.push(new core_1.default.LoaderOptionsPlugin(updateOptions));
+    options.plugins.push(updatePlugin);
     if (!global.printLogger) {
         options.infrastructureLogging = {
             level: "error"
         };
     }
     if (options.lazyCompilation) {
-        options.plugins.push(new plugin_1.LazyCompilationTestPlugin());
+        options.plugins.push(new plugin_2.LazyCompilationTestPlugin());
     }
 }
-function findBundle(context, name, target, updateOptions) {
+function findBundle(context, name, target, updatePlugin) {
     const compiler = context.getCompiler(name);
     if (!compiler)
         throw new Error("Compiler should exists when find bundle");
     const testConfig = context.getTestConfig();
     if (typeof testConfig.findBundle === "function") {
-        return testConfig.findBundle(updateOptions.updateIndex, compiler.getOptions());
+        return testConfig.findBundle(updatePlugin.getUpdateIndex(), compiler.getOptions());
     }
     const files = [];
     const prefiles = [];
@@ -184,11 +174,11 @@ function createHotRunner(context, name, file, env) {
     const testConfig = context.getTestConfig();
     const source = context.getSource();
     const dist = context.getDist();
-    const hotUpdateContext = context.getValue(name, "hotUpdateContext");
+    const updatePlugin = context.getValue(name, "hotUpdatePlugin");
     const next = async (callback) => {
         const usePromise = typeof callback === "function";
         try {
-            hotUpdateContext.updateIndex++;
+            await updatePlugin.goNext();
             const stats = await compiler.build();
             if (!stats) {
                 throw new Error("Should generate stats during build");
@@ -201,10 +191,10 @@ function createHotRunner(context, name, file, env) {
                 ? "hotUpdateStepErrorChecker"
                 : "hotUpdateStepChecker");
             if (checker) {
-                checker(hotUpdateContext, stats, runner.getGlobal("__HMR_UPDATED_RUNTIME__"));
+                checker(updatePlugin.getUpdateIndex(), stats, runner.getGlobal("__HMR_UPDATED_RUNTIME__"));
             }
-            await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${hotUpdateContext.updateIndex}`, "Error", compilerOptions);
-            await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${hotUpdateContext.updateIndex}`, "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);
             if (usePromise) {
                 // old callback style hmr cases
                 callback(null, jsonStats);

package/dist/case/incremental.d.ts

@@ -1,5 +1,5 @@
 import { type ECompilerType, type TCompilerOptions } from "../type";
-export declare function createHotIncrementalCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], webpackCases: boolean): void;
+export declare function createHotIncrementalCase(name: string, src: string, dist: string, temp: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], webpackCases: boolean): void;
 export type WatchIncrementalOptions = {
     ignoreNotFriendlyForIncrementalWarnings?: boolean;
 };

package/dist/case/incremental.js

@@ -12,9 +12,11 @@ const type_1 = require("../type");
 const hot_1 = require("./hot");
 const watch_1 = require("./watch");
 const hotCreators = new Map();
-function createHotIncrementalProcessor(name, target, webpackCases) {
-    const processor = (0, hot_1.createHotProcessor)(name, target, true);
+function createHotIncrementalProcessor(name, src, temp, target, webpackCases) {
+    const processor = (0, hot_1.createHotProcessor)(name, src, temp, target, true);
+    const originalBefore = processor.before;
     processor.before = async (context) => {
+        await originalBefore?.(context);
         context.setValue(name, "documentType", webpackCases ? type_1.EDocumentType.Fake : type_1.EDocumentType.JSDOM);
     };
     const originalAfterAll = processor.afterAll;
@@ -38,8 +40,8 @@ function getHotCreator(target, webpackCases) {
             clean: true,
             describe: true,
             target,
-            steps: ({ name, target }) => [
-                createHotIncrementalProcessor(name, target, webpackCases)
+            steps: ({ name, target, src, temp, dist }) => [
+                createHotIncrementalProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target, webpackCases)
             ],
             runner: {
                 key: (context, name, file) => name,
@@ -50,9 +52,9 @@ function getHotCreator(target, webpackCases) {
     }
     return hotCreators.get(key);
 }
-function createHotIncrementalCase(name, src, dist, target, webpackCases) {
+function createHotIncrementalCase(name, src, dist, temp, target, webpackCases) {
     const creator = getHotCreator(target, webpackCases);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }
 const watchCreators = new Map();
 function getWatchCreator(options) {
@@ -79,12 +81,10 @@ function getWatchCreator(options) {
                     .map(name => ({ name }));
                 return runs.map((run, index) => index === 0
                     ? (0, watch_1.createWatchInitialProcessor)(name, temp, run.name, watchState, {
-                        incremental: true,
-                        ignoreNotFriendlyForIncrementalWarnings: options.ignoreNotFriendlyForIncrementalWarnings
+                        incremental: true
                     })
                     : (0, watch_1.createWatchStepProcessor)(name, temp, run.name, watchState, {
-                        incremental: true,
-                        ignoreNotFriendlyForIncrementalWarnings: options.ignoreNotFriendlyForIncrementalWarnings
+                        incremental: true
                     }));
             },
             concurrent: true

package/dist/case/index.d.ts

@@ -1,20 +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 { createDiffCase } from "./diff";
+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 { createHotNormalCase, createNormalCase } from "./normal";
+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";

package/dist/case/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createNormalCase = exports.createHotNormalCase = exports.createNativeWatcher = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createEsmOutputCase = exports.createErrorCase = exports.createDiffCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
+exports.createWatchCase = exports.createTreeShakingCase = exports.createStatsOutputCase = exports.createStatsAPICase = exports.createSerialCase = exports.createProdNormalCase = exports.createNormalCase = exports.createHotNormalCase = exports.createDevNormalCase = exports.createNativeWatcher = exports.createMultiCompilerCase = exports.createWatchIncrementalCase = exports.createHotIncrementalCase = exports.createHotStepCase = exports.createHotCase = exports.createHookCase = exports.createHashCase = exports.createExampleCase = exports.createEsmOutputCase = exports.createErrorCase = exports.createDiffCase = exports.createDiagnosticCase = exports.getRspackDefaultConfig = exports.createDefaultsCase = exports.createConfigCase = exports.createCompilerCase = exports.createCacheCase = exports.createBuiltinCase = void 0;
 var builtin_1 = require("./builtin");
 Object.defineProperty(exports, "createBuiltinCase", { enumerable: true, get: function () { return builtin_1.createBuiltinCase; } });
 var cache_1 = require("./cache");
@@ -20,6 +20,8 @@ var error_1 = require("./error");
 Object.defineProperty(exports, "createErrorCase", { enumerable: true, get: function () { return error_1.createErrorCase; } });
 var esm_output_1 = require("./esm-output");
 Object.defineProperty(exports, "createEsmOutputCase", { enumerable: true, get: function () { return esm_output_1.createEsmOutputCase; } });
+var example_1 = require("./example");
+Object.defineProperty(exports, "createExampleCase", { enumerable: true, get: function () { return example_1.createExampleCase; } });
 var hash_1 = require("./hash");
 Object.defineProperty(exports, "createHashCase", { enumerable: true, get: function () { return hash_1.createHashCase; } });
 var hook_1 = require("./hook");
@@ -31,11 +33,15 @@ Object.defineProperty(exports, "createHotStepCase", { enumerable: true, get: fun
 var incremental_1 = require("./incremental");
 Object.defineProperty(exports, "createHotIncrementalCase", { enumerable: true, get: function () { return incremental_1.createHotIncrementalCase; } });
 Object.defineProperty(exports, "createWatchIncrementalCase", { enumerable: true, get: function () { return incremental_1.createWatchIncrementalCase; } });
+var multi_compiler_1 = require("./multi-compiler");
+Object.defineProperty(exports, "createMultiCompilerCase", { enumerable: true, get: function () { return multi_compiler_1.createMultiCompilerCase; } });
 var native_watcher_1 = require("./native-watcher");
 Object.defineProperty(exports, "createNativeWatcher", { enumerable: true, get: function () { return native_watcher_1.createNativeWatcher; } });
 var normal_1 = require("./normal");
+Object.defineProperty(exports, "createDevNormalCase", { enumerable: true, get: function () { return normal_1.createDevNormalCase; } });
 Object.defineProperty(exports, "createHotNormalCase", { enumerable: true, get: function () { return normal_1.createHotNormalCase; } });
 Object.defineProperty(exports, "createNormalCase", { enumerable: true, get: function () { return normal_1.createNormalCase; } });
+Object.defineProperty(exports, "createProdNormalCase", { enumerable: true, get: function () { return normal_1.createProdNormalCase; } });
 var serial_1 = require("./serial");
 Object.defineProperty(exports, "createSerialCase", { enumerable: true, get: function () { return serial_1.createSerialCase; } });
 var stats_api_1 = require("./stats-api");