@angular/compiler

@angular/compiler

Version 19.0.5
Published 15 days ago
4.29 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 CUSTOM_ELEMENTS_SCHEMA

const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata;

variable DEFAULT_INTERPOLATION_CONFIG

const DEFAULT_INTERPOLATION_CONFIG: InterpolationConfig;

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 INFERRED_TYPE

const INFERRED_TYPE: BuiltinType;

variable INT_TYPE

const INT_TYPE: BuiltinType;

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

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 | null,
    sourceSpan?: ParseSourceSpan | null
) => ArrowFunctionExpr;

function compileClassDebugInfo

compileClassDebugInfo: (debugInfo: R3ClassDebugInfo) => outputAst.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
) => outputAst.InvokeFunctionExpr;

function compileComponentClassMetadata

compileComponentClassMetadata: (
    metadata: R3ClassMetadata,
    dependencies: R3DeferPerComponentDependency[] | null
) => outputAst.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
) => outputAst.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) => outputAst.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 compileDeferResolverFunction

compileDeferResolverFunction: (
    meta: R3DeferResolverFunctionMetadata
) => outputAst.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) => outputAst.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: outputAst.Expression | null;
        statements: outputAst.Statement[];
    }[],
    constantStatements: outputAst.Statement[],
    meta: R3HmrMetadata
) => outputAst.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: outputAst.Expression,
    deferredDependencyNames: string[]
) => outputAst.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 computeMsgId

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

function createCssSelectorFromNode

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

Creates a CssSelector from an AST node.

function createInjectableType

createInjectableType: (meta: R3InjectableMetadata) => outputAst.ExpressionType;

function createMayBeForwardRefExpression

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

function devOnlyGuardedExpression

devOnlyGuardedExpression: (expr: outputAst.Expression) => outputAst.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 expressionType

expressionType: (
    expr: Expression,
    typeModifiers?: TypeModifier,
    typeParams?: Type[] | 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 | null,
    sourceSpan?: ParseSourceSpan | null,
    name?: string | null
) => FunctionExpr;

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,
    leadingComments?: LeadingComment[]
) => IfStmt;

function importExpr

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

function importType

importType: (
    id: ExternalReference,
    typeParams?: Type[] | 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 jsDocComment

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

function leadingComment

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

function literal

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

function literalArr

literalArr: (
    values: Expression[],
    type?: Type | null,
    sourceSpan?: ParseSourceSpan | 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 | null
) => LocalizedString;

function makeBindingParser

makeBindingParser: (interpolationConfig?: InterpolationConfig) => BindingParser;

Construct a BindingParser with a default configuration.

function mergeNsAndName

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

function not

not: (expr: Expression, sourceSpan?: ParseSourceSpan | 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;

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 splitNsName

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

function taggedTemplate

taggedTemplate: (
    tag: Expression,
    template: TemplateLiteral,
    type?: Type | null,
    sourceSpan?: ParseSourceSpan | null
) => TaggedTemplateExpr;

function tmplAstVisitAll

tmplAstVisitAll: <Result>(
    visitor: TmplAstVisitor<Result>,
    nodes: TmplAstNode[]
) => 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,
    sourceSpan?: ParseSourceSpan | null
) => UnaryOperatorExpr;

function variable

variable: (
    name: string,
    type?: Type | null,
    sourceSpan?: ParseSourceSpan | null
) => ReadVarExpr;

function verifyHostBindings

verifyHostBindings: (
    bindings: ParsedHostBindings,
    sourceSpan: ParseSourceSpan
) => 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, nodes: Node_2[], 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 ArrayType

class ArrayType extends Type {}

constructor

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

property of

of: Type;

method visitType

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

class ArrowFunctionExpr

class ArrowFunctionExpr extends Expression {}

constructor

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

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

class AstMemoryEfficientTransformer implements AstVisitor {}

method visitAll

visitAll: (asts: any[]) => any[];

method visitBinary

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

method visitCall

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

method visitChain

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

method visitConditional

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

method visitImplicitReceiver

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

method visitInterpolation

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

method visitKeyedRead

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

method visitKeyedWrite

visitKeyedWrite: (ast: KeyedWrite, context: any) => AST;

method visitLiteralArray

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

method visitLiteralMap

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

method visitLiteralPrimitive

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

method visitNonNullAssert

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

method visitPipe

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

method visitPrefixNot

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

method visitPropertyRead

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

method visitPropertyWrite

visitPropertyWrite: (ast: PropertyWrite, context: any) => AST;

method visitSafeCall

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

method visitSafeKeyedRead

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

method visitSafePropertyRead

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

method visitThisReceiver

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

method visitTypeofExpresion

visitTypeofExpresion: (ast: TypeofExpression, context: any) => AST;

method visitUnary

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

class AstTransformer

class AstTransformer implements AstVisitor {}

method visitAll

visitAll: (asts: any[]) => any[];

method visitBinary

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

method visitCall

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

method visitChain

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

method visitConditional

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

method visitImplicitReceiver

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

method visitInterpolation

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

method visitKeyedRead

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

method visitKeyedWrite

visitKeyedWrite: (ast: KeyedWrite, context: any) => AST;

method visitLiteralArray

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

method visitLiteralMap

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

method visitLiteralPrimitive

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

method visitNonNullAssert

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

method visitPipe

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

method visitPrefixNot

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

method visitPropertyRead

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

method visitPropertyWrite

visitPropertyWrite: (ast: PropertyWrite, context: any) => AST;

method visitSafeCall

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

method visitSafeKeyedRead

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

method visitSafePropertyRead

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

method visitThisReceiver

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

method visitTypeofExpresion

visitTypeofExpresion: (ast: TypeofExpression, context: any) => AST;

method visitUnary

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

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: ParserError[]
);

property ast

ast: AST;

property errors

errors: ParserError[];

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,
    keySpan: ParseSourceSpan,
    valueSpan: ParseSourceSpan,
    valueTokens: InterpolatedAttributeToken[],
    i18n: I18nMeta_2
);

property keySpan

readonly keySpan: ParseSourceSpan;

property name

name: string;

property value

value: string;

property valueSpan

valueSpan: ParseSourceSpan;

property valueTokens

valueTokens: InterpolatedAttributeToken[];

method visit

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

class Binary

class Binary extends AST {}

constructor

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

property left

left: AST;

property operation

operation: string;

property right

right: AST;

method visit

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

class BinaryOperatorExpr

class BinaryOperatorExpr extends Expression {}

constructor

constructor(
    operator: BinaryOperator,
    lhs: Expression,
    rhs: Expression,
    type?: Type,
    sourceSpan?: ParseSourceSpan,
    parens?: boolean
);

property lhs

lhs: Expression;

property operator

operator: BinaryOperator;

property parens

parens: boolean;

property rhs

rhs: Expression;

method clone

clone: () => BinaryOperatorExpr;

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

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

class BindingPipe

class BindingPipe extends ASTWithName {}

constructor

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

property args

args: any[];

property exp

exp: AST;

property name

name: string;

method visit

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

class Block

class Block extends NodeWithI18n {}

constructor

constructor(
    name: string,
    parameters: BlockParameter[],
    children: Node_2[],
    sourceSpan: ParseSourceSpan,
    nameSpan: ParseSourceSpan,
    startSourceSpan: ParseSourceSpan,
    endSourceSpan?: ParseSourceSpan,
    i18n?: I18nMeta_2
);

property children

children: Node_2[];

property endSourceSpan

endSourceSpan: ParseSourceSpan;

property name

name: string;

property nameSpan

nameSpan: ParseSourceSpan;

property parameters

parameters: BlockParameter[];

property startSourceSpan

startSourceSpan: ParseSourceSpan;

method visit

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

class BlockParameter

class BlockParameter implements BaseNode {}

constructor

constructor(expression: string, sourceSpan: ParseSourceSpan);

property expression

expression: string;

property sourceSpan

sourceSpan: ParseSourceSpan;

method visit

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

class BoundElementProperty

class BoundElementProperty {}

constructor

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

property keySpan

readonly keySpan: ParseSourceSpan;

property name

name: string;

property securityContext

securityContext: SecurityContext;

property sourceSpan

sourceSpan: ParseSourceSpan;

property type

type: BindingType;

property unit

unit: string;

property value

value: ASTWithSource<AST>;

property valueSpan

valueSpan: ParseSourceSpan;

class BuiltinType

class BuiltinType extends Type {}

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: any[]);

property expressions

expressions: any[];

method visit

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

class CommaExpr

class CommaExpr extends Expression {}

constructor

constructor(parts: Expression[], sourceSpan?: ParseSourceSpan);

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_2 implements BaseNode {}

constructor

constructor(value: string, sourceSpan: ParseSourceSpan);

property sourceSpan

sourceSpan: ParseSourceSpan;

property value

value: string;

method visit

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

class CompilerConfig

class CompilerConfig {}

constructor

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

property defaultEncapsulation

defaultEncapsulation: ViewEncapsulation;

property preserveWhitespaces

preserveWhitespaces: boolean;

property strictInjectionParameters

strictInjectionParameters: boolean;

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,
    sourceSpan?: ParseSourceSpan
);

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: outputAst.Expression,
    forceShared?: boolean
) => outputAst.Expression;

method getLiteralFactory

getLiteralFactory: (
    literal: outputAst.LiteralArrayExpr | outputAst.LiteralMapExpr
) => {
    literalFactory: outputAst.Expression;
    literalFactoryArguments: outputAst.Expression[];
};

method getSharedConstant

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

method getSharedFunctionReference

getSharedFunctionReference: (
    fn: outputAst.Expression,
    prefix: string,
    useUniqueName?: boolean
) => outputAst.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,
    modifiers?: StmtModifier,
    sourceSpan?: ParseSourceSpan,
    leadingComments?: LeadingComment[]
);

property name

name: string;

property params

params: FnParam[];

property statements

statements: Statement[];

property type

type: Type;

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,
    modifiers?: StmtModifier,
    sourceSpan?: ParseSourceSpan,
    leadingComments?: LeadingComment[]
);

property name

name: string;

property type

type: Type;

property value

value?: Expression;

method isEquivalent

isEquivalent: (stmt: Statement) => boolean;

method visitStatement

visitStatement: (visitor: StatementVisitor, 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,
    urlComment?: string
);

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_2 extends NodeWithI18n {}

constructor

constructor(
    name: string,
    attrs: Attribute[],
    children: Node_2[],
    sourceSpan: ParseSourceSpan,
    startSourceSpan: ParseSourceSpan,
    endSourceSpan?: ParseSourceSpan,
    i18n?: I18nMeta_2
);

property attrs

attrs: Attribute[];

property children

children: Node_2[];

property endSourceSpan

endSourceSpan: ParseSourceSpan;

property name

name: string;

property startSourceSpan

startSourceSpan: ParseSourceSpan;

method visit

visit: (visitor: Visitor, 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 | null } | null,
    part: string,
    newLine?: boolean
) => void;

method println

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

method removeEmptyLastLine

removeEmptyLastLine: () => void;

method spanOf

spanOf: (line: number, column: number) => ParseSourceSpan | 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) => void;

class Expansion

class Expansion extends NodeWithI18n {}

constructor

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

property cases

cases: ExpansionCase[];

property switchValue

switchValue: string;

property switchValueSourceSpan

switchValueSourceSpan: ParseSourceSpan;

property type

type: string;

method visit

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

class ExpansionCase

class ExpansionCase implements BaseNode {}

constructor

constructor(
    value: string,
    expression: Node_2[],
    sourceSpan: ParseSourceSpan,
    valueSourceSpan: ParseSourceSpan,
    expSourceSpan: ParseSourceSpan
);

property expression

expression: Node_2[];

property expSourceSpan

expSourceSpan: ParseSourceSpan;

property sourceSpan

sourceSpan: ParseSourceSpan;

property value

value: string;

property valueSourceSpan

valueSourceSpan: ParseSourceSpan;

method visit

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

class Expression

abstract class Expression {}

constructor

constructor(type: Type, sourceSpan?: ParseSourceSpan);

property sourceSpan

sourceSpan: ParseSourceSpan;

@angular/compiler

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable BOOL_TYPE

variable CUSTOM_ELEMENTS_SCHEMA

variable DEFAULT_INTERPOLATION_CONFIG

variable DYNAMIC_TYPE

variable emitDistinctChangesOnlyDefaultValue

variable EOF

variable FUNCTION_TYPE

variable INFERRED_TYPE

variable INT_TYPE

variable NO_ERRORS_SCHEMA

variable NONE_TYPE

variable NULL_EXPR

variable NUMBER_TYPE

variable STRING_TYPE

variable Type_2

variable TYPED_NULL_EXPR

variable VERSION

Functions

function areAllEquivalent

function arrowFn

function compileClassDebugInfo

function compileClassMetadata

function compileComponentClassMetadata

function compileComponentDeclareClassMetadata

function compileComponentFromMetadata

function compileDeclareClassMetadata

function compileDeclareComponentFromMetadata

function compileDeclareDirectiveFromMetadata

function compileDeclareFactoryFunction

function compileDeclareInjectableFromMetadata

function compileDeclareInjectorFromMetadata

function compileDeclareNgModuleFromMetadata

function compileDeclarePipeFromMetadata

function compileDeferResolverFunction

function compileDirectiveFromMetadata

function compileFactoryFunction

function compileHmrInitializer

Parameter meta

function compileHmrUpdateCallback

Parameter definitions

Parameter constantStatements

Parameter meta

function compileInjectable

function compileInjector

function compileNgModule

function compileOpaqueAsyncClassMetadata

Parameter metadata

Parameter deferResolver

Parameter deferredDependencyNames

function compilePipeFromMetadata

function computeMsgId

function createCssSelectorFromNode

function createInjectableType

function createMayBeForwardRefExpression

function devOnlyGuardedExpression

function encapsulateStyle

Parameter style

Parameter componentIdentifier

Returns

function expressionType

function findMatchingDirectivesAndPipes

function fn

function getHtmlTagDefinition

function getNsPrefix

function getSafePropertyAccessString

function identifierName

function ifStmt

function importExpr