refactor: remove EventEmitter from facade (#14837)

As of right now each module has its own copy of the EventEmitter
contributing to bloat.

modules/@angular/core/src/core.ts

@@ -29,7 +29,7 @@ export {TRANSLATIONS, TRANSLATIONS_FORMAT, LOCALE_ID, MissingTranslationStrategy
 export {ApplicationModule} from './application_module';
 export {wtfCreateScope, wtfLeave, wtfStartTimeRange, wtfEndTimeRange, WtfScopeFn} from './profile/profile';
 export {Type} from './type';
-export {EventEmitter} from './facade/async';
+export {EventEmitter} from './event_emitter';
 export {ErrorHandler} from './error_handler';
 export * from './core_private_export';
 export {Sanitizer, SecurityContext} from './security';
@@ -59,4 +59,4 @@ export type AnimationStyles = any;
 /**
  * @deprecated from v4
  */
-export type AnimationKeyframe = any;
+export type AnimationKeyframe = any;

modules/@angular/core/src/event_emitter.ts

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Subject} from 'rxjs/Subject';
+
+/**
+ * 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',
+ *   template: `
+ *   <div class="zippy">
+ *     <div (click)="toggle()">Toggle</div>
+ *     <div [hidden]="!visible">
+ *       <ng-content></ng-content>
+ *     </div>
+ *  </div>`})
+ * export class Zippy {
+ *   visible: boolean = true;
+ *   @Output() open: EventEmitter<any> = new EventEmitter();
+ *   @Output() close: EventEmitter<any> = new EventEmitter();
+ *
+ *   toggle() {
+ *     this.visible = !this.visible;
+ *     if (this.visible) {
+ *       this.open.emit(null);
+ *     } else {
+ *       this.close.emit(null);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The events payload can be accessed by the parameter `$event` on the components output event
+ * handler:
+ *
+ * ```
+ * <zippy (open)="onOpen($event)" (close)="onClose($event)"></zippy>
+ * ```
+ *
+ * Uses Rx.Observable but provides an adapter to make it work as specified here:
+ * https://github.com/jhusain/observable-spec
+ *
+ * Once a reference implementation of the spec is available, switch to it.
+ * @stable
+ */
+export class EventEmitter<T> extends Subject<T> {
+  // TODO: mark this as internal once all the facades are gone
+  // we can't mark it as internal now because EventEmitter exported via @angular/core would not
+  // contain this property making it incompatible with all the code that uses EventEmitter via
+  // facades, which are local to the code and do not have this property stripped.
+  // tslint:disable-next-line
+  __isAsync: boolean;
+
+  /**
+   * Creates an instance of [EventEmitter], which depending on [isAsync],
+   * delivers events synchronously or asynchronously.
+   */
+  constructor(isAsync: boolean = false) {
+    super();
+    this.__isAsync = isAsync;
+  }
+
+  emit(value?: T) { super.next(value); }
+
+  subscribe(generatorOrNext?: any, error?: any, complete?: any): any {
+    let schedulerFn: (t: any) => any;
+    let errorFn = (err: any): any => null;
+    let completeFn = (): any => null;
+
+    if (generatorOrNext && typeof generatorOrNext === 'object') {
+      schedulerFn = this.__isAsync ? (value: any) => {
+        setTimeout(() => generatorOrNext.next(value));
+      } : (value: any) => { generatorOrNext.next(value); };
+
+      if (generatorOrNext.error) {
+        errorFn = this.__isAsync ? (err) => { setTimeout(() => generatorOrNext.error(err)); } :
+                                   (err) => { generatorOrNext.error(err); };
+      }
+
+      if (generatorOrNext.complete) {
+        completeFn = this.__isAsync ? () => { setTimeout(() => generatorOrNext.complete()); } :
+                                      () => { generatorOrNext.complete(); };
+      }
+    } else {
+      schedulerFn = this.__isAsync ? (value: any) => { setTimeout(() => generatorOrNext(value)); } :
+                                     (value: any) => { generatorOrNext(value); };
+
+      if (error) {
+        errorFn =
+            this.__isAsync ? (err) => { setTimeout(() => error(err)); } : (err) => { error(err); };
+      }
+
+      if (complete) {
+        completeFn =
+            this.__isAsync ? () => { setTimeout(() => complete()); } : () => { complete(); };
+      }
+    }
+
+    return super.subscribe(schedulerFn, errorFn, completeFn);
+  }
+}

modules/@angular/core/src/linker/query_list.ts

@@ -6,10 +6,13 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {EventEmitter, Observable} from '../facade/async';
+import {Observable} from 'rxjs/Observable';
+
+import {EventEmitter} from '../event_emitter';
 import {ListWrapper} from '../facade/collection';
 import {getSymbolIterator} from '../facade/lang';
 
+
 /**
  * An unmodifiable list of items that Angular keeps up to date when the state
  * of the application changes.

modules/@angular/core/src/zone/ng_zone.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {EventEmitter} from '../facade/async';
+import {EventEmitter} from '../event_emitter';
 
 /**
  * An injectable service for executing work inside or outside of the Angular zone.

modules/@angular/core/test/debug/debug_node_spec.ts

@@ -7,15 +7,13 @@
  */
 
 
-import {Injectable, NO_ERRORS_SCHEMA} from '@angular/core';
+import {EventEmitter, Injectable, NO_ERRORS_SCHEMA} from '@angular/core';
 import {Component, Directive, Input} from '@angular/core/src/metadata';
 import {ComponentFixture, TestBed, async} from '@angular/core/testing';
 import {By} from '@angular/platform-browser/src/dom/debug/by';
 import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
-import {EventEmitter} from '../../src/facade/async';
-
 @Injectable()
 class Logger {
   logs: string[];

modules/@angular/core/test/event_emitter_spec.ts

@@ -0,0 +1,133 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {AsyncTestCompleter, beforeEach, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
+import {EventEmitter} from '../src/event_emitter';
+
+export function main() {
+  describe('EventEmitter', () => {
+    let emitter: EventEmitter<any>;
+
+    beforeEach(() => { emitter = new EventEmitter(); });
+
+    it('should call the next callback',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         emitter.subscribe({
+           next: (value: any) => {
+             expect(value).toEqual(99);
+             async.done();
+           }
+         });
+         emitter.emit(99);
+       }));
+
+    it('should call the throw callback',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         emitter.subscribe({
+           next: () => {},
+           error: (error: any) => {
+             expect(error).toEqual('Boom');
+             async.done();
+           }
+         });
+         emitter.error('Boom');
+       }));
+
+    it('should work when no throw callback is provided',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         emitter.subscribe({next: () => {}, error: (_: any) => { async.done(); }});
+         emitter.error('Boom');
+       }));
+
+    it('should call the return callback',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         emitter.subscribe(
+             {next: () => {}, error: (_: any) => {}, complete: () => { async.done(); }});
+         emitter.complete();
+       }));
+
+    it('should subscribe to the wrapper synchronously', () => {
+      let called = false;
+      emitter.subscribe({next: (value: any) => { called = true; }});
+      emitter.emit(99);
+
+      expect(called).toBe(true);
+    });
+
+    it('delivers next and error events synchronously',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const log: any[] /** TODO #9100 */ = [];
+
+         emitter.subscribe({
+           next: (x: any) => {
+             log.push(x);
+             expect(log).toEqual([1, 2]);
+           },
+           error: (err: any) => {
+             log.push(err);
+             expect(log).toEqual([1, 2, 3, 4]);
+             async.done();
+           }
+         });
+         log.push(1);
+         emitter.emit(2);
+         log.push(3);
+         emitter.error(4);
+         log.push(5);
+       }));
+
+    it('delivers next and complete events synchronously', () => {
+      const log: any[] /** TODO #9100 */ = [];
+
+      emitter.subscribe({
+        next: (x: any) => {
+          log.push(x);
+          expect(log).toEqual([1, 2]);
+        },
+        error: null,
+        complete: () => {
+          log.push(4);
+          expect(log).toEqual([1, 2, 3, 4]);
+        }
+      });
+      log.push(1);
+      emitter.emit(2);
+      log.push(3);
+      emitter.complete();
+      log.push(5);
+      expect(log).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    it('delivers events asynchronously when forced to async mode',
+       inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
+         const e = new EventEmitter(true);
+         const log: any[] /** TODO #9100 */ = [];
+         e.subscribe((x: any) => {
+           log.push(x);
+           expect(log).toEqual([1, 3, 2]);
+           async.done();
+         });
+         log.push(1);
+         e.emit(2);
+         log.push(3);
+
+       }));
+
+    it('reports whether it has subscribers', () => {
+      const e = new EventEmitter(false);
+      expect(e.observers.length > 0).toBe(false);
+      e.subscribe({next: () => {}});
+      expect(e.observers.length > 0).toBe(true);
+    });
+
+    // TODO: vsavkin: add tests cases
+    // should call dispose on the subscription if generator returns {done:true}
+    // should call dispose on the subscription on throw
+    // should call dispose on the subscription on return
+  });
+}

modules/@angular/core/test/facade/observable_spec.ts

@@ -7,8 +7,7 @@
  */
 
 import {AsyncTestCompleter, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
-
-import {Observable} from '../../src/facade/async';
+import {Observable} from 'rxjs/Observable';
 
 export function main() {
   describe('Observable', () => {

modules/@angular/core/test/linker/change_detection_integration_spec.ts

@@ -8,15 +8,13 @@
 
 import {ElementSchemaRegistry} from '@angular/compiler/src/schema/element_schema_registry';
 import {TEST_COMPILER_PROVIDERS} from '@angular/compiler/testing/test_bindings';
-import {AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, DebugElement, Directive, DoCheck, HostBinding, Inject, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, Pipe, PipeTransform, RenderComponentType, Renderer, RendererFactoryV2, RootRenderer, SimpleChange, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, WrappedValue} from '@angular/core';
+import {AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, DebugElement, Directive, DoCheck, EventEmitter, HostBinding, Inject, Injectable, Input, OnChanges, OnDestroy, OnInit, Output, Pipe, PipeTransform, RenderComponentType, Renderer, RendererFactoryV2, RootRenderer, SimpleChange, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, WrappedValue} from '@angular/core';
 import {ComponentFixture, TestBed, fakeAsync} from '@angular/core/testing';
 import {By} from '@angular/platform-browser/src/dom/debug/by';
 import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
 import {expect} from '@angular/platform-browser/testing/matchers';
-
 import {DomElementSchemaRegistry} from '../../../compiler/index';
 import {MockSchemaRegistry} from '../../../compiler/testing/index';
-import {EventEmitter} from '../../src/facade/async';
 
 export function main() {
   let elSchema: MockSchemaRegistry;

modules/@angular/core/test/linker/integration_spec.ts

@@ -7,7 +7,7 @@
  */
 
 import {CommonModule} from '@angular/common';
-import {ComponentFactory, Host, Inject, Injectable, InjectionToken, Injector, NO_ERRORS_SCHEMA, NgModule, OnDestroy, ReflectiveInjector, SkipSelf} from '@angular/core';
+import {ComponentFactory, EventEmitter, Host, Inject, Injectable, InjectionToken, Injector, NO_ERRORS_SCHEMA, NgModule, OnDestroy, ReflectiveInjector, SkipSelf} from '@angular/core';
 import {ChangeDetectionStrategy, ChangeDetectorRef, PipeTransform} from '@angular/core/src/change_detection/change_detection';
 import {getDebugContext} from '@angular/core/src/errors';
 import {ComponentFactoryResolver} from '@angular/core/src/linker/component_factory_resolver';
@@ -23,7 +23,6 @@ import {DOCUMENT} from '@angular/platform-browser/src/dom/dom_tokens';
 import {dispatchEvent, el} from '@angular/platform-browser/testing/browser_util';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
-import {EventEmitter} from '../../src/facade/async';
 import {stringify} from '../../src/facade/lang';
 
 const ANCHOR_ELEMENT = new InjectionToken('AnchorElement');

modules/@angular/core/test/testability/testability_spec.ts

@@ -6,15 +6,16 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {EventEmitter} from '@angular/core';
 import {Injectable} from '@angular/core/src/di';
 import {Testability} from '@angular/core/src/testability/testability';
 import {NgZone} from '@angular/core/src/zone/ng_zone';
 import {AsyncTestCompleter, SpyObject, beforeEach, describe, expect, inject, it} from '@angular/core/testing/testing_internal';
 
-import {EventEmitter} from '../../src/facade/async';
 import {scheduleMicroTask} from '../../src/facade/lang';
 
 
+
 // Schedules a microtasks (using a resolved promise .then())
 function microTask(fn: Function): void {
   scheduleMicroTask(() => {

modules/@angular/core/testing/ng_zone_mock.ts

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Injectable, NgZone} from '@angular/core';
-import {EventEmitter} from './facade/async';
+import {EventEmitter, Injectable, NgZone} from '@angular/core';
+
 
 /**
  * A mock implementation of {@link NgZone}.