`
- * - Next parent has the `Dependency` directive and so the dependency is satisfied.
- *
- * Angular injects `dependency=2`.
- *
- * @exportedAs angular2/annotations
- */
- class AncestorAnnotation extends Visibility {
- }
-
-
- /**
- * Specifies that an injector should retrieve a dependency from the direct parent.
- *
- * ## Example
- *
- * Here is a simple directive that retrieves a dependency from its parent element.
- *
- * ```
- * @Directive({
- * selector: '[dependency]',
- * properties: [
- * 'id: dependency'
- * ]
- * })
- * class Dependency {
- * id:string;
- * }
- *
- *
- * @Directive({
- * selector: '[my-directive]'
- * })
- * class Dependency {
- * constructor(@Parent() dependency:Dependency) {
- * expect(dependency.id).toEqual(1);
- * };
- * }
- * ```
- *
- * We use this with the following HTML template:
- *
- * ```
- *
- * ```
- * The `@Parent()` annotation in our constructor forces the injector to retrieve the dependency from
- * the
- * parent element (even thought the current element could resolve it): Angular injects
- * `dependency=1`.
- *
- * @exportedAs angular2/annotations
- */
- class ParentAnnotation extends Visibility {
- }
-
-
- /**
- * Specifies that an injector should retrieve a dependency from any ancestor element.
- *
- * An ancestor is any element between the parent element and shadow root.
- *
- *
- * ## Example
- *
- * Here is a simple directive that retrieves a dependency from an ancestor element.
- *
- * ```
- * @Directive({
- * selector: '[dependency]',
- * properties: [
- * 'id: dependency'
- * ]
- * })
- * class Dependency {
- * id:string;
- * }
- *
- *
- * @Directive({
- * selector: '[my-directive]'
- * })
- * class Dependency {
- * constructor(@Unbounded() dependency:Dependency) {
- * expect(dependency.id).toEqual(2);
- * };
- * }
- * ```
- *
- * @exportedAs angular2/annotations
- */
- class UnboundedAnnotation extends Visibility {
- }
-
- /**
- * Declares the available HTML templates for an application.
- *
- * Each angular component requires a single `@Component` and at least one `@View` annotation. The
- * `@View` annotation specifies the HTML template to use, and lists the directives that are active
- * within the template.
- *
- * When a component is instantiated, the template is loaded into the component's shadow root, and
- * the expressions and statements in the template are evaluated against the component.
- *
- * For details on the `@Component` annotation, see {@link Component}.
- *
- * ## Example
- *
- * ```
- * @Component({
- * selector: 'greet'
- * })
- * @View({
- * template: 'Hello {{name}}!',
- * directives: [GreetUser, Bold]
- * })
- * class Greet {
- * name: string;
- *
- * constructor() {
- * this.name = 'World';
- * }
- * }
- * ```
- */
- function View(arg: _ViewArg): (target: any) => any;
- interface _ViewArg {
- /**
- * Specifies a template URL for an angular component.
- *
- * NOTE: either `templateUrl` or `template` should be used, but not both.
- */
- templateUrl?: string;
-
- /**
- * Specifies an inline template for an angular component.
- *
- * NOTE: either `templateUrl` or `template` should be used, but not both.
- */
- template?: string;
-
- /**
- * Specifies a list of directives that can be used within a template.
- *
- * Directives must be listed explicitly to provide proper component encapsulation.
- *
- * ## Example
- *
- * ```javascript
- * @Component({
- * selector: 'my-component'
- * })
- * @View({
- * directives: [For]
- * template: '
- *
'
- * })
- * class MyComponent {
- * }
- * ```
- */
- // TODO(tbosch): use Type | Binding | List
when Dart supports union types,
- // as otherwise we would need to import Binding type and Dart would warn
- // for an unused import.
- directives?: List>;
-
- /**
- * Specify a custom renderer for this View.
- * If this is set, neither `template`, `templateURL` nor `directives` are used.
- */
- renderer?: string;
- }
-
- class ViewAnnotation {
- }
-
-
- /**
- * Bootstrapping for Angular applications.
- *
- * You instantiate an Angular application by explicitly specifying a component to use as the root
- * component for your
- * application via the `bootstrap()` method.
- *
- * ## Simple Example
- *
- * Assuming this `index.html`:
- *
- * ```html
- *
- *
- *
- * loading...
- *
- *
- * ```
- *
- * An application is bootstrapped inside an existing browser DOM, typically `index.html`. Unlike
- * Angular 1, Angular 2
- * does not compile/process bindings in `index.html`. This is mainly for security reasons, as well
- * as architectural
- * changes in Angular 2. This means that `index.html` can safely be processed using server-side
- * technologies such as
- * bindings. Bindings can thus use double-curly `{{ syntax }}` without collision from Angular 2
- * component double-curly
- * `{{ syntax }}`.
- *
- * We can use this script code:
- *
- * ```
- * @Component({
- * selector: 'my-app'
- * })
- * @View({
- * template: 'Hello {{ name }}!'
- * })
- * class MyApp {
- * name:string;
- *
- * constructor() {
- * this.name = 'World';
- * }
- * }
- *
- * main() {
- * return bootstrap(MyApp);
- * }
- * ```
- *
- * When the app developer invokes `bootstrap()` with the root component `MyApp` as its argument,
- * Angular performs the
- * following tasks:
- *
- * 1. It uses the component's `selector` property to locate the DOM element which needs to be
- * upgraded into
- * the angular component.
- * 2. It creates a new child injector (from the platform injector) and configures the injector with
- * the component's
- * `appInjector`. Optionally, you can also override the injector configuration for an app by
- * invoking
- * `bootstrap` with the `componentInjectableBindings` argument.
- * 3. It creates a new `Zone` and connects it to the angular application's change detection domain
- * instance.
- * 4. It creates a shadow DOM on the selected component's host element and loads the template into
- * it.
- * 5. It instantiates the specified component.
- * 6. Finally, Angular performs change detection to apply the initial data bindings for the
- * application.
- *
- *
- * ## Instantiating Multiple Applications on a Single Page
- *
- * There are two ways to do this.
- *
- *
- * ### Isolated Applications
- *
- * Angular creates a new application each time that the `bootstrap()` method is invoked. When
- * multiple applications
- * are created for a page, Angular treats each application as independent within an isolated change
- * detection and
- * `Zone` domain. If you need to share data between applications, use the strategy described in the
- * next
- * section, "Applications That Share Change Detection."
- *
- *
- * ### Applications That Share Change Detection
- *
- * If you need to bootstrap multiple applications that share common data, the applications must
- * share a common
- * change detection and zone. To do that, create a meta-component that lists the application
- * components in its template.
- * By only invoking the `bootstrap()` method once, with the meta-component as its argument, you
- * ensure that only a
- * single change detection zone is created and therefore data can be shared across the applications.
- *
- *
- * ## Platform Injector
- *
- * When working within a browser window, there are many singleton resources: cookies, title,
- * location, and others.
- * Angular services that represent these resources must likewise be shared across all Angular
- * applications that
- * occupy the same browser window. For this reason, Angular creates exactly one global platform
- * injector which stores
- * all shared services, and each angular application injector has the platform injector as its
- * parent.
- *
- * Each application has its own private injector as well. When there are multiple applications on a
- * page, Angular treats
- * each application injector's services as private to that application.
- *
- *
- * # API
- * - `appComponentType`: The root component which should act as the application. This is a reference
- * to a `Type`
- * which is annotated with `@Component(...)`.
- * - `componentInjectableBindings`: An additional set of bindings that can be added to `appInjector`
- * for the
- * Component to override default injection behavior.
- * - `errorReporter`: `function(exception:any, stackTrace:string)` a default error reporter for
- * unhandled exceptions.
- *
- * Returns a `Promise` with the application`s private Injector.
- *
- * @exportedAs angular2/core
- */
- function bootstrap(appComponentType: Type, componentInjectableBindings?: List>, errorReporter?: Function) : Promise ;
-
- class ApplicationRef {
- dispose(): any;
- hostComponent: any;
- hostComponentType: any;
- injector: any;
- }
-
- var appComponentRefToken : OpaqueToken ;
-
- var appComponentTypeToken : OpaqueToken ;
-
-
- /**
- * Specifies that a QueryList should be injected.
- *
- * See QueryList for usage and example.
- *
- * @exportedAs angular2/annotations
- */
- class QueryAnnotation extends DependencyAnnotation {
- directive: any;
- }
-
-
- /**
- * Specifies that a constant attribute value should be injected.
- *
- * The directive can inject constant string literals of host element attributes.
- *
- * ## Example
- *
- * Suppose we have an `` element and want to know its `type`.
- *
- * ```html
- *
- * ```
- *
- * A decorator can inject string literal `text` like so:
- *
- * ```javascript
- * @Directive({
- * selector: `input'
- * })
- * class InputDirective {
- * constructor(@Attribute('type') type) {
- * // type would be `text` in this example
- * }
- * }
- * ```
- *
- * @exportedAs angular2/annotations
- */
- class AttributeAnnotation extends DependencyAnnotation {
- attributeName: string;
- token: any;
- }
-
-
- /**
- * Cache that stores the AppProtoView of the template of a component.
- * Used to prevent duplicate work and resolve cyclic dependencies.
- */
- class CompilerCache {
- clear(): void;
- get(component: Type): AppProtoView;
- set(component: Type, protoView: AppProtoView): void;
- }
-
-
- /**
- * @exportedAs angular2/view
- */
- class Compiler {
- compile(component: Type): Promise;
- compileInHost(componentTypeOrBinding: Type | Binding): Promise;
- }
-
-
- /**
- * Defines lifecycle method [onChange] called after all of component's bound
- * properties are updated.
- */
- interface OnChange {
- onChange(changes: StringMap): void;
- }
-
-
- /**
- * Defines lifecycle method [onDestroy] called when a directive is being destroyed.
- */
- interface OnDestroy {
- onDestroy(): void;
- }
-
-
- /**
- * Defines lifecycle method [onCheck] called when a directive is being checked.
- */
- interface OnCheck {
- onCheck(): void;
- }
-
-
- /**
- * Defines lifecycle method [onInit] called when a directive is being checked the first time.
- */
- interface OnInit {
- onInit(): void;
- }
-
-
- /**
- * Defines lifecycle method [onAllChangesDone ] called when the bindings of all its children have
- * been changed.
- */
- interface OnAllChangesDone {
- onAllChangesDone(): void;
- }
-
-
- /**
- * An iterable live list of components in the Light DOM.
- *
- * Injectable Objects that contains a live list of child directives in the light DOM of a directive.
- * The directives are kept in depth-first pre-order traversal of the DOM.
- *
- * The `QueryList` is iterable, therefore it can be used in both javascript code with `for..of` loop
- * as well as in
- * template with `*ng-for="of"` directive.
- *
- * NOTE: In the future this class will implement an `Observable` interface. For now it uses a plain
- * list of observable
- * callbacks.
- *
- * # Example:
- *
- * Assume that `` component would like to get a list its children which are ``
- * components as shown in this
- * example:
- *
- * ```html
- *
- * ...
- * {{o.text}}
- *
- * ```
- *
- * In the above example the list of `` elements needs to get a list of `` elements so
- * that it could render
- * tabs with the correct titles and in the correct order.
- *
- * A possible solution would be for a `` to inject `` component and then register itself
- * with ``
- * component's on `hydrate` and deregister on `dehydrate` event. While a reasonable approach, this
- * would only work
- * partialy since `*ng-for` could rearange the list of `` components which would not be
- * reported to ``
- * component and thus the list of `` componets would be out of sync with respect to the list
- * of `` elements.
- *
- * A preferred solution is to inject a `QueryList` which is a live list of directives in the
- * component`s light DOM.
- *
- * ```javascript
- * @Component({
- * selector: 'tabs'
- * })
- * @View({
- * template: `
- *
- *
- * `
- * })
- * class Tabs {
- * panes: QueryList
- *
- * constructor(@Query(Pane) panes:QueryList) {
- * this.panes = panes;
- * }
- * }
- *
- * @Component({
- * selector: 'pane',
- * properties: ['title']
- * })
- * @View(...)
- * class Pane {
- * title:string;
- * }
- * ```
- *
- * @exportedAs angular2/view
- */
- class QueryList extends BaseQueryList {
- onChange(callback: any): any;
- removeCallback(callback: any): any;
- }
-
- class DirectiveResolver {
- resolve(type: Type): DirectiveAnnotation;
- }
-
-
- /**
- * @exportedAs angular2/view
- */
- class ComponentRef {
- dispose: Function;
- hostView: ViewRef;
- instance: any;
- location: ElementRef;
- }
-
-
- /**
- * Service for dynamically loading a Component into an arbitrary position in the internal Angular
- * application tree.
- *
- * @exportedAs angular2/view
- */
- class DynamicComponentLoader {
-
- /**
- * Loads a root component that is placed at the first element that matches the
- * component's selector.
- * The loaded component receives injection normally as a hosted view.
- */
- loadAsRoot(typeOrBinding: any, overrideSelector?: any, injector?: Injector): Promise;
-
- /**
- * Loads a component into the location given by the provided ElementRef. The loaded component
- * receives injection as if it in the place of the provided ElementRef.
- */
- loadIntoExistingLocation(typeOrBinding: any, location: ElementRef, injector?: Injector): Promise;
-
- /**
- * Loads a component into a free host view that is not yet attached to
- * a parent on the render side, although it is attached to a parent in the injector hierarchy.
- * The loaded component receives injection normally as a hosted view.
- */
- loadIntoNewLocation(typeOrBinding: any, parentComponentLocation: ElementRef, injector?: Injector): Promise;
-
- /**
- * Loads a component next to the provided ElementRef. The loaded component receives
- * injection normally as a hosted view.
- */
- loadNextToExistingLocation(typeOrBinding: any, location: ElementRef, injector?: Injector): Promise;
- }
-
- /**
- * Declare reusable UI building blocks for an application.
- *
- * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
- * `@Component`
- * annotation specifies when a component is instantiated, and which properties and hostListeners it
- * binds to.
- *
- * When a component is instantiated, Angular
- * - creates a shadow DOM for the component.
- * - loads the selected template into the shadow DOM.
- * - creates a child {@link Injector} which is configured with the `appInjector` for the
- * {@link Component}.
- *
- * All template expressions and statements are then evaluated against the component instance.
- *
- * For details on the `@View` annotation, see {@link View}.
- *
- * ## Example
- *
- * ```
- * @Component({
- * selector: 'greet'
- * })
- * @View({
- * template: 'Hello {{name}}!'
- * })
- * class Greet {
- * name: string;
- *
- * constructor() {
- * this.name = 'World';
- * }
- * }
- * ```
- *
- *
- * Dynamically loading a component at runtime:
- *
- * Regular Angular components are statically resolved. Dynamic components allows to resolve a
- * component at runtime
- * instead by providing a placeholder into which a regular Angular component can be dynamically
- * loaded. Once loaded,
- * the dynamically-loaded component becomes permanent and cannot be changed.
- * Dynamic components are declared just like components, but without a `@View` annotation.
- *
- *
- * ## Example
- *
- * Here we have `DynamicComp` which acts as the placeholder for `HelloCmp`. At runtime, the dynamic
- * component
- * `DynamicComp` requests loading of the `HelloCmp` component.
- *
- * There is nothing special about `HelloCmp`, which is a regular Angular component. It can also be
- * used in other static
- * locations.
- *
- * ```
- * @Component({
- * selector: 'dynamic-comp'
- * })
- * class DynamicComp {
- * helloCmp:HelloCmp;
- * constructor(loader:DynamicComponentLoader, location:ElementRef) {
- * loader.load(HelloCmp, location).then((helloCmp) => {
- * this.helloCmp = helloCmp;
- * });
- * }
- * }
- *
- * @Component({
- * selector: 'hello-cmp'
- * })
- * @View({
- * template: "{{greeting}}"
- * })
- * class HelloCmp {
- * greeting:string;
- * constructor() {
- * this.greeting = "hello";
- * }
- * }
- * ```
- */
- function Component(arg: _ComponentArg): (target: any) => any;
- interface _ComponentArg {
- /**
- * Defines the used change detection strategy.
- *
- * When a component is instantiated, Angular creates a change detector, which is responsible for
- * propagating
- * the component's bindings.
- *
- * The `changeDetection` property defines, whether the change detection will be checked every time
- * or only when the component
- * tells it to do so.
- */
- changeDetection?: string;
-
- /**
- * Defines the set of injectable objects that are visible to a Component and its children.
- *
- * The `appInjector` defined in the Component annotation allow you to configure a set of bindings
- * for the component's
- * injector.
- *
- * When a component is instantiated, Angular creates a new child Injector, which is configured
- * with the bindings in
- * the Component `appInjector` annotation. The injectable objects then become available for
- * injection to the component
- * itself and any of the directives in the component's template, i.e. they are not available to
- * the directives which
- * are children in the component's light DOM.
- *
- *
- * The syntax for configuring the `appInjector` injectable is identical to {@link Injector}
- * injectable configuration.
- * See {@link Injector} for additional detail.
- *
- *
- * ## Simple Example
- *
- * Here is an example of a class that can be injected:
- *
- * ```
- * class Greeter {
- * greet(name:string) {
- * return 'Hello ' + name + '!';
- * }
- * }
- *
- * @Component({
- * selector: 'greet',
- * appInjector: [
- * Greeter
- * ]
- * })
- * @View({
- * template: `{{greeter.greet('world')}}!`,
- * directives: [Child]
- * })
- * class HelloWorld {
- * greeter:Greeter;
- *
- * constructor(greeter:Greeter) {
- * this.greeter = greeter;
- * }
- * }
- * ```
- */
- appInjector?: List;
-
- /**
- * Defines the set of injectable objects that are visible to its view dom children.
- *
- * ## Simple Example
- *
- * Here is an example of a class that can be injected:
- *
- * ```
- * class Greeter {
- * greet(name:string) {
- * return 'Hello ' + name + '!';
- * }
- * }
- *
- * @Directive({
- * selector: 'needs-greeter'
- * })
- * class NeedsGreeter {
- * greeter:Greeter;
- *
- * constructor(greeter:Greeter) {
- * this.greeter = greeter;
- * }
- * }
- *
- * @Component({
- * selector: 'greet',
- * viewInjector: [
- * Greeter
- * ]
- * })
- * @View({
- * template: ``,
- * directives: [NeedsGreeter]
- * })
- * class HelloWorld {
- * }
- *
- * ```
- */
- viewInjector?: List;
-
- selector?: string;
- properties?: List;
- events?: List;
- hostListeners?: StringMap;
- hostProperties?: StringMap;
- hostAttributes?: StringMap;
- hostActions?: StringMap;
- exportAs?: string;
- lifecycle?: List;
- hostInjector?: List;
- compileChildren?: boolean;
- }
-
- class ComponentAnnotation extends DirectiveAnnotation {
- }
-
- /**
- * Directives allow you to attach behavior to elements in the DOM.
- *
- *