@rspack-canary/test-tools 1.5.9-canary-a915dabc-20251013174148 → 1.5.9-canary-e259bc79-20251014173821

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, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;
+export declare function createHotStepCase(name: string, src: string, dist: string, temp: string, target: TCompilerOptions<ECompilerType.Rspack>["target"]): void;

package/dist/case/hot-step.js

@@ -39,8 +39,8 @@ const GET_MODULE_HANDLER = {
     node: NODE_HANDLER
 };
 const creators = new Map();
-function createHotStepProcessor(name, target) {
-    const processor = (0, hot_1.createHotProcessor)(name, target);
+function createHotStepProcessor(name, src, temp, target) {
+    const processor = (0, hot_1.createHotProcessor)(name, src, temp, target);
     const entries = {};
     const hashes = [];
     function matchStepSnapshot(env, context, step, options, stats, runtime) {
@@ -53,7 +53,9 @@ function createHotStepProcessor(name, target) {
         const hotUpdateManifest = [];
         const changedFiles = step === 0
             ? []
-            : processor.hotUpdateContext.changedFiles.map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(context.getSource(), i)));
+            : processor.updatePlugin
+                .getModifiedFiles()
+                .map((i) => (0, helper_1.escapeSep)(node_path_1.default.relative(temp, i)));
         changedFiles.sort();
         const resultHashes = {
             [lastHash || "LAST_HASH"]: "LAST_HASH",
@@ -245,7 +247,7 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
     }
     const originRun = processor.run;
     processor.run = async function (env, context) {
-        context.setValue(name, "hotUpdateStepChecker", (hotUpdateContext, stats, runtime) => {
+        context.setValue(name, "hotUpdateStepChecker", (updateIndex, stats, runtime) => {
             const statsJson = stats.toJson({
                 assets: true,
                 chunks: true
@@ -264,10 +266,10 @@ ${runtime.javascript.disposedModules.map(i => `- ${i}`).join("\n")}
             }
             const compiler = context.getCompiler(name, type_1.ECompilerType.Rspack);
             const compilerOptions = compiler.getOptions();
-            matchStepSnapshot(env, context, hotUpdateContext.updateIndex, compilerOptions, statsJson, runtime);
+            matchStepSnapshot(env, context, updateIndex, compilerOptions, statsJson, runtime);
             hashes.push(stats.hash);
         });
-        context.setValue(name, "hotUpdateStepErrorChecker", (_, stats, runtime) => {
+        context.setValue(name, "hotUpdateStepErrorChecker", (updateIndex, stats, runtime) => {
             hashes.push(stats.hash);
         });
         await originRun(env, context);
@@ -312,8 +314,8 @@ function getCreator(target) {
             clean: true,
             describe: false,
             target,
-            steps: ({ name, target }) => [
-                createHotStepProcessor(name, target)
+            steps: ({ name, target, src, temp, dist }) => [
+                createHotStepProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
             ],
             runner: {
                 key: (context, name, file) => name,
@@ -324,7 +326,7 @@ function getCreator(target) {
     }
     return creators.get(target);
 }
-function createHotStepCase(name, src, dist, target) {
+function createHotStepCase(name, src, dist, temp, target) {
     const creator = getCreator(target);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }

package/dist/case/hot.d.ts

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

package/dist/case/hot.js

@@ -9,27 +9,27 @@ exports.createHotRunner = createHotRunner;
 const node_path_1 = __importDefault(require("node:path"));
 const core_1 = __importDefault(require("@rspack/core"));
 const helper_1 = require("../helper");
+const plugin_1 = require("../helper/hot-update/plugin");
 const checkArrayExpectation_1 = __importDefault(require("../helper/legacy/checkArrayExpectation"));
-const plugins_1 = require("../helper/plugins");
-const plugin_1 = require("../plugin");
+const plugin_2 = require("../plugin");
 const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
 const common_1 = require("./common");
 const runner_2 = require("./runner");
 const creators = new Map();
-function createHotProcessor(name, target, incremental = false) {
-    const hotUpdateContext = {
-        updateIndex: 0,
-        totalUpdates: 1,
-        changedFiles: []
-    };
+function createHotProcessor(name, src, temp, target, incremental = false) {
+    const updatePlugin = new plugin_1.HotUpdatePlugin(src, temp);
     const processor = {
+        before: async (context) => {
+            await updatePlugin.initialize();
+            context.setValue(name, "hotUpdatePlugin", updatePlugin);
+        },
         config: async (context) => {
             const compiler = (0, common_1.getCompiler)(context, name);
-            let options = defaultOptions(context, target, hotUpdateContext);
+            let options = defaultOptions(context, target);
             options = await (0, common_1.config)(context, name, ["rspack.config.js", "webpack.config.js"], options);
-            overrideOptions(context, options, target, hotUpdateContext);
+            overrideOptions(context, options, target, updatePlugin);
             if (incremental) {
                 options.experiments ??= {};
                 options.experiments.incremental ??= "advance-silent";
@@ -43,8 +43,7 @@ function createHotProcessor(name, target, incremental = false) {
             await (0, common_1.build)(context, name);
         },
         run: async (env, context) => {
-            context.setValue(name, "hotUpdateContext", hotUpdateContext);
-            await (0, common_1.run)(env, context, name, context => findBundle(context, name, target, hotUpdateContext));
+            await (0, common_1.run)(env, context, name, context => findBundle(context, name, target, updatePlugin));
         },
         check: async (env, context) => {
             await (0, common_1.check)(env, context, name);
@@ -53,12 +52,14 @@ function createHotProcessor(name, target, incremental = false) {
             if (context.getTestConfig().checkSteps === false) {
                 return;
             }
-            if (hotUpdateContext.updateIndex + 1 !== hotUpdateContext.totalUpdates) {
-                throw new Error(`Should run all hot steps (${hotUpdateContext.updateIndex + 1} / ${hotUpdateContext.totalUpdates}): ${name}`);
+            const updateIndex = updatePlugin.getUpdateIndex();
+            const totalUpdates = updatePlugin.getTotalUpdates();
+            if (updateIndex + 1 !== totalUpdates) {
+                throw new Error(`Should run all hot steps (${updateIndex + 1} / ${totalUpdates}): ${name}`);
             }
         }
     };
-    processor.hotUpdateContext = hotUpdateContext;
+    processor.updatePlugin = updatePlugin;
     return processor;
 }
 function getCreator(target) {
@@ -67,8 +68,8 @@ function getCreator(target) {
             clean: true,
             describe: true,
             target,
-            steps: ({ name, target }) => [
-                createHotProcessor(name, target)
+            steps: ({ name, target, src, dist, temp }) => [
+                createHotProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target)
             ],
             runner: {
                 key: (context, name, file) => name,
@@ -79,11 +80,11 @@ function getCreator(target) {
     }
     return creators.get(target);
 }
-function createHotCase(name, src, dist, target) {
+function createHotCase(name, src, dist, temp, target) {
     const creator = getCreator(target);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }
-function defaultOptions(context, target, updateOptions) {
+function defaultOptions(context, target) {
     const options = {
         context: context.getSource(),
         mode: "development",
@@ -112,10 +113,10 @@ function defaultOptions(context, target, updateOptions) {
         }
     };
     options.plugins ??= [];
-    options.plugins.push(new core_1.default.HotModuleReplacementPlugin(), new plugins_1.TestHotUpdatePlugin(updateOptions));
+    options.plugins.push(new core_1.default.HotModuleReplacementPlugin());
     return options;
 }
-function overrideOptions(context, options, target, updateOptions) {
+function overrideOptions(context, options, target, updatePlugin) {
     if (!options.entry) {
         options.entry = "./index.js";
     }
@@ -126,34 +127,24 @@ function overrideOptions(context, options, target, updateOptions) {
         options.module.generator[cssModuleType].exportsOnly ??=
             target === "async-node";
     }
-    options.module.rules ??= [];
-    options.module.rules.push({
-        use: [
-            {
-                loader: node_path_1.default.resolve(__dirname, "../helper/loaders/hot-update.js"),
-                options: updateOptions
-            }
-        ],
-        enforce: "pre"
-    });
     options.plugins ??= [];
-    options.plugins.push(new core_1.default.LoaderOptionsPlugin(updateOptions));
+    options.plugins.push(updatePlugin);
     if (!global.printLogger) {
         options.infrastructureLogging = {
             level: "error"
         };
     }
     if (options.lazyCompilation) {
-        options.plugins.push(new plugin_1.LazyCompilationTestPlugin());
+        options.plugins.push(new plugin_2.LazyCompilationTestPlugin());
     }
 }
-function findBundle(context, name, target, updateOptions) {
+function findBundle(context, name, target, updatePlugin) {
     const compiler = context.getCompiler(name);
     if (!compiler)
         throw new Error("Compiler should exists when find bundle");
     const testConfig = context.getTestConfig();
     if (typeof testConfig.findBundle === "function") {
-        return testConfig.findBundle(updateOptions.updateIndex, compiler.getOptions());
+        return testConfig.findBundle(updatePlugin.getUpdateIndex(), compiler.getOptions());
     }
     const files = [];
     const prefiles = [];
@@ -183,11 +174,11 @@ function createHotRunner(context, name, file, env) {
     const testConfig = context.getTestConfig();
     const source = context.getSource();
     const dist = context.getDist();
-    const hotUpdateContext = context.getValue(name, "hotUpdateContext");
+    const updatePlugin = context.getValue(name, "hotUpdatePlugin");
     const next = async (callback) => {
         const usePromise = typeof callback === "function";
         try {
-            hotUpdateContext.updateIndex++;
+            await updatePlugin.goNext();
             const stats = await compiler.build();
             if (!stats) {
                 throw new Error("Should generate stats during build");
@@ -200,10 +191,10 @@ function createHotRunner(context, name, file, env) {
                 ? "hotUpdateStepErrorChecker"
                 : "hotUpdateStepChecker");
             if (checker) {
-                checker(hotUpdateContext, stats, runner.getGlobal("__HMR_UPDATED_RUNTIME__"));
+                checker(updatePlugin.getUpdateIndex(), stats, runner.getGlobal("__HMR_UPDATED_RUNTIME__"));
             }
-            await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${hotUpdateContext.updateIndex}`, "Error", compilerOptions);
-            await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${hotUpdateContext.updateIndex}`, "Warning", compilerOptions);
+            await (0, checkArrayExpectation_1.default)(source, jsonStats, "error", `errors${updatePlugin.getUpdateIndex()}`, "Error", compilerOptions);
+            await (0, checkArrayExpectation_1.default)(source, jsonStats, "warning", `warnings${updatePlugin.getUpdateIndex()}`, "Warning", compilerOptions);
             if (usePromise) {
                 // old callback style hmr cases
                 callback(null, jsonStats);

package/dist/case/incremental.d.ts

@@ -1,5 +1,5 @@
 import { type ECompilerType, type TCompilerOptions } from "../type";
-export declare function createHotIncrementalCase(name: string, src: string, dist: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], webpackCases: boolean): void;
+export declare function createHotIncrementalCase(name: string, src: string, dist: string, temp: string, target: TCompilerOptions<ECompilerType.Rspack>["target"], webpackCases: boolean): void;
 export type WatchIncrementalOptions = {
     ignoreNotFriendlyForIncrementalWarnings?: boolean;
 };

package/dist/case/incremental.js

@@ -12,9 +12,11 @@ const type_1 = require("../type");
 const hot_1 = require("./hot");
 const watch_1 = require("./watch");
 const hotCreators = new Map();
-function createHotIncrementalProcessor(name, target, webpackCases) {
-    const processor = (0, hot_1.createHotProcessor)(name, target, true);
+function createHotIncrementalProcessor(name, src, temp, target, webpackCases) {
+    const processor = (0, hot_1.createHotProcessor)(name, src, temp, target, true);
+    const originalBefore = processor.before;
     processor.before = async (context) => {
+        await originalBefore?.(context);
         context.setValue(name, "documentType", webpackCases ? type_1.EDocumentType.Fake : type_1.EDocumentType.JSDOM);
     };
     const originalAfterAll = processor.afterAll;
@@ -38,8 +40,8 @@ function getHotCreator(target, webpackCases) {
             clean: true,
             describe: true,
             target,
-            steps: ({ name, target }) => [
-                createHotIncrementalProcessor(name, target, webpackCases)
+            steps: ({ name, target, src, temp, dist }) => [
+                createHotIncrementalProcessor(name, src, temp || node_path_1.default.resolve(dist, "temp"), target, webpackCases)
             ],
             runner: {
                 key: (context, name, file) => name,
@@ -50,9 +52,9 @@ function getHotCreator(target, webpackCases) {
     }
     return hotCreators.get(key);
 }
-function createHotIncrementalCase(name, src, dist, target, webpackCases) {
+function createHotIncrementalCase(name, src, dist, temp, target, webpackCases) {
     const creator = getHotCreator(target, webpackCases);
-    creator.create(name, src, dist);
+    creator.create(name, src, dist, temp);
 }
 const watchCreators = new Map();
 function getWatchCreator(options) {

package/dist/case/normal.js

@@ -199,10 +199,6 @@ function defaultOptions(context, compilerOptions, mode) {
             // Turning off here to fallback to webpack's default css processing logic.
             ...(compilerOptions?.module ? { outputModule: true } : {})
         }
-        // infrastructureLogging: compilerOptions?.cache && {
-        //   debug: true,
-        //   console: createLogger(infraStructureLog)
-        // }
     };
 }
 function overrideOptions(context, options) {

package/dist/case/watch.js

@@ -19,8 +19,6 @@ const runner_1 = require("../runner");
 const creator_1 = require("../test/creator");
 const type_1 = require("../type");
 const common_1 = require("./common");
-// This file is used to port step number to rspack.config.js/webpack.config.js
-const currentWatchStepModulePath = node_path_1.default.resolve(__dirname, "../helper/util/currentWatchStep");
 function createWatchInitialProcessor(name, tempDir, step, watchState, { incremental = false, nativeWatcher = false } = {}) {
     const watchContext = {
         currentTriggerFilename: null,
@@ -61,8 +59,6 @@ function createWatchInitialProcessor(name, tempDir, step, watchState, { incremen
         },
         build: async (context) => {
             const compiler = (0, common_1.getCompiler)(context, name);
-            const currentWatchStepModule = require(currentWatchStepModulePath);
-            currentWatchStepModule.step[name] = watchContext.step;
             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) => {
@@ -171,10 +167,7 @@ function createWatchStepProcessor(name, tempDir, step, watchState, { incremental
         // do nothing
     };
     processor.build = async (context) => {
-        const watchContext = context.getValue(name, "watchContext");
         const compiler = (0, common_1.getCompiler)(context, name);
-        const currentWatchStepModule = require(currentWatchStepModulePath);
-        currentWatchStepModule.step[name] = watchContext.step;
         const task = new Promise((resolve, reject) => {
             compiler.getEmitter().once(compiler_1.ECompilerEvent.Build, (e, stats) => {
                 if (e)

package/dist/helper/hot-update/plugin.d.ts

@@ -6,10 +6,10 @@ export declare class HotUpdatePlugin {
     private updateIndex;
     private files;
     constructor(projectDir: string, tempDir: string);
-    private getModifiedFiles;
     private getContent;
     private updateFiles;
     initialize(): Promise<void>;
+    getModifiedFiles(): string[];
     getUpdateIndex(): number;
     getTotalUpdates(): number;
     goNext(): Promise<void>;

package/dist/helper/hot-update/plugin.js

@@ -29,9 +29,6 @@ class HotUpdatePlugin {
         this.updateIndex = 0;
         this.files = {};
     }
-    getModifiedFiles() {
-        return Object.keys(this.files);
-    }
     getContent(filePath, index) {
         const contents = this.files[filePath] || [];
         let content = contents[index] === undefined ? contents.at(-1) || "" : contents[index];
@@ -86,13 +83,16 @@ class HotUpdatePlugin {
         });
         await this.updateFiles();
     }
+    getModifiedFiles() {
+        return Object.keys(this.files);
+    }
     getUpdateIndex() {
         return this.updateIndex;
     }
     getTotalUpdates() {
         return Object.values(this.files).reduce((max, item) => {
             return Math.max(max, item.length);
-        }, 0);
+        }, 1);
     }
     async goNext() {
         this.updateIndex++;

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

@@ -0,0 +1,2 @@
+declare function _exports(done: any, options: any, callback: any): (err: any, stats: any) => any;
+export = _exports;

package/dist/helper/legacy/update.esm.d.ts

@@ -0,0 +1 @@
+export default function update(done: any, options: any, callback: any): (err: any, stats: any) => any;

package/dist/helper/legacy/update.esm.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+// @ts-nocheck
+function update(done, options, callback) {
+    return function (err, stats) {
+        if (err)
+            return done(err);
+        import.meta.webpackHot
+            .check(options || true)
+            .then(updatedModules => {
+            if (!updatedModules) {
+                return done(new Error("No update available"));
+            }
+            if (callback)
+                callback(stats);
+        })
+            .catch(err => {
+            done(err);
+        });
+    };
+}
+;

package/dist/helper/legacy/update.js

@@ -0,0 +1,19 @@
+"use strict";
+// @ts-nocheck
+module.exports = function (done, options, callback) {
+    return function (err, stats) {
+        if (err)
+            return done(err);
+        module.hot
+            .check(options || true)
+            .then(updatedModules => {
+            if (!updatedModules)
+                return done(new Error("No update available"));
+            if (callback)
+                callback(stats);
+        })
+            .catch(err => {
+            done(err);
+        });
+    };
+};

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

@@ -1,2 +1 @@
 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

@@ -16,24 +16,6 @@ exports.checkChunkModules = function checkChunkModules(statsJson, chunkModulesMa
     }
     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) {

package/dist/index.d.ts

@@ -2,7 +2,6 @@ export * from "./case";
 export * from "./compare";
 export * from "./helper";
 export * from "./plugin";
-export * from "./reporter";
 export * from "./runner";
 export * from "./test/context";
 export * from "./test/creator";

package/dist/index.js

@@ -18,7 +18,6 @@ __exportStar(require("./case"), exports);
 __exportStar(require("./compare"), exports);
 __exportStar(require("./helper"), exports);
 __exportStar(require("./plugin"), exports);
-__exportStar(require("./reporter"), exports);
 __exportStar(require("./runner"), exports);
 __exportStar(require("./test/context"), exports);
 __exportStar(require("./test/creator"), exports);

package/dist/jest/ignore-snapshot-default-reporter.d.ts

@@ -0,0 +1,2 @@
+export = DefaultReporter;
+import { DefaultReporter } from "@jest/reporters";

package/dist/jest/ignore-snapshot-default-reporter.js

@@ -0,0 +1,57 @@
+"use strict";
+// @ts-nocheck
+const { DefaultReporter } = require("@jest/reporters");
+const chalk = require.cache[require.resolve("@jest/reporters")].require("chalk");
+const jestUtil = require.cache[require.resolve("@jest/reporters")].require("jest-util");
+const ARROW = " \u203A ";
+const DOT = " \u2022 ";
+const FAIL_COLOR = chalk.bold.red;
+const SNAPSHOT_ADDED = chalk.bold.green;
+const SNAPSHOT_UPDATED = chalk.bold.green;
+const SNAPSHOT_OUTDATED = chalk.bold.yellow;
+function getSnapshotStatus(snapshot, afterUpdate) {
+    const statuses = [];
+    if (snapshot.added) {
+        statuses.push(SNAPSHOT_ADDED(`${ARROW + jestUtil.pluralize("snapshot", snapshot.added)} written.`));
+    }
+    if (snapshot.updated) {
+        statuses.push(SNAPSHOT_UPDATED(`${ARROW + jestUtil.pluralize("snapshot", snapshot.updated)} updated.`));
+    }
+    if (snapshot.unmatched) {
+        statuses.push(FAIL_COLOR(`${ARROW + jestUtil.pluralize("snapshot", snapshot.unmatched)} failed.`));
+    }
+    if (snapshot.unchecked) {
+        if (afterUpdate) {
+            statuses.push(SNAPSHOT_UPDATED(`${ARROW + jestUtil.pluralize("snapshot", snapshot.unchecked)} removed.`));
+            for (const key of snapshot.uncheckedKeys) {
+                statuses.push(`  ${DOT}${key}`);
+            }
+        }
+        else {
+            statuses.push(`${SNAPSHOT_OUTDATED(`${ARROW + jestUtil.pluralize("snapshot", snapshot.unchecked)} obsolete`)}.`);
+        }
+    }
+    if (snapshot.fileDeleted) {
+        statuses.push(SNAPSHOT_UPDATED(`${ARROW}snapshot file removed.`));
+    }
+    return statuses;
+}
+const isUpdate = process.argv.includes("-u") || process.argv.includes("--updateSnapshot");
+const isFiltering = process.argv.includes("-t") || process.argv.includes("--testNamePattern");
+const isVerbose = process.argv.includes("--verbose");
+if (!isVerbose && !isUpdate && isFiltering) {
+    class IgnoreSnapshotDefaultReporter extends DefaultReporter {
+        printTestFileFailureMessage(_testPath, _config, result) {
+            if (result.failureMessage) {
+                this.log(result.failureMessage);
+            }
+            const didUpdate = this._globalConfig.updateSnapshot === "all";
+            const snapshotStatuses = getSnapshotStatus(result.snapshot, didUpdate);
+            snapshotStatuses.forEach(this.log);
+        }
+    }
+    module.exports = IgnoreSnapshotDefaultReporter;
+}
+else {
+    module.exports = DefaultReporter;
+}

package/dist/jest/ignore-snapshot-summary-reporter.d.ts

@@ -0,0 +1,2 @@
+export = SummaryReporter;
+import { SummaryReporter } from "@jest/reporters";

package/dist/jest/ignore-snapshot-summary-reporter.js

@@ -0,0 +1,24 @@
+"use strict";
+// @ts-nocheck
+const { SummaryReporter } = require("@jest/reporters");
+const chalk = require.cache[require.resolve("@jest/reporters")].require("chalk");
+const isUpdate = process.argv.includes("-u") || process.argv.includes("--updateSnapshot");
+const isFiltering = process.argv.includes("-t") || process.argv.includes("--testNamePattern");
+const isVerbose = process.argv.includes("--verbose");
+if (!isVerbose && !isUpdate && isFiltering) {
+    class IgnoreSnapshotSummaryReporter extends SummaryReporter {
+        _printSnapshotSummary(snapshots, globalConfig) {
+            if (snapshots.added ||
+                snapshots.filesRemoved ||
+                snapshots.unchecked ||
+                snapshots.unmatched ||
+                snapshots.updated) {
+                this.log(chalk.bold.yellow("Some snapshots are obsoleted, flush with `npm run test -- -u` if necessary.\n"));
+            }
+        }
+    }
+    module.exports = IgnoreSnapshotSummaryReporter;
+}
+else {
+    module.exports = SummaryReporter;
+}

package/dist/jest/patch-node-env.d.ts

@@ -0,0 +1,5 @@
+export = CustomEnvironment;
+declare const CustomEnvironment_base: typeof import("jest-environment-node").default;
+declare class CustomEnvironment extends CustomEnvironment_base {
+    handleTestEvent(event: any, state: any): Promise<void>;
+}

package/dist/jest/patch-node-env.js

@@ -0,0 +1,18 @@
+"use strict";
+// @ts-nocheck
+// Copied from <https://github.com/webpack/webpack/blob/main/test/patch-node-env.js>
+//
+const NodeEnvironment = 
+// For jest@29
+require("jest-environment-node").TestEnvironment ||
+    // For jest@27
+    require("jest-environment-node");
+class CustomEnvironment extends NodeEnvironment {
+    // Workaround for `Symbol('JEST_STATE_SYMBOL')`
+    async handleTestEvent(event, state) {
+        if (!this.global.JEST_STATE_SYMBOL) {
+            this.global.JEST_STATE_SYMBOL = state;
+        }
+    }
+}
+module.exports = CustomEnvironment;

package/dist/jest/slash.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(path: any): any;
+export = _exports;

package/dist/jest/slash.js

@@ -0,0 +1,16 @@
+"use strict";
+// @ts-nocheck
+/**
+ * The following code is copied from
+ * https://github.com/sindresorhus/slash/blob/98b618f5a3bfcb5dd374b204868818845b87bb2f/index.js
+ *
+ * MIT Licensed
+ * Author Sindre Sorhus @sindresorhus
+ */
+module.exports = function slash(path) {
+    const isExtendedLengthPath = path.startsWith("\\\\?\\");
+    if (isExtendedLengthPath) {
+        return path;
+    }
+    return path.replace(/\\/g, "/");
+};