chore(facade): remove most facade/async functions

modules/@angular/facade/src/async.ts

@@ -6,65 +6,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Observable} from 'rxjs/Observable';
 import {Subject} from 'rxjs/Subject';
-import {PromiseObservable} from 'rxjs/observable/PromiseObservable';
-import {toPromise} from 'rxjs/operator/toPromise';
 
 import {global, noop} from './lang';
 
 export {Observable} from 'rxjs/Observable';
 export {Subject} from 'rxjs/Subject';
-export {PromiseCompleter, PromiseWrapper} from './promise';
-
-export class TimerWrapper {
-  static setTimeout(fn: (...args: any[]) => void, millis: number): number {
-    return global.setTimeout(fn, millis);
-  }
-  static clearTimeout(id: number): void { global.clearTimeout(id); }
-
-  static setInterval(fn: (...args: any[]) => void, millis: number): number {
-    return global.setInterval(fn, millis);
-  }
-  static clearInterval(id: number): void { global.clearInterval(id); }
-}
-
-export class ObservableWrapper {
-  // TODO(vsavkin): when we use rxnext, try inferring the generic type from the first arg
-  static subscribe<T>(
-      emitter: any, onNext: (value: T) => void, onError?: (exception: any) => void,
-      onComplete: () => void = () => {}): Object {
-    onError = (typeof onError === 'function') && onError || noop;
-    onComplete = (typeof onComplete === 'function') && onComplete || noop;
-    return emitter.subscribe({next: onNext, error: onError, complete: onComplete});
-  }
-
-  static isObservable(obs: any): boolean { return !!obs.subscribe; }
-
-  /**
-   * Returns whether `obs` has any subscribers listening to events.
-   */
-  static hasSubscribers(obs: EventEmitter<any>): boolean { return obs.observers.length > 0; }
-
-  static dispose(subscription: any) { subscription.unsubscribe(); }
-
-  /**
-   * @deprecated - use callEmit() instead
-   */
-  static callNext(emitter: EventEmitter<any>, value: any) { emitter.emit(value); }
-
-  static callEmit(emitter: EventEmitter<any>, value: any) { emitter.emit(value); }
-
-  static callError(emitter: EventEmitter<any>, error: any) { emitter.error(error); }
-
-  static callComplete(emitter: EventEmitter<any>) { emitter.complete(); }
-
-  static fromPromise(promise: Promise<any>): Observable<any> {
-    return PromiseObservable.create(promise);
-  }
-
-  static toPromise(obj: Observable<any>): Promise<any> { return toPromise.call(obj); }
-}
 
 /**
  * Use by directives and components to emit custom Events.

modules/@angular/facade/src/promise.ts

@@ -1,61 +0,0 @@
-/**
- * @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
- */
-
-
-export class PromiseCompleter<R> {
-  promise: Promise<R>;
-  resolve: (value?: R|PromiseLike<R>) => void;
-  reject: (error?: any, stackTrace?: string) => void;
-
-  constructor() {
-    this.promise = new Promise((res, rej) => {
-      this.resolve = res;
-      this.reject = rej;
-    });
-  }
-}
-
-export class PromiseWrapper {
-  static resolve<T>(obj: T): Promise<T> { return Promise.resolve(obj); }
-
-  static reject(obj: any, _: any): Promise<any> { return Promise.reject(obj); }
-
-  // Note: We can't rename this method into `catch`, as this is not a valid
-  // method name in Dart.
-  static catchError<T>(promise: Promise<T>, onError: (error: any) => T | PromiseLike<T>):
-      Promise<T> {
-    return promise.catch(onError);
-  }
-
-  static all<T>(promises: (T|Promise<T>)[]): Promise<T[]> {
-    if (promises.length == 0) return Promise.resolve([]);
-    return Promise.all(promises);
-  }
-
-  static then<T, U>(
-      promise: Promise<T>, success: (value: T) => U | PromiseLike<U>,
-      rejection?: (error: any, stack?: any) => U | PromiseLike<U>): Promise<U> {
-    return promise.then(success, rejection);
-  }
-
-  static wrap<T>(computation: () => T): Promise<T> {
-    return new Promise((res, rej) => {
-      try {
-        res(computation());
-      } catch (e) {
-        rej(e);
-      }
-    });
-  }
-
-  static scheduleMicrotask(computation: () => any): void {
-    PromiseWrapper.then(PromiseWrapper.resolve(null), computation, (_) => {});
-  }
-
-  static completer<T>(): PromiseCompleter<T> { return new PromiseCompleter<T>(); }
-}