angular2.core

Constants

APP_ID → OpaqueToken: A DI Token representing a unique string id assigned to the application by Angular and used primarily for prefixing application attributes and CSS styles when ViewEncapsulation#Emulated is being used.

const OpaqueToken("AppId")
APP_INITIALIZER → OpaqueToken: A function that will be executed when an application is initialized.

const OpaqueToken("Application Initializer")
APPLICATION_COMMON_PROVIDERS → List: A default set of providers which should be included in any Angular application, regardless of the platform it runs onto.

const [APPLICATION_CORE_PROVIDERS, const Provider(ComponentResolver, useClass: ReflectorComponentResolver), APP_ID_RANDOM_PROVIDER, AppViewUtils, const Provider(IterableDiffers, useValue: defaultItera…
noValueProvided → dynamic: A special string used as the default value of useValue parameter.

'__noValueProvided__'
PACKAGE_ROOT_URL → OpaqueToken: A token which indicates the root directory of the application

const OpaqueToken("Application Packages Root URL")
PLATFORM_COMMON_PROVIDERS → List: A default set of providers which should be included in any Angular platform.

const [PLATFORM_CORE_PROVIDERS, const Provider(Reflector, useFactory: reflectorFactory, deps: const []), const Provider(ReflectorReader, useExisting: Reflector), TestabilityRegistry]
PLATFORM_DIRECTIVES → OpaqueToken: A token that can be provided when bootstraping an application to make an array of directives available in every component of the application.

const OpaqueToken("Platform Directives")
PLATFORM_INITIALIZER → OpaqueToken: A function that will be executed when a platform is initialized.

const OpaqueToken("Platform Initializer")
PLATFORM_PIPES → OpaqueToken: A token that can be provided when bootstraping an application to make an array of pipes available in every component of the application.

const OpaqueToken("Platform Pipes")

Typedefs

ComponentStateCallback() → void
GetterFn(obj) → dynamic
MethodFn(obj, List args) → dynamic
SetterFn(obj, value) → void
TrackByFn(num index, item) → dynamic: An optional function passed into NgFor that defines how to track items in an iterable (e.g. by index or id).

Properties

reflector → Reflector: read-only

Functions

coreBootstrap(Injector injector, ComponentFactory componentFactory) → ComponentRef: Shortcut for ApplicationRef.bootstrap.
coreLoadAndBootstrap(Injector injector, Type componentType) → Future<ComponentRef>: Resolves the componentFactory for the given component, waits for asynchronous initializers and bootstraps the component.
createNgZone() → NgZone: Create an Angular zone.
createPlatform(Injector injector) → PlatformRefImpl: Creates a platform. Platforms have to be eagerly created via this function.
disposePlatform() → void: Dispose the existing platform.
getPlatform() → PlatformRef: Returns the current platform.
provide(token, { Type useClass, useValue: noValueProvided, useExisting, Function useFactory, List<Object> deps, bool multi }) → Provider: Creates an injector Provider for the given token based on a given

Enums

ChangeDetectionStrategy: Describes within the change detector which strategy will be used the next time change detection is triggered.
ViewEncapsulation: Defines template and style encapsulation options available for Component's View.

Classes

AfterContentChecked: Implement this interface to get notified after every check of your directive's content.
AfterContentInit: Implement this interface to get notified when your directive's content has been fully initialized.
AfterViewChecked: Implement this interface to get notified after every check of your component's view.
AfterViewInit: Implement this interface to get notified when your component's view has been fully initialized.
AngularEntrypoint: Marks a function or method as an Angular 2 entrypoint.
ApplicationRef: A reference to an Angular application running on a page.
Attribute: An annotation to specify that a constant attribute value should be injected.
ChangeDetectorRef
CollectionChangeRecord
Component: Declare reusable UI building blocks for an application.
ComponentFactory
ComponentRef: Represents an instance of a Component created via a ComponentFactory.
ComponentResolver: Low-level service for loading ComponentFactorys, which can later be used to create and render a Component instance.
ComponentState: Mixin representing an component with observable state change.
ContentChild: Configures a content query.
ContentChildren: Configures a content query.
DependencyMetadata
Directive: Directives allow you to attach behavior to elements in the DOM.
DoCheck: Implement this interface to override the default change detection algorithm for your directive.
DynamicComponentLoader: Service for instantiating a Component and attaching it to a View at a specified location.
ElementRef: A wrapper around a native element inside of a View.
EmbeddedViewRef: Represents an Angular View.
EventEmitter
ExceptionHandler: Provides a hook for centralized exception handling.
GetTestability: Adapter interface for retrieving the Testability service associated for a particular context.
Host: Specifies that an injector should retrieve a dependency from any injector until reaching the closest host.
HostBinding: Declares a host property binding.
HostListener: Declares a host listener.
Inject: A parameter metadata that specifies a dependency.
Injectable: Compile-time metadata that marks a class Type or Function for injection.
Injector: The Injector interface.
InjectorFactory: A factory for an injector.
InjectorModule: Defines an injector module from which an injector can be generated.
Input: Declares a data-bound input property.
IterableDiffer: A strategy for tracking changes over time to an iterable.
IterableDifferFactory: Provides a factory for IterableDiffer.
IterableDiffers: A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
KeyValueChangeRecord
KeyValueDiffer: A differ that tracks changes made to an object over time.
KeyValueDifferFactory: Provides a factory for KeyValueDiffer.
KeyValueDiffers: A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
MapInjector: A simple injector based on a Map of values.
MapInjectorFactory: InjectorFactory for MapInjector.
NgZone: An injectable service for executing work inside or outside of the Angular zone.
NgZoneError: Stores error information; delivered via NgZone.onError stream.
NoReflectionCapabilities
OnChanges: Implement this interface to get notified when any data-bound property of your directive changes.
OnDestroy: Implement this interface to get notified when your directive is destroyed.
OnInit: Implement this interface to execute custom initialization logic after your directive's data-bound properties have been initialized.
OpaqueToken: Creates a token that can be used in a DI Provider.
Optional: A parameter metadata that marks a dependency as optional.
Output: Declares an event-bound output property.
Pipe: Declare reusable pipe function.
PipeTransform: To create a Pipe, you must implement this interface.
PlatformRef: The Angular platform is the entry point for Angular on a web page. Each page has exactly one platform, and services (such as reflection) which are common to every Angular application running on the page are bound in its scope.
PlatformReflectionCapabilities
Provider: Describes how an Injector should instantiate a given token.
ProviderProperty: Defines an injectable whose value is given by a property on an InjectorModule class.
Provides: Defines an injectable whose value is given by a property on an InjectorModule class.
Query: Declares an injectable parameter to be a live list of directives or variable bindings from the content children of a directive.
QueryList: A list of items that Angular keeps up to date when the state of the application changes.
ReflectionInfo: Reflective information about a symbol, including annotations, interfaces, and other metadata.
ReflectiveDependency: Dependency is used by the framework to extend DI. This is internal to Angular and should not be used directly.
ReflectiveInjector: A ReflectiveDependency injection container used for instantiating objects and resolving dependencies.
ReflectiveKey: A unique object used for retrieving items from the ReflectiveInjector.
Reflector: Provides access to reflection data about symbols.
RenderComponentType: Component prototype and runtime style information that are shared across all instances of a component type.
Renderer
ResolvedReflectiveBinding: See ResolvedProvider instead.
ResolvedReflectiveFactory: An internal resolved representation of a factory function created by resolving Provider.
ResolvedReflectiveProvider: An internal resolved representation of a Provider used by the Injector.
RootRenderer: Injectable service that provides a low-level interface for modifying the UI.
Self: Specifies that an Injector should retrieve a dependency only from itself.
SimpleChange: Represents a basic change from a previous to a new value.
SkipAngularInitCheck: Marks a deferred import as not needing explicit angular initialization.
SkipSelf: Specifies that the dependency resolution should start from the parent injector.
Stream: A source of asynchronous data events.
TemplateRef: Represents an Embedded Template that can be used to instantiate Embedded Views.
Testability: The Testability service provides testing hooks that can be accessed from the browser and by services such as Protractor. Each bootstrapped Angular application on the page will have an instance of Testability.
TestabilityRegistry: A global registry of Testability instances for specific elements.
View: Metadata properties available for configuring Views.
ViewChild: Declares a reference to a single child element.
ViewChildren: Declares a reference to multiple child elements.
ViewContainerRef: Represents a container where one or more Views can be attached.
ViewQuery: Similar to Query, but querying the component view, instead of the content children.
ViewRef
WrappedValue: Indicates that the result of a Pipe transformation has changed even though the reference has not changed.

Exceptions / Errors

AbstractProviderError: Base class for all errors arising from misconfigured providers.
CyclicDependencyError: Thrown when dependencies form a cycle.
ExpressionChangedAfterItHasBeenCheckedException: An error thrown if application changes model breaking the top-down data flow.
InstantiationError: Thrown when a constructing type returns with an Error.
InvalidProviderError: Thrown when an invalid provider is passed in the provider list to create an Injector.
NoAnnotationError: Thrown when the class has no annotation information.
NoProviderError: Thrown when trying to retrieve a dependency by Key from Injector, but the Injector does not have a Provider for Key.
OutOfBoundsError: Thrown when getting an object by index.
WrappedException