Function loadProjectAliases

src/resolution/path-aliases.ts:253–322

(projectRoot: string)

 * resolver does it via {@link aliasCache}).
 */
export function loadProjectAliases(projectRoot: string): AliasMap | null {
  // `tsconfig.base.json` comes last on purpose: when a root `tsconfig.json`
  // exists it stays authoritative and reaches the base through `extends`.
  // The fallback is for the Nx layouts where that never happens — a
  // solution-style root config (`references`, no `extends`, no `paths`), or
  // no root `tsconfig.json` at all.
  const candidates = ['tsconfig.json', 'jsconfig.json', 'tsconfig.base.json'];
  let effective: EffectiveOptions | null = null;
  let usedFile: string | null = null;
  for (const name of candidates) {
    const p = path.join(projectRoot, name);
    if (!fs.existsSync(p)) continue;
    const opts = loadEffectiveOptions(p, new Set(), 0);
    if (!opts) continue;
    // Remember the first readable config so a `paths`-less project still
    // logs the file it was judged on, but keep looking: a config that
    // contributes no aliases must not shadow one that does.
    if (!effective) {
      effective = opts;
      usedFile = name;
    }
    if (opts.paths) {
      effective = opts;
      usedFile = name;
      break;
    }
  }
  if (!effective) return null;

  // With no explicit baseUrl, `paths` targets are relative to the config that
  // declared them — which is the project root only when that config is the
  // root one (the pre-`extends` assumption).
  const baseUrl = effective.baseUrl ?? effective.pathsDir ?? projectRoot;

  const paths = effective.paths;
  if (!paths || typeof paths !== 'object') {
    // baseUrl alone isn't an "alias" per se; with no paths we'd just
    // be redirecting the whole tree. Skip — the existing resolver
    // already handles relative imports.
    return null;
  }

  const patterns: AliasPattern[] = [];
  for (const [pattern, targets] of Object.entries(paths)) {
    if (!Array.isArray(targets) || targets.length === 0) continue;
    const filtered = targets.filter((t): t is string => typeof t === 'string');
    if (filtered.length === 0) continue;
    const { prefix, suffix, hasWildcard } = splitWildcard(pattern);
    patterns.push({ prefix, suffix, hasWildcard, replacements: filtered });
  }

  if (patterns.length === 0) return null;

  // Specificity sort: longer prefix first; literal patterns before
  // wildcard patterns of the same prefix length. TypeScript itself
  // uses a similar "most specific match wins" rule.
  patterns.sort((a, b) => {
    if (a.prefix.length !== b.prefix.length) return b.prefix.length - a.prefix.length;