@angular/compiler

@angular/compiler

Version 22.0.2
Published 3 days ago
5 MB
1 dependency
MIT license

Install

npm i @angular/compiler

yarn add @angular/compiler

pnpm add @angular/compiler

Overview

Angular - the compiler library

Index

Variables

variable BOOL_TYPE

const BOOL_TYPE: BuiltinType;

variable core_d_AttributeMarker

const core_d_AttributeMarker: typeof AttributeMarker;

variable core_d_CUSTOM_ELEMENTS_SCHEMA

const core_d_CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata;

variable core_d_emitDistinctChangesOnlyDefaultValue

const core_d_emitDistinctChangesOnlyDefaultValue: boolean;

variable core_d_InjectFlags

const core_d_InjectFlags: typeof InjectFlags;

variable core_d_InputFlags

const core_d_InputFlags: typeof InputFlags;

variable core_d_MissingTranslationStrategy

const core_d_MissingTranslationStrategy: typeof MissingTranslationStrategy;

variable core_d_NO_ERRORS_SCHEMA

const core_d_NO_ERRORS_SCHEMA: SchemaMetadata;

variable core_d_parseSelectorToR3Selector

const core_d_parseSelectorToR3Selector: (selector: string) => R3CssSelectorList;

variable core_d_RenderFlags

const core_d_RenderFlags: typeof RenderFlags;

variable core_d_SecurityContext

const core_d_SecurityContext: typeof SecurityContext;

variable core_d_SelectorFlags

const core_d_SelectorFlags: typeof SelectorFlags;

variable CUSTOM_ELEMENTS_SCHEMA

const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata;

variable DYNAMIC_TYPE

const DYNAMIC_TYPE: BuiltinType;

variable emitDistinctChangesOnlyDefaultValue

const emitDistinctChangesOnlyDefaultValue: boolean;

variable EOF

const EOF: Token;

variable FUNCTION_TYPE

const FUNCTION_TYPE: BuiltinType;

variable HOST_BINDING_GUARD_COMMENT_TEXT

const HOST_BINDING_GUARD_COMMENT_TEXT: string;

Comment attached to an AST node that serves as a guard to distinguish nodes used for type checking host bindings from ones used for templates.

variable INFERRED_TYPE

const INFERRED_TYPE: BuiltinType;

variable INT_TYPE

const INT_TYPE: BuiltinType;

variable LEGACY_OPTIONAL_CHAINING_DEFAULT

const LEGACY_OPTIONAL_CHAINING_DEFAULT: boolean;

Whether legacy optional chaining is opt-in (false) or opt-out (true).
This is extracted in order to be patched in G3.

variable NO_ERRORS_SCHEMA

const NO_ERRORS_SCHEMA: SchemaMetadata;

variable NONE_TYPE

const NONE_TYPE: BuiltinType;

variable NULL_EXPR

const NULL_EXPR: LiteralExpr;

variable NUMBER_TYPE

const NUMBER_TYPE: BuiltinType;

variable output_ast_d_areAllEquivalent

const output_ast_d_areAllEquivalent: <T extends { isEquivalent(other: T): boolean }>(
    base: T[],
    other: T[]
) => boolean;

variable output_ast_d_ArrayType

const output_ast_d_ArrayType: typeof ArrayType;

variable output_ast_d_arrowFn

const output_ast_d_arrowFn: (
    params: FnParam[],
    body: Expression | Statement[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => ArrowFunctionExpr;

variable output_ast_d_ArrowFunctionExpr

const output_ast_d_ArrowFunctionExpr: typeof ArrowFunctionExpr;

variable output_ast_d_BinaryOperator

const output_ast_d_BinaryOperator: typeof BinaryOperator;

variable output_ast_d_BinaryOperatorExpr

const output_ast_d_BinaryOperatorExpr: typeof BinaryOperatorExpr;

variable output_ast_d_BOOL_TYPE

const output_ast_d_BOOL_TYPE: BuiltinType;

variable output_ast_d_BuiltinType

const output_ast_d_BuiltinType: typeof BuiltinType;

variable output_ast_d_BuiltinTypeName

const output_ast_d_BuiltinTypeName: typeof BuiltinTypeName;

variable output_ast_d_CommaExpr

const output_ast_d_CommaExpr: typeof CommaExpr;

variable output_ast_d_ConditionalExpr

const output_ast_d_ConditionalExpr: typeof ConditionalExpr;

variable output_ast_d_DeclareFunctionStmt

const output_ast_d_DeclareFunctionStmt: typeof DeclareFunctionStmt;

variable output_ast_d_DeclareVarStmt

const output_ast_d_DeclareVarStmt: typeof DeclareVarStmt;

variable output_ast_d_DYNAMIC_TYPE

const output_ast_d_DYNAMIC_TYPE: BuiltinType;

variable output_ast_d_DynamicImportExpr

const output_ast_d_DynamicImportExpr: typeof DynamicImportExpr;

variable output_ast_d_Expression

const output_ast_d_Expression: typeof Expression;

variable output_ast_d_ExpressionStatement

const output_ast_d_ExpressionStatement: typeof ExpressionStatement;

variable output_ast_d_expressionType

const output_ast_d_expressionType: (
    expr: Expression,
    typeModifiers?: TypeModifier,
    typeParams?: Type$1[]
) => ExpressionType;

variable output_ast_d_ExpressionType

const output_ast_d_ExpressionType: typeof ExpressionType;

variable output_ast_d_ExternalExpr

const output_ast_d_ExternalExpr: typeof ExternalExpr;

variable output_ast_d_ExternalReference

const output_ast_d_ExternalReference: typeof ExternalReference;

variable output_ast_d_fn

const output_ast_d_fn: (
    params: FnParam[],
    body: Statement[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    name?: string
) => FunctionExpr;

variable output_ast_d_FnParam

const output_ast_d_FnParam: typeof FnParam;

variable output_ast_d_FUNCTION_TYPE

const output_ast_d_FUNCTION_TYPE: BuiltinType;

variable output_ast_d_FunctionExpr

const output_ast_d_FunctionExpr: typeof FunctionExpr;

variable output_ast_d_ifStmt

const output_ast_d_ifStmt: (
    condition: Expression,
    thenClause: Statement[],
    elseClause?: Statement[],
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
) => IfStmt;

variable output_ast_d_IfStmt

const output_ast_d_IfStmt: typeof IfStmt;

variable output_ast_d_importExpr

const output_ast_d_importExpr: (
    id: ExternalReference,
    typeParams?: Type$1[],
    sourceSpan?: ParseSourceSpan$1
) => ExternalExpr;

variable output_ast_d_importType

const output_ast_d_importType: (
    id: ExternalReference,
    typeParams?: Type$1[],
    typeModifiers?: TypeModifier
) => ExpressionType;

variable output_ast_d_INFERRED_TYPE

const output_ast_d_INFERRED_TYPE: BuiltinType;

variable output_ast_d_InstantiateExpr

const output_ast_d_InstantiateExpr: typeof InstantiateExpr;

variable output_ast_d_INT_TYPE

const output_ast_d_INT_TYPE: BuiltinType;

variable output_ast_d_InvokeFunctionExpr

const output_ast_d_InvokeFunctionExpr: typeof InvokeFunctionExpr;

variable output_ast_d_isNull

const output_ast_d_isNull: (exp: Expression) => boolean;

variable output_ast_d_jsDocComment

const output_ast_d_jsDocComment: (tags?: JSDocTag[]) => JSDocComment;

variable output_ast_d_JSDocComment

const output_ast_d_JSDocComment: typeof JSDocComment;

variable output_ast_d_JSDocTagName

const output_ast_d_JSDocTagName: typeof JSDocTagName;

variable output_ast_d_leadingComment

const output_ast_d_leadingComment: (
    text: string,
    multiline?: boolean,
    trailingNewline?: boolean
) => LeadingComment;

variable output_ast_d_LeadingComment

const output_ast_d_LeadingComment: typeof LeadingComment;

variable output_ast_d_literal

const output_ast_d_literal: (
    value: any,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => LiteralExpr;

variable output_ast_d_literalArr

const output_ast_d_literalArr: (
    values: Expression[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => LiteralArrayExpr;

variable output_ast_d_LiteralArrayExpr

const output_ast_d_LiteralArrayExpr: typeof LiteralArrayExpr;

variable output_ast_d_LiteralExpr

const output_ast_d_LiteralExpr: typeof LiteralExpr;

variable output_ast_d_literalMap

const output_ast_d_literalMap: (
    values: { key: string; quoted: boolean; value: Expression }[],
    type?: MapType
) => LiteralMapExpr;

variable output_ast_d_LiteralMapExpr

const output_ast_d_LiteralMapExpr: typeof LiteralMapExpr;

variable output_ast_d_LiteralMapPropertyAssignment

const output_ast_d_LiteralMapPropertyAssignment: typeof LiteralMapPropertyAssignment;

variable output_ast_d_LiteralMapSpreadAssignment

const output_ast_d_LiteralMapSpreadAssignment: typeof LiteralMapSpreadAssignment;

variable output_ast_d_LiteralPiece

const output_ast_d_LiteralPiece: typeof LiteralPiece;

variable output_ast_d_localizedString

const output_ast_d_localizedString: (
    metaBlock: I18nMeta,
    messageParts: LiteralPiece[],
    placeholderNames: PlaceholderPiece[],
    expressions: Expression[],
    sourceSpan?: ParseSourceSpan$1
) => LocalizedString;

variable output_ast_d_LocalizedString

const output_ast_d_LocalizedString: typeof LocalizedString;

variable output_ast_d_MapType

const output_ast_d_MapType: typeof MapType;

variable output_ast_d_NONE_TYPE

const output_ast_d_NONE_TYPE: BuiltinType;

variable output_ast_d_not

const output_ast_d_not: (
    expr: Expression,
    sourceSpan?: ParseSourceSpan$1
) => NotExpr;

variable output_ast_d_NotExpr

const output_ast_d_NotExpr: typeof NotExpr;

variable output_ast_d_NULL_EXPR

const output_ast_d_NULL_EXPR: LiteralExpr;

variable output_ast_d_nullSafeIsEquivalent

const output_ast_d_nullSafeIsEquivalent: <
    T extends { isEquivalent(other: T): boolean }
>(
    base: T,
    other: T
) => boolean;

variable output_ast_d_NUMBER_TYPE

const output_ast_d_NUMBER_TYPE: BuiltinType;

variable output_ast_d_ParenthesizedExpr

const output_ast_d_ParenthesizedExpr: typeof ParenthesizedExpr;

variable output_ast_d_PlaceholderPiece

const output_ast_d_PlaceholderPiece: typeof PlaceholderPiece;

variable output_ast_d_ReadKeyExpr

const output_ast_d_ReadKeyExpr: typeof ReadKeyExpr;

variable output_ast_d_ReadPropExpr

const output_ast_d_ReadPropExpr: typeof ReadPropExpr;

variable output_ast_d_ReadVarExpr

const output_ast_d_ReadVarExpr: typeof ReadVarExpr;

variable output_ast_d_RegularExpressionLiteralExpr

const output_ast_d_RegularExpressionLiteralExpr: typeof RegularExpressionLiteralExpr;

variable output_ast_d_ReturnStatement

const output_ast_d_ReturnStatement: typeof ReturnStatement;

variable output_ast_d_SpreadElementExpr

const output_ast_d_SpreadElementExpr: typeof SpreadElementExpr;

variable output_ast_d_Statement

const output_ast_d_Statement: typeof Statement;

variable output_ast_d_StmtModifier

const output_ast_d_StmtModifier: typeof StmtModifier;

variable output_ast_d_STRING_TYPE

const output_ast_d_STRING_TYPE: BuiltinType;

variable output_ast_d_taggedTemplate

const output_ast_d_taggedTemplate: (
    tag: Expression,
    template: TemplateLiteralExpr,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => TaggedTemplateLiteralExpr;

variable output_ast_d_TaggedTemplateLiteralExpr

const output_ast_d_TaggedTemplateLiteralExpr: typeof TaggedTemplateLiteralExpr;

variable output_ast_d_TemplateLiteralElementExpr

const output_ast_d_TemplateLiteralElementExpr: typeof TemplateLiteralElementExpr;

variable output_ast_d_TemplateLiteralExpr

const output_ast_d_TemplateLiteralExpr: typeof TemplateLiteralExpr;

variable output_ast_d_transplantedType

const output_ast_d_transplantedType: <T>(
    type: T,
    typeModifiers?: TypeModifier
) => TransplantedType<T>;

variable output_ast_d_TransplantedType

const output_ast_d_TransplantedType: typeof TransplantedType;

variable output_ast_d_TYPED_NULL_EXPR

const output_ast_d_TYPED_NULL_EXPR: LiteralExpr;

variable output_ast_d_TypeModifier

const output_ast_d_TypeModifier: typeof TypeModifier;

variable output_ast_d_typeofExpr

const output_ast_d_typeofExpr: (expr: Expression) => TypeofExpr;

variable output_ast_d_TypeofExpr

const output_ast_d_TypeofExpr: typeof TypeofExpr;

variable output_ast_d_unary

const output_ast_d_unary: (
    operator: UnaryOperator,
    expr: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => UnaryOperatorExpr;

variable output_ast_d_UnaryOperator

const output_ast_d_UnaryOperator: typeof UnaryOperator;

variable output_ast_d_UnaryOperatorExpr

const output_ast_d_UnaryOperatorExpr: typeof UnaryOperatorExpr;

variable output_ast_d_variable

const output_ast_d_variable: (
    name: string,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
) => ReadVarExpr;

variable output_ast_d_VoidExpr

const output_ast_d_VoidExpr: typeof VoidExpr;

variable output_ast_d_WrappedNodeExpr

const output_ast_d_WrappedNodeExpr: typeof WrappedNodeExpr;

variable SCHEMA

const SCHEMA: string[];

This array represents the DOM schema. It encodes inheritance, properties, and events.
## Overview
Each line represents one kind of element. The element_inheritance and properties are joined using element_inheritance|properties syntax.
## Element Inheritance
The element_inheritance can be further subdivided as element1,element2,...^parentElement. Here the individual elements are separated by , (commas). Every element in the list has identical properties.
An element may inherit additional properties from parentElement If no ^parentElement is specified then "" (blank) element is assumed.
NOTE: The blank element inherits from root [Element] element, the super element of all elements.
NOTE an element prefix such as :svg: has no special meaning to the schema.
## Properties
Each element has a set of properties separated by , (commas). Each property can be prefixed by a special character designating its type:
- (no prefix): property is a string. - *: property represents an event. - !: property is a boolean. - #: property is a number. - %: property is an object.
## Query
The class creates an internal squas representation which allows to easily answer the query of if a given property exist on a given element.
NOTE: We don't yet support querying for types or events. NOTE: This schema is auto extracted from schema_extractor.ts located in the test folder, see dom_element_schema_registry_spec.ts

variable STRING_TYPE

const STRING_TYPE: BuiltinType;

variable Type$2

const Type$2: FunctionConstructor;

variable TYPED_NULL_EXPR

const TYPED_NULL_EXPR: LiteralExpr;

variable VERSION

const VERSION: Version;

Entry point for all public APIs of the compiler package.

Functions

function areAllEquivalent

areAllEquivalent: <T extends { isEquivalent(other: T): boolean }>(
    base: T[],
    other: T[]
) => boolean;

function arrowFn

arrowFn: (
    params: FnParam[],
    body: Expression | Statement[],
    type?: Type$1 | null,
    sourceSpan?: ParseSourceSpan$1 | null
) => ArrowFunctionExpr;

function compileClassDebugInfo

compileClassDebugInfo: (debugInfo: R3ClassDebugInfo) => Expression;

Generate an ngDevMode guarded call to setClassDebugInfo with the debug info about the class (e.g., the file name in which the class is defined)

function compileClassMetadata

compileClassMetadata: (metadata: R3ClassMetadata) => InvokeFunctionExpr;

function compileComponentClassMetadata

compileComponentClassMetadata: (
    metadata: R3ClassMetadata,
    dependencies: R3DeferPerComponentDependency[] | null
) => Expression;

Wraps the setClassMetadata function with extra logic that dynamically loads dependencies from @defer blocks.
Generates a call like this:
setClassMetadataAsync(type, () => [ import('./cmp-a').then(m => m.CmpA); import('./cmp-b').then(m => m.CmpB); ], (CmpA, CmpB) => { setClassMetadata(type, decorators, ctorParameters, propParameters); });
Similar to the setClassMetadata call, it's wrapped into the ngDevMode check to tree-shake away this code in production mode.

function compileComponentDeclareClassMetadata

compileComponentDeclareClassMetadata: (
    metadata: R3ClassMetadata,
    dependencies: R3DeferPerComponentDependency[] | null
) => Expression;

function compileComponentFromMetadata

compileComponentFromMetadata: (
    meta: R3ComponentMetadata<R3TemplateDependency>,
    constantPool: ConstantPool,
    bindingParser: BindingParser
) => R3CompiledExpression;

Compile a component for the render3 runtime as defined by the R3ComponentMetadata.

function compileDeclareClassMetadata

compileDeclareClassMetadata: (metadata: R3ClassMetadata) => Expression;

function compileDeclareComponentFromMetadata

compileDeclareComponentFromMetadata: (
    meta: R3ComponentMetadata<R3TemplateDependencyMetadata>,
    template: ParsedTemplate,
    additionalTemplateInfo: DeclareComponentTemplateInfo
) => R3CompiledExpression;

Compile a component declaration defined by the R3ComponentMetadata.

function compileDeclareDirectiveFromMetadata

compileDeclareDirectiveFromMetadata: (
    meta: R3DirectiveMetadata
) => R3CompiledExpression;

Compile a directive declaration defined by the R3DirectiveMetadata.

function compileDeclareFactoryFunction

compileDeclareFactoryFunction: (meta: R3FactoryMetadata) => R3CompiledExpression;

function compileDeclareInjectableFromMetadata

compileDeclareInjectableFromMetadata: (
    meta: R3InjectableMetadata
) => R3CompiledExpression;

Compile a Injectable declaration defined by the R3InjectableMetadata.

function compileDeclareInjectorFromMetadata

compileDeclareInjectorFromMetadata: (
    meta: R3InjectorMetadata
) => R3CompiledExpression;

function compileDeclareNgModuleFromMetadata

compileDeclareNgModuleFromMetadata: (
    meta: R3NgModuleMetadata
) => R3CompiledExpression;

function compileDeclarePipeFromMetadata

compileDeclarePipeFromMetadata: (meta: R3PipeMetadata) => R3CompiledExpression;

Compile a Pipe declaration defined by the R3PipeMetadata.

function compileDeclareServiceFromMetadata

compileDeclareServiceFromMetadata: (
    meta: R3ServiceMetadata
) => R3CompiledExpression;

Compile a Service declaration defined by the R3ServiceMetadata.

function compileDeferResolverFunction

compileDeferResolverFunction: (
    meta: R3DeferResolverFunctionMetadata
) => ArrowFunctionExpr;

Compiles the dependency resolver function for a defer block.

function compileDirectiveFromMetadata

compileDirectiveFromMetadata: (
    meta: R3DirectiveMetadata,
    constantPool: ConstantPool,
    bindingParser: BindingParser
) => R3CompiledExpression;

Compile a directive for the render3 runtime as defined by the R3DirectiveMetadata.

function compileFactoryFunction

compileFactoryFunction: (meta: R3FactoryMetadata) => R3CompiledExpression;

Construct a factory function expression for the given R3FactoryMetadata.

function compileHmrInitializer

compileHmrInitializer: (meta: R3HmrMetadata) => Expression;

Compiles the expression that initializes HMR for a class.
Parameter meta
HMR metadata extracted from the class.

function compileHmrUpdateCallback

compileHmrUpdateCallback: (
    definitions: {
        name: string;
        initializer: Expression | null;
        statements: Statement[];
    }[],
    constantStatements: Statement[],
    meta: R3HmrMetadata
) => DeclareFunctionStmt;

Compiles the HMR update callback for a class.
Parameter definitions
Compiled definitions for the class (e.g. defineComponent calls).
Parameter constantStatements
Supporting constants statements that were generated alongside the definition.
Parameter meta
HMR metadata extracted from the class.

function compileInjectable

compileInjectable: (
    meta: R3InjectableMetadata,
    resolveForwardRefs: boolean
) => R3CompiledExpression;

function compileInjector

compileInjector: (meta: R3InjectorMetadata) => R3CompiledExpression;

function compileNgModule

compileNgModule: (meta: R3NgModuleMetadata) => R3CompiledExpression;

Construct an R3NgModuleDef for the given R3NgModuleMetadata.

function compileOpaqueAsyncClassMetadata

compileOpaqueAsyncClassMetadata: (
    metadata: R3ClassMetadata,
    deferResolver: Expression,
    deferredDependencyNames: string[]
) => Expression;

Identical to compileComponentClassMetadata. Used for the cases where we're unable to analyze the deferred block dependencies, but we have a reference to the compiled dependency resolver function that we can use as is.
Parameter metadata
Class metadata for the internal setClassMetadata call.
Parameter deferResolver
Expression representing the deferred dependency loading function.
Parameter deferredDependencyNames
Names of the dependencies that are being loaded asynchronously.

function compilePipeFromMetadata

compilePipeFromMetadata: (metadata: R3PipeMetadata) => R3CompiledExpression;

function compileService

compileService: (
    meta: R3ServiceMetadata,
    resolveForwardRefs: boolean
) => R3CompiledExpression;

function computeMsgId

computeMsgId: (msg: string, meaning?: string) => string;

function createCssSelectorFromNode

createCssSelectorFromNode: (node: Element | Template) => CssSelector;

Creates a CssSelector from an AST node.

function createHostBindingsBlockGuard

createHostBindingsBlockGuard: () => string;

Creates an AST node that can be used as a guard in if statements to distinguish TypeScript nodes used for checking host bindings from ones used for checking templates.

function createHostElement

createHostElement: (
    type: 'component' | 'directive',
    selector: string | null,
    nameSpan: ParseSourceSpan$1,
    hostObjectLiteralBindings: HostObjectLiteralBinding[],
    hostBindingDecorators: HostBindingDecorator[],
    hostListenerDecorators: HostListenerDecorator[]
) => HostElement | null;

Creates an AST node that represents the host element of a directive. Can return null if there are no valid bindings to be checked.
Parameter meta
Metadata used to construct the host element.

function createInjectableType

createInjectableType: (
    type: Expression,
    typeArgumentCount: number
) => ExpressionType;

function createMayBeForwardRefExpression

createMayBeForwardRefExpression: <T extends Expression>(
    expression: T,
    forwardRef: ForwardRefHandling
) => MaybeForwardRefExpression<T>;

function delegateToFactory

delegateToFactory: (
    type: WrappedNodeExpr<any>,
    useType: WrappedNodeExpr<any>,
    unwrapForwardRefs: boolean
) => Expression;

function devOnlyGuardedExpression

devOnlyGuardedExpression: (expr: Expression) => Expression;

function encapsulateStyle

encapsulateStyle: (style: string, componentIdentifier?: string) => string;

Encapsulates a CSS stylesheet with emulated view encapsulation. This allows a stylesheet to be used with an Angular component that is using the ViewEncapsulation.Emulated mode.
Parameter style
The content of a CSS stylesheet.
Parameter componentIdentifier
The identifier to use within the CSS rules.
Returns
The encapsulated content for the style.

function escapeRegExp

escapeRegExp: (s: string) => string;

function expressionType

expressionType: (
    expr: Expression,
    typeModifiers?: TypeModifier,
    typeParams?: Type$1[] | null
) => ExpressionType;

function findMatchingDirectivesAndPipes

findMatchingDirectivesAndPipes: (
    template: string,
    directiveSelectors: string[]
) => {
    directives: { regular: string[]; deferCandidates: string[] };
    pipes: { regular: string[]; deferCandidates: string[] };
};

Given a template string and a set of available directive selectors, computes a list of matching selectors and splits them into 2 buckets: (1) eagerly used in a template and (2) directives used only in defer blocks. Similarly, returns 2 lists of pipes (eager and deferrable).
Note: deferrable directives selectors and pipes names used in @defer blocks are **candidates** and API caller should make sure that:
* A Component where a given template is defined is standalone * Underlying dependency classes are also standalone * Dependency class symbols are not eagerly used in a TS file where a host component (that owns the template) is located

function fn

fn: (
    params: FnParam[],
    body: Statement[],
    type?: Type$1 | null,
    sourceSpan?: ParseSourceSpan$1 | null,
    name?: string | null
) => FunctionExpr;

function generateTypeCheckBlock

generateTypeCheckBlock: (
    env: TcbEnvironment,
    component: TcbComponentMetadata,
    name: string,
    meta: TcbTypeCheckBlockMetadata,
    domSchemaChecker: DomSchemaChecker<unknown>,
    oobRecorder: OutOfBandDiagnosticRecorder<unknown>
) => string;

Given a component and metadata, compose a "type check block" function.
Parameter env
an TcbEnvironment into which type-checking code will be generated.
Parameter component
metadata about the component class.
Parameter name
Name of the generated function.
Parameter meta
metadata about the component's template and the function being generated.
Parameter domSchemaChecker
used to check and record errors regarding improper usage of DOM elements and bindings.
Parameter oobRecorder
used to record errors regarding template elements which could not be correctly translated into types during TCB generation.

function getHtmlTagDefinition

getHtmlTagDefinition: (tagName: string) => HtmlTagDefinition;

function getNsPrefix

getNsPrefix: { (fullName: string): string; (fullName: null): null };

function getSafePropertyAccessString

getSafePropertyAccessString: (accessor: string, name: string) => string;

function identifierName

identifierName: (
    compileIdentifier: CompileIdentifierMetadata | null | undefined
) => string | null;

function ifStmt

ifStmt: (
    condition: Expression,
    thenClause: Statement[],
    elseClause?: Statement[],
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
) => IfStmt;

function importExpr

importExpr: (
    id: ExternalReference,
    typeParams?: Type$1[] | null,
    sourceSpan?: ParseSourceSpan$1 | null
) => ExternalExpr;

function importType

importType: (
    id: ExternalReference,
    typeParams?: Type$1[] | null,
    typeModifiers?: TypeModifier
) => ExpressionType | null;

function isNgContainer

isNgContainer: (tagName: string) => boolean;

function isNgContent

isNgContent: (tagName: string) => boolean;

function isNgTemplate

isNgTemplate: (tagName: string) => boolean;

function isNull

isNull: (exp: Expression) => boolean;

function isUnsafeObjectKey

isUnsafeObjectKey: (key: string) => boolean;

function jsDocComment

jsDocComment: (tags?: JSDocTag[]) => JSDocComment;

function leadingComment

leadingComment: (
    text: string,
    multiline?: boolean,
    trailingNewline?: boolean
) => LeadingComment;

function literal

literal: (
    value: any,
    type?: Type$1 | null,
    sourceSpan?: ParseSourceSpan$1 | null
) => LiteralExpr;

function literalArr

literalArr: (
    values: Expression[],
    type?: Type$1 | null,
    sourceSpan?: ParseSourceSpan$1 | null
) => LiteralArrayExpr;

function literalMap

literalMap: (
    values: { key: string; quoted: boolean; value: Expression }[],
    type?: MapType | null
) => LiteralMapExpr;

function localizedString

localizedString: (
    metaBlock: I18nMeta,
    messageParts: LiteralPiece[],
    placeholderNames: PlaceholderPiece[],
    expressions: Expression[],
    sourceSpan?: ParseSourceSpan$1 | null
) => LocalizedString;

function makeBindingParser

makeBindingParser: (selectorlessEnabled?: boolean) => BindingParser;

Construct a BindingParser with a default configuration.

function mergeNsAndName

mergeNsAndName: (prefix: string, localName: string) => string;

function not

not: (expr: Expression, sourceSpan?: ParseSourceSpan$1 | null) => NotExpr;

function nullSafeIsEquivalent

nullSafeIsEquivalent: <T extends { isEquivalent(other: T): boolean }>(
    base: T | null,
    other: T | null
) => boolean;

function parseHostBindings

parseHostBindings: (host: {
    [key: string]: string | Expression;
}) => ParsedHostBindings;

function parseSelectorToR3Selector

parseSelectorToR3Selector: (selector: string | null) => R3CssSelectorList;

function parseTemplate

parseTemplate: (
    template: string,
    templateUrl: string,
    options?: ParseTemplateOptions
) => ParsedTemplate;

Parse a template into render3 Nodes and additional metadata, with no other dependencies.
Parameter template
text of the template to parse
Parameter templateUrl
URL to use for source mapping of the parsed template
Parameter options
options to modify how the template is parsed

function preserveWhitespacesDefault

preserveWhitespacesDefault: (
    preserveWhitespacesOption: boolean | null,
    defaultSetting?: boolean
) => boolean;

function publishFacade

publishFacade: (global: any) => void;

function r3JitTypeSourceSpan

r3JitTypeSourceSpan: (
    kind: string,
    typeName: string,
    sourceUrl: string
) => ParseSourceSpan$1;

Generates Source Span object for a given R3 Type for JIT mode.
Parameter kind
Component or Directive.
Parameter typeName
name of the Component or Directive.
Parameter sourceUrl
reference to Component or Directive source.
Returns
instance of ParseSourceSpan that represent a given Component or Directive.

function sanitizeIdentifier

sanitizeIdentifier: (name: string) => string;

function setEnableTemplateSourceLocations

setEnableTemplateSourceLocations: (value: boolean) => void;

Utility function to enable source locations. Intended to be used **only** inside unit tests.

function splitNsName

splitNsName: (elementName: string, fatal?: boolean) => [string | null, string];

function taggedTemplate

taggedTemplate: (
    tag: Expression,
    template: TemplateLiteralExpr,
    type?: Type$1 | null,
    sourceSpan?: ParseSourceSpan$1 | null
) => TaggedTemplateLiteralExpr;

function tmplAstVisitAll

tmplAstVisitAll: <Result>(visitor: Visitor<Result>, nodes: Node[]) => Result[];

function transplantedType

transplantedType: <T>(
    type: T,
    typeModifiers?: TypeModifier
) => TransplantedType<T>;

function typeofExpr

typeofExpr: (expr: Expression) => TypeofExpr;

function unary

unary: (
    operator: UnaryOperator,
    expr: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1 | null
) => UnaryOperatorExpr;

function variable

variable: (
    name: string,
    type?: Type$1 | null,
    sourceSpan?: ParseSourceSpan$1 | null,
    leadingComments?: LeadingComment[]
) => ReadVarExpr;

function verifyHostBindings

verifyHostBindings: (
    bindings: ParsedHostBindings,
    sourceSpan: ParseSourceSpan$1
) => ParseError[];

Verifies host bindings and returns the list of errors (if any). Empty array indicates that a given set of host bindings has no errors.
Parameter bindings
set of host bindings to verify.
Parameter sourceSpan
source span where host bindings were defined.
Returns
array of errors associated with a given set of host bindings.

function visitAll

visitAll: (visitor: Visitor$1, nodes: Node$1[], context?: any) => any[];

Classes

class AbsoluteSourceSpan

class AbsoluteSourceSpan {}

Records the absolute position of a text span in a source file, where start and end are the starting and ending byte offsets, respectively, of the text span in a source file.

constructor

constructor(start: number, end: number);

property end

readonly end: number;

property start

readonly start: number;

class AbstractEmitterVisitor

abstract class AbstractEmitterVisitor
    implements StatementVisitor, ExpressionVisitor, TypeVisitor {}

constructor

constructor(printComments: boolean, printTypes: boolean);

property printComments

protected readonly printComments: boolean;

property printTypes

protected readonly printTypes: boolean;

method printLeadingComments

protected printLeadingComments: (
    node: Expression | Statement,
    ctx: EmitterVisitorContext
) => void;

method shouldParenthesize

protected shouldParenthesize: (
    expression: Expression,
    containingExpression: Expression
) => boolean;

method visitAllExpressions

visitAllExpressions: (
    expressions: Expression[],
    ctx: EmitterVisitorContext,
    separator: string
) => void;

method visitAllObjects

visitAllObjects: <T>(
    handler: (t: T) => void,
    expressions: T[],
    ctx: EmitterVisitorContext,
    separator: string
) => void;

method visitAllStatements

visitAllStatements: (
    statements: Statement[],
    ctx: EmitterVisitorContext
) => void;

method visitArrayType

visitArrayType: (type: ArrayType, ctx: EmitterVisitorContext) => void;

method visitArrowFunctionExpr

visitArrowFunctionExpr: (
    ast: ArrowFunctionExpr,
    ctx: EmitterVisitorContext
) => void;

method visitBinaryOperatorExpr

visitBinaryOperatorExpr: (
    ast: BinaryOperatorExpr,
    ctx: EmitterVisitorContext
) => void;

method visitBuiltinType

visitBuiltinType: (type: BuiltinType, ctx: EmitterVisitorContext) => void;

method visitCommaExpr

visitCommaExpr: (ast: CommaExpr, ctx: EmitterVisitorContext) => void;

method visitConditionalExpr

visitConditionalExpr: (ast: ConditionalExpr, ctx: EmitterVisitorContext) => void;

method visitDeclareFunctionStmt

visitDeclareFunctionStmt: (
    stmt: DeclareFunctionStmt,
    ctx: EmitterVisitorContext
) => void;

method visitDeclareVarStmt

visitDeclareVarStmt: (stmt: DeclareVarStmt, ctx: EmitterVisitorContext) => void;

method visitDynamicImportExpr

visitDynamicImportExpr: (
    ast: DynamicImportExpr,
    ctx: EmitterVisitorContext
) => void;

method visitExpressionStmt

visitExpressionStmt: (
    stmt: ExpressionStatement,
    ctx: EmitterVisitorContext
) => void;

method visitExpressionType

visitExpressionType: (type: ExpressionType, ctx: EmitterVisitorContext) => void;

method visitExternalExpr

abstract visitExternalExpr: (
    ast: ExternalExpr,
    ctx: EmitterVisitorContext
) => void;

method visitFunctionExpr

visitFunctionExpr: (ast: FunctionExpr, ctx: EmitterVisitorContext) => void;

method visitIfStmt

visitIfStmt: (stmt: IfStmt, ctx: EmitterVisitorContext) => void;

method visitInstantiateExpr

visitInstantiateExpr: (ast: InstantiateExpr, ctx: EmitterVisitorContext) => void;

method visitInvokeFunctionExpr

visitInvokeFunctionExpr: (
    expr: InvokeFunctionExpr,
    ctx: EmitterVisitorContext
) => void;

method visitLiteralArrayExpr

visitLiteralArrayExpr: (
    ast: LiteralArrayExpr,
    ctx: EmitterVisitorContext
) => void;

method visitLiteralExpr

visitLiteralExpr: (ast: LiteralExpr, ctx: EmitterVisitorContext) => void;

method visitLiteralMapExpr

visitLiteralMapExpr: (ast: LiteralMapExpr, ctx: EmitterVisitorContext) => void;

method visitLocalizedString

visitLocalizedString: (ast: LocalizedString, ctx: EmitterVisitorContext) => void;

method visitMapType

visitMapType: (type: MapType, ctx: EmitterVisitorContext) => void;

method visitNotExpr

visitNotExpr: (ast: NotExpr, ctx: EmitterVisitorContext) => void;

method visitParams

protected visitParams: (params: FnParam[], ctx: EmitterVisitorContext) => void;

method visitParenthesizedExpr

visitParenthesizedExpr: (
    ast: ParenthesizedExpr,
    ctx: EmitterVisitorContext
) => void;

method visitReadKeyExpr

visitReadKeyExpr: (ast: ReadKeyExpr, ctx: EmitterVisitorContext) => void;

method visitReadPropExpr

visitReadPropExpr: (ast: ReadPropExpr, ctx: EmitterVisitorContext) => void;

method visitReadVarExpr

visitReadVarExpr: (ast: ReadVarExpr, ctx: EmitterVisitorContext) => void;

method visitRegularExpressionLiteral

visitRegularExpressionLiteral: (
    ast: RegularExpressionLiteralExpr,
    ctx: EmitterVisitorContext
) => void;

method visitReturnStmt

visitReturnStmt: (stmt: ReturnStatement, ctx: EmitterVisitorContext) => void;

method visitSpreadElementExpr

visitSpreadElementExpr: (
    ast: SpreadElementExpr,
    ctx: EmitterVisitorContext
) => void;

method visitTaggedTemplateLiteralExpr

visitTaggedTemplateLiteralExpr: (
    expr: TaggedTemplateLiteralExpr,
    ctx: EmitterVisitorContext
) => void;

method visitTemplateLiteralElementExpr

visitTemplateLiteralElementExpr: (
    expr: TemplateLiteralElementExpr,
    ctx: EmitterVisitorContext
) => void;

method visitTemplateLiteralExpr

visitTemplateLiteralExpr: (
    expr: TemplateLiteralExpr,
    ctx: EmitterVisitorContext
) => void;

method visitTransplantedType

visitTransplantedType: (
    type: TransplantedType<unknown>,
    ctx: EmitterVisitorContext
) => void;

method visitTypeofExpr

visitTypeofExpr: (expr: TypeofExpr, ctx: EmitterVisitorContext) => void;

method visitUnaryOperatorExpr

visitUnaryOperatorExpr: (
    ast: UnaryOperatorExpr,
    ctx: EmitterVisitorContext
) => void;

method visitVoidExpr

visitVoidExpr: (expr: VoidExpr, ctx: EmitterVisitorContext) => void;

method visitWrappedNodeExpr

abstract visitWrappedNodeExpr: (
    ast: WrappedNodeExpr<unknown>,
    ctx: EmitterVisitorContext
) => void;

class ArrayType

class ArrayType extends Type$1 {}

constructor

constructor(of: Type$1, modifiers?: TypeModifier);

property of

of: Type$1;

method visitType

visitType: (visitor: TypeVisitor, context: any) => any;

class ArrowFunction

class ArrowFunction extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    parameters: ArrowFunctionIdentifierParameter[],
    body: AST
);

property body

body: AST;

property parameters

parameters: ArrowFunctionIdentifierParameter[];

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class ArrowFunctionExpr

class ArrowFunctionExpr extends Expression {}

constructor

constructor(
    params: FnParam[],
    body: Expression | Statement[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property body

body: Expression | Statement[];

property params

params: FnParam[];

method clone

clone: () => Expression;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method toDeclStmt

toDeclStmt: (name: string, modifiers?: StmtModifier) => DeclareVarStmt;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class ArrowFunctionIdentifierParameter

class ArrowFunctionIdentifierParameter {}

constructor

constructor(name: string, span: ParseSpan, sourceSpan: AbsoluteSourceSpan);

property name

name: string;

property sourceSpan

sourceSpan: AbsoluteSourceSpan;

property span

span: ParseSpan;

class AST

abstract class AST {}

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan);

property sourceSpan

sourceSpan: AbsoluteSourceSpan;

Absolute location of the expression AST in a source code file.

property span

span: ParseSpan;

method toString

toString: () => string;

method visit

abstract visit: (visitor: AstVisitor, context?: any) => any;

class ASTWithName

abstract class ASTWithName extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    nameSpan: AbsoluteSourceSpan
);

property nameSpan

nameSpan: AbsoluteSourceSpan;

class ASTWithSource

class ASTWithSource<T extends AST = AST> extends AST {}

constructor

constructor(
    ast: AST,
    source: string,
    location: string,
    absoluteOffset: number,
    errors: ParseError[]
);

property ast

ast: AST;

property errors

errors: ParseError[];

property location

location: string;

property source

source: string;

method toString

toString: () => string;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class Attribute

class Attribute extends NodeWithI18n {}

constructor

constructor(
    name: string,
    value: string,
    sourceSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1,
    valueSpan: ParseSourceSpan$1,
    valueTokens: InterpolatedAttributeToken[],
    i18n: I18nMeta$1
);

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

name: string;

property value

value: string;

property valueSpan

valueSpan: ParseSourceSpan$1;

property valueTokens

valueTokens: InterpolatedAttributeToken[];

method visit

visit: (visitor: Visitor$1, context: any) => any;

class Binary

class Binary extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    operation: BinaryOperation,
    left: AST,
    right: AST
);

property left

left: AST;

property operation

operation: BinaryOperation;

property right

right: AST;

method isAssignmentOperation

static isAssignmentOperation: (op: string) => op is AssignmentOperation;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class BinaryOperatorExpr

class BinaryOperatorExpr extends Expression {}

constructor

constructor(
    operator: BinaryOperator,
    lhs: Expression,
    rhs: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property lhs

lhs: Expression;

property operator

operator: BinaryOperator;

property rhs

rhs: Expression;

method clone

clone: () => BinaryOperatorExpr;

method isAssignment

isAssignment: () => boolean;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class BindingParser

class BindingParser {}

Parses bindings in templates and in the directive host area.

constructor

constructor(
    _exprParser: Parser,
    _schemaRegistry: ElementSchemaRegistry,
    errors: ParseError[]
);

property errors

errors: ParseError[];

method calcPossibleSecurityContexts

calcPossibleSecurityContexts: (
    selector: string,
    propName: string,
    isAttribute: boolean
) => SecurityContext[];

method createBoundElementProperty

createBoundElementProperty: (
    elementSelector: string | null,
    boundProp: ParsedProperty,
    skipValidation?: boolean,
    mapPropertyName?: boolean
) => BoundElementProperty;

method createBoundHostProperties

createBoundHostProperties: (
    properties: HostProperties,
    sourceSpan: ParseSourceSpan$1
) => ParsedProperty[] | null;

method createDirectiveHostEventAsts

createDirectiveHostEventAsts: (
    hostListeners: HostListeners,
    sourceSpan: ParseSourceSpan$1
) => ParsedEvent[] | null;

method parseBinding

parseBinding: (
    value: string,
    isHostBinding: boolean,
    sourceSpan: ParseSourceSpan$1,
    absoluteOffset: number
) => ASTWithSource;

method parseEvent

parseEvent: (
    name: string,
    expression: string,
    isAssignmentEvent: boolean,
    sourceSpan: ParseSourceSpan$1,
    handlerSpan: ParseSourceSpan$1,
    targetMatchableAttrs: string[][],
    targetEvents: ParsedEvent[],
    keySpan: ParseSourceSpan$1
) => void;

method parseEventListenerName

parseEventListenerName: (rawName: string) => {
    eventName: string;
    target: string | null;
};

method parseInlineTemplateBinding

parseInlineTemplateBinding: (
    tplKey: string,
    tplValue: string,
    sourceSpan: ParseSourceSpan$1,
    absoluteValueOffset: number,
    targetMatchableAttrs: string[][],
    targetProps: ParsedProperty[],
    targetVars: ParsedVariable[],
    isIvyAst: boolean
) => void;

Parses the bindings in a microsyntax expression, and converts them to ParsedProperty or ParsedVariable.
Parameter tplKey
template binding name
Parameter tplValue
template binding value
Parameter sourceSpan
span of template binding relative to entire the template
Parameter absoluteValueOffset
start of the tplValue relative to the entire template
Parameter targetMatchableAttrs
potential attributes to match in the template
Parameter targetProps
target property bindings in the template
Parameter targetVars
target variables in the template

method parseInterpolation

parseInterpolation: (
    value: string,
    sourceSpan: ParseSourceSpan$1,
    interpolatedTokens:
        | InterpolatedAttributeToken[]
        | InterpolatedTextToken[]
        | null
) => ASTWithSource;

method parseInterpolationExpression

parseInterpolationExpression: (
    expression: string,
    sourceSpan: ParseSourceSpan$1
) => ASTWithSource;

Similar to parseInterpolation, but treats the provided string as a single expression element that would normally appear within the interpolation prefix and suffix ({{ and }}). This is used for parsing the switch expression in ICUs.

method parseLegacyAnimationEventName

parseLegacyAnimationEventName: (rawName: string) => {
    eventName: string;
    phase: string | null;
};

method parseLiteralAttr

parseLiteralAttr: (
    name: string,
    value: string | null,
    sourceSpan: ParseSourceSpan$1,
    absoluteOffset: number,
    valueSpan: ParseSourceSpan$1 | undefined,
    targetMatchableAttrs: string[][],
    targetProps: ParsedProperty[],
    keySpan: ParseSourceSpan$1
) => void;

method parsePropertyBinding

parsePropertyBinding: (
    name: string,
    expression: string,
    isHost: boolean,
    isPartOfAssignmentBinding: boolean,
    sourceSpan: ParseSourceSpan$1,
    absoluteOffset: number,
    valueSpan: ParseSourceSpan$1 | undefined,
    targetMatchableAttrs: string[][],
    targetProps: ParsedProperty[],
    keySpan: ParseSourceSpan$1
) => void;

method parsePropertyInterpolation

parsePropertyInterpolation: (
    name: string,
    value: string,
    sourceSpan: ParseSourceSpan$1,
    valueSpan: ParseSourceSpan$1 | undefined,
    targetMatchableAttrs: string[][],
    targetProps: ParsedProperty[],
    keySpan: ParseSourceSpan$1,
    interpolatedTokens:
        | InterpolatedAttributeToken[]
        | InterpolatedTextToken[]
        | null
) => boolean;

class BindingPipe

class BindingPipe extends ASTWithName {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    exp: AST,
    name: string,
    args: AST[],
    type: BindingPipeType,
    nameSpan: AbsoluteSourceSpan
);

property args

args: AST[];

property exp

exp: AST;

property name

name: string;

property type

readonly type: BindingPipeType;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class Block

class Block extends NodeWithI18n {}

constructor

constructor(
    name: string,
    parameters: BlockParameter[],
    children: Node$1[],
    sourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan?: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property children

children: Node$1[];

property endSourceSpan

endSourceSpan: ParseSourceSpan$1;

property name

name: string;

property nameSpan

nameSpan: ParseSourceSpan$1;

property parameters

parameters: BlockParameter[];

property startSourceSpan

startSourceSpan: ParseSourceSpan$1;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class BlockParameter

class BlockParameter implements BaseNode {}

constructor

constructor(expression: string, sourceSpan: ParseSourceSpan$1);

property expression

expression: string;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class BoundElementProperty

class BoundElementProperty {}

constructor

constructor(
    name: string,
    type: BindingType,
    securityContext: SecurityContext,
    value: ASTWithSource<AST>,
    unit: string,
    sourceSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1,
    valueSpan: ParseSourceSpan$1
);

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

name: string;

property securityContext

securityContext: SecurityContext;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property type

type: BindingType;

property unit

unit: string;

property value

value: ASTWithSource<AST>;

property valueSpan

valueSpan: ParseSourceSpan$1;

class BuiltinType

class BuiltinType extends Type$1 {}

constructor

constructor(name: BuiltinTypeName, modifiers?: TypeModifier);

property name

name: BuiltinTypeName;

method visitType

visitType: (visitor: TypeVisitor, context: any) => any;

class Call

class Call extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    receiver: AST,
    args: AST[],
    argumentSpan: AbsoluteSourceSpan
);

property args

args: AST[];

property argumentSpan

argumentSpan: AbsoluteSourceSpan;

property receiver

receiver: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class Chain

class Chain extends AST {}

Multiple expressions separated by a semicolon.

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, expressions: AST[]);

property expressions

expressions: AST[];

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class ClassPropertyMapping

class ClassPropertyMapping<T extends InputOrOutput = InputOrOutput> {}

A mapping of component property and template binding property names, for example containing the inputs of a particular directive or component.
A single component property has exactly one input/output annotation (and therefore one binding property name) associated with it, but the same binding property name may be shared across many component property names.
Allows bidirectional querying of the mapping - looking up all inputs/outputs with a given property name, or mapping from a specific class property to its binding property name.

property classPropertyNames

readonly classPropertyNames: string[];

All class property names mapped in this mapping.

property propertyNames

readonly propertyNames: string[];

All binding property names mapped in this mapping.

method [Symbol.iterator]

[Symbol.iterator]: () => IterableIterator<T>;

Implement the iterator protocol and return entry objects which contain the class and binding property names (and are useful for destructuring).

method empty

static empty: <T extends InputOrOutput>() => ClassPropertyMapping<T>;

Construct a ClassPropertyMapping with no entries.

method fromMappedObject

static fromMappedObject: <T extends InputOrOutput>(obj: {
    [classPropertyName: string]: string | T;
}) => ClassPropertyMapping<T>;

Construct a ClassPropertyMapping from a primitive JS object which maps class property names to either binding property names or an array that contains both names, which is used in on-disk metadata formats (e.g. in .d.ts files).

method getByBindingPropertyName

getByBindingPropertyName: (propertyName: string) => ReadonlyArray<T> | null;

Lookup all InputOrOutputs that use this propertyName.

method getByClassPropertyName

getByClassPropertyName: (classPropertyName: string) => T | null;

Lookup the InputOrOutput associated with a classPropertyName.

method hasBindingPropertyName

hasBindingPropertyName: (propertyName: BindingPropertyName) => boolean;

Check whether a mapping for the given property name exists.

method merge

static merge: <T extends InputOrOutput>(
    a: ClassPropertyMapping<T>,
    b: ClassPropertyMapping<T>
) => ClassPropertyMapping<T>;

Merge two mappings into one, with class properties from b taking precedence over class properties from a.

method toDirectMappedObject

toDirectMappedObject: () => { [classPropertyName: string]: string };

Convert this mapping to a primitive JS object which maps each class property directly to the binding property name associated with it.

method toJointMappedObject

toJointMappedObject: <O = T>(
    transform: (value: T) => O
) => { [classPropertyName: string]: O };

Convert this mapping to a primitive JS object which maps each class property either to itself (for cases where the binding property name is the same) or to an array which contains both names if they differ.
This object format is used when mappings are serialized (for example into .d.ts files).
Parameter transform
Function used to transform the values of the generated map.

class CombinedRecursiveAstVisitor

class CombinedRecursiveAstVisitor
    extends RecursiveAstVisitor
    implements RecursiveVisitor {}

Visitor that traverses all template and expression AST nodes in a template. Useful for cases where every single node needs to be visited.

method visit

visit: (node: AST | Node) => void;

method visitAllTemplateNodes

protected visitAllTemplateNodes: (nodes: Node[]) => void;

method visitBoundAttribute

visitBoundAttribute: (attribute: BoundAttribute) => void;

method visitBoundEvent

visitBoundEvent: (attribute: BoundEvent) => void;

method visitBoundText

visitBoundText: (text: BoundText) => void;

method visitComponent

visitComponent: (component: Component) => void;

method visitContent

visitContent: (content: Content) => void;

method visitDeferredBlock

visitDeferredBlock: (deferred: DeferredBlock) => void;

method visitDeferredBlockError

visitDeferredBlockError: (block: DeferredBlockError) => void;

method visitDeferredBlockLoading

visitDeferredBlockLoading: (block: DeferredBlockLoading) => void;

method visitDeferredBlockPlaceholder

visitDeferredBlockPlaceholder: (block: DeferredBlockPlaceholder) => void;

method visitDeferredTrigger

visitDeferredTrigger: (trigger: DeferredTrigger) => void;

method visitDirective

visitDirective: (directive: Directive) => void;

method visitElement

visitElement: (element: Element) => void;

method visitForLoopBlock

visitForLoopBlock: (block: ForLoopBlock) => void;

method visitForLoopBlockEmpty

visitForLoopBlockEmpty: (block: ForLoopBlockEmpty) => void;

method visitIcu

visitIcu: (icu: Icu) => void;

method visitIfBlock

visitIfBlock: (block: IfBlock) => void;

method visitIfBlockBranch

visitIfBlockBranch: (block: IfBlockBranch) => void;

method visitLetDeclaration

visitLetDeclaration: (decl: LetDeclaration) => void;

method visitReference

visitReference: (reference: Reference) => void;

method visitSwitchBlock

visitSwitchBlock: (block: SwitchBlock) => void;

method visitSwitchBlockCase

visitSwitchBlockCase: (block: SwitchBlockCase) => void;

method visitSwitchBlockCaseGroup

visitSwitchBlockCaseGroup: (block: SwitchBlockCaseGroup) => void;

method visitSwitchExhaustiveCheck

visitSwitchExhaustiveCheck: (block: SwitchExhaustiveCheck) => void;

method visitTemplate

visitTemplate: (template: Template) => void;

method visitText

visitText: (text: Text) => void;

method visitTextAttribute

visitTextAttribute: (attribute: TextAttribute) => void;

method visitUnknownBlock

visitUnknownBlock: (block: UnknownBlock) => void;

method visitVariable

visitVariable: (variable: Variable) => void;

class CommaExpr

class CommaExpr extends Expression {}

constructor

constructor(
    parts: Expression[],
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property parts

parts: Expression[];

method clone

clone: () => CommaExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class Comment

class Comment$1 implements BaseNode {}

constructor

constructor(value: string, sourceSpan: ParseSourceSpan$1);

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property value

value: string;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class CompilerConfig

class CompilerConfig {}

constructor

constructor({
    defaultEncapsulation,
    preserveWhitespaces,
    strictInjectionParameters,
}?: {
    defaultEncapsulation?: ViewEncapsulation$1;
    preserveWhitespaces?: boolean;
    strictInjectionParameters?: boolean;
});

property defaultEncapsulation

defaultEncapsulation: ViewEncapsulation$1;

property preserveWhitespaces

preserveWhitespaces: boolean;

property strictInjectionParameters

strictInjectionParameters: boolean;

class CompilerFacadeImpl

class CompilerFacadeImpl implements CompilerFacade {}

constructor

constructor(jitEvaluator?: JitEvaluator);

property FactoryTarget

FactoryTarget: typeof FactoryTarget;

property ResourceLoader

ResourceLoader: typeof ResourceLoader;

method compileComponent

compileComponent: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    facade: R3ComponentMetadataFacade
) => any;

method compileComponentDeclaration

compileComponentDeclaration: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    declaration: R3DeclareComponentFacade
) => any;

method compileDirective

compileDirective: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    facade: R3DirectiveMetadataFacade
) => any;

method compileDirectiveDeclaration

compileDirectiveDeclaration: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    declaration: R3DeclareDirectiveFacade
) => any;

method compileFactory

compileFactory: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    meta: R3FactoryDefMetadataFacade
) => any;

method compileFactoryDeclaration

compileFactoryDeclaration: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    meta: R3DeclareFactoryFacade
) => any;

method compileInjectable

compileInjectable: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    facade: R3InjectableMetadataFacade
) => any;

method compileInjectableDeclaration

compileInjectableDeclaration: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    facade: R3DeclareInjectableFacade
) => any;

method compileInjector

compileInjector: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    facade: R3InjectorMetadataFacade
) => any;

method compileInjectorDeclaration

compileInjectorDeclaration: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    declaration: R3DeclareInjectorFacade
) => any;

method compileNgModule

compileNgModule: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    facade: R3NgModuleMetadataFacade
) => any;

method compileNgModuleDeclaration

compileNgModuleDeclaration: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    declaration: R3DeclareNgModuleFacade
) => any;

method compilePipe

compilePipe: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    facade: R3PipeMetadataFacade
) => any;

method compilePipeDeclaration

compilePipeDeclaration: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    declaration: R3DeclarePipeFacade
) => any;

method compileService

compileService: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    facade: R3ServiceMetadataFacade
) => any;

method compileServiceDeclaration

compileServiceDeclaration: (
    angularCoreEnv: CoreEnvironment,
    sourceMapUrl: string,
    facade: R3DeclareServiceFacade
) => any;

method createParseSourceSpan

createParseSourceSpan: (
    kind: string,
    typeName: string,
    sourceUrl: string
) => ParseSourceSpan$1;

class Component

class Component$1 extends NodeWithI18n {}

constructor

constructor(
    componentName: string,
    tagName: string,
    fullName: string,
    attrs: Attribute[],
    directives: Directive$1[],
    children: Node$1[],
    isSelfClosing: boolean,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan?: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property attrs

attrs: Attribute[];

property children

readonly children: Node$1[];

property componentName

readonly componentName: string;

property directives

readonly directives: Directive$1[];

property endSourceSpan

endSourceSpan: ParseSourceSpan$1;

property fullName

readonly fullName: string;

property isSelfClosing

readonly isSelfClosing: boolean;

property startSourceSpan

readonly startSourceSpan: ParseSourceSpan$1;

property tagName

readonly tagName: string;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class Conditional

class Conditional extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    condition: AST,
    trueExp: AST,
    falseExp: AST
);

property condition

condition: AST;

property falseExp

falseExp: AST;

property trueExp

trueExp: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class ConditionalExpr

class ConditionalExpr extends Expression {}

constructor

constructor(
    condition: Expression,
    trueCase: Expression,
    falseCase?: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property condition

condition: Expression;

property falseCase

falseCase: Expression;

property trueCase

trueCase: Expression;

method clone

clone: () => ConditionalExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class ConstantPool

class ConstantPool {}

A constant pool allows a code emitter to share constant in an output context.
The constant pool also supports sharing access to ivy definitions references.

constructor

constructor(isClosureCompilerEnabled?: boolean);

property statements

statements: Statement[];

method getConstLiteral

getConstLiteral: (literal: Expression, forceShared?: boolean) => Expression;

method getSharedConstant

getSharedConstant: (
    def: SharedConstantDefinition,
    expr: Expression
) => Expression;

method getSharedFunctionReference

getSharedFunctionReference: (
    fn: Expression,
    prefix: string,
    useUniqueName?: boolean
) => Expression;

method uniqueName

uniqueName: (name: string, alwaysIncludeSuffix?: boolean) => string;

Produce a unique name in the context of this pool.
The name might be unique among different prefixes if any of the prefixes end in a digit so the prefix should be a constant string (not based on user input) and must not end in a digit.

class CssSelector

class CssSelector {}

A css selector contains an element name, css classes and attribute/value pairs with the purpose of selecting subsets out of them.

property attrs

attrs: string[];

The selectors are encoded in pairs where: - even locations are attribute names - odd locations are attribute values.
Example: Selector: [key1=value1][key2] would parse to:
['key1', 'value1', 'key2', '']

property classNames

classNames: string[];

property element

element: string;

property notSelectors

notSelectors: CssSelector[];

method addAttribute

addAttribute: (name: string, value?: string) => void;

method addClassName

addClassName: (name: string) => void;

method escapeAttribute

escapeAttribute: (attr: string) => string;

Escape $ sequences from the CSS attribute selector.
This is needed because $ can have a special meaning in CSS selectors, with this method we are escaping $ with `$'. [MDN web link for more info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors).
Parameter attr
the attribute to escape.
Returns
the escaped string.

method getAttrs

getAttrs: () => string[];

method hasElementSelector

hasElementSelector: () => boolean;

method isElementSelector

isElementSelector: () => boolean;

method parse

static parse: (selector: string) => CssSelector[];

method setElement

setElement: (element?: string | null) => void;

method toString

toString: () => string;

method unescapeAttribute

unescapeAttribute: (attr: string) => string;

Unescape \$ sequences from the CSS attribute selector.
This is needed because $ can have a special meaning in CSS selectors, but we might want to match an attribute that contains $. [MDN web link for more info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors).
Parameter attr
the attribute to unescape.
Returns
the unescaped string.

class DeclareFunctionStmt

class DeclareFunctionStmt extends Statement {}

constructor

constructor(
    name: string,
    params: FnParam[],
    statements: Statement[],
    type?: Type$1,
    modifiers?: StmtModifier,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property name

name: string;

property params

params: FnParam[];

property statements

statements: Statement[];

property type

type: Type$1;

method isEquivalent

isEquivalent: (stmt: Statement) => boolean;

method visitStatement

visitStatement: (visitor: StatementVisitor, context: any) => any;

class DeclareVarStmt

class DeclareVarStmt extends Statement {}

constructor

constructor(
    name: string,
    value?: Expression,
    type?: Type$1,
    modifiers?: StmtModifier,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property name

name: string;

property type

type: Type$1;

property value

value?: Expression;

method isEquivalent

isEquivalent: (stmt: Statement) => boolean;

method visitStatement

visitStatement: (visitor: StatementVisitor, context: any) => any;

class Directive

class Directive$1 implements BaseNode {}

constructor

constructor(
    name: string,
    attrs: Attribute[],
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan?: ParseSourceSpan$1
);

property attrs

readonly attrs: Attribute[];

property endSourceSpan

readonly endSourceSpan: ParseSourceSpan$1;

property name

readonly name: string;

property sourceSpan

readonly sourceSpan: ParseSourceSpan$1;

property startSourceSpan

readonly startSourceSpan: ParseSourceSpan$1;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class DomElementSchemaRegistry

class DomElementSchemaRegistry extends ElementSchemaRegistry {}

constructor

constructor();

method allKnownAttributesOfElement

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

method allKnownElementNames

allKnownElementNames: () => string[];

method allKnownEventsOfElement

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

method getDefaultComponentElementName

getDefaultComponentElementName: () => string;

method getMappedPropName

getMappedPropName: (propName: string) => string;

method hasElement

hasElement: (tagName: string, schemaMetas: SchemaMetadata[]) => boolean;

method hasProperty

hasProperty: (
    tagName: string,
    propName: string,
    schemaMetas: SchemaMetadata[]
) => boolean;

method normalizeAnimationStyleProperty

normalizeAnimationStyleProperty: (propName: string) => string;

method normalizeAnimationStyleValue

normalizeAnimationStyleValue: (
    camelCaseProp: string,
    userProvidedProp: string,
    val: string | number
) => { error: string; value: string };

method securityContext

securityContext: (
    tagName: string,
    propName: string,
    isAttribute: boolean
) => SecurityContext;

securityContext returns the security context for the given property on the given DOM tag.
Tag and property name are statically known and cannot change at runtime, i.e. it is not possible to bind a value into a changing attribute or tag name.
The filtering is based on a list of allowed tags|attributes. All attributes in the schema above are assumed to have the 'NONE' security context, i.e. that they are safe inert string values. Only specific well known attack vectors are assigned their appropriate context.

method validateAttribute

validateAttribute: (name: string) => { error: boolean; msg?: string };

method validateProperty

validateProperty: (name: string) => { error: boolean; msg?: string };

class DynamicImportExpr

class DynamicImportExpr extends Expression {}

constructor

constructor(
    url: string | Expression,
    sourceSpan?: ParseSourceSpan$1,
    urlComment?: string,
    leadingComments?: LeadingComment[]
);

property url

url: string | Expression;

property urlComment

urlComment?: string;

method clone

clone: () => DynamicImportExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class Element

class Element$1 extends NodeWithI18n {}

constructor

constructor(
    name: string,
    attrs: Attribute[],
    directives: Directive$1[],
    children: Node$1[],
    isSelfClosing: boolean,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    isVoid: boolean,
    i18n?: I18nMeta$1
);

property attrs

attrs: Attribute[];

property children

children: Node$1[];

property directives

readonly directives: Directive$1[];

property endSourceSpan

endSourceSpan: ParseSourceSpan$1;

property isSelfClosing

readonly isSelfClosing: boolean;

property isVoid

readonly isVoid: boolean;

property name

name: string;

property startSourceSpan

startSourceSpan: ParseSourceSpan$1;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class ElementSchemaRegistry

abstract class ElementSchemaRegistry {}

method allKnownElementNames

abstract allKnownElementNames: () => string[];

method getDefaultComponentElementName

abstract getDefaultComponentElementName: () => string;

method getMappedPropName

abstract getMappedPropName: (propName: string) => string;

method hasElement

abstract hasElement: (tagName: string, schemaMetas: SchemaMetadata[]) => boolean;

method hasProperty

abstract hasProperty: (
    tagName: string,
    propName: string,
    schemaMetas: SchemaMetadata[]
) => boolean;

method normalizeAnimationStyleProperty

abstract normalizeAnimationStyleProperty: (propName: string) => string;

method normalizeAnimationStyleValue

abstract normalizeAnimationStyleValue: (
    camelCaseProp: string,
    userProvidedProp: string,
    val: string | number
) => { error: string; value: string };

method securityContext

abstract securityContext: (
    elementName: string,
    propName: string,
    isAttribute: boolean
) => SecurityContext;

method validateAttribute

abstract validateAttribute: (name: string) => { error: boolean; msg?: string };

method validateProperty

abstract validateProperty: (name: string) => { error: boolean; msg?: string };

class EmitterVisitorContext

class EmitterVisitorContext {}

constructor

constructor(_indent: number);

method createRoot

static createRoot: () => EmitterVisitorContext;

method decIndent

decIndent: () => void;

method incIndent

incIndent: () => void;

method lineIsEmpty

lineIsEmpty: () => boolean;

method lineLength

lineLength: () => number;

method print

print: (
    from: { sourceSpan: ParseSourceSpan$1 | null } | null,
    part: string,
    newLine?: boolean
) => void;

method println

println: (
    from?: { sourceSpan: ParseSourceSpan$1 | null } | null,
    lastPart?: string
) => void;

method removeEmptyLastLine

removeEmptyLastLine: () => void;

method spanOf

spanOf: (line: number, column: number) => ParseSourceSpan$1 | null;

method toSource

toSource: () => string;

method toSourceMapGenerator

toSourceMapGenerator: (
    genFilePath: string,
    startsAtLine?: number
) => SourceMapGenerator;

class EmptyExpr

class EmptyExpr extends AST {}

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class Expansion

class Expansion extends NodeWithI18n {}

constructor

constructor(
    switchValue: string,
    type: string,
    cases: ExpansionCase[],
    sourceSpan: ParseSourceSpan$1,
    switchValueSourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property cases

cases: ExpansionCase[];

property switchValue

switchValue: string;

property switchValueSourceSpan

switchValueSourceSpan: ParseSourceSpan$1;

property type

type: string;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class ExpansionCase

class ExpansionCase implements BaseNode {}

constructor

constructor(
    value: string,
    expression: Node$1[],
    sourceSpan: ParseSourceSpan$1,
    valueSourceSpan: ParseSourceSpan$1,
    expSourceSpan: ParseSourceSpan$1
);

property expression

expression: Node$1[];

property expSourceSpan

expSourceSpan: ParseSourceSpan$1;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property value

value: string;

property valueSourceSpan

valueSourceSpan: ParseSourceSpan$1;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class Expression

abstract class Expression {}

constructor

constructor(
    type: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property leadingComments

leadingComments?: LeadingComment[];

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property type

type: Type$1;

method and

and: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method bigger

bigger: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method biggerEquals

biggerEquals: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method bitwiseAnd

bitwiseAnd: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method bitwiseOr

bitwiseOr: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method callFn

callFn: (
    params: Expression[],
    sourceSpan?: ParseSourceSpan$1 | null,
    pure?: boolean,
    leadingComments?: LeadingComment[]
) => InvokeFunctionExpr;

method clone

abstract clone: () => Expression;

method conditional

conditional: (
    trueCase: Expression,
    falseCase?: Expression | null,
    sourceSpan?: ParseSourceSpan$1 | null,
    leadingComments?: LeadingComment[]
) => ConditionalExpr;

method divide

divide: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method equals

equals: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method identical

identical: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method instantiate

instantiate: (
    params: Expression[],
    type?: Type$1 | null,
    sourceSpan?: ParseSourceSpan$1 | null,
    leadingComments?: LeadingComment[]
) => InstantiateExpr;

method isBlank

isBlank: (sourceSpan?: ParseSourceSpan$1 | null) => Expression;

method isConstant

abstract isConstant: () => boolean;

Return true if the expression is constant.

method isEquivalent

abstract isEquivalent: (e: Expression) => boolean;

Calculates whether this expression produces the same value as the given expression. Note: We don't check Types nor ParseSourceSpans nor function arguments.

method key

key: (
    index: Expression,
    type?: Type$1 | null,
    sourceSpan?: ParseSourceSpan$1 | null
) => ReadKeyExpr;

method lower

lower: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method lowerEquals

lowerEquals: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method minus

minus: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method modulo

modulo: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method multiply

multiply: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method notEquals

notEquals: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method notIdentical

notIdentical: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method nullishCoalesce

nullishCoalesce: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method or

or: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method plus

plus: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method power

power: (
    rhs: Expression,
    sourceSpan?: ParseSourceSpan$1 | null
) => BinaryOperatorExpr;

method prop

prop: (name: string, sourceSpan?: ParseSourceSpan$1 | null) => ReadPropExpr;

method toStmt

toStmt: (leadingComments?: LeadingComment[]) => Statement;

method visitExpression

abstract visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class ExpressionBinding

class ExpressionBinding {}

constructor

constructor(
    sourceSpan: AbsoluteSourceSpan,
    key: TemplateBindingIdentifier,
    value: ASTWithSource<AST>
);

Parameter sourceSpan
entire span of the binding.
Parameter key
binding name, like ngForOf, ngForTrackBy, ngIf, along with its span. Note that the length of the span may not be the same as key.source.length. For example, 1. key.source = ngFor, key.span is for "ngFor" 2. key.source = ngForOf, key.span is for "of" 3. key.source = ngForTrackBy, key.span is for "trackBy"
Parameter value
optional expression for the RHS.

property key

readonly key: TemplateBindingIdentifier;

property sourceSpan

readonly sourceSpan: AbsoluteSourceSpan;

property value

readonly value: ASTWithSource<AST>;

class ExpressionStatement

class ExpressionStatement extends Statement {}

constructor

constructor(
    expr: Expression,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property expr

expr: Expression;

method isEquivalent

isEquivalent: (stmt: Statement) => boolean;

method visitStatement

visitStatement: (visitor: StatementVisitor, context: any) => any;

class ExpressionType

class ExpressionType extends Type$1 {}

constructor

constructor(value: Expression, modifiers?: TypeModifier, typeParams?: Type$1[]);

property typeParams

typeParams: Type$1[];

property value

value: Expression;

method visitType

visitType: (visitor: TypeVisitor, context: any) => any;

class ExternalExpr

class ExternalExpr extends Expression {}

constructor

constructor(
    value: ExternalReference,
    type?: Type$1,
    typeParams?: Type$1[],
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property typeParams

typeParams: Type$1[];

property value

value: ExternalReference;

method clone

clone: () => ExternalExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class ExternalReference

class ExternalReference {}

constructor

constructor(moduleName: string, name: string);

property moduleName

moduleName: string;

property name

name: string;

class FunctionExpr

class FunctionExpr extends Expression {}

constructor

constructor(
    params: FnParam[],
    statements: Statement[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    name?: string,
    leadingComments?: LeadingComment[]
);

property name

name?: string;

property params

params: FnParam[];

property statements

statements: Statement[];

method clone

clone: () => FunctionExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression | Statement) => boolean;

method toDeclStmt

toDeclStmt: (name: string, modifiers?: StmtModifier) => DeclareFunctionStmt;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class HtmlParser

class HtmlParser extends Parser$1 {}

constructor

constructor();

method parse

parse: (
    source: string,
    url: string,
    options?: TokenizeOptions
) => ParseTreeResult;

class HtmlTagDefinition

class HtmlTagDefinition implements TagDefinition {}

constructor

constructor({
    closedByChildren,
    implicitNamespacePrefix,
    contentType,
    closedByParent,
    isVoid,
    ignoreFirstLf,
    preventNamespaceInheritance,
    canSelfClose,
}?: {
    closedByChildren?: string[];
    closedByParent?: boolean;
    implicitNamespacePrefix?: string;
    contentType?:
        | TagContentType
        | { [namespace: string]: TagContentType; default: TagContentType };
    isVoid?: boolean;
    ignoreFirstLf?: boolean;
    preventNamespaceInheritance?: boolean;
    canSelfClose?: boolean;
});

property canSelfClose

canSelfClose: boolean;

property closedByParent

closedByParent: boolean;

property ignoreFirstLf

ignoreFirstLf: boolean;

property implicitNamespacePrefix

implicitNamespacePrefix: string;

property isVoid

isVoid: boolean;

property preventNamespaceInheritance

preventNamespaceInheritance: boolean;

method getContentType

getContentType: (prefix?: string) => TagContentType;

method isClosedByChild

isClosedByChild: (name: string) => boolean;

class I18NHtmlParser

class I18NHtmlParser implements HtmlParser {}

constructor

constructor(
    _htmlParser: HtmlParser,
    translations?: string,
    translationsFormat?: string,
    missingTranslation?: MissingTranslationStrategy,
    console?: Console
);

property getTagDefinition

getTagDefinition: any;

method parse

parse: (
    source: string,
    url: string,
    options?: TokenizeOptions
) => ParseTreeResult;

class IfStmt

class IfStmt extends Statement {}

constructor

constructor(
    condition: Expression,
    trueCase: Statement[],
    falseCase?: Statement[],
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property condition

condition: Expression;

property falseCase

falseCase: Statement[];

property trueCase

trueCase: Statement[];

method isEquivalent

isEquivalent: (stmt: Statement) => boolean;

method visitStatement

visitStatement: (visitor: StatementVisitor, context: any) => any;

class ImplicitReceiver

class ImplicitReceiver extends AST {}

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class InstantiateExpr

class InstantiateExpr extends Expression {}

constructor

constructor(
    classExpr: Expression,
    args: Expression[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property args

args: Expression[];

property classExpr

classExpr: Expression;

method clone

clone: () => InstantiateExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class Interpolation

class Interpolation extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    strings: string[],
    expressions: AST[]
);

property expressions

expressions: AST[];

property strings

strings: string[];

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class InvokeFunctionExpr

class InvokeFunctionExpr extends Expression {}

constructor

constructor(
    fn: Expression,
    args: Expression[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    pure?: boolean,
    leadingComments?: LeadingComment[],
    isOptional?: boolean
);

property args

args: Expression[];

property fn

fn: Expression;

property isOptional

isOptional: boolean;

property pure

pure: boolean;

property receiver

readonly receiver: Expression;

method clone

clone: () => InvokeFunctionExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class JitEvaluator

class JitEvaluator {}

A helper class to manage the evaluation of JIT generated code.

method evaluateCode

evaluateCode: (
    sourceUrl: string,
    ctx: EmitterVisitorContext,
    vars: { [key: string]: any },
    createSourceMap: boolean
) => any;

Evaluate a piece of JIT generated code.
Parameter sourceUrl
The URL of this generated code.
Parameter ctx
A context object that contains an AST of the code to be evaluated.
Parameter vars
A map containing the names and values of variables that the evaluated code might reference.
Parameter createSourceMap
If true then create a source-map for the generated code and include it inline as a source-map comment.
Returns
The result of evaluating the code.

method evaluateStatements

evaluateStatements: (
    sourceUrl: string,
    statements: Statement[],
    refResolver: ExternalReferenceResolver,
    createSourceMaps: boolean
) => { [key: string]: any };

Parameter sourceUrl
The URL of the generated code.
Parameter statements
An array of Angular statement AST nodes to be evaluated.
Parameter refResolver
Resolves o.ExternalReferences into values.
Parameter createSourceMaps
If true then create a source-map for the generated code and include it inline as a source-map comment.
Returns
A map of all the variables in the generated code.

method executeFunction

executeFunction: (fn: Function, args: any[]) => any;

Execute a JIT generated function by calling it.
This method can be overridden in tests to capture the functions that are generated by this JitEvaluator class.
Parameter fn
A function to execute.
Parameter args
The arguments to pass to the function being executed.
Returns
The return value of the executed function.

class JSDocComment

class JSDocComment extends LeadingComment {}

constructor

constructor(tags: JSDocTag[]);

property tags

tags: JSDocTag[];

method toString

toString: () => string;

class KeyedRead

class KeyedRead extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    receiver: AST,
    key: AST
);

property key

key: AST;

property receiver

receiver: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class LeadingComment

class LeadingComment {}

constructor

constructor(text: string, multiline: boolean, trailingNewline: boolean);

property multiline

multiline: boolean;

property text

text: string;

property trailingNewline

trailingNewline: boolean;

method toString

toString: () => string;

class LetDeclaration

class LetDeclaration$1 implements BaseNode {}

constructor

constructor(
    name: string,
    value: string,
    sourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1,
    valueSpan: ParseSourceSpan$1
);

property name

name: string;

property nameSpan

readonly nameSpan: ParseSourceSpan$1;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property value

value: string;

property valueSpan

valueSpan: ParseSourceSpan$1;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class Lexer

class Lexer {}

method tokenize

tokenize: (text: string) => Token[];

class LiteralArray

class LiteralArray extends AST {}

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, expressions: AST[]);

property expressions

expressions: AST[];

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class LiteralArrayExpr

class LiteralArrayExpr extends Expression {}

constructor

constructor(
    entries: Expression[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property entries

entries: Expression[];

method clone

clone: () => LiteralArrayExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class LiteralExpr

class LiteralExpr extends Expression {}

constructor

constructor(
    value: string | number | boolean,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property value

value: string | number | boolean;

method clone

clone: () => LiteralExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class LiteralMap

class LiteralMap extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    keys: LiteralMapKey[],
    values: AST[]
);

property keys

keys: LiteralMapKey[];

property values

values: AST[];

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class LiteralMapExpr

class LiteralMapExpr extends Expression {}

constructor

constructor(
    entries: LiteralMapEntry[],
    type?: MapType,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property entries

entries: LiteralMapEntry[];

property valueType

valueType: Type$1;

method clone

clone: () => LiteralMapExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class LiteralMapPropertyAssignment

class LiteralMapPropertyAssignment {}

constructor

constructor(key: string, value: Expression, quoted: boolean);

property key

key: string;

property quoted

quoted: boolean;

property value

value: Expression;

method clone

clone: () => LiteralMapPropertyAssignment;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: LiteralMapPropertyAssignment) => boolean;

class LiteralMapSpreadAssignment

class LiteralMapSpreadAssignment {}

constructor

constructor(expression: Expression);

property expression

expression: Expression;

method clone

clone: () => LiteralMapSpreadAssignment;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: LiteralMapSpreadAssignment) => boolean;

class LiteralPrimitive

class LiteralPrimitive extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    value: string | number | boolean
);

property value

value: string | number | boolean;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class LocalizedString

class LocalizedString extends Expression {}

constructor

constructor(
    metaBlock: I18nMeta,
    messageParts: LiteralPiece[],
    placeHolderNames: PlaceholderPiece[],
    expressions: Expression[],
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property expressions

readonly expressions: Expression[];

property messageParts

readonly messageParts: LiteralPiece[];

property metaBlock

readonly metaBlock: I18nMeta;

property placeHolderNames

readonly placeHolderNames: PlaceholderPiece[];

method clone

clone: () => LocalizedString;

method getMessagePartSourceSpan

getMessagePartSourceSpan: (i: number) => ParseSourceSpan$1 | null;

method getPlaceholderSourceSpan

getPlaceholderSourceSpan: (i: number) => ParseSourceSpan$1;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method serializeI18nHead

serializeI18nHead: () => CookedRawString;

Serialize the given meta and messagePart into "cooked" and "raw" strings that can be used in a $localize tagged string. The format of the metadata is the same as that parsed by parseI18nMeta().
Parameter meta
The metadata to serialize
Parameter messagePart
The first part of the tagged string

method serializeI18nTemplatePart

serializeI18nTemplatePart: (partIndex: number) => CookedRawString;

Serialize the given placeholderName and messagePart into "cooked" and "raw" strings that can be used in a $localize tagged string.
The format is :<placeholder-name>[@@<associated-id>]:.
The associated-id is the message id of the (usually an ICU) message to which this placeholder refers.
Parameter partIndex
The index of the message part to serialize.

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class MapType

class MapType extends Type$1 {}

constructor

constructor(valueType: Type$1, modifiers?: TypeModifier);

property valueType

valueType: Type$1;

method visitType

visitType: (visitor: TypeVisitor, context: any) => any;

class MessageBundle

class MessageBundle {}

A container for message extracted from the templates.

constructor

constructor(
    _htmlParser: HtmlParser,
    _implicitTags: string[],
    _implicitAttrs: { [k: string]: string[] },
    _locale?: string,
    _preserveWhitespace?: boolean
);

method getMessages

getMessages: () => Message[];

method updateFromTemplate

updateFromTemplate: (source: string, url: string) => ParseError[];

method write

write: (
    serializer: Serializer,
    filterSources?: (path: string) => string
) => string;

class NodeWithI18n

abstract class NodeWithI18n implements BaseNode {}

constructor

constructor(sourceSpan: ParseSourceSpan$1, i18n?: I18nMeta$1);

property i18n

i18n?: I18nMeta$1;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

method visit

abstract visit: (visitor: Visitor$1, context: any) => any;

class NonNullAssert

class NonNullAssert extends AST {}

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, expression: AST);

property expression

expression: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class NotExpr

class NotExpr extends Expression {}

constructor

constructor(
    condition: Expression,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property condition

condition: Expression;

method clone

clone: () => NotExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class ParenthesizedExpr

class ParenthesizedExpr extends Expression {}

constructor

constructor(
    expr: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property expr

expr: Expression;

method clone

clone: () => ParenthesizedExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class ParenthesizedExpression

class ParenthesizedExpression extends AST {}

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, expression: AST);

property expression

expression: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class ParsedEvent

class ParsedEvent {}

constructor

constructor(
    name: string,
    targetOrPhase: string,
    type: number,
    handler: ASTWithSource<NonNullAssert | PropertyRead | KeyedRead>,
    sourceSpan: ParseSourceSpan$1,
    handlerSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1
);

constructor

constructor(
    name: string,
    targetOrPhase: string,
    type: ParsedEventType,
    handler: ASTWithSource<AST>,
    sourceSpan: ParseSourceSpan$1,
    handlerSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1
);

property handler

handler: ASTWithSource<AST>;

property handlerSpan

handlerSpan: ParseSourceSpan$1;

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

name: string;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property targetOrPhase

targetOrPhase: string;

property type

type: ParsedEventType;

class ParsedProperty

class ParsedProperty {}

constructor

constructor(
    name: string,
    expression: ASTWithSource<AST>,
    type: ParsedPropertyType,
    sourceSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1,
    valueSpan: ParseSourceSpan$1
);

property expression

expression: ASTWithSource<AST>;

property isAnimation

readonly isAnimation: boolean;

property isLegacyAnimation

readonly isLegacyAnimation: boolean;

property isLiteral

readonly isLiteral: boolean;

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

name: string;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property type

type: ParsedPropertyType;

property valueSpan

valueSpan: ParseSourceSpan$1;

class ParsedVariable

class ParsedVariable {}

ParsedVariable represents a variable declaration in a microsyntax expression.

constructor

constructor(
    name: string,
    value: string,
    sourceSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1,
    valueSpan?: ParseSourceSpan$1
);

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

readonly name: string;

property sourceSpan

readonly sourceSpan: ParseSourceSpan$1;

property value

readonly value: string;

property valueSpan

readonly valueSpan?: ParseSourceSpan$1;

class ParseError

class ParseError extends Error {}

constructor

constructor(
    span: ParseSourceSpan$1,
    msg: string,
    level?: ParseErrorLevel,
    relatedError?: {}
);

property level

readonly level: ParseErrorLevel;

Severity level of the error.

property msg

readonly msg: string;

Error message.

property relatedError

readonly relatedError?: {};

Error that caused the error to be surfaced. For example, an error in a sub-expression that couldn't be parsed. Not guaranteed to be defined, but can be used to provide more context.

property span

readonly span: ParseSourceSpan$1;

Location of the error.

method contextualMessage

contextualMessage: () => string;

method toString

toString: () => string;

class ParseLocation

class ParseLocation {}

constructor

constructor(file: ParseSourceFile, offset: number, line: number, col: number);

property col

col: number;

property file

file: ParseSourceFile;

property line

line: number;

property offset

offset: number;

method getContext

getContext: (
    maxChars: number,
    maxLines: number
) => { before: string; after: string } | null;

method moveBy

moveBy: (delta: number) => ParseLocation;

method toString

toString: () => string;

class Parser

class Parser {}

constructor

constructor(_lexer: Lexer, _supportsDirectPipeReferences?: boolean);

method parseAction

parseAction: (
    input: string,
    parseSourceSpan: ParseSourceSpan$1,
    absoluteOffset: number
) => ASTWithSource;

method parseBinding

parseBinding: (
    input: string,
    parseSourceSpan: ParseSourceSpan$1,
    absoluteOffset: number
) => ASTWithSource;

method parseInterpolation

parseInterpolation: (
    input: string,
    parseSourceSpan: ParseSourceSpan$1,
    absoluteOffset: number,
    interpolatedTokens:
        | InterpolatedAttributeToken[]
        | InterpolatedTextToken[]
        | null
) => ASTWithSource | null;

method parseInterpolationExpression

parseInterpolationExpression: (
    expression: string,
    parseSourceSpan: ParseSourceSpan$1,
    absoluteOffset: number
) => ASTWithSource;

Similar to parseInterpolation, but treats the provided string as a single expression element that would normally appear within the interpolation prefix and suffix ({{ and }}). This is used for parsing the switch expression in ICUs.

method parseSimpleBinding

parseSimpleBinding: (
    input: string,
    parseSourceSpan: ParseSourceSpan$1,
    absoluteOffset: number
) => ASTWithSource;

method parseTemplateBindings

parseTemplateBindings: (
    templateKey: string,
    templateValue: string,
    parseSourceSpan: ParseSourceSpan$1,
    absoluteKeyOffset: number,
    absoluteValueOffset: number
) => TemplateBindingParseResult;

Parse microsyntax template expression and return a list of bindings or parsing errors in case the given expression is invalid.
For example,
<div *ngFor="let item of items"> ^ ^ absoluteValueOffset for `templateValue` absoluteKeyOffset for `templateKey`
contains three bindings: 1. ngFor -> null 2. item -> NgForOfContext.$implicit 3. ngForOf -> items
This is apparent from the de-sugared template:
<ng-template ngFor let-item [ngForOf]="items">
Parameter templateKey
name of directive, without the * prefix. For example: ngIf, ngFor
Parameter templateValue
RHS of the microsyntax attribute
Parameter templateUrl
template filename if it's external, component filename if it's inline
Parameter absoluteKeyOffset
start of the templateKey
Parameter absoluteValueOffset
start of the templateValue

method splitInterpolation

splitInterpolation: (
    input: string,
    parseSourceSpan: ParseSourceSpan$1,
    errors: ParseError[],
    interpolatedTokens:
        | InterpolatedAttributeToken[]
        | InterpolatedTextToken[]
        | null
) => SplitInterpolation;

Splits a string of text into "raw" text segments and expressions present in interpolations in the string. Returns null if there are no interpolations, otherwise a SplitInterpolation with splits that look like <raw text> <raw text> ... <raw text> <raw text>

method wrapLiteralPrimitive

wrapLiteralPrimitive: (
    input: string | null,
    sourceSpanOrLocation: ParseSourceSpan$1 | string,
    absoluteOffset: number
) => ASTWithSource;

class ParseSourceFile

class ParseSourceFile {}

constructor

constructor(content: string, url: string);

property content

content: string;

property url

url: string;

class ParseSourceSpan

class ParseSourceSpan$1 {}

constructor

constructor(
    start: ParseLocation,
    end: ParseLocation,
    fullStart?: ParseLocation,
    details?: string
);

Create an object that holds information about spans of tokens/nodes captured during lexing/parsing of text.
Parameter start
The location of the start of the span (having skipped leading trivia). Skipping leading trivia makes source-spans more "user friendly", since things like HTML elements will appear to begin at the start of the opening tag, rather than at the start of any leading trivia, which could include newlines.
Parameter end
The location of the end of the span.
Parameter fullStart
The start of the token without skipping the leading trivia. This is used by tooling that splits tokens further, such as extracting Angular interpolations from text tokens. Such tooling creates new source-spans relative to the original token's source-span. If leading trivia characters have been skipped then the new source-spans may be incorrectly offset.
Parameter details
Additional information (such as identifier names) that should be associated with the span.

property details

details: string;

property end

end: ParseLocation;

property fullStart

fullStart: ParseLocation;

property start

start: ParseLocation;

method toString

toString: () => string;

class ParseSpan

class ParseSpan {}

constructor

constructor(start: number, end: number);

property end

end: number;

property start

start: number;

method toAbsolute

toAbsolute: (absoluteOffset: number) => AbsoluteSourceSpan;

class ParseTreeResult

class ParseTreeResult {}

constructor

constructor(rootNodes: Node$1[], errors: ParseError[]);

property errors

errors: ParseError[];

property rootNodes

rootNodes: Node$1[];

class PrefixNot

class PrefixNot extends AST {}

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, expression: AST);

property expression

expression: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class PropertyRead

class PropertyRead extends ASTWithName {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    nameSpan: AbsoluteSourceSpan,
    receiver: AST,
    name: string
);

property name

name: string;

property receiver

receiver: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class R3Identifiers

class Identifiers {}

property advance

static advance: ExternalReference;

property animationEnter

static animationEnter: ExternalReference;

property animationEnterListener

static animationEnterListener: ExternalReference;

property animationLeave

static animationLeave: ExternalReference;

property animationLeaveListener

static animationLeaveListener: ExternalReference;

property ariaProperty

static ariaProperty: ExternalReference;

property arrowFunction

static arrowFunction: ExternalReference;

property assertType

static assertType: { name: string; moduleName: string };

property attachSourceLocations

static attachSourceLocations: ExternalReference;

property attribute

static attribute: ExternalReference;

property ChangeDetectionStrategy

static ChangeDetectionStrategy: ExternalReference;

property classMap

static classMap: ExternalReference;

property classProp

static classProp: ExternalReference;

property ComponentDeclaration

static ComponentDeclaration: ExternalReference;

property componentInstance

static componentInstance: ExternalReference;

property conditional

static conditional: ExternalReference;

property conditionalBranchCreate

static conditionalBranchCreate: ExternalReference;

property conditionalCreate

static conditionalCreate: ExternalReference;

property contentChildDecorator

static contentChildDecorator: ExternalReference;

property contentChildrenDecorator

static contentChildrenDecorator: ExternalReference;

property contentQuery

static contentQuery: ExternalReference;

property contentQuerySignal

static contentQuerySignal: ExternalReference;

property control

static control: ExternalReference;

property controlCreate

static controlCreate: ExternalReference;

property ControlFeature

static ControlFeature: ExternalReference;

property core

static core: ExternalReference;

property declareClassMetadata

static declareClassMetadata: ExternalReference;

property declareClassMetadataAsync

static declareClassMetadataAsync: ExternalReference;

property declareComponent

static declareComponent: ExternalReference;

property declareDirective

static declareDirective: ExternalReference;

property declareFactory

static declareFactory: ExternalReference;

property declareInjectable

static declareInjectable: ExternalReference;

property declareInjector

static declareInjector: ExternalReference;

property declareLet

static declareLet: ExternalReference;

property declareNgModule

static declareNgModule: ExternalReference;

property declarePipe

static declarePipe: ExternalReference;

property declareService

static declareService: ExternalReference;

property defer

static defer: ExternalReference;

property deferEnableTimerScheduling

static deferEnableTimerScheduling: ExternalReference;

property deferHydrateNever

static deferHydrateNever: ExternalReference;

property deferHydrateOnHover

static deferHydrateOnHover: ExternalReference;

property deferHydrateOnIdle

static deferHydrateOnIdle: ExternalReference;

property deferHydrateOnImmediate

static deferHydrateOnImmediate: ExternalReference;

property deferHydrateOnInteraction

static deferHydrateOnInteraction: ExternalReference;

property deferHydrateOnTimer

static deferHydrateOnTimer: ExternalReference;

property deferHydrateOnViewport

static deferHydrateOnViewport: ExternalReference;

property deferHydrateWhen

static deferHydrateWhen: ExternalReference;

property deferOnHover

static deferOnHover: ExternalReference;

property deferOnIdle

static deferOnIdle: ExternalReference;

property deferOnImmediate

static deferOnImmediate: ExternalReference;

property deferOnInteraction

static deferOnInteraction: ExternalReference;

property deferOnTimer

static deferOnTimer: ExternalReference;

property deferOnViewport

static deferOnViewport: ExternalReference;

property deferPrefetchOnHover

static deferPrefetchOnHover: ExternalReference;

property deferPrefetchOnIdle

static deferPrefetchOnIdle: ExternalReference;

property deferPrefetchOnImmediate

static deferPrefetchOnImmediate: ExternalReference;

property deferPrefetchOnInteraction

static deferPrefetchOnInteraction: ExternalReference;

property deferPrefetchOnTimer

static deferPrefetchOnTimer: ExternalReference;

property deferPrefetchOnViewport

static deferPrefetchOnViewport: ExternalReference;

property deferPrefetchWhen

static deferPrefetchWhen: ExternalReference;

property deferWhen

static deferWhen: ExternalReference;

property defineComponent

static defineComponent: ExternalReference;

property defineDirective

static defineDirective: ExternalReference;

property defineInjector

static defineInjector: ExternalReference;

property defineNgModule

static defineNgModule: ExternalReference;

property definePipe

static definePipe: ExternalReference;

property defineService

static defineService: ExternalReference;

property DirectiveDeclaration

static DirectiveDeclaration: ExternalReference;

property directiveInject

static directiveInject: ExternalReference;

property disableBindings

static disableBindings: ExternalReference;

property domElement

static domElement: ExternalReference;

property domElementContainer

static domElementContainer: ExternalReference;

property domElementContainerEnd

static domElementContainerEnd: ExternalReference;

property domElementContainerStart

static domElementContainerStart: ExternalReference;

property domElementEnd

static domElementEnd: ExternalReference;

property domElementStart

static domElementStart: ExternalReference;

property domListener

static domListener: ExternalReference;

property domProperty

static domProperty: ExternalReference;

property domTemplate

static domTemplate: ExternalReference;

property element

static element: ExternalReference;

property elementContainer

static elementContainer: ExternalReference;

property elementContainerEnd

static elementContainerEnd: ExternalReference;

property elementContainerStart

static elementContainerStart: ExternalReference;

property elementEnd

static elementEnd: ExternalReference;

property elementStart

static elementStart: ExternalReference;

property enableBindings

static enableBindings: ExternalReference;

property enableIncrementalHydrationRuntime

static enableIncrementalHydrationRuntime: ExternalReference;

property ExternalStylesFeature

static ExternalStylesFeature: ExternalReference;

property FactoryDeclaration

static FactoryDeclaration: ExternalReference;

property FactoryTarget

static FactoryTarget: ExternalReference;

property forwardRef

static forwardRef: ExternalReference;

property getComponentDepsFactory

static getComponentDepsFactory: ExternalReference;

property getCurrentView

static getCurrentView: ExternalReference;

property getInheritedFactory

static getInheritedFactory: ExternalReference;

property getReplaceMetadataURL

static getReplaceMetadataURL: ExternalReference;

property HostDirectivesFeature

static HostDirectivesFeature: ExternalReference;

property i18n

static i18n: ExternalReference;

property i18nApply

static i18nApply: ExternalReference;

property i18nAttributes

static i18nAttributes: ExternalReference;

property i18nEnd

static i18nEnd: ExternalReference;

property i18nExp

static i18nExp: ExternalReference;

property i18nPostprocess

static i18nPostprocess: ExternalReference;

property i18nStart

static i18nStart: ExternalReference;

property InheritDefinitionFeature

static InheritDefinitionFeature: ExternalReference;

property inject

static inject: ExternalReference;

property InjectableDeclaration

static InjectableDeclaration: ExternalReference;

property injectAttribute

static injectAttribute: ExternalReference;

property InjectorDeclaration

static InjectorDeclaration: ExternalReference;

property InjectorDef

static InjectorDef: ExternalReference;

property inputDecorator

static inputDecorator: ExternalReference;

property InputSignalBrandWriteType

static InputSignalBrandWriteType: { name: string; moduleName: string };

property interpolate

static interpolate: ExternalReference;

property interpolate1

static interpolate1: ExternalReference;

property interpolate2

static interpolate2: ExternalReference;

property interpolate3

static interpolate3: ExternalReference;

property interpolate4

static interpolate4: ExternalReference;

property interpolate5

static interpolate5: ExternalReference;

property interpolate6

static interpolate6: ExternalReference;

property interpolate7

static interpolate7: ExternalReference;

property interpolate8

static interpolate8: ExternalReference;

property interpolateV

static interpolateV: ExternalReference;

property invalidFactory

static invalidFactory: ExternalReference;

property invalidFactoryDep

static invalidFactoryDep: ExternalReference;

property listener

static listener: ExternalReference;

property loadQuery

static loadQuery: ExternalReference;

property ModuleWithProviders

static ModuleWithProviders: ExternalReference;

property namespaceHTML

static namespaceHTML: ExternalReference;

property namespaceMathML

static namespaceMathML: ExternalReference;

property namespaceSVG

static namespaceSVG: ExternalReference;

property nextContext

static nextContext: ExternalReference;

property NgModuleDeclaration

static NgModuleDeclaration: ExternalReference;

property NgOnChangesFeature

static NgOnChangesFeature: ExternalReference;

property outputDecorator

static outputDecorator: ExternalReference;

property ɵɵdefineInjectable

static ɵɵdefineInjectable: ExternalReference;

property pipe

static pipe: ExternalReference;

property pipeBind1

static pipeBind1: ExternalReference;

property pipeBind2

static pipeBind2: ExternalReference;

property pipeBind3

static pipeBind3: ExternalReference;

property pipeBind4

static pipeBind4: ExternalReference;

property pipeBindV

static pipeBindV: ExternalReference;

property PipeDeclaration

static PipeDeclaration: ExternalReference;

property projection

static projection: ExternalReference;

property projectionDef

static projectionDef: ExternalReference;

property property

static property: ExternalReference;

property ProvidersFeature

static ProvidersFeature: ExternalReference;

property pureFunction0

static pureFunction0: ExternalReference;

property pureFunction1

static pureFunction1: ExternalReference;

property pureFunction2

static pureFunction2: ExternalReference;

property pureFunction3

static pureFunction3: ExternalReference;

property pureFunction4

static pureFunction4: ExternalReference;

property pureFunction5

static pureFunction5: ExternalReference;

property pureFunction6

static pureFunction6: ExternalReference;

property pureFunction7

static pureFunction7: ExternalReference;

property pureFunction8

static pureFunction8: ExternalReference;

property pureFunctionV

static pureFunctionV: ExternalReference;

property queryAdvance

static queryAdvance: ExternalReference;

property queryRefresh

static queryRefresh: ExternalReference;

property readContextLet

static readContextLet: ExternalReference;

property reference

static reference: ExternalReference;

property registerNgModuleType

static registerNgModuleType: ExternalReference;

property repeater

static repeater: ExternalReference;

property repeaterCreate

static repeaterCreate: ExternalReference;

property repeaterTrackByIdentity

static repeaterTrackByIdentity: ExternalReference;

property repeaterTrackByIndex

static repeaterTrackByIndex: ExternalReference;

property replaceMetadata

static replaceMetadata: ExternalReference;

property resetView

static resetView: ExternalReference;

property resolveBody

static resolveBody: ExternalReference;

property resolveDocument

static resolveDocument: ExternalReference;

property resolveForwardRef

static resolveForwardRef: ExternalReference;

property resolveWindow

static resolveWindow: ExternalReference;

property restoreView

static restoreView: ExternalReference;

property sanitizeHtml

static sanitizeHtml: ExternalReference;

property sanitizeResourceUrl

static sanitizeResourceUrl: ExternalReference;

property sanitizeScript

static sanitizeScript: ExternalReference;

property sanitizeStyle

static sanitizeStyle: ExternalReference;

property sanitizeUrl

static sanitizeUrl: ExternalReference;

property sanitizeUrlOrResourceUrl

static sanitizeUrlOrResourceUrl: ExternalReference;

property setClassDebugInfo

static setClassDebugInfo: ExternalReference;

property setClassMetadata

static setClassMetadata: ExternalReference;

property setClassMetadataAsync

static setClassMetadataAsync: ExternalReference;

property setComponentScope

static setComponentScope: ExternalReference;

property setNgModuleScope

static setNgModuleScope: ExternalReference;

property storeLet

static storeLet: ExternalReference;

property styleMap

static styleMap: ExternalReference;

property styleProp

static styleProp: ExternalReference;

property syntheticHostListener

static syntheticHostListener: ExternalReference;

property syntheticHostProperty

static syntheticHostProperty: ExternalReference;

property templateCreate

static templateCreate: ExternalReference;

property templateRefExtractor

static templateRefExtractor: ExternalReference;

property text

static text: ExternalReference;

property textInterpolate

static textInterpolate: ExternalReference;

property textInterpolate1

static textInterpolate1: ExternalReference;

property textInterpolate2

static textInterpolate2: ExternalReference;

property textInterpolate3

static textInterpolate3: ExternalReference;

property textInterpolate4

static textInterpolate4: ExternalReference;

property textInterpolate5

static textInterpolate5: ExternalReference;

property textInterpolate6

static textInterpolate6: ExternalReference;

property textInterpolate7

static textInterpolate7: ExternalReference;

property textInterpolate8

static textInterpolate8: ExternalReference;

property textInterpolateV

static textInterpolateV: ExternalReference;

property trustConstantHtml

static trustConstantHtml: ExternalReference;

property trustConstantResourceUrl

static trustConstantResourceUrl: ExternalReference;

property twoWayBindingSet

static twoWayBindingSet: ExternalReference;

property twoWayListener

static twoWayListener: ExternalReference;

property twoWayProperty

static twoWayProperty: ExternalReference;

property UnwrapDirectiveSignalInputs

static UnwrapDirectiveSignalInputs: { name: string; moduleName: string };

property unwrapWritableSignal

static unwrapWritableSignal: { name: string; moduleName: string };

property validateAttribute

static validateAttribute: ExternalReference;

property viewChildDecorator

static viewChildDecorator: ExternalReference;

property viewChildrenDecorator

static viewChildrenDecorator: ExternalReference;

property ViewEncapsulation

static ViewEncapsulation: ExternalReference;

property viewQuery

static viewQuery: ExternalReference;

property viewQuerySignal

static viewQuerySignal: ExternalReference;

class R3TargetBinder

class R3TargetBinder<DirectiveT extends DirectiveMeta>
    implements TargetBinder<DirectiveT> {}

Processes Targets with a given set of directives and performs a binding operation, which returns an object similar to TypeScript's ts.TypeChecker that contains knowledge about the target.

constructor

constructor(directiveMatcher: DirectiveMatcher<DirectiveT>);

method bind

bind: (target: Target<DirectiveT>) => BoundTarget<DirectiveT>;

Perform a binding operation on the given Target and return a BoundTarget which contains metadata about the types referenced in the template.

class ReadKeyExpr

class ReadKeyExpr extends Expression {}

constructor

constructor(
    receiver: Expression,
    index: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[],
    isOptional?: boolean
);

property index

index: Expression;

property isOptional

isOptional: boolean;

Whether the property access uses the optional-chaining operator (?.[).

property receiver

receiver: Expression;

method clone

clone: () => ReadKeyExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method set

set: (value: Expression) => BinaryOperatorExpr;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class ReadPropExpr

class ReadPropExpr extends Expression {}

constructor

constructor(
    receiver: Expression,
    name: string,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[],
    isOptional?: boolean
);

property index

readonly index: string;

property isOptional

isOptional: boolean;

Whether the property access uses the optional-chaining operator (?.).

property name

name: string;

property receiver

receiver: Expression;

method clone

clone: () => ReadPropExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method set

set: (value: Expression) => BinaryOperatorExpr;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class ReadVarExpr

class ReadVarExpr extends Expression {}

constructor

constructor(
    name: string,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property name

name: string;

method clone

clone: () => ReadVarExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method set

set: (value: Expression) => BinaryOperatorExpr;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class RecursiveAstVisitor

class RecursiveAstVisitor implements AstVisitor {}

method visit

visit: (ast: AST, context?: any) => any;

method visitAll

visitAll: (asts: AST[], context: any) => any;

method visitArrowFunction

visitArrowFunction: (ast: ArrowFunction, context: any) => any;

method visitBinary

visitBinary: (ast: Binary, context: any) => any;

method visitCall

visitCall: (ast: Call, context: any) => any;

method visitChain

visitChain: (ast: Chain, context: any) => any;

method visitConditional

visitConditional: (ast: Conditional, context: any) => any;

method visitEmptyExpr

visitEmptyExpr: (ast: EmptyExpr, context: any) => any;

method visitImplicitReceiver

visitImplicitReceiver: (ast: ThisReceiver, context: any) => any;

method visitInterpolation

visitInterpolation: (ast: Interpolation, context: any) => any;

method visitKeyedRead

visitKeyedRead: (ast: KeyedRead, context: any) => any;

method visitLiteralArray

visitLiteralArray: (ast: LiteralArray, context: any) => any;

method visitLiteralMap

visitLiteralMap: (ast: LiteralMap, context: any) => any;

method visitLiteralPrimitive

visitLiteralPrimitive: (ast: LiteralPrimitive, context: any) => any;

method visitNonNullAssert

visitNonNullAssert: (ast: NonNullAssert, context: any) => any;

method visitParenthesizedExpression

visitParenthesizedExpression: (
    ast: ParenthesizedExpression,
    context: any
) => void;

method visitPipe

visitPipe: (ast: BindingPipe, context: any) => any;

method visitPrefixNot

visitPrefixNot: (ast: PrefixNot, context: any) => any;

method visitPropertyRead

visitPropertyRead: (ast: PropertyRead, context: any) => any;

method visitRegularExpressionLiteral

visitRegularExpressionLiteral: (
    ast: RegularExpressionLiteral,
    context: any
) => void;

method visitSafeCall

visitSafeCall: (ast: SafeCall, context: any) => any;

method visitSafeKeyedRead

visitSafeKeyedRead: (ast: SafeKeyedRead, context: any) => any;

method visitSafePropertyRead

visitSafePropertyRead: (ast: SafePropertyRead, context: any) => any;

method visitSpreadElement

visitSpreadElement: (ast: SpreadElement, context: any) => void;

method visitTaggedTemplateLiteral

visitTaggedTemplateLiteral: (ast: TaggedTemplateLiteral, context: any) => void;

method visitTemplateLiteral

visitTemplateLiteral: (ast: TemplateLiteral, context: any) => void;

method visitTemplateLiteralElement

visitTemplateLiteralElement: (ast: TemplateLiteralElement, context: any) => void;

method visitThisReceiver

visitThisReceiver: (ast: ThisReceiver, context: any) => any;

method visitTypeofExpression

visitTypeofExpression: (ast: TypeofExpression, context: any) => void;

method visitUnary

visitUnary: (ast: Unary, context: any) => any;

method visitVoidExpression

visitVoidExpression: (ast: VoidExpression, context: any) => void;

class RecursiveVisitor

class RecursiveVisitor$1 implements Visitor$1 {}

constructor

constructor();

method visitAttribute

visitAttribute: (ast: Attribute, context: any) => any;

method visitBlock

visitBlock: (block: Block, context: any) => any;

method visitBlockParameter

visitBlockParameter: (ast: BlockParameter, context: any) => any;

method visitComment

visitComment: (ast: Comment$1, context: any) => any;

method visitComponent

visitComponent: (component: Component$1, context: any) => void;

method visitDirective

visitDirective: (directive: Directive$1, context: any) => void;

method visitElement

visitElement: (ast: Element$1, context: any) => any;

method visitExpansion

visitExpansion: (ast: Expansion, context: any) => any;

method visitExpansionCase

visitExpansionCase: (ast: ExpansionCase, context: any) => any;

method visitLetDeclaration

visitLetDeclaration: (decl: LetDeclaration$1, context: any) => void;

method visitText

visitText: (ast: Text$1, context: any) => any;

class RegularExpressionLiteral

class RegularExpressionLiteral extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    body: string,
    flags: string
);

property body

readonly body: string;

property flags

readonly flags: string;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class RegularExpressionLiteralExpr

class RegularExpressionLiteralExpr extends Expression {}

constructor

constructor(
    body: string,
    flags: string,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property body

body: string;

property flags

flags: string;

method clone

clone: () => RegularExpressionLiteralExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class ResourceLoader

abstract class ResourceLoader {}

An interface for retrieving documents by URL that the compiler uses to load templates.
This is an abstract class, rather than an interface, so that it can be used as injection token.

method get

abstract get: (url: string) => Promise<string> | string;

class ReturnStatement

class ReturnStatement extends Statement {}

constructor

constructor(
    value: Expression,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property value

value: Expression;

method isEquivalent

isEquivalent: (stmt: Statement) => boolean;

method visitStatement

visitStatement: (visitor: StatementVisitor, context: any) => any;

class SafeCall

class SafeCall extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    receiver: AST,
    args: AST[],
    argumentSpan: AbsoluteSourceSpan
);

property args

args: AST[];

property argumentSpan

argumentSpan: AbsoluteSourceSpan;

property receiver

receiver: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class SafeKeyedRead

class SafeKeyedRead extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    receiver: AST,
    key: AST
);

property key

key: AST;

property receiver

receiver: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class SafePropertyRead

class SafePropertyRead extends ASTWithName {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    nameSpan: AbsoluteSourceSpan,
    receiver: AST,
    name: string
);

property name

name: string;

property receiver

receiver: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class SelectorContext

class SelectorContext<T = any> {}

constructor

constructor(
    selector: CssSelector,
    cbContext: {},
    listContext: SelectorListContext
);

property cbContext

cbContext: {};

property listContext

listContext: SelectorListContext;

property notSelectors

notSelectors: CssSelector[];

property selector

selector: CssSelector;

method finalize

finalize: (
    cssSelector: CssSelector,
    callback: (c: CssSelector, a: T) => void
) => boolean;

class SelectorlessMatcher

class SelectorlessMatcher<T = unknown> {}

constructor

constructor(registry: Map<string, T[]>);

method match

match: (name: string) => T[];

class SelectorListContext

class SelectorListContext {}

constructor

constructor(selectors: CssSelector[]);

property alreadyMatched

alreadyMatched: boolean;

property selectors

selectors: CssSelector[];

class SelectorMatcher

class SelectorMatcher<T = any> {}

Reads a list of CssSelectors and allows to calculate which ones are contained in a given CssSelector.

method addSelectables

addSelectables: (cssSelectors: CssSelector[], callbackCtxt?: T) => void;

method createNotMatcher

static createNotMatcher: (notSelectors: CssSelector[]) => SelectorMatcher<null>;

method match

match: (
    cssSelector: CssSelector,
    matchedCallback: (c: CssSelector, a: T) => void
) => boolean;

Find the objects that have been added via addSelectable whose css selector is contained in the given css selector.
Parameter cssSelector
A css selector
Parameter matchedCallback
This callback will be called with the object handed into addSelectable boolean true if a match was found

class Serializer

abstract class Serializer {}

method createNameMapper

createNameMapper: (message: Message) => PlaceholderMapper | null;

method digest

abstract digest: (message: Message) => string;

method load

abstract load: (
    content: string,
    url: string
) => { locale: string | null; i18nNodesByMsgId: { [msgId: string]: Node$2[] } };

method write

abstract write: (messages: Message[], locale: string | null) => string;

class SplitInterpolation

class SplitInterpolation {}

constructor

constructor(
    strings: InterpolationPiece[],
    expressions: InterpolationPiece[],
    offsets: number[]
);

property expressions

expressions: InterpolationPiece[];

property offsets

offsets: number[];

property strings

strings: InterpolationPiece[];

class SpreadElement

class SpreadElement extends AST {}

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, expression: AST);

property expression

readonly expression: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class SpreadElementExpr

class SpreadElementExpr extends Expression {}

constructor

constructor(
    expression: Expression,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property expression

expression: Expression;

method clone

clone: () => SpreadElementExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class Statement

abstract class Statement {}

constructor

constructor(
    modifiers?: StmtModifier,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property leadingComments

leadingComments?: LeadingComment[];

property modifiers

modifiers: StmtModifier;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

method addLeadingComment

addLeadingComment: (leadingComment: LeadingComment) => void;

method hasModifier

hasModifier: (modifier: StmtModifier) => boolean;

method isEquivalent

abstract isEquivalent: (stmt: Statement) => boolean;

Calculates whether this statement produces the same value as the given statement. Note: We don't check Types nor ParseSourceSpans nor function arguments.

method visitStatement

abstract visitStatement: (visitor: StatementVisitor, context: any) => any;

class StringToken

class StringToken extends Token {}

constructor

constructor(index: number, end: number, strValue: string, kind: StringTokenKind);

property kind

readonly kind: StringTokenKind;

class TaggedTemplateLiteral

class TaggedTemplateLiteral extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    tag: AST,
    template: TemplateLiteral
);

property tag

tag: AST;

property template

template: TemplateLiteral;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class TaggedTemplateLiteralExpr

class TaggedTemplateLiteralExpr extends Expression {}

constructor

constructor(
    tag: Expression,
    template: TemplateLiteralExpr,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property tag

tag: Expression;

property template

template: TemplateLiteralExpr;

method clone

clone: () => TaggedTemplateLiteralExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class TcbExpr

class TcbExpr {}

Represents an expression generated within a type check block.

constructor

constructor(source: string);

method addExpressionIdentifier

addExpressionIdentifier: (identifier: ExpressionIdentifier, id?: number) => this;

Tags the expression with an identifier.
Parameter identifier
Identifier to apply to the expression.

method addParseSpanInfo

addParseSpanInfo: (span: AbsoluteSourceSpan | ParseSourceSpan$1) => this;

Adds a synthetic comment to the expression that represents the parse span of the provided node. This comment can later be retrieved as trivia of a node to recover original source locations.
Parameter span
Span from the parser containing the location information.

method markIgnoreDiagnostics

markIgnoreDiagnostics: () => this;

Marks the expression to be ignored for diagnostics.

method print

print: (ignoreComments?: boolean) => string;

Converts the node's current state to a string.
Parameter ignoreComments
Whether the comments associated with the expression should be skipped.

method quoteAndEscape

static quoteAndEscape: (value: string) => string;

Wraps a string value in quotes and escapes relevant characters.

method toString

toString: () => never;

toString implementation meant to catch errors like accidentally writing foo ${expr} bar instead of foo ${expr.print()} bar.

method wrapForTypeChecker

wrapForTypeChecker: () => this;

Wraps the expression in parenthesis such that inserted span comments become attached to the proper node.

class TemplateBindingParseResult

class TemplateBindingParseResult {}

constructor

constructor(
    templateBindings: TemplateBinding[],
    warnings: string[],
    errors: ParseError[]
);

property errors

errors: ParseError[];

property templateBindings

templateBindings: TemplateBinding[];

property warnings

warnings: string[];

class TemplateLiteral

class TemplateLiteral extends AST {}

constructor

constructor(
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    elements: TemplateLiteralElement[],
    expressions: AST[]
);

property elements

elements: TemplateLiteralElement[];

property expressions

expressions: AST[];

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class TemplateLiteralElement

class TemplateLiteralElement extends AST {}

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, text: string);

property text

text: string;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class TemplateLiteralElementExpr

class TemplateLiteralElementExpr extends Expression {}

constructor

constructor(
    text: string,
    sourceSpan?: ParseSourceSpan$1,
    rawText?: string,
    leadingComments?: LeadingComment[]
);

property rawText

readonly rawText: string;

property text

readonly text: string;

method clone

clone: () => TemplateLiteralElementExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class TemplateLiteralExpr

class TemplateLiteralExpr extends Expression {}

constructor

constructor(
    elements: TemplateLiteralElementExpr[],
    expressions: Expression[],
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property elements

elements: TemplateLiteralElementExpr[];

property expressions

expressions: Expression[];

method clone

clone: () => TemplateLiteralExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class Text

class Text$1 extends NodeWithI18n {}

constructor

constructor(
    value: string,
    sourceSpan: ParseSourceSpan$1,
    tokens: InterpolatedTextToken[],
    i18n?: I18nMeta$1
);

property tokens

tokens: InterpolatedTextToken[];

property value

value: string;

method visit

visit: (visitor: Visitor$1, context: any) => any;

class ThisReceiver

class ThisReceiver extends AST {}

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class TmplAstBlockNode

class BlockNode {}

constructor

constructor(
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1
);

property endSourceSpan

endSourceSpan: ParseSourceSpan$1;

property nameSpan

nameSpan: ParseSourceSpan$1;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property startSourceSpan

startSourceSpan: ParseSourceSpan$1;

class TmplAstBoundAttribute

class BoundAttribute implements Node {}

constructor

constructor(
    name: string,
    type: BindingType,
    securityContext: SecurityContext,
    value: AST,
    unit: string,
    sourceSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1,
    valueSpan: ParseSourceSpan$1,
    i18n: I18nMeta$1
);

property i18n

i18n: I18nMeta$1;

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

name: string;

property securityContext

securityContext: SecurityContext;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property type

type: BindingType;

property unit

unit: string;

property value

value: AST;

property valueSpan

valueSpan: ParseSourceSpan$1;

method fromBoundElementProperty

static fromBoundElementProperty: (
    prop: BoundElementProperty,
    i18n?: I18nMeta$1
) => BoundAttribute;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstBoundDeferredTrigger

class BoundDeferredTrigger extends DeferredTrigger {}

constructor

constructor(
    value: AST,
    sourceSpan: ParseSourceSpan$1,
    prefetchSpan: ParseSourceSpan$1,
    whenSourceSpan: ParseSourceSpan$1,
    hydrateSpan: ParseSourceSpan$1
);

property value

value: AST;

class TmplAstBoundEvent

class BoundEvent implements Node {}

constructor

constructor(
    name: string,
    type: ParsedEventType,
    handler: AST,
    target: string,
    phase: string,
    sourceSpan: ParseSourceSpan$1,
    handlerSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1
);

property handler

handler: AST;

property handlerSpan

handlerSpan: ParseSourceSpan$1;

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

name: string;

property phase

phase: string;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property target

target: string;

property type

type: ParsedEventType;

method fromParsedEvent

static fromParsedEvent: (event: ParsedEvent) => BoundEvent;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstBoundText

class BoundText implements Node {}

constructor

constructor(value: AST, sourceSpan: ParseSourceSpan$1, i18n?: I18nMeta$1);

property i18n

i18n?: I18nMeta$1;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property value

value: AST;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstComponent

class Component implements Node {}

constructor

constructor(
    componentName: string,
    tagName: string,
    fullName: string,
    attributes: TextAttribute[],
    inputs: BoundAttribute[],
    outputs: BoundEvent[],
    directives: Directive[],
    children: Node[],
    references: Reference[],
    isSelfClosing: boolean,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property attributes

attributes: TextAttribute[];

property children

children: Node[];

property componentName

componentName: string;

property directives

directives: Directive[];

property endSourceSpan

endSourceSpan: ParseSourceSpan$1;

property fullName

fullName: string;

property i18n

i18n?: I18nMeta$1;

property inputs

inputs: BoundAttribute[];

property isSelfClosing

isSelfClosing: boolean;

property outputs

outputs: BoundEvent[];

property references

references: Reference[];

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property startSourceSpan

startSourceSpan: ParseSourceSpan$1;

property tagName

tagName: string;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstContent

class Content implements Node {}

constructor

constructor(
    selector: string,
    attributes: TextAttribute[],
    children: Node[],
    isSelfClosing: boolean,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property attributes

attributes: TextAttribute[];

property children

children: Node[];

property endSourceSpan

endSourceSpan: ParseSourceSpan$1;

property i18n

i18n?: I18nMeta$1;

property isSelfClosing

isSelfClosing: boolean;

property name

readonly name: string;

property selector

selector: string;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property startSourceSpan

startSourceSpan: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstDeferredBlock

class DeferredBlock extends BlockNode implements Node {}

constructor

constructor(
    children: Node[],
    triggers: DeferredBlockTriggers,
    prefetchTriggers: DeferredBlockTriggers,
    hydrateTriggers: DeferredBlockTriggers,
    placeholder: DeferredBlockPlaceholder,
    loading: DeferredBlockLoading,
    error: DeferredBlockError,
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    mainBlockSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property children

children: Node[];

property error

error: DeferredBlockError;

property hydrateTriggers

readonly hydrateTriggers: Readonly<DeferredBlockTriggers>;

property i18n

i18n?: I18nMeta$1;

property loading

loading: DeferredBlockLoading;

property mainBlockSpan

mainBlockSpan: ParseSourceSpan$1;

property placeholder

placeholder: DeferredBlockPlaceholder;

property prefetchTriggers

readonly prefetchTriggers: Readonly<DeferredBlockTriggers>;

property triggers

readonly triggers: Readonly<DeferredBlockTriggers>;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

method visitAll

visitAll: (visitor: Visitor<unknown>) => void;

class TmplAstDeferredBlockError

class DeferredBlockError extends BlockNode implements Node {}

constructor

constructor(
    children: Node[],
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property children

children: Node[];

property i18n

i18n?: I18nMeta$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstDeferredBlockLoading

class DeferredBlockLoading extends BlockNode implements Node {}

constructor

constructor(
    children: Node[],
    afterTime: number,
    minimumTime: number,
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property afterTime

afterTime: number;

property children

children: Node[];

property i18n

i18n?: I18nMeta$1;

property minimumTime

minimumTime: number;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstDeferredBlockPlaceholder

class DeferredBlockPlaceholder extends BlockNode implements Node {}

constructor

constructor(
    children: Node[],
    minimumTime: number,
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property children

children: Node[];

property i18n

i18n?: I18nMeta$1;

property minimumTime

minimumTime: number;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstDeferredTrigger

abstract class DeferredTrigger implements Node {}

constructor

constructor(
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    prefetchSpan: ParseSourceSpan$1,
    whenOrOnSourceSpan: ParseSourceSpan$1,
    hydrateSpan: ParseSourceSpan$1
);

property hydrateSpan

hydrateSpan: ParseSourceSpan$1;

property nameSpan

nameSpan: ParseSourceSpan$1;

property prefetchSpan

prefetchSpan: ParseSourceSpan$1;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property whenOrOnSourceSpan

whenOrOnSourceSpan: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstDirective

class Directive implements Node {}

constructor

constructor(
    name: string,
    attributes: TextAttribute[],
    inputs: BoundAttribute[],
    outputs: BoundEvent[],
    references: Reference[],
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property attributes

attributes: TextAttribute[];

property endSourceSpan

endSourceSpan: ParseSourceSpan$1;

property i18n

i18n?: I18nMeta$1;

property inputs

inputs: BoundAttribute[];

property name

name: string;

property outputs

outputs: BoundEvent[];

property references

references: Reference[];

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property startSourceSpan

startSourceSpan: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstElement

class Element implements Node {}

constructor

constructor(
    name: string,
    attributes: TextAttribute[],
    inputs: BoundAttribute[],
    outputs: BoundEvent[],
    directives: Directive[],
    children: Node[],
    references: Reference[],
    isSelfClosing: boolean,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    isVoid: boolean,
    i18n?: I18nMeta$1
);

property attributes

attributes: TextAttribute[];

property children

children: Node[];

property directives

directives: Directive[];

property endSourceSpan

endSourceSpan: ParseSourceSpan$1;

property i18n

i18n?: I18nMeta$1;

property inputs

inputs: BoundAttribute[];

property isSelfClosing

isSelfClosing: boolean;

property isVoid

readonly isVoid: boolean;

property name

name: string;

property outputs

outputs: BoundEvent[];

property references

references: Reference[];

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property startSourceSpan

startSourceSpan: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstForLoopBlock

class ForLoopBlock extends BlockNode implements Node {}

constructor

constructor(
    item: Variable,
    expression: ASTWithSource<AST>,
    trackBy: ASTWithSource<AST>,
    trackKeywordSpan: ParseSourceSpan$1,
    contextVariables: Variable[],
    children: Node[],
    empty: ForLoopBlockEmpty,
    sourceSpan: ParseSourceSpan$1,
    mainBlockSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property children

children: Node[];

property contextVariables

contextVariables: Variable[];

property empty

empty: ForLoopBlockEmpty;

property expression

expression: ASTWithSource<AST>;

property i18n

i18n?: I18nMeta$1;

property item

item: Variable;

property mainBlockSpan

mainBlockSpan: ParseSourceSpan$1;

property trackBy

trackBy: ASTWithSource<AST>;

property trackKeywordSpan

trackKeywordSpan: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstForLoopBlockEmpty

class ForLoopBlockEmpty extends BlockNode implements Node {}

constructor

constructor(
    children: Node[],
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property children

children: Node[];

property i18n

i18n?: I18nMeta$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstHostElement

class HostElement implements Node {}

AST node that represents the host element of a directive. This node is used only for type checking purposes and cannot be produced from a user's template.

constructor

constructor(
    tagNames: string[],
    bindings: BoundAttribute[],
    listeners: BoundEvent[],
    sourceSpan: ParseSourceSpan$1
);

property bindings

readonly bindings: BoundAttribute[];

property listeners

readonly listeners: BoundEvent[];

property sourceSpan

readonly sourceSpan: ParseSourceSpan$1;

property tagNames

readonly tagNames: string[];

method visit

visit: <Result>() => Result;

class TmplAstHoverDeferredTrigger

class HoverDeferredTrigger extends DeferredTrigger {}

constructor

constructor(
    reference: string,
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    prefetchSpan: ParseSourceSpan$1,
    onSourceSpan: ParseSourceSpan$1,
    hydrateSpan: ParseSourceSpan$1
);

property reference

reference: string;

class TmplAstIcu

class Icu implements Node {}

constructor

constructor(
    vars: { [name: string]: BoundText },
    placeholders: { [name: string]: BoundText | Text },
    sourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property i18n

i18n?: I18nMeta$1;

property placeholders

placeholders: { [name: string]: BoundText | Text };

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property vars

vars: { [name: string]: BoundText };

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstIdleDeferredTrigger

class IdleDeferredTrigger extends DeferredTrigger {}

constructor

constructor(
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    prefetchSpan: ParseSourceSpan$1,
    onSourceSpan: ParseSourceSpan$1,
    hydrateSpan: ParseSourceSpan$1,
    timeout: number
);

property timeout

timeout: number;

class TmplAstIfBlock

class IfBlock extends BlockNode implements Node {}

constructor

constructor(
    branches: IfBlockBranch[],
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1
);

property branches

branches: IfBlockBranch[];

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstIfBlockBranch

class IfBlockBranch extends BlockNode implements Node {}

constructor

constructor(
    expression: AST,
    children: Node[],
    expressionAlias: Variable,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property children

children: Node[];

property expression

expression: AST;

property expressionAlias

expressionAlias: Variable;

property i18n

i18n?: I18nMeta$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstImmediateDeferredTrigger

class ImmediateDeferredTrigger extends DeferredTrigger {}

class TmplAstInteractionDeferredTrigger

class InteractionDeferredTrigger extends DeferredTrigger {}

constructor

constructor(
    reference: string,
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    prefetchSpan: ParseSourceSpan$1,
    onSourceSpan: ParseSourceSpan$1,
    hydrateSpan: ParseSourceSpan$1
);

property reference

reference: string;

class TmplAstLetDeclaration

class LetDeclaration implements Node {}

constructor

constructor(
    name: string,
    value: AST,
    sourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1,
    valueSpan: ParseSourceSpan$1
);

property name

name: string;

property nameSpan

nameSpan: ParseSourceSpan$1;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property value

value: AST;

property valueSpan

valueSpan: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstNeverDeferredTrigger

class NeverDeferredTrigger extends DeferredTrigger {}

class TmplAstRecursiveVisitor

class RecursiveVisitor implements Visitor<void> {}

method visitBoundAttribute

visitBoundAttribute: (attribute: BoundAttribute) => void;

method visitBoundEvent

visitBoundEvent: (attribute: BoundEvent) => void;

method visitBoundText

visitBoundText: (text: BoundText) => void;

method visitComponent

visitComponent: (component: Component) => void;

method visitContent

visitContent: (content: Content) => void;

method visitDeferredBlock

visitDeferredBlock: (deferred: DeferredBlock) => void;

method visitDeferredBlockError

visitDeferredBlockError: (block: DeferredBlockError) => void;

method visitDeferredBlockLoading

visitDeferredBlockLoading: (block: DeferredBlockLoading) => void;

method visitDeferredBlockPlaceholder

visitDeferredBlockPlaceholder: (block: DeferredBlockPlaceholder) => void;

method visitDeferredTrigger

visitDeferredTrigger: (trigger: DeferredTrigger) => void;

method visitDirective

visitDirective: (directive: Directive) => void;

method visitElement

visitElement: (element: Element) => void;

method visitForLoopBlock

visitForLoopBlock: (block: ForLoopBlock) => void;

method visitForLoopBlockEmpty

visitForLoopBlockEmpty: (block: ForLoopBlockEmpty) => void;

method visitIcu

visitIcu: (icu: Icu) => void;

method visitIfBlock

visitIfBlock: (block: IfBlock) => void;

method visitIfBlockBranch

visitIfBlockBranch: (block: IfBlockBranch) => void;

method visitLetDeclaration

visitLetDeclaration: (decl: LetDeclaration) => void;

method visitReference

visitReference: (reference: Reference) => void;

method visitSwitchBlock

visitSwitchBlock: (block: SwitchBlock) => void;

method visitSwitchBlockCase

visitSwitchBlockCase: (block: SwitchBlockCase) => void;

method visitSwitchBlockCaseGroup

visitSwitchBlockCaseGroup: (block: SwitchBlockCaseGroup) => void;

method visitSwitchExhaustiveCheck

visitSwitchExhaustiveCheck: (block: SwitchExhaustiveCheck) => void;

method visitTemplate

visitTemplate: (template: Template) => void;

method visitText

visitText: (text: Text) => void;

method visitTextAttribute

visitTextAttribute: (attribute: TextAttribute) => void;

method visitUnknownBlock

visitUnknownBlock: (block: UnknownBlock) => void;

method visitVariable

visitVariable: (variable: Variable) => void;

class TmplAstReference

class Reference implements Node {}

constructor

constructor(
    name: string,
    value: string,
    sourceSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1,
    valueSpan?: ParseSourceSpan$1
);

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

name: string;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property value

value: string;

property valueSpan

valueSpan?: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstSwitchBlock

class SwitchBlock extends BlockNode implements Node {}

constructor

constructor(
    expression: AST,
    groups: SwitchBlockCaseGroup[],
    unknownBlocks: UnknownBlock[],
    exhaustiveCheck: SwitchExhaustiveCheck,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1
);

property exhaustiveCheck

exhaustiveCheck: SwitchExhaustiveCheck;

property expression

expression: AST;

property groups

groups: SwitchBlockCaseGroup[];

property unknownBlocks

unknownBlocks: UnknownBlock[];

These blocks are only captured to allow for autocompletion in the language service. They aren't meant to be processed in any other way.

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstSwitchBlockCase

class SwitchBlockCase extends BlockNode implements Node {}

constructor

constructor(
    expression: AST,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1
);

property expression

expression: AST;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstSwitchBlockCaseGroup

class SwitchBlockCaseGroup extends BlockNode implements Node {}

constructor

constructor(
    cases: SwitchBlockCase[],
    children: Node[],
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property cases

cases: SwitchBlockCase[];

property children

children: Node[];

property i18n

i18n?: I18nMeta$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstSwitchExhaustiveCheck

class SwitchExhaustiveCheck extends BlockNode implements Node {}

constructor

constructor(
    expression: AST,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1
);

property expression

expression: AST;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstTemplate

class Template implements Node {}

constructor

constructor(
    tagName: string,
    attributes: TextAttribute[],
    inputs: BoundAttribute[],
    outputs: BoundEvent[],
    directives: Directive[],
    templateAttrs: (BoundAttribute | TextAttribute)[],
    children: Node[],
    references: Reference[],
    variables: Variable[],
    isSelfClosing: boolean,
    sourceSpan: ParseSourceSpan$1,
    startSourceSpan: ParseSourceSpan$1,
    endSourceSpan: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property attributes

attributes: TextAttribute[];

property children

children: Node[];

property directives

directives: Directive[];

property endSourceSpan

endSourceSpan: ParseSourceSpan$1;

property i18n

i18n?: I18nMeta$1;

property inputs

inputs: BoundAttribute[];

property isSelfClosing

isSelfClosing: boolean;

property outputs

outputs: BoundEvent[];

property references

references: Reference[];

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property startSourceSpan

startSourceSpan: ParseSourceSpan$1;

property tagName

tagName: string;

property templateAttrs

templateAttrs: (BoundAttribute | TextAttribute)[];

property variables

variables: Variable[];

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstText

class Text implements Node {}

constructor

constructor(value: string, sourceSpan: ParseSourceSpan$1);

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property value

value: string;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstTextAttribute

class TextAttribute implements Node {}

Represents a text attribute in the template.
valueSpan may not be present in cases where there is no value <div a></div>. keySpan may also not be present for synthetic attributes from ICU expansions.

constructor

constructor(
    name: string,
    value: string,
    sourceSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1,
    valueSpan?: ParseSourceSpan$1,
    i18n?: I18nMeta$1
);

property i18n

i18n?: I18nMeta$1;

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

name: string;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property value

value: string;

property valueSpan

valueSpan?: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstTimerDeferredTrigger

class TimerDeferredTrigger extends DeferredTrigger {}

constructor

constructor(
    delay: number,
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    prefetchSpan: ParseSourceSpan$1,
    onSourceSpan: ParseSourceSpan$1,
    hydrateSpan: ParseSourceSpan$1
);

property delay

delay: number;

class TmplAstUnknownBlock

class UnknownBlock implements Node {}

constructor

constructor(
    name: string,
    sourceSpan: ParseSourceSpan$1,
    nameSpan: ParseSourceSpan$1
);

property name

name: string;

property nameSpan

nameSpan: ParseSourceSpan$1;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstVariable

class Variable implements Node {}

constructor

constructor(
    name: string,
    value: string,
    sourceSpan: ParseSourceSpan$1,
    keySpan: ParseSourceSpan$1,
    valueSpan?: ParseSourceSpan$1
);

property keySpan

readonly keySpan: ParseSourceSpan$1;

property name

name: string;

property sourceSpan

sourceSpan: ParseSourceSpan$1;

property value

value: string;

property valueSpan

valueSpan?: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

class TmplAstViewportDeferredTrigger

class ViewportDeferredTrigger extends DeferredTrigger {}

constructor

constructor(
    reference: string,
    options: LiteralMap,
    nameSpan: ParseSourceSpan$1,
    sourceSpan: ParseSourceSpan$1,
    prefetchSpan: ParseSourceSpan$1,
    onSourceSpan: ParseSourceSpan$1,
    hydrateSpan: ParseSourceSpan$1
);

property options

readonly options: LiteralMap;

property reference

readonly reference: string;

class Token

class Token {}

constructor

constructor(
    index: number,
    end: number,
    type: TokenType,
    numValue: number,
    strValue: string
);

property end

end: number;

property index

index: number;

property numValue

numValue: number;

property strValue

strValue: string;

property type

type: TokenType;

method isCharacter

isCharacter: (code: number) => boolean;

method isError

isError: () => boolean;

method isIdentifier

isIdentifier: () => boolean;

method isKeyword

isKeyword: () => boolean;

method isKeywordAs

isKeywordAs: () => boolean;

method isKeywordFalse

isKeywordFalse: () => boolean;

method isKeywordIn

isKeywordIn: () => boolean;

method isKeywordInstanceOf

isKeywordInstanceOf: () => boolean;

method isKeywordLet

isKeywordLet: () => boolean;

method isKeywordNull

isKeywordNull: () => boolean;

method isKeywordThis

isKeywordThis: () => boolean;

method isKeywordTrue

isKeywordTrue: () => boolean;

method isKeywordTypeof

isKeywordTypeof: () => boolean;

method isKeywordUndefined

isKeywordUndefined: () => boolean;

method isKeywordVoid

isKeywordVoid: () => boolean;

method isNumber

isNumber: () => boolean;

method isOperator

isOperator: (operator: string) => boolean;

method isPrivateIdentifier

isPrivateIdentifier: () => boolean;

method isRegExpBody

isRegExpBody: () => boolean;

method isRegExpFlags

isRegExpFlags: () => boolean;

method isString

isString: () => this is StringToken;

method isTemplateLiteralEnd

isTemplateLiteralEnd: () => this is StringToken;

method isTemplateLiteralInterpolationStart

isTemplateLiteralInterpolationStart: () => boolean;

method isTemplateLiteralPart

isTemplateLiteralPart: () => this is StringToken;

method toNumber

toNumber: () => number;

method toString

toString: () => string | null;

class TransplantedType

class TransplantedType<T> extends Type$1 {}

constructor

constructor(type: {}, modifiers?: TypeModifier);

property type

readonly type: {};

method visitType

visitType: (visitor: TypeVisitor, context: any) => any;

class TreeError

class TreeError extends ParseError {}

constructor

constructor(elementName: string, span: ParseSourceSpan$1, msg: string);

property elementName

elementName: string;

method create

static create: (
    elementName: string | null,
    span: ParseSourceSpan$1,
    msg: string
) => TreeError;

class Type

abstract class Type$1 {}

constructor

constructor(modifiers?: TypeModifier);

property modifiers

modifiers: TypeModifier;

method hasModifier

hasModifier: (modifier: TypeModifier) => boolean;

method visitType

abstract visitType: (visitor: TypeVisitor, context: any) => any;

class TypeofExpr

class TypeofExpr extends Expression {}

constructor

constructor(
    expr: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property expr

expr: Expression;

method clone

clone: () => TypeofExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class TypeofExpression

class TypeofExpression extends AST {}

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, expression: AST);

property expression

expression: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class Unary

class Unary extends Binary {}

For backwards compatibility reasons, Unary inherits from Binary and mimics the binary AST node that was originally used. This inheritance relation can be deleted in some future major, after consumers have been given a chance to fully support Unary.

property expr

expr: AST;

property left

left: never;

property operation

operation: never;

property operator

operator: '+' | '-';

property right

right: never;

method createMinus

static createMinus: (
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    expr: AST
) => Unary;

Creates a unary minus expression "-x", represented as Binary using "0 - x".

method createPlus

static createPlus: (
    span: ParseSpan,
    sourceSpan: AbsoluteSourceSpan,
    expr: AST
) => Unary;

Creates a unary plus expression "+x", represented as Binary using "x - 0".

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class UnaryOperatorExpr

class UnaryOperatorExpr extends Expression {}

constructor

constructor(
    operator: UnaryOperator,
    expr: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    parens?: boolean,
    leadingComments?: LeadingComment[]
);

property expr

expr: Expression;

property operator

operator: UnaryOperator;

property parens

parens: boolean;

method clone

clone: () => UnaryOperatorExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class VariableBinding

class VariableBinding {}

constructor

constructor(
    sourceSpan: AbsoluteSourceSpan,
    key: TemplateBindingIdentifier,
    value: TemplateBindingIdentifier
);

Parameter sourceSpan
entire span of the binding.
Parameter key
name of the LHS along with its span.
Parameter value
optional value for the RHS along with its span.

property key

readonly key: TemplateBindingIdentifier;

property sourceSpan

readonly sourceSpan: AbsoluteSourceSpan;

property value

readonly value: TemplateBindingIdentifier;

class Version

class Version {}

constructor

constructor(full: string);

property full

full: string;

property major

readonly major: string;

property minor

readonly minor: string;

property patch

readonly patch: string;

class VoidExpr

class VoidExpr extends Expression {}

constructor

constructor(
    expr: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property expr

expr: Expression;

method clone

clone: () => VoidExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class VoidExpression

class VoidExpression extends AST {}

constructor

constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, expression: AST);

property expression

expression: AST;

method visit

visit: (visitor: AstVisitor, context?: any) => any;

class WrappedNodeExpr

class WrappedNodeExpr<T> extends Expression {}

constructor

constructor(
    node: {},
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
);

property node

node: {};

method clone

clone: () => WrappedNodeExpr<T>;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

visitExpression: (visitor: ExpressionVisitor, context: any) => any;

class Xliff

class Xliff extends Serializer {}

method digest

digest: (message: Message) => string;

method load

load: (
    content: string,
    url: string
) => { locale: string; i18nNodesByMsgId: { [msgId: string]: Node$2[] } };

method write

write: (messages: Message[], locale: string | null) => string;

class Xliff2

class Xliff2 extends Serializer {}

method digest

digest: (message: Message) => string;

method load

load: (
    content: string,
    url: string
) => { locale: string; i18nNodesByMsgId: { [msgId: string]: Node$2[] } };

method write

write: (messages: Message[], locale: string | null) => string;

class Xmb

class Xmb extends Serializer {}

method createNameMapper

createNameMapper: (message: Message) => PlaceholderMapper;

method digest

digest: (message: Message) => string;

method load

load: (
    content: string,
    url: string
) => { locale: string; i18nNodesByMsgId: { [msgId: string]: Node$2[] } };

method write

write: (messages: Message[], locale: string | null) => string;

class XmlParser

class XmlParser extends Parser$1 {}

constructor

constructor();

method parse

parse: (
    source: string,
    url: string,
    options?: TokenizeOptions
) => ParseTreeResult;

class Xtb

class Xtb extends Serializer {}

method createNameMapper

createNameMapper: (message: Message) => PlaceholderMapper;

method digest

digest: (message: Message) => string;

method load

load: (
    content: string,
    url: string
) => { locale: string; i18nNodesByMsgId: { [msgId: string]: Node$2[] } };

method write

write: (messages: Message[], locale: string | null) => string;

Interfaces

interface AstVisitor

interface AstVisitor {}

method visit

visit: (ast: AST, context?: any) => any;

This function is optionally defined to allow classes that implement this interface to selectively decide if the specified ast should be visited.
Parameter ast
node to visit
Parameter context
context that gets passed to the node and all its children

method visitArrowFunction

visitArrowFunction: (ast: ArrowFunction, context: any) => any;

method visitASTWithSource

visitASTWithSource: (ast: ASTWithSource, context: any) => any;

method visitBinary

visitBinary: (ast: Binary, context: any) => any;

method visitCall

visitCall: (ast: Call, context: any) => any;

method visitChain

visitChain: (ast: Chain, context: any) => any;

method visitConditional

visitConditional: (ast: Conditional, context: any) => any;

method visitEmptyExpr

visitEmptyExpr: (ast: EmptyExpr, context: any) => any;

method visitImplicitReceiver

visitImplicitReceiver: (ast: ImplicitReceiver, context: any) => any;

method visitInterpolation

visitInterpolation: (ast: Interpolation, context: any) => any;

method visitKeyedRead

visitKeyedRead: (ast: KeyedRead, context: any) => any;

method visitLiteralArray

visitLiteralArray: (ast: LiteralArray, context: any) => any;

method visitLiteralMap

visitLiteralMap: (ast: LiteralMap, context: any) => any;

method visitLiteralPrimitive

visitLiteralPrimitive: (ast: LiteralPrimitive, context: any) => any;

method visitNonNullAssert

visitNonNullAssert: (ast: NonNullAssert, context: any) => any;

method visitParenthesizedExpression

visitParenthesizedExpression: (
    ast: ParenthesizedExpression,
    context: any
) => any;

method visitPipe

visitPipe: (ast: BindingPipe, context: any) => any;

method visitPrefixNot

visitPrefixNot: (ast: PrefixNot, context: any) => any;

method visitPropertyRead

visitPropertyRead: (ast: PropertyRead, context: any) => any;

method visitRegularExpressionLiteral

visitRegularExpressionLiteral: (
    ast: RegularExpressionLiteral,
    context: any
) => any;

method visitSafeCall

visitSafeCall: (ast: SafeCall, context: any) => any;

method visitSafeKeyedRead

visitSafeKeyedRead: (ast: SafeKeyedRead, context: any) => any;

method visitSafePropertyRead

visitSafePropertyRead: (ast: SafePropertyRead, context: any) => any;

method visitSpreadElement

visitSpreadElement: (ast: SpreadElement, context: any) => any;

method visitTaggedTemplateLiteral

visitTaggedTemplateLiteral: (ast: TaggedTemplateLiteral, context: any) => any;

method visitTemplateLiteral

visitTemplateLiteral: (ast: TemplateLiteral, context: any) => any;

method visitTemplateLiteralElement

visitTemplateLiteralElement: (ast: TemplateLiteralElement, context: any) => any;

method visitThisReceiver

visitThisReceiver: (ast: ThisReceiver, context: any) => any;

The visitThisReceiver method is declared as optional for backwards compatibility. In an upcoming major release, this method will be made required.

method visitTypeofExpression

visitTypeofExpression: (ast: TypeofExpression, context: any) => any;

method visitUnary

visitUnary: (ast: Unary, context: any) => any;

The visitUnary method is declared as optional for backwards compatibility. In an upcoming major release, this method will be made required.

method visitVoidExpression

visitVoidExpression: (ast: TypeofExpression, context: any) => any;

interface BoundTarget

interface BoundTarget<DirectiveT extends DirectiveMeta> {}

Result of performing the binding operation against a Target.
The original Target is accessible, as well as a suite of methods for extracting binding information regarding the Target.
Parameter DirectiveT
directive metadata type

property target

readonly target: Target<DirectiveT>;

Get the original Target that was bound.

method getConflictingHostDirectiveBindings

getConflictingHostDirectiveBindings: (
    node: DirectiveOwner
) => ConflictingHostDirectiveBinding<DirectiveT>[] | null;

Returns any cases of conflicting host bindings that were detected during directive matching.
Parameter node
Node for which to look up the conflicting bindings.

method getConsumerOfBinding

getConsumerOfBinding: (
    binding: BoundAttribute | BoundEvent | TextAttribute
) => DirectiveT | Element | Template | null;

For a given binding, get the entity to which the binding is being made.
This will either be a directive or the node itself.

method getDeferBlocks

getDeferBlocks: () => DeferredBlock[];

Get a list of all @defer blocks used by the target.

method getDeferredTriggerTarget

getDeferredTriggerTarget: (
    block: DeferredBlock,
    trigger: DeferredTrigger
) => Element | null;

Gets the element that a specific deferred block trigger is targeting.
Parameter block
Block that the trigger belongs to.
Parameter trigger
Trigger whose target is being looked up.

method getDefinitionNodeOfSymbol

getDefinitionNodeOfSymbol: (symbol: TemplateEntity) => ScopedNode | null;

Given a particular Reference or Variable, get the ScopedNode which created it.
All Variables are defined on node, so this will always return a value for a Variable from the Target. Returns null otherwise.

method getDirectivesOfNode

getDirectivesOfNode: (node: DirectiveOwner) => DirectiveT[] | null;

For a given template node (either an Element or a Template), get the set of directives which matched the node, if any.

method getEagerlyUsedDirectives

getEagerlyUsedDirectives: () => DirectiveT[];

Get a list of eagerly used directives from the target. Note: this list *excludes* directives from @defer blocks.

method getEagerlyUsedPipes

getEagerlyUsedPipes: () => string[];

Get a list of eagerly used pipes from the target. Note: this list *excludes* pipes from @defer blocks.

method getEntitiesInScope

getEntitiesInScope: (node: ScopedNode | null) => ReadonlySet<TemplateEntity>;

Get all References and Variables visible within the given ScopedNode (or at the top level, if null is passed).

method getExpressionTarget

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

If the given AST expression refers to a Reference or Variable within the Target, then return that.
Otherwise, returns null.
This is only defined for AST expressions that read or write to a property of an ImplicitReceiver.

method getNestingLevel

getNestingLevel: (node: ScopedNode) => number;

Get the nesting level of a particular ScopedNode.
This starts at 1 for top-level nodes within the Target and increases for nodes nested at deeper levels.

method getReferenceTarget

getReferenceTarget: (ref: Reference) => ReferenceTarget<DirectiveT> | null;

For a given Reference, get the reference's target - either an Element, a Template, or a directive on a particular node.

method getUsedDirectives

getUsedDirectives: () => DirectiveT[];

Get a list of all the directives used by the target, including directives from @defer blocks.

method getUsedPipes

getUsedPipes: () => string[];

Get a list of all the pipes used by the target, including pipes from @defer blocks.

method isDeferred

isDeferred: (node: Element) => boolean;

Whether a given node is located in a @defer block.

method referencedDirectiveExists

referencedDirectiveExists: (name: string) => boolean;

Checks whether a component/directive that was referenced directly in the template exists.
Parameter name
Name of the component/directive.

interface CompileIdentifierMetadata

interface CompileIdentifierMetadata {}

property reference

reference: any;

interface ConflictingHostDirectiveBinding

interface ConflictingHostDirectiveBinding<DirectiveT> {}

Information about a host directive binding that was exposed under conflicting aliases.

property classPropertyName

classPropertyName: string;

Name of the class member that the binding would write into.

property conflictingAliases

conflictingAliases: Set<string>;

Aliases that caused the conflict.

property directive

directive: DirectiveT;

Metadata of the directive that the binding belongs to.

property kind

kind: 'input' | 'output';

Type of the binding.

interface DeclareComponentTemplateInfo

interface DeclareComponentTemplateInfo {}

property content

content: string;

The string contents of the template.
This is the "logical" template string, after expansion of any escaped characters (for inline templates). This may differ from the actual template bytes as they appear in the .ts file.

property inlineTemplateLiteralExpression

inlineTemplateLiteralExpression: Expression | null;

If the template was defined inline by a direct string literal, then this is that literal expression. Otherwise null, if the template was not defined inline or was not a literal.

property isInline

isInline: boolean;

Whether the template was inline (using template) or external (using templateUrl).

property sourceUrl

sourceUrl: string;

A full path to the file which contains the template.
This can be either the original .ts file if the template is inline, or the .html file if an external file was used.

interface DirectiveMeta

interface DirectiveMeta {}

Metadata regarding a directive that's needed to match it against template elements. This is provided by a consumer of the t2 APIs.

property animationTriggerNames

animationTriggerNames: LegacyAnimationTriggerNames | null;

The name of legacy animations that the user defines in the component. Only includes the legacy animation names.

property exportAs

exportAs: string[] | null;

Name under which the directive is exported, if any (exportAs in Angular).
Null otherwise

property inputs

inputs: ClassPropertyMapping;

Set of inputs which this directive claims.
Goes from property names to field names.

property isComponent

isComponent: boolean;

Whether the directive is a component.

property isStructural

isStructural: boolean;

Whether the directive is a structural directive (e.g. <div *ngIf></div>).

property matchSource

matchSource: MatchSource;

Tracks how the directive was matched.

property name

name: string;

Name of the directive class (used for debugging).

property ngContentSelectors

ngContentSelectors: string[] | null;

If the directive is a component, includes the selectors of its ng-content elements.

property outputs

outputs: ClassPropertyMapping;

Set of outputs which this directive claims.
Goes from property names to field names.

property preserveWhitespaces

preserveWhitespaces: boolean;

Whether the template of the component preserves whitespaces.

property ref

ref: {
    /** Key that uniquely identifies the reference. */
    key: string;
};

Reference to the directive declaration site.

property selector

selector: string | null;

The selector for the directive or null if there isn't one.

interface DomSchemaChecker

interface DomSchemaChecker<T> {}

Checks every non-Angular element/property processed in a template and potentially produces diagnostics related to improper usage.
A DomSchemaChecker's job is to check DOM nodes and their attributes written used in templates and produce diagnostics if the nodes don't conform to the DOM specification. It acts as a collector for these diagnostics, and can be queried later to retrieve the list of any that have been generated.

property diagnostics

readonly diagnostics: ReadonlyArray<T>;

Get the diagnostics that have been generated via checkElement and checkProperty calls thus far.

method checkElement

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

Check a non-Angular element and record any diagnostics about it.
Parameter id
Template ID, suitable for resolution with a TcbSourceResolver.
Parameter tagName
Tag name of the element in question
Parameter sourceSpanForDiagnostics
Span that should be used when reporting diagnostics.
Parameter schemas
any active schemas for the template, which might affect the validity of the element.
Parameter hostIsStandalone
Indicates whether the element's host is a standalone component.

method checkHostElementProperty

checkHostElementProperty: (
    id: string,
    element: HostElement,
    name: string,
    span: ParseSourceSpan$1,
    schemas: SchemaMetadata[]
) => void;

Check a property binding on a host element and record any diagnostics about it.
Parameter id
the type check ID, suitable for resolution with a TcbSourceResolver.
Parameter element
the element node in question.
Parameter name
the name of the property being checked.
Parameter span
the source span of the binding.
Parameter schemas
any active schemas for the template, which might affect the validity of the property.

method checkTemplateElementProperty

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

Check a property binding on an element and record any diagnostics about it.
Parameter id
the type check ID, suitable for resolution with a TcbSourceResolver.
Parameter tagName
tag name of the element.
Parameter name
the name of the property being checked.
Parameter span
the source span of the binding. This is redundant with element.attributes but is passed separately to avoid having to look up the particular property name.
Parameter schemas
any active schemas for the template, which might affect the validity of the property.

interface ExpressionVisitor

interface ExpressionVisitor {}

method visitArrowFunctionExpr

visitArrowFunctionExpr: (ast: ArrowFunctionExpr, context: any) => any;

method visitBinaryOperatorExpr

visitBinaryOperatorExpr: (ast: BinaryOperatorExpr, context: any) => any;

method visitCommaExpr

visitCommaExpr: (ast: CommaExpr, context: any) => any;

method visitConditionalExpr

visitConditionalExpr: (ast: ConditionalExpr, context: any) => any;

method visitDynamicImportExpr

visitDynamicImportExpr: (ast: DynamicImportExpr, context: any) => any;

method visitExternalExpr

visitExternalExpr: (ast: ExternalExpr, context: any) => any;

method visitFunctionExpr

visitFunctionExpr: (ast: FunctionExpr, context: any) => any;

method visitInstantiateExpr

visitInstantiateExpr: (ast: InstantiateExpr, context: any) => any;

method visitInvokeFunctionExpr

visitInvokeFunctionExpr: (ast: InvokeFunctionExpr, context: any) => any;

method visitLiteralArrayExpr

visitLiteralArrayExpr: (ast: LiteralArrayExpr, context: any) => any;

method visitLiteralExpr

visitLiteralExpr: (ast: LiteralExpr, context: any) => any;

method visitLiteralMapExpr

visitLiteralMapExpr: (ast: LiteralMapExpr, context: any) => any;

method visitLocalizedString

visitLocalizedString: (ast: LocalizedString, context: any) => any;

method visitNotExpr

visitNotExpr: (ast: NotExpr, context: any) => any;

method visitParenthesizedExpr

visitParenthesizedExpr: (ast: ParenthesizedExpr, context: any) => any;

method visitReadKeyExpr

visitReadKeyExpr: (ast: ReadKeyExpr, context: any) => any;

method visitReadPropExpr

visitReadPropExpr: (ast: ReadPropExpr, context: any) => any;

method visitReadVarExpr

visitReadVarExpr: (ast: ReadVarExpr, context: any) => any;

method visitRegularExpressionLiteral

visitRegularExpressionLiteral: (
    ast: RegularExpressionLiteralExpr,
    context: any
) => any;

method visitSpreadElementExpr

visitSpreadElementExpr: (ast: SpreadElementExpr, context: any) => any;

method visitTaggedTemplateLiteralExpr

visitTaggedTemplateLiteralExpr: (
    ast: TaggedTemplateLiteralExpr,
    context: any
) => any;

method visitTemplateLiteralElementExpr

visitTemplateLiteralElementExpr: (
    ast: TemplateLiteralElementExpr,
    context: any
) => any;

method visitTemplateLiteralExpr

visitTemplateLiteralExpr: (ast: TemplateLiteralExpr, context: any) => any;

method visitTypeofExpr

visitTypeofExpr: (ast: TypeofExpr, context: any) => any;

method visitUnaryOperatorExpr

visitUnaryOperatorExpr: (ast: UnaryOperatorExpr, context: any) => any;

method visitVoidExpr

visitVoidExpr: (ast: VoidExpr, context: any) => any;

method visitWrappedNodeExpr

visitWrappedNodeExpr: (ast: WrappedNodeExpr<any>, context: any) => any;

interface HostBindingDecorator

interface HostBindingDecorator {}

A single binding declared by the @HostBinding decorator on a class member.

property arguments

arguments: SourceNode[];

Arguments passed into the decorator

property decoratorSpan

decoratorSpan: ParseSourceSpan$1;

Location information about the decorator.

property memberName

memberName: StaticSourceNode;

Node representing the name of the member that was decorated.

property memberSpan

memberSpan: ParseSourceSpan$1;

Location information about the member that the decorator is set on.

interface HostListenerDecorator

interface HostListenerDecorator {}

A single binding declared by a @HostListener decorator on a class member.

property arguments

arguments: SourceNode[];

Arguments passed to the event.

property decoratorSpan

decoratorSpan: ParseSourceSpan$1;

Location information about the decorator.

property eventName

eventName: SourceNode | null;

Node declaring the name of the event (e.g. first argument of @HostListener).

property memberName

memberName: StaticSourceNode;

Node representing the name of the member that was decorated.

property memberSpan

memberSpan: ParseSourceSpan$1;

Location information about the member that the decorator is set on.

interface HostObjectLiteralBinding

interface HostObjectLiteralBinding {}

A single binding inside the host object of a directive.

property key

key: SourceNode;

Node representing the key of the binding.

property sourceSpan

sourceSpan: ParseSourceSpan$1;

Location information about the entire binding.

property value

value: SourceNode;

Node representing the value of the binding.

interface InputOrOutput

interface InputOrOutput {}

An input or output of a directive that has both a named JavaScript class property on a component or directive class, as well as an Angular template property name used for binding.

property bindingPropertyName

readonly bindingPropertyName: BindingPropertyName;

The property name used to bind this input or output in an Angular template.

property classPropertyName

readonly classPropertyName: ClassPropertyName;

The name of the JavaScript property on the component or directive instance for this input or output.

property isSignal

readonly isSignal: boolean;

Whether the input or output is signal based.

interface InterpolationPiece

interface InterpolationPiece {}

property end

end: number;

property start

start: number;

property text

text: string;

interface LegacyAnimationTriggerNames

interface LegacyAnimationTriggerNames {}

A data structure which captures the animation trigger names that are statically resolvable and whether some names could not be statically evaluated.

property includesDynamicAnimations

includesDynamicAnimations: boolean;

property staticTriggerNames

staticTriggerNames: string[];

interface LexerRange

interface LexerRange {}

property endPos

endPos: number;

property startCol

startCol: number;

property startLine

startLine: number;

property startPos

startPos: number;

interface LiteralMapPropertyKey

interface LiteralMapPropertyKey {}

property isShorthandInitialized

isShorthandInitialized?: boolean;

property key

key: string;

property kind

kind: 'property';

property quoted

quoted: boolean;

property sourceSpan

sourceSpan: AbsoluteSourceSpan;

property span

span: ParseSpan;

interface LiteralMapSpreadKey

interface LiteralMapSpreadKey {}

property kind

kind: 'spread';

property sourceSpan

sourceSpan: AbsoluteSourceSpan;

property span

span: ParseSpan;

interface MaybeForwardRefExpression

interface MaybeForwardRefExpression<T extends Expression = Expression> {}

Describes an expression that may have been wrapped in a forwardRef() guard.
This is used when describing expressions that can refer to types that may eagerly reference types that have not yet been defined.

property expression

expression: T;

The unwrapped expression.

property forwardRef

forwardRef: ForwardRefHandling;

Specified whether the expression contains a reference to something that has not yet been defined, and whether the expression is still wrapped in a forwardRef() call.
If this value is ForwardRefHandling.None then the expression is safe to use as-is.
Otherwise the expression was wrapped in a call to forwardRef() and must not be eagerly evaluated. Instead it must be wrapped in a function closure that will be evaluated lazily to allow the definition of the expression to be evaluated first.
In full AOT compilation it can be safe to unwrap the forwardRef() call up front if the expression will actually be evaluated lazily inside a function call after the value of expression has been defined.
But in other cases, such as partial AOT compilation or JIT compilation the expression will be evaluated eagerly in top level code so will need to continue to be wrapped in a forwardRef() call.

interface OutOfBandDiagnosticRecorder

interface OutOfBandDiagnosticRecorder<T> {}

Collects diagnostics on problems which occur in the template which aren't directly sourced from type check blocks.
During the creation of a type check block, the template is traversed and the OutOfBandDiagnosticRecorder is called to record cases when a correct interpretation for the template cannot be found. These operations create diagnostics which are stored by the recorder for later display.

property diagnostics

readonly diagnostics: ReadonlyArray<T>;

method conflictingDeclaration

conflictingDeclaration: (id: TypeCheckId, current: LetDeclaration) => void;

Reports a @let declaration that conflicts with another symbol in the same scope.
Parameter id
the type-checking ID of the template which contains the declaration.
Parameter current
the LetDeclaration which is invalid.

method conflictingHostDirectiveBinding

conflictingHostDirectiveBinding: (
    id: TypeCheckId,
    node: Element | Template | Component | Directive,
    directiveName: string,
    kind: 'input' | 'output',
    classPropertyName: string,
    aliases: string[]
) => void;

Reports that a host directive input/output has been exposed under multiple names.
Parameter id
Type checking ID of the template in which the host directive was used.
Parameter node
Node on which the host directive was used.
Parameter directiveName
Name of the host directive.
Parameter kind
Type of the conflicting binding.
Parameter classPropertyName
Name of the class member that declares the input/output.
Parameter aliases
Aliases under which the binding is exposed.

method controlFlowPreventingContentProjection

controlFlowPreventingContentProjection: (
    id: TypeCheckId,
    category: OutOfBandDiagnosticCategory,
    projectionNode: Element | Template,
    componentName: string,
    slotSelector: string,
    controlFlowNode:
        | IfBlockBranch
        | SwitchBlockCase
        | ForLoopBlock
        | ForLoopBlockEmpty,
    preservesWhitespaces: boolean
) => void;

Reports cases where control flow nodes prevent content projection.

method deferImplicitTriggerInvalidPlaceholder

deferImplicitTriggerInvalidPlaceholder: (
    id: TypeCheckId,
    trigger:
        | HoverDeferredTrigger
        | InteractionDeferredTrigger
        | ViewportDeferredTrigger
) => void;

Reports that an implicit deferred trigger is set on a block whose placeholder is not set up correctly (e.g. more than one root node).

method deferImplicitTriggerMissingPlaceholder

deferImplicitTriggerMissingPlaceholder: (
    id: TypeCheckId,
    trigger:
        | HoverDeferredTrigger
        | InteractionDeferredTrigger
        | ViewportDeferredTrigger
) => void;

Reports that an implicit deferred trigger is set on a block that does not have a placeholder.

method deferredComponentUsedEagerly

deferredComponentUsedEagerly: (id: TypeCheckId, element: Element) => void;

Reports usage of a component/directive imported via @Component.deferredImports outside of a @defer block in a template.
Parameter id
the type-checking ID of the template which contains the unknown pipe.
Parameter element
the element which hosts a component that was defer-loaded.

method deferredPipeUsedEagerly

deferredPipeUsedEagerly: (id: TypeCheckId, ast: BindingPipe) => void;

Reports usage of a pipe imported via @Component.deferredImports outside of a @defer block in a template.
Parameter id
the type-checking ID of the template which contains the unknown pipe.
Parameter ast
the BindingPipe invocation of the pipe which could not be found.

method duplicateTemplateVar

duplicateTemplateVar: (
    id: TypeCheckId,
    variable: Variable,
    firstDecl: Variable
) => void;

Reports a duplicate declaration of a template variable.
Parameter id
the type-checking ID of the template which contains the duplicate declaration.
Parameter variable
the Variable which duplicates a previously declared variable.
Parameter firstDecl
the first variable declaration which uses the same name as variable.

method formFieldUnsupportedBinding

formFieldUnsupportedBinding: (
    id: TypeCheckId,
    node: BoundAttribute | TextAttribute
) => void;

Reports an unsupported binding on a form FormField node.

method illegalForLoopTrackAccess

illegalForLoopTrackAccess: (
    id: TypeCheckId,
    block: ForLoopBlock,
    access: PropertyRead
) => void;

Reports accesses of properties that aren't available in a for block's tracking expression.

method illegalWriteToLetDeclaration

illegalWriteToLetDeclaration: (
    id: TypeCheckId,
    node: AST,
    target: LetDeclaration
) => void;

Reports cases where users are writing to @let declarations.

method inaccessibleDeferredTriggerElement

inaccessibleDeferredTriggerElement: (
    id: TypeCheckId,
    trigger:
        | HoverDeferredTrigger
        | InteractionDeferredTrigger
        | ViewportDeferredTrigger
) => void;

Reports deferred triggers that cannot access the element they're referring to.

method incorrectTemplateDependencyType

incorrectTemplateDependencyType: (
    id: TypeCheckId,
    node: Component | Directive
) => void;

Reports that a templace dependency of the wrong kind has been referenced at a specific position (e.g. <SomeDirective/>).
Parameter id
Type checking ID of the template in which the dependency is declared.
Parameter node
Node that declares the dependency.

method letUsedBeforeDefinition

letUsedBeforeDefinition: (
    id: TypeCheckId,
    node: PropertyRead,
    target: LetDeclaration
) => void;

Reports cases where users are accessing an @let before it is defined..

method missingNamedTemplateDependency

missingNamedTemplateDependency: (
    id: TypeCheckId,
    node: Component | Directive
) => void;

Reports that a named template dependency (e.g. <Missing/>) is not available.
Parameter id
Type checking ID of the template in which the dependency is declared.
Parameter node
Node that declares the dependency.

method missingPipe

missingPipe: (id: TypeCheckId, ast: BindingPipe, isStandalone: boolean) => void;

Reports usage of a | pipe expression in the template for which the named pipe could not be found.
Parameter id
the type-checking ID of the template which contains the unknown pipe.
Parameter ast
the BindingPipe invocation of the pipe which could not be found.
Parameter isStandalone
whether the host component is standalone.

method missingReferenceTarget

missingReferenceTarget: (id: TypeCheckId, ref: Reference) => void;

Reports a #ref="target" expression in the template for which a target directive could not be found.
Parameter id
the type-checking ID of the template which contains the broken reference.
Parameter ref
the Reference which could not be matched to a directive.

method missingRequiredInputs

missingRequiredInputs: (
    id: TypeCheckId,
    element: Element | Template | Component | Directive,
    directiveName: string,
    isComponent: boolean,
    inputAliases: string[]
) => void;

Reports required inputs that haven't been bound.

method multipleMatchingComponents

multipleMatchingComponents: (
    id: TypeCheckId,
    element: Element,
    componentNames: string[]
) => void;

Reports that multiple components in the compilation scope match a given element.

method splitTwoWayBinding

splitTwoWayBinding: (
    id: TypeCheckId,
    input: BoundAttribute,
    output: BoundEvent,
    inputConsumer: Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'>,
    outputConsumer:
        | Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'>
        | Element
) => void;

Reports a split two way binding error message.

method suboptimalTypeInference

suboptimalTypeInference: (id: TypeCheckId, variables: Variable[]) => void;

Report a warning when structural directives support context guards, but the current type-checking configuration prohibits their usage.

method unclaimedDirectiveBinding

unclaimedDirectiveBinding: (
    id: TypeCheckId,
    directive: Directive,
    node: BoundAttribute | TextAttribute | BoundEvent
) => void;

Reports a binding inside directive syntax that does not match any of the inputs/outputs of the directive.
Parameter id
Type checking ID of the template in which the directive was defined.
Parameter directive
Directive that contains the binding.
Parameter node
Node declaring the binding.

interface ParsedHostBindings

interface ParsedHostBindings {}

property attributes

attributes: Record<string, Expression>;

property listeners

listeners: Record<string, string>;

property properties

properties: Record<string, string>;

property specialAttributes

specialAttributes: {
    styleAttr?: string;
    classAttr?: string;
};

interface ParsedTemplate

interface ParsedTemplate {}

Information about the template which was extracted during parsing.
This contains the actual parsed template as well as any metadata collected during its parsing, some of which might be useful for re-parsing the template with different options.

property commentNodes

commentNodes?: Comment[];

Any R3 Comment Nodes extracted from the template when the collectCommentNodes parse template option is enabled.

property errors

errors: ParseError[] | null;

Any errors from parsing the template the first time.
null if there are no errors. Otherwise, the array of errors is guaranteed to be non-empty.

property ngContentSelectors

ngContentSelectors: string[];

Any ng-content selectors extracted from the template.

property nodes

nodes: Node[];

The template AST, parsed from the template.

property preserveWhitespaces

preserveWhitespaces?: boolean;

Include whitespace nodes in the parsed output.

property styles

styles: string[];

Any inline styles extracted from the metadata.

property styleUrls

styleUrls: string[];

Any styleUrls extracted from the metadata.

interface ParseTemplateOptions

interface ParseTemplateOptions {}

Options that can be used to modify how a template is parsed by parseTemplate().

property alwaysAttemptHtmlToR3AstConversion

alwaysAttemptHtmlToR3AstConversion?: boolean;

Whether to always attempt to convert the parsed HTML AST to an R3 AST, despite HTML or i18n Meta parse errors.
This option is useful in the context of the language service, where we want to get as much information as possible, despite any errors in the HTML. As an example, a user may be adding a new tag and expecting autocomplete on that tag. In this scenario, the HTML is in an errored state, as there is an incomplete open tag. However, we're still able to convert the HTML AST nodes to R3 AST nodes in order to provide information for the language service.
Note that even when true the HTML parse and i18n errors are still appended to the errors output, but this is done after converting the HTML AST to R3 AST.

property collectCommentNodes

collectCommentNodes?: boolean;

Include HTML Comment nodes in a top-level comments array on the returned R3 AST.
This option is required by tooling that needs to know the location of comment nodes within the AST. A concrete example is @angular-eslint which requires this in order to enable "eslint-disable" comments within HTML templates, which then allows users to turn off specific rules on a case by case basis, instead of for their whole project within a configuration file.

property enableBlockSyntax

enableBlockSyntax?: boolean;

Whether the @ block syntax is enabled.

property enableI18nLegacyMessageIdFormat

enableI18nLegacyMessageIdFormat?: boolean;

Render $localize message ids with additional legacy message ids.
This option defaults to true but in the future the default will be flipped.
For now set this option to false if you have migrated the translation files to use the new $localize message id format and you are not using compile time translation merging.

property enableLetSyntax

enableLetSyntax?: boolean;

Whether the @let syntax is enabled.

property enableSelectorless

enableSelectorless?: boolean;

Whether the selectorless syntax is enabled.

property escapedString

escapedString?: boolean;

If this text is stored in a JavaScript string, then we have to deal with escape sequences.
**Example 1:**
"abc\"def\nghi"
- The \" must be converted to ". - The \n must be converted to a new line character in a token, but it should not increment the current line for source mapping.
**Example 2:**
"abc\ def"
The line continuation (\ followed by a newline) should be removed from a token but the new line should increment the current line for source mapping.

property i18nNormalizeLineEndingsInICUs

i18nNormalizeLineEndingsInICUs?: boolean;

If this text is stored in an external template (e.g. via templateUrl) then we need to decide whether or not to normalize the line-endings (from \r\n to \n) when processing ICU expressions.
If true then we will normalize ICU expression line endings. The default is false, but this will be switched in a future major release.

property leadingTriviaChars

leadingTriviaChars?: string[];

An array of characters that should be considered as leading trivia. Leading trivia are characters that are not important to the developer, and so should not be included in source-map segments. A common example is whitespace.

property preserveLineEndings

preserveLineEndings?: boolean;

Preserve original line endings instead of normalizing '\r\n' endings to '\n'.

property preserveSignificantWhitespace

preserveSignificantWhitespace?: boolean;

Preserve whitespace significant to rendering.

property preserveWhitespaces

preserveWhitespaces?: boolean;

Include whitespace nodes in the parsed output.

property range

range?: LexerRange;

The start and end point of the text to parse within the source string. The entire source string is parsed if this is not provided.

interface R3ClassDebugInfo

interface R3ClassDebugInfo {}

Info needed for runtime errors related to a class, such as the location in which the class is defined.

property className

className: Expression;

A string literal containing the original class name as appears in its definition.

property filePath

filePath: Expression | null;

A string literal containing the relative path of the file in which the class is defined.
The path is relative to the project root. The compiler does the best effort to find the project root (e.g., using the rootDir of tsconfig), but if it fails this field is set to null, indicating that the file path was failed to be computed. In this case, the downstream consumers of the debug info will usually ignore the lineNumber field as well and just show the className. For security reasons we never show the absolute file path and prefer to just return null here.

property forbidOrphanRendering

forbidOrphanRendering: boolean;

Whether to check if this component is being rendered without its NgModule being loaded into the browser. Such checks is carried out only in dev mode.

property lineNumber

lineNumber: Expression;

A number literal number containing the line number in which this class is defined.

property type

type: Expression;

The class identifier

interface R3ClassMetadata

interface R3ClassMetadata {}

Metadata of a class which captures the original Angular decorators of a class. The original decorators are preserved in the generated code to allow TestBed APIs to recompile the class using the original decorator with a set of overrides applied.

property ctorParameters

ctorParameters: Expression | null;

An expression representing the Angular decorators applied to constructor parameters, or null if there is no constructor.

property decorators

decorators: Expression;

An expression representing the Angular decorators that were applied on the class.

property propDecorators

propDecorators: Expression | null;

An expression representing the Angular decorators that were applied on the properties of the class, or null if no properties have decorators.

property type

type: Expression;

The class type for which the metadata is captured.

interface R3CompiledExpression

interface R3CompiledExpression {}

Result of compilation of a render3 code unit, e.g. component, directive, pipe, etc.

property expression

expression: Expression;

property statements

statements: Statement[];

property type

type: Type$1;

interface R3ComponentMetadata

interface R3ComponentMetadata<DeclarationT extends R3TemplateDependency>
    extends R3DirectiveMetadata {}

Information needed to compile a component for the render3 runtime.

property animations

animations: Expression | null;

A collection of animation triggers that will be used in the component template.

property changeDetection

changeDetection: ChangeDetectionStrategy$1 | Expression | null;

Strategy used for detecting changes in the component.
In global compilation mode the value is ChangeDetectionStrategy if available as it is statically resolved during analysis phase. Whereas in local compilation mode the value is the expression as appears in the decorator.

property declarationListEmitMode

declarationListEmitMode: DeclarationListEmitMode;

Specifies how the 'directives' and/or pipes array, if generated, need to be emitted.

property declarations

declarations: DeclarationT[];

property defer

defer: R3ComponentDeferMetadata;

Metadata related to the deferred blocks in the component's template.

property encapsulation

encapsulation: ViewEncapsulation$1;

An encapsulation policy for the component's styling. Possible values: - ViewEncapsulation.Emulated: Apply modified component styles in order to emulate a native Shadow DOM CSS encapsulation behavior. - ViewEncapsulation.None: Apply component styles globally without any sort of encapsulation. - ViewEncapsulation.ShadowDom: Use the browser's native Shadow DOM API to encapsulate styles.

property externalStyles

externalStyles?: string[];

A collection of style paths for external stylesheets that will be applied and scoped to the component.

property hasDirectiveDependencies

hasDirectiveDependencies: boolean;

Whether any of the component's dependencies are directives.

property i18nUseExternalIds

i18nUseExternalIds: boolean;

Whether translation variable name should contain external message id (used by Closure Compiler's output of goog.getMsg for transition period).

property rawImports

rawImports?: Expression;

The imports expression as appears on the component decorate for standalone component. This field is currently needed only for local compilation, and so in other compilation modes it may not be set. If component has empty array imports then this field is not set.

property relativeContextFilePath

relativeContextFilePath: string;

Path to the .ts file in which this template's generated code will be included, relative to the compilation root. This will be used to generate identifiers that need to be globally unique in certain contexts (such as g3).

property relativeTemplatePath

relativeTemplatePath: string | null;

Relative path to the component's template from the root of the project. Used to generate debugging information.

property styles

styles: string[];

A collection of styling data that will be applied and scoped to the component.

property template

template: {
    /**
     * Parsed nodes of the template.
     */
    nodes: Node[];
    /**
     * Any ng-content selectors extracted from the template. Contains `*` when an ng-content
     * element without selector is present.
     */
    ngContentSelectors: string[];
    /**
     * Whether the template preserves whitespaces from the user's code.
     */
    preserveWhitespaces?: boolean;
};

Information about the component's template.

property viewProviders

viewProviders: Expression | null;

The list of view providers defined in the component.

interface R3DeclareClassMetadata

interface R3DeclareClassMetadata extends R3PartialDeclaration {}

Describes the shape of the object that the ɵɵngDeclareClassMetadata() function accepts.
This interface serves primarily as documentation, as conformance to this interface is not enforced during linking.

property ctorParameters

ctorParameters?: Expression;

Optionally specifies the constructor parameters, their types and the Angular decorators of each parameter. This property is omitted if the class does not have a constructor.

property decorators

decorators: Expression;

The Angular decorators of the class.

property propDecorators

propDecorators?: Expression;

Optionally specifies the Angular decorators applied to the class properties. This property is omitted if no properties have any decorators.

interface R3DeclareClassMetadataAsync

interface R3DeclareClassMetadataAsync extends R3PartialDeclaration {}

Describes the shape of the object that the ɵɵngDeclareClassMetadataAsync() function accepts.
This interface serves primarily as documentation, as conformance to this interface is not enforced during linking.

property resolveDeferredDeps

resolveDeferredDeps: Expression;

Function that loads the deferred dependencies associated with the component.

property resolveMetadata

resolveMetadata: Expression;

Function that, when invoked with the resolved deferred dependencies, will return the class metadata.

interface R3DeclareComponentMetadata

interface R3DeclareComponentMetadata extends R3DeclareDirectiveMetadata {}

Describes the shape of the object that the ɵɵngDeclareComponent() function accepts.

property animations

animations?: Expression;

A collection of animation triggers that will be used in the component template.

property changeDetection

changeDetection?: ChangeDetectionStrategy$1;

Strategy used for detecting changes in the component. Defaults to ChangeDetectionStrategy.OnPush.

property components

components?: R3DeclareDirectiveDependencyMetadata[];

List of components which matched in the template, including sufficient metadata for each directive to attribute bindings and references within the template to each directive specifically, if the runtime instructions support this.

property deferBlockDependencies

deferBlockDependencies?: Expression[];

List of defer block dependency functions, ordered by the appearance of the corresponding deferred block in the template.

property dependencies

dependencies?: R3DeclareTemplateDependencyMetadata[];

List of dependencies which matched in the template, including sufficient metadata for each directive/pipe to attribute bindings and references within the template to each directive specifically, if the runtime instructions support this.

property directives

directives?: R3DeclareDirectiveDependencyMetadata[];

List of directives which matched in the template, including sufficient metadata for each directive to attribute bindings and references within the template to each directive specifically, if the runtime instructions support this.

property encapsulation

encapsulation?: ViewEncapsulation$1;

An encapsulation policy for the component's styling. Defaults to ViewEncapsulation.Emulated.

property isInline

isInline?: boolean;

Whether the template was inline (using template) or external (using templateUrl). Defaults to false.

property pipes

pipes?: {
    [pipeName: string]: Expression | (() => Expression);
};

A map of pipe names to an expression referencing the pipe type (possibly a forward reference wrapped in a forwardRef invocation) which are used in the template.

property preserveWhitespaces

preserveWhitespaces?: boolean;

Whether whitespace in the template should be preserved. Defaults to false.

property styles

styles?: string[];

CSS from inline styles and included styleUrls.

property template

template: Expression;

The component's unparsed template string as opaque expression. The template is represented using either a string literal or template literal without substitutions, but its value is not read directly. Instead, the template parser is given the full source file's text and the range of this expression to parse directly from source.

property viewProviders

viewProviders?: Expression;

The list of view providers defined in the component.

interface R3DeclareDependencyMetadata

interface R3DeclareDependencyMetadata {}

Metadata indicating how a dependency should be injected into a factory.

property attribute

attribute?: boolean;

Whether the dependency is injecting an attribute value. Default: false.

property host

host?: boolean;

Whether the dependency has an qualifier. Default: false,

property optional

optional?: boolean;

Whether the dependency has an qualifier. Default: false,

property self

self?: boolean;

Whether the dependency has an qualifier. Default: false,

property skipSelf

skipSelf?: boolean;

Whether the dependency has an qualifier. Default: false,

property token

token: Expression | null;

An expression representing the token or value to be injected, or null if the dependency is not valid.
If this dependency is due to the @Attribute() decorator, then this is an expression evaluating to the name of the attribute.

interface R3DeclareDirectiveDependencyMetadata

interface R3DeclareDirectiveDependencyMetadata {}

property exportAs

exportAs?: string[];

Names by which this directive exports itself for references.

property inputs

inputs?: string[];

Property names of the directive's inputs.

property kind

kind: 'directive' | 'component';

property outputs

outputs?: string[];

Event names of the directive's outputs.

property selector

selector: string;

Selector of the directive.

property type

type: Expression | (() => Expression);

Reference to the directive class (possibly a forward reference wrapped in a forwardRef invocation).

interface R3DeclareDirectiveMetadata

interface R3DeclareDirectiveMetadata extends R3PartialDeclaration {}

Describes the shape of the object that the ɵɵngDeclareDirective() function accepts.

property controlCreate

controlCreate?: {
    passThroughInput: string | null;
};

property exportAs

exportAs?: string[];

The names by which the directive is exported.

property host

host?: {
    /**
     * A mapping of attribute names to their value expression.
     */
    attributes?: {
        [key: string]: Expression;
    };
    /**
     * A mapping of event names to their unparsed event handler expression.
     */
    listeners: {
        [key: string]: string;
    };
    /**
     * A mapping of bound properties to their unparsed binding expression.
     */
    properties?: {
        [key: string]: string;
    };
    /**
     * The value of the class attribute, if present. This is stored outside of `attributes` as its
     * string value must be known statically.
     */
    classAttribute?: string;
    /**
     * The value of the style attribute, if present. This is stored outside of `attributes` as its
     * string value must be known statically.
     */
    styleAttribute?: string;
};

Information about host bindings present on the component.

property hostDirectives

hostDirectives?: R3DeclareHostDirectiveMetadata[];

Additional directives applied to the directive host.

property inputs

inputs?: {
    [fieldName: string]:
        | {
              classPropertyName: string;
              publicName: string;
              isSignal: boolean;
              isRequired: boolean;
              transformFunction: Expression | null;
          }
        | LegacyInputPartialMapping;
};

A mapping of inputs from class property names to binding property names, or to a tuple of binding property name and class property name if the names are different.

property isSignal

isSignal?: boolean;

Whether the directive is a signal-based directive. Defaults to false.

property isStandalone

isStandalone?: boolean;

Whether the directive is standalone. Defaults to false.

property outputs

outputs?: {
    [classPropertyName: string]: string;
};

A mapping of outputs from class property names to binding property names.

property providers

providers?: Expression;

The list of providers provided by the directive.

property queries

queries?: R3DeclareQueryMetadata[];

Information about the content queries made by the directive.

property selector

selector?: string;

Unparsed selector of the directive.

property usesInheritance

usesInheritance?: boolean;

Whether the directive has an inheritance clause. Defaults to false.

property usesOnChanges

usesOnChanges?: boolean;

Whether the directive implements the ngOnChanges hook. Defaults to false.

property viewQueries

viewQueries?: R3DeclareQueryMetadata[];

Information about the view queries made by the directive.

interface R3DeclareFactoryMetadata

interface R3DeclareFactoryMetadata extends R3PartialDeclaration {}

Describes the shape of the object that the ɵɵngDeclareFactory() function accepts.
This interface serves primarily as documentation, as conformance to this interface is not enforced during linking.

property deps

deps: R3DeclareDependencyMetadata[] | 'invalid' | null;

A collection of dependencies that this factory relies upon.
If this is null, then the type's constructor is nonexistent and will be inherited from an ancestor of the type.
If this is 'invalid', then one or more of the parameters wasn't resolvable and any attempt to use these deps will result in a runtime error.

property target

target: FactoryTarget;

Type of the target being created by the factory.

interface R3DeclareHostDirectiveMetadata

interface R3DeclareHostDirectiveMetadata {}

Describes the shape of the object literal that can be passed in as a part of the hostDirectives array.

property directive

directive: Expression;

property inputs

inputs?: string[];

property outputs

outputs?: string[];

interface R3DeclareInjectableMetadata

interface R3DeclareInjectableMetadata extends R3PartialDeclaration {}

Describes the shape of the object that the ɵɵngDeclareInjectable() function accepts.
This interface serves primarily as documentation, as conformance to this interface is not enforced during linking.

property deps

deps?: R3DeclareDependencyMetadata[];

An array of dependencies to support instantiating this injectable via useClass or useFactory.

property providedIn

providedIn?: Expression;

If provided, specifies that the declared injectable belongs to a particular injector: - InjectorType such as NgModule, - 'root' the root injector - 'any' all injectors. If not provided, then it does not belong to any injector. Must be explicitly listed in the providers of an injector.

property useClass

useClass?: Expression;

If provided, an expression that evaluates to a class to use when creating an instance of this injectable.

property useExisting

useExisting?: Expression;

If provided, an expression that evaluates to a token of another injectable that this injectable aliases.

property useFactory

useFactory?: Expression;

If provided, an expression that evaluates to a function to use when creating an instance of this injectable.

property useValue

useValue?: Expression;

If provided, an expression that evaluates to the value of the instance of this injectable.

interface R3DeclareInjectorMetadata

interface R3DeclareInjectorMetadata extends R3PartialDeclaration {}

Describes the shape of the objects that the ɵɵngDeclareInjector() accepts.

property imports

imports?: Expression[];

The list of imports into the injector.

property providers

providers?: Expression;

The list of providers provided by the injector.

interface R3DeclareNgModuleDependencyMetadata

interface R3DeclareNgModuleDependencyMetadata {}

property kind

kind: 'ngmodule';

property type

type: Expression | (() => Expression);

interface R3DeclareNgModuleMetadata

interface R3DeclareNgModuleMetadata extends R3PartialDeclaration {}

Describes the shape of the objects that the ɵɵngDeclareNgModule() accepts.

property bootstrap

bootstrap?: Expression[];

An array of expressions representing the bootstrap components specified by the module.

property declarations

declarations?: Expression[];

An array of expressions representing the directives and pipes declared by the module.

property exports

exports?: Expression[];

An array of expressions representing the exports of the module.

property id

id?: Expression;

Unique ID or expression representing the unique ID of an NgModule.

property imports

imports?: Expression[];

An array of expressions representing the imports of the module.

property schemas

schemas?: Expression[];

The set of schemas that declare elements to be allowed in the NgModule.

interface R3DeclarePipeDependencyMetadata

interface R3DeclarePipeDependencyMetadata {}

property kind

kind: 'pipe';

property name

name: string;

property type

type: Expression | (() => Expression);

Reference to the pipe class (possibly a forward reference wrapped in a forwardRef invocation).

interface R3DeclarePipeMetadata

interface R3DeclarePipeMetadata extends R3PartialDeclaration {}

Describes the shape of the object that the ɵɵngDeclarePipe() function accepts.
This interface serves primarily as documentation, as conformance to this interface is not enforced during linking.

property isStandalone

isStandalone?: boolean;

Whether the pipe is standalone.
Default: false.

property name

name: string;

The name to use in templates to refer to this pipe.

property pure

pure?: boolean;

Whether this pipe is "pure".
A pure pipe's transform() method is only invoked when its input arguments change.
Default: true.

interface R3DeclareQueryMetadata

interface R3DeclareQueryMetadata {}

property descendants

descendants?: boolean;

Whether to include only direct children or all descendants. Defaults to false.

property emitDistinctChangesOnly

emitDistinctChangesOnly?: boolean;

True to only fire changes if there are underlying changes to the query.

property first

first?: boolean;

Whether to read only the first matching result, or an array of results. Defaults to false.

property isSignal

isSignal: boolean;

Whether the query is signal-based.

property predicate

predicate: Expression | string[];

Either an expression representing a type (possibly wrapped in a forwardRef()) or InjectionToken for the query predicate, or a set of string selectors.

property propertyName

propertyName: string;

Name of the property on the class to update with query results.

property read

read?: Expression;

An expression representing a type to read from each matched node, or null if the default value for a given node is to be returned.

property static

static?: boolean;

Whether or not this query should collect only static results. Defaults to false.
If static is true, the query's results will be set on the component after nodes are created, but before change detection runs. This means that any results that relied upon change detection to run (e.g. results inside *ngIf or *ngFor views) will not be collected. Query results are available in the ngOnInit hook.
If static is false, the query's results will be set on the component after change detection runs. This means that the query results can contain nodes inside *ngIf or *ngFor views, but the results will not be available in the ngOnInit hook (only in the ngAfterContentInit for content hooks and ngAfterViewInit for view hooks).

interface R3DeclareServiceMetadata

interface R3DeclareServiceMetadata extends R3PartialDeclaration {}

Describes the shape of the object that the ɵɵngDeclareService() function accepts.
This interface serves primarily as documentation, as conformance to this interface is not enforced during linking.

property autoProvided

autoProvided?: boolean;

Determines whether the service should be provided automatically or if the user is responsible for providing it.

property factory

factory?: Expression;

If provided, an expression that evaluates to a function to use when creating an instance of this injectable.

interface R3DeferPerBlockDependency

interface R3DeferPerBlockDependency {}

Information about a single dependency of a defer block in PerBlock mode.

property importPath

importPath: string | null;

Import path where this dependency is located.

property isDefaultImport

isDefaultImport: boolean;

Whether the symbol is the default export.

property isDeferrable

isDeferrable: boolean;

Whether this dependency can be defer-loaded.

property symbolName

symbolName: string;

Dependency class name.

property typeReference

typeReference: Expression;

Reference to a dependency.

interface R3DeferPerComponentDependency

interface R3DeferPerComponentDependency {}

Information about a single dependency of a defer block in PerComponent mode.

property importPath

importPath: string;

Import path where this dependency is located.

property isDefaultImport

isDefaultImport: boolean;

Whether the symbol is the default export.

property symbolName

symbolName: string;

Dependency class name.

interface R3DependencyMetadata

interface R3DependencyMetadata {}

property attributeNameType

attributeNameType: Expression | null;

If an decorator is present, this is the literal type of the attribute name, or the unknown type if no literal type is available (e.g. the attribute name is an expression). Otherwise it is null;

property host

host: boolean;

Whether the dependency has an qualifier.

property optional

optional: boolean;

Whether the dependency has an qualifier.

property self

self: boolean;

Whether the dependency has an qualifier.

property skipSelf

skipSelf: boolean;

Whether the dependency has an qualifier.

property token

token: Expression | null;

An expression representing the token or value to be injected. Or null if the dependency could not be resolved - making it invalid.

interface R3DirectiveDependencyMetadata

interface R3DirectiveDependencyMetadata extends R3TemplateDependency {}

Information about a directive that is used in a component template. Only the stable, public facing information of the directive is stored here.

property exportAs

exportAs: string[] | null;

Name under which the directive is exported, if any (exportAs in Angular). Null otherwise.

property inputs

inputs: string[];

The binding property names of the inputs of the directive.

property isComponent

isComponent: boolean;

If true then this directive is actually a component; otherwise it is not.

property kind

kind: R3TemplateDependencyKind.Directive;

property outputs

outputs: string[];

The binding property names of the outputs of the directive.

property selector

selector: string;

The selector of the directive.

interface R3DirectiveMetadata

interface R3DirectiveMetadata {}

Information needed to compile a directive for the render3 runtime.

property controlCreate

controlCreate: {
    passThroughInput: string | null;
} | null;

Whether or not the component or directive uses the private ɵngControlCreate hook.

property deps

deps: R3DependencyMetadata[] | 'invalid' | null;

Dependencies of the directive's constructor.

property exportAs

exportAs: string[] | null;

Reference name under which to export the directive's type in a template, if any.

property host

host: R3HostMetadata;

Mappings indicating how the directive interacts with its host element (host bindings, listeners, etc).

property hostDirectives

hostDirectives: R3HostDirectiveMetadata[] | null;

Additional directives applied to the directive host.

property inputs

inputs: {
    [field: string]: R3InputMetadata;
};

A mapping of inputs from class property names to binding property names, or to a tuple of binding property name and class property name if the names are different.

property isSignal

isSignal: boolean;

Whether or not the component or directive is signal-based.

property isStandalone

isStandalone: boolean;

Whether or not the component or directive is standalone.

property legacyOptionalChaining

legacyOptionalChaining: boolean;

Whether null should be used instead of undefined for optional chaining.

property lifecycle

lifecycle: {
    /**
     * Whether the directive uses NgOnChanges.
     */
    usesOnChanges: boolean;
};

Information about usage of specific lifecycle events which require special treatment in the code generator.

property name

name: string;

Name of the directive type.

property outputs

outputs: {
    [field: string]: string;
};

A mapping of outputs from class property names to binding property names, or to a tuple of binding property name and class property name if the names are different.

property providers

providers: Expression | null;

The list of providers defined in the directive.

property queries

queries: R3QueryMetadata[];

Information about the content queries made by the directive.

property selector

selector: string | null;

Unparsed selector of the directive, or null if there was no selector.

property type

type: R3Reference;

An expression representing a reference to the directive itself.

property typeArgumentCount

typeArgumentCount: number;

Number of generic type parameters of the type itself.

property typeSourceSpan

typeSourceSpan: ParseSourceSpan$1;

A source span for the directive type.

property usesInheritance

usesInheritance: boolean;

Whether or not the component or directive inherits from another class

property viewQueries

viewQueries: R3QueryMetadata[];

Information about the view queries made by the directive.

interface R3HmrMetadata

interface R3HmrMetadata {}

Metadata necessary to compile HMR-related code call.

property className

className: string;

Name of the component class.

property filePath

filePath: string;

File path of the component class.

property localDependencies

localDependencies: {
    name: string;
    runtimeRepresentation: Expression;
}[];

HMR update functions cannot contain imports so any locals the generated code depends on (e.g. references to imports within the same file or imported symbols) have to be passed in as function parameters. This array contains the names and runtime representation of the locals.

property namespaceDependencies

namespaceDependencies: R3HmrNamespaceDependency[];

When the compiler generates new imports, they get produced as namespace imports (e.g. import * as i0 from '@angular/core'). These namespaces have to be captured and passed along to the update callback.

property type

type: Expression;

Component class for which HMR is being enabled.

interface R3HmrNamespaceDependency

interface R3HmrNamespaceDependency {}

HMR dependency on a namespace import.

property assignedName

assignedName: string;

Name under which to refer to the namespace inside HMR-related code. Must be a valid JS identifier.

property moduleName

moduleName: string;

Module name of the import.

interface R3HostDirectiveMetadata

interface R3HostDirectiveMetadata {}

Information needed to compile a host directive for the render3 runtime.

property directive

directive: R3Reference;

An expression representing the host directive class itself.

property inputs

inputs: {
    [publicName: string]: string;
} | null;

Inputs from the host directive that will be exposed on the host.

property isForwardReference

isForwardReference: boolean;

Whether the expression referring to the host directive is a forward reference.

property outputs

outputs: {
    [publicName: string]: string;
} | null;

Outputs from the host directive that will be exposed on the host.

interface R3HostMetadata

interface R3HostMetadata {}

Mappings indicating how the class interacts with its host element (host bindings, listeners, etc).

property attributes

attributes: {
    [key: string]: Expression;
};

A mapping of attribute binding keys to o.Expressions.

property listeners

listeners: {
    [key: string]: string;
};

A mapping of event binding keys to unparsed expressions.

property properties

properties: {
    [key: string]: string;
};

A mapping of property binding keys to unparsed expressions.

property specialAttributes

specialAttributes: {
    styleAttr?: string;
    classAttr?: string;
};

interface R3InjectableMetadata

interface R3InjectableMetadata {}

property deps

deps?: R3DependencyMetadata[];

property name

name: string;

property providedIn

providedIn: MaybeForwardRefExpression;

property type

type: R3Reference;

property typeArgumentCount

typeArgumentCount: number;

property useClass

useClass?: MaybeForwardRefExpression;

property useExisting

useExisting?: MaybeForwardRefExpression;

property useFactory

useFactory?: Expression;

property useValue

useValue?: MaybeForwardRefExpression;

interface R3InjectorMetadata

interface R3InjectorMetadata {}

property imports

imports: Expression[];

property name

name: string;

property providers

providers: Expression | null;

property type

type: R3Reference;

interface R3InputMetadata

interface R3InputMetadata {}

Metadata for an individual input on a directive.

property bindingPropertyName

bindingPropertyName: string;

property classPropertyName

classPropertyName: string;

property isSignal

isSignal: boolean;

property required

required: boolean;

property transformFunction

transformFunction: Expression | null;

Transform function for the input.
Null if there is no transform, or if this is a signal input. Signal inputs capture their transform as part of the InputSignal.

interface R3NgModuleDependencyMetadata

interface R3NgModuleDependencyMetadata extends R3TemplateDependency {}

property kind

kind: R3TemplateDependencyKind.NgModule;

interface R3NgModuleMetadataGlobal

interface R3NgModuleMetadataGlobal extends R3NgModuleMetadataCommon {}

Metadata required by the module compiler in full/partial mode to generate a module def (ɵmod) for a type.

property bootstrap

bootstrap: R3Reference[];

An array of expressions representing the bootstrap components specified by the module.

property containsForwardDecls

containsForwardDecls: boolean;

Whether to generate closure wrappers for bootstrap, declarations, imports, and exports.

property declarations

declarations: R3Reference[];

An array of expressions representing the directives and pipes declared by the module.

property exports

exports: R3Reference[];

An array of expressions representing the exports of the module.

property imports

imports: R3Reference[];

An array of expressions representing the imports of the module.

property includeImportTypes

includeImportTypes: boolean;

Whether or not to include imports in generated type declarations.

property kind

kind: R3NgModuleMetadataKind.Global;

property publicDeclarationTypes

publicDeclarationTypes: Expression[] | null;

Those declarations which should be visible to downstream consumers. If not specified, all declarations are made visible to downstream consumers.

interface R3PartialDeclaration

interface R3PartialDeclaration {}

property minVersion

minVersion: string;

The minimum version of the compiler that can process this partial declaration.

property ngImport

ngImport: Expression;

A reference to the @angular/core ES module, which allows access to all Angular exports, including Ivy instructions.

property type

type: Expression;

Reference to the decorated class, which is subject to this partial declaration.

property version

version: string;

Version number of the Angular compiler that was used to compile this declaration. The linker will be able to detect which version a library is using and interpret its metadata accordingly.

interface R3PipeDependencyMetadata

interface R3PipeDependencyMetadata extends R3TemplateDependency {}

property kind

kind: R3TemplateDependencyKind.Pipe;

property name

name: string;

interface R3PipeMetadata

interface R3PipeMetadata {}

property deps

deps: R3DependencyMetadata[] | null;

Dependencies of the pipe's constructor.

property isStandalone

isStandalone: boolean;

Whether the pipe is standalone.

property name

name: string;

Name of the pipe type.

property pipeName

pipeName: string | null;

Name of the pipe.

property pure

pure: boolean;

Whether the pipe is marked as pure.

property type

type: R3Reference;

An expression representing a reference to the pipe itself.

property typeArgumentCount

typeArgumentCount: number;

Number of generic type parameters of the type itself.

interface R3QueryMetadata

interface R3QueryMetadata {}

Information needed to compile a query (view or content).

property descendants

descendants: boolean;

Whether to include only direct children or all descendants.

property emitDistinctChangesOnly

emitDistinctChangesOnly: boolean;

If the QueryList should fire change event only if actual change to query was computed (vs old behavior where the change was fired whenever the query was recomputed, even if the recomputed query resulted in the same list.)

property first

first: boolean;

Whether to read only the first matching result, or an array of results.

property isSignal

isSignal: boolean;

Whether the query is signal-based.

property predicate

predicate: MaybeForwardRefExpression | string[];

Either an expression representing a type or InjectionToken for the query predicate, or a set of string selectors.
Note: At compile time we split selectors as an optimization that avoids this extra work at runtime creation phase.
Notably, if the selector is not statically analyzable due to an expression, the selectors may need to be split up at runtime.

property propertyName

propertyName: string;

Name of the property on the class to update with query results.

property read

read: Expression | null;

An expression representing a type to read from each matched node, or null if the default value for a given node is to be returned.

property static

static: boolean;

Whether or not this query should collect only static results.
If static is true, the query's results will be set on the component after nodes are created, but before change detection runs. This means that any results that relied upon change detection to run (e.g. results inside *ngIf or *ngFor views) will not be collected. Query results are available in the ngOnInit hook.
If static is false, the query's results will be set on the component after change detection runs. This means that the query results can contain nodes inside *ngIf or *ngFor views, but the results will not be available in the ngOnInit hook (only in the ngAfterContentInit for content hooks and ngAfterViewInit for view hooks).
Note: For signal-based queries, this option does not have any effect.

interface R3Reference

interface R3Reference {}

property type

type: Expression;

property value

value: Expression;

interface R3ServiceMetadata

interface R3ServiceMetadata {}

property autoProvided

autoProvided?: boolean;

property factory

factory?: Expression;

property name

name: string;

property type

type: R3Reference;

property typeArgumentCount

typeArgumentCount: number;

interface R3TemplateDependency

interface R3TemplateDependency {}

A dependency that's used within a component template.

property kind

kind: R3TemplateDependencyKind;

property type

type: Expression;

The type of the dependency as an expression.

interface SchemaMetadata

interface SchemaMetadata {}

property name

name: string;

interface StatementVisitor

interface StatementVisitor {}

method visitDeclareFunctionStmt

visitDeclareFunctionStmt: (stmt: DeclareFunctionStmt, context: any) => any;

method visitDeclareVarStmt

visitDeclareVarStmt: (stmt: DeclareVarStmt, context: any) => any;

method visitExpressionStmt

visitExpressionStmt: (stmt: ExpressionStatement, context: any) => any;

method visitIfStmt

visitIfStmt: (stmt: IfStmt, context: any) => any;

method visitReturnStmt

visitReturnStmt: (stmt: ReturnStatement, context: any) => any;

interface StaticSourceNode

interface StaticSourceNode {}

A SourceNode which represents a static expression.

property kind

kind: 'string' | 'identifier';

property source

source: string;

Raw source code of the node (e.g. strings include the quotes).

property sourceSpan

sourceSpan: ParseSourceSpan$1;

Location information about the node.

property text

text: string;

Actual text of the node (e.g. value inside the quotes in strings).

interface TagDefinition

interface TagDefinition {}

property canSelfClose

canSelfClose: boolean;

property closedByParent

closedByParent: boolean;

property ignoreFirstLf

ignoreFirstLf: boolean;

property implicitNamespacePrefix

implicitNamespacePrefix: string | null;

property isVoid

isVoid: boolean;

property preventNamespaceInheritance

preventNamespaceInheritance: boolean;

method getContentType

getContentType: (prefix?: string) => TagContentType;

method isClosedByChild

isClosedByChild: (name: string) => boolean;

interface Target

interface Target<DirectiveT> {}

A logical target for analysis, which could contain a template or other types of bindings.

property host

host?: {
    node: HostElement;
    directives: DirectiveT[];
};

property template

template?: Node[];

interface TargetBinder

interface TargetBinder<D extends DirectiveMeta> {}

Interface to the binding API, which processes a template and returns an object similar to the ts.TypeChecker.
The returned BoundTarget has an API for extracting information about the processed target.

method bind

bind: (target: Target<D>) => BoundTarget<D>;

interface TcbComponentMetadata

interface TcbComponentMetadata {}

property ref

ref: TcbReferenceMetadata;

property typeArguments

typeArguments: string[] | null;

property typeParameters

typeParameters: TcbTypeParameter[] | null;

interface TcbDirectiveMetadata

interface TcbDirectiveMetadata {}

property animationTriggerNames

animationTriggerNames: LegacyAnimationTriggerNames | null;

property coercedInputFields

coercedInputFields: Set<ClassPropertyName>;

property exportAs

exportAs: string[] | null;

property hasNgFieldDirective

hasNgFieldDirective: boolean;

property hasNgTemplateContextGuard

hasNgTemplateContextGuard: boolean;

property inputs

inputs: ClassPropertyMapping<TcbInputMapping>;

property isComponent

isComponent: boolean;

property isExplicitlyDeferred

isExplicitlyDeferred: boolean;

property isGeneric

isGeneric: boolean;

property isStandalone

isStandalone: boolean;

property isStructural

isStructural: boolean;

property matchSource

matchSource: MatchSource;

property name

name: string;

property ngContentSelectors

ngContentSelectors: string[] | null;

property ngTemplateGuards

ngTemplateGuards: TemplateGuardMeta[];

property outputs

outputs: ClassPropertyMapping;

property preserveWhitespaces

preserveWhitespaces: boolean;

property publicMethods

publicMethods: Set<string>;

property ref

ref: TcbReferenceMetadata;

property requiresInlineTypeCtor

requiresInlineTypeCtor: boolean;

property restrictedInputFields

restrictedInputFields: Set<ClassPropertyName>;

property selector

selector: string | null;

property stringLiteralInputFields

stringLiteralInputFields: Set<ClassPropertyName>;

property typeParameters

typeParameters: TcbTypeParameter[] | null;

Type parameters of the directive, if available.

property undeclaredInputFields

undeclaredInputFields: Set<ClassPropertyName>;

interface TcbEnvironment

interface TcbEnvironment {}

Interface representing the environment needed for TCB generation. This allows us to avoid depending on the full Environment class from compiler-cli which depends on TypeScript APIs.

property config

config: TypeCheckingConfig;

method getPreludeStatements

getPreludeStatements: () => TcbExpr[];

method pipeInst

pipeInst: (pipeMeta: TcbPipeMetadata) => TcbExpr;

method referenceExternalSymbol

referenceExternalSymbol: (moduleName: string, name: string) => TcbExpr;

method referenceTcbValue

referenceTcbValue: (ref: TcbReferenceMetadata) => TcbExpr;

method typeCtorFor

typeCtorFor: (dir: TcbDirectiveMetadata) => TcbExpr;

interface TcbPipeMetadata

interface TcbPipeMetadata {}

property isExplicitlyDeferred

isExplicitlyDeferred: boolean;

property name

name: string;

property ref

ref: TcbReferenceMetadata;

interface TcbReferenceMetadata

interface TcbReferenceMetadata {}

property isLocal

readonly isLocal: boolean;

True if the symbol successfully emitted locally (no external import required)

property key

readonly key: TcbReferenceKey;

Key used to uniquely identify the target of this reference.

property moduleName

readonly moduleName: string | null;

The module path where the symbol is located, or null if local/ambient

property name

readonly name: string;

The name of the class

property nodeFilePath

readonly nodeFilePath?: string;

The absolute path to the file containing the reference node, if available.

property nodeNameSpan

readonly nodeNameSpan?: AbsoluteSourceSpan;

Defines the AbsoluteSourceSpan of the target's node name, if available.

property unexportedDiagnostic

readonly unexportedDiagnostic: string | null;

If the reference could not be externally emitted, this string holds the diagnostic reason why

interface TcbTypeCheckBlockMetadata

interface TcbTypeCheckBlockMetadata {}

property boundTarget

boundTarget: BoundTarget<TcbDirectiveMetadata>;

property id

id: TypeCheckId;

property isStandalone

isStandalone: boolean;

property pipes

pipes: Map<string, TcbPipeMetadata> | null;

property preserveWhitespaces

preserveWhitespaces: boolean;

property schemas

schemas: SchemaMetadata[];

interface TcbTypeParameter

interface TcbTypeParameter {}

property name

name: string;

property representation

representation: string;

property representationWithDefault

representationWithDefault: string;

interface TemplateBindingIdentifier

interface TemplateBindingIdentifier {}

property source

source: string;

property span

span: AbsoluteSourceSpan;

interface TemplateGuardMeta

interface TemplateGuardMeta {}

Metadata that describes a template guard for one of the directive's inputs.

property inputName

inputName: string;

The input name that this guard should be applied to.

property type

type: 'invocation' | 'binding';

Represents the type of the template guard.
- 'invocation' means that a call to the template guard function is emitted so that its return type can result in narrowing of the input type. - 'binding' means that the input binding expression itself is used as template guard.

interface TmplAstDeferredBlockTriggers

interface DeferredBlockTriggers {}

property hover

hover?: HoverDeferredTrigger;

property idle

idle?: IdleDeferredTrigger;

property immediate

immediate?: ImmediateDeferredTrigger;

property interaction

interaction?: InteractionDeferredTrigger;

property never

never?: NeverDeferredTrigger;

property timer

timer?: TimerDeferredTrigger;

property viewport

viewport?: ViewportDeferredTrigger;

property when

when?: BoundDeferredTrigger;

interface TmplAstNode

interface Node {}

property sourceSpan

sourceSpan: ParseSourceSpan$1;

method visit

visit: <Result>(visitor: Visitor<Result>) => Result;

interface TmplAstVisitor

interface Visitor<Result = any> {}

method visit

visit: (node: Node) => Result;

method visitBoundAttribute

visitBoundAttribute: (attribute: BoundAttribute) => Result;

method visitBoundEvent

visitBoundEvent: (attribute: BoundEvent) => Result;

method visitBoundText

visitBoundText: (text: BoundText) => Result;

method visitComponent

visitComponent: (component: Component) => Result;

method visitContent

visitContent: (content: Content) => Result;

method visitDeferredBlock

visitDeferredBlock: (deferred: DeferredBlock) => Result;

method visitDeferredBlockError

visitDeferredBlockError: (block: DeferredBlockError) => Result;

method visitDeferredBlockLoading

visitDeferredBlockLoading: (block: DeferredBlockLoading) => Result;

method visitDeferredBlockPlaceholder

visitDeferredBlockPlaceholder: (block: DeferredBlockPlaceholder) => Result;

method visitDeferredTrigger

visitDeferredTrigger: (trigger: DeferredTrigger) => Result;

method visitDirective

visitDirective: (directive: Directive) => Result;

method visitElement

visitElement: (element: Element) => Result;

method visitForLoopBlock

visitForLoopBlock: (block: ForLoopBlock) => Result;

method visitForLoopBlockEmpty

visitForLoopBlockEmpty: (block: ForLoopBlockEmpty) => Result;

method visitIcu

visitIcu: (icu: Icu) => Result;

method visitIfBlock

visitIfBlock: (block: IfBlock) => Result;

method visitIfBlockBranch

visitIfBlockBranch: (block: IfBlockBranch) => Result;

method visitLetDeclaration

visitLetDeclaration: (decl: LetDeclaration) => Result;

method visitReference

visitReference: (reference: Reference) => Result;

method visitSwitchBlock

visitSwitchBlock: (block: SwitchBlock) => Result;

method visitSwitchBlockCase

visitSwitchBlockCase: (block: SwitchBlockCase) => Result;

method visitSwitchBlockCaseGroup

visitSwitchBlockCaseGroup: (block: SwitchBlockCaseGroup) => Result;

method visitSwitchExhaustiveCheck

visitSwitchExhaustiveCheck: (block: SwitchExhaustiveCheck) => Result;

method visitTemplate

visitTemplate: (template: Template) => Result;

method visitText

visitText: (text: Text) => Result;

method visitTextAttribute

visitTextAttribute: (attribute: TextAttribute) => Result;

method visitUnknownBlock

visitUnknownBlock: (block: UnknownBlock) => Result;

method visitVariable

visitVariable: (variable: Variable) => Result;

interface TypeCheckingConfig

interface TypeCheckingConfig {}

property allowDomEventAssertion

allowDomEventAssertion: boolean;

Whether the type of DOM events should be asserted with '@angular/core' 'ɵassertType'.

property allowSignalsInTwoWayBindings

allowSignalsInTwoWayBindings: boolean;

Whether the type of two-way bindings should be widened to allow WritableSignal.

property alwaysCheckSchemaInTemplateBodies

alwaysCheckSchemaInTemplateBodies: boolean;

Whether to always apply DOM schema checks in template bodies, independently of the checkTemplateBodies setting.

property applyTemplateContextGuards

applyTemplateContextGuards: boolean;

Whether to narrow the types of template contexts.

property checkControlFlowBodies

checkControlFlowBodies: boolean;

Whether to descend into the bodies of control flow blocks (@if, @switch and @for).

property checkQueries

checkQueries: false;

Whether to check resolvable queries.

property checkTemplateBodies

checkTemplateBodies: boolean;

Whether to descend into template bodies and check any bindings there.

property checkTypeOfAnimationEvents

checkTypeOfAnimationEvents: boolean;

Whether to infer the type of the $event variable in event bindings for animations.

property checkTypeOfAttributes

checkTypeOfAttributes: boolean;

Whether to check text attributes that happen to be consumed by a directive or component.

property checkTypeOfDomBindings

checkTypeOfDomBindings: boolean;

Whether to check the left-hand side type of binding operations to DOM properties.

property checkTypeOfDomEvents

checkTypeOfDomEvents: boolean;

Whether to infer the type of the $event variable in event bindings to DOM events.

property checkTypeOfDomReferences

checkTypeOfDomReferences: boolean;

Whether to infer the type of local references to DOM elements.

property checkTypeOfInputBindings

checkTypeOfInputBindings: boolean;

Whether to check the left-hand side type of binding operations.

property checkTypeOfNonDomReferences

checkTypeOfNonDomReferences: boolean;

Whether to infer the type of local references.

property checkTypeOfOutputEvents

checkTypeOfOutputEvents: boolean;

Whether to infer the type of the $event variable in event bindings for directive outputs or animation events.

property checkTypeOfPipes

checkTypeOfPipes: boolean;

Whether to include type information from pipes in the type-checking operation.

property controlFlowPreventingContentProjection

controlFlowPreventingContentProjection: 'error' | 'warning' | 'suppress';

Whether to check if control flow syntax will prevent a node from being projected.

property enableTemplateTypeChecker

enableTemplateTypeChecker: boolean;

Whether to adjust the output of the TCB to ensure compatibility with the TemplateTypeChecker.

property honorAccessModifiersForInputBindings

honorAccessModifiersForInputBindings: boolean;

Whether to honor the access modifiers on input bindings for the component/directive.

property strictLiteralTypes

strictLiteralTypes: boolean;

Whether or not to infer types for object and array literals in the template.

property strictNullInputBindings

strictNullInputBindings: boolean;

Whether to use strict null types for input bindings for directives.

property strictSafeNavigationTypes

strictSafeNavigationTypes: boolean;

Whether to use a strict type for null-safe navigation operations.

property unusedStandaloneImports

unusedStandaloneImports: 'error' | 'warning' | 'suppress';

Whether to check if @Component.imports contains unused symbols.

property useContextGenericType

useContextGenericType: boolean;

Whether to use any generic types of the context component.

property useInlineTypeConstructors

useInlineTypeConstructors: boolean;

Whether to use inline type constructors.

interface TypeCtorMetadata

interface TypeCtorMetadata {}

property body

body: boolean;

Whether to generate a body for the function or not.

property coercedInputFields

coercedInputFields: Set<string>;

Set of field names which have type coercion enabled.

property fields

fields: {
    inputs: ClassPropertyMapping<TcbInputMapping>;
};

Input, output, and query field names in the type which should be included as constructor input.

property fnName

fnName: string;

The name of the requested type constructor function.

interface TypeVisitor

interface TypeVisitor {}

method visitArrayType

visitArrayType: (type: ArrayType, context: any) => any;

method visitBuiltinType

visitBuiltinType: (type: BuiltinType, context: any) => any;

method visitExpressionType

visitExpressionType: (type: ExpressionType, context: any) => any;

method visitMapType

visitMapType: (type: MapType, context: any) => any;

method visitTransplantedType

visitTransplantedType: (type: TransplantedType<unknown>, context: any) => any;

interface Visitor

interface Visitor$1 {}

method visit

visit: (node: Node$1, context: any) => any;

method visitAttribute

visitAttribute: (attribute: Attribute, context: any) => any;

method visitBlock

visitBlock: (block: Block, context: any) => any;

method visitBlockParameter

visitBlockParameter: (parameter: BlockParameter, context: any) => any;

method visitComment

visitComment: (comment: Comment$1, context: any) => any;

method visitComponent

visitComponent: (component: Component$1, context: any) => any;

method visitDirective

visitDirective: (directive: Directive$1, context: any) => any;

method visitElement

visitElement: (element: Element$1, context: any) => any;

method visitExpansion

visitExpansion: (expansion: Expansion, context: any) => any;

method visitExpansionCase

visitExpansionCase: (expansionCase: ExpansionCase, context: any) => any;

method visitLetDeclaration

visitLetDeclaration: (decl: LetDeclaration$1, context: any) => any;

method visitText

visitText: (text: Text$1, context: any) => any;

Enums

enum BinaryOperator

enum BinaryOperator {
    Equals = 0,
    NotEquals = 1,
    Assign = 2,
    Identical = 3,
    NotIdentical = 4,
    Minus = 5,
    Plus = 6,
    Divide = 7,
    Multiply = 8,
    Modulo = 9,
    And = 10,
    Or = 11,
    BitwiseOr = 12,
    BitwiseAnd = 13,
    Lower = 14,
    LowerEquals = 15,
    Bigger = 16,
    BiggerEquals = 17,
    NullishCoalesce = 18,
    Exponentiation = 19,
    In = 20,
    InstanceOf = 21,
    AdditionAssignment = 22,
    SubtractionAssignment = 23,
    MultiplicationAssignment = 24,
    DivisionAssignment = 25,
    RemainderAssignment = 26,
    ExponentiationAssignment = 27,
    AndAssignment = 28,
    OrAssignment = 29,
    NullishCoalesceAssignment = 30,
}

member AdditionAssignment

AdditionAssignment = 22

member And

And = 10

member AndAssignment

AndAssignment = 28

member Assign

Assign = 2

member Bigger

Bigger = 16

member BiggerEquals

BiggerEquals = 17

member BitwiseAnd

BitwiseAnd = 13

member BitwiseOr

BitwiseOr = 12

member Divide

Divide = 7

member DivisionAssignment

DivisionAssignment = 25

member Equals

Equals = 0

member Exponentiation

Exponentiation = 19

member ExponentiationAssignment

ExponentiationAssignment = 27

member Identical

Identical = 3

member In

In = 20

member InstanceOf

InstanceOf = 21

member Lower

Lower = 14

member LowerEquals

LowerEquals = 15

member Minus

Minus = 5

member Modulo

Modulo = 9

member MultiplicationAssignment

MultiplicationAssignment = 24

member Multiply

Multiply = 8

member NotEquals

NotEquals = 1

member NotIdentical

NotIdentical = 4

member NullishCoalesce

NullishCoalesce = 18

member NullishCoalesceAssignment

NullishCoalesceAssignment = 30

member Or

Or = 11

member OrAssignment

OrAssignment = 29

member Plus

Plus = 6

member RemainderAssignment

RemainderAssignment = 26

member SubtractionAssignment

SubtractionAssignment = 23

enum BindingPipeType

enum BindingPipeType {
    ReferencedByName = 0,
    ReferencedDirectly = 1,
}

Possible types for a pipe.

member ReferencedByName

ReferencedByName = 0

Pipe is being referenced by its name, for example: @Pipe({name: 'foo'}) class FooPipe and {{123 | foo}}.

member ReferencedDirectly

ReferencedDirectly = 1

Pipe is being referenced by its class name, for example: @Pipe() class FooPipe and {{123 | FooPipe}}.

enum BindingType

enum BindingType {
    Property = 0,
    Attribute = 1,
    Class = 2,
    Style = 3,
    LegacyAnimation = 4,
    TwoWay = 5,
    Animation = 6,
}

member Animation

Animation = 6

member Attribute

Attribute = 1

member Class

Class = 2

member LegacyAnimation

LegacyAnimation = 4

member Property

Property = 0

member Style

Style = 3

member TwoWay

TwoWay = 5

enum BuiltinTypeName

enum BuiltinTypeName {
    Dynamic = 0,
    Bool = 1,
    String = 2,
    Int = 3,
    Number = 4,
    Function = 5,
    Inferred = 6,
    None = 7,
}

member Bool

Bool = 1

member Dynamic

Dynamic = 0

member Function

Function = 5

member Inferred

Inferred = 6

member Int

Int = 3

member None

None = 7

member Number

Number = 4

member String

String = 2

enum ChangeDetectionStrategy

enum ChangeDetectionStrategy {
    OnPush = 0,
    Default = 1,
    Eager = 1,
}

member Default

Default = 1

member Eager

Eager = 1

member OnPush

OnPush = 0

enum CommentTriviaType

enum CommentTriviaType {
    DIAGNOSTIC = 'D',
    EXPRESSION_TYPE_IDENTIFIER = 'T',
}

Used to identify what type the comment is.

member DIAGNOSTIC

DIAGNOSTIC = 'D'

member EXPRESSION_TYPE_IDENTIFIER

EXPRESSION_TYPE_IDENTIFIER = 'T'

enum DeclarationListEmitMode

const enum DeclarationListEmitMode {
    Direct = 0,
    Closure = 1,
    ClosureResolved = 2,
    RuntimeResolved = 3,
}

Specifies how a list of declaration type references should be emitted into the generated code.

member Closure

Closure = 1

The list of declarations is emitted into the generated code wrapped inside a closure, which is needed when at least one declaration is a forward reference.
directives: function () { return [MyDir, ForwardDir]; },

member ClosureResolved

ClosureResolved = 2

Similar to Closure, with the addition that the list of declarations can contain individual items that are themselves forward references. This is relevant for JIT compilations, as unwrapping the forwardRef cannot be done statically so must be deferred. This mode emits the declaration list using a mapping transform through resolveForwardRef to ensure that any forward references within the list are resolved when the outer closure is invoked.
Consider the case where the runtime has captured two declarations in two distinct values:
const dirA = MyDir; const dirB = forwardRef(function() { return ForwardRef; });
This mode would emit the declarations captured in dirA and dirB as follows:
directives: function () { return [dirA, dirB].map(ng.resolveForwardRef); },

member Direct

Direct = 0

The list of declarations is emitted into the generated code as is.
directives: [MyDir],

member RuntimeResolved

RuntimeResolved = 3

enum DeferBlockDepsEmitMode

const enum DeferBlockDepsEmitMode {
    PerBlock = 0,
    PerComponent = 1,
}

Defines how dynamic imports for deferred dependencies should be emitted in the generated output: - either in a function on per-component basis (in case of local compilation) - or in a function on per-block basis (in full compilation mode)

member PerBlock

PerBlock = 0

Dynamic imports are grouped on per-block basis.
This is used in full compilation mode, when compiler has more information about particular dependencies that belong to this block.

member PerComponent

PerComponent = 1

Dynamic imports are grouped on per-component basis.
In local compilation, compiler doesn't have enough information to determine which deferred dependencies belong to which block. In this case we group all dynamic imports into a single file on per-component basis.

enum ExpressionIdentifier

enum ExpressionIdentifier {
    DIRECTIVE = 'DIR',
    HOST_DIRECTIVE = 'HOSTDIR',
    COMPONENT_COMPLETION = 'COMPCOMP',
    EVENT_PARAMETER = 'EP',
    VARIABLE_AS_EXPRESSION = 'VAE',
}

Identifies what the TCB expression is for (for example, a directive declaration).

member COMPONENT_COMPLETION

COMPONENT_COMPLETION = 'COMPCOMP'

member DIRECTIVE

DIRECTIVE = 'DIR'

member EVENT_PARAMETER

EVENT_PARAMETER = 'EP'

member HOST_DIRECTIVE

HOST_DIRECTIVE = 'HOSTDIR'

member VARIABLE_AS_EXPRESSION

VARIABLE_AS_EXPRESSION = 'VAE'

enum FactoryTarget

enum FactoryTarget {
    Directive = 0,
    Component = 1,
    Injectable = 2,
    Pipe = 3,
    NgModule = 4,
    Service = 5,
}

member Component

Component = 1

member Directive

Directive = 0

member Injectable

Injectable = 2

member NgModule

NgModule = 4

member Pipe

Pipe = 3

member Service

Service = 5

enum ForwardRefHandling

const enum ForwardRefHandling {
    None = 0,
    Wrapped = 1,
    Unwrapped = 2,
}

Specifies how a forward ref has been handled in a MaybeForwardRefExpression

member None

None = 0

The expression was not wrapped in a forwardRef() call in the first place.

member Unwrapped

Unwrapped = 2

The expression was wrapped in a forwardRef() call but has since been unwrapped.

member Wrapped

Wrapped = 1

The expression is still wrapped in a forwardRef() call.

enum LexerTokenType

const enum LexerTokenType {
    TAG_OPEN_START = 0,
    TAG_OPEN_END = 1,
    TAG_OPEN_END_VOID = 2,
    TAG_CLOSE = 3,
    INCOMPLETE_TAG_OPEN = 4,
    TEXT = 5,
    ESCAPABLE_RAW_TEXT = 6,
    RAW_TEXT = 7,
    INTERPOLATION = 8,
    ENCODED_ENTITY = 9,
    COMMENT_START = 10,
    COMMENT_END = 11,
    IN_ELEMENT_COMMENT = 12,
    CDATA_START = 13,
    CDATA_END = 14,
    ATTR_NAME = 15,
    ATTR_QUOTE = 16,
    ATTR_VALUE_TEXT = 17,
    ATTR_VALUE_INTERPOLATION = 18,
    DOC_TYPE = 19,
    EXPANSION_FORM_START = 20,
    EXPANSION_CASE_VALUE = 21,
    EXPANSION_CASE_EXP_START = 22,
    EXPANSION_CASE_EXP_END = 23,
    EXPANSION_FORM_END = 24,
    BLOCK_OPEN_START = 25,
    BLOCK_OPEN_END = 26,
    BLOCK_CLOSE = 27,
    BLOCK_PARAMETER = 28,
    INCOMPLETE_BLOCK_OPEN = 29,
    LET_START = 30,
    LET_VALUE = 31,
    LET_END = 32,
    INCOMPLETE_LET = 33,
    COMPONENT_OPEN_START = 34,
    COMPONENT_OPEN_END = 35,
    COMPONENT_OPEN_END_VOID = 36,
    COMPONENT_CLOSE = 37,
    INCOMPLETE_COMPONENT_OPEN = 38,
    DIRECTIVE_NAME = 39,
    DIRECTIVE_OPEN = 40,
    DIRECTIVE_CLOSE = 41,
    EOF = 42,
}

member ATTR_NAME

ATTR_NAME = 15

member ATTR_QUOTE

ATTR_QUOTE = 16

member ATTR_VALUE_INTERPOLATION

ATTR_VALUE_INTERPOLATION = 18

member ATTR_VALUE_TEXT

ATTR_VALUE_TEXT = 17

member BLOCK_CLOSE

BLOCK_CLOSE = 27

member BLOCK_OPEN_END

BLOCK_OPEN_END = 26

member BLOCK_OPEN_START

BLOCK_OPEN_START = 25

member BLOCK_PARAMETER

BLOCK_PARAMETER = 28

member CDATA_END

CDATA_END = 14

member CDATA_START

CDATA_START = 13

member COMMENT_END

COMMENT_END = 11

member COMMENT_START

COMMENT_START = 10

member COMPONENT_CLOSE

COMPONENT_CLOSE = 37

member COMPONENT_OPEN_END

COMPONENT_OPEN_END = 35

member COMPONENT_OPEN_END_VOID

COMPONENT_OPEN_END_VOID = 36

member COMPONENT_OPEN_START

COMPONENT_OPEN_START = 34

member DIRECTIVE_CLOSE

DIRECTIVE_CLOSE = 41

member DIRECTIVE_NAME

DIRECTIVE_NAME = 39

member DIRECTIVE_OPEN

DIRECTIVE_OPEN = 40

member DOC_TYPE

DOC_TYPE = 19

member ENCODED_ENTITY

ENCODED_ENTITY = 9

member EOF

EOF = 42

member ESCAPABLE_RAW_TEXT

ESCAPABLE_RAW_TEXT = 6

member EXPANSION_CASE_EXP_END

EXPANSION_CASE_EXP_END = 23

member EXPANSION_CASE_EXP_START

EXPANSION_CASE_EXP_START = 22

member EXPANSION_CASE_VALUE

EXPANSION_CASE_VALUE = 21

member EXPANSION_FORM_END

EXPANSION_FORM_END = 24

member EXPANSION_FORM_START

EXPANSION_FORM_START = 20

member IN_ELEMENT_COMMENT

IN_ELEMENT_COMMENT = 12

member INCOMPLETE_BLOCK_OPEN

INCOMPLETE_BLOCK_OPEN = 29

member INCOMPLETE_COMPONENT_OPEN

INCOMPLETE_COMPONENT_OPEN = 38

member INCOMPLETE_LET

INCOMPLETE_LET = 33

member INCOMPLETE_TAG_OPEN

INCOMPLETE_TAG_OPEN = 4

member INTERPOLATION

INTERPOLATION = 8

member LET_END

LET_END = 32

member LET_START

LET_START = 30

member LET_VALUE

LET_VALUE = 31

member RAW_TEXT

RAW_TEXT = 7

member TAG_CLOSE

TAG_CLOSE = 3

member TAG_OPEN_END

TAG_OPEN_END = 1

member TAG_OPEN_END_VOID

TAG_OPEN_END_VOID = 2

member TAG_OPEN_START

TAG_OPEN_START = 0

member TEXT

TEXT = 5

enum MatchSource

enum MatchSource {
    Selector = 0,
    HostDirective = 1,
}

Possible ways that a directive can be matched.

member HostDirective

HostDirective = 1

The directive was applied as a host directive.

member Selector

Selector = 0

The directive was matched by its selector.

enum OutOfBandDiagnosticCategory

enum OutOfBandDiagnosticCategory {
    Error = 0,
    Warning = 1,
}

Categories of diagnostics that can be reported by a OutOfBandDiagnosticRecorder.

member Error

Error = 0

member Warning

Warning = 1

enum ParsedEventType

enum ParsedEventType {
    Regular = 0,
    LegacyAnimation = 1,
    TwoWay = 2,
    Animation = 3,
}

member Animation

Animation = 3

member LegacyAnimation

LegacyAnimation = 1

member Regular

Regular = 0

member TwoWay

TwoWay = 2

enum ParsedPropertyType

enum ParsedPropertyType {
    DEFAULT = 0,
    LITERAL_ATTR = 1,
    LEGACY_ANIMATION = 2,
    TWO_WAY = 3,
    ANIMATION = 4,
}

member ANIMATION

ANIMATION = 4

member DEFAULT

DEFAULT = 0

member LEGACY_ANIMATION

LEGACY_ANIMATION = 2

member LITERAL_ATTR

LITERAL_ATTR = 1

member TWO_WAY

TWO_WAY = 3

enum ParseErrorLevel

enum ParseErrorLevel {
    WARNING = 0,
    ERROR = 1,
}

member ERROR

ERROR = 1

member WARNING

WARNING = 0

enum ParseFlags

const enum ParseFlags {
    None = 0,
    Action = 1,
}

Represents the possible parse modes to be used as a bitmask.

member Action

Action = 1

Whether an output binding is being parsed.

member None

None = 0

enum QueryFlags

const enum QueryFlags {
    none = 0,
    descendants = 1,
    isStatic = 2,
    emitDistinctChangesOnly = 4,
}

A set of flags to be used with Queries.
NOTE: Ensure changes here are in sync with packages/core/src/render3/interfaces/query.ts

member descendants

descendants = 1

Whether or not the query should descend into children.

member emitDistinctChangesOnly

emitDistinctChangesOnly = 4

If the QueryList should fire change event only if actual change to query was computed (vs old behavior where the change was fired whenever the query was recomputed, even if the recomputed query resulted in the same list.)

member isStatic

isStatic = 2

The query can be computed statically and hence can be assigned eagerly.
NOTE: Backwards compatibility with ViewEngine.

member none

none = 0

No flags

enum R3NgModuleMetadataKind

enum R3NgModuleMetadataKind {
    Global = 0,
    Local = 1,
    Isolated = 2,
}

The type of the NgModule meta data. - Global: Used for full and partial compilation modes which mainly includes R3References. - Local: Used for the local compilation mode which mainly includes the raw expressions as appears in the NgModule decorator.

member Global

Global = 0

member Isolated

Isolated = 2

member Local

Local = 1

enum R3SelectorScopeMode

enum R3SelectorScopeMode {
    Inline = 0,
    SideEffect = 1,
    Omit = 2,
}

How the selector scope of an NgModule (its declarations, imports, and exports) should be emitted as a part of the NgModule definition.

member Inline

Inline = 0

Emit the declarations inline into the module definition.
This option is useful in certain contexts where it's known that JIT support is required. The tradeoff here is that this emit style prevents directives and pipes from being tree-shaken if they are unused, but the NgModule is used.

member Omit

Omit = 2

Don't generate selector scopes at all.
This is useful for contexts where JIT support is known to be unnecessary.

member SideEffect

SideEffect = 1

Emit the declarations using a side effectful function call, ɵɵsetNgModuleScope, that is guarded with the ngJitMode flag.
This form of emit supports JIT and can be optimized away if the ngJitMode flag is set to false, which allows unused directives and pipes to be tree-shaken.

enum R3TemplateDependencyKind

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

member Directive

Directive = 0

member NgModule

NgModule = 2

member Pipe

Pipe = 1

enum StmtModifier

enum StmtModifier {
    None = 0,
    Final = 1,
    Private = 2,
    Exported = 4,
    Static = 8,
}

member Exported

Exported = 4

member Final

Final = 1

member None

None = 0

member Private

Private = 2

member Static

Static = 8

enum StringTokenKind

enum StringTokenKind {
    Plain = 0,
    TemplateLiteralPart = 1,
    TemplateLiteralEnd = 2,
}

member Plain

Plain = 0

member TemplateLiteralEnd

TemplateLiteralEnd = 2

member TemplateLiteralPart

TemplateLiteralPart = 1

enum TagContentType

enum TagContentType {
    RAW_TEXT = 0,
    ESCAPABLE_RAW_TEXT = 1,
    PARSABLE_DATA = 2,
}

member ESCAPABLE_RAW_TEXT

ESCAPABLE_RAW_TEXT = 1

member PARSABLE_DATA

PARSABLE_DATA = 2

member RAW_TEXT

RAW_TEXT = 0

enum TcbGenericContextBehavior

enum TcbGenericContextBehavior {
    UseEmitter = 0,
    CopyClassNodes = 1,
    FallbackToAny = 2,
}

Controls how generics for the component context class will be handled during TCB generation.

member CopyClassNodes

CopyClassNodes = 1

Generic parameter declarations will be copied directly from the ts.ClassDeclaration of the component class.
The caller must only use the generated TCB code in a context where such copies will still be valid, such as an inline type check block.

member FallbackToAny

FallbackToAny = 2

Any generic parameters for the component context class will be set to any.
Produces a less useful type, but is always safe to use.

member UseEmitter

UseEmitter = 0

References to generic parameter bounds will be emitted via the TypeParameterEmitter.
The caller must verify that all parameter bounds are emittable in order to use this mode.

enum TokenType

enum TokenType {
    Character = 0,
    Identifier = 1,
    PrivateIdentifier = 2,
    Keyword = 3,
    String = 4,
    Operator = 5,
    Number = 6,
    RegExpBody = 7,
    RegExpFlags = 8,
    Error = 9,
}

member Character

Character = 0

member Error

Error = 9

member Identifier

Identifier = 1

member Keyword

Keyword = 3

member Number

Number = 6

member Operator

Operator = 5

member PrivateIdentifier

PrivateIdentifier = 2

member RegExpBody

RegExpBody = 7

member RegExpFlags

RegExpFlags = 8

member String

String = 4

enum TypeModifier

enum TypeModifier {
    None = 0,
    Const = 1,
}

member Const

Const = 1

member None

None = 0

enum UnaryOperator

enum UnaryOperator {
    Minus = 0,
    Plus = 1,
}

member Minus

Minus = 0

member Plus

Plus = 1

enum ViewEncapsulation

enum ViewEncapsulation {
    Emulated = 0,
    None = 2,
    ShadowDom = 3,
    ExperimentalIsolatedShadowDom = 4,
}

member Emulated

Emulated = 0

member ExperimentalIsolatedShadowDom

ExperimentalIsolatedShadowDom = 4

member None

None = 2

member ShadowDom

ShadowDom = 3

Type Aliases

type ArrowFunctionParameter

type ArrowFunctionParameter = ArrowFunctionIdentifierParameter;

type AssignmentOperation

type AssignmentOperation =
    | '='
    | '+='
    | '-='
    | '*='
    | '/='
    | '%='
    | '**='
    | '&&='
    | '||='
    | '??=';

type BindingPropertyName

type BindingPropertyName = string;

The name by which an input or output of a directive or component is bound in an Angular template.
This type exists for documentation only.

type ClassPropertyName

type ClassPropertyName = string;

The name of a class property that backs an input or output declared by a directive or component.
This type exists for documentation only.

type CompileClassMetadataFn

type CompileClassMetadataFn = (metadata: R3ClassMetadata) => Expression;

type DirectiveMatcher

type DirectiveMatcher<DirectiveT extends DirectiveMeta> =
    | SelectorMatcher<DirectiveT[]>
    | SelectorlessMatcher<DirectiveT>;

Object used to match template nodes to directives.

type DirectiveOwner

type DirectiveOwner = Element | Template | Component | Directive | HostElement;

Nodes that can have directives applied to them.

type LegacyInputPartialMapping

type LegacyInputPartialMapping =
    | string
    | [
          bindingPropertyName: string,
          classPropertyName: string,
          transformFunction?: Expression
      ];

type LiteralMapKey

type LiteralMapKey = LiteralMapPropertyKey | LiteralMapSpreadKey;

type Node

type Node$1 =
    | Attribute
    | Comment$1
    | Element$1
    | Expansion
    | ExpansionCase
    | Text$1
    | Block
    | BlockParameter
    | Component$1
    | Directive$1;

type R3ComponentDeferMetadata

type R3ComponentDeferMetadata =
    | {
          mode: DeferBlockDepsEmitMode.PerBlock;
          blocks: Map<DeferredBlock, Expression | null>;
      }
    | {
          mode: DeferBlockDepsEmitMode.PerComponent;
          dependenciesFn: Expression | null;
      };

Information about the deferred blocks in a component's template.

type R3DeclareTemplateDependencyMetadata

type R3DeclareTemplateDependencyMetadata =
    | R3DeclareDirectiveDependencyMetadata
    | R3DeclarePipeDependencyMetadata
    | R3DeclareNgModuleDependencyMetadata;

type R3DeferResolverFunctionMetadata

type R3DeferResolverFunctionMetadata =
    | {
          mode: DeferBlockDepsEmitMode.PerBlock;
          dependencies: R3DeferPerBlockDependency[];
      }
    | {
          mode: DeferBlockDepsEmitMode.PerComponent;
          dependencies: R3DeferPerComponentDependency[];
      };

Information needed to compile the defer block resolver function.

type R3FactoryMetadata

type R3FactoryMetadata =
    | R3ConstructorFactoryMetadata
    | R3DelegatedFnOrClassMetadata
    | R3ExpressionFactoryMetadata;

type R3NgModuleMetadata

type R3NgModuleMetadata =
    | R3NgModuleMetadataGlobal
    | R3NgModuleMetadataLocal
    | R3NgModuleMetadataIsolated;

type R3TemplateDependencyMetadata

type R3TemplateDependencyMetadata =
    | R3DirectiveDependencyMetadata
    | R3PipeDependencyMetadata
    | R3NgModuleDependencyMetadata;

A dependency that's used within a component template

type ReferenceTarget

type ReferenceTarget<DirectiveT> =
    | {
          directive: DirectiveT;
          node: Exclude<DirectiveOwner, HostElement>;
      }
    | Element
    | Template;

Possible values that a reference can be resolved to.

type ScopedNode

type ScopedNode =
    | Template
    | SwitchBlockCaseGroup
    | IfBlockBranch
    | ForLoopBlock
    | ForLoopBlockEmpty
    | DeferredBlock
    | DeferredBlockError
    | DeferredBlockLoading
    | DeferredBlockPlaceholder
    | Content
    | HostElement;

Node that has a Scope associated with it.

type SourceMap

type SourceMap = {
    version: number;
    file?: string;
    sourceRoot: string;
    sources: string[];
    sourcesContent: (string | null)[];
    mappings: string;
};

type SourceNode

type SourceNode =
    | StaticSourceNode
    | {
          kind: 'unspecified';
          sourceSpan: ParseSourceSpan$1;
      };

Represents information extracted from the source AST.

type TcbInputMapping

type TcbInputMapping = InputOrOutput & {
    required: boolean;
    /**
     * AST-free string representation of the transform type of the input, if available.
     */
    transformType?: string;
};

type TcbReferenceKey

type TcbReferenceKey = string & {
    __brand: 'TcbReferenceKey';
};

type TemplateBinding

type TemplateBinding = VariableBinding | ExpressionBinding;

TemplateBinding refers to a particular key-value pair in a microsyntax expression. A few examples are:
|---------------------|--------------|---------|--------------| | expression | key | value | binding type | |---------------------|--------------|---------|--------------| | 1. let item | item | null | variable | | 2. of items | ngForOf | items | expression | | 3. let x = y | x | y | variable | | 4. index as i | i | index | variable | | 5. trackBy: func | ngForTrackBy | func | expression | | 6. *ngIf="cond" | ngIf | cond | expression | |---------------------|--------------|---------|--------------|
(6) is a notable exception because it is a binding from the template key in the LHS of a HTML attribute to the expression in the RHS. All other bindings in the example above are derived solely from the RHS.

type TemplateEntity

type TemplateEntity = Reference | Variable | LetDeclaration;

Entity that is local to the template and defined within the template.

type TypeCheckId

type TypeCheckId = string & {
    __brand: 'TypeCheckId';
};

Namespaces

namespace core

namespace core {}

variable AttributeMarker

const AttributeMarker: typeof AttributeMarker;

variable CUSTOM_ELEMENTS_SCHEMA

const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata;

variable emitDistinctChangesOnlyDefaultValue

const emitDistinctChangesOnlyDefaultValue: boolean;

variable InjectFlags

const InjectFlags: typeof InjectFlags;

variable InputFlags

const InputFlags: typeof InputFlags;

variable MissingTranslationStrategy

const MissingTranslationStrategy: typeof MissingTranslationStrategy;

variable NO_ERRORS_SCHEMA

const NO_ERRORS_SCHEMA: SchemaMetadata;

variable parseSelectorToR3Selector

const parseSelectorToR3Selector: (selector: string) => R3CssSelectorList;

variable RenderFlags

const RenderFlags: typeof RenderFlags;

variable SecurityContext

const SecurityContext: typeof SecurityContext;

variable SelectorFlags

const SelectorFlags: typeof SelectorFlags;

variable Type

const Type: FunctionConstructor;

interface Type

interface Type$2 extends Function {}

construct signature

new (...args: any[]): any;

enum ChangeDetectionStrategy

enum ChangeDetectionStrategy {
    OnPush = 0,
    Default = 1,
    Eager = 1,
}

member Default

Default = 1

member Eager

Eager = 1

member OnPush

OnPush = 0

enum ViewEncapsulation

enum ViewEncapsulation {
    Emulated = 0,
    None = 2,
    ShadowDom = 3,
    ExperimentalIsolatedShadowDom = 4,
}

member Emulated

Emulated = 0

member ExperimentalIsolatedShadowDom

ExperimentalIsolatedShadowDom = 4

member None

None = 2

member ShadowDom

ShadowDom = 3

type AttributeMarker

type core_d_AttributeMarker = AttributeMarker;

type HostBinding

type core_d_HostBinding = HostBinding;

type HostListener

type core_d_HostListener = HostListener;

type InjectFlags

type core_d_InjectFlags = InjectFlags;

type Input

type core_d_Input = Input;

type InputFlags

type core_d_InputFlags = InputFlags;

type MissingTranslationStrategy

type core_d_MissingTranslationStrategy = MissingTranslationStrategy;

type Output

type core_d_Output = Output;

type R3CssSelector

type core_d_R3CssSelector = R3CssSelector;

type R3CssSelectorList

type core_d_R3CssSelectorList = R3CssSelectorList;

type RenderFlags

type core_d_RenderFlags = RenderFlags;

type SchemaMetadata

type core_d_SchemaMetadata = SchemaMetadata;

type SecurityContext

type core_d_SecurityContext = SecurityContext;

type SelectorFlags

type core_d_SelectorFlags = SelectorFlags;

namespace outputAst

namespace outputAst {}

variable areAllEquivalent

const areAllEquivalent: <T extends { isEquivalent(other: T): boolean }>(
    base: T[],
    other: T[]
) => boolean;

variable ArrayType

const ArrayType: typeof ArrayType;

variable arrowFn

const arrowFn: (
    params: FnParam[],
    body: Expression | Statement[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => ArrowFunctionExpr;

variable ArrowFunctionExpr

const ArrowFunctionExpr: typeof ArrowFunctionExpr;

variable BinaryOperator

const BinaryOperator: typeof BinaryOperator;

variable BinaryOperatorExpr

const BinaryOperatorExpr: typeof BinaryOperatorExpr;

variable BOOL_TYPE

const BOOL_TYPE: BuiltinType;

variable BuiltinType

const BuiltinType: typeof BuiltinType;

variable BuiltinTypeName

const BuiltinTypeName: typeof BuiltinTypeName;

variable CommaExpr

const CommaExpr: typeof CommaExpr;

variable ConditionalExpr

const ConditionalExpr: typeof ConditionalExpr;

variable DeclareFunctionStmt

const DeclareFunctionStmt: typeof DeclareFunctionStmt;

variable DeclareVarStmt

const DeclareVarStmt: typeof DeclareVarStmt;

variable DYNAMIC_TYPE

const DYNAMIC_TYPE: BuiltinType;

variable DynamicImportExpr

const DynamicImportExpr: typeof DynamicImportExpr;

variable Expression

const Expression: typeof Expression;

variable ExpressionStatement

const ExpressionStatement: typeof ExpressionStatement;

variable expressionType

const expressionType: (
    expr: Expression,
    typeModifiers?: TypeModifier,
    typeParams?: Type$1[]
) => ExpressionType;

variable ExpressionType

const ExpressionType: typeof ExpressionType;

variable ExternalExpr

const ExternalExpr: typeof ExternalExpr;

variable ExternalReference

const ExternalReference: typeof ExternalReference;

variable fn

const fn: (
    params: FnParam[],
    body: Statement[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    name?: string
) => FunctionExpr;

variable FnParam

const FnParam: typeof FnParam;

variable FUNCTION_TYPE

const FUNCTION_TYPE: BuiltinType;

variable FunctionExpr

const FunctionExpr: typeof FunctionExpr;

variable ifStmt

const ifStmt: (
    condition: Expression,
    thenClause: Statement[],
    elseClause?: Statement[],
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
) => IfStmt;

variable IfStmt

const IfStmt: typeof IfStmt;

variable importExpr

const importExpr: (
    id: ExternalReference,
    typeParams?: Type$1[],
    sourceSpan?: ParseSourceSpan$1
) => ExternalExpr;

variable importType

const importType: (
    id: ExternalReference,
    typeParams?: Type$1[],
    typeModifiers?: TypeModifier
) => ExpressionType;

variable INFERRED_TYPE

const INFERRED_TYPE: BuiltinType;

variable InstantiateExpr

const InstantiateExpr: typeof InstantiateExpr;

variable INT_TYPE

const INT_TYPE: BuiltinType;

variable InvokeFunctionExpr

const InvokeFunctionExpr: typeof InvokeFunctionExpr;

variable isNull

const isNull: (exp: Expression) => boolean;

variable jsDocComment

const jsDocComment: (tags?: JSDocTag[]) => JSDocComment;

variable JSDocComment

const JSDocComment: typeof JSDocComment;

variable JSDocTagName

const JSDocTagName: typeof JSDocTagName;

variable leadingComment

const leadingComment: (
    text: string,
    multiline?: boolean,
    trailingNewline?: boolean
) => LeadingComment;

variable LeadingComment

const LeadingComment: typeof LeadingComment;

variable literal

const literal: (
    value: any,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => LiteralExpr;

variable literalArr

const literalArr: (
    values: Expression[],
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => LiteralArrayExpr;

variable LiteralArrayExpr

const LiteralArrayExpr: typeof LiteralArrayExpr;

variable LiteralExpr

const LiteralExpr: typeof LiteralExpr;

variable literalMap

const literalMap: (
    values: { key: string; quoted: boolean; value: Expression }[],
    type?: MapType
) => LiteralMapExpr;

variable LiteralMapExpr

const LiteralMapExpr: typeof LiteralMapExpr;

variable LiteralMapPropertyAssignment

const LiteralMapPropertyAssignment: typeof LiteralMapPropertyAssignment;

variable LiteralMapSpreadAssignment

const LiteralMapSpreadAssignment: typeof LiteralMapSpreadAssignment;

variable LiteralPiece

const LiteralPiece: typeof LiteralPiece;

variable localizedString

const localizedString: (
    metaBlock: I18nMeta,
    messageParts: LiteralPiece[],
    placeholderNames: PlaceholderPiece[],
    expressions: Expression[],
    sourceSpan?: ParseSourceSpan$1
) => LocalizedString;

variable LocalizedString

const LocalizedString: typeof LocalizedString;

variable MapType

const MapType: typeof MapType;

variable NONE_TYPE

const NONE_TYPE: BuiltinType;

variable not

const not: (expr: Expression, sourceSpan?: ParseSourceSpan$1) => NotExpr;

variable NotExpr

const NotExpr: typeof NotExpr;

variable NULL_EXPR

const NULL_EXPR: LiteralExpr;

variable nullSafeIsEquivalent

const nullSafeIsEquivalent: <T extends { isEquivalent(other: T): boolean }>(
    base: T,
    other: T
) => boolean;

variable NUMBER_TYPE

const NUMBER_TYPE: BuiltinType;

variable ParenthesizedExpr

const ParenthesizedExpr: typeof ParenthesizedExpr;

variable PlaceholderPiece

const PlaceholderPiece: typeof PlaceholderPiece;

variable ReadKeyExpr

const ReadKeyExpr: typeof ReadKeyExpr;

variable ReadPropExpr

const ReadPropExpr: typeof ReadPropExpr;

variable ReadVarExpr

const ReadVarExpr: typeof ReadVarExpr;

variable RegularExpressionLiteralExpr

const RegularExpressionLiteralExpr: typeof RegularExpressionLiteralExpr;

variable ReturnStatement

const ReturnStatement: typeof ReturnStatement;

variable SpreadElementExpr

const SpreadElementExpr: typeof SpreadElementExpr;

variable Statement

const Statement: typeof Statement;

variable StmtModifier

const StmtModifier: typeof StmtModifier;

variable STRING_TYPE

const STRING_TYPE: BuiltinType;

variable taggedTemplate

const taggedTemplate: (
    tag: Expression,
    template: TemplateLiteralExpr,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => TaggedTemplateLiteralExpr;

variable TaggedTemplateLiteralExpr

const TaggedTemplateLiteralExpr: typeof TaggedTemplateLiteralExpr;

variable TemplateLiteralElementExpr

const TemplateLiteralElementExpr: typeof TemplateLiteralElementExpr;

variable TemplateLiteralExpr

const TemplateLiteralExpr: typeof TemplateLiteralExpr;

variable transplantedType

const transplantedType: <T>(
    type: T,
    typeModifiers?: TypeModifier
) => TransplantedType<T>;

variable TransplantedType

const TransplantedType: typeof TransplantedType;

variable TYPED_NULL_EXPR

const TYPED_NULL_EXPR: LiteralExpr;

variable TypeModifier

const TypeModifier: typeof TypeModifier;

variable typeofExpr

const typeofExpr: (expr: Expression) => TypeofExpr;

variable TypeofExpr

const TypeofExpr: typeof TypeofExpr;

variable unary

const unary: (
    operator: UnaryOperator,
    expr: Expression,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1
) => UnaryOperatorExpr;

variable UnaryOperator

const UnaryOperator: typeof UnaryOperator;

variable UnaryOperatorExpr

const UnaryOperatorExpr: typeof UnaryOperatorExpr;

variable variable

const variable: (
    name: string,
    type?: Type$1,
    sourceSpan?: ParseSourceSpan$1,
    leadingComments?: LeadingComment[]
) => ReadVarExpr;

variable VoidExpr

const VoidExpr: typeof VoidExpr;

variable WrappedNodeExpr

const WrappedNodeExpr: typeof WrappedNodeExpr;

class RecursiveAstVisitor

class RecursiveAstVisitor$1 implements StatementVisitor, ExpressionVisitor {}

method visitAllExpressions

visitAllExpressions: (exprs: Expression[], context: any) => void;

method visitAllStatements

visitAllStatements: (stmts: Statement[], context: any) => void;

method visitArrayType

visitArrayType: (type: ArrayType, context: any) => any;

method visitArrowFunctionExpr

visitArrowFunctionExpr: (ast: ArrowFunctionExpr, context: any) => any;

method visitBinaryOperatorExpr

visitBinaryOperatorExpr: (ast: BinaryOperatorExpr, context: any) => any;

method visitBuiltinType

visitBuiltinType: (type: BuiltinType, context: any) => any;

method visitCommaExpr

visitCommaExpr: (ast: CommaExpr, context: any) => any;

method visitConditionalExpr

visitConditionalExpr: (ast: ConditionalExpr, context: any) => any;

method visitDeclareFunctionStmt

visitDeclareFunctionStmt: (stmt: DeclareFunctionStmt, context: any) => any;

method visitDeclareVarStmt

visitDeclareVarStmt: (stmt: DeclareVarStmt, context: any) => any;

method visitDynamicImportExpr

visitDynamicImportExpr: (ast: DynamicImportExpr, context: any) => any;

method visitExpression

visitExpression: (ast: Expression, context: any) => any;

method visitExpressionStmt

visitExpressionStmt: (stmt: ExpressionStatement, context: any) => any;

method visitExpressionType

visitExpressionType: (type: ExpressionType, context: any) => any;

method visitExternalExpr

visitExternalExpr: (ast: ExternalExpr, context: any) => any;

method visitFunctionExpr

visitFunctionExpr: (ast: FunctionExpr, context: any) => any;

method visitIfStmt

visitIfStmt: (stmt: IfStmt, context: any) => any;

method visitInstantiateExpr

visitInstantiateExpr: (ast: InstantiateExpr, context: any) => any;

method visitInvokeFunctionExpr

visitInvokeFunctionExpr: (ast: InvokeFunctionExpr, context: any) => any;

method visitLiteralArrayExpr

visitLiteralArrayExpr: (ast: LiteralArrayExpr, context: any) => any;

method visitLiteralExpr

visitLiteralExpr: (ast: LiteralExpr, context: any) => any;

method visitLiteralMapExpr

visitLiteralMapExpr: (ast: LiteralMapExpr, context: any) => any;

method visitLocalizedString

visitLocalizedString: (ast: LocalizedString, context: any) => any;

method visitMapType

visitMapType: (type: MapType, context: any) => any;

method visitNotExpr

visitNotExpr: (ast: NotExpr, context: any) => any;

method visitParenthesizedExpr

visitParenthesizedExpr: (ast: ParenthesizedExpr, context: any) => any;

method visitReadKeyExpr

visitReadKeyExpr: (ast: ReadKeyExpr, context: any) => any;

method visitReadPropExpr

visitReadPropExpr: (ast: ReadPropExpr, context: any) => any;

method visitReadVarExpr

visitReadVarExpr: (ast: ReadVarExpr, context: any) => any;

method visitRegularExpressionLiteral

visitRegularExpressionLiteral: (
    ast: RegularExpressionLiteralExpr,
    context: any
) => any;

method visitReturnStmt

visitReturnStmt: (stmt: ReturnStatement, context: any) => any;

method visitSpreadElementExpr

visitSpreadElementExpr: (ast: SpreadElementExpr, context: any) => any;

method visitTaggedTemplateLiteralExpr

visitTaggedTemplateLiteralExpr: (
    ast: TaggedTemplateLiteralExpr,
    context: any
) => any;

method visitTemplateLiteralElementExpr

visitTemplateLiteralElementExpr: (
    ast: TemplateLiteralElementExpr,
    context: any
) => any;

method visitTemplateLiteralExpr

visitTemplateLiteralExpr: (ast: TemplateLiteralExpr, context: any) => any;

method visitTransplantedType

visitTransplantedType: (type: TransplantedType<unknown>, context: any) => any;

method visitType

visitType: (ast: Type$1, context: any) => any;

method visitTypeofExpr

visitTypeofExpr: (ast: TypeofExpr, context: any) => any;

method visitUnaryOperatorExpr

visitUnaryOperatorExpr: (ast: UnaryOperatorExpr, context: any) => any;

method visitVoidExpr

visitVoidExpr: (ast: VoidExpr, context: any) => any;

method visitWrappedNodeExpr

visitWrappedNodeExpr: (ast: WrappedNodeExpr<any>, context: any) => any;

class Type

abstract class Type$1 {}

constructor

constructor(modifiers?: TypeModifier);

property modifiers

modifiers: TypeModifier;

method hasModifier

hasModifier: (modifier: TypeModifier) => boolean;

method visitType

abstract visitType: (visitor: TypeVisitor, context: any) => any;

type ArrayType

type output_ast_d_ArrayType = ArrayType;

type ArrowFunctionExpr

type output_ast_d_ArrowFunctionExpr = ArrowFunctionExpr;

type BinaryOperator

type output_ast_d_BinaryOperator = BinaryOperator;

type BinaryOperatorExpr

type output_ast_d_BinaryOperatorExpr = BinaryOperatorExpr;

type BuiltinType

type output_ast_d_BuiltinType = BuiltinType;

type BuiltinTypeName

type output_ast_d_BuiltinTypeName = BuiltinTypeName;

type CommaExpr

type output_ast_d_CommaExpr = CommaExpr;

type ConditionalExpr

type output_ast_d_ConditionalExpr = ConditionalExpr;

type CookedRawString

type output_ast_d_CookedRawString = CookedRawString;

type DeclareFunctionStmt

type output_ast_d_DeclareFunctionStmt = DeclareFunctionStmt;

type DeclareVarStmt

type output_ast_d_DeclareVarStmt = DeclareVarStmt;

type DynamicImportExpr

type output_ast_d_DynamicImportExpr = DynamicImportExpr;

type Expression

type output_ast_d_Expression = Expression;

type ExpressionStatement

type output_ast_d_ExpressionStatement = ExpressionStatement;

type ExpressionType

type output_ast_d_ExpressionType = ExpressionType;

type ExpressionVisitor

type output_ast_d_ExpressionVisitor = ExpressionVisitor;

type ExternalExpr

type output_ast_d_ExternalExpr = ExternalExpr;

type ExternalReference

type output_ast_d_ExternalReference = ExternalReference;

type FnParam

type output_ast_d_FnParam = FnParam;

type FunctionExpr

type output_ast_d_FunctionExpr = FunctionExpr;

type IfStmt

type output_ast_d_IfStmt = IfStmt;

type InstantiateExpr

type output_ast_d_InstantiateExpr = InstantiateExpr;

type InvokeFunctionExpr

type output_ast_d_InvokeFunctionExpr = InvokeFunctionExpr;

type JSDocComment

type output_ast_d_JSDocComment = JSDocComment;

type JSDocTag

type output_ast_d_JSDocTag = JSDocTag;

type JSDocTagName

type output_ast_d_JSDocTagName = JSDocTagName;

type LeadingComment

type output_ast_d_LeadingComment = LeadingComment;

type LiteralArrayExpr

type output_ast_d_LiteralArrayExpr = LiteralArrayExpr;

type LiteralExpr

type output_ast_d_LiteralExpr = LiteralExpr;

type LiteralMapEntry

type output_ast_d_LiteralMapEntry = LiteralMapEntry;

type LiteralMapExpr

type output_ast_d_LiteralMapExpr = LiteralMapExpr;

type LiteralMapPropertyAssignment

type output_ast_d_LiteralMapPropertyAssignment = LiteralMapPropertyAssignment;

type LiteralMapSpreadAssignment

type output_ast_d_LiteralMapSpreadAssignment = LiteralMapSpreadAssignment;

type LiteralPiece

type output_ast_d_LiteralPiece = LiteralPiece;

type LocalizedString

type output_ast_d_LocalizedString = LocalizedString;

type MapType

type output_ast_d_MapType = MapType;

type MessagePiece

type output_ast_d_MessagePiece = MessagePiece;

type NotExpr

type output_ast_d_NotExpr = NotExpr;

type ParenthesizedExpr

type output_ast_d_ParenthesizedExpr = ParenthesizedExpr;

type PlaceholderPiece

type output_ast_d_PlaceholderPiece = PlaceholderPiece;

type ReadKeyExpr

type output_ast_d_ReadKeyExpr = ReadKeyExpr;

type ReadPropExpr

type output_ast_d_ReadPropExpr = ReadPropExpr;

type ReadVarExpr

type output_ast_d_ReadVarExpr = ReadVarExpr;

type RegularExpressionLiteralExpr

type output_ast_d_RegularExpressionLiteralExpr = RegularExpressionLiteralExpr;

type ReturnStatement

type output_ast_d_ReturnStatement = ReturnStatement;

type SpreadElementExpr

type output_ast_d_SpreadElementExpr = SpreadElementExpr;

type Statement

type output_ast_d_Statement = Statement;

type StatementVisitor

type output_ast_d_StatementVisitor = StatementVisitor;

type StmtModifier

type output_ast_d_StmtModifier = StmtModifier;

type TaggedTemplateLiteralExpr

type output_ast_d_TaggedTemplateLiteralExpr = TaggedTemplateLiteralExpr;

type TemplateLiteralElementExpr

type output_ast_d_TemplateLiteralElementExpr = TemplateLiteralElementExpr;

type TemplateLiteralExpr

type output_ast_d_TemplateLiteralExpr = TemplateLiteralExpr;

type TransplantedType

type output_ast_d_TransplantedType<T> = TransplantedType<T>;

type TypeModifier

type output_ast_d_TypeModifier = TypeModifier;

type TypeofExpr

type output_ast_d_TypeofExpr = TypeofExpr;

type TypeVisitor

type output_ast_d_TypeVisitor = TypeVisitor;

type UnaryOperator

type output_ast_d_UnaryOperator = UnaryOperator;

type UnaryOperatorExpr

type output_ast_d_UnaryOperatorExpr = UnaryOperatorExpr;

type VoidExpr

type output_ast_d_VoidExpr = VoidExpr;

type WrappedNodeExpr

type output_ast_d_WrappedNodeExpr<T> = WrappedNodeExpr<T>;

Package Files (1)

types/compiler.d.ts

Dependencies (1)

tslib

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

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

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

Markdown

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

HTML

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

Updated 2 seconds ago.
Package analyzed in 23351 ms.
Missing or incorrect documentation? Open an issue for this package.