@rspack-canary/test-tools 1.6.0-canary-6cd722f4-20251022123039 → 1.6.0-canary-4ad8b49f-20251023175711

package/dist/case/hot-step.js

@@ -9,8 +9,6 @@ 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 type_1 = require("../type");
-const common_1 = require("./common");
 const hot_1 = require("./hot");
 const NOOP_SET = new Set();
 const escapeLocalName = (str) => str.split(/[-<>:"/|?*.]/).join("_");
@@ -244,7 +242,7 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
     }
     const originRun = processor.run;
     processor.run = async function (env, context) {
-        context.setValue(name, "hotUpdateStepChecker", (updateIndex, stats, runtime) => {
+        context.setValue("hotUpdateStepChecker", (updateIndex, stats, runtime) => {
             const statsJson = stats.toJson({
                 assets: true,
                 chunks: true
@@ -261,18 +259,18 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
                             : Array.from(entry.runtime);
                 }
             }
-            const compiler = context.getCompiler(name, type_1.ECompilerType.Rspack);
+            const compiler = context.getCompiler();
             const compilerOptions = compiler.getOptions();
             matchStepSnapshot(env, context, updateIndex, compilerOptions, statsJson, runtime);
             hashes.push(stats.hash);
         });
-        context.setValue(name, "hotUpdateStepErrorChecker", (updateIndex, stats, runtime) => {
+        context.setValue("hotUpdateStepErrorChecker", (updateIndex, stats, runtime) => {
             hashes.push(stats.hash);
         });
         await originRun(env, context);
     };
     processor.check = async function (env, context) {
-        const compiler = (0, common_1.getCompiler)(context, name);
+        const compiler = context.getCompiler();
         const stats = compiler.getStats();
         if (!stats || !stats.hash) {
             env.expect(false);

package/dist/case/hot.d.ts

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

package/dist/case/hot.js

@@ -22,10 +22,10 @@ function createHotProcessor(name, src, temp, target, incremental = false) {
     const processor = {
         before: async (context) => {
             await updatePlugin.initialize();
-            context.setValue(name, "hotUpdatePlugin", updatePlugin);
+            context.setValue("hotUpdatePlugin", updatePlugin);
         },
         config: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             let options = defaultOptions(context, target);
             options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
             overrideOptions(context, options, target, updatePlugin);
@@ -141,7 +141,7 @@ function overrideOptions(context, options, target, updatePlugin) {
     }
 }
 function findBundle(context, name, target, updatePlugin) {
-    const compiler = context.getCompiler(name);
+    const compiler = context.getCompiler();
     if (!compiler)
         throw new Error("Compiler should exists when find bundle");
     const testConfig = context.getTestConfig();
@@ -171,12 +171,12 @@ function findBundle(context, name, target, updatePlugin) {
     return [...prefiles, ...files];
 }
 function createHotRunner(context, name, file, env) {
-    const compiler = context.getCompiler(name);
+    const compiler = context.getCompiler();
     const compilerOptions = compiler.getOptions();
     const testConfig = context.getTestConfig();
     const source = context.getSource();
     const dist = context.getDist();
-    const updatePlugin = context.getValue(name, "hotUpdatePlugin");
+    const updatePlugin = context.getValue("hotUpdatePlugin");
     const nextHMR = async (m, options) => {
         await updatePlugin.goNext();
         const stats = await compiler.build();
@@ -187,7 +187,7 @@ function createHotRunner(context, name, file, env) {
         // errorDetails: true
         });
         const compilerOptions = compiler.getOptions();
-        const checker = context.getValue(name, jsonStats.errors?.length
+        const checker = context.getValue(jsonStats.errors?.length
             ? "hotUpdateStepErrorChecker"
             : "hotUpdateStepChecker");
         if (checker) {

package/dist/case/incremental.d.ts

@@ -1,5 +1,5 @@
-import type { ECompilerType, TCompilerOptions } from "../type";
-export declare function createHotIncrementalCase(name: string, src: string, dist: string, temp: string, target: TCompilerOptions<ECompilerType.Rspack>["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/index.d.ts

@@ -8,7 +8,6 @@ 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";

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.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;
+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.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");
@@ -14,8 +14,6 @@ Object.defineProperty(exports, "createDefaultsCase", { enumerable: true, get: fu
 Object.defineProperty(exports, "getRspackDefaultConfig", { enumerable: true, get: function () { return defaults_1.getRspackDefaultConfig; } });
 var diagnostic_1 = require("./diagnostic");
 Object.defineProperty(exports, "createDiagnosticCase", { enumerable: true, get: function () { return diagnostic_1.createDiagnosticCase; } });
-var diff_1 = require("./diff");
-Object.defineProperty(exports, "createDiffCase", { enumerable: true, get: function () { return diff_1.createDiffCase; } });
 var error_1 = require("./error");
 Object.defineProperty(exports, "createErrorCase", { enumerable: true, get: function () { return error_1.createErrorCase; } });
 var esm_output_1 = require("./esm-output");

package/dist/case/multi-compiler.d.ts

@@ -1,18 +1,19 @@
-import type { ECompilerType, ITestContext, TCompilation, TCompiler, TCompilerOptions, TCompilerStats, TCompilerStatsCompilation } from "../type";
+import type { Compilation, Compiler, RspackOptions, Stats, StatsCompilation } from "@rspack/core";
+import type { ITestContext } from "../type";
 export declare function createMultiCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
 export type TMultiCompilerCaseConfig = {
     description: string;
     error?: boolean;
     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>;
+    options?: (context: ITestContext) => RspackOptions;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
     check?: ({ context, stats, files, compiler, compilation }: {
         context: ITestContext;
-        stats?: TCompilerStatsCompilation<ECompilerType.Rspack>;
+        stats?: StatsCompilation;
         files?: Record<string, string>;
-        compiler: TCompiler<ECompilerType.Rspack>;
-        compilation?: TCompilation<ECompilerType.Rspack>;
+        compiler: Compiler;
+        compilation?: Compilation;
     }) => Promise<void>;
-    compilerCallback?: (error: Error | null, stats: TCompilerStats<ECompilerType.Rspack> | null) => void;
+    compilerCallback?: (error: Error | null, stats: Stats | null) => void;
 };

package/dist/case/multi-compiler.js

@@ -7,11 +7,10 @@ exports.createMultiCompilerCase = createMultiCompilerCase;
 const node_path_1 = __importDefault(require("node:path"));
 const memfs_1 = require("memfs");
 const creator_1 = require("../test/creator");
-const common_1 = require("./common");
 function createMultiCompilerProcessor(name, caseConfig) {
     return {
         config: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             const options = Object.assign([
                 {
                     name: "a",
@@ -27,7 +26,7 @@ function createMultiCompilerProcessor(name, caseConfig) {
             compiler.setOptions(options);
         },
         compiler: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             if (caseConfig.compilerCallback) {
                 compiler.createCompilerWithCallback(caseConfig.compilerCallback);
             }
@@ -57,7 +56,7 @@ function createMultiCompilerProcessor(name, caseConfig) {
             await caseConfig.compiler?.(context, c);
         },
         build: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             if (typeof caseConfig.build === "function") {
                 await caseConfig.build?.(context, compiler.getCompiler());
             }

package/dist/case/normal.js

@@ -21,7 +21,7 @@ const createCaseOptions = (hot, mode) => {
         steps: ({ name }) => [
             {
                 config: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const compiler = context.getCompiler();
                     let options = defaultOptions(context, {
                         plugins: hot ? [new core_1.HotModuleReplacementPlugin()] : []
                     }, mode);

package/dist/case/runner.d.ts

@@ -1,4 +1,5 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITestRunner, TCompilerStatsCompilation } from "../type";
+import type { StatsCompilation } from "@rspack/core";
+import type { ITestContext, ITestEnv, ITestRunner } from "../type";
 export type THotStepRuntimeLangData = {
     outdatedModules: string[];
     outdatedDependencies: Record<string, string[]>;
@@ -12,7 +13,7 @@ export type THotStepRuntimeData = {
     css: THotStepRuntimeLangData;
     statusPath: string[];
 };
-export declare function cachedStats<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): () => TCompilerStatsCompilation<T>;
-export declare function createRunner<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
+export declare function cachedStats(context: ITestContext, name: string): () => StatsCompilation;
+export declare function createRunner(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
 export declare function getMultiCompilerRunnerKey(context: ITestContext, name: string, file: string): string;
-export declare function createMultiCompilerRunner<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
+export declare function createMultiCompilerRunner(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;

package/dist/case/runner.js

@@ -5,9 +5,9 @@ exports.createRunner = createRunner;
 exports.getMultiCompilerRunnerKey = getMultiCompilerRunnerKey;
 exports.createMultiCompilerRunner = createMultiCompilerRunner;
 const runner_1 = require("../runner");
-const common_1 = require("./common");
+const debug_1 = require("../test/debug");
 function cachedStats(context, name) {
-    const compiler = context.getCompiler(name);
+    const compiler = context.getCompiler();
     const statsGetter = (() => {
         let cached = null;
         return () => {
@@ -23,7 +23,7 @@ function cachedStats(context, name) {
     return statsGetter;
 }
 function createRunner(context, name, file, env) {
-    const compiler = (0, common_1.getCompiler)(context, name);
+    const compiler = context.getCompiler();
     const testConfig = context.getTestConfig();
     const compilerOptions = compiler.getOptions();
     const runnerOptions = {
@@ -48,8 +48,8 @@ function createRunner(context, name, file, env) {
     return new runner_1.NodeRunner(runnerOptions);
 }
 function getFileIndexHandler(context, name, file) {
-    const multiFileIndexMap = context.getValue(name, "multiFileIndexMap") || {};
-    const runned = context.getValue(name, "runned") || new Set();
+    const multiFileIndexMap = context.getValue("multiFileIndexMap") || {};
+    const runned = context.getValue("runned") || new Set();
     if (typeof multiFileIndexMap[file] === "undefined") {
         throw new Error("Unexpect file in multiple runner");
     }
@@ -60,7 +60,7 @@ function getFileIndexHandler(context, name, file) {
     }
     const getIndex = () => [indexList[seq], seq];
     const flagIndex = () => runned.add(`${name}:${file}[${seq}]`);
-    context.setValue(name, "runned", runned);
+    context.setValue("runned", runned);
     return { getIndex, flagIndex };
 }
 function getMultiCompilerRunnerKey(context, name, file) {
@@ -71,9 +71,11 @@ function getMultiCompilerRunnerKey(context, name, file) {
 function createMultiCompilerRunner(context, name, file, env) {
     const testConfig = context.getTestConfig();
     const { getIndex, flagIndex } = getFileIndexHandler(context, name, file);
-    const multiCompilerOptions = context.getValue(name, "multiCompilerOptions") || [];
+    const multiCompilerOptions = context.getValue("multiCompilerOptions") || [];
     const [index] = getIndex();
     const compilerOptions = multiCompilerOptions[index];
+    const logs = context.getValue(debug_1.DEBUG_SCOPES.RunLogs);
+    const errors = context.getValue(debug_1.DEBUG_SCOPES.RunErrors);
     let runner;
     const runnerOptions = {
         runInNewContext: false,
@@ -91,7 +93,9 @@ function createMultiCompilerRunner(context, name, file, env) {
         testConfig: context.getTestConfig(),
         source: context.getSource(),
         dist: context.getDist(),
-        compilerOptions
+        compilerOptions,
+        logs,
+        errors
     };
     if (compilerOptions.target === "web" ||
         compilerOptions.target === "webworker") {

package/dist/case/serial.d.ts

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

package/dist/case/stats-api.d.ts

@@ -1,10 +1,11 @@
-import type { ECompilerType, ITestContext, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
+import type { Compiler, RspackOptions, Stats } from "@rspack/core";
+import type { ITestContext } from "../type";
 export type TStatsAPICaseConfig = {
     description: string;
-    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+    options?: (context: ITestContext) => RspackOptions;
     snapshotName?: string;
-    compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
-    build?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
-    check?: (stats: TCompilerStats<ECompilerType.Rspack>, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    check?: (stats: Stats, compiler: Compiler) => Promise<void>;
 };
 export declare function createStatsAPICase(name: string, src: string, dist: string, testConfig: string): void;

package/dist/case/stats-api.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStatsAPICase = createStatsAPICase;
 const memfs_1 = require("memfs");
 const creator_1 = require("../test/creator");
-const common_1 = require("./common");
 let addedSerializer = false;
 const creator = new creator_1.BasicCaseCreator({
     clean: true,
@@ -13,16 +12,16 @@ const creator = new creator_1.BasicCaseCreator({
         return [
             {
                 config: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const compiler = context.getCompiler();
                     compiler.setOptions(options(context, config.options));
                 },
                 compiler: async (context) => {
-                    const compilerManager = (0, common_1.getCompiler)(context, name);
+                    const compilerManager = context.getCompiler();
                     compilerManager.createCompiler();
                     compiler(context, compilerManager.getCompiler(), config.compiler);
                 },
                 build: async (context) => {
-                    const compiler = (0, common_1.getCompiler)(context, name);
+                    const compiler = context.getCompiler();
                     if (typeof config.build === "function") {
                         await config.build(context, compiler.getCompiler());
                     }
@@ -52,8 +51,7 @@ function createStatsAPICase(name, src, dist, testConfig) {
     });
 }
 function options(context, custom) {
-    const res = (custom?.(context) ||
-        {});
+    const res = (custom?.(context) || {});
     res.experiments ??= {};
     res.experiments.css ??= true;
     res.experiments.rspackFuture ??= {};
@@ -75,7 +73,7 @@ async function compiler(context, compiler, custom) {
     }
 }
 async function check(env, context, name, custom) {
-    const manager = (0, common_1.getCompiler)(context, name);
+    const manager = context.getCompiler();
     const stats = manager.getStats();
     env.expect(typeof stats).toBe("object");
     await custom?.(stats, manager.getCompiler());

package/dist/case/stats-output.d.ts

@@ -1,5 +1,6 @@
-import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
-export declare function createStatsProcessor(name: string, defaultOptions: (index: number, context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>, overrideOptions: (index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>) => void): {
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext, ITestEnv } from "../type";
+export declare function createStatsProcessor(name: string, defaultOptions: (index: number, context: ITestContext) => RspackOptions, overrideOptions: (index: number, context: ITestContext, options: RspackOptions) => void): {
     before: (context: ITestContext) => Promise<void>;
     config: (context: ITestContext) => Promise<void>;
     compiler: (context: ITestContext) => Promise<void>;

package/dist/case/stats-output.js

@@ -114,7 +114,7 @@ class RspackStats {
     }
 }
 async function check(env, context, name, writeStatsOuptut, snapshot, stderr) {
-    const compiler = (0, common_1.getCompiler)(context, name);
+    const compiler = context.getCompiler();
     const options = compiler.getOptions();
     const stats = compiler.getStats();
     if (!stats || !compiler)

package/dist/case/treeshaking.js

@@ -13,7 +13,7 @@ const creator = new creator_1.BasicCaseCreator({
     steps: ({ name }) => [
         {
             config: async (context) => {
-                const compiler = (0, common_1.getCompiler)(context, name);
+                const compiler = context.getCompiler();
                 const options = (0, builtin_1.defaultOptions)(context);
                 overrideOptions(context, options);
                 compiler.setOptions(options);

package/dist/case/watch.d.ts

@@ -1,14 +1,14 @@
-import type { ECompilerType, ITestContext, ITestEnv, ITestRunner } from "../type";
+import type { ITestContext, ITestEnv, ITestRunner } from "../type";
 export declare function createWatchInitialProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher }?: {
     incremental?: boolean | undefined;
     nativeWatcher?: boolean | undefined;
 }): {
     before: (context: ITestContext) => Promise<void>;
-    config: <T extends ECompilerType.Rspack>(context: ITestContext) => Promise<void>;
+    config: (context: ITestContext) => Promise<void>;
     compiler: (context: ITestContext) => Promise<void>;
     build: (context: ITestContext) => Promise<void>;
     run: (env: ITestEnv, context: ITestContext) => Promise<void>;
-    check: <T extends ECompilerType.Rspack>(env: ITestEnv, context: ITestContext) => Promise<void>;
+    check: (env: ITestEnv, context: ITestContext) => Promise<void>;
     after: (context: ITestContext) => Promise<void>;
 };
 export declare function createWatchStepProcessor(name: string, tempDir: string, step: string, watchState: Record<string, any>, { incremental, nativeWatcher }?: {
@@ -16,13 +16,13 @@ export declare function createWatchStepProcessor(name: string, tempDir: string,
     nativeWatcher?: boolean | undefined;
 }): {
     before: (context: ITestContext) => Promise<void>;
-    config: <T extends ECompilerType.Rspack>(context: ITestContext) => Promise<void>;
+    config: (context: ITestContext) => Promise<void>;
     compiler: (context: ITestContext) => Promise<void>;
     build: (context: ITestContext) => Promise<void>;
     run: (env: ITestEnv, context: ITestContext) => Promise<void>;
-    check: <T extends ECompilerType.Rspack>(env: ITestEnv, context: ITestContext) => Promise<void>;
+    check: (env: ITestEnv, context: ITestContext) => Promise<void>;
     after: (context: ITestContext) => Promise<void>;
 };
 export declare function createWatchCase(name: string, src: string, dist: string, temp: string): void;
 export declare function getWatchRunnerKey(context: ITestContext, name: string, file: string): string;
-export declare function createWatchRunner<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;
+export declare function createWatchRunner(context: ITestContext, name: string, file: string, env: ITestEnv): ITestRunner;

package/dist/case/watch.js

@@ -29,7 +29,7 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
     };
     return {
         before: async (context) => {
-            context.setValue(name, "watchContext", watchContext);
+            context.setValue("watchContext", watchContext);
         },
         config: async (context) => {
             const testConfig = context.getTestConfig();
@@ -46,9 +46,9 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             const compilerOptions = multiCompilerOptions.length === 1
                 ? multiCompilerOptions[0]
                 : multiCompilerOptions;
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             compiler.setOptions(compilerOptions);
-            context.setValue(name, "multiCompilerOptions", multiCompilerOptions);
+            context.setValue("multiCompilerOptions", multiCompilerOptions);
         },
         compiler: async (context) => {
             const c = await (0, common_1.compiler)(context, name);
@@ -57,7 +57,7 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             });
         },
         build: async (context) => {
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             node_fs_1.default.mkdirSync(watchContext.tempDir, { recursive: true });
             (0, copyDiff_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), watchContext.tempDir, true);
             const task = new Promise((resolve, reject) => {
@@ -77,12 +77,12 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             const testConfig = context.getTestConfig();
             if (testConfig.noTests)
                 return;
-            const errors = (context.getError(name) || []).map(e => ({
+            const errors = (context.getError() || []).map(e => ({
                 message: e.message,
                 stack: e.stack
             }));
             const warnings = [];
-            const compiler = (0, common_1.getCompiler)(context, name);
+            const compiler = context.getCompiler();
             const stats = compiler.getStats();
             const options = compiler.getOptions();
             const checkStats = testConfig.checkStats || (() => true);
@@ -148,7 +148,7 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
             await (0, checkArrayExpectation_1.default)(node_path_1.default.join(context.getSource(), watchContext.step), { warnings }, "warning", "warnings", "Warning", options);
             // clear error if checked
             if (node_fs_1.default.existsSync(context.getSource("errors.js"))) {
-                context.clearError(name);
+                context.clearError();
             }
             // check hash
             if (testConfig.writeStatsOuptut) {
@@ -169,7 +169,7 @@ function createWatchStepProcessor(name, tempDir, step, watchState, { incremental
         // do nothing
     };
     processor.build = async (context) => {
-        const compiler = (0, common_1.getCompiler)(context, name);
+        const compiler = context.getCompiler();
         const task = new Promise((resolve, reject) => {
             compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
                 if (e)
@@ -252,7 +252,8 @@ function overrideOptions(index, context, options, tempDir, nativeWatcher) {
     }
     options.experiments.rspackFuture ??= {};
     options.experiments.rspackFuture.bundlerInfo ??= {};
-    options.experiments.rspackFuture.bundlerInfo.force ??= false;
+    options.experiments.rspackFuture.bundlerInfo.force ??=
+        false;
     // test incremental: "safe" here, we test default incremental in Incremental-*.test.js
     options.experiments.incremental ??= "safe";
     if (!global.printLogger) {
@@ -282,13 +283,13 @@ function defaultOptions({ incremental = false, ignoreNotFriendlyForIncrementalWa
     return {};
 }
 function getWatchRunnerKey(context, name, file) {
-    const watchContext = context.getValue(name, "watchContext");
+    const watchContext = context.getValue("watchContext");
     const stepName = watchContext?.step;
     return `${name}-${stepName}`;
 }
 function cachedWatchStats(context, name) {
-    const compiler = context.getCompiler(name);
-    const watchContext = context.getValue(name, "watchContext");
+    const compiler = context.getCompiler();
+    const watchContext = context.getValue("watchContext");
     const stepName = watchContext?.step;
     const statsGetter = (() => {
         const cached = {};
@@ -305,9 +306,9 @@ function cachedWatchStats(context, name) {
     return statsGetter;
 }
 function createWatchRunner(context, name, file, env) {
-    const compiler = context.getCompiler(name);
+    const compiler = context.getCompiler();
     const compilerOptions = compiler.getOptions();
-    const watchContext = context.getValue(name, "watchContext");
+    const watchContext = context.getValue("watchContext");
     const stepName = watchContext?.step;
     if (!stepName) {
         throw new Error("Can not get watch step name from context");

package/dist/compiler.d.ts

@@ -1,29 +1,28 @@
 import EventEmitter from "node:events";
-import { ECompilerType, type ITestCompilerManager, type TCompiler, type TCompilerFactories, type TCompilerOptions, type TCompilerStats } from "./type";
+import { Compiler, type RspackOptions, type Stats } from "@rspack/core";
+import type { ITestCompilerManager, ITestContext } from "./type";
 export declare enum ECompilerEvent {
     Build = "build",
     Option = "option",
     Create = "create",
     Close = "close"
 }
-export declare const COMPILER_FACTORIES: TCompilerFactories<ECompilerType>;
-export declare class TestCompilerManager<T extends ECompilerType> implements ITestCompilerManager<T> {
-    protected type: T;
-    protected factories: TCompilerFactories<T>;
-    protected compilerOptions: TCompilerOptions<T>;
-    protected compilerInstance: TCompiler<T> | null;
-    protected compilerStats: TCompilerStats<T> | null;
+export declare class TestCompilerManager implements ITestCompilerManager {
+    protected context: ITestContext;
+    protected compilerOptions: RspackOptions;
+    protected compilerInstance: Compiler | null;
+    protected compilerStats: Stats | null;
     protected emitter: EventEmitter;
-    constructor(type: T, factories?: TCompilerFactories<T>);
-    getOptions(): TCompilerOptions<T>;
-    setOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
-    mergeOptions(newOptions: TCompilerOptions<T>): TCompilerOptions<T>;
-    getCompiler(): TCompiler<T> | null;
-    createCompiler(): TCompiler<T>;
-    createCompilerWithCallback(callback: (error: Error | null, stats: TCompilerStats<T> | null) => void): TCompiler<T>;
-    build(): Promise<TCompilerStats<T>>;
+    constructor(context: ITestContext);
+    getOptions(): RspackOptions;
+    setOptions(newOptions: RspackOptions): RspackOptions;
+    mergeOptions(newOptions: RspackOptions): RspackOptions;
+    getCompiler(): Compiler | null;
+    createCompiler(): Compiler;
+    createCompilerWithCallback(callback: (error: Error | null, stats: Stats | null) => void): Compiler;
+    build(): Promise<Stats>;
     watch(timeout?: number): void;
-    getStats(): TCompilerStats<T> | null;
+    getStats(): Stats | null;
     getEmitter(): EventEmitter<[never]>;
     close(): Promise<void>;
 }