fix: test

Author: xiaoxiaojx

lib/TsconfigPathsPlugin.js

@@ -35,10 +35,9 @@ module.exports = class TsconfigPathsPlugin {
 	apply(resolver) {
 		if (!this.configFile) return;
 
-		const fs = resolver.fileSystem;
 		const aliasTarget = resolver.ensureHook("internal-resolve");
 		const moduleTarget = resolver.ensureHook("module");
-		const aliasOptionsPromise = this.loadAndConvertPaths(fs);
+		const aliasOptionsPromise = this.loadAndConvertPaths(resolver);
 
 		resolver
 			.getHook("raw-resolve")
@@ -90,25 +89,30 @@ module.exports = class TsconfigPathsPlugin {
 
 	/**
 	 * Load tsconfig.json (and referenced tsconfigs) and convert paths to AliasPlugin format
-	 * @param {import("./Resolver").FileSystem} fs the file system
+	 * @param {Resolver} resolver the file system
 	 * @returns {Promise<AliasOption[]>} Array of alias options for AliasPlugin
 	 */
-	async loadAndConvertPaths(fs) {
+	async loadAndConvertPaths(resolver) {
 		try {
+			const fs = resolver.fileSystem;
 			const configPath = path.isAbsolute(this.configFile)
 				? this.configFile
-				: path.resolve(process.cwd(), this.configFile);
+				: resolver.join(process.cwd(), this.configFile);
 
 			const mainOptions = await this.readTsconfigCompilerOptions(
-				fs,
+				resolver,
 				configPath,
 			);
 			if (!mainOptions) return [];
 
 			/** @type {AliasOption[]} */
 			const aliases = [];
 			aliases.push(
-				...this.convertPathsToAliases(mainOptions.paths, mainOptions.baseUrl),
+				...this.convertPathsToAliases(
+					resolver,
+					mainOptions.paths,
+					mainOptions.baseUrl,
+				),
 			);
 
 			// Collect references from the main tsconfig.json
@@ -129,7 +133,7 @@ module.exports = class TsconfigPathsPlugin {
 				if (!refPathLike) continue;
 				let refPath = path.isAbsolute(refPathLike)
 					? refPathLike
-					: path.resolve(path.dirname(configPath), refPathLike);
+					: resolver.join(path.dirname(configPath), refPathLike);
 				// If reference points to a directory, append tsconfig.json
 				try {
 					const stat = await new Promise((resolve, reject) => {
@@ -139,19 +143,23 @@ module.exports = class TsconfigPathsPlugin {
 						});
 					});
 					if (stat.isDirectory()) {
-						refPath = path.join(refPath, "tsconfig.json");
+						refPath = resolver.join(refPath, "tsconfig.json");
 					}
 				} catch (_e) {
 					// if it doesn't exist as directory/file, try adding tsconfig.json
 					if (!/\.json$/i.test(refPath)) {
-						refPath = path.join(refPath, "tsconfig.json");
+						refPath = resolver.join(refPath, "tsconfig.json");
 					}
 				}
 
 				const refOptions = await this.readTsconfigCompilerOptions(fs, refPath);
 				if (!refOptions) continue;
 				aliases.push(
-					...this.convertPathsToAliases(refOptions.paths, refOptions.baseUrl),
+					...this.convertPathsToAliases(
+						resolver,
+						refOptions.paths,
+						refOptions.baseUrl,
+					),
 				);
 			}
 
@@ -163,12 +171,13 @@ module.exports = class TsconfigPathsPlugin {
 
 	/**
 	 * Read tsconfig.json and return normalized compiler options
-	 * @param {import("./Resolver").FileSystem} fs the file system
+	 * @param {Resolver} resolver the resolver
 	 * @param {string} absTsconfigPath absolute path to tsconfig.json
 	 * @returns {Promise<{ baseUrl: string, paths: {[key: string]: string[]} } | null>} the normalized compiler options
 	 */
-	async readTsconfigCompilerOptions(fs, absTsconfigPath) {
+	async readTsconfigCompilerOptions(resolver, absTsconfigPath) {
 		try {
+			const fs = resolver.fileSystem;
 			const json = await new Promise((resolve, reject) => {
 				fs.readFile(absTsconfigPath, "utf8", (err, data) => {
 					if (err) reject(err);
@@ -181,7 +190,7 @@ module.exports = class TsconfigPathsPlugin {
 			if (!baseUrl) {
 				baseUrl = path.dirname(absTsconfigPath);
 			} else if (!path.isAbsolute(baseUrl)) {
-				baseUrl = path.resolve(path.dirname(absTsconfigPath), baseUrl);
+				baseUrl = resolver.join(path.dirname(absTsconfigPath), baseUrl);
 			}
 			const paths = compilerOptions.paths || {};
 			return { baseUrl, paths };
@@ -192,27 +201,28 @@ module.exports = class TsconfigPathsPlugin {
 
 	/**
 	 * Convert TypeScript paths configuration to AliasPlugin aliases
+	 * @param {Resolver} resolver the resolver
 	 * @param {{[key: string]: string[]}} paths TypeScript paths mapping
 	 * @param {string} baseUrl Base URL for resolving paths
 	 * @returns {AliasOption[]} Array of alias options
 	 */
-	convertPathsToAliases(paths, baseUrl) {
+	convertPathsToAliases(resolver, paths, baseUrl) {
 		/** @type {AliasOption[]} */
 		const aliases = [];
 
 		for (const [pattern, mappings] of Object.entries(paths)) {
 			// Handle exact matches (no wildcards)
 			if (!pattern.includes("*")) {
 				if (mappings.length > 0) {
-					const targetPath = path.resolve(baseUrl, mappings[0]);
+					const targetPath = resolver.join(baseUrl, mappings[0]);
 					aliases.push({ name: pattern, alias: targetPath });
 				}
 			} else {
 				// Handle wildcard patterns by mapping the directory
 				const aliasName = pattern.replace(/\/\*$/, "");
 				// Convert targets like "dir/*" -> "dir"
 				const aliasTargets = mappings.map((mapping) =>
-					path.resolve(baseUrl, mapping.replace(/\/\*$/, "")),
+					resolver.join(baseUrl, mapping.replace(/\/\*$/, "")),
 				);
 				if (aliasTargets.length > 0) {
 					aliases.push({ name: aliasName, alias: aliasTargets[0] });

types.d.ts

@@ -1593,21 +1593,22 @@ declare class TsconfigPathsPlugin {
 	 * Load tsconfig.json (and referenced tsconfigs) and convert paths to AliasPlugin format
 	 */
 	loadAndConvertPaths(
-		fs: FileSystem,
+		resolver: Resolver,
 	): Promise<AliasOptionTsconfigPathsPlugin[]>;
 
 	/**
 	 * Read tsconfig.json and return normalized compiler options
 	 */
 	readTsconfigCompilerOptions(
-		fs: FileSystem,
+		resolver: Resolver,
 		absTsconfigPath: string,
 	): Promise<null | { baseUrl: string; paths: { [index: string]: string[] } }>;
 
 	/**
 	 * Convert TypeScript paths configuration to AliasPlugin aliases
 	 */
 	convertPathsToAliases(
+		resolver: Resolver,
 		paths: { [index: string]: string[] },
 		baseUrl: string,
 	): AliasOptionTsconfigPathsPlugin[];