@rspack/test-tools 1.0.13 → 1.0.14

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

package/dist/processor/stats.js

@@ -10,9 +10,11 @@ const helper_1 = require("../helper");
 const captureStdio_1 = __importDefault(require("../helper/legacy/captureStdio"));
 const multi_1 = require("./multi");
 const REG_ERROR_CASE = /error$/;
-const quoteMeta = (str) => {
-    return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+class RspackStats {
+    constructor(value) {
+        this.value = value;
+    }
+}
 class StatsProcessor extends multi_1.MultiTaskProcessor {
     constructor(_statsOptions) {
         super({
@@ -124,37 +126,14 @@ class StatsProcessor extends multi_1.MultiTaskProcessor {
         }
         let actual = stats.toString(toStringOptions);
         env.expect(typeof actual).toBe("string");
+        actual = this.stderr.toString() + actual;
         if (!hasColorSetting) {
-            actual = this.stderr.toString() + actual;
             actual = actual
                 .replace(/\u001b\[[0-9;]*m/g, "")
                 // CHANGE: The time unit display in Rspack is second
                 .replace(/[.0-9]+(\s?s)/g, "X$1");
         }
-        else {
-            actual = this.stderr.toStringRaw() + actual;
-            // eslint-disable-no-control-regex
-            actual = actual
-                .replace(/\u001b\[1m\u001b\[([0-9;]*)m/g, "<CLR=$1,BOLD>")
-                .replace(/\u001b\[1m/g, "<CLR=BOLD>")
-                .replace(/\u001b\[39m\u001b\[22m/g, "</CLR>")
-                .replace(/\u001b\[([0-9;]*)m/g, "<CLR=$1>")
-                // CHANGE: The time unit display in Rspack is second
-                .replace(/[.0-9]+(<\/CLR>)?(\s?s)/g, "X$1$2");
-        }
-        // cspell:ignore Xdir
-        const testPath = context.getSource();
-        actual = actual
-            .replace(/\r\n?/g, "\n")
-            // CHANGE: Remove potential line break and "|" caused by long text
-            .replace(/((ERROR|WARNING)([\s\S](?!╭|├))*?)(\n {2}│ )/g, "$1")
-            // CHANGE: Update the regular expression to replace the 'Rspack' version string
-            .replace(/Rspack [^ )]+(\)?) compiled/g, "Rspack x.x.x$1 compiled")
-            .replace(new RegExp(quoteMeta(testPath), "g"), `Xdir/${node_path_1.default.basename(this._options.name)}`)
-            .replace(/(\w)\\(\w)/g, "$1/$2")
-            .replace(/, additional resolving: X ms/g, "")
-            .replace(/Unexpected identifier '.+?'/g, "Unexpected identifier");
-        env.expect(actual).toMatchSnapshot();
+        env.expect(new RspackStats(actual)).toMatchSnapshot();
         const testConfig = context.getTestConfig();
         if (typeof testConfig?.validate === "function") {
             testConfig.validate(stats, this.stderr.toString());