` ) will ensure that this element will get the "button" role.
- *
- * ```typescript
- * @Directive({
- * selector: '[my-button]',
- * host: {
- * 'role': 'button'
- * }
- * })
- * class MyButton {
- * }
- * ```
- */
- host: {[key: string]: string};
-
- /**
- * Defines the set of injectable objects that are visible to a Directive and its light 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: 'greet',
- * bindings: [
- * Greeter
- * ]
- * })
- * class HelloWorld {
- * greeter:Greeter;
- *
- * constructor(greeter:Greeter) {
- * this.greeter = greeter;
- * }
- * }
- * ```
- */
- bindings: any[];
-
- /**
- * Defines the name that can be used in the template to assign this directive to a variable.
- *
- * ## Simple Example
- *
- * ```
- * @Directive({
- * selector: 'child-dir',
- * exportAs: 'child'
- * })
- * class ChildDir {
- * }
- *
- * @Component({
- * selector: 'main',
- * })
- * @View({
- * template: `
`,
- * directives: [ChildDir]
- * })
- * class MainComponent {
- * }
- *
- * ```
- */
- exportAs: string;
-
- /**
- * The module id of the module that contains the directive.
- * Needed to be able to resolve relative urls for templates and styles.
- * In Dart, this can be determined automatically and does not need to be set.
- * In CommonJS, this can always be set to `module.id`.
- *
- * ## Simple Example
- *
- * ```
- * @Directive({
- * selector: 'someDir',
- * moduleId: module.id
- * })
- * class SomeDir {
- * }
- *
- * ```
- */
- moduleId: string;
-
- /**
- * Configures the queries that will be injected into the directive.
- *
- * Content queries are set before the `afterContentInit` callback is called.
- * View queries are set before the `afterViewInit` callback is called.
- *
- * ### Example
- *
- * ```
- * @Component({
- * selector: 'someDir',
- * queries: {
- * contentChildren: new ContentChildren(ChildDirective),
- * viewChildren: new ViewChildren(ChildDirective)
- * }
- * })
- * @View({
- * template: '
',
- * directives: [ChildDirective]
- * })
- * class SomeDir {
- * contentChildren: QueryList
,
- * viewChildren: QueryList
- *
- * afterContentInit() {
- * // contentChildren is set
- * }
- *
- * afterViewInit() {
- * // viewChildren is set
- * }
- * }
- * ```
- */
- queries: {[key: string]: any};
-
- }
-
-
- /**
- * Declare reusable pipe function.
- *
- * ## Example
- *
- * ```
- * @Pipe({
- * name: 'lowercase'
- * })
- * class Lowercase {
- * transform(v, args) { return v.toLowerCase(); }
- * }
- * ```
- */
- class PipeMetadata extends InjectableMetadata {
-
- constructor({name, pure}: {name: string, pure: boolean});
-
- name: string;
-
- pure: boolean;
-
- }
-
-
- /**
- * Declares a data-bound input property.
- *
- * Angular automatically updates data-bound properties during change detection.
- *
- * `InputMetadata` takes an optional parameter that specifies the name
- * used when instantiating a component in the template. When not provided,
- * the name of the decorated property is used.
- *
- * ### Example
- *
- * The following example creates a component with two input properties.
- *
- * ```typescript
- * @Component({selector: 'bank-account'})
- * @View({
- * template: `
- * Bank Name: {{bankName}}
- * Account Id: {{id}}
- * `
- * })
- * class BankAccount {
- * @Input() bankName: string;
- * @Input('account-id') id: string;
- *
- * // this property is not bound, and won't be automatically updated by Angular
- * normalizedBankName: string;
- * }
- *
- * @Component({selector: 'app'})
- * @View({
- * template: `
- *
- * `,
- * directives: [BankAccount]
- * })
- * class App {}
- *
- * bootstrap(App);
- * ```
- */
- class InputMetadata {
-
- constructor(bindingPropertyName?: string);
-
- /**
- * Name used when instantiating a component in the temlate.
- */
- bindingPropertyName: string;
-
- }
-
-
- /**
- * Declares an event-bound output property.
- *
- * When an output property emits an event, an event handler attached to that event
- * the template is invoked.
- *
- * `OutputMetadata` takes an optional parameter that specifies the name
- * used when instantiating a component in the template. When not provided,
- * the name of the decorated property is used.
- *
- * ### Example
- *
- * ```typescript
- * @Directive({
- * selector: 'interval-dir',
- * })
- * class IntervalDir {
- * @Output() everySecond = new EventEmitter();
- * @Output('everyFiveSeconds') five5Secs = new EventEmitter();
- *
- * constructor() {
- * setInterval(() => this.everySecond.next("event"), 1000);
- * setInterval(() => this.five5Secs.next("event"), 5000);
- * }
- * }
- *
- * @Component({selector: 'app'})
- * @View({
- * template: `
- *
- *
- * `,
- * directives: [IntervalDir]
- * })
- * class App {
- * everySecond() { console.log('second'); }
- * everyFiveSeconds() { console.log('five seconds'); }
- * }
- * bootstrap(App);
- * ```
- */
- class OutputMetadata {
-
- constructor(bindingPropertyName?: string);
-
- bindingPropertyName: string;
-
- }
-
-
- /**
- * Declares a host property binding.
- *
- * Angular automatically checks host property bindings during change detection.
- * If a binding changes, it will update the host element of the directive.
- *
- * `HostBindingMetadata` takes an optional parameter that specifies the property
- * name of the host element that will be updated. When not provided,
- * the class property name is used.
- *
- * ### Example
- *
- * The following example creates a directive that sets the `valid` and `invalid` classes
- * on the DOM element that has ng-model directive on it.
- *
- * ```typescript
- * @Directive({selector: '[ng-model]'})
- * class NgModelStatus {
- * constructor(public control:NgModel) {}
- * @HostBinding('[class.valid]') get valid { return this.control.valid; }
- * @HostBinding('[class.invalid]') get invalid { return this.control.invalid; }
- * }
- *
- * @Component({selector: 'app'})
- * @View({
- * template: ``,
- * directives: [FORM_DIRECTIVES, NgModelStatus]
- * })
- * class App {
- * prop;
- * }
- *
- * bootstrap(App);
- * ```
- */
- class HostBindingMetadata {
-
- constructor(hostPropertyName?: string);
-
- hostPropertyName: string;
-
- }
-
-
- /**
- * Declares a host listener.
- *
- * Angular will invoke the decorated method when the host element emits the specified event.
- *
- * If the decorated method returns `false`, then `preventDefault` is applied on the DOM
- * event.
- *
- * ### Example
- *
- * The following example declares a directive that attaches a click listener to the button and
- * counts clicks.
- *
- * ```typescript
- * @Directive({selector: 'button[counting]'})
- * class CountClicks {
- * numberOfClicks = 0;
- *
- * @HostListener('click', ['$event.target'])
- * onClick(btn) {
- * console.log("button", btn, "number of clicks:", this.numberOfClicks++);
- * }
- * }
- *
- * @Component({selector: 'app'})
- * @View({
- * template: ``,
- * directives: [CountClicks]
- * })
- * class App {}
- *
- * bootstrap(App);
- * ```
- */
- class HostListenerMetadata {
-
- constructor(eventName: string, args?: string[]);
-
- eventName: string;
-
- args: string[];
-
- }
-
-
- /**
- * Metadata properties available for configuring Views.
- *
- * 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 ComponentMetadata}.
- *
- * ## Example
- *
- * ```
- * @Component({
- * selector: 'greet'
- * })
- * @View({
- * template: 'Hello {{name}}!',
- * directives: [GreetUser, Bold]
- * })
- * class Greet {
- * name: string;
- *
- * constructor() {
- * this.name = 'World';
- * }
- * }
- * ```
- */
- class ViewMetadata {
-
- constructor({templateUrl, template, directives, pipes, encapsulation, styles, styleUrls}?: {
- templateUrl?: string,
- template?: string,
- directives?: Array,
- pipes?: Array,
- encapsulation?: ViewEncapsulation,
- styles?: string[],
- styleUrls?: string[],
- });
-
- /**
- * Specifies a template URL for an Angular component.
- *
- * NOTE: Only one of `templateUrl` or `template` can be defined per View.
- *
- *
- */
- templateUrl: string;
-
- /**
- * Specifies an inline template for an Angular component.
- *
- * NOTE: Only one of `templateUrl` or `template` can be defined per View.
- */
- template: string;
-
- /**
- * Specifies stylesheet URLs for an Angular component.
- *
- *
- */
- styleUrls: string[];
-
- /**
- * Specifies an inline stylesheet for an Angular component.
- */
- styles: 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: [NgFor]
- * template: '
- * '
- * })
- * class MyComponent {
- * }
- * ```
- */
- directives: Array;
-
- pipes: Array;
-
- /**
- * Specify how the template and the styles should be encapsulated.
- * The default is {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} if the view
- * has styles,
- * otherwise {@link ViewEncapsulation#None `ViewEncapsulation.None`}.
- */
- encapsulation: ViewEncapsulation;
-
- }
-
-
- /**
- * Defines template and style encapsulation options available for Component's {@link View}.
- *
- * See {@link ViewMetadata#encapsulation}.
- */
- enum ViewEncapsulation {
-
- /**
- * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host
- * Element and pre-processing the style rules provided via
- * {@link ViewMetadata#styles} or {@link ViewMetadata#stylesUrls}, and adding the new Host Element
- * attribute to all selectors.
- *
- * This is the default option.
- */
- Emulated,
-
- /**
- * Use the native encapsulation mechanism of the renderer.
- *
- * For the DOM this means using [Shadow DOM](https://w3c.github.io/webcomponents/spec/shadow/) and
- * creating a ShadowRoot for Component's Host Element.
- */
- Native,
-
- /**
- * Don't provide any template or style encapsulation.
- */
- None
- }
-
-
-
- /**
- * Interface for the {@link DirectiveMetadata} decorator function.
- *
- * See {@link DirectiveFactory}.
- */
- interface DirectiveDecorator extends TypeDecorator {
-
- }
-
-
- /**
- * Interface for the {@link ComponentMetadata} decorator function.
- *
- * See {@link ComponentFactory}.
- */
- interface ComponentDecorator extends TypeDecorator {
-
- /**
- * Chain {@link ViewMetadata} annotation.
- */
- View(obj: {
- templateUrl?: string,
- template?: string,
- directives?: Array,
- pipes?: Array,
- renderer?: string,
- styles?: string[],
- styleUrls?: string[],
- }): ViewDecorator;
-
- }
-
-
- /**
- * Interface for the {@link ViewMetadata} decorator function.
- *
- * See {@link ViewFactory}.
- */
- interface ViewDecorator extends TypeDecorator {
-
- /**
- * Chain {@link ViewMetadata} annotation.
- */
- View(obj: {
- templateUrl?: string,
- template?: string,
- directives?: Array,
- pipes?: Array,
- renderer?: string,
- styles?: string[],
- styleUrls?: string[],
- }): ViewDecorator;
-
- }
-
-
- /**
- * {@link DirectiveMetadata} factory for creating annotations, decorators or DSL.
- *
- * ## Example as TypeScript Decorator
- *
- * ```
- * import {Directive} from "angular2/angular2";
- *
- * @Directive({...})
- * class MyDirective {
- * constructor() {
- * ...
- * }
- * }
- * ```
- *
- * ## Example as ES5 DSL
- *
- * ```
- * var MyDirective = ng
- * .Directive({...})
- * .Class({
- * constructor: function() {
- * ...
- * }
- * })
- * ```
- *
- * ## Example as ES5 annotation
- *
- * ```
- * var MyDirective = function() {
- * ...
- * };
- *
- * MyDirective.annotations = [
- * new ng.Directive({...})
- * ]
- * ```
- */
- interface DirectiveFactory {
-
- new(obj: {
- selector?: string,
- inputs?: string[],
- outputs?: string[],
- properties?: string[],
- events?: string[],
- host?: {[key: string]: string},
- bindings?: any[],
- exportAs?: string,
- moduleId?: string,
- queries?: {[key: string]: any}
- }): DirectiveMetadata;
-
- (obj: {
- selector?: string,
- inputs?: string[],
- outputs?: string[],
- properties?: string[],
- events?: string[],
- host?: {[key: string]: string},
- bindings?: any[],
- exportAs?: string,
- moduleId?: string,
- queries?: {[key: string]: any}
- }): DirectiveDecorator;
-
- }
-
-
- /**
- * {@link ComponentMetadata} factory for creating annotations, decorators or DSL.
- *
- * ## Example as TypeScript Decorator
- *
- * ```
- * import {Component, View} from "angular2/angular2";
- *
- * @Component({...})
- * @View({...})
- * class MyComponent {
- * constructor() {
- * ...
- * }
- * }
- * ```
- *
- * ## Example as ES5 DSL
- *
- * ```
- * var MyComponent = ng
- * .Component({...})
- * .View({...})
- * .Class({
- * constructor: function() {
- * ...
- * }
- * })
- * ```
- *
- * ## Example as ES5 annotation
- *
- * ```
- * var MyComponent = function() {
- * ...
- * };
- *
- * MyComponent.annotations = [
- * new ng.Component({...}),
- * new ng.View({...})
- * ]
- * ```
- */
- interface ComponentFactory {
-
- new(obj: {
- selector?: string,
- inputs?: string[],
- outputs?: string[],
- properties?: string[],
- events?: string[],
- host?: {[key: string]: string},
- bindings?: any[],
- exportAs?: string,
- moduleId?: string,
- queries?: {[key: string]: any},
- viewBindings?: any[],
- changeDetection?: ChangeDetectionStrategy,
- }): ComponentMetadata;
-
- (obj: {
- selector?: string,
- inputs?: string[],
- outputs?: string[],
- properties?: string[],
- events?: string[],
- host?: {[key: string]: string},
- bindings?: any[],
- exportAs?: string,
- moduleId?: string,
- queries?: {[key: string]: any},
- viewBindings?: any[],
- changeDetection?: ChangeDetectionStrategy,
- }): ComponentDecorator;
-
- }
-
-
- /**
- * {@link ViewMetadata} factory for creating annotations, decorators or DSL.
- *
- * ## Example as TypeScript Decorator
- *
- * ```
- * import {Component, View} from "angular2/angular2";
- *
- * @Component({...})
- * @View({...})
- * class MyComponent {
- * constructor() {
- * ...
- * }
- * }
- * ```
- *
- * ## Example as ES5 DSL
- *
- * ```
- * var MyComponent = ng
- * .Component({...})
- * .View({...})
- * .Class({
- * constructor: function() {
- * ...
- * }
- * })
- * ```
- *
- * ## Example as ES5 annotation
- *
- * ```
- * var MyComponent = function() {
- * ...
- * };
- *
- * MyComponent.annotations = [
- * new ng.Component({...}),
- * new ng.View({...})
- * ]
- * ```
- */
- interface ViewFactory {
-
- new(obj: {
- templateUrl?: string,
- template?: string,
- directives?: Array,
- pipes?: Array,
- encapsulation?: ViewEncapsulation,
- styles?: string[],
- styleUrls?: string[],
- }): ViewMetadata;
-
- (obj: {
- templateUrl?: string,
- template?: string,
- directives?: Array,
- pipes?: Array,
- encapsulation?: ViewEncapsulation,
- styles?: string[],
- styleUrls?: string[],
- }): ViewDecorator;
-
- }
-
-
- /**
- * {@link AttributeMetadata} factory for creating annotations, decorators or DSL.
- *
- * ## Example as TypeScript Decorator
- *
- * ```
- * import {Attribute, Component, View} from "angular2/angular2";
- *
- * @Component({...})
- * @View({...})
- * class MyComponent {
- * constructor(@Attribute('title') title: string) {
- * ...
- * }
- * }
- * ```
- *
- * ## Example as ES5 DSL
- *
- * ```
- * var MyComponent = ng
- * .Component({...})
- * .View({...})
- * .Class({
- * constructor: [new ng.Attribute('title'), function(title) {
- * ...
- * }]
- * })
- * ```
- *
- * ## Example as ES5 annotation
- *
- * ```
- * var MyComponent = function(title) {
- * ...
- * };
- *
- * MyComponent.annotations = [
- * new ng.Component({...}),
- * new ng.View({...})
- * ]
- * MyComponent.parameters = [
- * [new ng.Attribute('title')]
- * ]
- * ```
- */
- interface AttributeFactory {
-
- new(name: string): AttributeMetadata;
-
- (name: string): TypeDecorator;
-
- }
-
-
- /**
- * {@link QueryMetadata} factory for creating annotations, decorators or DSL.
- *
- * ### Example as TypeScript Decorator
- *
- * ```
- * import {Query, QueryList, Component, View} from "angular2/angular2";
- *
- * @Component({...})
- * @View({...})
- * class MyComponent {
- * constructor(@Query(SomeType) queryList: QueryList) {
- * ...
- * }
- * }
- * ```
- *
- * ### Example as ES5 DSL
- *
- * ```
- * var MyComponent = ng
- * .Component({...})
- * .View({...})
- * .Class({
- * constructor: [new ng.Query(SomeType), function(queryList) {
- * ...
- * }]
- * })
- * ```
- *
- * ### Example as ES5 annotation
- *
- * ```
- * var MyComponent = function(queryList) {
- * ...
- * };
- *
- * MyComponent.annotations = [
- * new ng.Component({...}),
- * new ng.View({...})
- * ]
- * MyComponent.parameters = [
- * [new ng.Query(SomeType)]
- * ]
- * ```
- */
- interface QueryFactory {
-
- new(selector: Type | string, {descendants}?: {descendants?: boolean}): QueryMetadata;
-
- (selector: Type | string, {descendants}?: {descendants?: boolean}): ParameterDecorator;
-
- }
-
-
- interface ContentChildrenFactory {
-
- new(selector: Type | string, {descendants}?: {descendants?: boolean}): ContentChildrenMetadata;
-
- (selector: Type | string, {descendants}?: {descendants?: boolean}): any;
-
- }
-
-
- interface ContentChildFactory {
-
- new(selector: Type | string): ContentChildFactory;
-
- (selector: Type | string): any;
-
- }
-
-
- interface ViewChildrenFactory {
-
- new(selector: Type | string): ViewChildrenMetadata;
-
- (selector: Type | string): any;
-
- }
-
-
- interface ViewChildFactory {
-
- new(selector: Type | string): ViewChildFactory;
-
- (selector: Type | string): any;
-
- }
-
-
- /**
- * {@link PipeMetadata} factory for creating decorators.
- *
- * ## Example as TypeScript Decorator
- *
- * ```
- * import {Pipe} from "angular2/angular2";
- *
- * @Pipe({...})
- * class MyPipe {
- * constructor() {
- * ...
- * }
- *
- * transform(v, args) {}
- * }
- * ```
- */
- interface PipeFactory {
-
- new(obj: {name: string, pure?: boolean}): any;
-
- (obj: {name: string, pure?: boolean}): any;
-
- }
-
-
- /**
- * {@link InputMetadata} factory for creating decorators.
- *
- * See {@link InputMetadata}.
- */
- interface InputFactory {
-
- new(bindingPropertyName?: string): any;
-
- (bindingPropertyName?: string): any;
-
- }
-
-
- /**
- * {@link OutputMetadata} factory for creating decorators.
- *
- * See {@link OutputMetadata}.
- */
- interface OutputFactory {
-
- new(bindingPropertyName?: string): any;
-
- (bindingPropertyName?: string): any;
-
- }
-
-
- /**
- * {@link HostBindingMetadata} factory function.
- */
- interface HostBindingFactory {
-
- new(hostPropertyName?: string): any;
-
- (hostPropertyName?: string): any;
-
- }
-
-
- /**
- * {@link HostListenerMetadata} factory function.
- */
- interface HostListenerFactory {
-
- new(eventName: string, args?: string[]): any;
-
- (eventName: string, args?: string[]): any;
-
- }
-
-
- /**
- * {@link ComponentMetadata} factory function.
- */
- var Component: ComponentFactory;
-
-
-
- /**
- * {@link DirectiveMetadata} factory function.
- */
- var Directive: DirectiveFactory;
-
-
-
- /**
- * {@link ViewMetadata} factory function.
- */
- var View: ViewFactory;
-
-
-
- /**
- * {@link AttributeMetadata} factory function.
- */
- var Attribute: AttributeFactory;
-
-
-
- /**
- * {@link QueryMetadata} factory function.
- */
- var Query: QueryFactory;
-
-
-
- /**
- * {@link ContentChildrenMetadata} factory function.
- */
- var ContentChildren: ContentChildrenFactory;
-
-
-
- /**
- * {@link ContentChildMetadata} factory function.
- */
- var ContentChild: ContentChildFactory;
-
-
-
- /**
- * {@link ViewChildrenMetadata} factory function.
- */
- var ViewChildren: ViewChildrenFactory;
-
-
-
- /**
- * {@link ViewChildMetadata} factory function.
- */
- var ViewChild: ViewChildFactory;
-
-
-
- /**
- * {@link di/ViewQueryMetadata} factory function.
- */
- var ViewQuery: QueryFactory;
-
-
-
- /**
- * {@link PipeMetadata} factory function.
- */
- var Pipe: PipeFactory;
-
-
-
- /**
- * {@link InputMetadata} factory function.
- *
- * See {@link InputMetadata}.
- */
- var Input: InputFactory;
-
-
-
- /**
- * {@link OutputMetadata} factory function.
- *
- * See {@link OutputMetadatas}.
- */
- var Output: OutputFactory;
-
-
-
- /**
- * {@link HostBindingMetadata} factory function.
- */
- var HostBinding: HostBindingFactory;
-
-
-
- /**
- * {@link HostListenerMetadata} factory function.
- */
- var HostListener: HostListenerFactory;
-
-
-
- /**
- * Provides a way for expressing ES6 classes with parameter annotations in ES5.
- *
- * ## Basic Example
- *
- * ```
- * var Greeter = ng.Class({
- * constructor: function(name) {
- * this.name = name;
- * },
- *
- * greet: function() {
- * alert('Hello ' + this.name + '!');
- * }
- * });
- * ```
- *
- * is equivalent to ES6:
- *
- * ```
- * class Greeter {
- * constructor(name) {
- * this.name = name;
- * }
- *
- * greet() {
- * alert('Hello ' + this.name + '!');
- * }
- * }
- * ```
- *
- * or equivalent to ES5:
- *
- * ```
- * var Greeter = function (name) {
- * this.name = name;
- * }
- *
- * Greeter.prototype.greet = function () {
- * alert('Hello ' + this.name + '!');
- * }
- * ```
- *
- * ## Example with parameter annotations
- *
- * ```
- * var MyService = ng.Class({
- * constructor: [String, [new Query(), QueryList], function(name, queryList) {
- * ...
- * }]
- * });
- * ```
- *
- * is equivalent to ES6:
- *
- * ```
- * class MyService {
- * constructor(name: string, @Query() queryList: QueryList) {
- * ...
- * }
- * }
- * ```
- *
- * ## Example with inheritance
- *
- * ```
- * var Shape = ng.Class({
- * constructor: (color) {
- * this.color = color;
- * }
- * });
- *
- * var Square = ng.Class({
- * extends: Shape,
- * constructor: function(color, size) {
- * Shape.call(this, color);
- * this.size = size;
- * }
- * });
- * ```
- */
- function Class(clsDef: ClassDefinition): Type;
-
-
-
- /**
- * Declares the interface to be used with {@link Class}.
- */
- interface ClassDefinition {
-
- /**
- * Optional argument for specifying the superclass.
- */
- extends?: Type;
-
- /**
- * Required constructor function for a class.
- *
- * The function may be optionally wrapped in an `Array`, in which case additional parameter
- * annotations may be specified.
- * The number of arguments and the number of parameter annotations must match.
- *
- * See {@link Class} for example of usage.
- */
- constructor: Function | any[];
-
- }
-
-
- /**
- * An interface implemented by all Angular type decorators, which allows them to be used as ES7
- * decorators as well as
- * Angular DSL syntax.
- *
- * DSL syntax:
- *
- * ```
- * var MyClass = ng
- * .Component({...})
- * .View({...})
- * .Class({...});
- * ```
- *
- * ES7 syntax:
- *
- * ```
- * @ng.Component({...})
- * @ng.View({...})
- * class MyClass {...}
- * ```
- */
- interface TypeDecorator {
-
- /**
- * Invoke as ES7 decorator.
- */
- (type: T): T;
-
- /**
- * Storage for the accumulated annotations so far used by the DSL syntax.
- *
- * Used by {@link Class} to annotate the generated class.
- */
- annotations: any[];
-
- /**
- * Generate a class from the definition and annotate it with {@link TypeDecorator#annotations}.
- */
- Class(obj: ClassDefinition): Type;
-
- }
-
-
- /**
- * A parameter metadata that specifies a dependency.
- *
- * ### Example ([live demo](http://plnkr.co/edit/6uHYJK?p=preview))
- *
- * ```typescript
- * class Engine {}
- *
- * @Injectable()
- * class Car {
- * engine;
- * constructor(@Inject("MyEngine") engine:Engine) {
- * this.engine = engine;
- * }
- * }
- *
- * var injector = Injector.resolveAndCreate([
- * bind("MyEngine").toClass(Engine),
- * Car
- * ]);
- *
- * expect(injector.get(Car).engine instanceof Engine).toBe(true);
- * ```
- *
- * When `@Inject()` is not present, {@link Injector} will use the type annotation of the parameter.
- *
- * ### Example
- *
- * ```typescript
- * class Engine {}
- *
- * @Injectable()
- * class Car {
- * constructor(public engine: Engine) {} //same as constructor(@Inject(Engine) engine:Engine)
- * }
- *
- * var injector = Injector.resolveAndCreate([Engine, Car]);
- * expect(injector.get(Car).engine instanceof Engine).toBe(true);
- * ```
- */
- class InjectMetadata {
-
- constructor(token: any);
-
- token: any;
-
- toString(): string;
-
- }
-
-
- /**
- * A parameter metadata that marks a dependency as optional. {@link Injector} provides `null` if
- * the dependency is not found.
- *
- * ### Example ([live demo](http://plnkr.co/edit/AsryOm?p=preview))
- *
- * ```typescript
- * class Engine {}
- *
- * @Injectable()
- * class Car {
- * engine;
- * constructor(@Optional() engine:Engine) {
- * this.engine = engine;
- * }
- * }
- *
- * var injector = Injector.resolveAndCreate([Car]);
- * expect(injector.get(Car).engine).toBeNull();
- * ```
- */
- class OptionalMetadata {
-
- toString(): string;
-
- }
-
-
- /**
- * A marker metadata that marks a class as available to {@link Injector} for creation.
- *
- * ### Example ([live demo](http://plnkr.co/edit/Wk4DMQ?p=preview))
- *
- * ```typescript
- * @Injectable()
- * class UsefulService {}
- *
- * @Injectable()
- * class NeedsService {
- * constructor(public service:UsefulService) {}
- * }
- *
- * var injector = Injector.resolveAndCreate([NeedsService, UsefulService]);
- * expect(injector.get(NeedsService).service instanceof UsefulService).toBe(true);
- * ```
- * {@link Injector} will throw {@link NoAnnotationError} when trying to instantiate a class that
- * does not have `@Injectable` marker, as shown in the example below.
- *
- * ```typescript
- * class UsefulService {}
- *
- * class NeedsService {
- * constructor(public service:UsefulService) {}
- * }
- *
- * var injector = Injector.resolveAndCreate([NeedsService, UsefulService]);
- * expect(() => injector.get(NeedsService)).toThrowError();
- * ```
- */
- class InjectableMetadata {
-
- constructor();
-
- }
-
-
- /**
- * Specifies that an {@link Injector} should retrieve a dependency only from itself.
- *
- * ### Example ([live demo](http://plnkr.co/edit/NeagAg?p=preview))
- *
- * ```typescript
- * class Dependency {
- * }
- *
- * @Injectable()
- * class NeedsDependency {
- * dependency;
- *
- * dependency;
- * constructor(@Self() dependency:Dependency) {
- * this.dependency = dependency;
- * }
- * }
- *
- * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
- * var nd = inj.get(NeedsDependency);
- *
- * expect(nd.dependency instanceof Dependency).toBe(true);
- *
- * var inj = Injector.resolveAndCreate([Dependency]);
- * var child = inj.resolveAndCreateChild([NeedsDependency]);
- * expect(() => child.get(NeedsDependency)).toThrowError();
- * ```
- */
- class SelfMetadata {
-
- toString(): string;
-
- }
-
-
- /**
- * Specifies that an injector should retrieve a dependency from any injector until reaching the
- * closest host.
- *
- * In Angular, a component element is automatically declared as a host for all the injectors in
- * its view.
- *
- * ### Example ([live demo](http://plnkr.co/edit/GX79pV?p=preview))
- *
- * In the following example `App` contains `ParentCmp`, which contains `ChildDirective`.
- * So `ParentCmp` is the host of `ChildDirective`.
- *
- * `ChildDirective` depends on two services: `HostService` and `OtherService`.
- * `HostService` is defined at `ParentCmp`, and `OtherService` is defined at `App`.
- *
- * ```typescript
- * class OtherService {}
- * class HostService {}
- *
- * @Directive({
- * selector: 'child-directive'
- * })
- * class ChildDirective {
- * constructor(@Optional() @Host() os:OtherService, @Optional() @Host() hs:HostService){
- * console.log("os is null", os);
- * console.log("hs is NOT null", hs);
- * }
- * }
- *
- * @Component({
- * selector: 'parent-cmp',
- * bindings: [HostService]
- * })
- * @View({
- * template: `
- * Dir:
- * `,
- * directives: [ChildDirective]
- * })
- * class ParentCmp {
- * }
- *
- * @Component({
- * selector: 'app',
- * bindings: [OtherService]
- * })
- * @View({
- * template: `
- * Parent:
- * `,
- * directives: [ParentCmp]
- * })
- * class App {
- * }
- *
- * bootstrap(App);
- * ```
- */
- class HostMetadata {
-
- toString(): string;
-
- }
-
-
- /**
- * Specifies that the dependency resolution should start from the parent injector.
- *
- * ### Example ([live demo](http://plnkr.co/edit/Wchdzb?p=preview))
- *
- * ```typescript
- * class Dependency {
- * }
- *
- * @Injectable()
- * class NeedsDependency {
- * dependency;
- * constructor(@SkipSelf() dependency:Dependency) {
- * this.dependency = dependency;
- * }
- * }
- *
- * var parent = Injector.resolveAndCreate([Dependency]);
- * var child = parent.resolveAndCreateChild([NeedsDependency]);
- * expect(child.get(NeedsDependency).dependency instanceof Depedency).toBe(true);
- *
- * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
- * expect(() => inj.get(NeedsDependency)).toThrowError();
- * ```
- */
- class SkipSelfMetadata {
-
- toString(): string;
-
- }
-
-
- /**
- * `DependencyMetadata` is used by the framework to extend DI.
- * This is internal to Angular and should not be used directly.
- */
- class DependencyMetadata {
-
- token: any;
-
- }
-
-
- /**
- * Allows to refer to references which are not yet defined.
- *
- * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of
- * DI is declared,
- * but not yet defined. It is also used when the `token` which we use when creating a query is not
- * yet defined.
- *
- * ### Example ([live demo](http://plnkr.co/edit/bRs0SX2OTQiJzqvjgl8P?p=preview))
- *
- * ```typescript
- * class Door {
- * lock: Lock;
- * constructor(@Inject(forwardRef(() => Lock)) lock:Lock) {
- * this.lock = lock;
- * }
- * }
- *
- * // Only at this point Lock is defined.
- * class Lock {
- * }
- *
- * var injector = Injector.resolveAndCreate([Door, Lock]);
- * var door = injector.get(Door);
- * expect(door instanceof Door).toBe(true);
- * expect(door.lock instanceof Lock).toBe(true);
- * ```
- */
- function forwardRef(forwardRefFn: ForwardRefFn): Type;
-
-
-
- /**
- * Lazily retrieves the reference value from a forwardRef.
- *
- * Acts as the identity function when given a non-forward-ref value.
- *
- * ### Example ([live demo](http://plnkr.co/edit/GU72mJrk1fiodChcmiDR?p=preview))
- *
- * ```typescript
- * var ref = forwardRef(() => "refValue");
- * expect(resolveForwardRef(ref)).toEqual("refValue");
- * expect(resolveForwardRef("regularValue")).toEqual("regularValue");
- * ```
- *
- * See: {@link forwardRef}
- */
- function resolveForwardRef(type: any): any;
-
-
-
- /**
- * An interface that a function passed into {@link forwardRef} has to implement.
- *
- * ### Example
- *
- * ```typescript
- * var fn:ForwardRefFn = forwardRef(() => Lock);
- * ```
- */
- interface ForwardRefFn {
-
- (): any;
-
- }
-
-
- /**
- * A dependency injection container used for instantiating objects and resolving dependencies.
- *
- * An `Injector` is a replacement for a `new` operator, which can automatically resolve the
- * constructor dependencies.
- *
- * In typical use, application code asks for the dependencies in the constructor and they are
- * resolved by the `Injector`.
- *
- * ### Example ([live demo](http://plnkr.co/edit/jzjec0?p=preview))
- *
- * The following example creates an `Injector` configured to create `Engine` and `Car`.
- *
- * ```typescript
- * @Injectable()
- * class Engine {
- * }
- *
- * @Injectable()
- * class Car {
- * constructor(public engine:Engine) {}
- * }
- *
- * var injector = Injector.resolveAndCreate([Car, Engine]);
- * var car = injector.get(Car);
- * expect(car instanceof Car).toBe(true);
- * expect(car.engine instanceof Engine).toBe(true);
- * ```
- *
- * Notice, we don't use the `new` operator because we explicitly want to have the `Injector`
- * resolve all of the object's dependencies automatically.
- */
- class Injector {
-
- /**
- * Private
- */
- constructor(_proto: any, _parent?: Injector, _depProvider?: any, _debugContext?: Function);
-
- /**
- * Turns an array of binding definitions into an array of resolved bindings.
- *
- * A resolution is a process of flattening multiple nested arrays and converting individual
- * bindings into an array of {@link ResolvedBinding}s.
- *
- * ### Example ([live demo](http://plnkr.co/edit/AiXTHi?p=preview))
- *
- * ```typescript
- * @Injectable()
- * class Engine {
- * }
- *
- * @Injectable()
- * class Car {
- * constructor(public engine:Engine) {}
- * }
- *
- * var bindings = Injector.resolve([Car, [[Engine]]]);
- *
- * expect(bindings.length).toEqual(2);
- *
- * expect(bindings[0] instanceof ResolvedBinding).toBe(true);
- * expect(bindings[0].key.displayName).toBe("Car");
- * expect(bindings[0].dependencies.length).toEqual(1);
- * expect(bindings[0].factory).toBeDefined();
- *
- * expect(bindings[1].key.displayName).toBe("Engine");
- * });
- * ```
- *
- * See {@link fromResolvedBindings} for more info.
- */
- static resolve(bindings: Array): ResolvedBinding[];
-
- /**
- * Resolves an array of bindings and creates an injector from those bindings.
- *
- * The passed-in bindings can be an array of `Type`, {@link Binding},
- * or a recursive array of more bindings.
- *
- * ### Example ([live demo](http://plnkr.co/edit/ePOccA?p=preview))
- *
- * ```typescript
- * @Injectable()
- * class Engine {
- * }
- *
- * @Injectable()
- * class Car {
- * constructor(public engine:Engine) {}
- * }
- *
- * var injector = Injector.resolveAndCreate([Car, Engine]);
- * expect(injector.get(Car) instanceof Car).toBe(true);
- * ```
- *
- * This function is slower than the corresponding `fromResolvedBindings`
- * because it needs to resolve the passed-in bindings first.
- * See {@link resolve} and {@link fromResolvedBindings}.
- */
- static resolveAndCreate(bindings: Array): Injector;
-
- /**
- * Creates an injector from previously resolved bindings.
- *
- * This API is the recommended way to construct injectors in performance-sensitive parts.
- *
- * ### Example ([live demo](http://plnkr.co/edit/KrSMci?p=preview))
- *
- * ```typescript
- * @Injectable()
- * class Engine {
- * }
- *
- * @Injectable()
- * class Car {
- * constructor(public engine:Engine) {}
- * }
- *
- * var bindings = Injector.resolve([Car, Engine]);
- * var injector = Injector.fromResolvedBindings(bindings);
- * expect(injector.get(Car) instanceof Car).toBe(true);
- * ```
- */
- static fromResolvedBindings(bindings: ResolvedBinding[]): Injector;
-
- /**
- * Retrieves an instance from the injector based on the provided token.
- * Throws {@link NoBindingError} if not found.
- *
- * ### Example ([live demo](http://plnkr.co/edit/HeXSHg?p=preview))
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([
- * bind("validToken").toValue("Value")
- * ]);
- * expect(injector.get("validToken")).toEqual("Value");
- * expect(() => injector.get("invalidToken")).toThrowError();
- * ```
- *
- * `Injector` returns itself when given `Injector` as a token.
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([]);
- * expect(injector.get(Injector)).toBe(injector);
- * ```
- */
- get(token: any): any;
-
- /**
- * Retrieves an instance from the injector based on the provided token.
- * Returns null if not found.
- *
- * ### Example ([live demo](http://plnkr.co/edit/tpEbEy?p=preview))
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([
- * bind("validToken").toValue("Value")
- * ]);
- * expect(injector.getOptional("validToken")).toEqual("Value");
- * expect(injector.getOptional("invalidToken")).toBe(null);
- * ```
- *
- * `Injector` returns itself when given `Injector` as a token.
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([]);
- * expect(injector.getOptional(Injector)).toBe(injector);
- * ```
- */
- getOptional(token: any): any;
-
- /**
- * Parent of this injector.
- *
- *
- *
- * ### Example ([live demo](http://plnkr.co/edit/eosMGo?p=preview))
- *
- * ```typescript
- * var parent = Injector.resolveAndCreate([]);
- * var child = parent.resolveAndCreateChild([]);
- * expect(child.parent).toBe(parent);
- * ```
- */
- parent: Injector;
-
- /**
- * Resolves an array of bindings and creates a child injector from those bindings.
- *
- *
- *
- * The passed-in bindings can be an array of `Type`, {@link Binding},
- * or a recursive array of more bindings.
- *
- * ### Example ([live demo](http://plnkr.co/edit/opB3T4?p=preview))
- *
- * ```typescript
- * class ParentBinding {}
- * class ChildBinding {}
- *
- * var parent = Injector.resolveAndCreate([ParentBinding]);
- * var child = parent.resolveAndCreateChild([ChildBinding]);
- *
- * expect(child.get(ParentBinding) instanceof ParentBinding).toBe(true);
- * expect(child.get(ChildBinding) instanceof ChildBinding).toBe(true);
- * expect(child.get(ParentBinding)).toBe(parent.get(ParentBinding));
- * ```
- *
- * This function is slower than the corresponding `createChildFromResolved`
- * because it needs to resolve the passed-in bindings first.
- * See {@link resolve} and {@link createChildFromResolved}.
- */
- resolveAndCreateChild(bindings: Array): Injector;
-
- /**
- * Creates a child injector from previously resolved bindings.
- *
- *
- *
- * This API is the recommended way to construct injectors in performance-sensitive parts.
- *
- * ### Example ([live demo](http://plnkr.co/edit/VhyfjN?p=preview))
- *
- * ```typescript
- * class ParentBinding {}
- * class ChildBinding {}
- *
- * var parentBindings = Injector.resolve([ParentBinding]);
- * var childBindings = Injector.resolve([ChildBinding]);
- *
- * var parent = Injector.fromResolvedBindings(parentBindings);
- * var child = parent.createChildFromResolved(childBindings);
- *
- * expect(child.get(ParentBinding) instanceof ParentBinding).toBe(true);
- * expect(child.get(ChildBinding) instanceof ChildBinding).toBe(true);
- * expect(child.get(ParentBinding)).toBe(parent.get(ParentBinding));
- * ```
- */
- createChildFromResolved(bindings: ResolvedBinding[]): Injector;
-
- /**
- * Resolves a binding and instantiates an object in the context of the injector.
- *
- * The created object does not get cached by the injector.
- *
- * ### Example ([live demo](http://plnkr.co/edit/yvVXoB?p=preview))
- *
- * ```typescript
- * @Injectable()
- * class Engine {
- * }
- *
- * @Injectable()
- * class Car {
- * constructor(public engine:Engine) {}
- * }
- *
- * var injector = Injector.resolveAndCreate([Engine]);
- *
- * var car = injector.resolveAndInstantiate(Car);
- * expect(car.engine).toBe(injector.get(Engine));
- * expect(car).not.toBe(injector.resolveAndInstantiate(Car));
- * ```
- */
- resolveAndInstantiate(binding: Type | Binding): any;
-
- /**
- * Instantiates an object using a resolved binding in the context of the injector.
- *
- * The created object does not get cached by the injector.
- *
- * ### Example ([live demo](http://plnkr.co/edit/ptCImQ?p=preview))
- *
- * ```typescript
- * @Injectable()
- * class Engine {
- * }
- *
- * @Injectable()
- * class Car {
- * constructor(public engine:Engine) {}
- * }
- *
- * var injector = Injector.resolveAndCreate([Engine]);
- * var carBinding = Injector.resolve([Car])[0];
- * var car = injector.instantiateResolved(carBinding);
- * expect(car.engine).toBe(injector.get(Engine));
- * expect(car).not.toBe(injector.instantiateResolved(carBinding));
- * ```
- */
- instantiateResolved(binding: ResolvedBinding): any;
-
- displayName: string;
-
- toString(): string;
-
- }
-
-
- /**
- * Describes how the {@link Injector} should instantiate a given token.
- *
- * See {@link bind}.
- *
- * ### Example ([live demo](http://plnkr.co/edit/GNAyj6K6PfYg2NBzgwZ5?p%3Dpreview&p=preview))
- *
- * ```javascript
- * var injector = Injector.resolveAndCreate([
- * new Binding("message", { toValue: 'Hello' })
- * ]);
- *
- * expect(injector.get("message")).toEqual('Hello');
- * ```
- */
- class Binding {
-
- constructor(token: any, {toClass, toValue, toAlias, toFactory, deps, multi}: {
- toClass?: Type,
- toValue?: any,
- toAlias?: any,
- toFactory?: Function,
- deps?: Object[],
- multi?: boolean
- });
-
- /**
- * Token used when retrieving this binding. Usually, it is a type {@link `Type`}.
- */
- token: any;
-
- /**
- * Binds a DI token to an implementation class.
- *
- * ### Example ([live demo](http://plnkr.co/edit/RSTG86qgmoxCyj9SWPwY?p=preview))
- *
- * Because `toAlias` and `toClass` are often confused, the example contains both use cases for
- * easy
- * comparison.
- *
- * ```typescript
- * class Vehicle {}
- *
- * class Car extends Vehicle {}
- *
- * var injectorClass = Injector.resolveAndCreate([
- * Car,
- * new Binding(Vehicle, { toClass: Car })
- * ]);
- * var injectorAlias = Injector.resolveAndCreate([
- * Car,
- * new Binding(Vehicle, { toAlias: Car })
- * ]);
- *
- * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
- * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
- *
- * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
- * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
- * ```
- */
- toClass: Type;
-
- /**
- * Binds a DI token to a value.
- *
- * ### Example ([live demo](http://plnkr.co/edit/UFVsMVQIDe7l4waWziES?p=preview))
- *
- * ```javascript
- * var injector = Injector.resolveAndCreate([
- * new Binding("message", { toValue: 'Hello' })
- * ]);
- *
- * expect(injector.get("message")).toEqual('Hello');
- * ```
- */
- toValue: any;
-
- /**
- * Binds a DI token as an alias for an existing token.
- *
- * An alias means that {@link Injector} returns the same instance as if the alias token was used.
- * This is in contrast to `toClass` where a separate instance of `toClass` is returned.
- *
- * ### Example ([live demo](http://plnkr.co/edit/QsatsOJJ6P8T2fMe9gr8?p=preview))
- *
- * Because `toAlias` and `toClass` are often confused the example contains both use cases for easy
- * comparison.
- *
- * ```typescript
- * class Vehicle {}
- *
- * class Car extends Vehicle {}
- *
- * var injectorAlias = Injector.resolveAndCreate([
- * Car,
- * new Binding(Vehicle, { toAlias: Car })
- * ]);
- * var injectorClass = Injector.resolveAndCreate([
- * Car,
- * new Binding(Vehicle, { toClass: Car })
- * ]);
- *
- * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
- * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
- *
- * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
- * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
- * ```
- */
- toAlias: any;
-
- /**
- * Binds a DI token to a function which computes the value.
- *
- * ### Example ([live demo](http://plnkr.co/edit/Scoxy0pJNqKGAPZY1VVC?p=preview))
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([
- * new Binding(Number, { toFactory: () => { return 1+2; }}),
- * new Binding(String, { toFactory: (value) => { return "Value: " + value; },
- * deps: [Number] })
- * ]);
- *
- * expect(injector.get(Number)).toEqual(3);
- * expect(injector.get(String)).toEqual('Value: 3');
- * ```
- *
- * Used in conjuction with dependencies.
- */
- toFactory: Function;
-
- /**
- * Specifies a set of dependencies
- * (as `token`s) which should be injected into the factory function.
- *
- * ### Example ([live demo](http://plnkr.co/edit/Scoxy0pJNqKGAPZY1VVC?p=preview))
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([
- * new Binding(Number, { toFactory: () => { return 1+2; }}),
- * new Binding(String, { toFactory: (value) => { return "Value: " + value; },
- * deps: [Number] })
- * ]);
- *
- * expect(injector.get(Number)).toEqual(3);
- * expect(injector.get(String)).toEqual('Value: 3');
- * ```
- *
- * Used in conjunction with `toFactory`.
- */
- dependencies: Object[];
-
- /**
- * Creates multiple bindings matching the same token (a multi-binding).
- *
- * Multi-bindings are used for creating pluggable service, where the system comes
- * with some default bindings, and the user can register additonal bindings.
- * The combination of the default bindings and the additional bindings will be
- * used to drive the behavior of the system.
- *
- * ### Example
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([
- * new Binding("Strings", { toValue: "String1", multi: true}),
- * new Binding("Strings", { toValue: "String2", multi: true})
- * ]);
- *
- * expect(injector.get("Strings")).toEqual(["String1", "String2"]);
- * ```
- *
- * Multi-bindings and regular bindings cannot be mixed. The following
- * will throw an exception:
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([
- * new Binding("Strings", { toValue: "String1", multi: true }),
- * new Binding("Strings", { toValue: "String2"})
- * ]);
- * ```
- */
- multi: boolean;
-
- }
-
-
- /**
- * Helper class for the {@link bind} function.
- */
- class BindingBuilder {
-
- constructor(token: any);
-
- token: any;
-
- /**
- * Binds a DI token to a class.
- *
- * ### Example ([live demo](http://plnkr.co/edit/ZpBCSYqv6e2ud5KXLdxQ?p=preview))
- *
- * Because `toAlias` and `toClass` are often confused, the example contains both use cases for
- * easy comparison.
- *
- * ```typescript
- * class Vehicle {}
- *
- * class Car extends Vehicle {}
- *
- * var injectorClass = Injector.resolveAndCreate([
- * Car,
- * bind(Vehicle).toClass(Car)
- * ]);
- * var injectorAlias = Injector.resolveAndCreate([
- * Car,
- * bind(Vehicle).toAlias(Car)
- * ]);
- *
- * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
- * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
- *
- * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
- * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
- * ```
- */
- toClass(type: Type): Binding;
-
- /**
- * Binds a DI token to a value.
- *
- * ### Example ([live demo](http://plnkr.co/edit/G024PFHmDL0cJFgfZK8O?p=preview))
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([
- * bind('message').toValue('Hello')
- * ]);
- *
- * expect(injector.get('message')).toEqual('Hello');
- * ```
- */
- toValue(value: any): Binding;
-
- /**
- * Binds a DI token as an alias for an existing token.
- *
- * An alias means that we will return the same instance as if the alias token was used. (This is
- * in contrast to `toClass` where a separate instance of `toClass` will be returned.)
- *
- * ### Example ([live demo](http://plnkr.co/edit/uBaoF2pN5cfc5AfZapNw?p=preview))
- *
- * Because `toAlias` and `toClass` are often confused, the example contains both use cases for
- * easy
- * comparison.
- *
- * ```typescript
- * class Vehicle {}
- *
- * class Car extends Vehicle {}
- *
- * var injectorAlias = Injector.resolveAndCreate([
- * Car,
- * bind(Vehicle).toAlias(Car)
- * ]);
- * var injectorClass = Injector.resolveAndCreate([
- * Car,
- * bind(Vehicle).toClass(Car)
- * ]);
- *
- * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
- * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
- *
- * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
- * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
- * ```
- */
- toAlias(aliasToken: /*Type*/ any): Binding;
-
- /**
- * Binds a DI token to a function which computes the value.
- *
- * ### Example ([live demo](http://plnkr.co/edit/OejNIfTT3zb1iBxaIYOb?p=preview))
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([
- * bind(Number).toFactory(() => { return 1+2; }),
- * bind(String).toFactory((v) => { return "Value: " + v; }, [Number])
- * ]);
- *
- * expect(injector.get(Number)).toEqual(3);
- * expect(injector.get(String)).toEqual('Value: 3');
- * ```
- */
- toFactory(factory: Function, dependencies?: any[]): Binding;
-
- }
-
-
- /**
- * An internal resolved representation of a {@link Binding} used by the {@link Injector}.
- *
- * It is usually created automatically by `Injector.resolveAndCreate`.
- *
- * It can be created manually, as follows:
- *
- * ### Example ([live demo](http://plnkr.co/edit/RfEnhh8kUEI0G3qsnIeT?p%3Dpreview&p=preview))
- *
- * ```typescript
- * var resolvedBindings = Injector.resolve([new Binding('message', {toValue: 'Hello'})]);
- * var injector = Injector.fromResolvedBindings(resolvedBindings);
- *
- * expect(injector.get('message')).toEqual('Hello');
- * ```
- */
- interface ResolvedBinding {
-
- /**
- * A key, usually a `Type`.
- */
- key: Key;
-
- }
-
-
- /**
- * @private
- * An internal resolved representation of a factory function created by resolving {@link Binding}.
- */
- class ResolvedFactory {
-
- constructor(factory: Function, dependencies: Dependency[]);
-
- /**
- * Factory function which can return an instance of an object represented by a key.
- */
- factory: Function;
-
- /**
- * Arguments (dependencies) to the `factory` function.
- */
- dependencies: Dependency[];
-
- }
-
-
- /**
- * @private
- */
- class Dependency {
-
- constructor(key: Key, optional: boolean, lowerBoundVisibility: any, upperBoundVisibility: any, properties: any[]);
-
- static fromKey(key: Key): Dependency;
-
- key: Key;
-
- optional: boolean;
-
- lowerBoundVisibility: any;
-
- upperBoundVisibility: any;
-
- properties: any[];
-
- }
-
-
- /**
- * Creates a {@link Binding}.
- *
- * To construct a {@link Binding}, bind a `token` to either a class, a value, a factory function, or
- * to an alias to another `token`.
- * See {@link BindingBuilder} for more details.
- *
- * The `token` is most commonly a class or {@link angular2/di/OpaqueToken}.
- */
- function bind(token: any): BindingBuilder;
-
-
-
- /**
- * A unique object used for retrieving items from the {@link Injector}.
- *
- * Keys have:
- * - a system-wide unique `id`.
- * - a `token`.
- *
- * `Key` is used internally by {@link Injector} because its system-wide unique `id` allows the
- * injector to store created objects in a more efficient way.
- *
- * `Key` should not be created directly. {@link Injector} creates keys automatically when resolving
- * bindings.
- */
- class Key {
-
- /**
- * Private
- */
- constructor(token: Object, id: number);
-
- /**
- * Retrieves a `Key` for a token.
- */
- static get(token: Object): Key;
-
- /**
- * @returns the number of keys registered in the system.
- */
- static numberOfKeys: number;
-
- token: Object;
-
- id: number;
-
- /**
- * Returns a stringified token.
- */
- displayName: string;
-
- }
-
-
- /**
- * @private
- * Type literals is a Dart-only feature. This is here only so we can x-compile
- * to multiple languages.
- */
- class TypeLiteral {
-
- type: any;
-
- }
-
-
- /**
- * Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the
- * {@link Injector} does not have a {@link Binding} for {@link Key}.
- *
- * ### Example ([live demo](http://plnkr.co/edit/vq8D3FRB9aGbnWJqtEPE?p=preview))
- *
- * ```typescript
- * class A {
- * constructor(b:B) {}
- * }
- *
- * expect(() => Injector.resolveAndCreate([A])).toThrowError();
- * ```
- */
- class NoBindingError extends AbstractBindingError {
-
- constructor(injector: Injector, key: Key);
-
- }
-
-
- /**
- * Base class for all errors arising from misconfigured bindings.
- */
- class AbstractBindingError extends BaseException {
-
- constructor(injector: Injector, key: Key, constructResolvingMessage: Function);
-
- addKey(injector: Injector, key: Key): void;
-
- context: any;
-
- }
-
-
- /**
- * Thrown when dependencies form a cycle.
- *
- * ### Example ([live demo](http://plnkr.co/edit/wYQdNos0Tzql3ei1EV9j?p=info))
- *
- * ```typescript
- * var injector = Injector.resolveAndCreate([
- * bind("one").toFactory((two) => "two", [[new Inject("two")]]),
- * bind("two").toFactory((one) => "one", [[new Inject("one")]])
- * ]);
- *
- * expect(() => injector.get("one")).toThrowError();
- * ```
- *
- * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
- */
- class CyclicDependencyError extends AbstractBindingError {
-
- constructor(injector: Injector, key: Key);
-
- }
-
-
- /**
- * Thrown when a constructing type returns with an Error.
- *
- * The `InstantiationError` class contains the original error plus the dependency graph which caused
- * this object to be instantiated.
- *
- * ### Example ([live demo](http://plnkr.co/edit/7aWYdcqTQsP0eNqEdUAf?p=preview))
- *
- * ```typescript
- * class A {
- * constructor() {
- * throw new Error('message');
- * }
- * }
- *
- * var injector = Injector.resolveAndCreate([A]);
- *
- * try {
- * injector.get(A);
- * } catch (e) {
- * expect(e instanceof InstantiationError).toBe(true);
- * expect(e.originalException.message).toEqual("message");
- * expect(e.originalStack).toBeDefined();
- * }
- * ```
- */
- interface InstantiationError extends WrappedException {
-
- addKey(injector: Injector, key: Key): void;
-
- wrapperMessage: string;
-
- causeKey: Key;
-
- context: any;
-
- }
-
-
- /**
- * Thrown when an object other then {@link Binding} (or `Type`) is passed to {@link Injector}
- * creation.
- *
- * ### Example ([live demo](http://plnkr.co/edit/YatCFbPAMCL0JSSQ4mvH?p=preview))
- *
- * ```typescript
- * expect(() => Injector.resolveAndCreate(["not a type"])).toThrowError();
- * ```
- */
- class InvalidBindingError extends BaseException {
-
- constructor(binding: any);
-
- }
-
-
- /**
- * Thrown when the class has no annotation information.
- *
- * Lack of annotation information prevents the {@link Injector} from determining which dependencies
- * need to be injected into the constructor.
- *
- * ### Example ([live demo](http://plnkr.co/edit/rHnZtlNS7vJOPQ6pcVkm?p=preview))
- *
- * ```typescript
- * class A {
- * constructor(b) {}
- * }
- *
- * expect(() => Injector.resolveAndCreate([A])).toThrowError();
- * ```
- *
- * This error is also thrown when the class not marked with {@link @Injectable} has parameter types.
- *
- * ```typescript
- * class B {}
- *
- * class A {
- * constructor(b:B) {} // no information about the parameter types of A is available at runtime.
- * }
- *
- * expect(() => Injector.resolveAndCreate([A,B])).toThrowError();
- * ```
- */
- class NoAnnotationError extends BaseException {
-
- constructor(typeOrFunc: any, params: any[][]);
-
- }
-
-
- /**
- * Thrown when getting an object by index.
- *
- * ### Example ([live demo](http://plnkr.co/edit/bRs0SX2OTQiJzqvjgl8P?p=preview))
- *
- * ```typescript
- * class A {}
- *
- * var injector = Injector.resolveAndCreate([A]);
- *
- * expect(() => injector.getAt(100)).toThrowError();
- * ```
- */
- class OutOfBoundsError extends BaseException {
-
- constructor(index: any);
-
- }
-
-
- /**
- * Creates a token that can be used in a DI Binding.
- *
- * ### Example ([live demo](http://plnkr.co/edit/Ys9ezXpj2Mnoy3Uc8KBp?p=preview))
- *
- * ```typescript
- * var t = new OpaqueToken("binding");
- *
- * var injector = Injector.resolveAndCreate([
- * bind(t).toValue("bindingValue")
- * ]);
- *
- * expect(injector.get(t)).toEqual("bindingValue");
- * ```
- *
- * Using an `OpaqueToken` is preferable to using strings as tokens because of possible collisions
- * caused by multiple bindings using the same string as two different tokens.
- *
- * Using an `OpaqueToken` is preferable to using an `Object` as tokens because it provides better
- * error messages.
- */
- class OpaqueToken {
-
- constructor(_desc: string);
-
- toString(): string;
-
- }
-
-
- /**
- * Factory for creating {@link InjectMetadata}.
- */
- interface InjectFactory {
-
- new(token: any): InjectMetadata;
-
- (token: any): any;
-
- }
-
-
- /**
- * Factory for creating {@link OptionalMetadata}.
- */
- interface OptionalFactory {
-
- new(): OptionalMetadata;
-
- (): any;
-
- }
-
-
- /**
- * Factory for creating {@link InjectableMetadata}.
- */
- interface InjectableFactory {
-
- new(): InjectableMetadata;
-
- (): any;
-
- }
-
-
- /**
- * Factory for creating {@link SelfMetadata}.
- */
- interface SelfFactory {
-
- new(): SelfMetadata;
-
- (): any;
-
- }
-
-
- /**
- * Factory for creating {@link HostMetadata}.
- */
- interface HostFactory {
-
- new(): HostMetadata;
-
- (): any;
-
- }
-
-
- /**
- * Factory for creating {@link SkipSelfMetadata}.
- */
- interface SkipSelfFactory {
-
- new(): SkipSelfMetadata;
-
- (): any;
-
- }
-
-
- /**
- * Factory for creating {@link InjectMetadata}.
- */
- var Inject: InjectFactory;
-
-
-
- /**
- * Factory for creating {@link OptionalMetadata}.
- */
- var Optional: OptionalFactory;
-
-
-
- /**
- * Factory for creating {@link InjectableMetadata}.
- */
- var Injectable: InjectableFactory;
-
-
-
- /**
- * Factory for creating {@link SelfMetadata}.
- */
- var Self: SelfFactory;
-
-
-
- /**
- * Factory for creating {@link HostMetadata}.
- */
- var Host: HostFactory;
-
-
-
- /**
- * Factory for creating {@link SkipSelfMetadata}.
- */
- var SkipSelf: SkipSelfFactory;
-
-
-
- /**
- * The `async` pipe subscribes to an Observable or Promise and returns the latest value it has
- * emitted.
- * When a new value is emitted, the `async` pipe marks the component to be checked for changes.
- *
- * # Example
- * The example below binds the `time` Observable to the view. Every 500ms, the `time` Observable
- * updates the view with the current time.
- *
- * ```
- * import {Observable} from 'angular2/core';
- * @Component({
- * selector: "task-cmp"
- * })
- * @View({
- * template: "Time: {{ time | async }}"
- * })
- * class Task {
- * time = new Observable(observer => {
- * setInterval(_ =>
- * observer.next(new Date().getTime()), 500);
- * });
- * }
- * ```
- */
- class AsyncPipe implements PipeTransform, PipeOnDestroy {
-
- constructor(_ref: ChangeDetectorRef);
-
- onDestroy(): void;
-
- transform(obj: Observable | Promise, args?: any[]): any;
-
- }
-
-
- /**
- * WARNING: this pipe uses the Internationalization API.
- * Therefore it is only reliable in Chrome and Opera browsers.
- *
- * Formats a date value to a string based on the requested format.
- *
- * # Usage
- *
- * expression | date[:format]
- *
- * where `expression` is a date object or a number (milliseconds since UTC epoch) and
- * `format` indicates which date/time components to include:
- *
- * | Component | Symbol | Short Form | Long Form | Numeric | 2-digit |
- * |-----------|:------:|--------------|-------------------|-----------|-----------|
- * | era | G | G (AD) | GGGG (Anno Domini)| - | - |
- * | year | y | - | - | y (2015) | yy (15) |
- * | month | M | MMM (Sep) | MMMM (September) | M (9) | MM (09) |
- * | day | d | - | - | d (3) | dd (03) |
- * | weekday | E | EEE (Sun) | EEEE (Sunday) | - | - |
- * | hour | j | - | - | j (13) | jj (13) |
- * | hour12 | h | - | - | h (1 PM) | hh (01 PM)|
- * | hour24 | H | - | - | H (13) | HH (13) |
- * | minute | m | - | - | m (5) | mm (05) |
- * | second | s | - | - | s (9) | ss (09) |
- * | timezone | z | - | z (Pacific Standard Time)| - | - |
- * | timezone | Z | Z (GMT-8:00) | - | - | - |
- *
- * In javascript, only the components specified will be respected (not the ordering,
- * punctuations, ...) and details of the formatting will be dependent on the locale.
- * On the other hand in Dart version, you can also include quoted text as well as some extra
- * date/time components such as quarter. For more information see:
- * https://api.dartlang.org/apidocs/channels/stable/dartdoc-viewer/intl/intl.DateFormat.
- *
- * `format` can also be one of the following predefined formats:
- *
- * - `'medium'`: equivalent to `'yMMMdjms'` (e.g. Sep 3, 2010, 12:05:08 PM for en-US)
- * - `'short'`: equivalent to `'yMdjm'` (e.g. 9/3/2010, 12:05 PM for en-US)
- * - `'fullDate'`: equivalent to `'yMMMMEEEEd'` (e.g. Friday, September 3, 2010 for en-US)
- * - `'longDate'`: equivalent to `'yMMMMd'` (e.g. September 3, 2010)
- * - `'mediumDate'`: equivalent to `'yMMMd'` (e.g. Sep 3, 2010 for en-US)
- * - `'shortDate'`: equivalent to `'yMd'` (e.g. 9/3/2010 for en-US)
- * - `'mediumTime'`: equivalent to `'jms'` (e.g. 12:05:08 PM for en-US)
- * - `'shortTime'`: equivalent to `'jm'` (e.g. 12:05 PM for en-US)
- *
- * Timezone of the formatted text will be the local system timezone of the end-users machine.
- *
- * # Examples
- *
- * Assuming `dateObj` is (year: 2015, month: 6, day: 15, hour: 21, minute: 43, second: 11)
- * in the _local_ time and locale is 'en-US':
- *
- * {{ dateObj | date }} // output is 'Jun 15, 2015'
- * {{ dateObj | date:'medium' }} // output is 'Jun 15, 2015, 9:43:11 PM'
- * {{ dateObj | date:'shortTime' }} // output is '9:43 PM'
- * {{ dateObj | date:'mmss' }} // output is '43:11'
- */
- class DatePipe implements PipeTransform {
-
- transform(value: any, args: any[]): string;
-
- supports(obj: any): boolean;
-
- }
-
-
- let DEFAULT_PIPES: Binding;
-
-
-
- let DEFAULT_PIPES_TOKEN: OpaqueToken;
-
-
-
- /**
- * Implements json transforms to any object.
- *
- * # Example
- *
- * In this example we transform the user object to json.
- *
- * ```
- * @Component({
- * selector: "user-cmp"
- * })
- * @View({
- * template: "User: {{ user | json }}"
- * })
- * class Username {
- * user:Object
- * constructor() {
- * this.user = { name: "PatrickJS" };
- * }
- * }
- *
- * ```
- */
- class JsonPipe implements PipeTransform {
-
- transform(value: any, args?: any[]): string;
-
- }
-
-
- /**
- * Creates a new List or String containing only a subset (slice) of the
- * elements.
- *
- * The starting index of the subset to return is specified by the `start` parameter.
- *
- * The ending index of the subset to return is specified by the optional `end` parameter.
- *
- * # Usage
- *
- * expression | slice:start[:end]
- *
- * All behavior is based on the expected behavior of the JavaScript API
- * Array.prototype.slice() and String.prototype.slice()
- *
- * Where the input expression is a [List] or [String], and `start` is:
- *
- * - **a positive integer**: return the item at _start_ index and all items after
- * in the list or string expression.
- * - **a negative integer**: return the item at _start_ index from the end and all items after
- * in the list or string expression.
- * - **`|start|` greater than the size of the expression**: return an empty list or string.
- * - **`|start|` negative greater than the size of the expression**: return entire list or
- * string expression.
- *
- * and where `end` is:
- *
- * - **omitted**: return all items until the end of the input
- * - **a positive integer**: return all items before _end_ index of the list or string
- * expression.
- * - **a negative integer**: return all items before _end_ index from the end of the list
- * or string expression.
- *
- * When operating on a [List], the returned list is always a copy even when all
- * the elements are being returned.
- *
- * # Examples
- *
- * ## List Example
- *
- * Assuming `var collection = ['a', 'b', 'c', 'd']`, this `ng-for` directive:
- *
- * {{i}}
- *
- * produces the following:
- *
- * b
- * c
- *
- * ## String Examples
- *
- * {{ 'abcdefghij' | slice:0:4 }} // output is 'abcd'
- * {{ 'abcdefghij' | slice:4:0 }} // output is ''
- * {{ 'abcdefghij' | slice:-4 }} // output is 'ghij'
- * {{ 'abcdefghij' | slice:-4,-2 }} // output is 'gh'
- * {{ 'abcdefghij' | slice: -100 }} // output is 'abcdefghij'
- * {{ 'abcdefghij' | slice: 100 }} // output is ''
- */
- class SlicePipe implements PipeTransform {
-
- transform(value: any, args?: any[]): any;
-
- supports(obj: any): boolean;
-
- }
-
-
- /**
- * Implements lowercase transforms to text.
- *
- * # Example
- *
- * In this example we transform the user text lowercase.
- *
- * ```
- * @Component({
- * selector: "username-cmp"
- * })
- * @View({
- * template: "Username: {{ user | lowercase }}"
- * })
- * class Username {
- * user:string;
- * }
- *
- * ```
- */
- class LowerCasePipe implements PipeTransform {
-
- transform(value: string, args?: any[]): string;
-
- }
-
-
- class NumberPipe {
-
- }
-
-
- /**
- * WARNING: this pipe uses the Internationalization API.
- * Therefore it is only reliable in Chrome and Opera browsers.
- *
- * Formats a number as local text. i.e. group sizing and separator and other locale-specific
- * configurations are based on the active locale.
- *
- * # Usage
- *
- * expression | number[:digitInfo]
- *
- * where `expression` is a number and `digitInfo` has the following format:
- *
- * {minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}
- *
- * - minIntegerDigits is the minimum number of integer digits to use. Defaults to 1.
- * - minFractionDigits is the minimum number of digits after fraction. Defaults to 0.
- * - maxFractionDigits is the maximum number of digits after fraction. Defaults to 3.
- *
- * For more information on the acceptable range for each of these numbers and other
- * details see your native internationalization library.
- *
- * # Examples
- *
- * {{ 123 | number }} // output is 123
- * {{ 123.1 | number: '.2-3' }} // output is 123.10
- * {{ 1 | number: '2.2' }} // output is 01.00
- */
- class DecimalPipe extends NumberPipe implements PipeTransform {
-
- transform(value: any, args: any[]): string;
-
- }
-
-
- /**
- * WARNING: this pipe uses the Internationalization API.
- * Therefore it is only reliable in Chrome and Opera browsers.
- *
- * Formats a number as local percent.
- *
- * # Usage
- *
- * expression | percent[:digitInfo]
- *
- * For more information about `digitInfo` see {@link DecimalPipe}
- */
- class PercentPipe extends NumberPipe implements PipeTransform {
-
- transform(value: any, args: any[]): string;
-
- }
-
-
- /**
- * WARNING: this pipe uses the Internationalization API.
- * Therefore it is only reliable in Chrome and Opera browsers.
- *
- * Formats a number as local currency.
- *
- * # Usage
- *
- * expression | currency[:currencyCode[:symbolDisplay[:digitInfo]]]
- *
- * where `currencyCode` is the ISO 4217 currency code, such as "USD" for the US dollar and
- * "EUR" for the euro. `symbolDisplay` is a boolean indicating whether to use the currency
- * symbol (e.g. $) or the currency code (e.g. USD) in the output. The default for this value
- * is `false`.
- * For more information about `digitInfo` see {@link DecimalPipe}
- */
- class CurrencyPipe extends NumberPipe implements PipeTransform {
-
- transform(value: any, args: any[]): string;
-
- }
-
-
- /**
- * Implements uppercase transforms to text.
- *
- * # Example
- *
- * In this example we transform the user text uppercase.
- *
- * ```
- * @Component({
- * selector: "username-cmp"
- * })
- * @View({
- * template: "Username: {{ user | uppercase }}"
- * })
- * class Username {
- * user:string;
- * }
- *
- * ```
- */
- class UpperCasePipe implements PipeTransform {
-
- transform(value: string, args?: any[]): string;
-
- }
-
-
- /**
- *
- * Runtime representation a type that a Component or other object is instances of.
- *
- * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by
- * the `MyCustomComponent` constructor function.
- */
- interface Type extends Function {
-
- new(...args: any[]): any;
-
- }
-
-
- class Observable {
-
- observer(generator: any): Object;
-
- }
-
-
- /**
- * Use by directives and components to emit custom Events.
- *
- * ## Examples
- *
- * In the following example, `Zippy` alternatively emits `open` and `close` events when its
- * title gets clicked:
- *
- * ```
- * @Component({selector: 'zippy'})
- * @View({template: `
- *
- *
Toggle
- *
- *
- *
- *