@angular/compiler-cli

@angular/compiler-cli

Version 22.2.4
Published 5 days ago
2.74 MB
8 dependencies
MIT license

Install

npm i @angular/compiler-cli

yarn add @angular/compiler-cli

pnpm add @angular/compiler-cli

Overview

Angular - the compiler CLI for Node.js

Index

Variables

variable DEFAULT_ERROR_CODE

const DEFAULT_ERROR_CODE: number;

variable GLOBAL_DEFS_FOR_TERSER

const GLOBAL_DEFS_FOR_TERSER: { ngDevMode: boolean; ngI18nClosureMode: boolean };

Known values for global variables in @angular/core that Terser should set using https://github.com/terser-js/terser#conditional-compilation

variable GLOBAL_DEFS_FOR_TERSER_WITH_AOT

const GLOBAL_DEFS_FOR_TERSER_WITH_AOT: {
    ngDevMode: boolean;
    ngI18nClosureMode: boolean;
    ngJitMode: boolean;
};

variable LogicalProjectPath

const LogicalProjectPath: {
    relativePathBetween: (
        from: LogicalProjectPath,
        to: LogicalProjectPath
    ) => PathSegment;
};

variable SOURCE

const SOURCE: string;

variable UNKNOWN_ERROR_CODE

const UNKNOWN_ERROR_CODE: number;

variable VERSION

const VERSION: Version;

Functions

function absoluteFrom

absoluteFrom: (path: string) => AbsoluteFsPath;

Convert the path path to an AbsoluteFsPath, throwing an error if it's not an absolute path.

function absoluteFromSourceFile

absoluteFromSourceFile: (sf: { fileName: string }) => AbsoluteFsPath;

Extract an AbsoluteFsPath from a ts.SourceFile-like object.

function angularJitApplicationTransform

angularJitApplicationTransform: (
    program: ts.Program,
    isCore?: boolean,
    shouldTransformClass?: (node: ts.ClassDeclaration) => boolean
) => ts.TransformerFactory<ts.SourceFile>;

JIT transform for Angular applications. Used by the Angular CLI for unit tests and explicit JIT applications.
The transforms include:
- A transform for downleveling Angular decorators and Angular-decorated class constructor parameters for dependency injection. This transform can be used by the CLI for JIT-mode compilation where constructor parameters and associated Angular decorators should be downleveled so that apps are not exposed to the ES2015 temporal dead zone limitation in TypeScript. See https://github.com/angular/angular-cli/pull/14473 for more details.
- A transform for adding @Input to signal inputs. Signal inputs cannot be recognized at runtime using reflection. That is because the class would need to be instantiated- but is not possible before creation. To fix this for JIT, a decorator is automatically added that will declare the input as a signal input while also capturing the necessary metadata

function basename

basename: (filePath: PathString, extension?: string) => PathSegment;

Static access to basename.

function calcProjectFileAndBasePath

calcProjectFileAndBasePath: (
    project: string,
    host?: ConfigurationHost
) => { projectFile: AbsoluteFsPath; basePath: AbsoluteFsPath };

function constructorParametersDownlevelTransform

constructorParametersDownlevelTransform: (
    program: ts.Program,
    isCore?: boolean
) => ts.TransformerFactory<ts.SourceFile>;

JIT transform used by the Angular CLI.
NOTE: Signature is explicitly captured here to highlight the contract various Angular CLI versions are relying on.

function createCompilerHost

createCompilerHost: ({
    options,
    tsHost,
}: {
    options: CompilerOptions;
    tsHost?: ts.CompilerHost;
}) => CompilerHost;

function createFileSystemTsReadDirectoryFn

createFileSystemTsReadDirectoryFn: (
    fs: FileSystem
) => NonNullable<ts.CompilerHost['readDirectory']>;

Creates a ts.CompilerHost#readDirectory implementation function, that leverages the specified file system (that may be e.g. virtual).

function createProgram

createProgram: ({
    rootNames,
    options,
    host,
    oldProgram,
}: {
    rootNames: ReadonlyArray<string>;
    options: CompilerOptions;
    host: CompilerHost;
    oldProgram?: Program;
}) => Program;

function defaultGatherDiagnostics

defaultGatherDiagnostics: (program: api.Program) => ReadonlyArray<ts.Diagnostic>;

function dirname

dirname: <T extends PathString>(file: T) => T;

Static access to dirname.

function exitCodeFromResult

exitCodeFromResult: (diags: ReadonlyArray<ts.Diagnostic> | undefined) => number;

function findFirstMatchingNode

findFirstMatchingNode: <T extends ts.Node>(
    tcb: ts.Node,
    opts: FindOptions<T>
) => T | null;

Given a ts.Node with finds the first node whose matching the criteria specified by the FindOptions.
Returns null when no ts.Node matches the given conditions.

function formatDiagnostics

formatDiagnostics: (
    diags: ReadonlyArray<ts.Diagnostic>,
    host?: ts.FormatDiagnosticsHost
) => string;

function freshCompilationTicket

freshCompilationTicket: (
    tsProgram: ts.Program,
    options: NgCompilerOptions,
    incrementalBuildStrategy: IncrementalBuildStrategy,
    programDriver: ProgramDriver,
    perfRecorder: ActivePerfRecorder | null,
    enableTemplateTypeChecker: boolean,
    usePoisonedData: boolean
) => CompilationTicket;

Create a CompilationTicket for a brand new compilation, using no prior state.

function getAngularDecorators

getAngularDecorators: (
    decorators: Decorator[],
    names: readonly string[],
    isCore: boolean
) => Decorator[];

function getDownlevelDecoratorsTransform

getDownlevelDecoratorsTransform: (
    typeChecker: ts.TypeChecker,
    host: ReflectionHost,
    diagnostics: ts.Diagnostic[],
    isCore: boolean,
    isClosureCompilerEnabled: boolean,
    shouldTransformClass?: (node: ts.ClassDeclaration) => boolean
) => ts.TransformerFactory<ts.SourceFile>;

Gets a transformer for downleveling Angular constructor parameter and property decorators.
Note that Angular class decorators are never processed as those rely on side effects that would otherwise no longer be executed. i.e. the creation of a component definition.
Parameter typeChecker
Reference to the program's type checker.
Parameter host
Reflection host that is used for determining decorators.
Parameter diagnostics
List which will be populated with diagnostics if any.
Parameter isCore
Whether the current TypeScript program is for the @angular/core package.
Parameter isClosureCompilerEnabled
Whether closure annotations need to be added where needed.
Parameter shouldTransformClass
Optional function to check if a given class should be transformed.

function getFileSystem

getFileSystem: () => FileSystem;

function getInitializerApiJitTransform

getInitializerApiJitTransform: (
    host: ReflectionHost,
    importTracker: ImportedSymbolsTracker,
    isCore: boolean,
    shouldTransformClass?: (node: ts.ClassDeclaration) => boolean
) => ts.TransformerFactory<ts.SourceFile>;

Creates an AST transform that looks for Angular classes and transforms initializer-based declared members to work with JIT compilation.
For example, an input() member may be transformed to add an @Input decorator for JIT.
Parameter host
Reflection host
Parameter importTracker
Import tracker for efficient import checking.
Parameter isCore
Whether this transforms runs against @angular/core.
Parameter shouldTransformClass
Optional function to check if a given class should be transformed.

function getRootDirs

getRootDirs: (
    host: Pick<ts.CompilerHost, 'getCurrentDirectory' | 'getCanonicalFileName'>,
    options: ts.CompilerOptions
) => AbsoluteFsPath[];

function getSourceFileOrError

getSourceFileOrError: (
    program: ts.Program,
    fileName: AbsoluteFsPath
) => ts.SourceFile;

function hasExpressionIdentifier

hasExpressionIdentifier: (
    sourceFile: ts.SourceFile,
    node: ts.Node,
    identifier: ExpressionIdentifier
) => boolean;

function incrementalFromCompilerTicket

incrementalFromCompilerTicket: (
    oldCompiler: NgCompiler,
    newProgram: ts.Program,
    incrementalBuildStrategy: IncrementalBuildStrategy,
    programDriver: ProgramDriver,
    modifiedResourceFiles: Set<AbsoluteFsPath>,
    perfRecorder: ActivePerfRecorder | null
) => CompilationTicket;

Create a CompilationTicket as efficiently as possible, based on a previous NgCompiler instance and a new ts.Program.

function isDocEntryWithSourceInfo

isDocEntryWithSourceInfo: (entry: DocEntry) => entry is DocEntryWithSourceInfo;

function isExternalResource

isExternalResource: (resource: Resource) => resource is ExternalResource;

function isFatalDiagnosticError

isFatalDiagnosticError: (err: any) => err is FatalDiagnosticError;

function isLocalCompilationDiagnostics

isLocalCompilationDiagnostics: (diagnostic: ts.Diagnostic) => boolean;

Whether the compiler diagnostics represents an error related to local compilation mode.
This helper has application in 1P where we check whether a diagnostic is related to local compilation in order to add some g3 specific info to it.

function isLocalRelativePath

isLocalRelativePath: (relativePath: string) => boolean;

Returns true if the given path is locally relative.
This is used to work out if the given path is relative (i.e. not absolute) but also is not escaping the current directory.

function isNamedClassDeclaration

isNamedClassDeclaration: (node: ts.Node) => node is any;

function isRoot

isRoot: (path: AbsoluteFsPath) => boolean;

Returns true when the path provided is the root path.

function isRooted

isRooted: (path: string) => boolean;

Static access to isRooted.

function isShim

isShim: (sf: ts.SourceFile) => boolean;

Check whether sf is a shim ts.SourceFile (either a per-file shim or a top-level shim).

function isTsDiagnostic

isTsDiagnostic: (diagnostic: any) => diagnostic is ts.Diagnostic;

function join

join: <T extends PathString>(basePath: T, ...paths: string[]) => T;

Static access to join.

function ngErrorCode

ngErrorCode: (code: ErrorCode) => number;

function performCompilation

performCompilation: <CbEmitRes extends ts.EmitResult = ts.EmitResult>({
    rootNames,
    options,
    host,
    oldProgram,
    emitCallback,
    mergeEmitResultsCallback,
    gatherDiagnostics,
    customTransformers,
    emitFlags,
    forceEmit,
    modifiedResourceFiles,
}: {
    rootNames: string[];
    options: api.CompilerOptions;
    host?: api.CompilerHost;
    oldProgram?: api.Program;
    emitCallback?: api.TsEmitCallback<CbEmitRes>;
    mergeEmitResultsCallback?: api.TsMergeEmitResultsCallback<CbEmitRes>;
    gatherDiagnostics?: (program: api.Program) => ReadonlyArray<ts.Diagnostic>;
    customTransformers?: api.CustomTransformers;
    emitFlags?: api.EmitFlags;
    forceEmit?: boolean;
    modifiedResourceFiles?: Set<string> | null;
}) => PerformCompilationResult;

function readConfiguration

readConfiguration: (
    project: string,
    existingOptions?: api.CompilerOptions,
    host?: ConfigurationHost,
    extendedConfigCache?: Map<string, ts.ExtendedConfigCacheEntry>
) => ParsedConfiguration;

function relative

relative: <T extends PathString>(from: T, to: T) => PathSegment | AbsoluteFsPath;

Static access to relative.

function relativeFrom

relativeFrom: (path: string) => PathSegment;

Convert the path path to a PathSegment, throwing an error if it's not a relative path.

function resolve

resolve: (basePath: string, ...paths: string[]) => AbsoluteFsPath;

Static access to resolves.

function resourceChangeTicket

resourceChangeTicket: (
    compiler: NgCompiler,
    modifiedResourceFiles: Set<string>
) => IncrementalResourceCompilationTicket;

function setFileSystem

setFileSystem: (fileSystem: FileSystem) => void;

function toRelativeImport

toRelativeImport: (
    relativePath: PathSegment | AbsoluteFsPath
) => PathSegment | AbsoluteFsPath;

Converts a path to a form suitable for use as a relative module import specifier.
In other words it adds the ./ to the path if it is locally relative.

Classes

class ConsoleLogger

class ConsoleLogger implements Logger {}

A simple logger that outputs directly to the Console.
The log messages can be filtered based on severity via the logLevel constructor parameter.

constructor

constructor(level: LogLevel);

property level

level: LogLevel;

method debug

debug: (...args: string[]) => void;

method error

error: (...args: string[]) => void;

method info

info: (...args: string[]) => void;

method warn

warn: (...args: string[]) => void;

class DocsExtractor

class DocsExtractor {}

Extracts all information from a source file that may be relevant for generating public API documentation.

constructor

constructor(typeChecker: ts.TypeChecker, metadataReader: MetadataReader);

method extractAll

extractAll: (
    sourceFile: ts.SourceFile,
    rootDir: string,
    privateModules: Set<string>
) => { entries: DocEntry[]; symbols: Map<string, string> };

Gets the set of all documentable entries from a source file, including declarations that are re-exported from this file as an entry-point.
Parameter sourceFile
The file from which to extract documentable entries.

class Environment

class Environment extends ReferenceEmitEnvironment {}

A context which hosts one or more Type Check Blocks (TCBs).
An Environment supports the generation of TCBs by tracking necessary imports, declarations of type constructors, and other statements beyond the type-checking code within the TCB itself. Through method calls on Environment, the TCB generator can request ts.Expressions which reference declarations in the Environment for these artifacts`.
Environment can be used in a standalone fashion, or can be extended to support more specialized usage.

constructor

constructor(
    config: TypeCheckingConfig,
    importManager: ImportManager,
    refEmitter: ReferenceEmitter,
    contextFile: ts.SourceFile,
    copiedSourceOriginPath?: String & { _brand: 'AbsoluteFsPath' }
);

property config

readonly config: TypeCheckingConfig;

property copiedSourceOriginPath

copiedSourceOriginPath?: String & { _brand: 'AbsoluteFsPath' };

property pipeInstStatements

protected pipeInstStatements: TcbExpr[];

property typeCtorStatements

protected typeCtorStatements: TcbExpr[];

method getPreludeStatements

getPreludeStatements: () => TcbExpr[];

method pipeInst

pipeInst: (pipe: TcbPipeMetadata) => TcbExpr;

method typeCtorFor

typeCtorFor: (dir: TcbDirectiveMetadata) => TcbExpr;

Get an expression referring to a type constructor for the given directive.
Depending on the shape of the directive itself, this could be either a reference to a declared type constructor, or to an inline type constructor.

class ImportManager

class ImportManager
    implements
        ImportGenerator<
            ts.SourceFile,
            ts.Identifier | ts.PropertyAccessExpression
        > {}

Import manager that can be used to conveniently and efficiently generate imports It efficiently re-uses existing source file imports, or previous generated imports.
These capabilities are important for efficient TypeScript transforms that minimize structural changes to the dependency graph of source files, enabling as much incremental re-use as possible.
Those imports may be inserted via a TypeScript transform, or via manual string manipulation using e.g. magic-string.

constructor

constructor(config?: Partial<ImportManagerConfig>);

method addImport

addImport: {
    (request: ImportRequest<ts.SourceFile> & { asTypeReference: true }):
        | ts.Identifier
        | ts.QualifiedName;
    (
        request: ImportRequest<ts.SourceFile> & { asTypeReference?: undefined }
    ): any;
};

Adds an import to the given source-file and returns a TypeScript expression that can be used to access the newly imported symbol.

method addSideEffectImport

addSideEffectImport: (
    requestedFile: ts.SourceFile,
    moduleSpecifier: string
) => void;

Adds a side-effect import for the given module.

method finalize

finalize: () => {
    affectedFiles: Set<string>;
    updatedImports: Map<ts.NamedImports, ts.NamedImports>;
    newImports: Map<string, ts.ImportDeclaration[]>;
    reusedOriginalAliasDeclarations: Set<AliasImportDeclaration>;
    deletedImports: Set<ts.ImportDeclaration>;
};

Finalizes the import manager by computing all necessary import changes and returning them.
Changes are collected once at the end, after all imports are requested, because this simplifies building up changes to existing imports that need to be updated, and allows more trivial re-use of previous generated imports.

method removeImport

removeImport: (
    requestedFile: ts.SourceFile,
    exportSymbolName: string,
    moduleSpecifier: string
) => void;

Marks all imported symbols with a specific name for removal. Call addImport to undo this operation.
Parameter requestedFile
File from which to remove the imports.
Parameter exportSymbolName
Declared name of the symbol being removed.
Parameter moduleSpecifier
Module from which the symbol is being imported.

method toTsTransform

toTsTransform: (
    extraStatementsMap?: Map<string, ts.Statement[]>
) => ts.TransformerFactory<ts.SourceFile>;

Gets a TypeScript transform for the import manager.
Parameter extraStatementsMap
Additional set of statements to be inserted for given source files after their imports. E.g. top-level constants.

method transformTsFile

transformTsFile: (
    ctx: ts.TransformationContext,
    file: ts.SourceFile,
    extraStatementsAfterImports?: ts.Statement[]
) => ts.SourceFile;

Transforms a single file as a shorthand, using toTsTransform.
Parameter extraStatementsMap
Additional set of statements to be inserted for given source files after their imports. E.g. top-level constants.

class InvalidFileSystem

class InvalidFileSystem implements FileSystem {}

The default FileSystem that will always fail.
This is a way of ensuring that the developer consciously chooses and configures the FileSystem before using it; particularly important when considering static functions like absoluteFrom() which rely on the FileSystem under the hood.

method basename

basename: (filePath: string, extension?: string) => PathSegment;

method chdir

chdir: (path: AbsoluteFsPath) => void;

method copyFile

copyFile: (from: AbsoluteFsPath, to: AbsoluteFsPath) => void;

method dirname

dirname: <T extends PathString>(file: T) => T;

method ensureDir

ensureDir: (path: AbsoluteFsPath) => void;

method exists

exists: (path: AbsoluteFsPath) => boolean;

method extname

extname: (path: AbsoluteFsPath | PathSegment) => string;

method getDefaultLibLocation

getDefaultLibLocation: () => AbsoluteFsPath;

method isCaseSensitive

isCaseSensitive: () => boolean;

method isRoot

isRoot: (path: AbsoluteFsPath) => boolean;

method isRooted

isRooted: (path: string) => boolean;

method join

join: <T extends PathString>(basePath: T, ...paths: string[]) => T;

method lstat

lstat: (path: AbsoluteFsPath) => FileStats;

method moveFile

moveFile: (from: AbsoluteFsPath, to: AbsoluteFsPath) => void;

method normalize

normalize: <T extends PathString>(path: T) => T;

method pwd

pwd: () => AbsoluteFsPath;

method readdir

readdir: (path: AbsoluteFsPath) => PathSegment[];

method readFile

readFile: (path: AbsoluteFsPath) => string;

method readFileBuffer

readFileBuffer: (path: AbsoluteFsPath) => Uint8Array;

method realpath

realpath: (filePath: AbsoluteFsPath) => AbsoluteFsPath;

method relative

relative: <T extends PathString>(from: T, to: T) => PathSegment | AbsoluteFsPath;

method removeDeep

removeDeep: (path: AbsoluteFsPath) => void;

method removeFile

removeFile: (path: AbsoluteFsPath) => void;

method resolve

resolve: (...paths: string[]) => AbsoluteFsPath;

method stat

stat: (path: AbsoluteFsPath) => FileStats;

method symlink

symlink: (target: AbsoluteFsPath, path: AbsoluteFsPath) => void;

method writeFile

writeFile: (
    path: AbsoluteFsPath,
    data: string | Uint8Array,
    exclusive?: boolean
) => void;

class LogicalFileSystem

class LogicalFileSystem {}

A utility class which can translate absolute paths to source files into logical paths in TypeScript's logical file system, based on the root directories of the project.

constructor

constructor(
    rootDirs: AbsoluteFsPath[],
    compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>
);

method logicalPathOfFile

logicalPathOfFile: (physicalFile: AbsoluteFsPath) => LogicalProjectPath | null;

Get the logical path in the project of a source file.
Returns
A LogicalProjectPath to the source file, or null if the source file is not in any of the TS project's root directories.

method logicalPathOfSf

logicalPathOfSf: (sf: ts.SourceFile) => LogicalProjectPath | null;

Get the logical path in the project of a ts.SourceFile.
This method is provided as a convenient alternative to calling logicalPathOfFile(absoluteFromSourceFile(sf)).

class NgCompiler

class NgCompiler {}

The heart of the Angular Ivy compiler.
The NgCompiler provides an API for performing Angular compilation within a custom TypeScript compiler. Each instance of NgCompiler supports a single compilation, which might be incremental.
NgCompiler is lazy, and does not perform any of the work of the compilation until one of its output methods (e.g. getDiagnostics) is called.
See the README.md for more information.

property enableTemplateTypeChecker

readonly enableTemplateTypeChecker: boolean;

property ignoreForDiagnostics

readonly ignoreForDiagnostics: Set<ts.SourceFile>;

property ignoreForEmit

readonly ignoreForEmit: Set<ts.SourceFile>;

property incrementalCompilation

readonly incrementalCompilation: IncrementalCompilation;

property incrementalStrategy

readonly incrementalStrategy: IncrementalBuildStrategy;

property options

readonly options: NgCompilerOptions;

property perfRecorder

readonly perfRecorder: ActivePerfRecorder;

property programDriver

readonly programDriver: ProgramDriver;

property usePoisonedData

readonly usePoisonedData: boolean;

method analyzeAsync

analyzeAsync: () => Promise<void>;

Perform Angular's analysis step (as a precursor to getDiagnostics or prepareEmit) asynchronously.
Normally, this operation happens lazily whenever getDiagnostics or prepareEmit are called. However, certain consumers may wish to allow for an asynchronous phase of analysis, where resources such as styleUrls are resolved asynchronously. In these cases analyzeAsync must be called first, and its Promise awaited prior to calling any other APIs of NgCompiler.

method emitHmrUpdateModule

emitHmrUpdateModule: (node: ts.Declaration) => string | null;

Emits the JavaScript module that can be used to replace the metadata of a class during HMR.
Parameter node
Class for which to generate the update module.

method fromTicket

static fromTicket: (
    ticket: CompilationTicket,
    adapter: NgCompilerAdapter
) => NgCompiler;

Convert a CompilationTicket into an NgCompiler instance for the requested compilation.
Depending on the nature of the compilation request, the NgCompiler instance may be reused from a previous compilation and updated with any changes, it may be a new instance which incrementally reuses state from a previous compilation, or it may represent a fresh compilation entirely.

method getApiDocumentation

getApiDocumentation: (
    entryPoint: string,
    privateModules: Set<string>
) => { entries: DocEntry[]; symbols: Map<string, string> };

Gets information for the current program that may be used to generate API reference documentation. This includes Angular-specific information, such as component inputs and outputs.
Parameter entryPoint
Path to the entry point for the package for which API docs should be extracted.
Returns
A map of symbols with their associated module, eg: ApplicationRef => @angular/core

method getComponentsWithStyleFile

getComponentsWithStyleFile: (
    styleFilePath: string
) => ReadonlySet<DeclarationNode>;

Retrieves the ts.Declarations for any component(s) which use the given template file.

method getComponentsWithTemplateFile

getComponentsWithTemplateFile: (
    templateFilePath: string
) => ReadonlySet<DeclarationNode>;

Retrieves the ts.Declarations for any component(s) which use the given template file.

method getCurrentProgram

getCurrentProgram: () => ts.Program;

Get the current ts.Program known to this NgCompiler.
Compilation begins with an input ts.Program, and during template type-checking operations new ts.Programs may be produced using the ProgramDriver. The most recent such ts.Program to be produced is available here.
This ts.Program serves two key purposes:
* As an incremental starting point for creating the next ts.Program based on files that the user has changed (for clients using the TS compiler program APIs).
* As the "before" point for an incremental compilation invocation, to determine what's changed between the old and new programs (for all compilations).

method getDiagnostics

getDiagnostics: () => ts.Diagnostic[];

Get all Angular-related diagnostics for this compilation.

method getDiagnosticsForComponent

getDiagnosticsForComponent: (component: ts.ClassDeclaration) => ts.Diagnostic[];

Get all ts.Diagnostics currently available that pertain to the given component.

method getDiagnosticsForFile

getDiagnosticsForFile: (
    file: ts.SourceFile,
    optimizeFor: OptimizeFor
) => ts.Diagnostic[];

Get all Angular-related diagnostics for this compilation.
If a ts.SourceFile is passed, only diagnostics related to that file are returned.

method getDirectiveResources

getDirectiveResources: (classDecl: ts.Declaration) => DirectiveResources | null;

Retrieves external resources for the given directive.

method getIndexedComponents

getIndexedComponents: () => Map<
    DeclarationNode,
    IndexedComponent<DeclarationNode>
>;

Run the indexing process and return a Map of all indexed components.
See the indexing package for more details.

method getMeta

getMeta: (classDecl: ts.Declaration) => PipeMeta | DirectiveMeta | null;

method getOptionDiagnostics

getOptionDiagnostics: () => ts.Diagnostic[];

Get all setup-related diagnostics for this compilation.

method getResourceDependencies

getResourceDependencies: (file: ts.SourceFile) => string[];

Get the resource dependencies of a file.
If the file is not part of the compilation, an empty array will be returned.

method getTemplateTypeChecker

getTemplateTypeChecker: () => TemplateTypeChecker;

method prepareEmit

prepareEmit: () => { transformers: ts.CustomTransformers };

Fetch transformers and other information which is necessary for a consumer to emit the program with Angular-added definitions.

method xi18n

xi18n: (ctx: Xi18nContext) => void;

Collect i18n messages into the Xi18nContext.

class NgtscCompilerHost

class NgtscCompilerHost implements ts.CompilerHost {}

constructor

constructor(fs: FileSystem, options?: ts.CompilerOptions);

property fs

protected fs: FileSystem;

property options

protected options: ts.CompilerOptions;

method fileExists

fileExists: (fileName: string) => boolean;

method getCanonicalFileName

getCanonicalFileName: (fileName: string) => string;

method getCurrentDirectory

getCurrentDirectory: () => string;

method getDefaultLibFileName

getDefaultLibFileName: (options: ts.CompilerOptions) => string;

method getDefaultLibLocation

getDefaultLibLocation: () => string;

method getNewLine

getNewLine: () => string;

method getSourceFile

getSourceFile: (
    fileName: string,
    languageVersion: ts.ScriptTarget
) => ts.SourceFile | undefined;

method readFile

readFile: (fileName: string) => string | undefined;

method realpath

realpath: (path: string) => string;

method useCaseSensitiveFileNames

useCaseSensitiveFileNames: () => boolean;

method writeFile

writeFile: (
    fileName: string,
    data: string,
    writeByteOrderMark: boolean,
    onError: (message: string) => void,
    sourceFiles?: ReadonlyArray<ts.SourceFile>
) => void;

class NgTscPlugin

class NgTscPlugin implements TscPlugin {}

A plugin for tsc_wrapped which allows Angular compilation from a plain ts_library.

constructor

constructor(ngOptions: {});

property compiler

readonly compiler: NgCompiler;

property name

name: string;

method createTransformers

createTransformers: () => ts.CustomTransformers;

method getDiagnostics

getDiagnostics: (file?: ts.SourceFile) => ts.Diagnostic[];

method getNextProgram

getNextProgram: () => ts.Program;

method getOptionDiagnostics

getOptionDiagnostics: () => ts.Diagnostic[];

method setupCompilation

setupCompilation: (
    program: ts.Program,
    oldProgram?: ts.Program
) => {
    ignoreForDiagnostics: Set<ts.SourceFile>;
    ignoreForEmit: Set<ts.SourceFile>;
};

method wrapHost

wrapHost: (
    host: ts.CompilerHost & Partial<UnifiedModulesHost>,
    inputFiles: readonly string[],
    options: ts.CompilerOptions
) => PluginCompilerHost;

class NgtscProgram

class NgtscProgram implements api.Program {}

Entrypoint to the Angular Compiler (Ivy+) which sits behind the api.Program interface, allowing it to be a drop-in replacement for the legacy View Engine compiler to tooling such as the command-line main() function or the Angular CLI.

constructor

constructor(
    rootNames: readonly string[],
    options: NgCompilerOptions,
    delegateHost: api.CompilerHost,
    oldProgram?: NgtscProgram
);

property compiler

readonly compiler: NgCompiler;

method emit

emit: <CbEmitRes extends ts.EmitResult>(
    opts?: api.EmitOptions<CbEmitRes> | undefined
) => ts.EmitResult;

method getApiDocumentation

getApiDocumentation: (
    entryPoint: string,
    privateModules: Set<string>
) => { entries: DocEntry[]; symbols: Map<string, string> };

Gets information for the current program that may be used to generate API reference documentation. This includes Angular-specific information, such as component inputs and outputs.
Parameter entryPoint
Path to the entry point for the package for which API docs should be extracted.

method getEmittedSourceFiles

getEmittedSourceFiles: () => Map<string, ts.SourceFile>;

method getIndexedComponents

getIndexedComponents: () => Map<
    DeclarationNode,
    IndexedComponent<DeclarationNode>
>;

method getNgOptionDiagnostics

getNgOptionDiagnostics: (
    cancellationToken?: ts.CancellationToken | undefined
) => readonly ts.Diagnostic[];

method getNgSemanticDiagnostics

getNgSemanticDiagnostics: (
    fileName?: string | undefined,
    cancellationToken?: ts.CancellationToken | undefined
) => readonly ts.Diagnostic[];

method getNgStructuralDiagnostics

getNgStructuralDiagnostics: (
    cancellationToken?: ts.CancellationToken | undefined
) => readonly ts.Diagnostic[];

method getReuseTsProgram

getReuseTsProgram: () => ts.Program;

method getTsOptionDiagnostics

getTsOptionDiagnostics: (
    cancellationToken?: ts.CancellationToken | undefined
) => readonly ts.Diagnostic[];

method getTsProgram

getTsProgram: () => ts.Program;

method getTsSemanticDiagnostics

getTsSemanticDiagnostics: (
    sourceFile?: ts.SourceFile | undefined,
    cancellationToken?: ts.CancellationToken | undefined
) => readonly ts.Diagnostic[];

method getTsSyntacticDiagnostics

getTsSyntacticDiagnostics: (
    sourceFile?: ts.SourceFile | undefined,
    cancellationToken?: ts.CancellationToken | undefined
) => readonly ts.Diagnostic[];

method listLazyRoutes

listLazyRoutes: (entryRoute?: string | undefined) => api.LazyRoute[];

method loadNgStructureAsync

loadNgStructureAsync: () => Promise<void>;

Ensure that the NgCompiler has properly analyzed the program, and allow for the asynchronous loading of any resources during the process.
This is used by the Angular CLI to allow for spawning (async) child compilations for things like SASS files used in styleUrls.

class NodeJSFileSystem

class NodeJSFileSystem extends NodeJSReadonlyFileSystem implements FileSystem {}

A wrapper around the Node.js file-system (i.e. the fs package).

method copyFile

copyFile: (from: AbsoluteFsPath, to: AbsoluteFsPath) => void;

method ensureDir

ensureDir: (path: AbsoluteFsPath) => void;

method moveFile

moveFile: (from: AbsoluteFsPath, to: AbsoluteFsPath) => void;

method removeDeep

removeDeep: (path: AbsoluteFsPath) => void;

method removeFile

removeFile: (path: AbsoluteFsPath) => void;

method symlink

symlink: (target: AbsoluteFsPath, path: AbsoluteFsPath) => void;

method writeFile

writeFile: (
    path: AbsoluteFsPath,
    data: string | Uint8Array,
    exclusive?: boolean
) => void;

class Reference

class Reference<T extends ts.Node = ts.Node> {}

A ts.Node plus the context in which it was discovered.
A Reference is a pointer to a ts.Node that was extracted from the program somehow. It contains not only the node itself, but the information regarding how the node was located. In particular, it might track different identifiers by which the node is exposed, as well as potentially a module specifier which might expose the node.
The Angular compiler uses References instead of ts.Nodes when tracking classes or generating imports.

constructor

constructor(node: ts.Node, bestGuessOwningModule?: OwningModule | AmbientImport);

property alias

readonly alias: any;

property bestGuessOwningModule

readonly bestGuessOwningModule: OwningModule;

The compiler's best guess at an absolute module specifier which owns this Reference.
This is usually determined by tracking the import statements which led the compiler to a given node. If any of these imports are absolute, it's an indication that the node being imported might come from that module.
It is not _guaranteed_ that the node in question is exported from its bestGuessOwningModule - that is mostly a convention that applies in certain package formats.
If bestGuessOwningModule is null, then it's likely the node came from the current program.

property debugName

readonly debugName: string;

A name for the node, if one is available.
This is only suited for debugging. Any actual references to this node should be made with ts.Identifiers (see getIdentityIn).

property hasOwningModuleGuess

readonly hasOwningModuleGuess: boolean;

Whether this reference has a potential owning module or not.
See bestGuessOwningModule.

property isAmbient

readonly isAmbient: boolean;

property key

readonly key: string;

property node

readonly node: ts.Node;

property ownedByModuleGuess

readonly ownedByModuleGuess: string;

The best guess at which module specifier owns this particular reference, or null if there isn't one.

property synthetic

synthetic: boolean;

Indicates that the Reference was created synthetically, not as a result of natural value resolution.
This is used to avoid misinterpreting the Reference in certain contexts.

method addIdentifier

addIdentifier: (identifier: ts.Identifier) => void;

Record a ts.Identifier by which it's valid to refer to this node, within the context of this Reference.

method cloneWithAlias

cloneWithAlias: (alias: Expression) => Reference<T>;

method cloneWithNoIdentifiers

cloneWithNoIdentifiers: () => Reference<T>;

method getIdentityIn

getIdentityIn: (context: ts.SourceFile) => ts.Identifier | null;

Get a ts.Identifier within this Reference that can be used to refer within the context of a given ts.SourceFile, if any.

method getIdentityInExpression

getIdentityInExpression: (expr: ts.Expression) => ts.Identifier | null;

Get a ts.Identifier for this Reference that exists within the given expression.
This is very useful for producing ts.Diagnostics that reference References that were extracted from some larger expression, as it can be used to pinpoint the ts.Identifier within the expression from which the Reference originated.

method getOriginForDiagnostics

getOriginForDiagnostics: (
    container: ts.Expression,
    fallback?: ts.Expression
) => ts.Expression;

Given the 'container' expression from which this Reference was extracted, produce a ts.Expression to use in a diagnostic which best indicates the position within the container expression that generated the Reference.
For example, given a Reference to the class 'Bar' and the containing expression: [Foo, Bar, Baz], this function would attempt to return the ts.Identifier for Bar within the array. This could be used to produce a nice diagnostic context:
[Foo, Bar, Baz] ~~~
If no specific node can be found, then the fallback expression is used, which defaults to the entire containing expression.

class ReferenceEmitter

class ReferenceEmitter {}

Generates Expressions which refer to References in a given context.
A ReferenceEmitter uses one or more ReferenceEmitStrategy implementations to produce an Expression which refers to a Reference in the context of a particular file.

constructor

constructor(strategies: ReferenceEmitStrategy[]);

method emit

emit: (
    ref: Reference,
    context: ts.SourceFile,
    importFlags?: ImportFlags
) => ReferenceEmitResult;

class RegistryDomSchemaChecker

class RegistryDomSchemaChecker implements DomSchemaChecker<TemplateDiagnostic> {}

Checks non-Angular elements and properties against the DomElementSchemaRegistry, a schema maintained by the Angular team via extraction from a browser IDL.

constructor

constructor(resolver: TypeCheckSourceResolver);

property diagnostics

readonly diagnostics: readonly TemplateDiagnostic[];

method checkElement

checkElement: (
    id: TypeCheckId,
    tagName: string,
    sourceSpanForDiagnostics: ParseSourceSpan,
    schemas: SchemaMetadata[],
    hostIsStandalone: boolean
) => void;

method checkHostElementProperty

checkHostElementProperty: (
    id: TypeCheckId,
    element: TmplAstHostElement,
    name: string,
    span: ParseSourceSpan,
    schemas: SchemaMetadata[]
) => void;

method checkTemplateElementEvent

checkTemplateElementEvent: (
    id: TypeCheckId,
    tagName: string,
    eventName: string,
    span: ParseSourceSpan,
    schemas: SchemaMetadata[],
    hasComponent: boolean
) => void;

method checkTemplateElementProperty

checkTemplateElementProperty: (
    id: TypeCheckId,
    tagName: string,
    name: string,
    span: ParseSourceSpan,
    schemas: SchemaMetadata[],
    hostIsStandalone: boolean
) => void;

class SymbolBuilder

class SymbolBuilder {}

Generates and caches Symbols for various template structures for a given component.
The SymbolBuilder internally caches the Symbols it creates, and must be destroyed and replaced if the component's template changes.

constructor

constructor(
    tcbPath: String & { _brand: 'AbsoluteFsPath' },
    tcbIsShim: boolean,
    typeCheckBlock: ts.Node,
    boundTarget: SymbolBoundTarget,
    typeCheckingConfig: TypeCheckingConfig
);

method getSymbol

getSymbol: {
    (node: TmplAstTemplate | TmplAstElement):
        | TemplateSymbol
        | ElementSymbol
        | null;
    (node: any): ReferenceSymbol | VariableSymbol | LetDeclarationSymbol;
    (node: TmplAstComponent): SelectorlessComponentSymbol;
    (node: TmplAstDirective): SelectorlessDirectiveSymbol;
    (node: any): Symbol;
};

class TrackedIncrementalBuildStrategy

class TrackedIncrementalBuildStrategy implements IncrementalBuildStrategy {}

Tracks an IncrementalState within the strategy itself.

method getIncrementalState

getIncrementalState: () => IncrementalState | null;

method setIncrementalState

setIncrementalState: (state: IncrementalState) => void;

method toNextBuildStrategy

toNextBuildStrategy: () => TrackedIncrementalBuildStrategy;

Interfaces

interface AngularCompilerOptions

interface CompilerOptions extends NgCompilerOptions, ts.CompilerOptions {}

property annotationsAs

annotationsAs?: 'decorators' | 'static fields';

property basePath

basePath?: string;

property createExternalSymbolFactoryReexports

createExternalSymbolFactoryReexports?: boolean;

Whether NGC should generate re-exports for external symbols which are referenced in Angular metadata (e.g. @Component, @Inject, @ViewChild). This can be enabled in order to avoid dynamically generated module dependencies which can break strict dependency enforcements. This is not enabled by default. Read more about this here: https://github.com/angular/angular/issues/25644.

property disableExpressionLowering

disableExpressionLowering?: boolean;

property enableResourceInlining

enableResourceInlining?: boolean;

Whether to replace the templateUrl and styleUrls property in all decorators with inlined contents in template and styles properties. When enabled, the .js output of ngc will have no lazy-loaded templateUrl or styleUrls. Note that this requires that resources be available to load statically at compile-time.

property flatModulePrivateSymbolPrefix

flatModulePrivateSymbolPrefix?: string;

property genDir

genDir?: string;

property generateCodeForLibraries

generateCodeForLibraries?: boolean;

property i18nInFile

i18nInFile?: string;

property i18nInFormat

i18nInFormat?: string;

property i18nInMissingTranslations

i18nInMissingTranslations?: 'error' | 'warning' | 'ignore';

property skipMetadataEmit

skipMetadataEmit?: boolean;

property skipTemplateCodegen

skipTemplateCodegen?: boolean;

property strictMetadataEmit

strictMetadataEmit?: boolean;

property trace

trace?: boolean;

interface BindingSymbol

interface BindingSymbol {}

Represents either an input or output binding in a template.

property kind

kind: SymbolKind.Binding;

property target

target: DirectiveSymbol | ElementSymbol | TemplateSymbol;

The DirectiveSymbol or ElementSymbol for the Directive, Component, or HTMLElement with the binding.

property tcbLocation

tcbLocation: TcbLocation;

The location in the shim file where the field access for the binding appears.

property tcbTypeLocation

tcbTypeLocation?: TcbLocation;

The position of the expression used to determine the type.

interface ClassEntry

interface ClassEntry extends DocEntry {}

Documentation entity for a TypeScript class.

property extends

extends?: string;

property generics

generics: GenericEntry[];

property implements

implements: string[];

property isAbstract

isAbstract: boolean;

property members

members: MemberEntry[];

interface ClassSymbol

interface ClassSymbol {}

Represents an instance of a class found in the TCB, i.e. `var _pipe1: MyPipe = null!;

property isPipeClassSymbol

isPipeClassSymbol?: boolean;

Whether this class symbol represents a pipe.

property tcbLocation

tcbLocation: TcbLocation;

The position for the variable declaration for the class instance.

interface CompilerHost

interface CompilerHost extends ts.CompilerHost, ExtendedTsCompilerHost {}

method amdModuleName

amdModuleName: (sf: ts.SourceFile) => string | undefined;

Produce an AMD module name for the source file. Used in Bazel.
An AMD module can have an arbitrary name, so that it is require'd by name rather than by path. See https://requirejs.org/docs/whyamd.html#namedmodules

method fromSummaryFileName

fromSummaryFileName: (fileName: string, referringLibFileName: string) => string;

Converts a fileName that was processed by toSummaryFileName back into a real fileName given the fileName of the library that is referring to it.

method moduleNameToFileName

moduleNameToFileName: (
    moduleName: string,
    containingFile: string
) => string | null;

Converts a module name that is used in an import to a file path. I.e. path/to/containingFile.ts containing import {...} from 'module-name'.

method toSummaryFileName

toSummaryFileName: (fileName: string, referringSrcFileName: string) => string;

Converts a file name into a representation that should be stored in a summary file. This has to include changing the suffix as well. E.g. some_file.ts -> some_file.d.ts
Parameter referringSrcFileName
the source file that refers to fileName

interface CompilerOptions

interface CompilerOptions extends NgCompilerOptions, ts.CompilerOptions {}

property annotationsAs

annotationsAs?: 'decorators' | 'static fields';

property basePath

basePath?: string;

property createExternalSymbolFactoryReexports

createExternalSymbolFactoryReexports?: boolean;

Whether NGC should generate re-exports for external symbols which are referenced in Angular metadata (e.g. @Component, @Inject, @ViewChild). This can be enabled in order to avoid dynamically generated module dependencies which can break strict dependency enforcements. This is not enabled by default. Read more about this here: https://github.com/angular/angular/issues/25644.

property disableExpressionLowering

disableExpressionLowering?: boolean;

property enableResourceInlining

enableResourceInlining?: boolean;

Whether to replace the templateUrl and styleUrls property in all decorators with inlined contents in template and styles properties. When enabled, the .js output of ngc will have no lazy-loaded templateUrl or styleUrls. Note that this requires that resources be available to load statically at compile-time.

property flatModulePrivateSymbolPrefix

flatModulePrivateSymbolPrefix?: string;

property genDir

genDir?: string;

property generateCodeForLibraries

generateCodeForLibraries?: boolean;

property i18nInFile

i18nInFile?: string;

property i18nInFormat

i18nInFormat?: string;

property i18nInMissingTranslations

i18nInMissingTranslations?: 'error' | 'warning' | 'ignore';

property skipMetadataEmit

skipMetadataEmit?: boolean;

property skipTemplateCodegen

skipTemplateCodegen?: boolean;

property strictMetadataEmit

strictMetadataEmit?: boolean;

property trace

trace?: boolean;

interface ConstantEntry

interface ConstantEntry extends DocEntry {}

Documentation entity for a constant.

property type

type: string;

interface CustomTransformers

interface CustomTransformers {}

property afterTs

afterTs?: ts.TransformerFactory<ts.SourceFile>[];

property beforeTs

beforeTs?: ts.TransformerFactory<ts.SourceFile>[];

interface DecoratorEntry

interface DecoratorEntry extends DocEntry {}

Documentation entity for an Angular decorator.

property decoratorType

decoratorType: DecoratorType;

property members

members: PropertyEntry[] | null;

property signatures

signatures: {
    parameters: ParameterEntry[];
    jsdocTags: JsDocTagEntry[];
}[];

interface DirectiveEntry

interface DirectiveEntry extends ClassEntry {}

Documentation entity for an Angular directives and components.

property exportAs

exportAs: string[];

property isStandalone

isStandalone: boolean;

property selector

selector: string;

interface DirectiveMeta

interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {}

Metadata collected for a directive within an NgModule's scope.

property assumedToExportProviders

assumedToExportProviders: boolean;

Whether the directive should be assumed to export providers if imported as a standalone type.

property baseClass

baseClass: Reference<ClassDeclaration> | 'dynamic' | null;

A Reference to the base class for the directive, if one was detected.
A value of 'dynamic' indicates that while the analyzer detected that this directive extends another type, it could not statically determine the base class.

property decorator

decorator: ts.Decorator | null;

The primary decorator associated with this directive.
If this is null, no decorator exists, meaning it's probably from a .d.ts file.

property deferredBlocks

deferredBlocks?: Set<string> | null;

Block names in @Component.deferredImports under which this class was imported, if deferredImports was configured as an object literal. null if flat array.

property deferredImports

deferredImports: Reference<ClassDeclaration>[] | null;

For standalone components, the list of imported types that can be used in @defer blocks (when only explicit dependencies are allowed).

property deferredImportsByBlock

deferredImportsByBlock?: Map<string, Reference<ClassDeclaration>[]> | null;

Map of block name -> resolved deferred imports when deferredImports is an object literal.

property foreignImports

foreignImports: ForeignComponentMeta[] | null;

For standalone components, the list of imported foreign components.
Note that while a foreign import is not likely to be a class, this type is used because it includes the expected identifier we'll need, making further code simpler.

property hostDirectives

hostDirectives: HostDirectiveMeta[] | null;

Additional directives applied to the directive host.

property imports

imports: Reference<ClassDeclaration>[] | null;

For standalone components, the list of imported types.

property inputFieldNamesFromMetadataArray

inputFieldNamesFromMetadataArray: Set<string> | null;

List of input fields that were defined in the class decorator metadata. Null for directives extracted from .d.ts

property inputs

inputs: ClassPropertyMapping<InputMapping>;

A mapping of input field names to the property names.

property isExplicitlyDeferred

isExplicitlyDeferred: boolean;

Whether this class was imported into a standalone component's scope via @Component.deferredImports field.

property isPoisoned

isPoisoned: boolean;

Whether the directive had some issue with its declaration that means it might not have complete and reliable metadata.

property isSignal

isSignal: boolean;

Whether the directive is a signal entity.

property isStandalone

isStandalone: boolean;

Whether the directive is a standalone entity.

property isStructural

isStructural: boolean;

Whether the directive is likely a structural directive (injects TemplateRef).

property kind

kind: MetaKind.Directive;

property localReferencedSymbols

localReferencedSymbols: Set<string> | null;

Names of the symbols within the source file that are referenced directly inside the template.

property matchSource

matchSource: MatchSource;

Way in which the directive was matched.

property outputs

outputs: ClassPropertyMapping;

A mapping of output field names to the property names.

property queries

queries: string[];

property rawImports

rawImports: ts.Expression | null;

Node declaring the imports of a standalone component. Used to produce diagnostics.

property ref

ref: Reference<ClassDeclaration>;

property schemas

schemas: SchemaMetadata[] | null;

For standalone components, the list of schemas declared.

property selector

selector: string | null;

Unparsed selector of the directive, or null if the directive does not have a selector.

property selectorlessEnabled

selectorlessEnabled: boolean;

Whether selectorless is enabled for the specific component.

interface DirectiveModuleExportDetails

interface DirectiveModuleExportDetails {}

property exportName

exportName: string;

property moduleSpecifier

moduleSpecifier: string;

interface DirectSourceMapping

interface DirectSourceMapping {}

A mapping to a node within the same source file..
ParseSourceSpans for this node should be accurate for direct reporting in a TS error message.

property node

node: ts.Node;

property type

type: 'direct';

interface DocEntry

interface DocEntry {}

Base type for all documentation entities.

property aliases

aliases?: string[];

property description

description: string;

property entryType

entryType: EntryType;

property jsdocTags

jsdocTags: JsDocTagEntry[];

property name

name: string;

property rawComment

rawComment: string;

interface DocEntryWithSourceInfo

interface DocEntryWithSourceInfo extends DocEntry {}

property source

source: SourceEntry;

interface DomBindingSymbol

interface DomBindingSymbol {}

A representation of an attribute on an element or template. These bindings aren't currently type-checked (see checkTypeOfDomBindings) so they won't have a ts.Type, ts.Symbol, or shim location.

property host

host: ElementSymbol | TemplateSymbol;

The symbol for the element or template of the text attribute.

property kind

kind: SymbolKind.DomBinding;

interface ElementSymbol

interface ElementSymbol {}

A representation of an element in a component template.

property directives

directives: DirectiveSymbol[];

A list of directives applied to the element.

property kind

kind: SymbolKind.Element;

property tcbLocation

tcbLocation: TcbLocation;

The location in the shim file for the variable that holds the type of the element.

property templateNode

templateNode: TmplAstElement;

interface EmitOptions

interface EmitOptions<CbEmitRes extends ts.EmitResult> {}

property cancellationToken

cancellationToken?: ts.CancellationToken;

property customTransformers

customTransformers?: CustomTransformers;

property emitCallback

emitCallback?: TsEmitCallback<CbEmitRes>;

property emitFlags

emitFlags?: EmitFlags;

property forceEmit

forceEmit?: boolean;

property mergeEmitResultsCallback

mergeEmitResultsCallback?: TsMergeEmitResultsCallback<CbEmitRes>;

interface EntryCollection

interface EntryCollection {}

The JSON data file format for extracted API reference info.

property entries

entries: DocEntry[];

property moduleLabel

moduleLabel: string;

property moduleName

moduleName: string;

property normalizedModuleName

normalizedModuleName: string;

property repo

repo: string;

property symbols

symbols?: string[][];

interface EnumEntry

interface EnumEntry extends DocEntry {}

Documentation entity for a TypeScript enum.

property members

members: EnumMemberEntry[];

interface EnumMemberEntry

interface EnumMemberEntry extends MemberEntry {}

Sub-entry for an enum member.

property type

type: string;

property value

value: string;

interface ExpressionSymbol

interface ExpressionSymbol {}

A representation of an expression in a component template.

property kind

kind: SymbolKind.Expression;

property tcbLocation

tcbLocation: TcbLocation;

The position of the most relevant part of the expression.

property tcbTypeLocation

tcbTypeLocation?: TcbLocation;

The position of the expression used to determine the type.

interface ExternalTemplateSourceMapping

interface ExternalTemplateSourceMapping {}

A mapping to a template declared in an external HTML file, where node positions in ParseSourceSpans represent accurate offsets into the external file.
In this case, the given node refers to the templateUrl expression.

property componentClass

componentClass: ClassDeclaration;

property node

node: ts.Expression;

property template

template: string;

property templateUrl

templateUrl: string;

property type

type: 'external';

interface FileStats

interface FileStats {}

Information about an object in the FileSystem. This is analogous to the fs.Stats class in Node.js.

method isDirectory

isDirectory: () => boolean;

method isFile

isFile: () => boolean;

method isSymbolicLink

isSymbolicLink: () => boolean;

interface FileSystem

interface FileSystem extends ReadonlyFileSystem {}

A basic interface to abstract the underlying file-system.
This makes it easier to provide mock file-systems in unit tests, but also to create clever file-systems that have features such as caching.

method copyFile

copyFile: (from: AbsoluteFsPath, to: AbsoluteFsPath) => void;

method ensureDir

ensureDir: (path: AbsoluteFsPath) => void;

method moveFile

moveFile: (from: AbsoluteFsPath, to: AbsoluteFsPath) => void;

method removeDeep

removeDeep: (path: AbsoluteFsPath) => void;

method removeFile

removeFile: (path: AbsoluteFsPath) => void;

method symlink

symlink: (target: AbsoluteFsPath, path: AbsoluteFsPath) => void;

method writeFile

writeFile: (
    path: AbsoluteFsPath,
    data: string | Uint8Array,
    exclusive?: boolean
) => void;

interface FileUpdate

interface FileUpdate {}

property newText

newText: string;

The source file text.

property originalFile

originalFile: ts.SourceFile | null;

Represents the source file from the original program that is being updated. If the file update targets a shim file then this is null, as shim files do not have an associated original file.

interface FullSourceMapping

interface FullSourceMapping {}

A representation of all a node's type checking information we know. Useful for producing diagnostics based on a TCB node or generally mapping from a TCB node back to a template location.

property sourceLocation

sourceLocation: SourceLocation;

property sourceMapping

sourceMapping: SourceMapping;

property span

span: ParseSourceSpan;

interface FunctionDefinitionEntry

interface FunctionDefinitionEntry {}

Interface describing a function with overload signatures.

property implementation

implementation: FunctionSignatureMetadata | null;

property name

name: string;

property signatures

signatures: FunctionSignatureMetadata[];

interface FunctionSignatureMetadata

interface FunctionSignatureMetadata extends DocEntry {}

property generics

generics: GenericEntry[];

property isNewType

isNewType: boolean;

property params

params: ParameterEntry[];

property returnDescription

returnDescription?: string;

property returnType

returnType: string;

interface GenericEntry

interface GenericEntry {}

Documentation entity for single generic parameter.

property constraint

constraint: string | undefined;

property default

default: string | undefined;

property name

name: string;

interface GetPotentialAngularMetaOptions

interface GetPotentialAngularMetaOptions {}

property includeExternalModule

includeExternalModule: boolean;

interface GlobalCompletion

interface GlobalCompletion {}

Autocompletion data for an expression in the global scope.
Global completion is accomplished by merging data from two sources: * TypeScript completion of the component's class members. * Local references and variables that are in scope at a given template level.

property componentContext

componentContext: TcbLocation;

A location within the type-checking shim where TypeScript's completion APIs can be used to access completions for the template's component context (component class members).

property nodeContext

nodeContext: TcbLocation | null;

A location within the type-checking shim where TypeScript's completion APIs can be used to access completions for the AST node of the cursor position (primitive constants).

property templateContext

templateContext: Map<
    string,
    ReferenceCompletion | VariableCompletion | LetDeclarationCompletion
>;

Map of local references and variables that are visible at the requested level of the template.
Shadowing of references/variables from multiple levels of the template has already been accounted for in the preparation of templateContext. Entries here shadow component members of the same name (from the componentContext completions).

interface HostBindingsContext

interface HostBindingsContext {}

Contextual data for type checking the host bindings of a directive.

property directives

directives: DirectiveMeta[];

Directives present on the host element.

property node

node: TmplAstHostElement;

AST node representing the host element of the directive.

property sourceMapping

sourceMapping: SourceMapping;

Describes the source of the host bindings. Used for mapping errors back.

interface IndirectSourceMapping

interface IndirectSourceMapping {}

A mapping to a node which is still in a TS file, but where the positions in any ParseSourceSpans are not accurate for one reason or another.
This can occur if the expression was interpolated in a way where the compiler could not construct a contiguous mapping for the template string.

property componentClass

componentClass: ClassDeclaration;

property node

node: ts.Expression;

property template

template: string;

property type

type: 'indirect';

interface InitializerApiFunctionEntry

interface InitializerApiFunctionEntry extends DocEntry {}

Docs entry describing an initializer API function.
An initializer API function is a function that is invoked as initializer of class members. The function may hold additional sub functions, like .required.
Known popular initializer APIs are input(), output(), model().
Initializer APIs are often constructed typed in complex ways so this entry type allows for readable "parsing" and interpretation of such constructs. Initializer APIs are explicitly denoted via a JSDoc tag.

property callFunction

callFunction: FunctionDefinitionEntry;

property subFunctions

subFunctions: FunctionDefinitionEntry[];

interface InputBindingSymbol

interface InputBindingSymbol {}

A representation of an input binding in a component template.

property bindings

bindings: BindingSymbol[];

A single input may be bound to multiple components or directives.

property kind

kind: SymbolKind.Input;

interface InterfaceEntry

interface InterfaceEntry extends DocEntry {}

Documentation entity for a TypeScript interface.

property extends

extends: string[];

property generics

generics: GenericEntry[];

property implements

implements: string[];

property members

members: MemberEntry[];

interface JsDocTagEntry

interface JsDocTagEntry {}

Documentation entity for single JsDoc tag.

property comment

comment: string;

property name

name: string;

interface LazyRoute

interface LazyRoute {}

property module

module: {
    name: string;
    filePath: string;
};

property referencedModule

referencedModule: {
    name: string;
    filePath: string;
};

property route

route: string;

interface LetDeclarationCompletion

interface LetDeclarationCompletion {}

An autocompletion result representing an @let declaration in the template.

property kind

kind: CompletionKind.LetDeclaration;

property node

node: TmplAstLetDeclaration;

The TmplAstLetDeclaration from the template which should be available as a completion.

interface LetDeclarationSymbol

interface LetDeclarationSymbol {}

A representation of an @let declaration in a component template.

property declaration

declaration: TmplAstLetDeclaration;

The node in the TemplateAst where the @let is declared.

property initializerLocation

initializerLocation: TcbLocation;

The location in the shim file of the @let declaration's initializer expression.

property kind

kind: SymbolKind.LetDeclaration;

property localVarLocation

localVarLocation: TcbLocation;

The location in the shim file for the identifier of the @let declaration.

interface Logger

interface Logger {}

Implement this interface if you want to provide different logging output from the standard ConsoleLogger.

property level

level: LogLevel;

method debug

debug: (...args: string[]) => void;

method error

error: (...args: string[]) => void;

method info

info: (...args: string[]) => void;

method warn

warn: (...args: string[]) => void;

interface MemberEntry

interface MemberEntry {}

Sub-entry for a single class or enum member.

property description

description: string;

property jsdocTags

jsdocTags: JsDocTagEntry[];

property memberTags

memberTags: MemberTags[];

property memberType

memberType: MemberType;

property name

name: string;

interface NamespaceEntry

interface NamespaceEntry extends DocEntry {}

Documentation entity for a TypeScript namespace.

property members

members: DocEntry[];

interface NgCompilerAdapter

interface NgCompilerAdapter
    extends Omit<ts.ModuleResolutionHost, 'getCurrentDirectory'>,
        Pick<
            ExtendedTsCompilerHost,
            'getCurrentDirectory' | ExtendedCompilerHostMethods
        >,
        SourceFileTypeIdentifier {}

Adapter for NgCompiler that allows it to be used in various circumstances, such as command-line ngc, as a plugin to ts_library in Bazel, or from the Language Service.
NgCompilerAdapter is a subset of the NgCompilerHost implementation of ts.CompilerHost which is relied upon by NgCompiler. A consumer of NgCompiler can therefore use the NgCompilerHost or implement NgCompilerAdapter itself.

property constructionDiagnostics

readonly constructionDiagnostics: ts.Diagnostic[];

An array of ts.Diagnostics that occurred during construction of the ts.Program.

property entryPoint

readonly entryPoint: AbsoluteFsPath | null;

A path to a single file which represents the entrypoint of an Angular Package Format library, if the current program is one.
This is used to emit a flat module index if requested, and can be left null if that is not required.

property ignoreForEmit

readonly ignoreForEmit: Set<ts.SourceFile>;

A Set of ts.SourceFiles which are internal to the program and should not be emitted as JS files.
Often these are shim files such as ngtypecheck shims used for template type-checking in command-line ngc.

property rootDirs

readonly rootDirs: ReadonlyArray<AbsoluteFsPath>;

Resolved list of root directories explicitly set in, or inferred from, the tsconfig.

property unifiedModulesHost

readonly unifiedModulesHost: UnifiedModulesHost | null;

A specialized interface provided in some environments (such as Bazel) which overrides how import specifiers are generated.
If not required, this can be null.

interface NgCompilerOptions

interface NgCompilerOptions
    extends ts.CompilerOptions,
        LegacyNgcOptions,
        BazelAndG3Options,
        DiagnosticOptions,
        TypeCheckingOptions,
        TestOnlyOptions,
        I18nOptions,
        TargetOptions,
        InternalOptions,
        MiscOptions {}

A merged interface of all of the various Angular compiler options, as well as the standard ts.CompilerOptions.
Also includes a few miscellaneous options.

index signature

[prop: string]: any;

interface OutputBindingSymbol

interface OutputBindingSymbol {}

A representation of an output binding in a component template.

property bindings

bindings: BindingSymbol[];

A single output may be bound to multiple components or directives.

property kind

kind: SymbolKind.Output;

interface ParameterEntry

interface ParameterEntry {}

Sub-entry for a single function parameter.

property description

description: string;

property isOptional

isOptional: boolean;

property isRestParam

isRestParam: boolean;

property name

name: string;

property type

type: string;

interface ParsedConfiguration

interface ParsedConfiguration {}

property emitFlags

emitFlags: api.EmitFlags;

property errors

errors: ts.Diagnostic[];

property options

options: api.CompilerOptions;

property project

project: string;

property projectReferences

projectReferences?: readonly ts.ProjectReference[] | undefined;

property rootNames

rootNames: string[];

interface PathManipulation

interface PathManipulation {}

An abstraction over the path manipulation aspects of a file-system.

method basename

basename: (filePath: string, extension?: string) => PathSegment;

method chdir

chdir: (path: AbsoluteFsPath) => void;

method dirname

dirname: <T extends PathString>(file: T) => T;

method extname

extname: {
    (path: AbsoluteFsPath | PathSegment): string;
    (path: AbsoluteFsPath | PathSegment): string;
};

method isRoot

isRoot: (path: AbsoluteFsPath) => boolean;

method isRooted

isRooted: (path: string) => boolean;

method join

join: <T extends PathString>(basePath: T, ...paths: string[]) => T;

method normalize

normalize: <T extends PathString>(path: T) => T;

method pwd

pwd: () => AbsoluteFsPath;

method relative

relative: <T extends PathString>(from: T, to: T) => PathSegment | AbsoluteFsPath;

Compute the relative path between from and to.
In file-systems that can have multiple file trees the returned path may not actually be "relative" (i.e. PathSegment). For example, Windows can have multiple drives : relative('c:/a/b', 'd:/a/c') would be `d:/a/c'.

method resolve

resolve: (...paths: string[]) => AbsoluteFsPath;

interface PerformCompilationResult

interface PerformCompilationResult {}

property diagnostics

diagnostics: ReadonlyArray<ts.Diagnostic>;

property emitResult

emitResult?: ts.EmitResult;

property program

program?: api.Program;

interface PipeEntry

interface PipeEntry extends ClassEntry {}

property isPure

isPure: boolean;

property isStandalone

isStandalone: boolean;

property pipeName

pipeName: string | null;

property usage

usage: string;

interface PipeMeta

interface PipeMeta {}

Metadata for a pipe within an NgModule's scope.

property decorator

decorator: ts.Decorator | null;

property deferredBlocks

deferredBlocks?: Set<string> | null;

property isExplicitlyDeferred

isExplicitlyDeferred: boolean;

property isPure

isPure: boolean;

property isStandalone

isStandalone: boolean;

property kind

kind: MetaKind.Pipe;

property name

name: string | null;

property nameExpr

nameExpr: ts.Expression | null;

property ref

ref: Reference<ClassDeclaration>;

interface PipeSymbol

interface PipeSymbol {}

A representation for a call to a pipe's transform method in the TCB.

property classSymbol

classSymbol: ClassSymbol;

The symbol for the pipe class as an instance that appears in the TCB.

property kind

kind: SymbolKind.Pipe;

property tcbLocation

tcbLocation: TcbLocation;

The position of the transform call in the template.

interface PluginCompilerHost

interface PluginCompilerHost extends ts.CompilerHost, Partial<UnifiedModulesHost> {}

A ts.CompilerHost which also returns a list of input files, out of which the ts.Program should be created.
Currently mirrored from @bazel/concatjs/internal/tsc_wrapped/plugin_api (with the naming of fileNameToModuleName corrected).

property inputFiles

readonly inputFiles: ReadonlyArray<string>;

interface PotentialDirective

interface PotentialDirective {}

Metadata on a directive which is available in a template.

property isComponent

isComponent: boolean;

true if this directive is a component.

property isInScope

isInScope: boolean;

Whether or not this directive is in scope.

property isStructural

isStructural: boolean;

true if this directive is a structural directive.

property ngModule

ngModule: ClassDeclaration | null;

The module which declares the directive.

property ref

ref: SymbolReference;

property selector

selector: string | null;

The selector for the directive or component.

property tsCompletionEntryInfos

tsCompletionEntryInfos: TsCompletionEntryInfo[] | null;

The directive can be exported by multiple modules, collecting all the entry information here.
Filter the appropriate entry information when using it to compute the module specifier.

interface PotentialDirectiveModuleSpecifierResolver

interface PotentialDirectiveModuleSpecifierResolver {}

method resolve

resolve: (
    toImport: Reference<ClassDeclaration>,
    importOn: ts.Node | null
) => DirectiveModuleExportDetails | null;

interface PotentialImport

interface PotentialImport {}

A PotentialImport for some Angular trait has a TypeScript module specifier, which can be relative, as well as an identifier name.

property isForwardReference

isForwardReference: boolean;

property kind

kind: PotentialImportKind;

property moduleSpecifier

moduleSpecifier?: string;

property symbolName

symbolName: string;

interface PotentialPipe

interface PotentialPipe {}

Metadata for a pipe which is available in a template.

property isInScope

isInScope: boolean;

Whether or not this pipe is in scope.

property name

name: string | null;

Name of the pipe.

property ref

ref: SymbolReference;

property tsCompletionEntryInfos

tsCompletionEntryInfos: TsCompletionEntryInfo[] | null;

The pipe can be exported by multiple modules, collecting all the entry information here.
Filter the appropriate entry information when using it to compute the module specifier.

interface Program

interface Program {}

method emit

emit: <CbEmitRes extends ts.EmitResult>(
    opts?: EmitOptions<CbEmitRes> | undefined
) => ts.EmitResult;

Emit the files requested by emitFlags implied by the program.
Angular structural information is required to emit files.

method getNgOptionDiagnostics

getNgOptionDiagnostics: (
    cancellationToken?: ts.CancellationToken
) => ReadonlyArray<ts.Diagnostic>;

Retrieve options diagnostics for the Angular options used to create the program.

method getNgSemanticDiagnostics

getNgSemanticDiagnostics: (
    fileName?: string,
    cancellationToken?: ts.CancellationToken
) => ReadonlyArray<ts.Diagnostic>;

Retrieve the Angular semantic diagnostics.
Angular structural information is required to produce these diagnostics.

method getNgStructuralDiagnostics

getNgStructuralDiagnostics: (
    cancellationToken?: ts.CancellationToken
) => ReadonlyArray<ts.Diagnostic>;

Retrieve the diagnostics for the structure of an Angular application is correctly formed. This includes validating Angular annotations and the syntax of referenced and imbedded HTML and CSS.
Note it is important to displaying TypeScript semantic diagnostics along with Angular structural diagnostics as an error in the program structure might cause errors detected in semantic analysis and a semantic error might cause errors in specifying the program structure.
Angular structural information is required to produce these diagnostics.

method getTsOptionDiagnostics

getTsOptionDiagnostics: (
    cancellationToken?: ts.CancellationToken
) => ReadonlyArray<ts.Diagnostic>;

Retrieve options diagnostics for the TypeScript options used to create the program. This is faster than calling getTsProgram().getOptionsDiagnostics() since it does not need to collect Angular structural information to produce the errors.

method getTsProgram

getTsProgram: () => ts.Program;

Retrieve the TypeScript program used to produce semantic diagnostics and emit the sources.
Angular structural information is required to produce the program.

method getTsSemanticDiagnostics

getTsSemanticDiagnostics: (
    sourceFile?: ts.SourceFile,
    cancellationToken?: ts.CancellationToken
) => ReadonlyArray<ts.Diagnostic>;

Retrieve the semantic diagnostics from TypeScript. This is equivalent to calling getTsProgram().getSemanticDiagnostics() directly and is included for completeness.

method getTsSyntacticDiagnostics

getTsSyntacticDiagnostics: (
    sourceFile?: ts.SourceFile,
    cancellationToken?: ts.CancellationToken
) => ReadonlyArray<ts.Diagnostic>;

Retrieve the syntax diagnostics from TypeScript. This is faster than calling getTsProgram().getSyntacticDiagnostics() since it does not need to collect Angular structural information to produce the errors.

method listLazyRoutes

listLazyRoutes: (entryRoute?: string) => LazyRoute[];

This method is obsolete and always returns an empty array.

method loadNgStructureAsync

loadNgStructureAsync: () => Promise<void>;

Load Angular structural information asynchronously. If this method is not called then the Angular structural information, including referenced HTML and CSS files, are loaded synchronously. If the supplied Angular compiler host returns a promise from loadResource() will produce a diagnostic error message or, getTsProgram() or emit to throw.

interface ProgramDriver

interface ProgramDriver {}

property inliningMode

readonly inliningMode: InliningMode;

How this strategy handles operations that require inlining.

property supportsInlineOperations

readonly supportsInlineOperations: boolean;

Whether this strategy supports modifying user files (inline modifications) in addition to modifying type-checking shims.

method getProgram

getProgram: () => ts.Program;

Retrieve the latest version of the program, containing all the updates made thus far.

method getSourceFileVersion

getSourceFileVersion: (sf: ts.SourceFile) => string;

Retrieve a string version for a given ts.SourceFile, which much change when the contents of the file have changed.
If this method is present, the compiler will use these versions in addition to object identity for ts.SourceFiles to determine what's changed between two incremental programs. This is valuable for some clients (such as the Language Service) that treat ts.SourceFiles as mutable objects.

method updateFiles

updateFiles: (
    contents: Map<AbsoluteFsPath, FileUpdate>,
    updateMode: UpdateMode
) => void;

Incorporate a set of changes to either augment or completely replace the type-checking code included in the type-checking program.

interface ProgramTypeCheckAdapter

interface ProgramTypeCheckAdapter {}

Interface to trigger generation of type-checking code for a program given a new TypeCheckContext.

method typeCheck

typeCheck: (sf: ts.SourceFile, ctx: TypeCheckContext) => void;

interface PropertyEntry

interface PropertyEntry extends MemberEntry {}

Sub-entry for a class property.

property inputAlias

inputAlias?: string;

property isRequiredInput

isRequiredInput?: boolean;

property outputAlias

outputAlias?: string;

property type

type: string;

interface ReadonlyFileSystem

interface ReadonlyFileSystem extends PathManipulation {}

An abstraction over the read-only aspects of a file-system.

method exists

exists: (path: AbsoluteFsPath) => boolean;

method getDefaultLibLocation

getDefaultLibLocation: () => AbsoluteFsPath;

method isCaseSensitive

isCaseSensitive: () => boolean;

method lstat

lstat: (path: AbsoluteFsPath) => FileStats;

method readdir

readdir: (path: AbsoluteFsPath) => PathSegment[];

method readFile

readFile: (path: AbsoluteFsPath) => string;

method readFileBuffer

readFileBuffer: (path: AbsoluteFsPath) => Uint8Array;

method realpath

realpath: (filePath: AbsoluteFsPath) => AbsoluteFsPath;

method stat

stat: (path: AbsoluteFsPath) => FileStats;

interface ReferenceCompletion

interface ReferenceCompletion {}

An autocompletion result representing a local reference declared in the template.

property kind

kind: CompletionKind.Reference;

property node

node: TmplAstReference;

The TmplAstReference from the template which should be available as a completion.

interface ReferenceSymbol

interface ReferenceSymbol {}

A representation of a local reference in a component template.

property declaration

declaration: TmplAstReference;

The node in the TemplateAst where the symbol is declared. That is, node for the #ref or #ref="exportAs".

property kind

kind: SymbolKind.Reference;

property referenceVarLocation

referenceVarLocation: TcbLocation;

The location in the TCB for the identifier node in the reference variable declaration. For example, given a variable declaration statement for a template reference: var _t2 = _t1, this location is [_t2 node].getStart(). This location can be used to find references to the variable within the template.

property target

target: TmplAstElement | TmplAstTemplate | SymbolReference;

Depending on the type of the reference, this is one of the following: - TmplAstElement when the local ref refers to the HTML element - TmplAstTemplate when the ref refers to an ng-template - SymbolReference when the local ref refers to a Directive instance (#ref="myExportAs")

property targetLocation

targetLocation: TcbLocation;

The location in the shim file of a variable that holds the type of the local ref. For example, a reference declaration like the following:
var _t1 = document.createElement('div'); var _t2 = _t1; // This is the reference declaration
This targetLocation is [_t1 variable declaration].getStart().

interface ReflectionHost

interface ReflectionHost {}

Abstracts reflection operations on a TypeScript AST.
Depending on the format of the code being interpreted, different concepts are represented with different syntactical structures. The ReflectionHost abstracts over those differences and presents a single API by which the compiler can query specific information about the AST.
All operations on the ReflectionHost require the use of TypeScript ts.Nodes with binding information already available (that is, nodes that come from a ts.Program that has been type-checked, and are not synthetically created).

method getBaseClassExpression

getBaseClassExpression: (clazz: ClassDeclaration) => ts.Expression | null;

Get an expression representing the base class (if any) of the given clazz.
This expression is most commonly an Identifier, but is possible to inherit from a more dynamic expression.
Parameter clazz
the class whose base we want to get.

method getConstructorParameters

getConstructorParameters: (clazz: ClassDeclaration) => CtorParameter[] | null;

Reflect over the constructor of a class and return metadata about its parameters.
This method only looks at the constructor of a class directly and not at any inherited constructors.
Parameter clazz
a ClassDeclaration representing the class over which to reflect.
Returns
an array of Parameter metadata representing the parameters of the constructor, if a constructor exists. If the constructor exists and has 0 parameters, this array will be empty. If the class has no constructor, this method returns null.

method getDeclarationOfIdentifier

getDeclarationOfIdentifier: (id: ts.Identifier) => Declaration | null;

Trace an identifier to its declaration, if possible.
This method attempts to resolve the declaration of the given identifier, tracing back through imports and re-exports until the original declaration statement is found. A Declaration object is returned if the original declaration is found, or null is returned otherwise.
If the declaration is in a different module, and that module is imported via an absolute path, this method also returns the absolute path of the imported module. For example, if the code is:
import {RouterModule} from '@angular/core'; export const ROUTES = RouterModule.forRoot([...]);
and if getDeclarationOfIdentifier is called on RouterModule in the ROUTES expression, then it would trace RouterModule via its import from @angular/core, and note that the definition was imported from @angular/core into the application where it was referenced.
If the definition is re-exported several times from different absolute module names, only the first one (the one by which the application refers to the module) is returned.
This module name is returned in the viaModule field of the Declaration. If The declaration is relative to the application itself and there was no import through an absolute path, then viaModule is null.
Parameter id
a TypeScript ts.Identifier to trace back to a declaration.
Returns
metadata about the Declaration if the original declaration is found, or null otherwise.

method getDecoratorsOfDeclaration

getDecoratorsOfDeclaration: (declaration: ts.Declaration) => Decorator[] | null;

Examine a declaration (for example, of a class or function) and return metadata about any decorators present on the declaration.
Parameter declaration
a TypeScript ts.Declaration node representing the class or function over which to reflect. For example, if the intent is to reflect the decorators of a class and the source is in ES6 format, this will be a ts.ClassDeclaration node. If the source is in ES5 format, this might be a ts.VariableDeclaration as classes in ES5 are represented as the result of an IIFE execution.
Returns
an array of Decorator metadata if decorators are present on the declaration, or null if either no decorators were present or if the declaration is not of a decoratable type.

method getDefinitionOfFunction

getDefinitionOfFunction: (fn: ts.Node) => FunctionDefinition | null;

Reflect over a function and return metadata about its parameters and body.
Functions in TypeScript and ES5 code have different AST representations, in particular around default values for parameters. A TypeScript function has its default value as the initializer on the parameter declaration, whereas an ES5 function has its default value set in a statement of the form:
if (param === void 0) { param = 3; }
This method abstracts over these details, and interprets the function declaration and body to extract parameter default values and the "real" body.
A current limitation is that this metadata has no representation for shorthand assignment of parameter objects in the function signature.
Parameter fn
a TypeScript ts.Declaration node representing the function over which to reflect.
Returns
a FunctionDefinition giving metadata about the function definition.

method getExportsOfModule

getExportsOfModule: (module: ts.Node) => Map<string, Declaration> | null;

Collect the declarations exported from a module by name.
Iterates over the exports of a module (including re-exports) and returns a map of export name to its Declaration. If an exported value is itself re-exported from another module, the Declaration's viaModule will reflect that.
Parameter node
a TypeScript ts.Node representing the module (for example a ts.SourceFile) for which to collect exports.
Returns
a map of Declarations for the module's exports, by name.

method getGenericArityOfClass

getGenericArityOfClass: (clazz: ClassDeclaration) => number | null;

Get the number of generic type parameters of a given class.
Parameter clazz
a ClassDeclaration representing the class over which to reflect.
Returns
the number of type parameters of the class, if known, or null if the declaration is not a class or has an unknown number of type parameters.

method getImportOfIdentifier

getImportOfIdentifier: (id: ts.Identifier) => Import | null;

Determine if an identifier was imported from another module and return Import metadata describing its origin.
Parameter id
a TypeScript ts.Identifier to reflect.
Returns
metadata about the Import if the identifier was imported from another module, or null if the identifier doesn't resolve to an import but instead is locally defined.

method getMembersOfClass

getMembersOfClass: (clazz: ClassDeclaration) => ClassMember[];

Examine a declaration which should be of a class, and return metadata about the members of the class.
Parameter clazz
a ClassDeclaration representing the class over which to reflect.
Returns
an array of ClassMember metadata representing the members of the class.
Throws
if declaration does not resolve to a class declaration.

method getVariableValue

getVariableValue: (declaration: ts.VariableDeclaration) => ts.Expression | null;

Find the assigned value of a variable declaration.
Normally this will be the initializer of the declaration, but where the variable is not a const we may need to look elsewhere for the variable's value.
Parameter declaration
a TypeScript variable declaration, whose value we want.
Returns
the value of the variable, as a TypeScript expression node, or undefined if the value cannot be computed.

method hasBaseClass

hasBaseClass: (clazz: ClassDeclaration) => boolean;

Determines whether the given declaration, which should be a class, has a base class.
Parameter clazz
a ClassDeclaration representing the class over which to reflect.

method isClass

isClass: (node: ts.Node) => node is any;

Check whether the given node actually represents a class.

method isStaticallyExported

isStaticallyExported: (decl: ts.Node) => boolean;

Returns true if a declaration is exported from the module in which it's defined.
Not all mechanisms by which a declaration is exported can be statically detected, especially when processing already compiled JavaScript. A false result does not indicate that the declaration is never visible outside its module, only that it was not exported via one of the export mechanisms that the ReflectionHost is capable of statically checking.

interface Resource

interface Resource {}

Represents an resource for a component and contains the AbsoluteFsPath to the file which was resolved by evaluating the ts.Expression (generally, a relative or absolute string path to the resource).
If the resource is inline, the path will be null.

property node

node: ts.Node;

property path

path: AbsoluteFsPath | null;

interface SelectorlessComponentSymbol

interface SelectorlessComponentSymbol {}

A representation of a selectorless component reference in a template.

property directives

directives: DirectiveSymbol[];

Includes the component class itself and any host directives that may have been applied as a side-effect of it.

property kind

kind: SymbolKind.SelectorlessComponent;

property tcbLocation

tcbLocation: TcbLocation;

The location in the shim file for the variable that holds the type of the component.

property templateNode

templateNode: TmplAstComponent;

Template AST node defining the component.

interface SelectorlessDirectiveSymbol

interface SelectorlessDirectiveSymbol {}

A representation of a selectorless directive reference in a template.

property directives

directives: DirectiveSymbol[];

Includes the directive class itself and any host directives that may have been applied as a side-effect of it.

property kind

kind: SymbolKind.SelectorlessDirective;

property tcbLocation

tcbLocation: TcbLocation;

The location in the shim file for the variable that holds the type of the directive.

property templateNode

templateNode: TmplAstDirective;

Template AST node defining the directive.

interface SourceEntry

interface SourceEntry {}

property endLine

endLine: number;

property filePath

filePath: string;

property startLine

startLine: number;

interface SourceLocation

interface SourceLocation {}

A mapping of a TCB template id to a span in the corresponding source code.

property id

id: TypeCheckId;

property span

span: AbsoluteSourceSpan;

interface SymbolBoundTarget

interface SymbolBoundTarget {}

method getConsumerOfBinding

getConsumerOfBinding: (
    binding: TmplAstBoundAttribute | TmplAstBoundEvent | TmplAstTextAttribute
) => SymbolDirectiveMeta | TmplAstElement | TmplAstTemplate | null;

method getDirectivesOfNode

getDirectivesOfNode: (node: TmplAstNode) => SymbolDirectiveMeta[] | null;

method getExpressionTarget

getExpressionTarget: (expr: AST) => TemplateEntity | null;

method getReferenceTarget

getReferenceTarget: (
    ref: TmplAstReference
) => ReferenceTarget<SymbolDirectiveMeta> | null;

interface SymbolDirectiveMeta

interface SymbolDirectiveMeta {}

property hostDirectives

hostDirectives?: HostDirectiveMeta[] | null;

property inputs

inputs: ClassPropertyMapping;

property isComponent

isComponent: boolean;

property isStructural

isStructural: boolean;

property matchSource

matchSource: MatchSource;

property outputs

outputs: ClassPropertyMapping;

property selector

selector: string | null;

method getNgModule

getNgModule: () => ClassDeclaration | null;

method getSymbolReference

getSymbolReference: () => SymbolReference;

interface SymbolReference

interface SymbolReference {}

A reference to a symbol in a source file, without holding heavy AST nodes.

property filePath

filePath: string;

property moduleSpecifier

moduleSpecifier?: string;

property name

name: string;

property position

position: number;

interface TcbLocation

interface TcbLocation {}

Information about where a ts.Node can be found in the type check file. This can either be a type-checking shim file, or an original source file for inline type check blocks.

property endInFile

endInFile?: number;

The end position in the TCB file. Used to correctly resolve AST expressions.

property isShimFile

isShimFile: boolean;

Whether the type check block exists in a type-checking shim file or is inline.

property positionInFile

positionInFile: number;

The location in the file where node appears.

property tcbPath

tcbPath: AbsoluteFsPath;

The fully qualified path of the file which contains the generated TypeScript type check code for the component's template.

interface TemplateContext

interface TemplateContext {}

Contextuable data for type checking the template of a component.

property file

file: ParseSourceFile;

ParseSourceFile associated with the template.

property nodes

nodes: TmplAstNode[];

AST nodes representing the template.

property parseErrors

parseErrors: ParseError[] | null;

Errors produced while parsing the template.

property pipes

pipes: Map<string, PipeMeta>;

Pipes available within the template.

property preserveWhitespaces

preserveWhitespaces: boolean;

Whether the template preserves whitespaces.

property sourceMapping

sourceMapping: SourceMapping;

Describes the origin of the template text. Used for mapping errors back.

interface TemplateDiagnostic

interface TemplateDiagnostic extends ts.DiagnosticWithLocation {}

A ts.Diagnostic with additional information about the diagnostic related to template type-checking.

property sourceFile

sourceFile: ts.SourceFile;

The component with the template that resulted in this diagnostic.

property typeCheckId

typeCheckId: TypeCheckId;

The type check ID of the directive that resulted in this diagnostic.

interface TemplateSymbol

interface TemplateSymbol {}

property directives

directives: DirectiveSymbol[];

A list of directives applied to the element.

property kind

kind: SymbolKind.Template;

property templateNode

templateNode: TmplAstTemplate;

interface TemplateTypeChecker

interface TemplateTypeChecker {}

Interface to the Angular Template Type Checker to extract diagnostics and intelligence from the compiler's understanding of component templates.
This interface is analogous to TypeScript's own ts.TypeChecker API.
In general, this interface supports two kinds of operations: - updating Type Check Blocks (TCB)s that capture the template in the form of TypeScript code - querying information about available TCBs, including diagnostics
Once a TCB is available, information about it can be queried. If no TCB is available to answer a query, depending on the method either null will be returned or an error will be thrown.

method generateAllTypeCheckBlocks

generateAllTypeCheckBlocks: () => void;

Ensures shims for the whole program are generated. This type of operation would be required by operations like "find references" and "refactor/rename" because references may appear in type check blocks generated from templates anywhere in the program.

method getDiagnosticsForComponent

getDiagnosticsForComponent: (component: ts.ClassDeclaration) => ts.Diagnostic[];

Get all ts.Diagnostics currently available that pertain to the given component.
This method always runs in OptimizeFor.SingleFile mode.

method getDiagnosticsForFile

getDiagnosticsForFile: (
    sf: ts.SourceFile,
    optimizeFor: OptimizeFor
) => ts.Diagnostic[];

Get all ts.Diagnostics currently available for the given ts.SourceFile.
This method will fail (throw) if there are components within the ts.SourceFile that do not have TCBs available.
Generating a template type-checking program is expensive, and in some workflows (e.g. checking an entire program before emit), it should ideally only be done once. The optimizeFor flag allows the caller to hint to getDiagnosticsForFile (which internally will create a template type-checking program if needed) whether the caller is interested in just the results of the single file, or whether they plan to query about other files in the program. Based on this flag, getDiagnosticsForFile will determine how much of the user's program to prepare for checking as part of the template type-checking program it creates.

method getDirectiveMetadata

getDirectiveMetadata: (
    dir: ts.ClassDeclaration
) => TypeCheckableDirectiveMeta | null;

Retrieve the type checking engine's metadata for the given directive class, if available.

method getDirectiveScopeData

getDirectiveScopeData: (
    component: ts.ClassDeclaration,
    isInScope: boolean,
    tsCompletionEntryInfo: TsCompletionEntryInfo | null
) => PotentialDirective | null;

Get the scope data for a directive.

method getDirectivesOfNode

getDirectivesOfNode: (
    component: ts.ClassDeclaration,
    node: TmplAstElement | TmplAstTemplate
) => TypeCheckableDirectiveMeta[] | null;

Gets the directives that apply to the given template node in a component's template.

method getElementsInFileScope

getElementsInFileScope: (
    component: ts.ClassDeclaration
) => Map<string, PotentialDirective | null>;

Retrieve a Map of potential template element tags that includes in the current component's file scope, or in the component's NgModule scope.
The different with the getPotentialElementTags is that the directives in the map do not need to update the import statement.

method getExpressionCompletionLocation

getExpressionCompletionLocation: (
    expr: PropertyRead | SafePropertyRead,
    component: ts.ClassDeclaration
) => TcbLocation | null;

For the given expression node, retrieve a TcbLocation that can be used to perform autocompletion at that point in the expression, if such a location exists.

method getExpressionTarget

getExpressionTarget: (
    expression: AST,
    clazz: ts.ClassDeclaration
) => TemplateEntity | null;

Gets the target of a template expression, if possible. See BoundTarget.getExpressionTarget for more information.

method getForeignComponent

getForeignComponent: (
    component: ts.ClassDeclaration,
    element: TmplAstElement
) => ForeignComponentMeta | null;

Gets the foreign component that matched the given template element.

method getGlobalCompletions

getGlobalCompletions: (
    context: TmplAstTemplate | null,
    component: ts.ClassDeclaration,
    node: AST | TmplAstNode
) => GlobalCompletion | null;

Get "global" Completions in the given context.
Global completions are completions in the global context, as opposed to completions within an existing expression. For example, completing inside a new interpolation expression ({{|}}) or inside a new property binding `[input]="|" should retrieve global completions, which will include completions from the template's context component, as well as any local references or template variables which are in scope for that expression.

method getGlobalTsContext

getGlobalTsContext: (component: ts.ClassDeclaration) => TcbLocation | null;

Get the TcbLocation for the global context, which is the location of the this variable.

method getHostElement

getHostElement: (
    directive: ts.ClassDeclaration,
    optimizeFor?: OptimizeFor
) => TmplAstHostElement | null;

Retrieve the host element of the given directive.

method getLiteralCompletionLocation

getLiteralCompletionLocation: (
    strNode: LiteralPrimitive | TmplAstTextAttribute,
    component: ts.ClassDeclaration
) => TcbLocation | null;

For the given node represents a LiteralPrimitive(the TextAttribute represents a string literal), retrieve a TcbLocation that can be used to perform autocompletion at that point in the node, if such a location exists.

method getNgModuleMetadata

getNgModuleMetadata: (module: ts.ClassDeclaration) => NgModuleMeta | null;

Retrieve the type checking engine's metadata for the given NgModule class, if available.

method getOwningNgModule

getOwningNgModule: (
    component: ts.ClassDeclaration
) => ts.ClassDeclaration | null;

Get the class of the NgModule that owns this Angular trait. If the result is null, that probably means the provided component is standalone.

method getPipeMetadata

getPipeMetadata: (pipe: ts.ClassDeclaration) => PipeMeta | null;

Retrieve the type checking engine's metadata for the given pipe class, if available.

method getPotentialDomBindings

getPotentialDomBindings: (
    tagName: string
) => { attribute: string; property: string }[];

Retrieve any potential DOM bindings for the given element.
This returns an array of objects which list both the attribute and property names of each binding, which are usually identical but can vary if the HTML attribute name is for example a reserved keyword in JS, like the for attribute which corresponds to the htmlFor property.

method getPotentialDomEvents

getPotentialDomEvents: (tagName: string) => string[];

Retrieve any potential DOM events.

method getPotentialElementTags

getPotentialElementTags: (
    component: ts.ClassDeclaration,
    tsLs: ts.LanguageService,
    options: GetPotentialAngularMetaOptions
) => Map<string, PotentialDirective | null>;

Retrieve a Map of potential template element tags, to either the PotentialDirective that declares them (if the tag is from a directive/component), or null if the tag originates from the DOM schema.

method getPotentialImportsFor

getPotentialImportsFor: (
    toImport: Reference<ClassDeclaration>,
    inContext: ts.Node,
    importMode: PotentialImportMode,
    potentialDirectiveModuleSpecifierResolver?: PotentialDirectiveModuleSpecifierResolver
) => ReadonlyArray<PotentialImport>;

In the context of an Angular trait, generate potential imports for a directive.

method getPotentialPipes

getPotentialPipes: (component: ts.ClassDeclaration) => PotentialPipe[];

Get basic metadata on the pipes which are in scope or can be imported for the given component.

method getPotentialTemplateDirectives

getPotentialTemplateDirectives: (
    component: ts.ClassDeclaration,
    tsLs: ts.LanguageService,
    options: GetPotentialAngularMetaOptions
) => PotentialDirective[];

Get basic metadata on the directives which are in scope or can be imported for the given component.

method getPrimaryAngularDecorator

getPrimaryAngularDecorator: (target: ts.ClassDeclaration) => ts.Decorator | null;

Get the primary decorator for an Angular class (such as @Component). This does not work for @Injectable.

method getSourceMappingAtTcbLocation

getSourceMappingAtTcbLocation: (
    tcbLocation: TcbLocation
) => FullSourceMapping | null;

Given a shim and position within the file, returns information for mapping back to a source location.

method getSuggestionDiagnosticsForComponent

getSuggestionDiagnosticsForComponent: (
    component: ts.ClassDeclaration,
    tsLs: ts.LanguageService
) => ts.DiagnosticWithLocation[];

Gets suggestion diagnostics for the given component. These diagnostics tend to proactively suggest deprecated, as opposed to diagnostics that indicate potentially incorrect runtime behavior.
This method always runs in OptimizeFor.SingleFile mode.

method getSuggestionDiagnosticsForFile

getSuggestionDiagnosticsForFile: (
    sf: ts.SourceFile,
    tsLs: ts.LanguageService,
    optimizeFor: OptimizeFor
) => ts.DiagnosticWithLocation[];

Gets suggestion diagnostics for the given ts.SourceFile. These diagnostics tend to proactively suggest deprecated, as opposed to diagnostics that indicate potentially incorrect runtime behavior.

method getSymbolOfNode

getSymbolOfNode: {
    (node: TmplAstElement, component: ts.ClassDeclaration): ElementSymbol | null;
    (node: TmplAstTemplate, component: ts.ClassDeclaration): TemplateSymbol;
    (node: any, component: ts.ClassDeclaration): TemplateSymbol | ElementSymbol;
    (
        node: TmplAstComponent,
        component: ts.ClassDeclaration
    ): SelectorlessComponentSymbol;
    (
        node: TmplAstDirective,
        component: ts.ClassDeclaration
    ): SelectorlessDirectiveSymbol;
    (node: any, component: ts.ClassDeclaration): Symbol;
};

Retrieves a Symbol for the node in a component's template.
This method can return null if a valid Symbol cannot be determined for the node.
See Also
- Symbol

method getTemplate

getTemplate: (
    component: ts.ClassDeclaration,
    optimizeFor?: OptimizeFor
) => TmplAstNode[] | null;

Retrieve the template in use for the given component.

method getTsSymbolOfSymbol

getTsSymbolOfSymbol: (
    symbol: Symbol | BindingSymbol | ClassSymbol
) => ts.Symbol | null;

Translates a symbol's TCB location to its corresponding ts.Symbol using the program's type checker.

method getTypeCheckBlock

getTypeCheckBlock: (component: ts.ClassDeclaration) => ts.Node | null;

Retrieve the top-level node representing the TCB for the given component.
This can return null if there is no TCB available for the component.
This method always runs in OptimizeFor.SingleFile mode.

method getTypeOfSymbol

getTypeOfSymbol: (
    symbol: Symbol | BindingSymbol | ClassSymbol
) => ts.Type | null;

Translates a symbol's TCB location to its corresponding ts.Type using the program's type checker. This is used by compiler checks that need semantic type information from a positional symbol.

method getUsedDirectives

getUsedDirectives: (
    component: ts.ClassDeclaration
) => TypeCheckableDirectiveMeta[] | null;

Gets the directives that have been used in a component's template.

method getUsedPipes

getUsedPipes: (component: ts.ClassDeclaration) => string[] | null;

Gets the pipes that have been used in a component's template.

method invalidateClass

invalidateClass: (clazz: ts.ClassDeclaration) => void;

Reset the TemplateTypeChecker's state for the given class, so that it will be recomputed on the next request.

method isTrackedTypeCheckFile

isTrackedTypeCheckFile: (filePath: AbsoluteFsPath) => boolean;

Returns true if the given file is in the record of known shims generated by the compiler, false if we cannot find the file in the shim records.

method makeTemplateDiagnostic

makeTemplateDiagnostic: <T extends ErrorCode>(
    clazz: ts.ClassDeclaration,
    sourceSpan: ParseSourceSpan | AbsoluteSourceSpan,
    category: ts.DiagnosticCategory,
    errorCode: T,
    message: string,
    relatedInformation?: {
        text: string;
        start: number;
        end: number;
        sourceFile?: ts.SourceFile;
    }[]
) => NgTemplateDiagnostic<T>;

Constructs a ts.Diagnostic for a given ParseSourceSpan within a template.
Parameter relatedInformation
Optional list of secondary related messages: - Omit sourceFile when start and end offsets are locations within the template itself. - Specify sourceFile only when referencing a separate file (e.g. directive class declaration).

interface TsCompletionEntryInfo

interface TsCompletionEntryInfo {}

property tsCompletionEntryData

tsCompletionEntryData?: ts.CompletionEntryData;

This data is from the tsLs completion entry, and will be used in the ls.getCompletionEntryDetails.

property tsCompletionEntrySymbolFileName

tsCompletionEntrySymbolFileName: string;

Sometimes, the location of the tsCompletionEntry symbol does not match the location of the Angular symbol.
For example, the BarComponent is declared in bar.ts and exported from there. The public_api.ts also reexports the BarComponent from bar.ts, so the tsCompletionEntrySymbolFileName will be public_api.ts.

property tsCompletionEntrySymbolName

tsCompletionEntrySymbolName: string;

Sometime the component can be exported with a different name than the class name. For example, export {BarComponent as NewBarComponent} from './bar.component';
Sometimes, the component is exported by the NgModule.

interface TsEmitArguments

interface TsEmitArguments {}

property cancellationToken

cancellationToken?: ts.CancellationToken;

property customTransformers

customTransformers?: ts.CustomTransformers;

property emitOnlyDtsFiles

emitOnlyDtsFiles?: boolean;

property host

host: CompilerHost;

property options

options: CompilerOptions;

property program

program: ts.Program;

property targetSourceFile

targetSourceFile?: ts.SourceFile;

property writeFile

writeFile?: ts.WriteFileCallback;

interface TsEmitCallback

interface TsEmitCallback<T extends ts.EmitResult> {}

call signature

(args: TsEmitArguments): T;

interface TsMergeEmitResultsCallback

interface TsMergeEmitResultsCallback<T extends ts.EmitResult> {}

call signature

(results: T[]): T;

interface TsNodeSymbolInfo

interface TsNodeSymbolInfo {}

A generic representation of some node in a template.

property tcbLocation

tcbLocation: TcbLocation;

The position of the most relevant part of the template node.

property tcbTypeLocation

tcbTypeLocation?: TcbLocation;

The position of the expression used to determine the type.

interface TypeAliasEntry

interface TypeAliasEntry extends ConstantEntry {}

Documentation entity for a type alias.

property generics

generics: GenericEntry[];

property members

members: MemberEntry[];

interface TypeCheckableDirectiveMeta

interface TypeCheckableDirectiveMeta extends DirectiveMeta, DirectiveTypeCheckMeta {}

Extension of DirectiveMeta that includes additional information required to type-check the usage of a particular directive.

property decorator

decorator: ts.Decorator | null;

property deferredBlocks

deferredBlocks?: Set<string> | null;

property hostDirectives

hostDirectives: HostDirectiveMeta[] | null;

property imports

imports: Reference<ClassDeclaration>[] | null;

property inputs

inputs: ClassPropertyMapping<InputMapping>;

property isExplicitlyDeferred

isExplicitlyDeferred: boolean;

property isSignal

isSignal: boolean;

property isStandalone

isStandalone: boolean;

property outputs

outputs: ClassPropertyMapping;

property queries

queries: string[];

property rawImports

rawImports: ts.Expression | null;

property ref

ref: Reference<ClassDeclaration>;

interface TypeCheckBlockMetadata

interface TypeCheckBlockMetadata {}

Metadata required in addition to a component class in order to generate a type check block (TCB) for that component.

property boundTarget

boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;

Semantic information about the template of the component.

property id

id: TypeCheckId;

A unique identifier for the class which gave rise to this TCB.
This can be used to map errors back to the ts.ClassDeclaration for the directive.

property isStandalone

isStandalone: boolean;

property pipes

pipes: Map<string, PipeMeta> | null;

property preserveWhitespaces

preserveWhitespaces: boolean;

A boolean indicating whether the component preserves whitespaces in its template.

property schemas

schemas: SchemaMetadata[];

Schemas that apply to this template.

interface TypeCheckContext

interface TypeCheckContext {}

A currently pending type checking operation, into which templates for type-checking can be registered.

method addDirective

addDirective: (
    ref: Reference<ClassDeclaration<ts.ClassDeclaration>>,
    binder: R3TargetBinder<TypeCheckableDirectiveMeta>,
    schemas: SchemaMetadata[],
    templateContext: TemplateContext | null,
    hostBindingContext: HostBindingsContext | null,
    isStandalone: boolean
) => void;

Register a directive to be potentially be type-checked.
Directives registered via addDIrective are available for checking, but might be skipped if checking of that class is not required. This can happen for a few reasons, including if it was previously checked and the prior results are still valid.
Parameter ref
a Reference to the directive class which yielded this template.
Parameter binder
an R3TargetBinder which encapsulates the scope of this template, including all available directives.
Parameter schemas
Schemas that will apply when checking the directive.
Parameter templateContext
Contextual information necessary for checking the template. Only relevant for component classes.
Parameter hostBindingContext
Contextual information necessary for checking the host bindings of a directive.
Parameter isStandalone
a boolean indicating whether the directive is standalone.

interface TypeCheckSourceResolver

interface TypeCheckSourceResolver {}

Adapter interface which allows the directive type-checking diagnostics code to interpret offsets in a TCB and map them back to their original locations.

method getHostBindingsMapping

getHostBindingsMapping: (id: TypeCheckId) => SourceMapping;

For the given type checking id, retrieve the source mapping of its host bindings.

method getTemplateSourceMapping

getTemplateSourceMapping: (id: TypeCheckId) => SourceMapping;

For the given type checking id, retrieve the original source mapping which describes how the offsets in the template should be interpreted.

method getTypeCheckId

getTypeCheckId: (node: ts.ClassDeclaration) => TypeCheckId;

method toHostParseSourceSpan

toHostParseSourceSpan: (
    id: TypeCheckId,
    span: AbsoluteSourceSpan
) => ParseSourceSpan | null;

Convert an absolute source span coming from a host binding associated with the given type checking id into a full ParseSourceSpan. The returned parse span has line and column numbers in addition to only absolute offsets and gives access to the original source code.

method toTemplateParseSourceSpan

toTemplateParseSourceSpan: (
    id: TypeCheckId,
    span: AbsoluteSourceSpan
) => ParseSourceSpan | null;

Convert an absolute source span coming from the template associated with the given type checking id into a full ParseSourceSpan. The returned parse span has line and column numbers in addition to only absolute offsets and gives access to the original source code.

interface VariableCompletion

interface VariableCompletion {}

An autocompletion result representing a variable declared in the template.

property kind

kind: CompletionKind.Variable;

property node

node: TmplAstVariable;

The TmplAstVariable from the template which should be available as a completion.

interface VariableSymbol

interface VariableSymbol {}

A representation of a context variable in a component template.

property declaration

declaration: TmplAstVariable;

The node in the TemplateAst where the variable is declared. That is, the node for the let- node in the template.

property initializerLocation

initializerLocation: TcbLocation;

The location in the shim file for the initializer node of the variable that represents the template variable.

property kind

kind: SymbolKind.Variable;

property localVarLocation

localVarLocation: TcbLocation;

The location in the shim file for the identifier that was declared for the template variable.

Enums

enum CompletionKind

enum CompletionKind {
    Reference = 0,
    Variable = 1,
    LetDeclaration = 2,
}

Discriminant of an autocompletion source (a Completion).

member LetDeclaration

LetDeclaration = 2

member Reference

Reference = 0

member Variable

Variable = 1

enum DecoratorType

enum DecoratorType {
    Class = 'class',
    Member = 'member',
    Parameter = 'parameter',
}

member Class

Class = 'class'

member Member

Member = 'member'

member Parameter

Parameter = 'parameter'

enum EmitFlags

enum EmitFlags {
    DTS = 1,
    JS = 2,
    Metadata = 4,
    I18nBundle = 8,
    Codegen = 16,
    Default = 19,
    All = 31,
}

member All

All = 31

member Codegen

Codegen = 16

member Default

Default = 19

member DTS

DTS = 1

member I18nBundle

I18nBundle = 8

member JS

JS = 2

member Metadata

Metadata = 4

enum EntryType

enum EntryType {
    Block = 'block',
    Component = 'component',
    Constant = 'constant',
    Decorator = 'decorator',
    Directive = 'directive',
    Element = 'element',
    Enum = 'enum',
    Function = 'function',
    Interface = 'interface',
    NgModule = 'ng_module',
    Pipe = 'pipe',
    TypeAlias = 'type_alias',
    UndecoratedClass = 'undecorated_class',
    InitializerApiFunction = 'initializer_api_function',
    Namespace = 'namespace',
}

Type of top-level documentation entry.

member Block

Block = 'block'

member Component

Component = 'component'

member Constant

Constant = 'constant'

member Decorator

Decorator = 'decorator'

member Directive

Directive = 'directive'

member Element

Element = 'element'

member Enum

Enum = 'enum'

member Function

Function = 'function'

member InitializerApiFunction

InitializerApiFunction = 'initializer_api_function'

member Interface

Interface = 'interface'

member Namespace

Namespace = 'namespace'

member NgModule

NgModule = 'ng_module'

member Pipe

Pipe = 'pipe'

member TypeAlias

TypeAlias = 'type_alias'

member UndecoratedClass

UndecoratedClass = 'undecorated_class'

enum ErrorCode

enum ErrorCode {
    DECORATOR_ARG_NOT_LITERAL = -1001,
    DECORATOR_ARITY_WRONG = 1002,
    DECORATOR_NOT_CALLED = 1003,
    DECORATOR_UNEXPECTED = 1005,
    DECORATOR_COLLISION = 1006,
    VALUE_HAS_WRONG_TYPE = 1010,
    VALUE_NOT_LITERAL = 1011,
    DUPLICATE_DECORATED_PROPERTIES = 1012,
    INITIALIZER_API_WITH_DISALLOWED_DECORATOR = 1050,
    INITIALIZER_API_DECORATOR_METADATA_COLLISION = 1051,
    INITIALIZER_API_NO_REQUIRED_FUNCTION = 1052,
    INITIALIZER_API_DISALLOWED_MEMBER_VISIBILITY = 1053,
    DUPLICATE_BINDING_NAME = 1054,
    INCORRECTLY_DECLARED_ON_STATIC_MEMBER = 1100,
    COMPONENT_MISSING_TEMPLATE = 2001,
    PIPE_MISSING_NAME = 2002,
    PARAM_MISSING_TOKEN = -2003,
    DIRECTIVE_MISSING_SELECTOR = 2004,
    UNDECORATED_PROVIDER = 2005,
    DIRECTIVE_INHERITS_UNDECORATED_CTOR = 2006,
    UNDECORATED_CLASS_USING_ANGULAR_FEATURES = 2007,
    COMPONENT_RESOURCE_NOT_FOUND = 2008,
    COMPONENT_INVALID_SHADOW_DOM_SELECTOR = -2009,
    COMPONENT_NOT_STANDALONE = 2010,
    COMPONENT_IMPORT_NOT_STANDALONE = 2011,
    COMPONENT_UNKNOWN_IMPORT = 2012,
    HOST_DIRECTIVE_INVALID = 2013,
    HOST_DIRECTIVE_NOT_STANDALONE = 2014,
    HOST_DIRECTIVE_COMPONENT = 2015,
    INJECTABLE_INHERITS_INVALID_CONSTRUCTOR = 2016,
    HOST_DIRECTIVE_UNDEFINED_BINDING = 2017,
    HOST_DIRECTIVE_CONFLICTING_ALIAS = 2018,
    HOST_DIRECTIVE_MISSING_REQUIRED_BINDING = 2019,
    CONFLICTING_INPUT_TRANSFORM = 2020,
    COMPONENT_INVALID_STYLE_URLS = 2021,
    COMPONENT_UNKNOWN_DEFERRED_IMPORT = 2022,
    NON_STANDALONE_NOT_ALLOWED = 2023,
    MISSING_NAMED_TEMPLATE_DEPENDENCY = 2024,
    INCORRECT_NAMED_TEMPLATE_DEPENDENCY_TYPE = 2025,
    UNSUPPORTED_SELECTORLESS_COMPONENT_FIELD = 2026,
    COMPONENT_ANIMATIONS_CONFLICT = 2027,
    SERVICE_CONSTRUCTOR_DI = 2028,
    SYMBOL_NOT_EXPORTED = 3001,
    IMPORT_CYCLE_DETECTED = -3003,
    IMPORT_GENERATION_FAILURE = 3004,
    CONFIG_FLAT_MODULE_NO_INDEX = 4001,
    CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK = 4002,
    CONFIG_EXTENDED_DIAGNOSTICS_IMPLIES_STRICT_TEMPLATES = 4003,
    CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL = 4004,
    CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK = 4005,
    CONFIG_EMIT_DECLARATION_ONLY_UNSUPPORTED = 4006,
    HOST_BINDING_PARSE_ERROR = 5001,
    TEMPLATE_PARSE_ERROR = 5002,
    NGMODULE_INVALID_DECLARATION = 6001,
    NGMODULE_INVALID_IMPORT = 6002,
    NGMODULE_INVALID_EXPORT = 6003,
    NGMODULE_INVALID_REEXPORT = 6004,
    NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC = 6005,
    NGMODULE_REEXPORT_NAME_COLLISION = 6006,
    NGMODULE_DECLARATION_NOT_UNIQUE = 6007,
    NGMODULE_DECLARATION_IS_STANDALONE = 6008,
    NGMODULE_BOOTSTRAP_IS_STANDALONE = 6009,
    WARN_NGMODULE_ID_UNNECESSARY = -6100,
    SCHEMA_INVALID_ELEMENT = -8001,
    SCHEMA_INVALID_ATTRIBUTE = -8002,
    MISSING_REFERENCE_TARGET = -8003,
    MISSING_PIPE = 8004,
    WRITE_TO_READ_ONLY_VARIABLE = 8005,
    DUPLICATE_VARIABLE_DECLARATION = 8006,
    SPLIT_TWO_WAY_BINDING = 8007,
    MISSING_REQUIRED_INPUTS = 8008,
    ILLEGAL_FOR_LOOP_TRACK_ACCESS = 8009,
    INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT = 8010,
    CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION = -8011,
    DEFERRED_PIPE_USED_EAGERLY = 8012,
    DEFERRED_DIRECTIVE_USED_EAGERLY = 8013,
    DEFERRED_DEPENDENCY_IMPORTED_EAGERLY = 8014,
    ILLEGAL_LET_WRITE = 8015,
    LET_USED_BEFORE_DEFINITION = 8016,
    CONFLICTING_LET_DECLARATION = 8017,
    UNCLAIMED_DIRECTIVE_BINDING = 8018,
    DEFER_IMPLICIT_TRIGGER_MISSING_PLACEHOLDER = 8019,
    DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER = 8020,
    DEFER_TRIGGER_MISCONFIGURATION = 8021,
    FORM_FIELD_UNSUPPORTED_BINDING = 8022,
    MULTIPLE_MATCHING_COMPONENTS = -8023,
    CONFLICTING_HOST_DIRECTIVE_BINDING = -8024,
    FOREIGN_COMPONENT_UNSUPPORTED_BINDING = 8025,
    INVALID_CONTENT_PLACEMENT = 8026,
    FOREIGN_COMPONENT_CONTENT_UNNECESSARY_FOR_CHILDREN = 8027,
    CONFLICTING_CONTENT_DECLARATION = 8028,
    CONFLICTING_CONTENT_AND_PROPERTY = 8029,
    UNCLAIMED_EVENT_BINDING = 8030,
    INVALID_BANANA_IN_BOX = 8101,
    NULLISH_COALESCING_NOT_NULLABLE = 8102,
    MISSING_CONTROL_FLOW_DIRECTIVE = 8103,
    TEXT_ATTRIBUTE_NOT_BINDING = 8104,
    MISSING_NGFOROF_LET = 8105,
    SUFFIX_NOT_SUPPORTED = 8106,
    OPTIONAL_CHAIN_NOT_NULLABLE = 8107,
    SKIP_HYDRATION_NOT_STATIC = 8108,
    INTERPOLATED_SIGNAL_NOT_INVOKED = 8109,
    UNSUPPORTED_INITIALIZER_API_USAGE = 8110,
    UNINVOKED_FUNCTION_IN_EVENT_BINDING = 8111,
    UNUSED_LET_DECLARATION = 8112,
    UNUSED_STANDALONE_IMPORTS = 8113,
    UNPARENTHESIZED_NULLISH_COALESCING = 8114,
    UNINVOKED_TRACK_FUNCTION = 8115,
    MISSING_STRUCTURAL_DIRECTIVE = 8116,
    UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION = 8117,
    FORBIDDEN_REQUIRED_INITIALIZER_INVOCATION = 8118,
    INLINE_TCB_REQUIRED = 8900,
    INLINE_TYPE_CTOR_REQUIRED = 8901,
    INJECTABLE_DUPLICATE_PROV = 9001,
    SUGGEST_STRICT_TEMPLATES = 10001,
    SUGGEST_SUBOPTIMAL_TYPE_INFERENCE = 10002,
    LOCAL_COMPILATION_UNRESOLVED_CONST = 11001,
    LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION = 11003,
    DEFER_BLOCK_MISSING_NAME_PARAMETER = 11100,
    DEFER_BLOCK_UNKNOWN_NAME_PARAMETER = 11101,
    DEFER_BLOCK_INVALID_NAME_PARAMETER = 11102,
}

member COMPONENT_ANIMATIONS_CONFLICT

COMPONENT_ANIMATIONS_CONFLICT = 2027

A component is using both the animations property and animate.enter or animate.leave in the template.

member COMPONENT_IMPORT_NOT_STANDALONE

COMPONENT_IMPORT_NOT_STANDALONE = 2011

Raised when a type in the imports of a component is a directive or pipe, but is not standalone.

member COMPONENT_INVALID_SHADOW_DOM_SELECTOR

COMPONENT_INVALID_SHADOW_DOM_SELECTOR = -2009

Raised when a component uses ShadowDom view encapsulation, but its selector does not match the shadow DOM tag name requirements.

member COMPONENT_INVALID_STYLE_URLS

COMPONENT_INVALID_STYLE_URLS = 2021

Raised when a component has both styleUrls and styleUrl.

member COMPONENT_MISSING_TEMPLATE

COMPONENT_MISSING_TEMPLATE = 2001

member COMPONENT_NOT_STANDALONE

COMPONENT_NOT_STANDALONE = 2010

Raised when a component has imports but is not marked as standalone: true.

member COMPONENT_RESOURCE_NOT_FOUND

COMPONENT_RESOURCE_NOT_FOUND = 2008

Raised when an component cannot resolve an external resource, such as a template or a style sheet.

member COMPONENT_UNKNOWN_DEFERRED_IMPORT

COMPONENT_UNKNOWN_DEFERRED_IMPORT = 2022

Raised when a type in the deferredImports of a component is not a component, directive or pipe.

member COMPONENT_UNKNOWN_IMPORT

COMPONENT_UNKNOWN_IMPORT = 2012

Raised when a type in the imports of a component is not a directive, pipe, or NgModule.

member CONFIG_EMIT_DECLARATION_ONLY_UNSUPPORTED

CONFIG_EMIT_DECLARATION_ONLY_UNSUPPORTED = 4006

member CONFIG_EXTENDED_DIAGNOSTICS_IMPLIES_STRICT_TEMPLATES

CONFIG_EXTENDED_DIAGNOSTICS_IMPLIES_STRICT_TEMPLATES = 4003

member CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL

CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CATEGORY_LABEL = 4004

member CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK

CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK = 4005

member CONFIG_FLAT_MODULE_NO_INDEX

CONFIG_FLAT_MODULE_NO_INDEX = 4001

member CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK

CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK = 4002

member CONFLICTING_CONTENT_AND_PROPERTY

CONFLICTING_CONTENT_AND_PROPERTY = 8029

Raised when a @content block name conflicts with an input binding on the parent foreign component.

member CONFLICTING_CONTENT_DECLARATION

CONFLICTING_CONTENT_DECLARATION = 8028

Raised when multiple @content blocks with the same name are defined for a foreign component.

member CONFLICTING_HOST_DIRECTIVE_BINDING

CONFLICTING_HOST_DIRECTIVE_BINDING = -8024

Raised when a host directive input/output is exposed multiple times under the same name.

member CONFLICTING_INPUT_TRANSFORM

CONFLICTING_INPUT_TRANSFORM = 2020

Raised when a component specifies both a transform function on an input and has a corresponding ngAcceptInputType_ member for the same input.

member CONFLICTING_LET_DECLARATION

CONFLICTING_LET_DECLARATION = 8017

A @let declaration conflicts with another symbol in the same scope.

member CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION

CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION = -8011

A control flow node is projected at the root of a component and is preventing its direct descendants from being projected, because it has more than one root node.
<comp> @if (expr) { <div projectsIntoSlot></div> Text preventing the div from being projected } </comp>

member DECORATOR_ARG_NOT_LITERAL

DECORATOR_ARG_NOT_LITERAL = -1001

member DECORATOR_ARITY_WRONG

DECORATOR_ARITY_WRONG = 1002

member DECORATOR_COLLISION

DECORATOR_COLLISION = 1006

This error code indicates that there are incompatible decorators on a type or a class field.

member DECORATOR_NOT_CALLED

DECORATOR_NOT_CALLED = 1003

member DECORATOR_UNEXPECTED

DECORATOR_UNEXPECTED = 1005

member DEFER_BLOCK_INVALID_NAME_PARAMETER

DEFER_BLOCK_INVALID_NAME_PARAMETER = 11102

Raised when a @defer block specifies a name parameter but deferredImports is not an object.

member DEFER_BLOCK_MISSING_NAME_PARAMETER

DEFER_BLOCK_MISSING_NAME_PARAMETER = 11100

Raised when a @defer block is missing a name parameter but deferredImports is an object.

member DEFER_BLOCK_UNKNOWN_NAME_PARAMETER

DEFER_BLOCK_UNKNOWN_NAME_PARAMETER = 11101

Raised when a @defer block specifies a name parameter that does not match any entry in deferredImports.

member DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER

DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER = 8020

The @placeholder for an implicit @defer trigger is not set up correctly, for example:

@defer(on viewport) {
  Hello
} @placeholder {
  <!-- Multiple root nodes. -->
  <button></button>
  <div></div>
}

member DEFER_IMPLICIT_TRIGGER_MISSING_PLACEHOLDER

DEFER_IMPLICIT_TRIGGER_MISSING_PLACEHOLDER = 8019

An @defer block with an implicit trigger does not have a placeholder, for example:
@defer(on viewport) { Hello }

member DEFER_TRIGGER_MISCONFIGURATION

DEFER_TRIGGER_MISCONFIGURATION = 8021

Raised when an @defer block defines unreachable or redundant triggers. Examples: multiple main triggers, 'on immediate' together with other mains or any prefetch, prefetch timer delay that is not earlier than the main timer, or an identical prefetch

member DEFERRED_DEPENDENCY_IMPORTED_EAGERLY

DEFERRED_DEPENDENCY_IMPORTED_EAGERLY = 8014

A directive/component/pipe imported via @Component.deferredImports is also included into the @Component.imports list.

member DEFERRED_DIRECTIVE_USED_EAGERLY

DEFERRED_DIRECTIVE_USED_EAGERLY = 8013

A directive/component imported via @Component.deferredImports is used outside of a @defer block in a template.

member DEFERRED_PIPE_USED_EAGERLY

DEFERRED_PIPE_USED_EAGERLY = 8012

A pipe imported via @Component.deferredImports is used outside of a @defer block in a template.

member DIRECTIVE_INHERITS_UNDECORATED_CTOR

DIRECTIVE_INHERITS_UNDECORATED_CTOR = 2006

Raised when a Directive inherits its constructor from a base class without an Angular decorator.

member DIRECTIVE_MISSING_SELECTOR

DIRECTIVE_MISSING_SELECTOR = 2004

member DUPLICATE_BINDING_NAME

DUPLICATE_BINDING_NAME = 1054

Raised whenever there are duplicate binding property names for outputs, inputs & models.

member DUPLICATE_DECORATED_PROPERTIES

DUPLICATE_DECORATED_PROPERTIES = 1012

member DUPLICATE_VARIABLE_DECLARATION

DUPLICATE_VARIABLE_DECLARATION = 8006

A template variable was declared twice. For example:
<div *ngFor="let i of items; let i = index"> </div>

member FORBIDDEN_REQUIRED_INITIALIZER_INVOCATION

FORBIDDEN_REQUIRED_INITIALIZER_INVOCATION = 8118

A required initializer is being invoked in a forbidden context such as a property initializer or a constructor.
For example: ```ts class MyComponent { myInput = input.required(); somValue = this.myInput(); // Error
constructor() { this.myInput(); // Error }

member FOREIGN_COMPONENT_CONTENT_UNNECESSARY_FOR_CHILDREN

FOREIGN_COMPONENT_CONTENT_UNNECESSARY_FOR_CHILDREN = 8027

Raised when a @content block is named 'children', which is unnecessary because children should be passed implicitly.

member FOREIGN_COMPONENT_UNSUPPORTED_BINDING

FOREIGN_COMPONENT_UNSUPPORTED_BINDING = 8025

Raised when a foreign component node has an unsupported Angular binding.

member FORM_FIELD_UNSUPPORTED_BINDING

FORM_FIELD_UNSUPPORTED_BINDING = 8022

Raised when the user has an unsupported binding on a FormField directive.

member HOST_BINDING_PARSE_ERROR

HOST_BINDING_PARSE_ERROR = 5001

Raised when a host expression has a parse error, such as a host listener or host binding expression containing a pipe.

member HOST_DIRECTIVE_COMPONENT

HOST_DIRECTIVE_COMPONENT = 2015

Raised when a host directive is a component.

member HOST_DIRECTIVE_CONFLICTING_ALIAS

HOST_DIRECTIVE_CONFLICTING_ALIAS = 2018

Raised when a host tries to alias a host directive binding to a pre-existing binding's public name.

member HOST_DIRECTIVE_INVALID

HOST_DIRECTIVE_INVALID = 2013

Raised when the compiler wasn't able to resolve the metadata of a host directive.

member HOST_DIRECTIVE_MISSING_REQUIRED_BINDING

HOST_DIRECTIVE_MISSING_REQUIRED_BINDING = 2019

Raised when a host directive definition doesn't expose a required binding from the host directive.

member HOST_DIRECTIVE_NOT_STANDALONE

HOST_DIRECTIVE_NOT_STANDALONE = 2014

Raised when a host directive isn't standalone.

member HOST_DIRECTIVE_UNDEFINED_BINDING

HOST_DIRECTIVE_UNDEFINED_BINDING = 2017

Raised when a host tries to alias a host directive binding that does not exist.

member ILLEGAL_FOR_LOOP_TRACK_ACCESS

ILLEGAL_FOR_LOOP_TRACK_ACCESS = 8009

The tracking expression of a for loop block is accessing a variable that is unavailable, for example:
<ng-template let-ref> @for (item of items; track ref) {} </ng-template>

member ILLEGAL_LET_WRITE

ILLEGAL_LET_WRITE = 8015

An expression is trying to write to an @let declaration.

member IMPORT_CYCLE_DETECTED

IMPORT_CYCLE_DETECTED = -3003

Raised when a relationship between directives and/or pipes would cause a cyclic import to be created that cannot be handled, such as in partial compilation mode.

member IMPORT_GENERATION_FAILURE

IMPORT_GENERATION_FAILURE = 3004

Raised when the compiler is unable to generate an import statement for a reference.

member INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT

INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT = 8010

The trigger of a defer block cannot access its trigger element, either because it doesn't exist or it's in a different view.
@defer (on interaction(trigger)) {...} <ng-template> <button #trigger></button> </ng-template>

member INCORRECT_NAMED_TEMPLATE_DEPENDENCY_TYPE

INCORRECT_NAMED_TEMPLATE_DEPENDENCY_TYPE = 2025

Raised if an incorrect type is used for a named template dependency (e.g. directive class used as a component).

member INCORRECTLY_DECLARED_ON_STATIC_MEMBER

INCORRECTLY_DECLARED_ON_STATIC_MEMBER = 1100

An Angular feature, like inputs, outputs or queries is incorrectly declared on a static member.

member INITIALIZER_API_DECORATOR_METADATA_COLLISION

INITIALIZER_API_DECORATOR_METADATA_COLLISION = 1051

Raised when an initializer API feature (like signal inputs) are also declared in the class decorator metadata.
e.g. a signal input is also declared in the @Directive inputs array.

member INITIALIZER_API_DISALLOWED_MEMBER_VISIBILITY

INITIALIZER_API_DISALLOWED_MEMBER_VISIBILITY = 1053

Raised whenever an initializer API is used on a class member and the given access modifiers (e.g. private) are not allowed.

member INITIALIZER_API_NO_REQUIRED_FUNCTION

INITIALIZER_API_NO_REQUIRED_FUNCTION = 1052

Raised whenever an initializer API does not support the .required function, but is still detected unexpectedly.

member INITIALIZER_API_WITH_DISALLOWED_DECORATOR

INITIALIZER_API_WITH_DISALLOWED_DECORATOR = 1050

Raised when an initializer API is annotated with an unexpected decorator.
e.g. @Input is also applied on the class member using input.

member INJECTABLE_DUPLICATE_PROV

INJECTABLE_DUPLICATE_PROV = 9001

An injectable already has a ɵprov property.

member INJECTABLE_INHERITS_INVALID_CONSTRUCTOR

INJECTABLE_INHERITS_INVALID_CONSTRUCTOR = 2016

Raised when a type with Angular decorator inherits its constructor from a base class which has a constructor that is incompatible with Angular DI.

member INLINE_TCB_REQUIRED

INLINE_TCB_REQUIRED = 8900

The template type-checking engine would need to generate an inline type check block for a component, but the current type-checking environment doesn't support it.

member INLINE_TYPE_CTOR_REQUIRED

INLINE_TYPE_CTOR_REQUIRED = 8901

The template type-checking engine would need to generate an inline type constructor for a directive or component, but the current type-checking environment doesn't support it.

member INTERPOLATED_SIGNAL_NOT_INVOKED

INTERPOLATED_SIGNAL_NOT_INVOKED = 8109

Signal functions should be invoked when interpolated in templates.
For example:
{{ mySignal() }}

member INVALID_BANANA_IN_BOX

INVALID_BANANA_IN_BOX = 8101

A two way binding in a template has an incorrect syntax, parentheses outside brackets. For example:
<div ([foo])="bar" />

member INVALID_CONTENT_PLACEMENT

INVALID_CONTENT_PLACEMENT = 8026

Raised when a @content block is not used as a direct child of a foreign component.

member LET_USED_BEFORE_DEFINITION

LET_USED_BEFORE_DEFINITION = 8016

An expression is trying to read an @let before it has been defined.

member LOCAL_COMPILATION_UNRESOLVED_CONST

LOCAL_COMPILATION_UNRESOLVED_CONST = 11001

In local compilation mode a const is required to be resolved statically but cannot be so since it is imported from a file outside of the compilation unit. This usually happens with const being used as Angular decorators parameters such as @Component.template, @HostListener.eventName, etc.

member LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION

LOCAL_COMPILATION_UNSUPPORTED_EXPRESSION = 11003

In local compilation mode a certain expression or syntax is not supported. This is usually because the expression/syntax is not very common and so we did not add support for it yet. This can be changed in the future and support for more expressions could be added if need be. Meanwhile, this error is thrown to indicate a current unavailability.

member MISSING_CONTROL_FLOW_DIRECTIVE

MISSING_CONTROL_FLOW_DIRECTIVE = 8103

A known control flow directive (e.g. *ngIf) is used in a template, but the CommonModule is not imported.

member MISSING_NAMED_TEMPLATE_DEPENDENCY

MISSING_NAMED_TEMPLATE_DEPENDENCY = 2024

Raised when a named template dependency isn't defined in the component's source file.

member MISSING_NGFOROF_LET

MISSING_NGFOROF_LET = 8105

NgForOf is used in a template, but the user forgot to include let in their statement.
For example:
<ul><li *ngFor="item of items">{{item["name"]}};</li></ul>

member MISSING_PIPE

MISSING_PIPE = 8004

No matching pipe was found for a

member MISSING_REFERENCE_TARGET

MISSING_REFERENCE_TARGET = -8003

No matching directive was found for a #ref="target" expression.

member MISSING_REQUIRED_INPUTS

MISSING_REQUIRED_INPUTS = 8008

A directive usage isn't binding to one or more required inputs.

member MISSING_STRUCTURAL_DIRECTIVE

MISSING_STRUCTURAL_DIRECTIVE = 8116

A structural directive is used in a template, but the directive is not imported.

member MULTIPLE_MATCHING_COMPONENTS

MULTIPLE_MATCHING_COMPONENTS = -8023

Raised when multiple components in the compilation scope match a given element in a template.

member NGMODULE_BOOTSTRAP_IS_STANDALONE

NGMODULE_BOOTSTRAP_IS_STANDALONE = 6009

Raised when a standalone component is part of the bootstrap list of an NgModule.

member NGMODULE_DECLARATION_IS_STANDALONE

NGMODULE_DECLARATION_IS_STANDALONE = 6008

Raised when a standalone directive/pipe is part of the declarations of an NgModule.

member NGMODULE_DECLARATION_NOT_UNIQUE

NGMODULE_DECLARATION_NOT_UNIQUE = 6007

Raised when a directive/pipe is part of the declarations of two or more NgModules.

member NGMODULE_INVALID_DECLARATION

NGMODULE_INVALID_DECLARATION = 6001

Raised when an NgModule contains an invalid reference in declarations.

member NGMODULE_INVALID_EXPORT

NGMODULE_INVALID_EXPORT = 6003

Raised when an NgModule contains an invalid type in exports.

member NGMODULE_INVALID_IMPORT

NGMODULE_INVALID_IMPORT = 6002

Raised when an NgModule contains an invalid type in imports.

member NGMODULE_INVALID_REEXPORT

NGMODULE_INVALID_REEXPORT = 6004

Raised when an NgModule contains a type in exports which is neither in declarations nor otherwise imported.

member NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC

NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC = 6005

Raised when a ModuleWithProviders with a missing generic type argument is passed into an NgModule.

member NGMODULE_REEXPORT_NAME_COLLISION

NGMODULE_REEXPORT_NAME_COLLISION = 6006

Raised when an NgModule exports multiple directives/pipes of the same name and the compiler attempts to generate private re-exports within the NgModule file.

member NON_STANDALONE_NOT_ALLOWED

NON_STANDALONE_NOT_ALLOWED = 2023

Raised when a standalone: false component is declared but strictStandalone is set.

member NULLISH_COALESCING_NOT_NULLABLE

NULLISH_COALESCING_NOT_NULLABLE = 8102

The left side of a nullish coalescing operation is not nullable.
{{ foo ?? bar }}
When the type of foo doesn't include null or undefined.

member OPTIONAL_CHAIN_NOT_NULLABLE

OPTIONAL_CHAIN_NOT_NULLABLE = 8107

The left side of an optional chain operation is not nullable.
{{ foo?.bar }} {{ foo?.['bar'] }} {{ foo?.() }}
When the type of foo doesn't include null or undefined.

member PARAM_MISSING_TOKEN

PARAM_MISSING_TOKEN = -2003

member PIPE_MISSING_NAME

PIPE_MISSING_NAME = 2002

member SCHEMA_INVALID_ATTRIBUTE

SCHEMA_INVALID_ATTRIBUTE = -8002

An element's attribute name failed validation against the DOM schema.

member SCHEMA_INVALID_ELEMENT

SCHEMA_INVALID_ELEMENT = -8001

An element name failed validation against the DOM schema.

member SERVICE_CONSTRUCTOR_DI

SERVICE_CONSTRUCTOR_DI = 2028

Raised when an @Service class is using constructor dependency injection.

member SKIP_HYDRATION_NOT_STATIC

SKIP_HYDRATION_NOT_STATIC = 8108

ngSkipHydration should not be a binding (it should be a static attribute).
For example:
<my-cmp [ngSkipHydration]="someTruthyVar" />
ngSkipHydration cannot be a binding and can not have values other than "true" or an empty value

member SPLIT_TWO_WAY_BINDING

SPLIT_TWO_WAY_BINDING = 8007

A template has a two way binding (two bindings created by a single syntactical element) in which the input and output are going to different places.

member SUFFIX_NOT_SUPPORTED

SUFFIX_NOT_SUPPORTED = 8106

Indicates that the binding suffix is not supported
Style bindings support suffixes like style.width.px, .em, and .%. These suffixes are _not_ supported for attribute bindings.
For example [attr.width.px]="5" becomes width.px="5" when bound. This is almost certainly unintentional and this error is meant to surface this mistake to the developer.

member SUGGEST_STRICT_TEMPLATES

SUGGEST_STRICT_TEMPLATES = 10001

Suggest users to enable strictTemplates to make use of full capabilities provided by Angular language service.

member SUGGEST_SUBOPTIMAL_TYPE_INFERENCE

SUGGEST_SUBOPTIMAL_TYPE_INFERENCE = 10002

Indicates that a particular structural directive provides advanced type narrowing functionality, but the current template type-checking configuration does not allow its usage in type inference.

member SYMBOL_NOT_EXPORTED

SYMBOL_NOT_EXPORTED = 3001

member TEMPLATE_PARSE_ERROR

TEMPLATE_PARSE_ERROR = 5002

Raised when the compiler cannot parse a component's template.

member TEXT_ATTRIBUTE_NOT_BINDING

TEXT_ATTRIBUTE_NOT_BINDING = 8104

A text attribute is not interpreted as a binding but likely intended to be.
For example:
<div attr.x="value" class.blue="true" style.margin-right.px="5"> </div>
All of the above attributes will just be static text attributes and will not be interpreted as bindings by the compiler.

member UNCLAIMED_DIRECTIVE_BINDING

UNCLAIMED_DIRECTIVE_BINDING = 8018

A binding inside selectorless directive syntax did not match any inputs/outputs of the directive.

member UNCLAIMED_EVENT_BINDING

UNCLAIMED_EVENT_BINDING = 8030

An event binding on an element with matched directives refers to an event which is neither an output of the matched directives nor a known native DOM event. For example:
<some-cmp (outputTypo)="handle()"></some-cmp>
This is only reported when strictUnclaimedEventNames is enabled.

member UNDECORATED_CLASS_USING_ANGULAR_FEATURES

UNDECORATED_CLASS_USING_ANGULAR_FEATURES = 2007

Raised when an undecorated class that is using Angular features has been discovered.

member UNDECORATED_PROVIDER

UNDECORATED_PROVIDER = 2005

Raised when an undecorated class is passed in as a provider to a module or a directive.

member UNINVOKED_FUNCTION_IN_EVENT_BINDING

UNINVOKED_FUNCTION_IN_EVENT_BINDING = 8111

A function in an event binding is not called.
For example:
<button (click)="myFunc"></button>
This will not call myFunc when the button is clicked. Instead, it should be <button (click)="myFunc()"></button>.

member UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION

UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION = 8117

A function in a text interpolation is not invoked.
For example:
<p> {{ firstName }} </p>
The firstName function is not invoked. Instead, it should be:
<p> {{ firstName() }} </p>

member UNINVOKED_TRACK_FUNCTION

UNINVOKED_TRACK_FUNCTION = 8115

The function passed to @for track is not invoked.
For example:
@for (item of items; track trackByName) {}
For the track function to work properly, it must be invoked.
For example:
@for (item of items; track trackByName(item)) {}

member UNPARENTHESIZED_NULLISH_COALESCING

UNPARENTHESIZED_NULLISH_COALESCING = 8114

An expression mixes nullish coalescing and logical and/or without parentheses.

member UNSUPPORTED_INITIALIZER_API_USAGE

UNSUPPORTED_INITIALIZER_API_USAGE = 8110

Initializer-based APIs can only be invoked from inside of an initializer.

// Allowed
myInput = input();

// Not allowed
function myInput() {
  return input();
}

member UNSUPPORTED_SELECTORLESS_COMPONENT_FIELD

UNSUPPORTED_SELECTORLESS_COMPONENT_FIELD = 2026

Raised for @Component fields that aren't supported in a selectorless context.

member UNUSED_LET_DECLARATION

UNUSED_LET_DECLARATION = 8112

A @let declaration in a template isn't used.

For example:

@let used = 1; <!-- Not an error -->
@let notUsed = 2; <!-- Error -->

{{used}}

member UNUSED_STANDALONE_IMPORTS

UNUSED_STANDALONE_IMPORTS = 8113

A symbol referenced in @Component.imports isn't being used within the template.

member VALUE_HAS_WRONG_TYPE

VALUE_HAS_WRONG_TYPE = 1010

member VALUE_NOT_LITERAL

VALUE_NOT_LITERAL = 1011

member WARN_NGMODULE_ID_UNNECESSARY

WARN_NGMODULE_ID_UNNECESSARY = -6100

Indicates that an NgModule is declared with id: module.id. This is an anti-pattern that is disabled explicitly in the compiler, that was originally based on a misunderstanding of NgModule.id.

member WRITE_TO_READ_ONLY_VARIABLE

WRITE_TO_READ_ONLY_VARIABLE = 8005

The left-hand side of an assignment expression was a template variable. Effectively, the template looked like:
<ng-template let-something> <button (click)="something = ...">...</button> </ng-template>
Template variables are read-only.

enum InliningMode

enum InliningMode {
    InlineOps = 0,
    Error = 1,
    CopySourceToTcb = 2,
}

How a type-checking context should handle operations which would require inlining.

member CopySourceToTcb

CopySourceToTcb = 2

member Error

Error = 1

member InlineOps

InlineOps = 0

enum LogLevel

enum LogLevel {
    debug = 0,
    info = 1,
    warn = 2,
    error = 3,
}

member debug

debug = 0

member error

error = 3

member info

info = 1

member warn

warn = 2

enum MemberTags

enum MemberTags {
    Abstract = 'abstract',
    Static = 'static',
    Readonly = 'readonly',
    Protected = 'protected',
    Optional = 'optional',
    Input = 'input',
    Output = 'output',
    Inherited = 'override',
}

Informational tags applicable to class members.

member Abstract

Abstract = 'abstract'

member Inherited

Inherited = 'override'

member Input

Input = 'input'

member Optional

Optional = 'optional'

member Output

Output = 'output'

member Protected

Protected = 'protected'

member Readonly

Readonly = 'readonly'

member Static

Static = 'static'

enum MemberType

enum MemberType {
    Property = 'property',
    Method = 'method',
    Getter = 'getter',
    Setter = 'setter',
    EnumItem = 'enum_item',
    Interface = 'interface',
    TypeAlias = 'type_alias',
}

Types of class members

member EnumItem

EnumItem = 'enum_item'

member Getter

Getter = 'getter'

member Interface

Interface = 'interface'

member Method

Method = 'method'

member Property

Property = 'property'

member Setter

Setter = 'setter'

member TypeAlias

TypeAlias = 'type_alias'

enum MetaKind

enum MetaKind {
    Directive = 0,
    Pipe = 1,
    NgModule = 2,
}

Disambiguates different kinds of compiler metadata objects.

member Directive

Directive = 0

member NgModule

NgModule = 2

member Pipe

Pipe = 1

enum OptimizeFor

enum OptimizeFor {
    SingleFile = 0,
    WholeProgram = 1,
}

Describes the scope of the caller's interest in template type-checking results.

member SingleFile

SingleFile = 0

Indicates that a consumer of a TemplateTypeChecker is only interested in results for a given file, and wants them as fast as possible.
Calling TemplateTypeChecker methods successively for multiple files while specifying OptimizeFor.SingleFile can result in significant unnecessary overhead overall.

member WholeProgram

WholeProgram = 1

Indicates that a consumer of a TemplateTypeChecker intends to query for results pertaining to the entire user program, and so the type-checker should internally optimize for this case.
Initial calls to retrieve type-checking information may take longer, but repeated calls to gather information for the whole user program will be significantly faster with this mode of optimization.

enum PerfPhase

enum PerfPhase {
    Unaccounted = 0,
    Setup = 1,
    TypeScriptProgramCreate = 2,
    Reconciliation = 3,
    ResourceUpdate = 4,
    TypeScriptDiagnostics = 5,
    Analysis = 6,
    Resolve = 7,
    CycleDetection = 8,
    TcbGeneration = 9,
    TcbUpdateProgram = 10,
    TypeScriptEmit = 11,
    Compile = 12,
    TtcAutocompletion = 13,
    TtcDiagnostics = 14,
    TtcSuggestionDiagnostics = 15,
    TtcSymbol = 16,
    LsReferencesAndRenames = 17,
    LsQuickInfo = 18,
    LsDefinition = 19,
    LsCompletions = 20,
    LsTcb = 21,
    LsDiagnostics = 22,
    LsSuggestionDiagnostics = 23,
    LsComponentLocations = 24,
    LsSignatureHelp = 25,
    OutliningSpans = 26,
    LsCodeFixes = 27,
    LsCodeFixesAll = 28,
    LSComputeApplicableRefactorings = 29,
    LSApplyRefactoring = 30,
    LSSemanticClassification = 31,
    LAST = 32,
}

A phase of compilation for which time is tracked in a distinct bucket.

member Analysis

Analysis = 6

Time spent in Angular analysis of individual classes in the program.

member Compile

Compile = 12

Time spent by Angular performing code transformations of ASTs as they're about to be emitted.
This includes the actual code generation step for templates, and occurs during the emit phase (but is tracked separately from TypeScriptEmit time).

member CycleDetection

CycleDetection = 8

Time spent building the import graph of the program in order to perform cycle detection.

member LAST

LAST = 32

Tracks the number of PerfPhases, and must appear at the end of the list.

member LSApplyRefactoring

LSApplyRefactoring = 30

Time spent computing changes for applying a given refactoring.

member LsCodeFixes

LsCodeFixes = 27

Time spent by the Angular Language Service calculating code fixes.

member LsCodeFixesAll

LsCodeFixesAll = 28

Time spent by the Angular Language Service to fix all detected same type errors.

member LsCompletions

LsCompletions = 20

Time spent by the Angular Language Service calculating a "get completions" (AKA autocomplete) operation.

member LsComponentLocations

LsComponentLocations = 24

Time spent by the Angular Language Service calculating a "get component locations for template" operation.

member LSComputeApplicableRefactorings

LSComputeApplicableRefactorings = 29

Time spent computing possible Angular refactorings.

member LsDefinition

LsDefinition = 19

Time spent by the Angular Language Service calculating a "get type definition" or "get definition" operation.

member LsDiagnostics

LsDiagnostics = 22

Time spent by the Angular Language Service calculating diagnostics.

member LsQuickInfo

LsQuickInfo = 18

Time spent by the Angular Language Service calculating a "quick info" operation.

member LsReferencesAndRenames

LsReferencesAndRenames = 17

Time spent by the Angular Language Service calculating a "get references" or a renaming operation.

member LSSemanticClassification

LSSemanticClassification = 31

Time spent by the Angular Language Service calculating semantic classifications.

member LsSignatureHelp

LsSignatureHelp = 25

Time spent by the Angular Language Service calculating signature help.

member LsSuggestionDiagnostics

LsSuggestionDiagnostics = 23

Time spent by the Angular Language Service calculating suggestion diagnostics.

member LsTcb

LsTcb = 21

Time spent by the Angular Language Service calculating a "view template typecheck block" operation.

member OutliningSpans

OutliningSpans = 26

Time spent by the Angular Language Service calculating outlining spans.

member Reconciliation

Reconciliation = 3

Time spent reconciling the contents of an old ts.Program with the new incremental one.
Only present in incremental compilations.

member Resolve

Resolve = 7

Time spent in Angular global analysis (synthesis of analysis information into a complete understanding of the program).

member ResourceUpdate

ResourceUpdate = 4

Time spent updating an NgCompiler instance with a resource-only change.
Only present in incremental compilations where the change was resource-only.

member Setup

Setup = 1

Time spent setting up the compiler, before a TypeScript program is created.
This includes operations like configuring the ts.CompilerHost and any wrappers.

member TcbGeneration

TcbGeneration = 9

Time spent generating the text of Type Check Blocks in order to perform template type checking.

member TcbUpdateProgram

TcbUpdateProgram = 10

Time spent updating the ts.Program with new Type Check Block code.

member TtcAutocompletion

TtcAutocompletion = 13

Time spent performing a TemplateTypeChecker autocompletion operation.

member TtcDiagnostics

TtcDiagnostics = 14

Time spent computing template type-checking diagnostics.

member TtcSuggestionDiagnostics

TtcSuggestionDiagnostics = 15

Time spent computing template type-checking suggestion diagnostics.

member TtcSymbol

TtcSymbol = 16

Time spent getting a Symbol from the TemplateTypeChecker.

member TypeScriptDiagnostics

TypeScriptDiagnostics = 5

Time spent calculating the plain TypeScript diagnostics (structural and semantic).

member TypeScriptEmit

TypeScriptEmit = 11

Time spent by TypeScript performing its emit operations, including downleveling and writing output files.

member TypeScriptProgramCreate

TypeScriptProgramCreate = 2

Time spent in ts.createProgram, including reading and parsing ts.SourceFiles in the ts.CompilerHost.
This might be an incremental program creation operation.

member Unaccounted

Unaccounted = 0

The "default" phase which tracks time not spent in any other phase.

enum PotentialImportKind

enum PotentialImportKind {
    NgModule = 0,
    Standalone = 1,
}

Which kind of Angular Trait the import targets.

member NgModule

NgModule = 0

member Standalone

Standalone = 1

enum PotentialImportMode

enum PotentialImportMode {
    Normal = 0,
    ForceDirect = 1,
}

Possible modes in which to look up a potential import.

member ForceDirect

ForceDirect = 1

An import is assumed to be standalone and is imported directly. This is useful for migrations where a declaration wasn't standalone when the program was created, but will become standalone as a part of the migration.

member Normal

Normal = 0

Whether an import is standalone is inferred based on its metadata.

enum SymbolKind

enum SymbolKind {
    Input = 0,
    Output = 1,
    Binding = 2,
    Reference = 3,
    Variable = 4,
    Directive = 5,
    Element = 6,
    Template = 7,
    Expression = 8,
    DomBinding = 9,
    Pipe = 10,
    LetDeclaration = 11,
    SelectorlessComponent = 12,
    SelectorlessDirective = 13,
}

member Binding

Binding = 2

member Directive

Directive = 5

member DomBinding

DomBinding = 9

member Element

Element = 6

member Expression

Expression = 8

member Input

Input = 0

member LetDeclaration

LetDeclaration = 11

member Output

Output = 1

member Pipe

Pipe = 10

member Reference

Reference = 3

member SelectorlessComponent

SelectorlessComponent = 12

member SelectorlessDirective

SelectorlessDirective = 13

member Template

Template = 7

member Variable

Variable = 4

Type Aliases

type AbsoluteFsPath

type AbsoluteFsPath = BrandedPath<'AbsoluteFsPath'>;

A fully qualified path in the file system, in POSIX form.

type ClassDeclaration

type ClassDeclaration<T extends DeclarationNode = DeclarationNode> = T & {
    name: ts.Identifier;
};

The ts.Declaration of a "class".
Classes are represented differently in different code formats: - In TS code, they are typically defined using the class keyword. - In ES2015 code, they are usually defined using the class keyword, but they can also be variable declarations, which are initialized to a class expression (e.g. let Foo = Foo1 = class Foo {}). - In ES5 code, they are typically defined as variable declarations being assigned the return value of an IIFE. The actual "class" is implemented as a constructor function inside the IIFE, but the outer variable declaration represents the "class" to the rest of the program.
For ReflectionHost purposes, a class declaration should always have a name identifier, because we need to be able to reference it in other parts of the program.

type CompilationTicket

type CompilationTicket =
    | FreshCompilationTicket
    | IncrementalTypeScriptCompilationTicket
    | IncrementalResourceCompilationTicket;

A request to begin Angular compilation, either starting from scratch or from a known prior state.
CompilationTickets are used to initialize (or update) an NgCompiler instance, the core of the Angular compiler. They abstract the starting state of compilation and allow NgCompiler to be managed independently of any incremental compilation lifecycle.

type Completion

type Completion =
    | ReferenceCompletion
    | VariableCompletion
    | LetDeclarationCompletion;

An autocompletion source of any kind.

type ConfigurationHost

type ConfigurationHost = Pick<
    ReadonlyFileSystem,
    | 'readFile'
    | 'exists'
    | 'lstat'
    | 'resolve'
    | 'join'
    | 'dirname'
    | 'extname'
    | 'pwd'
    | 'readdir'
>;

Used to read configuration files.

type DeclarationNode

type DeclarationNode = ts.Declaration;

A type that is used to identify a declaration.

type DirectiveSymbol

type DirectiveSymbol =
    | (DirectiveSymbolBase & {
          matchSource: MatchSource.Selector;
      })
    | (DirectiveSymbolBase & {
          matchSource: MatchSource.HostDirective;
          exposedInputs: Record<string, string> | null;
          exposedOutputs: Record<string, string> | null;
      });

A representation of a directive/component whose selector matches a node in a component template.

type FunctionEntry

type FunctionEntry = FunctionDefinitionEntry &
    DocEntry & {
        implementation: FunctionSignatureMetadata;
    };

type InputMapping

type InputMapping = InputOrOutput & {
    required: boolean;
    /**
     * Transform for the input. Null if no transform is configured.
     *
     * For signal-based inputs, this is always `null` even if a transform
     * is configured. Signal inputs capture their transform write type
     * automatically in the `InputSignal`, nor is there a need to emit a
     * reference to the transform.
     *
     * For zone-based decorator `@Input`s this is different because the transform
     * write type needs to be captured in a coercion member as the decorator information
     * is lost in the `.d.ts` for type-checking.
     */
    transform: DecoratorInputTransform | null;
};

Metadata for a single input mapping.

type InterfaceMemberEntry

type InterfaceMemberEntry = MemberEntry & InterfaceEntry;

Sub-entry for an interface (included via namespace).

type LogicalProjectPath

type LogicalProjectPath = BrandedPath<'LogicalProjectPath'>;

A path that's relative to the logical root of a TypeScript project (one of the project's rootDirs).
Paths in the type system use POSIX format.

type MethodEntry

type MethodEntry = MemberEntry & FunctionEntry;

Sub-entry for a class method.

type NgTemplateDiagnostic

type NgTemplateDiagnostic<T extends ErrorCode> = TemplateDiagnostic & {
    __ngCode: T;
};

A TemplateDiagnostic with a specific error code.

type PathSegment

type PathSegment = BrandedPath<'PathSegment'>;

A path that's relative to another (unspecified) root.
This does not necessarily have to refer to a physical file.

type PathString

type PathString = string | AbsoluteFsPath | PathSegment;

type SourceMapping

type SourceMapping =
    | DirectSourceMapping
    | IndirectSourceMapping
    | ExternalTemplateSourceMapping;

type Symbol

type Symbol =
    | InputBindingSymbol
    | OutputBindingSymbol
    | ElementSymbol
    | ReferenceSymbol
    | VariableSymbol
    | ExpressionSymbol
    | DirectiveSymbol
    | TemplateSymbol
    | DomBindingSymbol
    | PipeSymbol
    | LetDeclarationSymbol
    | SelectorlessComponentSymbol
    | SelectorlessDirectiveSymbol;

A representation of an entity in the TemplateAst.

type TemplateDeclarationSymbol

type TemplateDeclarationSymbol = ReferenceSymbol | VariableSymbol;

A Symbol which declares a new named entity in the template scope.

type TypeAliasMemberEntry

type TypeAliasMemberEntry = MemberEntry & TypeAliasEntry;

Sub-entry for a type alias (included via namespace).

Package Files (54)

Dependencies (8)

Dev Dependencies (2)

Peer Dependencies (2)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@angular/compiler-cli.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@angular/compiler-cli)

HTML

<a href="https://www.jsdocs.io/package/@angular/compiler-cli"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 3 days ago.
Package analyzed in 13086 ms.
Missing or incorrect documentation? Open an issue for this package.

@angular/compiler-cli

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable DEFAULT_ERROR_CODE

variable GLOBAL_DEFS_FOR_TERSER

variable GLOBAL_DEFS_FOR_TERSER_WITH_AOT

variable LogicalProjectPath

variable SOURCE

variable UNKNOWN_ERROR_CODE

variable VERSION

Functions

function absoluteFrom

function absoluteFromSourceFile

function angularJitApplicationTransform

function basename

function calcProjectFileAndBasePath

function constructorParametersDownlevelTransform

function createCompilerHost

function createFileSystemTsReadDirectoryFn

function createProgram

function defaultGatherDiagnostics

function dirname

function exitCodeFromResult

function findFirstMatchingNode

function formatDiagnostics

function freshCompilationTicket

function getAngularDecorators

function getDownlevelDecoratorsTransform

Parameter typeChecker

Parameter host

Parameter diagnostics

Parameter isCore

Parameter isClosureCompilerEnabled

Parameter shouldTransformClass

function getFileSystem

function getInitializerApiJitTransform

Parameter host

Parameter importTracker

Parameter isCore

Parameter shouldTransformClass

function getRootDirs

function getSourceFileOrError

function hasExpressionIdentifier

function incrementalFromCompilerTicket

function isDocEntryWithSourceInfo

function isExternalResource

function isFatalDiagnosticError

function isLocalCompilationDiagnostics

function isLocalRelativePath

function isNamedClassDeclaration

function isRoot

function isRooted

function isShim

function isTsDiagnostic

function join

function ngErrorCode

function performCompilation

function readConfiguration

function relative

function relativeFrom

function resolve

function resourceChangeTicket

function setFileSystem

function toRelativeImport

Classes

class ConsoleLogger

constructor

property level

method debug

method error

method info

method warn