`
- * - 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: `
- *