@angular/compiler-cli

  • Version 13.0.2
  • Published
  • 8.1 MB
  • 11 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

Functions

Classes

Interfaces

Enums

Type Aliases

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 METADATA_VERSION

        const METADATA_VERSION: number;
        • Copyright Google LLC All Rights Reserved.

          Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license

        variable SOURCE

        const SOURCE: string;

          variable UNKNOWN_ERROR_CODE

          const UNKNOWN_ERROR_CODE: number;

            variable VERSION

            const VERSION: any;

              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 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: any) => any;
                • 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.

                function createBundleIndexHost

                createBundleIndexHost: <H extends any>(
                ngOptions: CompilerOptions,
                rootFiles: ReadonlyArray<string>,
                host: H,
                getMetadataCache: () => MetadataCache
                ) => { host: H; indexName?: string; errors?: ts.Diagnostic[] };

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

                        function dirname

                        dirname: <T extends PathString>(file: T) => T;
                        • Static access to dirname.

                        function exitCodeFromResult

                        exitCodeFromResult: (diags: Diagnostics | undefined) => number;

                          function flattenDiagnosticMessageChain

                          flattenDiagnosticMessageChain: (
                          chain: api.DiagnosticMessageChain,
                          host?: any,
                          indent?: number
                          ) => string;

                            function formatDiagnostic

                            formatDiagnostic: (diagnostic: api.Diagnostic, host?: any) => string;

                              function formatDiagnosticPosition

                              formatDiagnosticPosition: (position: any, host?: any) => string;

                                function formatDiagnostics

                                formatDiagnostics: (diags: Diagnostics, host?: any) => string;

                                  function getFileSystem

                                  getFileSystem: () => FileSystem;

                                    function getSourceFileOrError

                                    getSourceFileOrError: (program: any, fileName: AbsoluteFsPath) => any;

                                      function isClassMetadata

                                      isClassMetadata: (value: any) => value is ClassMetadata;

                                        function isConstructorMetadata

                                        isConstructorMetadata: (value: any) => value is ConstructorMetadata;

                                          function isFunctionMetadata

                                          isFunctionMetadata: (value: any) => value is FunctionMetadata;

                                            function isInterfaceMetadata

                                            isInterfaceMetadata: (value: any) => value is InterfaceMetadata;

                                              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 isMemberMetadata

                                              isMemberMetadata: (value: any) => value is MemberMetadata;

                                                function isMetadataError

                                                isMetadataError: (value: any) => value is MetadataError;

                                                  function isMetadataGlobalReferenceExpression

                                                  isMetadataGlobalReferenceExpression: (
                                                  value: any
                                                  ) => value is MetadataGlobalReferenceExpression;

                                                    function isMetadataImportDefaultReference

                                                    isMetadataImportDefaultReference: (
                                                    value: any
                                                    ) => value is MetadataImportedDefaultReferenceExpression;

                                                      function isMetadataImportedSymbolReferenceExpression

                                                      isMetadataImportedSymbolReferenceExpression: (
                                                      value: any
                                                      ) => value is MetadataImportedSymbolReferenceExpression;

                                                        function isMetadataModuleReferenceExpression

                                                        isMetadataModuleReferenceExpression: (
                                                        value: any
                                                        ) => value is MetadataModuleReferenceExpression;

                                                          function isMetadataSymbolicBinaryExpression

                                                          isMetadataSymbolicBinaryExpression: (
                                                          value: any
                                                          ) => value is MetadataSymbolicBinaryExpression;

                                                            function isMetadataSymbolicCallExpression

                                                            isMetadataSymbolicCallExpression: (
                                                            value: any
                                                            ) => value is MetadataSymbolicCallExpression;

                                                              function isMetadataSymbolicExpression

                                                              isMetadataSymbolicExpression: (
                                                              value: any
                                                              ) => value is MetadataSymbolicExpression;

                                                                function isMetadataSymbolicIfExpression

                                                                isMetadataSymbolicIfExpression: (
                                                                value: any
                                                                ) => value is MetadataSymbolicIfExpression;

                                                                  function isMetadataSymbolicIndexExpression

                                                                  isMetadataSymbolicIndexExpression: (
                                                                  value: any
                                                                  ) => value is MetadataSymbolicIndexExpression;

                                                                    function isMetadataSymbolicPrefixExpression

                                                                    isMetadataSymbolicPrefixExpression: (
                                                                    value: any
                                                                    ) => value is MetadataSymbolicPrefixExpression;

                                                                      function isMetadataSymbolicReferenceExpression

                                                                      isMetadataSymbolicReferenceExpression: (
                                                                      value: any
                                                                      ) => value is MetadataSymbolicReferenceExpression;

                                                                        function isMetadataSymbolicSelectExpression

                                                                        isMetadataSymbolicSelectExpression: (
                                                                        value: any
                                                                        ) => value is MetadataSymbolicSelectExpression;

                                                                          function isMetadataSymbolicSpreadExpression

                                                                          isMetadataSymbolicSpreadExpression: (
                                                                          value: any
                                                                          ) => value is MetadataSymbolicSpreadExpression;

                                                                            function isMethodMetadata

                                                                            isMethodMetadata: (value: any) => value is MethodMetadata;

                                                                              function isModuleMetadata

                                                                              isModuleMetadata: (value: any) => value is ModuleMetadata;

                                                                                function isNgDiagnostic

                                                                                isNgDiagnostic: (diagnostic: any) => diagnostic is Diagnostic;

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

                                                                                    function join

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

                                                                                    function ngToTsDiagnostic

                                                                                    ngToTsDiagnostic: (ng: Diagnostic) => any;
                                                                                    • Converts a ng.Diagnostic into a ts.Diagnostic. This looses some information, and also uses an incomplete object as file.

                                                                                      I.e. only use this where the API allows only a ts.Diagnostic.

                                                                                    function performCompilation

                                                                                    performCompilation: ({
                                                                                    rootNames,
                                                                                    options,
                                                                                    host,
                                                                                    oldProgram,
                                                                                    emitCallback,
                                                                                    mergeEmitResultsCallback,
                                                                                    gatherDiagnostics,
                                                                                    customTransformers,
                                                                                    emitFlags,
                                                                                    modifiedResourceFiles,
                                                                                    }: {
                                                                                    rootNames: string[];
                                                                                    options: api.CompilerOptions;
                                                                                    host?: api.CompilerHost;
                                                                                    oldProgram?: api.Program;
                                                                                    emitCallback?: api.TsEmitCallback;
                                                                                    mergeEmitResultsCallback?: api.TsMergeEmitResultsCallback;
                                                                                    gatherDiagnostics?: (program: api.Program) => Diagnostics;
                                                                                    customTransformers?: api.CustomTransformers;
                                                                                    emitFlags?: api.EmitFlags;
                                                                                    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 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<any, '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: any) => 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 MetadataCollector

                                                                                                        class MetadataCollector {}
                                                                                                        • Collect decorator metadata from a TypeScript module.

                                                                                                        constructor

                                                                                                        constructor(options?: CollectorOptions);

                                                                                                          method getMetadata

                                                                                                          getMetadata: (
                                                                                                          sourceFile: any,
                                                                                                          strict?: boolean,
                                                                                                          substituteExpression?: (value: MetadataValue, node: any) => MetadataValue
                                                                                                          ) => ModuleMetadata | undefined;
                                                                                                          • Returns a JSON.stringify friendly form describing the decorators of the exported classes from the source file that is expected to correspond to a module.

                                                                                                          class NgtscCompilerHost

                                                                                                          class NgtscCompilerHost implements ts.CompilerHost {}

                                                                                                            constructor

                                                                                                            constructor(fs: FileSystem, options?: any);

                                                                                                              property fs

                                                                                                              protected fs: FileSystem;

                                                                                                                property options

                                                                                                                protected options: any;

                                                                                                                  method fileExists

                                                                                                                  fileExists: (fileName: string) => boolean;

                                                                                                                    method getCanonicalFileName

                                                                                                                    getCanonicalFileName: (fileName: string) => string;

                                                                                                                      method getCurrentDirectory

                                                                                                                      getCurrentDirectory: () => string;

                                                                                                                        method getDefaultLibFileName

                                                                                                                        getDefaultLibFileName: (options: any) => string;

                                                                                                                          method getDefaultLibLocation

                                                                                                                          getDefaultLibLocation: () => string;

                                                                                                                            method getNewLine

                                                                                                                            getNewLine: () => string;

                                                                                                                              method getSourceFile

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

                                                                                                                                method readFile

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

                                                                                                                                  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: () => any;

                                                                                                                                              method getDiagnostics

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

                                                                                                                                                method getNextProgram

                                                                                                                                                getNextProgram: () => any;

                                                                                                                                                  method getOptionDiagnostics

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

                                                                                                                                                    method setupCompilation

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

                                                                                                                                                      method wrapHost

                                                                                                                                                      wrapHost: (
                                                                                                                                                      host: ts.CompilerHost & Partial<UnifiedModulesHost>,
                                                                                                                                                      inputFiles: readonly string[],
                                                                                                                                                      options: any
                                                                                                                                                      ) => 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: (
                                                                                                                                                            opts?:
                                                                                                                                                            | {
                                                                                                                                                            emitFlags?: api.EmitFlags | undefined;
                                                                                                                                                            cancellationToken?: ts.CancellationToken | undefined;
                                                                                                                                                            customTransformers?: api.CustomTransformers | undefined;
                                                                                                                                                            emitCallback?: api.TsEmitCallback | undefined;
                                                                                                                                                            mergeEmitResultsCallback?:
                                                                                                                                                            | api.TsMergeEmitResultsCallback
                                                                                                                                                            | undefined;
                                                                                                                                                            }
                                                                                                                                                            | undefined
                                                                                                                                                            ) => any;

                                                                                                                                                              method getEmittedGeneratedFiles

                                                                                                                                                              getEmittedGeneratedFiles: () => Map<string, GeneratedFile>;

                                                                                                                                                                method getEmittedSourceFiles

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

                                                                                                                                                                  method getIndexedComponents

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

                                                                                                                                                                    method getLibrarySummaries

                                                                                                                                                                    getLibrarySummaries: () => Map<string, api.LibrarySummary>;

                                                                                                                                                                      method getNgOptionDiagnostics

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

                                                                                                                                                                        method getNgSemanticDiagnostics

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

                                                                                                                                                                          method getNgStructuralDiagnostics

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

                                                                                                                                                                            method getReuseTsProgram

                                                                                                                                                                            getReuseTsProgram: () => any;

                                                                                                                                                                              method getTsOptionDiagnostics

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

                                                                                                                                                                                method getTsProgram

                                                                                                                                                                                getTsProgram: () => any;

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

                                                                                                                                                                                                              enableSummariesForJit?: boolean;
                                                                                                                                                                                                              • Whether to generate .ngsummary.ts files that allow to use AOTed artifacts in JIT mode. This is off by default.

                                                                                                                                                                                                              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 ClassMetadata

                                                                                                                                                                                                                                  interface ClassMetadata {}

                                                                                                                                                                                                                                    property arity

                                                                                                                                                                                                                                    arity?: number;

                                                                                                                                                                                                                                      property decorators

                                                                                                                                                                                                                                      decorators?: (MetadataSymbolicExpression | MetadataError)[];

                                                                                                                                                                                                                                        property extends

                                                                                                                                                                                                                                        extends?: MetadataSymbolicExpression | MetadataError;

                                                                                                                                                                                                                                          property members

                                                                                                                                                                                                                                          members?: MetadataMap;

                                                                                                                                                                                                                                            property statics

                                                                                                                                                                                                                                            statics?: {
                                                                                                                                                                                                                                            [name: string]: MetadataValue | FunctionMetadata;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              interface CollectorOptions

                                                                                                                                                                                                                                              interface CollectorOptions {}
                                                                                                                                                                                                                                              • A set of collector options to use when collecting metadata.

                                                                                                                                                                                                                                              property quotedNames

                                                                                                                                                                                                                                              quotedNames?: boolean;
                                                                                                                                                                                                                                              • Collect a hidden field "$quoted$" in objects literals that record when the key was quoted in the source.

                                                                                                                                                                                                                                              property substituteExpression

                                                                                                                                                                                                                                              substituteExpression?: (value: MetadataValue, node: ts.Node) => MetadataValue;
                                                                                                                                                                                                                                              • An expression substitution callback.

                                                                                                                                                                                                                                              property verboseInvalidExpression

                                                                                                                                                                                                                                              verboseInvalidExpression?: boolean;
                                                                                                                                                                                                                                              • Do not simplify invalid expressions.

                                                                                                                                                                                                                                              property version

                                                                                                                                                                                                                                              version?: number;
                                                                                                                                                                                                                                              • Version of the metadata to collect.

                                                                                                                                                                                                                                              interface CompilerHost

                                                                                                                                                                                                                                              interface CompilerHost extends ts.CompilerHost, ExtendedTsCompilerHost {}

                                                                                                                                                                                                                                                method amdModuleName

                                                                                                                                                                                                                                                amdModuleName: (sf: any) => 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 referrig 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 soure 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 enableSummariesForJit

                                                                                                                                                                                                                                                        enableSummariesForJit?: boolean;
                                                                                                                                                                                                                                                        • Whether to generate .ngsummary.ts files that allow to use AOTed artifacts in JIT mode. This is off by default.

                                                                                                                                                                                                                                                        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 ConstructorMetadata

                                                                                                                                                                                                                                                                            interface ConstructorMetadata extends MethodMetadata {}

                                                                                                                                                                                                                                                                              property parameters

                                                                                                                                                                                                                                                                              parameters?: (MetadataSymbolicExpression | MetadataError | null | undefined)[];

                                                                                                                                                                                                                                                                                interface CustomTransformers

                                                                                                                                                                                                                                                                                interface CustomTransformers {}

                                                                                                                                                                                                                                                                                  property afterTs

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

                                                                                                                                                                                                                                                                                    property beforeTs

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

                                                                                                                                                                                                                                                                                      interface Diagnostic

                                                                                                                                                                                                                                                                                      interface Diagnostic {}

                                                                                                                                                                                                                                                                                        property category

                                                                                                                                                                                                                                                                                        category: ts.DiagnosticCategory;

                                                                                                                                                                                                                                                                                          property chain

                                                                                                                                                                                                                                                                                          chain?: DiagnosticMessageChain;

                                                                                                                                                                                                                                                                                            property code

                                                                                                                                                                                                                                                                                            code: number;

                                                                                                                                                                                                                                                                                              property messageText

                                                                                                                                                                                                                                                                                              messageText: string;

                                                                                                                                                                                                                                                                                                property position

                                                                                                                                                                                                                                                                                                position?: Position;

                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                  source: 'angular';

                                                                                                                                                                                                                                                                                                    property span

                                                                                                                                                                                                                                                                                                    span?: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                      interface DiagnosticMessageChain

                                                                                                                                                                                                                                                                                                      interface DiagnosticMessageChain {}

                                                                                                                                                                                                                                                                                                        property messageText

                                                                                                                                                                                                                                                                                                        messageText: string;

                                                                                                                                                                                                                                                                                                          property next

                                                                                                                                                                                                                                                                                                          next?: DiagnosticMessageChain[];

                                                                                                                                                                                                                                                                                                            property position

                                                                                                                                                                                                                                                                                                            position?: Position;

                                                                                                                                                                                                                                                                                                              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;
                                                                                                                                                                                                                                                                                                                  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;
                                                                                                                                                                                                                                                                                                                              symlink: (target: AbsoluteFsPath, path: AbsoluteFsPath) => void;

                                                                                                                                                                                                                                                                                                                                method writeFile

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

                                                                                                                                                                                                                                                                                                                                  interface FunctionMetadata

                                                                                                                                                                                                                                                                                                                                  interface FunctionMetadata {}

                                                                                                                                                                                                                                                                                                                                    property defaults

                                                                                                                                                                                                                                                                                                                                    defaults?: MetadataValue[];

                                                                                                                                                                                                                                                                                                                                      property parameters

                                                                                                                                                                                                                                                                                                                                      parameters: string[];

                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                        value: MetadataValue;

                                                                                                                                                                                                                                                                                                                                          interface InterfaceMetadata

                                                                                                                                                                                                                                                                                                                                          interface InterfaceMetadata {}

                                                                                                                                                                                                                                                                                                                                            interface LazyRoute

                                                                                                                                                                                                                                                                                                                                            interface LazyRoute {}

                                                                                                                                                                                                                                                                                                                                              property module

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

                                                                                                                                                                                                                                                                                                                                                property referencedModule

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

                                                                                                                                                                                                                                                                                                                                                  property route

                                                                                                                                                                                                                                                                                                                                                  route: string;

                                                                                                                                                                                                                                                                                                                                                    interface LibrarySummary

                                                                                                                                                                                                                                                                                                                                                    interface LibrarySummary {}

                                                                                                                                                                                                                                                                                                                                                      property fileName

                                                                                                                                                                                                                                                                                                                                                      fileName: string;

                                                                                                                                                                                                                                                                                                                                                        property sourceFile

                                                                                                                                                                                                                                                                                                                                                        sourceFile?: ts.SourceFile;

                                                                                                                                                                                                                                                                                                                                                          property text

                                                                                                                                                                                                                                                                                                                                                          text: 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 MemberMetadata

                                                                                                                                                                                                                                                                                                                                                                      interface MemberMetadata {}

                                                                                                                                                                                                                                                                                                                                                                        property decorators

                                                                                                                                                                                                                                                                                                                                                                        decorators?: (MetadataSymbolicExpression | MetadataError)[];

                                                                                                                                                                                                                                                                                                                                                                          property parameters

                                                                                                                                                                                                                                                                                                                                                                          parameters?: (MetadataSymbolicExpression | MetadataError | null | undefined)[];

                                                                                                                                                                                                                                                                                                                                                                            interface MetadataArray

                                                                                                                                                                                                                                                                                                                                                                            interface MetadataArray {}

                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                              [name: number]: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                interface MetadataError

                                                                                                                                                                                                                                                                                                                                                                                interface MetadataError extends MetadataSourceLocationInfo {}

                                                                                                                                                                                                                                                                                                                                                                                  property context

                                                                                                                                                                                                                                                                                                                                                                                  context?: {
                                                                                                                                                                                                                                                                                                                                                                                  [name: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                  • Context information that can be used to generate a more descriptive error message. The content of the context is dependent on the error message.

                                                                                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                                                                                  message: string;
                                                                                                                                                                                                                                                                                                                                                                                  • This message should be short and relatively discriptive and should be fixed once it is created. If the reader doesn't recognize the message, it will display the message unmodified. If the reader recognizes the error message is it free to use substitute message the is more descriptive and/or localized.

                                                                                                                                                                                                                                                                                                                                                                                  property module

                                                                                                                                                                                                                                                                                                                                                                                  module?: string;
                                                                                                                                                                                                                                                                                                                                                                                  • The module of the error (only used in bundled metadata)

                                                                                                                                                                                                                                                                                                                                                                                  interface MetadataGlobalReferenceExpression

                                                                                                                                                                                                                                                                                                                                                                                  interface MetadataGlobalReferenceExpression extends MetadataSourceLocationInfo {}

                                                                                                                                                                                                                                                                                                                                                                                    property arguments

                                                                                                                                                                                                                                                                                                                                                                                    arguments?: MetadataValue[];

                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                                                                                        interface MetadataImportedDefaultReferenceExpression

                                                                                                                                                                                                                                                                                                                                                                                        interface MetadataImportedDefaultReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                        extends MetadataSourceLocationInfo {}

                                                                                                                                                                                                                                                                                                                                                                                          property arguments

                                                                                                                                                                                                                                                                                                                                                                                          arguments?: MetadataValue[];

                                                                                                                                                                                                                                                                                                                                                                                            property default

                                                                                                                                                                                                                                                                                                                                                                                            default: boolean;

                                                                                                                                                                                                                                                                                                                                                                                              property module

                                                                                                                                                                                                                                                                                                                                                                                              module: string;

                                                                                                                                                                                                                                                                                                                                                                                                interface MetadataImportedSymbolReferenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                interface MetadataImportedSymbolReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                extends MetadataSourceLocationInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                  property arguments

                                                                                                                                                                                                                                                                                                                                                                                                  arguments?: MetadataValue[];

                                                                                                                                                                                                                                                                                                                                                                                                    property module

                                                                                                                                                                                                                                                                                                                                                                                                    module: string;

                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                                                                                                        interface MetadataMap

                                                                                                                                                                                                                                                                                                                                                                                                        interface MetadataMap {}

                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                          [name: string]: MemberMetadata[];

                                                                                                                                                                                                                                                                                                                                                                                                            interface MetadataModuleReferenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                            interface MetadataModuleReferenceExpression extends MetadataSourceLocationInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                              property module

                                                                                                                                                                                                                                                                                                                                                                                                              module: string;

                                                                                                                                                                                                                                                                                                                                                                                                                interface MetadataObject

                                                                                                                                                                                                                                                                                                                                                                                                                interface MetadataObject {}

                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                  [name: string]: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                    interface MetadataSourceLocationInfo

                                                                                                                                                                                                                                                                                                                                                                                                                    interface MetadataSourceLocationInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                      property character

                                                                                                                                                                                                                                                                                                                                                                                                                      character?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The number of utf8 code-units from the beginning of the file of the error.

                                                                                                                                                                                                                                                                                                                                                                                                                      property line

                                                                                                                                                                                                                                                                                                                                                                                                                      line?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The line number of the error in the .ts file the metadata was created for.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface MetadataSymbolicBinaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                      interface MetadataSymbolicBinaryExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property left

                                                                                                                                                                                                                                                                                                                                                                                                                        left: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                          property operator

                                                                                                                                                                                                                                                                                                                                                                                                                          operator:
                                                                                                                                                                                                                                                                                                                                                                                                                          | '&&'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '||'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '|'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '^'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '&'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '=='
                                                                                                                                                                                                                                                                                                                                                                                                                          | '!='
                                                                                                                                                                                                                                                                                                                                                                                                                          | '==='
                                                                                                                                                                                                                                                                                                                                                                                                                          | '!=='
                                                                                                                                                                                                                                                                                                                                                                                                                          | '<'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '>'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '<='
                                                                                                                                                                                                                                                                                                                                                                                                                          | '>='
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'instanceof'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'in'
                                                                                                                                                                                                                                                                                                                                                                                                                          | 'as'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '<<'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '>>'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '>>>'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '+'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '-'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '*'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '/'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '%'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '**'
                                                                                                                                                                                                                                                                                                                                                                                                                          | '??';

                                                                                                                                                                                                                                                                                                                                                                                                                            property right

                                                                                                                                                                                                                                                                                                                                                                                                                            right: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                              interface MetadataSymbolicCallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                              interface MetadataSymbolicCallExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property arguments

                                                                                                                                                                                                                                                                                                                                                                                                                                arguments?: MetadataValue[];

                                                                                                                                                                                                                                                                                                                                                                                                                                  property expression

                                                                                                                                                                                                                                                                                                                                                                                                                                  expression: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MetadataSymbolicIfExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MetadataSymbolicIfExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      property condition

                                                                                                                                                                                                                                                                                                                                                                                                                                      condition: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property elseExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                        elseExpression: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property thenExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                          thenExpression: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MetadataSymbolicIndexExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MetadataSymbolicIndexExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              property expression

                                                                                                                                                                                                                                                                                                                                                                                                                                              expression: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property index

                                                                                                                                                                                                                                                                                                                                                                                                                                                index: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MetadataSymbolicPrefixExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MetadataSymbolicPrefixExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property operand

                                                                                                                                                                                                                                                                                                                                                                                                                                                    operand: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property operator

                                                                                                                                                                                                                                                                                                                                                                                                                                                      operator: '+' | '-' | '~' | '!';

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MetadataSymbolicSelectExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface MetadataSymbolicSelectExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                          expression: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property member

                                                                                                                                                                                                                                                                                                                                                                                                                                                            member: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MetadataSymbolicSpreadExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MetadataSymbolicSpreadExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                expression: MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MethodMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MethodMetadata extends MemberMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property parameterDecorators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parameterDecorators?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | (MetadataSymbolicExpression | MetadataError)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModuleExportMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ModuleExportMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property export

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        export?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        as: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          from: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ModuleMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ModuleMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property exports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              exports?: ModuleExportMetadata[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property importAs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                importAs?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  metadata: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [name: string]: MetadataEntry;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property origins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    origins?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [name: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      version: number;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property emitResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              emitResult?: ts.EmitResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                program?: api.Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Program {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method emit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    emit: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    emitFlags,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cancellationToken,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    customTransformers,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    emitCallback,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mergeEmitResultsCallback,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    emitFlags?: EmitFlags;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cancellationToken?: ts.CancellationToken;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    customTransformers?: CustomTransformers;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    emitCallback?: TsEmitCallback;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mergeEmitResultsCallback?: TsMergeEmitResultsCallback;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Emit the files requested by emitFlags implied by the program.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Angular structural information is required to emit files.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getLibrarySummaries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getLibrarySummaries: () => Map<string, LibrarySummary>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns the .d.ts / .ngsummary.json / .ngfactory.d.ts files of libraries that have been emitted in this program or previous programs with paths that emulate the fact that these libraries have been compiled before with no outDir.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getNgOptionDiagnostics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getNgOptionDiagnostics: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cancellationToken?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ReadonlyArray<ts.Diagnostic | Diagnostic>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Retrieve options diagnostics for the Angular options used to create the program.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getNgSemanticDiagnostics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getNgSemanticDiagnostics: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fileName?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cancellationToken?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ReadonlyArray<ts.Diagnostic | Diagnostic>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Retrieve the Angular semantic diagnostics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Angular structural information is required to produce these diagnostics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getNgStructuralDiagnostics

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getNgStructuralDiagnostics: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cancellationToken?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ReadonlyArray<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?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => 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: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 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?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cancellationToken?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => 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?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cancellationToken?: any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => 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 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 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 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (args: TsEmitArguments): ts.EmitResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TsMergeEmitResultsCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TsMergeEmitResultsCallback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (results: ts.EmitResult[]): ts.EmitResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Enums

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Diagnostics = ReadonlyArray<ts.Diagnostic | api.Diagnostic>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 MetadataEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MetadataEntry =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ClassMetadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | InterfaceMetadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | FunctionMetadata
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | MetadataValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MetadataSymbolicExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MetadataSymbolicExpression =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataSymbolicBinaryExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataSymbolicIndexExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataSymbolicIndexExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataSymbolicCallExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataSymbolicCallExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataSymbolicPrefixExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataSymbolicIfExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataGlobalReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataModuleReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataImportedSymbolReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataImportedDefaultReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataSymbolicSelectExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MetadataSymbolicSpreadExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MetadataSymbolicReferenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MetadataSymbolicReferenceExpression =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | MetadataGlobalReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | MetadataModuleReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | MetadataImportedSymbolReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | MetadataImportedDefaultReferenceExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MetadataValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MetadataValue =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataObject
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataArray
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataSymbolicExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataSymbolicReferenceExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataSymbolicBinaryExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataSymbolicIndexExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataSymbolicCallExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataSymbolicPrefixExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataSymbolicIfExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataSymbolicSpreadExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataSymbolicSelectExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | MetadataError;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package Files (22)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dependencies (11)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Peer Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto 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>