fix: share join/dirname caches across resolvers via fileSystem WeakMap

Use fileSystem as the cache owner so that multiple Resolver instances
sharing the same fileSystem (e.g. across webpack recompilations) reuse
the same join/dirname caches. When the fileSystem is garbage collected,
the caches are released via WeakMap.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: xiaoxiaojx

lib/Resolver.js

@@ -18,6 +18,15 @@ const {
 	normalize,
 } = require("./util/path");
 
+/**
+ * @typedef {object} PathCacheFunctions
+ * @property {(rootPath: string, request: string) => string} join cached join
+ * @property {(maybePath: string) => string} dirname cached dirname
+ */
+
+/** @type {WeakMap<FileSystem, PathCacheFunctions>} */
+const _pathCacheByFs = new WeakMap();
+
 /** @typedef {import("./ResolverFactory").ResolveOptions} ResolveOptions */
 
 /**
@@ -400,8 +409,21 @@ class Resolver {
 	constructor(fileSystem, options) {
 		this.fileSystem = fileSystem;
 		this.options = options;
-		this.join = options.unsafeCache ? createCachedJoin() : _join;
-		this.dirname = options.unsafeCache ? createCachedDirname() : _dirname;
+		if (options.unsafeCache) {
+			let pathCache = _pathCacheByFs.get(fileSystem);
+			if (!pathCache) {
+				pathCache = {
+					join: createCachedJoin(),
+					dirname: createCachedDirname(),
+				};
+				_pathCacheByFs.set(fileSystem, pathCache);
+			}
+			this.join = pathCache.join;
+			this.dirname = pathCache.dirname;
+		} else {
+			this.join = _join;
+			this.dirname = _dirname;
+		}
 		/** @type {KnownHooks} */
 		this.hooks = {
 			resolveStep: new SyncHook(["hook", "request"], "resolveStep"),

test/resolver-cache.test.js

@@ -19,7 +19,7 @@ describe("Resolver join/dirname cache", () => {
 			expect(resolver.dirname).not.toBe(dirname);
 		});
 
-		it("should create independent caches per resolver", () => {
+		it("should share caches across resolvers with the same fileSystem", () => {
 			const fileSystem = new CachedInputFileSystem(fs, 0);
 
 			const resolver1 = ResolverFactory.createResolver({
@@ -33,6 +33,25 @@ describe("Resolver join/dirname cache", () => {
 				unsafeCache: true,
 			});
 
+			expect(resolver1.join).toBe(resolver2.join);
+			expect(resolver1.dirname).toBe(resolver2.dirname);
+		});
+
+		it("should use independent caches for different fileSystems", () => {
+			const fileSystem1 = new CachedInputFileSystem(fs, 0);
+			const fileSystem2 = new CachedInputFileSystem(fs, 0);
+
+			const resolver1 = ResolverFactory.createResolver({
+				fileSystem: fileSystem1,
+				extensions: [".js"],
+				unsafeCache: true,
+			});
+			const resolver2 = ResolverFactory.createResolver({
+				fileSystem: fileSystem2,
+				extensions: [".js"],
+				unsafeCache: true,
+			});
+
 			expect(resolver1.join).not.toBe(resolver2.join);
 			expect(resolver1.dirname).not.toBe(resolver2.dirname);
 		});