update

Author: xiaoxiaojx

lib/Resolver.js

@@ -294,7 +294,8 @@ const {
 
 /**
  * @typedef {object} TsconfigFileData
- * @property {Array<AliasOption>} aliases tsconfig file data
+ * @property {Array<AliasOption>} alias tsconfig file data
+ * @property {Array<string>} modules tsconfig file data
  * @property {Set<string>} fileDependencies file dependencies
  */
 
@@ -308,7 +309,7 @@ const {
  * @property {string=} relativePath relative path
  * @property {boolean=} ignoreSymlinks true when need to ignore symlinks, otherwise false
  * @property {boolean=} fullySpecified true when full specified, otherwise false
- * @property {TsconfigFileData=} tsconfigFileData tsconfig file data
+ * @property {TsconfigFileData | null=} tsconfigFileData tsconfig file data
  * @property {string=} __innerRequest inner request for internal usage
  * @property {string=} __innerRequest_request inner request for internal usage
  * @property {string=} __innerRequest_relativePath inner relative path for internal usage

lib/TsconfigPathsPlugin.js

@@ -5,22 +5,16 @@
 
 "use strict";
 
-const path = require("path");
 const { aliasResolveHandler } = require("./AliasUtils");
 const { modulesResolveHandler } = require("./ModulesUtils");
+const TsconfigPathsUtils = require("./TsconfigPathsUtils");
 
 /** @typedef {import("./Resolver")} Resolver */
 /** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 /** @typedef {import("./AliasUtils").AliasOption} AliasOption */
 /** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
 /** @typedef {import("./Resolver").ResolveContext} ResolveContext */
-
-/**
- * @typedef {object} TsconfigPathsPluginOptions
- * @property {string=} configFile - Path to tsconfig.json file
- * @property {string=} baseUrl - Override baseUrl from tsconfig.json
- * @property {string=} context - Context directory for resolving relative paths
- */
+/** @typedef {import("./Resolver").TsconfigFileData} TsconfigFileData */
 
 const DEFAULT_CONFIG_FILE = "tsconfig.json";
 
@@ -46,14 +40,17 @@ module.exports = class TsconfigPathsPlugin {
 				"TsconfigPathsPlugin",
 				async (request, resolveContext, callback) => {
 					try {
-						const aliases = await this.beforeResolve(
+						const tsconfigFileData = await this.loadTsconfigFile(
 							resolver,
 							request,
 							resolveContext,
 						);
+
+						if (!tsconfigFileData) return callback();
+
 						aliasResolveHandler(
 							resolver,
-							aliases.filter((option) => option.name !== "*"),
+							tsconfigFileData.alias,
 							aliasTarget,
 							request,
 							resolveContext,
@@ -71,18 +68,17 @@ module.exports = class TsconfigPathsPlugin {
 				"TsconfigPathsPlugin",
 				async (request, resolveContext, callback) => {
 					try {
-						const aliases = await this.beforeResolve(
+						const tsconfigFileData = await this.loadTsconfigFile(
 							resolver,
 							request,
 							resolveContext,
 						);
-						const directories = aliases
-							.filter((option) => option.name === "*")
-							.map((option) => /** @type {string} */ (option.alias));
+
+						if (!tsconfigFileData) return callback();
 
 						modulesResolveHandler(
 							resolver,
-							directories,
+							tsconfigFileData.modules,
 							moduleTarget,
 							request,
 							resolveContext,
@@ -100,178 +96,27 @@ module.exports = class TsconfigPathsPlugin {
 	 * @param {Resolver} resolver the resolver
 	 * @param {ResolveRequest} request the request
 	 * @param {ResolveContext} resolveContext the resolve context
-	 * @returns {Promise<Array<AliasOption>>} the pre-processed request
-	 */
-	async beforeResolve(resolver, request, resolveContext) {
-		const tsconfigFileData =
-			request.tsconfigFileData || (await this.loadAndConvertPaths(resolver));
-		if (!tsconfigFileData) return [];
-		const { aliases, fileDependencies } = tsconfigFileData;
-		for (const fileDependency of fileDependencies) {
-			if (resolveContext.fileDependencies) {
-				resolveContext.fileDependencies.add(fileDependency);
-			}
-		}
-		request.tsconfigFileData = tsconfigFileData;
-		return aliases;
-	}
-
-	/**
-	 * Load tsconfig.json (and referenced tsconfigs) and convert paths to AliasPlugin format
-	 * @param {Resolver} resolver the resolver
-	 * @returns {Promise<{aliases: AliasOption[], fileDependencies: Set<string>} | null>} Array of alias options for AliasPlugin
+	 * @returns {Promise<TsconfigFileData | null>} the pre-processed request
 	 */
-	async loadAndConvertPaths(resolver) {
-		try {
-			const fs = resolver.fileSystem;
-			const configPath = path.isAbsolute(this.configFile)
-				? this.configFile
-				: resolver.join(process.cwd(), this.configFile);
-
-			const mainOptions = await this.readTsconfigCompilerOptions(
-				resolver,
-				configPath,
-			);
-			if (!mainOptions) return null;
-
-			/** @type {AliasOption[]} */
-			const aliases = [];
-			/** @type {Set<string>} */
-			const fileDependencies = new Set();
-			const result = {
-				aliases,
-				fileDependencies,
-			};
-			aliases.push(
-				...this.convertPathsToAliases(
-					resolver,
-					mainOptions.paths,
-					mainOptions.baseUrl,
-				),
+	async loadTsconfigFile(resolver, request, resolveContext) {
+		if (typeof request.tsconfigFileData === "undefined") {
+			request.tsconfigFileData = await TsconfigPathsUtils.loadTsconfigFile(
+				resolver.fileSystem,
+				this.configFile,
 			);
-
-			// Collect references from the main tsconfig.json
-			const tsconfigJson = await new Promise((resolve, reject) => {
-				fs.readFile(configPath, "utf8", (err, data) => {
-					if (err) reject(err);
-					resolve(JSON.parse(/** @type {string} */ (data)));
-				});
-			});
-			fileDependencies.add(configPath);
-
-			const references = Array.isArray(tsconfigJson.references)
-				? tsconfigJson.references
-				: [];
-
-			for (const ref of references) {
-				/** @type {string} */
-				// TypeScript allows string or object with path
-				const refPathLike = typeof ref === "string" ? ref : ref && ref.path;
-				if (!refPathLike) continue;
-				let refPath = path.isAbsolute(refPathLike)
-					? refPathLike
-					: resolver.join(path.dirname(configPath), refPathLike);
-				// If reference points to a directory, append tsconfig.json
-				try {
-					const stat = await new Promise((resolve, reject) => {
-						fs.stat(refPath, (err, stat) => {
-							if (err) reject(err);
-							resolve(stat);
-						});
-					});
-					if (stat.isDirectory()) {
-						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 = resolver.join(refPath, "tsconfig.json");
-					}
-				}
-
-				const refOptions = await this.readTsconfigCompilerOptions(
-					resolver,
-					refPath,
-				);
-				if (!refOptions) continue;
-				fileDependencies.add(refPath);
-
-				aliases.push(
-					...this.convertPathsToAliases(
-						resolver,
-						refOptions.paths,
-						refOptions.baseUrl,
-					),
-				);
-			}
-
-			return result;
-		} catch (_error) {
-			return null;
 		}
-	}
 
-	/**
-	 * Read tsconfig.json and return normalized compiler options
-	 * @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(resolver, absTsconfigPath) {
-		try {
-			const fs = resolver.fileSystem;
-			const json = await new Promise((resolve, reject) => {
-				fs.readFile(absTsconfigPath, "utf8", (err, data) => {
-					if (err) reject(err);
-					resolve(JSON.parse(/** @type {string} */ (data)));
-				});
-			});
-			const compilerOptions =
-				json && json.compilerOptions ? json.compilerOptions : {};
-			let { baseUrl } = compilerOptions;
-			if (!baseUrl) {
-				baseUrl = path.dirname(absTsconfigPath);
-			} else if (!path.isAbsolute(baseUrl)) {
-				baseUrl = resolver.join(path.dirname(absTsconfigPath), baseUrl);
-			}
-			const paths = compilerOptions.paths || {};
-			return { baseUrl, paths };
-		} catch (_e) {
+		const { tsconfigFileData } = request;
+
+		if (!tsconfigFileData) {
 			return null;
 		}
-	}
-
-	/**
-	 * 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(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 = 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) =>
-					resolver.join(baseUrl, mapping.replace(/\/\*$/, "")),
-				);
-				if (aliasTargets.length > 0) {
-					aliases.push({ name: aliasName, alias: aliasTargets[0] });
-				}
+		for (const fileDependency of tsconfigFileData.fileDependencies) {
+			if (resolveContext.fileDependencies) {
+				resolveContext.fileDependencies.add(fileDependency);
 			}
 		}
-
-		return aliases;
+		return tsconfigFileData;
 	}
 };