honeymoose
/
angular-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore(typings): move comments to decorator args. 

The properties of the annotation classes are not really the public API.
Users will interact with these via a decorator, and the decorator
takes a single arg, typed with the args class. Thus the comment is
more useful on the arg class.

This also fixes the problem of intellisense/autocomplete not showing
the important docs as you fill in the properties in a decorator
declaration.
This commit is contained in:
Alex Eagle 2015-07-06 16:32:29 -07:00
parent b10d7a2e51
commit 8681f79182
3 changed files with 107 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
modules/angular2/src/core/annotations/decorators.ts
View File

@ -36,7 +36,8 @@ export interface IView {
/* from annotations */ /* from annotations */
export var Component: IComponent = <IComponent>makeDecorator(ComponentAnnotation, (fn: any) => fn.View = View); export var Component: IComponent =
<IComponent>makeDecorator(ComponentAnnotation, (fn: any) => fn.View = View);
export var Directive: IDirective = <IDirective>makeDecorator(DirectiveAnnotation); export var Directive: IDirective = <IDirective>makeDecorator(DirectiveAnnotation);
/* from view */ /* from view */

150
modules/angular2/src/core/annotations_impl/annotations.ts
View File

@ -3,8 +3,6 @@ import {List} from 'angular2/src/facade/collection';
import {Injectable, self} from 'angular2/src/di/annotations_impl'; import {Injectable, self} from 'angular2/src/di/annotations_impl';
import {DEFAULT} from 'angular2/change_detection'; import {DEFAULT} from 'angular2/change_detection';
// type StringMap = {[idx: string]: string};
/** /**
* Directives allow you to attach behavior to elements in the DOM. * Directives allow you to attach behavior to elements in the DOM.
* *
@ -410,6 +408,33 @@ import {DEFAULT} from 'angular2/change_detection';
*/ */
@CONST() @CONST()
export class Directive extends Injectable { export class Directive extends Injectable {
selector: string;
properties: List<string>;
events: List<string>;
host: StringMap<string, string>;
lifecycle: List<LifecycleEvent>;
// TODO(vsavkin): This would better fall under the Macro directive concept.
compileChildren: boolean;
hostInjector: List<any>;
exportAs: string;
constructor({
selector, properties, events, host, lifecycle, hostInjector, exportAs,
compileChildren = true,
}: DirectiveArgs = {}) {
super(self);
this.selector = selector;
this.properties = properties;
this.events = events;
this.host = host;
this.exportAs = exportAs;
this.lifecycle = lifecycle;
this.compileChildren = compileChildren;
this.hostInjector = hostInjector;
}
}
export interface DirectiveArgs {
/** /**
* The CSS selector that triggers the instantiation of a directive. * The CSS selector that triggers the instantiation of a directive.
* *
@ -442,7 +467,7 @@ export class Directive extends Injectable {
* The directive would only be instantiated on the `<input type="text">` element. * The directive would only be instantiated on the `<input type="text">` element.
* *
*/ */
selector: string; selector?: string;
/** /**
* Enumerates the set of properties that accept data binding for a directive. * Enumerates the set of properties that accept data binding for a directive.
@ -537,7 +562,7 @@ export class Directive extends Injectable {
* keyValDiff`. * keyValDiff`.
* *
*/ */
properties: List<string>; properties?: List<string>;
/** /**
* Enumerates the set of emitted events. * Enumerates the set of emitted events.
@ -582,7 +607,7 @@ export class Directive extends Injectable {
* ``` * ```
* *
*/ */
events: List<string>; events?: List<string>;
/** /**
* Specifiy the events, actions, properties and attributes related to the host element. * Specifiy the events, actions, properties and attributes related to the host element.
@ -709,7 +734,7 @@ export class Directive extends Injectable {
* *
* In this example calling focus on InputDirective will result in calling focus on the input. * In this example calling focus on InputDirective will result in calling focus on the input.
*/ */
host: StringMap<string, string>; host?: StringMap<string, string>;
/** /**
* Specifies which lifecycle should be notified to the directive. * Specifies which lifecycle should be notified to the directive.
@ -717,13 +742,7 @@ export class Directive extends Injectable {
* See {@link onChange}, {@link onDestroy}, {@link onCheck}, * See {@link onChange}, {@link onDestroy}, {@link onCheck},
* {@link onInit}, {@link onAllChangesDone} for details. * {@link onInit}, {@link onAllChangesDone} for details.
*/ */
lifecycle: List<LifecycleEvent>; lifecycle?: List<LifecycleEvent>;
/**
* If set to false the compiler does not compile the children of this directive.
*/
// TODO(vsavkin): This would better fall under the Macro directive concept.
compileChildren: boolean;
/** /**
* Defines the set of injectable objects that are visible to a Directive and its light dom * Defines the set of injectable objects that are visible to a Directive and its light dom
@ -755,7 +774,7 @@ export class Directive extends Injectable {
* } * }
* ``` * ```
*/ */
hostInjector: List<any>; hostInjector?: List<any>;
/** /**
* Defines the name that can be used in the template to assign this directive to a variable. * Defines the name that can be used in the template to assign this directive to a variable.
@ -782,32 +801,11 @@ export class Directive extends Injectable {
* *
* ``` * ```
*/ */
exportAs: string;
constructor({
selector, properties, events, host, lifecycle, hostInjector, exportAs,
compileChildren = true,
}: DirectiveArgs = {}) {
super(self);
this.selector = selector;
this.properties = properties;
this.events = events;
this.host = host;
this.exportAs = exportAs;
this.lifecycle = lifecycle;
this.compileChildren = compileChildren;
this.hostInjector = hostInjector;
}
}
export interface DirectiveArgs {
selector?: string;
properties?: List<string>;
events?: List<string>;
host?: StringMap<string, string>;
lifecycle?: List<LifecycleEvent>;
hostInjector?: List<any>;
exportAs?: string; exportAs?: string;
/**
* If set to false the compiler does not compile the children of this directive.
*/
compileChildren?: boolean; compileChildren?: boolean;
} }
@ -851,19 +849,28 @@ export interface DirectiveArgs {
*/ */
@CONST() @CONST()
export class Component extends Directive { export class Component extends Directive {
/**
* 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; changeDetection: string;
viewInjector: List<any>;
constructor({selector, properties, events, host, exportAs, lifecycle, hostInjector, viewInjector,
changeDetection = DEFAULT, compileChildren = true}: ComponentArgs = {}) {
super({
selector: selector,
properties: properties,
events: events,
host: host,
exportAs: exportAs,
hostInjector: hostInjector,
lifecycle: lifecycle,
compileChildren: compileChildren
});
this.changeDetection = changeDetection;
this.viewInjector = viewInjector;
}
}
export interface ComponentArgs extends DirectiveArgs {
/** /**
* Defines the set of injectable objects that are visible to its view dom children. * Defines the set of injectable objects that are visible to its view dom children.
* *
@ -904,28 +911,19 @@ export class Component extends Directive {
* *
* ``` * ```
*/ */
viewInjector: List<any>;
constructor({selector, properties, events, host, exportAs, lifecycle, hostInjector, viewInjector,
changeDetection = DEFAULT, compileChildren = true}: ComponentArgs = {}) {
super({
selector: selector,
properties: properties,
events: events,
host: host,
exportAs: exportAs,
hostInjector: hostInjector,
lifecycle: lifecycle,
compileChildren: compileChildren
});
this.changeDetection = changeDetection;
this.viewInjector = viewInjector;
}
}
export interface ComponentArgs extends DirectiveArgs {
viewInjector?: List<any>; viewInjector?: List<any>;
/**
* 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; changeDetection?: string;
} }
@ -959,7 +957,7 @@ export class LifecycleEvent {
* ``` * ```
* @exportedAs angular2/annotations * @exportedAs angular2/annotations
*/ */
export const onDestroy = CONST_EXPR(new LifecycleEvent("onDestroy")); export const onDestroy: LifecycleEvent = CONST_EXPR(new LifecycleEvent("onDestroy"));
/** /**
@ -997,7 +995,7 @@ export const onDestroy = CONST_EXPR(new LifecycleEvent("onDestroy"));
* ``` * ```
* @exportedAs angular2/annotations * @exportedAs angular2/annotations
*/ */
export const onChange = CONST_EXPR(new LifecycleEvent("onChange")); export const onChange: LifecycleEvent = CONST_EXPR(new LifecycleEvent("onChange"));
/** /**
* Notify a directive when it has been checked. * Notify a directive when it has been checked.
@ -1021,7 +1019,7 @@ export const onChange = CONST_EXPR(new LifecycleEvent("onChange"));
* ``` * ```
* @exportedAs angular2/annotations * @exportedAs angular2/annotations
*/ */
export const onCheck = CONST_EXPR(new LifecycleEvent("onCheck")); export const onCheck: LifecycleEvent = CONST_EXPR(new LifecycleEvent("onCheck"));
/** /**
* Notify a directive when it has been checked the first itme. * Notify a directive when it has been checked the first itme.
@ -1045,7 +1043,7 @@ export const onCheck = CONST_EXPR(new LifecycleEvent("onCheck"));
* ``` * ```
* @exportedAs angular2/annotations * @exportedAs angular2/annotations
*/ */
export const onInit = CONST_EXPR(new LifecycleEvent("onInit")); export const onInit: LifecycleEvent = CONST_EXPR(new LifecycleEvent("onInit"));
/** /**
* Notify a directive when the bindings of all its children have been checked (whether they have * Notify a directive when the bindings of all its children have been checked (whether they have
@ -1067,4 +1065,4 @@ export const onInit = CONST_EXPR(new LifecycleEvent("onInit"));
* ``` * ```
* @exportedAs angular2/annotations * @exportedAs angular2/annotations
*/ */
export const onAllChangesDone = CONST_EXPR(new LifecycleEvent("onAllChangesDone")); export const onAllChangesDone: LifecycleEvent = CONST_EXPR(new LifecycleEvent("onAllChangesDone"));

62
modules/angular2/src/core/annotations_impl/view.ts
View File

@ -35,29 +35,39 @@ import {ABSTRACT, CONST, Type} from 'angular2/src/facade/lang';
*/ */
@CONST() @CONST()
export class View { export class View {
templateUrl: string;
template: string;
styleUrls: List<string>;
styles: List<string>;
// TODO(tbosch): use Type | Binding | List<any> when Dart supports union types,
// as otherwise we would need to import Binding type and Dart would warn
// for an unused import.
directives: List<Type | any | List<any>>;
renderer: string;
constructor({templateUrl, template, directives, renderer, styles, styleUrls}: ViewArgs = {}) {
this.templateUrl = templateUrl;
this.template = template;
this.styleUrls = styleUrls;
this.styles = styles;
this.directives = directives;
this.renderer = renderer;
}
}
export interface ViewArgs {
/** /**
* Specifies a template URL for an angular component. * Specifies a template URL for an angular component.
* *
* NOTE: either `templateUrl` or `template` should be used, but not both. * NOTE: either `templateUrl` or `template` should be used, but not both.
*/ */
templateUrl: string; templateUrl?: string;
/** /**
* Specifies an inline template for an angular component. * Specifies an inline template for an angular component.
* *
* NOTE: either `templateUrl` or `template` should be used, but not both. * NOTE: either `templateUrl` or `template` should be used, but not both.
*/ */
template: string; template?: string;
/**
* Specifies stylesheet URLs for an angular component.
*/
styleUrls: List<string>;
/**
* Specifies an inline stylesheet for an angular component.
*/
styles: List<string>;
/** /**
* Specifies a list of directives that can be used within a template. * Specifies a list of directives that can be used within a template.
@ -81,32 +91,22 @@ export class View {
* } * }
* ``` * ```
*/ */
// TODO(tbosch): use Type | Binding | List<any> when Dart supports union types, directives?: List<Type | any | List<any>>;
// as otherwise we would need to import Binding type and Dart would warn
// for an unused import.
directives: List<Type | any | List<any>>;
/** /**
* Specify a custom renderer for this View. * Specify a custom renderer for this View.
* If this is set, neither `template`, `templateUrl`, `styles`, `styleUrls` nor `directives` are * If this is set, neither `template`, `templateUrl`, `styles`, `styleUrls` nor `directives` are
* used. * used.
*/ */
renderer: string;
constructor({templateUrl, template, directives, renderer, styles, styleUrls}: ViewArgs = {}) {
this.templateUrl = templateUrl;
this.template = template;
this.styleUrls = styleUrls;
this.styles = styles;
this.directives = directives;
this.renderer = renderer;
}
}
export interface ViewArgs {
templateUrl?: string;
template?: string;
directives?: List<Type | any | List<any>>;
renderer?: string; renderer?: string;
/**
* Specifies an inline stylesheet for an angular component.
*/
styles?: List<string>; styles?: List<string>;
/**
* Specifies stylesheet URLs for an angular component.
*/
styleUrls?: List<string>; styleUrls?: List<string>;
} }