@angular/compiler-cli

@angular/compiler-cli

Version 18.2.12
Published 2 days ago
2.56 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: {
    ngJitMode: boolean;
    ngDevMode: boolean;
    ngI18nClosureMode: 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 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 formatDiagnostics

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

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 getSourceFileOrError

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

function isDocEntryWithSourceInfo

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

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 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 isTsDiagnostic

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

function join

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

Static access to join.

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
) => 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 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 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 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>;

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;

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 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 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[];

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 DocEntry

interface DocEntry {}

Base type for all documentation entities.

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 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;

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 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 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 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 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 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 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 isStandalone

isStandalone: boolean;

property pipeName

pipeName: string;

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 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 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 SourceEntry

interface SourceEntry {}

property endLine

endLine: number;

property filePath

filePath: string;

property startLine

startLine: number;

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 TypeAliasEntry

interface TypeAliasEntry extends ConstantEntry {}

Documentation entity for a type alias.

property generics

generics: GenericEntry[];

Enums

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',
}

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 NgModule

NgModule = 'ng_module'

member Pipe

Pipe = 'pipe'

member TypeAlias

TypeAlias = 'type_alias'

member UndecoratedClass

UndecoratedClass = 'undecorated_class'

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',
}

Types of class members

member EnumItem

EnumItem = 'enum_item'

member Getter

Getter = 'getter'

member Method

Method = 'method'

member Property

Property = 'property'

member Setter

Setter = 'setter'

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.

Type Aliases

type AbsoluteFsPath

type AbsoluteFsPath = BrandedPath<'AbsoluteFsPath'>;

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

type ConfigurationHost

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

Used to read configuration files.

type FunctionEntry

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

type InterfaceEntry

type InterfaceEntry = ClassEntry;

Documentation entity for a TypeScript interface.

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 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;

Namespaces

namespace @babel/core

module '@babel/core' {}

namespace @babel/generator

module '@babel/generator' {}

Package Files (25)

Dependencies (8)

Dev Dependencies (0)

No dev dependencies.

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 2 days ago.
Package analyzed in 9585 ms.
Missing or incorrect documentation? Open an issue for this package.

@angular/compiler-cli

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

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 createProgram

function defaultGatherDiagnostics

function dirname

function exitCodeFromResult

function formatDiagnostics

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 getSourceFileOrError

function isDocEntryWithSourceInfo

function isLocalCompilationDiagnostics

function isLocalRelativePath

function isRoot

function isRooted

function isTsDiagnostic

function join

function performCompilation

function readConfiguration

function relative

function relativeFrom

function resolve

function setFileSystem

function toRelativeImport

Classes

class ConsoleLogger

constructor

property level

method debug

method error

method info

method warn

class DocsExtractor

constructor

method extractAll

Parameter sourceFile

class LogicalFileSystem

constructor

method logicalPathOfFile

Returns

method logicalPathOfSf

class NgtscCompilerHost

constructor

property fs