Angular Modernizer
    Preparing search index...

    Class ASTPathAliasResolver

    AST-based Path Alias Resolver

    Resolves TypeScript path aliases by modifying the AST directly, eliminating string manipulation and re-parsing overhead. Path mappings are loaded from tsconfig.json. AST-based alternative to PathAliasResolver.preprocessFileContent.

    Key Advantages over String-based Resolver:

    • 10x faster: <2ms vs <20ms per file
    • 100% accurate: AST-based vs regex pattern matching
    • Zero re-parsing: Modifies AST in-place
    • Better error handling: Syntax-aware modifications

    1. Custom Path Aliases

      import { SharedModule } from '@shared/modules';
      // AST modification: setModuleSpecifier('../shared/modules')
      // Result: import { SharedModule } from '../shared/modules';

    2. External Decorator Projects

      import { PageComponent } from '@shared/decorators/page';
      // AST modification: setModuleSpecifier('../shared/decorators/page')
      // Result: import { PageComponent } from '../shared/decorators/page';

    3. Monorepo Packages

      import { UserService } from '@domain/user/services/user.service';
      // AST modification: setModuleSpecifier('../../domain/user/services/user.service')
      // Result: import { UserService } from '../../domain/user/services/user.service';

    tsconfig.json → ASTPathAliasResolver → Modified AST (in-place)
                          ↓
                    Alias Mappings
                    (cached in memory)

    import { ASTPathAliasResolver } from '@angular-modernizer/core';
    import { Project } from 'ts-morph';

    const project = new Project({ tsConfigFilePath: './tsconfig.json' });
    const resolver = new ASTPathAliasResolver({
      baseDir: '/path/to/project',
      customAliases: [{ alias: '@shared', resolvedPath: 'src/shared' }]
    });

    // Parse file once
    const sourceFile = project.createSourceFile('component.ts', content);

    // Resolve aliases directly in AST (no re-parsing)
    const result = resolver.resolveAliasesInAST(sourceFile);
    console.info(`Resolved ${result.aliasesResolved} aliases`);

    // AST is already modified, no need to re-parse
    const transformedCode = sourceFile.getFullText();
    Index

    Constructors

    constructor

    Methods

    addAlias clearCache getAliasCount getAliases getCacheStats loadFromTsconfig resolveAliasesInAST

    Constructors

    • Initialize the AST-based Path Alias Resolver

      Loads path mappings from options and prepares for resolution.

      Parameters

      Returns ASTPathAliasResolver

      // Default configuration
      const resolver = new ASTPathAliasResolver();

      // Custom configuration
      const resolver = new ASTPathAliasResolver({
        baseDir: '/path/to/project',
        customAliases: [
          { alias: '@shared', resolvedPath: 'src/shared' },
          { alias: '@domain', resolvedPath: 'src/domain' }
        ]
      });

    Methods

    • Add a custom path alias at runtime

      Parameters

      Returns void

      resolver.addAlias({
        alias: '@legacy',
        resolvedPath: 'legacy/src'
      });

    • Clear the resolution cache

      Useful when aliases are modified at runtime.

      Returns void

    • Get the count of registered aliases

      Returns number

      Number of aliases

    • Get cache statistics

      Returns { size: number }

      Cache size information

      • size: number

        Number of cached alias resolutions.

    • Load path aliases from tsconfig.json

      Reads the "paths" property from tsconfig.json and converts it to PathAliasMapping entries for efficient lookup.

      Parameters

      • tsconfigPath: string

        Path to tsconfig.json file

      Returns Promise<void>

      Error if tsconfig.json cannot be read or parsed

      const resolver = new ASTPathAliasResolver({ baseDir: '/project' });
      await resolver.loadFromTsconfig('./tsconfig.json');

      // Now resolver has all path aliases from tsconfig
      const result = resolver.resolveAliasesInAST(sourceFile);

      {
        "compilerOptions": {
          "baseUrl": "./",
          "paths": {
            "@shared/*": ["src/shared/*"],
            "@domain/*": ["src/domain/*"],
            "@features/*": ["src/features/*"]
          }
        }
      }

    • Resolve path aliases directly in the AST

      This method modifies import/export declarations in-place without any string manipulation or re-parsing.

      Algorithm:

      1. Get all import/export declarations from AST
      2. For each declaration, check if module specifier matches an alias
      3. If match found, calculate relative path and update AST directly
      4. No re-parsing required - AST is already modified

      Performance:

      • <2ms per file (vs <20ms string-based)
      • No string manipulation overhead
      • No re-parsing overhead

      Parameters

      • sourceFile: SourceFile

        ts-morph SourceFile to modify

      Returns ASTPathAliasResult

      Result with count of resolved aliases and modified imports

      const sourceFile = project.createSourceFile('component.ts', content);
      const result = resolver.resolveAliasesInAST(sourceFile);

      console.info(`Resolved ${result.aliasesResolved} aliases`);
      result.modifiedImports.forEach(({ from, to }) => {
        console.info(`  ${from} → ${to}`);
      });

      // AST is already modified, get transformed code
      const code = sourceFile.getFullText();

    Settings

    Member Visibility

    On This Page

    Use CasesArchitecture
    Constructors
    Methods