@angular/compiler-cli

  • Version 12.0.3
  • Published
  • 8.78 MB
  • 14 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 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 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 exitCodeFromResult

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

                        function filterErrorsAndWarnings

                        filterErrorsAndWarnings: (diagnostics: Diagnostics) => Diagnostics;

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

                                                                              isTsDiagnostic: (diagnostic: any) => diagnostic is any;

                                                                                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;

                                                                                    Classes

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

                                                                                                                                        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 i18nOutFile

                                                                                                                                                            i18nOutFile?: string;

                                                                                                                                                              property i18nOutFormat

                                                                                                                                                              i18nOutFormat?: string;

                                                                                                                                                                property i18nOutLocale

                                                                                                                                                                i18nOutLocale?: string;

                                                                                                                                                                  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 i18nOutFile

                                                                                                                                                                                                            i18nOutFile?: string;

                                                                                                                                                                                                              property i18nOutFormat

                                                                                                                                                                                                              i18nOutFormat?: string;

                                                                                                                                                                                                                property i18nOutLocale

                                                                                                                                                                                                                i18nOutLocale?: string;

                                                                                                                                                                                                                  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 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 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 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[];
                                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the lazy routes in the program.

                                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter entryRoute

                                                                                                                                                                                                                                                                                                                                                                                                                                  A reference to an NgModule like someModule#name. If given, will recursively analyze routes starting from this symbol only. Otherwise will list all routes for all NgModules in the program/

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Package Files (13)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dependencies (14)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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>