@rspack-canary/test-tools 1.6.0-canary-6cd722f4-20251022123039 → 1.6.0-canary-e28e40e9-20251022173516

package/dist/case/builtin.d.ts

@@ -1,3 +1,4 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext } from "../type";
 export declare function createBuiltinCase(name: string, src: string, dist: string): void;
-export declare function defaultOptions<T extends ECompilerType.Rspack>(context: ITestContext): TCompilerOptions<T>;
+export declare function defaultOptions(context: ITestContext): RspackOptions;

package/dist/case/cache.d.ts

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

package/dist/case/cache.js

@@ -137,7 +137,10 @@ function findBundle(name, target, context) {
     const stats = compiler.getStats();
     if (!stats)
         throw new Error("Stats should exists when find bundle");
-    const info = stats.toJson({ all: false, entrypoints: true });
+    const info = stats.toJson({
+        all: false,
+        entrypoints: true
+    });
     if (target === "web" || target === "webworker") {
         for (const file of info.entrypoints.main.assets) {
             if ((0, helper_1.isJavaScript)(file.name)) {

package/dist/case/common.d.ts

@@ -1,11 +1,12 @@
-import { ECompilerType, type ITestCompilerManager, type ITestContext, type ITestEnv, type TCompiler, type TCompilerOptions } from "../type";
-export declare function getCompiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): ITestCompilerManager<T>;
-export declare function config<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, configFiles: string[], defaultOptions?: TCompilerOptions<T>): Promise<TCompilerOptions<T>>;
-export declare function compiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): Promise<TCompiler<T>>;
-export declare function build<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string): Promise<TCompiler<T>>;
-export declare function run<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, findBundle: (context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): Promise<void>;
-export declare function check<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string): Promise<void>;
-export declare function checkSnapshot<T extends ECompilerType = ECompilerType.Rspack>(env: ITestEnv, context: ITestContext, name: string, snapshot: string, filter?: (file: string) => boolean): Promise<void>;
+import type { Compiler, RspackOptions } from "@rspack/core";
+import type { ITestCompilerManager, ITestContext, ITestEnv } from "../type";
+export declare function getCompiler(context: ITestContext, name: string): ITestCompilerManager;
+export declare function config(context: ITestContext, name: string, configFiles: string[], defaultOptions?: RspackOptions): Promise<RspackOptions>;
+export declare function compiler(context: ITestContext, name: string): Promise<Compiler>;
+export declare function build(context: ITestContext, name: string): Promise<Compiler>;
+export declare function run(env: ITestEnv, context: ITestContext, name: string, findBundle: (context: ITestContext, options: RspackOptions) => string[] | string | void): Promise<void>;
+export declare function check(env: ITestEnv, context: ITestContext, name: string): Promise<void>;
+export declare function checkSnapshot(env: ITestEnv, context: ITestContext, name: string, snapshot: string, filter?: (file: string) => boolean): Promise<void>;
 export declare function afterExecute(context: ITestContext, name: string): Promise<void>;
-export declare function findMultiCompilerBundle<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, multiFindBundle: (index: number, context: ITestContext, options: TCompilerOptions<T>) => string[] | string | void): string[];
-export declare function configMultiCompiler<T extends ECompilerType = ECompilerType.Rspack>(context: ITestContext, name: string, configFiles: string[], defaultOptions: (index: number, context: ITestContext) => TCompilerOptions<T>, overrideOptions: (index: number, context: ITestContext, options: TCompilerOptions<T>) => void): void;
+export declare function findMultiCompilerBundle(context: ITestContext, name: string, multiFindBundle: (index: number, context: ITestContext, options: RspackOptions) => string[] | string | void): string[];
+export declare function configMultiCompiler(context: ITestContext, name: string, configFiles: string[], defaultOptions: (index: number, context: ITestContext) => RspackOptions, overrideOptions: (index: number, context: ITestContext, options: RspackOptions) => void): void;

package/dist/case/common.js

@@ -19,9 +19,8 @@ const webpack_merge_1 = __importDefault(require("webpack-merge"));
 const helper_1 = require("../helper");
 const placeholder_1 = require("../helper/expect/placeholder");
 const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-const type_1 = require("../type");
 function getCompiler(context, name) {
-    return context.getCompiler(name, type_1.ECompilerType.Rspack);
+    return context.getCompiler(name);
 }
 async function config(context, name, configFiles, defaultOptions = {}) {
     const compiler = getCompiler(context, name);
@@ -138,9 +137,7 @@ async function checkSnapshot(env, context, name, snapshot, filter) {
     const compilers = "compilers" in compiler
         ? compiler.compilers
         : [compiler];
-    const totalStats = "stats" in stats
-        ? stats.stats
-        : [stats];
+    const totalStats = "stats" in stats ? stats.stats : [stats];
     const total = compilers.length;
     for (let i = 0; i < compilers.length; i++) {
         const c = compilers[i];

package/dist/case/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 createCompilerCase(name: string, src: string, dist: string, testConfig: string): void;
 export type TCompilerCaseConfig = {
     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/config.d.ts

@@ -1,7 +1,8 @@
-import type { ECompilerType, ITestContext, ITestProcessor, TCompilerOptions, TTestConfig } from "../type";
-export type TConfigCaseConfig = Omit<TTestConfig<ECompilerType.Rspack>, "validate">;
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext, ITestProcessor, TTestConfig } from "../type";
+export type TConfigCaseConfig = Omit<TTestConfig, "validate">;
 export declare function createConfigProcessor(name: string): ITestProcessor;
 export declare function createConfigCase(name: string, src: string, dist: string): void;
-export declare function defaultOptions(index: number, context: ITestContext): TCompilerOptions<ECompilerType.Rspack>;
-export declare function overrideOptions(index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>): void;
-export declare function findBundle(index: number, context: ITestContext, options: TCompilerOptions<ECompilerType.Rspack>): string | string[];
+export declare function defaultOptions(index: number, context: ITestContext): RspackOptions;
+export declare function overrideOptions(index: number, context: ITestContext, options: RspackOptions): void;
+export declare function findBundle(index: number, context: ITestContext, options: RspackOptions): string | string[];

package/dist/case/defaults.d.ts

@@ -1,10 +1,11 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext } from "../type";
 export declare function createDefaultsCase(name: string, src: string): void;
-export declare function getRspackDefaultConfig(cwd: string, config: TCompilerOptions<ECompilerType>): TCompilerOptions<ECompilerType>;
+export declare function getRspackDefaultConfig(cwd: string, config: RspackOptions): RspackOptions;
 export type TDefaultsCaseConfig = {
-    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
+    options?: (context: ITestContext) => RspackOptions;
     cwd?: string;
-    diff: (diff: jest.JestMatchers<RspackTestDiff>, defaults: jest.JestMatchers<TCompilerOptions<ECompilerType.Rspack>>) => Promise<void>;
+    diff: (diff: jest.JestMatchers<RspackTestDiff>, defaults: jest.JestMatchers<RspackOptions>) => Promise<void>;
     description: string;
 };
 declare class RspackTestDiff {

package/dist/case/defaults.js

@@ -88,7 +88,7 @@ async function run(name, processor) {
         context.emitError(name, e);
     }
     finally {
-        await processor.check?.({ expect, it, beforeEach, afterEach, jest }, context);
+        await processor.check?.({ expect, it, beforeEach, afterEach, jest: global.jest || global.rstest }, context);
         await processor.after?.(context);
     }
 }

package/dist/case/error.d.ts

@@ -1,5 +1,5 @@
-import type { StatsError } from "@rspack/core";
-import type { ECompilerType, ITestContext, TCompiler, TCompilerOptions } from "../type";
+import type { Compiler, RspackOptions, StatsError } from "@rspack/core";
+import type { ITestContext } from "../type";
 export declare function createErrorCase(name: string, src: string, dist: string, testConfig: string): void;
 declare class RspackStatsDiagnostics {
     errors: StatsError[];
@@ -9,9 +9,9 @@ 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>;
+    options?: (context: ITestContext) => RspackOptions;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
+    build?: (context: ITestContext, compiler: Compiler) => Promise<void>;
     check?: (stats: RspackStatsDiagnostics) => Promise<void>;
 };
 export {};

package/dist/case/hash.d.ts

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

package/dist/case/hook.d.ts

@@ -1,5 +1,6 @@
+import { Compiler, type RspackOptions } from "@rspack/core";
 import { TestContext, type TTestContextOptions } from "../test/context";
-import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions } from "../type";
+import type { ITestContext, ITestEnv } from "../type";
 export declare function createHookCase(name: string, src: string, dist: string, source: string): void;
 export declare class HookCasesContext extends TestContext {
     protected src: string;
@@ -29,8 +30,8 @@ export declare class HookCasesContext extends TestContext {
     }): Promise<void>;
 }
 export type THookCaseConfig = {
-    options?: (context: ITestContext) => TCompilerOptions<ECompilerType.Rspack>;
-    compiler?: (context: ITestContext, compiler: TCompiler<ECompilerType.Rspack>) => Promise<void>;
+    options?: (context: ITestContext) => RspackOptions;
+    compiler?: (context: ITestContext, compiler: Compiler) => Promise<void>;
     check?: (context: ITestContext) => Promise<void>;
     snapshotFileFilter?: (file: string) => boolean;
     description: string;

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, temp: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
+import type { RspackOptions } from "@rspack/core";
+export declare function createHotStepCase(name: string, src: string, dist: string, temp: string, target: RspackOptions["target"]): void;

package/dist/case/hot-step.js

@@ -9,7 +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();
@@ -261,7 +260,7 @@ ${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(name);
             const compilerOptions = compiler.getOptions();
             matchStepSnapshot(env, context, updateIndex, compilerOptions, statsJson, runtime);
             hashes.push(stats.hash);

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/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/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/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

@@ -52,8 +52,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 ??= {};

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/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

@@ -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) {

package/dist/compiler.d.ts

@@ -1,29 +1,27 @@
 import EventEmitter from "node:events";
-import { ECompilerType, type ITestCompilerManager, type TCompiler, type TCompilerFactories, type TCompilerOptions, type TCompilerStats } from "./type";
+import type { Compiler, RspackOptions, Stats } from "@rspack/core";
+import type { ITestCompilerManager } 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 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();
+    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>;
 }

package/dist/compiler.js

@@ -3,10 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestCompilerManager = exports.COMPILER_FACTORIES = exports.ECompilerEvent = void 0;
+exports.TestCompilerManager = exports.ECompilerEvent = void 0;
 const node_events_1 = __importDefault(require("node:events"));
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
-const type_1 = require("./type");
 var ECompilerEvent;
 (function (ECompilerEvent) {
     ECompilerEvent["Build"] = "build";
@@ -14,14 +13,8 @@ var ECompilerEvent;
     ECompilerEvent["Create"] = "create";
     ECompilerEvent["Close"] = "close";
 })(ECompilerEvent || (exports.ECompilerEvent = ECompilerEvent = {}));
-exports.COMPILER_FACTORIES = {
-    [type_1.ECompilerType.Rspack]: ((options, callback) => require("@rspack/core")(options, callback)),
-    [type_1.ECompilerType.Webpack]: ((options, callback) => require("webpack")(options, callback))
-};
 class TestCompilerManager {
-    constructor(type, factories = exports.COMPILER_FACTORIES) {
-        this.type = type;
-        this.factories = factories;
+    constructor() {
         this.compilerOptions = {};
         this.compilerInstance = null;
         this.compilerStats = null;
@@ -44,12 +37,12 @@ class TestCompilerManager {
         return this.compilerInstance;
     }
     createCompiler() {
-        this.compilerInstance = this.factories[this.type](this.compilerOptions);
+        this.compilerInstance = require("@rspack/core")(this.compilerOptions);
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }
     createCompilerWithCallback(callback) {
-        this.compilerInstance = this.factories[this.type](this.compilerOptions, callback);
+        this.compilerInstance = require("@rspack/core")(this.compilerOptions, callback);
         this.emitter.emit(ECompilerEvent.Create, this.compilerInstance);
         return this.compilerInstance;
     }

package/dist/helper/legacy/checkArrayExpectation.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 "use strict";
-const fs = require("graceful-fs");
+const fs = require("fs-extra");
 const path = require("node:path");
 const check = (expected, actual) => {
     if (expected instanceof RegExp) {

package/dist/helper/read-config-file.d.ts

@@ -1,2 +1,3 @@
-import type { ECompilerType, ITestContext, TCompilerOptions } from "../type";
-export declare function readConfigFile<T extends ECompilerType>(files: string[], context: ITestContext, prevOption?: TCompilerOptions<T>, functionApply?: (config: (TCompilerOptions<T> | ((...args: unknown[]) => TCompilerOptions<T>))[]) => TCompilerOptions<T>[]): TCompilerOptions<T>[];
+import type { RspackOptions } from "@rspack/core";
+import type { ITestContext } from "../type";
+export declare function readConfigFile(files: string[], context: ITestContext, prevOption?: RspackOptions, functionApply?: (config: (RspackOptions | ((...args: unknown[]) => RspackOptions))[]) => RspackOptions[]): RspackOptions[];

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./case";
-export * from "./compare";
 export * from "./helper";
 export * from "./plugin";
 export * from "./runner";

package/dist/index.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./case"), exports);
-__exportStar(require("./compare"), exports);
 __exportStar(require("./helper"), exports);
 __exportStar(require("./plugin"), exports);
 __exportStar(require("./runner"), exports);

package/dist/plugin/index.d.ts

@@ -1,4 +1 @@
 export * from "./lazy-compilation-test-plugin";
-export * from "./rspack-diff-config-plugin";
-export * from "./webpack-diff-config-plugin";
-export * from "./webpack-module-placeholder-plugin";

package/dist/plugin/index.js

@@ -15,6 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lazy-compilation-test-plugin"), exports);
-__exportStar(require("./rspack-diff-config-plugin"), exports);
-__exportStar(require("./webpack-diff-config-plugin"), exports);
-__exportStar(require("./webpack-module-placeholder-plugin"), exports);

package/dist/runner/node/index.d.ts

@@ -1,25 +1,26 @@
-import { type ECompilerType, type IGlobalContext, type IModuleScope, type ITestEnv, type ITestRunner, type TCompilerOptions, type TCompilerStatsCompilation, type TModuleObject, type TRunnerFile, type TRunnerRequirer, type TTestConfig } from "../../type";
+import type { RspackOptions, StatsCompilation } from "@rspack/core";
+import { type IGlobalContext, type IModuleScope, type ITestEnv, type ITestRunner, type TModuleObject, type TRunnerFile, type TRunnerRequirer, type TTestConfig } from "../../type";
 declare global {
     var printLogger: boolean;
 }
-export interface INodeRunnerOptions<T extends ECompilerType> {
+export interface INodeRunnerOptions {
     env: ITestEnv;
-    stats?: () => TCompilerStatsCompilation<T>;
+    stats?: () => StatsCompilation;
     name: string;
     runInNewContext?: boolean;
-    testConfig: TTestConfig<T>;
+    testConfig: TTestConfig;
     source: string;
     dist: string;
-    compilerOptions: TCompilerOptions<T>;
+    compilerOptions: RspackOptions;
     cachable?: boolean;
 }
-export declare class NodeRunner<T extends ECompilerType = ECompilerType.Rspack> implements ITestRunner {
-    protected _options: INodeRunnerOptions<T>;
+export declare class NodeRunner implements ITestRunner {
+    protected _options: INodeRunnerOptions;
     protected requireCache: any;
     protected globalContext: IGlobalContext | null;
     protected baseModuleScope: IModuleScope | null;
     protected requirers: Map<string, TRunnerRequirer>;
-    constructor(_options: INodeRunnerOptions<T>);
+    constructor(_options: INodeRunnerOptions);
     run(file: string): Promise<unknown>;
     getRequire(): TRunnerRequirer;
     getGlobal(name: string): unknown;

package/dist/runner/node/index.js

@@ -81,7 +81,9 @@ class NodeRunner {
             this._options.testConfig.moduleScope(this.baseModuleScope, this._options.stats, this._options.compilerOptions);
         }
         this.createRunner();
-        const res = this.getRequire()(this._options.dist, file.startsWith("./") || file.startsWith("https://test.cases/")
+        const res = this.getRequire()(node_path_1.default.isAbsolute(file) ? node_path_1.default.dirname(file) : this._options.dist, file.startsWith("./") ||
+            file.startsWith("https://test.cases/") ||
+            node_path_1.default.isAbsolute(file)
             ? file
             : `./${file}`);
         if (typeof res === "object" && "then" in res) {