@angular/compiler

@angular/compiler

Version 13.3.6
Published 3 days ago
8.82 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 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;

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

variable EOF

const EOF: Token;

variable NO_ERRORS_SCHEMA

const NO_ERRORS_SCHEMA: SchemaMetadata;

variable NONE_TYPE

const NONE_TYPE: BuiltinType;

variable STRING_TYPE

const STRING_TYPE: BuiltinType;

variable VERSION

const VERSION: Version;

Functions

function compileClassMetadata

compileClassMetadata: (metadata: R3ClassMetadata) => o.Expression;

function compileComponentFromMetadata

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

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

function compileDeclareClassMetadata

compileDeclareClassMetadata: (metadata: R3ClassMetadata) => o.Expression;

function compileDeclareComponentFromMetadata

compileDeclareComponentFromMetadata: (
    meta: R3ComponentMetadata,
    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 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 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 compilePipeFromMetadata

compilePipeFromMetadata: (metadata: R3PipeMetadata) => R3CompiledExpression;

function computeMsgId

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

function createInjectableType

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

function createMayBeForwardRefExpression

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

function devOnlyGuardedExpression

devOnlyGuardedExpression: (expr: o.Expression) => o.Expression;

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 isIdentifier

isIdentifier: (input: string) => boolean;

function isNgContainer

isNgContainer: (tagName: string) => boolean;

function isNgContent

isNgContent: (tagName: string) => boolean;

function isNgTemplate

isNgTemplate: (tagName: string) => boolean;

function jsDocComment

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

function leadingComment

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

function literalMap

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

function makeBindingParser

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

Construct a BindingParser with a default configuration.

function mergeNsAndName

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

function parseHostBindings

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

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) => [string | null, string];

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[], 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 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 visitQuote

visitQuote: (ast: Quote, 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 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 visitQuote

visitQuote: (ast: Quote, 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 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 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
);

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

class BoundElementProperty {}

constructor

constructor(
    name: string,
    type: BindingType,
    securityContext: SecurityContext,
    value: ASTWithSource,
    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;

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 isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method visitExpression

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

class Comment

class Comment 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,
    useJit,
    jitDevMode,
    missingTranslation,
    preserveWhitespaces,
    strictInjectionParameters,
}?: {
    defaultEncapsulation?: ViewEncapsulation;
    useJit?: boolean;
    jitDevMode?: boolean;
    missingTranslation?: MissingTranslationStrategy | null;
    preserveWhitespaces?: boolean;
    strictInjectionParameters?: boolean;
});

property defaultEncapsulation

defaultEncapsulation: ViewEncapsulation;

property jitDevMode

jitDevMode: boolean;

property missingTranslation

missingTranslation: MissingTranslationStrategy;

property preserveWhitespaces

preserveWhitespaces: boolean;

property strictInjectionParameters

strictInjectionParameters: boolean;

property useJit

useJit: 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 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: o.Statement[];

method getConstLiteral

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

method getLiteralFactory

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

method uniqueName

uniqueName: (prefix: string) => string;

Produce a unique name.
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 getMatchingElementTemplate

getMatchingElementTemplate: () => string;

Gets a template string for an element that matches the selector.

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 Element

class Element extends NodeWithI18n {}

constructor

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

property attrs

attrs: Attribute[];

property children

children: Node[];

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

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[],
    sourceSpan: ParseSourceSpan,
    valueSourceSpan: ParseSourceSpan,
    expSourceSpan: ParseSourceSpan
);

property expression

expression: Node[];

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;

property type

type: Type;

method and

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

method bigger

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

method biggerEquals

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

method bitwiseAnd

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

method callFn

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

method conditional

conditional: (
    trueCase: Expression,
    falseCase?: Expression | null,
    sourceSpan?: ParseSourceSpan | null
) => ConditionalExpr;

method divide

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

method equals

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

method identical

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

method instantiate

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

method isBlank

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

method lower

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

method lowerEquals

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

method minus

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

method modulo

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

method multiply

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

method notEquals

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

method notIdentical

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

method nullishCoalesce

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

method or

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

method plus

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

method prop

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

method toStmt

toStmt: () => Statement;

method visitExpression

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

class ExpressionBinding

class ExpressionBinding {}

constructor

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

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;

class ExpressionStatement

class ExpressionStatement extends Statement {}

constructor

constructor(
    expr: Expression,
    sourceSpan?: ParseSourceSpan,
    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 {}

constructor

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

property typeParams

typeParams: Type[];

property value

value: Expression;

method visitType

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

class ExternalExpr

class ExternalExpr extends Expression {}

constructor

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

property typeParams

typeParams: Type[];

property value

value: ExternalReference;

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, runtime?: any);

property moduleName

moduleName: string;

property name

name: string;

property runtime

runtime?: any;

class FunctionExpr

class FunctionExpr extends Expression {}

constructor

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

property name

name?: string;

property params

params: FnParam[];

property statements

statements: Statement[];

method isConstant

isConstant: () => boolean;

method isEquivalent

isEquivalent: (e: Expression) => boolean;

method toDeclStmt

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

method visitExpression

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

class HtmlParser

class HtmlParser extends Parser {}

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,
}?: {
    closedByChildren?: string[];
    closedByParent?: boolean;
    implicitNamespacePrefix?: string;
    contentType?:
        | TagContentType
        | { [namespace: string]: TagContentType; default: TagContentType };
    isVoid?: boolean;
    ignoreFirstLf?: boolean;
    preventNamespaceInheritance?: 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,
    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,
    sourceSpan?: ParseSourceSpan
);

property args

args: Expression[];

property classExpr

classExpr: Expression;

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

property expressions

expressions: any[];

property strings

strings: any[];

method visit

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

class InterpolationConfig

class InterpolationConfig {}

constructor

constructor(start: string, end: string);

property end

end: string;

property start

start: string;

method fromArray

static fromArray: (markers: [string, string] | null) => InterpolationConfig;

class InvokeFunctionExpr

class InvokeFunctionExpr extends Expression {}

constructor

constructor(
    fn: Expression,
    args: Expression[],
    type?: Type,
    sourceSpan?: ParseSourceSpan,
    pure?: boolean
);

property args

args: Expression[];

property fn

fn: Expression;

property pure

pure: boolean;

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: o.Statement[],
    refResolver: ExternalReferenceResolver,

@angular/compiler

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable CUSTOM_ELEMENTS_SCHEMA

variable DEFAULT_INTERPOLATION_CONFIG

variable DYNAMIC_TYPE

variable emitDistinctChangesOnlyDefaultValue

variable EOF

variable NO_ERRORS_SCHEMA

variable NONE_TYPE

variable STRING_TYPE

variable VERSION

Functions

function compileClassMetadata

function compileComponentFromMetadata

function compileDeclareClassMetadata

function compileDeclareComponentFromMetadata

function compileDeclareDirectiveFromMetadata

function compileDeclareFactoryFunction

function compileDeclareInjectableFromMetadata

function compileDeclareInjectorFromMetadata

function compileDeclareNgModuleFromMetadata

function compileDeclarePipeFromMetadata

function compileDirectiveFromMetadata

function compileFactoryFunction

function compileInjectable

function compileInjector

function compileNgModule

function compilePipeFromMetadata

function computeMsgId

function createInjectableType

function createMayBeForwardRefExpression

function devOnlyGuardedExpression

function getHtmlTagDefinition

function getNsPrefix

function getSafePropertyAccessString

function identifierName

function isIdentifier

function isNgContainer

function isNgContent

function isNgTemplate

function jsDocComment

function leadingComment

function literalMap

function makeBindingParser

function mergeNsAndName

function parseHostBindings

function parseTemplate

Parameter template

Parameter templateUrl

Parameter options

function preserveWhitespacesDefault

function publishFacade

function r3JitTypeSourceSpan

Parameter kind

Parameter typeName

Parameter sourceUrl

Returns

function sanitizeIdentifier

function splitNsName

function verifyHostBindings

Parameter bindings

Parameter sourceSpan

Returns

function visitAll

Classes

class AbsoluteSourceSpan

constructor

property end

property start

class ArrayType