update

Author: xiaoxiaojx

lib/TsconfigPathsUtils.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const path = require("path");
-const { isAbsolute, join, normalize } = require("./util/path");
+const { join, normalize } = require("./util/path");
 
 /** @typedef {import("./Resolver")} Resolver */
 /** @typedef {import("./Resolver").FileSystem} FileSystem */
@@ -47,34 +47,6 @@ function sortByLongestPrefix(arr) {
 	return [...arr].sort((a, b) => getPrefixLength(b) - getPrefixLength(a));
 }
 
-/**
- * Converts an absolute baseUrl and paths to an array of absolute mapping entries.
- * The array is sorted by longest prefix.
- * Having an array with entries allows us to keep a sorting order rather than
- * sort by keys each time we use the mappings.
- * @param {{[key: string]: string[]}} paths TypeScript paths mapping
- * @param {string} baseUrl Base URL for resolving paths
- * @returns {AliasOption[]} Array of alias options
- */
-function getAbsoluteMappingEntries(paths, baseUrl) {
-	/** @type {string[]} */
-	const sortedKeys = sortByLongestPrefix(Object.keys(paths));
-	/** @type {AliasOption[]} */
-	const absolutePaths = [];
-
-	for (const pattern of sortedKeys) {
-		const mappings = paths[pattern];
-		// const aliasName = pattern.replace(/\/\*$/, "");
-		// Convert targets like "dir/*" -> "dir"
-		const aliasTargets = mappings.map((mapping) => join(baseUrl, mapping));
-		if (aliasTargets.length > 0) {
-			absolutePaths.push({ name: pattern, alias: aliasTargets });
-		}
-	}
-
-	return absolutePaths;
-}
-
 /**
  * Merge two tsconfig objects
  * @param {Tsconfig} base base config
@@ -235,11 +207,9 @@ async function readTsconfigCompilerOptions(fileSystem, absTsconfigPath) {
 		};
 		let { baseUrl } = compilerOptions;
 
-		if (!baseUrl) {
-			baseUrl = path.dirname(absTsconfigPath);
-		} else if (!isAbsolute(baseUrl)) {
-			baseUrl = join(path.dirname(absTsconfigPath), baseUrl);
-		}
+		baseUrl = !baseUrl
+			? path.dirname(absTsconfigPath)
+			: join(path.dirname(absTsconfigPath), baseUrl);
 
 		const paths = compilerOptions.paths || {};
 		return { options: { baseUrl, paths }, fileDependencies };
@@ -250,30 +220,42 @@ async function readTsconfigCompilerOptions(fileSystem, absTsconfigPath) {
 
 /**
  * Convert tsconfig paths to resolver options
- * @param {AliasOption[]} aliases the aliases
+ * @param {{[key: string]: string[]}} paths TypeScript paths mapping
+ * @param {string} baseUrl Base URL for resolving paths
  * @returns {Omit<TsconfigPathsData, "fileDependencies">} the resolver options
  */
-function pathsToResolveOptions(aliases) {
+function pathsToResolveOptions(paths, baseUrl) {
+	/** @type {string[]} */
+	const sortedKeys = sortByLongestPrefix(Object.keys(paths));
 	/** @type {AliasOption[]} */
 	const alias = [];
 	/** @type {string[]} */
 	const modules = [];
-	for (const opt of aliases) {
-		if (opt.name === "*") {
-			modules.push(
-				.../** @type {Array<string>} */ (opt.alias)
-					.map((dir) => {
-						if (/[/\\]\*$/.test(dir)) {
-							return dir.replace(/[/\\]\*$/, "");
-						}
-						return "";
-					})
-					.filter(Boolean),
-			);
-		} else {
-			alias.push(opt);
+
+	for (const pattern of sortedKeys) {
+		const mappings = paths[pattern];
+		const aliasTargets = mappings.map((mapping) => join(baseUrl, mapping));
+
+		if (aliasTargets.length > 0) {
+			if (pattern === "*") {
+				// Handle "*" pattern - extract modules from wildcard targets
+				modules.push(
+					...aliasTargets
+						.map((dir) => {
+							if (/[/\\]\*$/.test(dir)) {
+								return dir.replace(/[/\\]\*$/, "");
+							}
+							return "";
+						})
+						.filter(Boolean),
+				);
+			} else {
+				// Handle regular patterns - add as alias
+				alias.push({ name: pattern, alias: aliasTargets });
+			}
 		}
 	}
+
 	return {
 		alias,
 		modules,
@@ -293,25 +275,17 @@ async function loadTsconfigPathsData(
 	context = process.cwd(),
 ) {
 	try {
-		const absTsconfigPath = isAbsolute(configFile)
-			? configFile
-			: join(context, configFile);
-
+		const absTsconfigPath = join(context, configFile);
 		const result = await readTsconfigCompilerOptions(
 			fileSystem,
 			absTsconfigPath,
 		);
 		if (!result) return null;
 		const { options: compilerOptions, fileDependencies } = result;
 		if (!compilerOptions) return null;
-		/** @type {AliasOption[]} */
-		const absolutePaths = getAbsoluteMappingEntries(
-			compilerOptions.paths,
-			compilerOptions.baseUrl,
-		);
 
 		return {
-			...pathsToResolveOptions(absolutePaths),
+			...pathsToResolveOptions(compilerOptions.paths, compilerOptions.baseUrl),
 			fileDependencies,
 		};
 	} catch (_e) {

lib/util/path.js

@@ -120,14 +120,6 @@ const getType = (maybePath) => {
 	return PathType.Normal;
 };
 
-/**
- * @param {string} path a path
- * @returns {boolean} true, if path is absolute
- */
-const isAbsolute = (path) =>
-	getType(path) === PathType.AbsolutePosix ||
-	getType(path) === PathType.AbsoluteWin;
-
 /**
  * @param {string} maybePath a path
  * @returns {string} the normalized path
@@ -207,6 +199,5 @@ module.exports.cachedJoin = cachedJoin;
 module.exports.deprecatedInvalidSegmentRegEx = deprecatedInvalidSegmentRegEx;
 module.exports.getType = getType;
 module.exports.invalidSegmentRegEx = invalidSegmentRegEx;
-module.exports.isAbsolute = isAbsolute;
 module.exports.join = join;
 module.exports.normalize = normalize;