@rspack/test-tools 1.0.13 → 1.1.0-beta.0

package/dist/helper/expect/to-match-file-snapshot.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toMatchFileSnapshot = void 0;
+exports.toMatchFileSnapshot = toMatchFileSnapshot;
 /* istanbul ignore file */
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -94,4 +94,3 @@ function toMatchFileSnapshot(content, filepath, options = {}) {
         message: () => `The output file ${chalk_1.default.blue(node_path_1.default.basename(filename))} ${chalk_1.default.bold.red("doesn't exist")}.`
     };
 }
-exports.toMatchFileSnapshot = toMatchFileSnapshot;

package/dist/helper/index.d.ts

@@ -4,3 +4,4 @@ export * from "./read-config-file";
 export * from "./update-snapshot";
 export * from "./win";
 export * from "./replace-paths";
+export * from "./util/checkStats";

package/dist/helper/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./read-config-file"), exports);
 __exportStar(require("./update-snapshot"), exports);
 __exportStar(require("./win"), exports);
 __exportStar(require("./replace-paths"), exports);
+__exportStar(require("./util/checkStats"), exports);

package/dist/helper/legacy/EventSourceForNode.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 export = EventSource;
 declare class EventSource {
     constructor(url: any);
     response: import("http").IncomingMessage | undefined;
     close(): void;
-    set onopen(arg: any);
-    set onmessage(arg: any);
+    set onopen(value: any);
+    set onmessage(value: any);
 }

package/dist/helper/legacy/FakeDocument.d.ts

@@ -37,10 +37,10 @@ export class FakeElement {
     removeAttribute(name: any): void;
     getAttribute(name: any): any;
     _toRealUrl(value: any): any;
-    set src(arg: any);
+    set src(value: any);
     get src(): any;
     get children(): any[];
-    set href(arg: any);
+    set href(value: any);
     get href(): any;
 }
 export class FakeSheet {

package/dist/helper/legacy/asModule.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 declare function _exports(something: any, context: any, unlinked: any): Promise<vm.Module>;
 export = _exports;
 import vm = require("node:vm");

package/dist/helper/legacy/createFakeWorker.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 declare function _exports(env: any, { outputDirectory }: {
     outputDirectory: any;
 }): {

package/dist/helper/legacy/fakeSystem.d.ts

@@ -1,8 +1,8 @@
 export function register(name: any, deps: any, fn: any): void;
 export function set(name: any, exports: any): void;
-export const registry: undefined;
-export const _require: undefined;
-export const _nextName: string;
+export let registry: undefined;
+export let _require: undefined;
+export let _nextName: string;
 export function setRequire(req: any): void;
 export function init(modules: any): void;
 export function execute(name: any): any;

package/dist/helper/legacy/walkCssTokens.d.ts

@@ -1,3 +1,6 @@
+declare namespace _exports {
+    export { CssTokenCallbacks, CharHandler };
+}
 declare function _exports(input: string, callbacks: CssTokenCallbacks): void;
 declare namespace _exports {
     export { isIdentStartCodePoint };
@@ -5,10 +8,9 @@ declare namespace _exports {
     export function eatWhitespace(input: string, pos: number): number;
     export function eatWhitespaceAndComments(input: string, pos: number): number;
     export function eatWhiteLine(input: string, pos: number): number;
-    export { CssTokenCallbacks, CharHandler };
 }
 export = _exports;
-export type CssTokenCallbacks = {
+type CssTokenCallbacks = {
     isSelector?: ((arg0: string, arg1: number) => boolean) | undefined;
     url?: ((arg0: string, arg1: number, arg2: number, arg3: number, arg4: number) => number) | undefined;
     string?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
@@ -26,7 +28,7 @@ export type CssTokenCallbacks = {
     semicolon?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
     comma?: ((arg0: string, arg1: number, arg2: number) => number) | undefined;
 };
-export type CharHandler = (arg0: string, arg1: number, arg2: CssTokenCallbacks) => number;
+type CharHandler = (arg0: string, arg1: number, arg2: CssTokenCallbacks) => number;
 /**
  * ident-start code point
  *

package/dist/helper/parse-modules.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseModules = void 0;
+exports.parseModules = parseModules;
 const BOOTSTRAP_SPLIT_LINE = "/************************************************************************/";
 const MODULE_START_FLAG = "/* start::";
 const MODULE_END_FLAG = "/* end::";
@@ -71,4 +71,3 @@ function parseModules(content, options = {}) {
         runtimeModules
     };
 }
-exports.parseModules = parseModules;

package/dist/helper/read-config-file.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readConfigFile = void 0;
+exports.readConfigFile = readConfigFile;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 function readConfigFile(files, functionApply) {
     const existsFile = files.find(i => fs_extra_1.default.existsSync(i));
@@ -11,4 +11,3 @@ function readConfigFile(files, functionApply) {
     const configArr = Array.isArray(fileConfig) ? fileConfig : [fileConfig];
     return functionApply ? functionApply(configArr) : configArr;
 }
-exports.readConfigFile = readConfigFile;

package/dist/helper/replace-paths.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replacePaths = void 0;
+exports.replacePaths = replacePaths;
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const serializer = require("jest-serializer-path");
@@ -22,4 +22,3 @@ function replacePaths(input) {
     }
     return normalizePaths(paths).split(rspackRoot).join("<RSPACK_ROOT>");
 }
-exports.replacePaths = replacePaths;

package/dist/helper/setup-env.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/setup-env.js

@@ -1,5 +1,6 @@
 "use strict";
 // @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
 if (process.env.ALTERNATIVE_SORT) {
     const oldSort = Array.prototype.sort;
     Array.prototype.sort = function (cmp) {

package/dist/helper/setup-expect.js

@@ -1,12 +1,69 @@
 "use strict";
-// @ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
+const char_1 = require("./expect/char");
+const diff_1 = require("./expect/diff");
+const error_1 = require("./expect/error");
+const placeholder_1 = require("./expect/placeholder");
+const rspack_1 = require("./expect/rspack");
 const to_be_typeof_1 = require("./expect/to-be-typeof");
 const to_end_with_1 = require("./expect/to-end-with");
 const to_match_file_snapshot_1 = require("./expect/to-match-file-snapshot");
+const { normalizePaths } = require("jest-serializer-path");
 expect.extend({
     // CHANGE: new test matcher for `rspack-test-tools`
+    // @ts-ignore
     toMatchFileSnapshot: to_match_file_snapshot_1.toMatchFileSnapshot,
     toBeTypeOf: to_be_typeof_1.toBeTypeOf,
     toEndWith: to_end_with_1.toEndWith
 });
+const pipes = [
+    char_1.normalizeSlash,
+    char_1.normalizeCLR,
+    char_1.normalizeCRLF,
+    placeholder_1.normalizePlaceholder,
+    normalizePaths
+];
+const serialize = (str, extra = []) => [...pipes, ...extra].reduce((res, transform) => transform(res), str);
+expect.addSnapshotSerializer({
+    test(received) {
+        return typeof received === "string";
+    },
+    print(received) {
+        return serialize(received.trim());
+    }
+});
+// for diff
+expect.addSnapshotSerializer({
+    test(received) {
+        return received?.constructor?.name === "RspackTestDiff";
+    },
+    print(received, next) {
+        return next((0, diff_1.normalizeDiff)(received));
+    }
+});
+// for errors
+expect.addSnapshotSerializer({
+    test(received) {
+        return received?.constructor?.name === "RspackStatsDiagnostics";
+    },
+    print(received, next) {
+        return next((0, error_1.normalizeDignostics)(received));
+    }
+});
+expect.addSnapshotSerializer({
+    test(received) {
+        return typeof received?.message === "string";
+    },
+    print(received, next) {
+        return next((0, error_1.normalizeError)(received));
+    }
+});
+// for stats
+expect.addSnapshotSerializer({
+    test(received) {
+        return received?.constructor?.name === "RspackStats";
+    },
+    print(received, next) {
+        return next((0, rspack_1.normalizeStats)(received));
+    }
+});

package/dist/helper/update-snapshot.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUpdateSnapshot = void 0;
+exports.isUpdateSnapshot = isUpdateSnapshot;
 function isUpdateSnapshot() {
     return global.updateSnapshot || process.env.UPDATE_SNAPSHOT === "true";
 }
-exports.isUpdateSnapshot = isUpdateSnapshot;

package/dist/helper/util/checkSourceMap.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = checkSourceMap;
 // @ts-nocheck
 // Check the mapping of various key locations back to the original source
 async function checkSourceMap(out, outCodeMap, toSearch, _checkColumn = true // passing `false` indicating it's an `OriginalSource`.
@@ -93,4 +94,3 @@ async function checkSourceMap(out, outCodeMap, toSearch, _checkColumn = true //
     }
     return !failed;
 }
-exports.default = checkSourceMap;

package/dist/helper/util/checkStats.d.ts

@@ -0,0 +1,2 @@
+export function checkChunkModules(statsJson: any, chunkModulesMap: any, strict?: boolean): boolean;
+export function checkChunkRuntime(statsJson: any, chunkModulesMap: any, strict?: boolean): boolean;

package/dist/helper/util/checkStats.js

@@ -0,0 +1,43 @@
+"use strict";
+// @ts-nocheck
+exports.checkChunkModules = function checkChunkModules(statsJson, chunkModulesMap, strict = true) {
+    for (const chunkId of Reflect.ownKeys(chunkModulesMap)) {
+        const chunk = getChunk(statsJson, chunkId);
+        const expectedModules = chunkModulesMap[chunkId];
+        const chunkModules = chunk.modules.map(m => m.identifier);
+        if (strict) {
+            expectedModules.length === chunkModules.length;
+        }
+        for (const module of expectedModules) {
+            if (!chunkModules.find(moduleId => moduleId.includes(module))) {
+                throw new Error(`chunk ${chunkId} has no module contains id: ${module}`);
+            }
+        }
+    }
+    return true;
+};
+exports.checkChunkRuntime = function checkChunkModules(statsJson, chunkModulesMap, strict = true) {
+    for (const chunkId of Reflect.ownKeys(chunkModulesMap)) {
+        const chunk = getChunk(statsJson, chunkId);
+        const expectedRuntime = chunkModulesMap[chunkId];
+        const chunkRuntime = chunk.runtime;
+        if (strict) {
+            expectedRuntime.length === chunkRuntime.length;
+        }
+        for (let i = 0; i < expectedRuntime.length; i++) {
+            const expected = expectedRuntime[i];
+            const rt = chunkRuntime[i];
+            if (expected !== rt) {
+                throw new Error(`chunk ${chunkId} runtime not equal, expected: ${expectedRuntime}, but got: ${chunkRuntime}`);
+            }
+        }
+    }
+    return true;
+};
+function getChunk(statsJson, id) {
+    const chunk = statsJson.chunks.find(chunk => chunk.id.includes(id));
+    if (!chunk) {
+        throw new Error(`cannot find chunk with id: ${id}`);
+    }
+    return chunk;
+}

package/dist/helper/util/filterUtil.d.ts

@@ -1,8 +1,8 @@
 export namespace FilteredStatus {
-    const TODO: string;
-    const PARTIAL_PASS: string;
-    const FAILED: string;
-    const NO_PLAN: string;
+    let TODO: string;
+    let PARTIAL_PASS: string;
+    let FAILED: string;
+    let NO_PLAN: string;
 }
 export function decodeFilteredTest(encoded: any): any;
 export function normalizeFilteredTestName(flag: any, testName: any): string;

package/dist/helper/util/identifier.d.ts

@@ -24,8 +24,8 @@ export namespace makePathsRelative {
  * @param {Object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} the returned relative path
  */
-export function makePathsAbsolute(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-export namespace makePathsAbsolute { }
+export function makePathsRelative(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
+export namespace makePathsRelative { }
 /**
  * @param {string} str the path with query and fragment
  * @param {Object=} associatedObjectForCache an object to which the cache will be attached
@@ -40,8 +40,8 @@ export namespace parseResource {
  * @param {Object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {ParsedResource} parsed parts
  */
-export function parseResourceWithoutFragment(str: string, associatedObjectForCache?: Object | undefined): ParsedResource;
-export namespace parseResourceWithoutFragment { }
+export function parseResource(str: string, associatedObjectForCache?: Object | undefined): ParsedResource;
+export namespace parseResource { }
 export function getUndoPath(filename: string, outputPath: string, enforceRelative: boolean): string;
 export type MakeRelativePathsCache = {
     relativePaths?: Map<string, Map<string, string>> | undefined;
@@ -63,14 +63,14 @@ export type ParsedResourceWithoutFragment = {
  * @param {Object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} the returned relative path
  */
-export function contextify(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-export namespace contextify { }
+declare function makePathsRelative(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
+declare namespace makePathsRelative { }
 /**
  * @param {string} context context used to create relative path
  * @param {string} identifier identifier used to create relative path
  * @param {Object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} the returned relative path
  */
-export function absolutify(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-export namespace absolutify { }
-import path = require("path");
+declare function makePathsRelative(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
+declare namespace makePathsRelative { }
+export { contextify, absolutify };

package/dist/helper/win.js

@@ -3,13 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeEOL = exports.escapeSep = void 0;
+exports.escapeSep = escapeSep;
+exports.escapeEOL = escapeEOL;
 const node_path_1 = __importDefault(require("node:path"));
 function escapeSep(str) {
     return str.split(node_path_1.default.win32.sep).join(node_path_1.default.posix.sep);
 }
-exports.escapeSep = escapeSep;
 function escapeEOL(str) {
     return str.split("\r\n").join("\n").trim();
 }
-exports.escapeEOL = escapeEOL;

package/dist/processor/defaults.d.ts

@@ -1,8 +1,6 @@
-/// <reference types="jest" />
-/// <reference types="../jest.d.ts" />
 import type { ECompilerType, ITestContext, ITestEnv, TCompilerOptions } from "../type";
 import { SimpleTaskProcessor } from "./simple";
-declare class Diff {
+declare class RspackTestDiff {
     value: string;
     constructor(value: string);
 }
@@ -10,7 +8,7 @@ export interface IDefaultsConfigProcessorOptions<T extends ECompilerType> {
     options?: (context: ITestContext) => TCompilerOptions<T>;
     cwd?: string;
     name: string;
-    diff: (diff: jest.JestMatchers<Diff>, defaults: jest.JestMatchers<TCompilerOptions<T>>) => Promise<void>;
+    diff: (diff: jest.JestMatchers<RspackTestDiff>, defaults: jest.JestMatchers<TCompilerOptions<T>>) => Promise<void>;
     compilerType: T;
 }
 export declare class DefaultsConfigProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
@@ -27,6 +25,5 @@ export declare class DefaultsConfigProcessor<T extends ECompilerType> extends Si
     afterAll(context: ITestContext): Promise<void>;
     protected getCompiler(context: ITestContext): import("../type").ITestCompilerManager<T>;
     static getDefaultConfig(cwd: string, config: TCompilerOptions<ECompilerType>): TCompilerOptions<ECompilerType>;
-    static addSnapshotSerializer(expectImpl: jest.Expect): void;
 }
 export {};

package/dist/processor/defaults.js

@@ -8,23 +8,7 @@ const jest_diff_1 = require("jest-diff");
 const strip_ansi_1 = __importDefault(require("strip-ansi"));
 const simple_1 = require("./simple");
 const CURRENT_CWD = process.cwd();
-const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-const cwdRegExp = new RegExp(`${quoteMeta(CURRENT_CWD)}((?:\\\\)?(?:[a-zA-Z.\\-_]+\\\\)*)`, "g");
-const escapedCwd = JSON.stringify(CURRENT_CWD).slice(1, -1);
-const escapedCwdRegExp = new RegExp(`${quoteMeta(escapedCwd)}((?:\\\\\\\\)?(?:[a-zA-Z.\\-_]+\\\\\\\\)*)`, "g");
-const normalize = (str) => {
-    let normalizedStr;
-    if (CURRENT_CWD.startsWith("/")) {
-        normalizedStr = str.replace(new RegExp(quoteMeta(CURRENT_CWD), "g"), "<cwd>");
-    }
-    else {
-        normalizedStr = str.replace(cwdRegExp, (_, g) => `<cwd>${g.replace(/\\/g, "/")}`);
-        normalizedStr = normalizedStr.replace(escapedCwdRegExp, (_, g) => `<cwd>${g.replace(/\\\\/g, "/")}`);
-    }
-    normalizedStr = normalizedStr.replace(/@@ -\d+,\d+ \+\d+,\d+ @@/g, "@@ ... @@");
-    return normalizedStr;
-};
-class Diff {
+class RspackTestDiff {
     constructor(value) {
         this.value = value;
     }
@@ -60,7 +44,7 @@ class DefaultsConfigProcessor extends simple_1.SimpleTaskProcessor {
         const compiler = this.getCompiler(context);
         const config = DefaultsConfigProcessor.getDefaultConfig(this._defaultsConfigOptions.cwd || CURRENT_CWD, compiler.getOptions());
         const diff = (0, strip_ansi_1.default)((0, jest_diff_1.diff)(this.defaultConfig, config, { expand: false, contextLines: 0 }));
-        await this._defaultsConfigOptions.diff(env.expect(new Diff(diff)), env.expect(this.defaultConfig));
+        await this._defaultsConfigOptions.diff(env.expect(new RspackTestDiff(diff)), env.expect(this.defaultConfig));
     }
     async before(context) { }
     async after(context) { }
@@ -80,23 +64,5 @@ class DefaultsConfigProcessor extends simple_1.SimpleTaskProcessor {
         process.chdir(CURRENT_CWD);
         return normalizedConfig;
     }
-    static addSnapshotSerializer(expectImpl) {
-        expectImpl.addSnapshotSerializer({
-            test(value) {
-                return value instanceof Diff;
-            },
-            print(received) {
-                return normalize(received.value);
-            }
-        });
-        expectImpl.addSnapshotSerializer({
-            test(value) {
-                return typeof value === "string";
-            },
-            print(received) {
-                return JSON.stringify(normalize(received));
-            }
-        });
-    }
 }
 exports.DefaultsConfigProcessor = DefaultsConfigProcessor;

package/dist/processor/error.d.ts

@@ -1,18 +1,17 @@
-/// <reference types="jest" />
-/// <reference types="../jest.d.ts" />
 import type { StatsError } from "@rspack/core";
 import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions } from "../type";
 import { SimpleTaskProcessor } from "./simple";
-type TStatsDiagnostics = {
+declare class RspackStatsDiagnostics {
     errors: StatsError[];
     warnings: StatsError[];
-};
+    constructor(errors: StatsError[], warnings: StatsError[]);
+}
 export interface IErrorProcessorOptions<T extends ECompilerType> {
     name: string;
     compilerType: T;
     options?: (options: TCompilerOptions<T>, context: ITestContext) => TCompilerOptions<T>;
     build?: (context: ITestContext, compiler: TCompiler<T>) => Promise<void>;
-    check?: (stats: TStatsDiagnostics) => Promise<void>;
+    check?: (stats: RspackStatsDiagnostics) => Promise<void>;
 }
 export declare class ErrorProcessor<T extends ECompilerType> extends SimpleTaskProcessor<T> {
     protected _errorOptions: IErrorProcessorOptions<T>;
@@ -20,6 +19,5 @@ export declare class ErrorProcessor<T extends ECompilerType> extends SimpleTaskP
     compiler(context: ITestContext): Promise<void>;
     run(env: ITestEnv, context: ITestContext): Promise<void>;
     check(env: ITestEnv, context: ITestContext): Promise<void>;
-    static addSnapshotSerializer(expectImpl: jest.Expect): void;
 }
 export {};

package/dist/processor/error.js

@@ -5,51 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorProcessor = void 0;
 const node_path_1 = __importDefault(require("node:path"));
-const pretty_format_1 = __importDefault(require("pretty-format"));
 const webpack_merge_1 = __importDefault(require("webpack-merge"));
 const simple_1 = require("./simple");
-const CWD_PATTERN = new RegExp(node_path_1.default.join(process.cwd(), "../../").replace(/\\/g, "/"), "gm");
-const ERROR_STACK_PATTERN = /(│.* at ).*/g;
-function cleanErrorStack(message) {
-    return message.replace(ERROR_STACK_PATTERN, "$1xxx");
-}
-function cleanError(err) {
-    const result = {};
-    for (const key of Object.getOwnPropertyNames(err)) {
-        result[key] = err[key];
-    }
-    if (result.message) {
-        result.message = cleanErrorStack(err.message);
+class RspackStatsDiagnostics {
+    constructor(errors, warnings) {
+        this.errors = errors;
+        this.warnings = warnings;
     }
-    if (result.stack) {
-        result.stack = cleanErrorStack(result.stack);
-    }
-    return result;
-}
-function serialize(received) {
-    return ((0, pretty_format_1.default)(received, prettyFormatOptions)
-        .replace(CWD_PATTERN, "<cwd>")
-        // replace line numbers in error stacks
-        .replace(/:\d+:\d+/g, ":<line>:<col>")
-        .trim());
 }
-const prettyFormatOptions = {
-    escapeRegex: false,
-    printFunctionName: false,
-    plugins: [
-        {
-            test(val) {
-                return typeof val === "string";
-            },
-            print(val) {
-                return `"${val
-                    .replace(/\\/gm, "/")
-                    .replace(/"/gm, '\\"')
-                    .replace(/\r?\n/gm, "\\n")}"`;
-            }
-        }
-    ]
-};
 class ErrorProcessor extends simple_1.SimpleTaskProcessor {
     constructor(_errorOptions) {
         super({
@@ -126,31 +89,7 @@ class ErrorProcessor extends simple_1.SimpleTaskProcessor {
         const { errors, warnings } = statsResult;
         env.expect(Array.isArray(errors)).toBe(true);
         env.expect(Array.isArray(warnings)).toBe(true);
-        await this._errorOptions.check?.({
-            errors: errors,
-            warnings: warnings
-        });
-    }
-    static addSnapshotSerializer(expectImpl) {
-        expectImpl.addSnapshotSerializer({
-            test(received) {
-                return received.errors || received.warnings;
-            },
-            print(received) {
-                return serialize({
-                    errors: received.errors.map(e => cleanError(e)),
-                    warnings: received.warnings.map(e => cleanError(e))
-                });
-            }
-        });
-        expectImpl.addSnapshotSerializer({
-            test(received) {
-                return received.message;
-            },
-            print(received) {
-                return serialize(cleanError(received));
-            }
-        });
+        await this._errorOptions.check?.(new RspackStatsDiagnostics(errors, warnings));
     }
 }
 exports.ErrorProcessor = ErrorProcessor;

package/dist/processor/hook.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { type TTestContextOptions, TestContext } from "../test/context";
 import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions } from "../type";
 import { type ISnapshotProcessorOptions, SnapshotProcessor } from "./snapshot";

package/dist/processor/hot-new-incremental.js

@@ -29,15 +29,7 @@ class HotNewIncrementalProcessor extends hot_1.HotProcessor {
         if (this._hotOptions.compilerType === type_1.ECompilerType.Rspack) {
             const rspackOptions = options;
             rspackOptions.experiments ??= {};
-            rspackOptions.experiments.incremental ??= {
-                make: true,
-                emitAssets: true,
-                inferAsyncModules: true,
-                providedExports: true,
-                moduleHashes: true,
-                moduleCodegen: true,
-                moduleRuntimeRequirements: true
-            };
+            rspackOptions.experiments.incremental ??= true;
         }
         else {
             throw new Error("HotNewIncrementalProcessor should only used for Rspack.");

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

@@ -1,5 +1,3 @@
-/// <reference types="jest" />
-/// <reference types="../jest.d.ts" />
 import type { ECompilerType, ITestContext, ITestEnv, TCompiler, TCompilerOptions, TCompilerStats } from "../type";
 import { SimpleTaskProcessor } from "./simple";
 export interface IStatsAPIProcessorOptions<T extends ECompilerType> {
@@ -16,5 +14,4 @@ export declare class StatsAPIProcessor<T extends ECompilerType> extends SimpleTa
     compiler(context: ITestContext): Promise<void>;
     run(env: ITestEnv, context: ITestContext): Promise<void>;
     check(env: ITestEnv, context: ITestContext): Promise<void>;
-    static addSnapshotSerializer(expectImpl: jest.Expect): void;
 }

package/dist/processor/stats-api.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatsAPIProcessor = void 0;
 const memfs_1 = require("memfs");
 const simple_1 = require("./simple");
-const serializer = require("jest-serializer-path");
 class StatsAPIProcessor extends simple_1.SimpleTaskProcessor {
     constructor(_statsAPIOptions) {
         super({
@@ -40,8 +39,5 @@ class StatsAPIProcessor extends simple_1.SimpleTaskProcessor {
         env.expect(typeof stats).toBe("object");
         await this._statsAPIOptions.check?.(stats, compiler.getCompiler());
     }
-    static addSnapshotSerializer(expectImpl) {
-        expectImpl.addSnapshotSerializer(serializer);
-    }
 }
 exports.StatsAPIProcessor = StatsAPIProcessor;