@rspack-canary/test-tools 1.5.7-canary-a3406c0a-20250922173625 → 1.5.8-canary-e350b761-20250924173613

package/dist/case/diff.js

@@ -7,10 +7,12 @@ exports.createDiffCase = createDiffCase;
 const node_path_1 = __importDefault(require("node:path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const rimraf_1 = require("rimraf");
+const compare_1 = require("../compare");
 const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
-const processor_1 = require("../processor");
+const plugin_1 = require("../plugin");
 const tester_1 = require("../test/tester");
 const type_1 = require("../type");
+const common_1 = require("./common");
 const DEFAULT_CASE_CONFIG = {
     webpackPath: require.resolve("webpack"),
     rspackPath: require.resolve("@rspack/core"),
@@ -63,7 +65,49 @@ function createDiffCase(name, src, dist) {
         const env = (0, createLazyTestEnv_1.default)(1000);
     });
 }
-function createDiffProcessor(config) {
+function defaultOptions(type, src, dist) {
+    return {
+        entry: node_path_1.default.join(src, "./src/index.js"),
+        context: src,
+        output: {
+            path: dist,
+            filename: "bundle.js",
+            chunkFilename: "[name].chunk.js"
+        },
+        plugins: [
+            type === type_1.ECompilerType.Webpack && new plugin_1.WebpackDiffConfigPlugin(),
+            type === type_1.ECompilerType.Rspack && new plugin_1.RspackDiffConfigPlugin()
+        ].filter(Boolean),
+        experiments: type === type_1.ECompilerType.Rspack
+            ? {
+                css: true,
+                rspackFuture: {
+                    bundlerInfo: {
+                        force: false
+                    }
+                }
+            }
+            : {}
+    };
+}
+function createFormatOptions(options, hashes) {
+    const formatOptions = {
+        ignoreModuleArguments: options.ignoreModuleArguments,
+        ignoreModuleId: options.ignoreModuleId,
+        ignorePropertyQuotationMark: options.ignorePropertyQuotationMark,
+        ignoreBlockOnlyStatement: options.ignoreBlockOnlyStatement,
+        ignoreIfCertainCondition: options.ignoreIfCertainCondition,
+        ignoreSwcHelpersPath: options.ignoreSwcHelpersPath,
+        ignoreObjectPropertySequence: options.ignoreObjectPropertySequence,
+        ignoreCssFilePath: options.ignoreCssFilePath,
+        replacements: options.replacements || []
+    };
+    for (const hash of hashes) {
+        formatOptions.replacements.push({ from: hash, to: "fullhash" });
+    }
+    return formatOptions;
+}
+function createDiffProcessor(options) {
     const fileCompareMap = new Map();
     const createCompareResultHandler = (type) => {
         return (file, results) => {
@@ -75,28 +119,132 @@ function createDiffProcessor(config) {
             fileCompareMap.set(file, fileResult);
         };
     };
-    const processor = new processor_1.DiffProcessor({
-        webpackPath: config.webpackPath,
-        rspackPath: config.rspackPath,
-        files: config.files,
-        modules: config.modules,
-        runtimeModules: config.runtimeModules,
-        renameModule: config.renameModule,
-        ignoreModuleId: config.ignoreModuleId ?? true,
-        ignoreModuleArguments: config.ignoreModuleArguments ?? true,
-        ignorePropertyQuotationMark: config.ignorePropertyQuotationMark ?? true,
-        ignoreBlockOnlyStatement: config.ignoreBlockOnlyStatement ?? true,
-        ignoreIfCertainCondition: config.ignoreIfCertainCondition ?? true,
-        ignoreSwcHelpersPath: config.ignoreSwcHelpersPath ?? true,
-        ignoreObjectPropertySequence: config.ignoreObjectPropertySequence ?? true,
-        ignoreCssFilePath: config.ignoreCssFilePath ?? true,
+    const diffOptions = {
+        webpackPath: options.webpackPath,
+        rspackPath: options.rspackPath,
+        files: options.files,
+        modules: options.modules,
+        runtimeModules: options.runtimeModules,
+        renameModule: options.renameModule,
+        ignoreModuleId: options.ignoreModuleId ?? true,
+        ignoreModuleArguments: options.ignoreModuleArguments ?? true,
+        ignorePropertyQuotationMark: options.ignorePropertyQuotationMark ?? true,
+        ignoreBlockOnlyStatement: options.ignoreBlockOnlyStatement ?? true,
+        ignoreIfCertainCondition: options.ignoreIfCertainCondition ?? true,
+        ignoreSwcHelpersPath: options.ignoreSwcHelpersPath ?? true,
+        ignoreObjectPropertySequence: options.ignoreObjectPropertySequence ?? true,
+        ignoreCssFilePath: options.ignoreCssFilePath ?? true,
         onCompareModules: createCompareResultHandler("modules"),
         onCompareRuntimeModules: createCompareResultHandler("runtimeModules"),
-        bootstrap: config.bootstrap ?? true,
-        detail: config.detail ?? true,
-        errors: config.errors ?? false,
-        replacements: config.replacements
-    });
+        bootstrap: options.bootstrap ?? true,
+        detail: options.detail ?? true,
+        errors: options.errors ?? false,
+        replacements: options.replacements
+    };
+    const hashes = [];
+    const webpackProcessor = global.updateSnapshot &&
+        {
+            config: async (context) => {
+                const compiler = (0, common_1.getCompiler)(context, type_1.ECompilerType.Webpack);
+                let options = defaultOptions(type_1.ECompilerType.Webpack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Webpack));
+                options = await (0, common_1.config)(context, type_1.ECompilerType.Webpack, ["webpack.config.js", "rspack.config.js"], options);
+                compiler.setOptions(options);
+            },
+            compiler: async (context) => {
+                await (0, common_1.compiler)(context, type_1.ECompilerType.Webpack);
+            },
+            build: async (context) => {
+                await (0, common_1.build)(context, type_1.ECompilerType.Webpack);
+            },
+            run: async (env, context) => { },
+            check: async (env, context) => {
+                await (0, common_1.check)(env, context, type_1.ECompilerType.Webpack);
+            }
+        };
+    const rspackProcessor = {
+        config: async (context) => {
+            const compiler = (0, common_1.getCompiler)(context, type_1.ECompilerType.Rspack);
+            let options = defaultOptions(type_1.ECompilerType.Rspack, context.getSource(), node_path_1.default.join(context.getDist(), type_1.ECompilerType.Rspack));
+            options = await (0, common_1.config)(context, type_1.ECompilerType.Rspack, ["rspack.config.js", "webpack.config.js"], options);
+            compiler.setOptions(options);
+        },
+        compiler: async (context) => {
+            await (0, common_1.compiler)(context, type_1.ECompilerType.Rspack);
+        },
+        build: async (context) => {
+            await (0, common_1.build)(context, type_1.ECompilerType.Rspack);
+        },
+        run: async (env, context) => { },
+        check: async (env, context) => {
+            await (0, common_1.check)(env, context, type_1.ECompilerType.Rspack);
+        }
+    };
+    const processor = {
+        config: async (context) => {
+            if (webpackProcessor) {
+                await webpackProcessor.config(context);
+            }
+            await rspackProcessor.config(context);
+        },
+        compiler: async (context) => {
+            if (webpackProcessor) {
+                await webpackProcessor.compiler(context);
+            }
+            await rspackProcessor.compiler(context);
+        },
+        build: async (context) => {
+            if (webpackProcessor) {
+                await webpackProcessor.build(context);
+            }
+            await rspackProcessor.build(context);
+        },
+        run: async (env, context) => { },
+        check: async (env, context) => {
+            if (webpackProcessor) {
+                const webpackCompiler = context.getCompiler(type_1.ECompilerType.Webpack);
+                const webpackStats = webpackCompiler.getStats();
+                //TODO: handle chunk hash and content hash
+                webpackStats?.hash && hashes.push(webpackStats?.hash);
+                if (!diffOptions.errors) {
+                    env.expect(webpackStats?.hasErrors()).toBe(false);
+                }
+            }
+            const rspackCompiler = context.getCompiler(type_1.ECompilerType.Rspack);
+            const rspackStats = rspackCompiler.getStats();
+            //TODO: handle chunk hash and content hash
+            rspackStats?.hash && hashes.push(rspackStats?.hash);
+            if (!diffOptions.errors) {
+                env.expect(rspackStats?.hasErrors()).toBe(false);
+            }
+            const dist = context.getDist();
+            const snapshot = context.getSource("__snapshot__");
+            for (const file of diffOptions.files) {
+                const rspackDist = node_path_1.default.join(dist, type_1.ECompilerType.Rspack, file);
+                const webpackDist = node_path_1.default.join(dist, type_1.ECompilerType.Webpack, file);
+                const snapshotDist = node_path_1.default.join(snapshot, file.replace(/\.js$/, ".json"));
+                const result = (0, compare_1.compareFile)(rspackDist, webpackDist, {
+                    modules: diffOptions.modules,
+                    runtimeModules: diffOptions.runtimeModules,
+                    format: createFormatOptions(diffOptions, hashes),
+                    renameModule: diffOptions.renameModule,
+                    bootstrap: diffOptions.bootstrap,
+                    detail: diffOptions.detail,
+                    snapshot: snapshotDist
+                });
+                if (typeof diffOptions.onCompareFile === "function") {
+                    diffOptions.onCompareFile(file, result);
+                }
+                if (typeof diffOptions.onCompareModules === "function" &&
+                    result.modules.modules) {
+                    diffOptions.onCompareModules(file, result.modules.modules);
+                }
+                if (typeof diffOptions.onCompareRuntimeModules === "function" &&
+                    result.modules.runtimeModules) {
+                    diffOptions.onCompareRuntimeModules(file, result.modules.runtimeModules);
+                }
+            }
+        }
+    };
     return [processor, fileCompareMap];
 }
 function checkCompareResults(name, getResults) {

package/dist/case/error.d.ts

@@ -1,6 +1,16 @@
-import { type ISimpleProcessorOptions } from "../processor";
-import { ECompilerType } from "../type";
-export type TErrorCaseConfig = Omit<ISimpleProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType"> & {
+import type { StatsError } from "@rspack/core";
+import type { ECompilerType, ITestContext, TCompiler, TCompilerOptions } from "../type";
+export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;
+declare class RspackStatsDiagnostics {
+    errors: StatsError[];
+    warnings: StatsError[];
+    constructor(errors: StatsError[], warnings: StatsError[]);
+}
+export type TErrorCaseConfig = {
     description: string;
+    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+    compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    build?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    check?: (stats: RspackStatsDiagnostics) => Promise<void>;
 };
-export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;
+export {};

package/dist/case/error.js

@@ -6,10 +6,55 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createErrorCase = createErrorCase;
 const node_path_1 = __importDefault(require("node:path"));
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const processor_1 = require("../processor");
-const simple_1 = require("../test/simple");
-const type_1 = require("../type");
+const creator_1 = require("../test/creator");
+const common_1 = require("./common");
 let addedSerializer = false;
+const creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: true,
+    steps: ({ name, caseConfig }) => {
+        const config = caseConfig;
+        return [
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    compiler.setOptions(options(context, config.options));
+                },
+                compiler: async (context) => {
+                    const compilerManager = (0, common_1.getCompiler)(context, name);
+                    compilerManager.createCompiler();
+                    compiler(context, compilerManager.getCompiler(), config.compiler);
+                },
+                build: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    if (typeof config.build === "function") {
+                        await config.build(context, compiler.getCompiler());
+                    }
+                    else {
+                        await compiler.build();
+                    }
+                },
+                run: async (env, context) => {
+                    // no need to run, just check the snapshot of diagnostics
+                },
+                check: async (env, context) => {
+                    await check(env, context, name, config.check);
+                }
+            }
+        ];
+    },
+    concurrent: true
+});
+function createErrorCase(name, src, dist, testConfig) {
+    if (!addedSerializer) {
+        addedSerializer = true;
+    }
+    const caseConfig = require(testConfig);
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description
+    });
+}
 function options(context, custom) {
     let options = {
         context: node_path_1.default.resolve(__dirname, "../../../../tests/rspack-test/fixtures/errors"),
@@ -70,7 +115,9 @@ class RspackStatsDiagnostics {
         this.warnings = warnings;
     }
 }
-async function check(env, context, _, stats, check) {
+async function check(env, context, name, check) {
+    const compiler = (0, common_1.getCompiler)(context, name);
+    const stats = compiler.getStats();
     env.expect(typeof stats).toBe("object");
     const statsResult = stats.toJson({ errorDetails: false });
     env.expect(typeof statsResult).toBe("object");
@@ -79,20 +126,3 @@ async function check(env, context, _, stats, check) {
     env.expect(Array.isArray(warnings)).toBe(true);
     await check?.(new RspackStatsDiagnostics(errors, warnings));
 }
-function createErrorCase(name, src, dist, testConfig) {
-    if (!addedSerializer) {
-        addedSerializer = true;
-    }
-    const caseConfig = require(testConfig);
-    const runner = (0, simple_1.getSimpleProcessorRunner)(src, dist);
-    it(caseConfig.description, async () => {
-        await runner(name, new processor_1.SimpleTaskProcessor({
-            name: name,
-            compilerType: type_1.ECompilerType.Rspack,
-            options: context => options(context, caseConfig.options),
-            compiler: (context, c) => compiler(context, c, caseConfig.compiler),
-            build: caseConfig.build,
-            check: (env, context, compiler, stats) => check(env, context, compiler, stats, caseConfig.check)
-        }));
-    });
-}

package/dist/case/hash.d.ts

@@ -1,3 +1,3 @@
-import { ECompilerType, type TTestConfig } from "../type";
+import type { ECompilerType, TTestConfig } from "../type";
 export type THashCaseConfig = Pick<TTestConfig<ECompilerType.Rspack>, "validate">;
 export declare function createHashCase(name: string, src: string, dist: string): void;

package/dist/case/hash.js

@@ -1,10 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHashCase = createHashCase;
-const processor_1 = require("../processor");
 const creator_1 = require("../test/creator");
-const type_1 = require("../type");
+const common_1 = require("./common");
 const REG_ERROR_CASE = /error$/;
+class HashCaseCreator extends creator_1.BasicCaseCreator {
+    describe(name, tester, testConfig, options) {
+        it(`should print correct hash for ${name}`, async () => {
+            await tester.prepare();
+            await tester.compile();
+            await tester.check(this.createEnv(testConfig, options));
+            await tester.resume();
+        }, 30000);
+    }
+}
+const creator = new HashCaseCreator({
+    clean: true,
+    describe: false,
+    steps: ({ name }) => [
+        {
+            config: async (context) => {
+                (0, common_1.configMultiCompiler)(context, name, ["rspack.config.js", "webpack.config.js"], defaultOptions, 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 snapshot
+            },
+            check: async (env, context) => {
+                await check(env, context, name);
+            }
+        }
+    ]
+});
+function createHashCase(name, src, dist) {
+    creator.create(name, src, dist);
+}
 function defaultOptions(index, context) {
     return {
         context: context.getSource(),
@@ -33,23 +68,15 @@ function overrideOptions(index, context, options) {
         };
     }
 }
-class HashCaseCreator extends creator_1.BasicCaseCreator {
-    describe(name, tester, testConfig) {
-        it(`should print correct hash for ${name}`, async () => {
-            await tester.prepare();
-            await tester.compile();
-            await tester.check(this.createEnv(testConfig));
-            await tester.resume();
-        }, 30000);
-    }
-}
-async function check(env, context, compiler, stats) {
+async function check(env, context, name) {
+    const compiler = (0, common_1.getCompiler)(context, name);
+    const stats = compiler.getStats();
     const testConfig = context.getTestConfig();
     if (!stats) {
         env.expect(false);
         return;
     }
-    if (REG_ERROR_CASE.test(this._options.name)) {
+    if (REG_ERROR_CASE.test(name)) {
         env.expect(stats.hasErrors());
     }
     else {
@@ -62,23 +89,3 @@ async function check(env, context, compiler, stats) {
         throw new Error("HashTestCases should have test.config.js and a validate method");
     }
 }
-function createHashProcessor(name) {
-    const processor = new processor_1.MultiTaskProcessor({
-        name,
-        compilerType: type_1.ECompilerType.Rspack,
-        configFiles: ["rspack.config.js", "webpack.config.js"],
-        runable: false,
-        defaultOptions,
-        overrideOptions,
-        check
-    });
-    return processor;
-}
-const creator = new HashCaseCreator({
-    clean: true,
-    describe: false,
-    steps: ({ name }) => [createHashProcessor(name)]
-});
-function createHashCase(name, src, dist) {
-    creator.create(name, src, dist);
-}

package/dist/case/hook.d.ts

@@ -1,7 +1,6 @@
-import { type ISnapshotProcessorOptions } from "../processor";
 import { TestContext, type TTestContextOptions } from "../test/context";
-import type { ITestEnv } from "../type";
-import { ECompilerType, type ITestContext, type TCompiler, type TCompilerOptions } from "../type";
+import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions } from "../type";
+export declare function createHookCase(name: string, src: string, dist: string, source: string): void;
 export declare class HookCasesContext extends TestContext {
     protected src: string;
     protected testName: string;
@@ -29,10 +28,10 @@ export declare class HookCasesContext extends TestContext {
         diff: {};
     }): Promise<void>;
 }
-export type THookCaseConfig = Omit<ISnapshotProcessorOptions<ECompilerType.Rspack>, "name" | "compilerType" | "runable"> & {
+export type THookCaseConfig = {
     options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
     compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
     check?: (context: ITestContext) => Promise<void>;
+    snapshotFileFilter?: (file: string) => boolean;
     description: string;
 };
-export declare function createHookCase(name: string, src: string, dist: string, source: string): void;

package/dist/case/hook.js

@@ -11,14 +11,60 @@ const jest_snapshot_1 = require("jest-snapshot");
 const path_serializer_1 = require("path-serializer");
 const pretty_format_1 = require("pretty-format");
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const createLazyTestEnv_1 = __importDefault(require("../helper/legacy/createLazyTestEnv"));
-const processor_1 = require("../processor");
-const runner_1 = require("../runner");
 const context_1 = require("../test/context");
-const simple_1 = require("../test/simple");
-const type_1 = require("../type");
+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 creator = new creator_1.BasicCaseCreator({
+    clean: true,
+    describe: true,
+    createContext: (config) => new HookCasesContext(config.src, config.name, config),
+    steps: ({ name, caseConfig: _caseConfig, src }) => {
+        const caseConfig = _caseConfig;
+        return [
+            {
+                config: async (context) => {
+                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], defaultOptions(context, caseConfig.options));
+                    if (!global.printLogger) {
+                        options.infrastructureLogging = {
+                            level: "error"
+                        };
+                    }
+                    compiler.setOptions(options);
+                },
+                compiler: async (context) => {
+                    const c = await (0, common_1.compiler)(context, name);
+                    if (caseConfig.compiler) {
+                        await caseConfig.compiler(context, c);
+                    }
+                },
+                build: async (context) => {
+                    await (0, common_1.build)(context, name);
+                },
+                run: async (env, context) => {
+                    // no need to run, just check snapshot
+                },
+                check: async (env, context) => {
+                    await (0, common_1.checkSnapshot)(env, context, name, node_path_1.default.join(src, "output.snap.txt"), caseConfig.snapshotFileFilter);
+                }
+            }
+        ];
+    }
+});
+function createHookCase(name, src, dist, source) {
+    const caseConfig = require(node_path_1.default.join(src, "test.js"));
+    const testName = node_path_1.default.basename(name.slice(0, name.indexOf(node_path_1.default.extname(name))));
+    creator.create(name, src, dist, undefined, {
+        caseConfig,
+        description: () => caseConfig.description,
+        createContext: (config) => new HookCasesContext(src, testName, {
+            src: source,
+            dist: dist
+        })
+    });
+}
 const sourceSerializer = {
     test(val) {
         return val instanceof core_1.sources.Source;
@@ -146,71 +192,33 @@ class HookCasesContext extends context_1.TestContext {
     }
 }
 exports.HookCasesContext = HookCasesContext;
-function createHookCase(name, src, dist, source) {
-    const caseConfig = require(node_path_1.default.join(src, "test.js"));
-    const testName = node_path_1.default.basename(name.slice(0, name.indexOf(node_path_1.default.extname(name))));
-    const runner = (0, simple_1.getSimpleProcessorRunner)(source, dist, {
-        env: () => env,
-        context: () => new HookCasesContext(src, testName, {
-            src: source,
-            dist: dist,
-            runnerFactory: runner_1.BasicRunnerFactory
-        })
-    });
-    it(caseConfig.description, async () => {
-        await runner(name, new processor_1.SnapshotProcessor({
-            name,
-            compilerType: type_1.ECompilerType.Rspack,
-            findBundle: () => ["main.js"],
-            snapshot: node_path_1.default.join(src, "output.snap.txt"),
-            runable: false,
-            defaultOptions: context => {
-                let defaultOptions = {
-                    context: context.getSource(),
-                    mode: "production",
-                    target: "async-node",
-                    devtool: false,
-                    cache: false,
-                    entry: "./hook",
-                    output: {
-                        path: context.getDist()
-                    },
-                    optimization: {
-                        minimize: false
-                    },
-                    experiments: {
-                        css: true,
-                        rspackFuture: {
-                            bundlerInfo: {
-                                force: false
-                            }
-                        },
-                        inlineConst: true,
-                        lazyBarrel: true
-                    }
-                };
-                if (caseConfig.options) {
-                    defaultOptions = (0, webpack_merge_1.default)(defaultOptions, caseConfig.options(context));
-                }
-                return defaultOptions;
-            },
-            overrideOptions: (context, options) => {
-                if (!global.printLogger) {
-                    options.infrastructureLogging = {
-                        level: "error"
-                    };
-                }
-            },
-            compiler: caseConfig.compiler,
-            check: async function (env, context, compiler, stats) {
-                await context.collectSnapshots(env);
-                await processor_1.SnapshotProcessor.prototype.check.call(this, env, context);
-                if (typeof caseConfig.check === "function") {
-                    await caseConfig.check(context);
+function defaultOptions(context, custom) {
+    let defaultOptions = {
+        context: context.getSource(),
+        mode: "production",
+        target: "async-node",
+        devtool: false,
+        cache: false,
+        entry: "./hook",
+        output: {
+            path: context.getDist()
+        },
+        optimization: {
+            minimize: false
+        },
+        experiments: {
+            css: true,
+            rspackFuture: {
+                bundlerInfo: {
+                    force: false
                 }
             },
-            snapshotFileFilter: caseConfig.snapshotFileFilter
-        }));
-    });
-    const env = (0, createLazyTestEnv_1.default)(10000);
+            inlineConst: true,
+            lazyBarrel: true
+        }
+    };
+    if (custom) {
+        defaultOptions = (0, webpack_merge_1.default)(defaultOptions, custom(context));
+    }
+    return defaultOptions;
 }

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

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