feat(core): renames Property into Input and Event into Output

BREACKING CHANGE:

Before: @Directive({properties: ['one'], events: ['two']})
After: @Directive({inputs: ['one'], outputs: ['two']})

Before: @Component({properties: ['one'], events: ['two']})
After: @Componet({inputs: ['one'], outputs: ['two']})

Before: class A {@Property() one; @Event() two;}
After: class A {@Input() one; @Output() two;}

modules/angular2/src/compiler/change_definition_factory.ts

@@ -77,8 +77,8 @@ class ProtoViewVisitor implements TemplateAstVisitor {
     if (ast.isBound()) {
       this.boundElementCount++;
     }
-    templateVisitAll(this, ast.properties, null);
-    templateVisitAll(this, ast.events);
+    templateVisitAll(this, ast.inputs, null);
+    templateVisitAll(this, ast.outputs);
     templateVisitAll(this, ast.exportAsVars);
     for (var i = 0; i < ast.directives.length; i++) {
       ast.directives[i].visit(this, i);
@@ -158,7 +158,7 @@ class ProtoViewVisitor implements TemplateAstVisitor {
     });
     this.directiveRecords.push(directiveRecord);
 
-    templateVisitAll(this, ast.properties, directiveRecord);
+    templateVisitAll(this, ast.inputs, directiveRecord);
     var bindingRecords = this.bindingRecords;
     if (directiveRecord.callOnChanges) {
       bindingRecords.push(BindingRecord.createDirectiveOnChanges(directiveRecord));

modules/angular2/src/compiler/command_compiler.ts

@@ -246,7 +246,7 @@ class CommandBuilderVisitor<R> implements TemplateAstVisitor {
   }
   visitElement(ast: ElementAst, context: any): any {
     var component = ast.getComponent();
-    var eventTargetAndNames = visitAndReturnContext(this, ast.events, []);
+    var eventTargetAndNames = visitAndReturnContext(this, ast.outputs, []);
     var variableNameAndValues = [];
     if (isBlank(component)) {
       ast.exportAsVars.forEach((varAst) => {

modules/angular2/src/compiler/directive_metadata.ts

@@ -94,16 +94,16 @@ export class CompileTemplateMetadata {
 }
 
 export class CompileDirectiveMetadata {
-  static create({type, isComponent, dynamicLoadable, selector, exportAs, changeDetection,
-                 properties, events, host, lifecycleHooks, template}: {
+  static create({type, isComponent, dynamicLoadable, selector, exportAs, changeDetection, inputs,
+                 outputs, host, lifecycleHooks, template}: {
     type?: CompileTypeMetadata,
     isComponent?: boolean,
     dynamicLoadable?: boolean,
     selector?: string,
     exportAs?: string,
     changeDetection?: ChangeDetectionStrategy,
-    properties?: string[],
-    events?: string[],
+    inputs?: string[],
+    outputs?: string[],
     host?: StringMap<string, string>,
     lifecycleHooks?: LifecycleHooks[],
     template?: CompileTemplateMetadata
@@ -123,22 +123,22 @@ export class CompileDirectiveMetadata {
         }
       });
     }
-    var propsMap = {};
-    if (isPresent(properties)) {
-      properties.forEach((bindConfig: string) => {
+    var inputsMap = {};
+    if (isPresent(inputs)) {
+      inputs.forEach((bindConfig: string) => {
         // canonical syntax: `dirProp: elProp`
         // if there is no `:`, use dirProp = elProp
         var parts = splitAtColon(bindConfig, [bindConfig, bindConfig]);
-        propsMap[parts[0]] = parts[1];
+        inputsMap[parts[0]] = parts[1];
       });
     }
-    var eventsMap = {};
-    if (isPresent(events)) {
-      events.forEach((bindConfig: string) => {
+    var outputsMap = {};
+    if (isPresent(outputs)) {
+      outputs.forEach((bindConfig: string) => {
         // canonical syntax: `dirProp: elProp`
         // if there is no `:`, use dirProp = elProp
         var parts = splitAtColon(bindConfig, [bindConfig, bindConfig]);
-        eventsMap[parts[0]] = parts[1];
+        outputsMap[parts[0]] = parts[1];
       });
     }
 
@@ -149,8 +149,8 @@ export class CompileDirectiveMetadata {
       selector: selector,
       exportAs: exportAs,
       changeDetection: changeDetection,
-      properties: propsMap,
-      events: eventsMap,
+      inputs: inputsMap,
+      outputs: outputsMap,
       hostListeners: hostListeners,
       hostProperties: hostProperties,
       hostAttributes: hostAttributes,
@@ -164,23 +164,23 @@ export class CompileDirectiveMetadata {
   selector: string;
   exportAs: string;
   changeDetection: ChangeDetectionStrategy;
-  properties: StringMap<string, string>;
-  events: StringMap<string, string>;
+  inputs: StringMap<string, string>;
+  outputs: StringMap<string, string>;
   hostListeners: StringMap<string, string>;
   hostProperties: StringMap<string, string>;
   hostAttributes: StringMap<string, string>;
   lifecycleHooks: LifecycleHooks[];
   template: CompileTemplateMetadata;
-  constructor({type, isComponent, dynamicLoadable, selector, exportAs, changeDetection, properties,
-               events, hostListeners, hostProperties, hostAttributes, lifecycleHooks, template}: {
+  constructor({type, isComponent, dynamicLoadable, selector, exportAs, changeDetection, inputs,
+               outputs, hostListeners, hostProperties, hostAttributes, lifecycleHooks, template}: {
     type?: CompileTypeMetadata,
     isComponent?: boolean,
     dynamicLoadable?: boolean,
     selector?: string,
     exportAs?: string,
     changeDetection?: ChangeDetectionStrategy,
-    properties?: StringMap<string, string>,
-    events?: StringMap<string, string>,
+    inputs?: StringMap<string, string>,
+    outputs?: StringMap<string, string>,
     hostListeners?: StringMap<string, string>,
     hostProperties?: StringMap<string, string>,
     hostAttributes?: StringMap<string, string>,
@@ -193,8 +193,8 @@ export class CompileDirectiveMetadata {
     this.selector = selector;
     this.exportAs = exportAs;
     this.changeDetection = changeDetection;
-    this.properties = properties;
-    this.events = events;
+    this.inputs = inputs;
+    this.outputs = outputs;
     this.hostListeners = hostListeners;
     this.hostProperties = hostProperties;
     this.hostAttributes = hostAttributes;
@@ -212,8 +212,8 @@ export class CompileDirectiveMetadata {
       changeDetection: isPresent(data['changeDetection']) ?
                            CHANGE_DECTION_STRATEGY_VALUES[data['changeDetection']] :
                            data['changeDetection'],
-      properties: data['properties'],
-      events: data['events'],
+      inputs: data['inputs'],
+      outputs: data['outputs'],
       hostListeners: data['hostListeners'],
       hostProperties: data['hostProperties'],
       hostAttributes: data['hostAttributes'],
@@ -233,8 +233,8 @@ export class CompileDirectiveMetadata {
       'type': isPresent(this.type) ? this.type.toJson() : this.type,
       'changeDetection': isPresent(this.changeDetection) ? serializeEnum(this.changeDetection) :
                                                            this.changeDetection,
-      'properties': this.properties,
-      'events': this.events,
+      'inputs': this.inputs,
+      'outputs': this.outputs,
       'hostListeners': this.hostListeners,
       'hostProperties': this.hostProperties,
       'hostAttributes': this.hostAttributes,
@@ -253,8 +253,8 @@ export function createHostComponentMeta(componentType: CompileTypeMetadata,
     template: new CompileTemplateMetadata(
         {template: template, templateUrl: '', styles: [], styleUrls: [], ngContentSelectors: []}),
     changeDetection: ChangeDetectionStrategy.Default,
-    properties: [],
-    events: [],
+    inputs: [],
+    outputs: [],
     host: {},
     lifecycleHooks: [],
     isComponent: true,

modules/angular2/src/compiler/runtime_metadata.ts

@@ -58,8 +58,8 @@ export class RuntimeMetadataResolver {
             {name: stringify(directiveType), moduleId: moduleId, runtime: directiveType}),
         template: templateMeta,
         changeDetection: changeDetectionStrategy,
-        properties: directiveAnnotation.properties,
-        events: directiveAnnotation.events,
+        inputs: directiveAnnotation.inputs,
+        outputs: directiveAnnotation.outputs,
         host: directiveAnnotation.host,
         lifecycleHooks: ListWrapper.filter(LIFECYCLE_HOOKS_VALUES,
                                            hook => hasLifecycleHook(hook, directiveType))

modules/angular2/src/compiler/template_ast.ts

@@ -56,7 +56,7 @@ export class VariableAst implements TemplateAst {
 
 export class ElementAst implements TemplateAst {
   constructor(public name: string, public attrs: AttrAst[],
-              public properties: BoundElementPropertyAst[], public events: BoundEventAst[],
+              public inputs: BoundElementPropertyAst[], public outputs: BoundEventAst[],
               public exportAsVars: VariableAst[], public directives: DirectiveAst[],
               public children: TemplateAst[], public ngContentIndex: number,
               public sourceInfo: string) {}
@@ -65,7 +65,7 @@ export class ElementAst implements TemplateAst {
   }
 
   isBound(): boolean {
-    return (this.properties.length > 0 || this.events.length > 0 || this.exportAsVars.length > 0 ||
+    return (this.inputs.length > 0 || this.outputs.length > 0 || this.exportAsVars.length > 0 ||
             this.directives.length > 0);
   }
 
@@ -95,7 +95,7 @@ export class BoundDirectivePropertyAst implements TemplateAst {
 
 export class DirectiveAst implements TemplateAst {
   constructor(public directive: CompileDirectiveMetadata,
-              public properties: BoundDirectivePropertyAst[],
+              public inputs: BoundDirectivePropertyAst[],
               public hostProperties: BoundElementPropertyAst[], public hostEvents: BoundEventAst[],
               public exportAsVars: VariableAst[], public sourceInfo: string) {}
   visit(visitor: TemplateAstVisitor, context: any): any {

modules/angular2/src/compiler/template_compiler.ts

@@ -65,8 +65,8 @@ export class TemplateCompiler {
           selector: directive.selector,
           exportAs: directive.exportAs,
           changeDetection: directive.changeDetection,
-          properties: directive.properties,
-          events: directive.events,
+          inputs: directive.inputs,
+          outputs: directive.outputs,
           hostListeners: directive.hostListeners,
           hostProperties: directive.hostProperties,
           hostAttributes: directive.hostAttributes,

modules/angular2/src/compiler/template_parser.ts

@@ -415,7 +415,7 @@ class TemplateParseVisitor implements HtmlAstVisitor {
       this._createDirectiveHostPropertyAsts(elementName, directive.hostProperties, sourceInfo,
                                             hostProperties);
       this._createDirectiveHostEventAsts(directive.hostListeners, sourceInfo, hostEvents);
-      this._createDirectivePropertyAsts(directive.properties, props, directiveProperties);
+      this._createDirectivePropertyAsts(directive.inputs, props, directiveProperties);
       var exportAsVars = [];
       possibleExportAsVars.forEach((varAst) => {
         if ((varAst.value.length === 0 && directive.isComponent) ||
@@ -489,7 +489,7 @@ class TemplateParseVisitor implements HtmlAstVisitor {
     var boundElementProps: BoundElementPropertyAst[] = [];
     var boundDirectivePropsIndex = new Map<string, BoundDirectivePropertyAst>();
     directives.forEach((directive: DirectiveAst) => {
-      directive.properties.forEach((prop: BoundDirectivePropertyAst) => {
+      directive.inputs.forEach((prop: BoundDirectivePropertyAst) => {
         boundDirectivePropsIndex.set(prop.templateName, prop);
       });
     });