feat(facade): do not reexport Observable from angular2/core

BREAKING CHANGE

Before import {Observable} from 'angular2/core'

After import {Observable} from 'rxjs/Observable';

modules/angular2/src/facade/async.ts

@@ -4,14 +4,15 @@ import {global, isPresent, noop} from 'angular2/src/facade/lang';
 import {Promise} from 'angular2/src/facade/promise';
 export {PromiseWrapper, Promise, PromiseCompleter} from 'angular2/src/facade/promise';
 
+import {Observable} from 'rxjs/Observable';
 import {Subject} from 'rxjs/Subject';
-import {Observable as RxObservable} from 'rxjs/Observable';
 import {Subscription} from 'rxjs/Subscription';
 import {Operator} from 'rxjs/Operator';
 
 import {PromiseObservable} from 'rxjs/observable/fromPromise';
 import {toPromise} from 'rxjs/operator/toPromise';
 
+export {Observable} from 'rxjs/Observable';
 export {Subject} from 'rxjs/Subject';
 
 export namespace NodeJS {
@@ -160,74 +161,4 @@ export class EventEmitter<T> extends Subject<T> {
 
     return super.subscribe(schedulerFn, errorFn, completeFn);
   }
-}
-
-/**
- * Allows publishing and subscribing to series of async values.
- *
- * The `Observable` class is an alias to the `Observable` returned from
- * {@link https://github.com/reactivex/rxjs}. `Observables` are a means of delivering
- * any number of values over any period of time. `Observables` can be thought of as a
- * mixture of `Promise` and `Array`. `Observables` are like `Arrays` in that they can have
- * chained combinators -- like `map`, `reduce`, and `filter` -- attached in order to
- * perform projections and transformations of data. And they are like `Promises`
- * in that they can asynchronously deliver values. But unlike a `Promise`, an
- * `Observable` can emit many values over time, and decides if/when it is completed.
- *
- * `Observable` is also being considered for inclusion in the
- * [ECMAScript spec](https://github.com/zenparsing/es-observable).
- *
- * ## Example
- *
- * A simple example of using an `Observable` is a timer `Observable`, which will
- * notify an `Observer` each time an interval has completed.
- *
- * {@example facade/ts/async/observable.ts region='Observable'}
- *
- * The `Observable` in Angular currently doesn't provide any combinators by default.
- * So it's necessary to explicitly import any combinators that an application requires.
- * There are two ways to import RxJS combinators: pure and patched. The "pure" approach
- * involves importing a combinator as a function every place that an application needs it,
- * then calling the function with the source observable as the context of the function.
- *
- * ## Example
- *
- * {@example facade/ts/async/observable_pure.ts region='Observable'}
- *
- * The "patched" approach to using combinators is to import a special module for
- * each combinator, which will automatically cause the combinator to be patched
- * to the `Observable` prototype, which will make it available to use anywhere in
- * an application after the combinator has been imported once.
- *
- * ## Example
- *
- * (Notice the extra "add" in the path to import `map`)
- *
- * {@example facade/ts/async/observable_patched.ts region='Observable'}
- *
- * Notice that the sequence of operations is now able to be expressed "left-to-right"
- * because `map` is on the `Observable` prototype. For a simple example like this one,
- * the left-to-right expression may seem insignificant. However, when several operators
- * are used in combination, the "callback tree" grows several levels deep, and becomes
- * difficult to read. For this reason, the "patched" approach is the recommended approach
- * to add new operators to `Observable`.
- *
- * For applications that are less sensitive about payload size, the set of core operators
- * can be patched onto the `Observable` prototype with a single import, by importing the
- * `rxjs` module.
- *
- * {@example facade/ts/async/observable_all.ts region='Observable'}
- *
- * Full documentation on RxJS `Observable` and available combinators can be found
- * in the RxJS [Observable docs](http://reactivex.io/RxJS/class/es6/Observable.js~Observable.html).
- *
- */
-// todo(robwormald): ts2dart should handle this properly
-export class Observable<T> extends RxObservable<T> {
-  lift<T, R>(operator: Operator<T, R>): Observable<T> {
-    const observable = new Observable();
-    observable.source = this;
-    observable.operator = operator;
-    return observable;
-  }
-}
+}

modules/angular2/src/facade/facade.ts

@@ -1,5 +1,5 @@
 // Public API for Facade
 export {ConcreteType, Type} from './lang';
-export {Observable, EventEmitter} from './async';
+export {EventEmitter} from './async';
 export {WrappedException} from './exceptions';
 export {ExceptionHandler} from './exception_handler';

modules/angular2/src/http/backends/jsonp_backend.ts

@@ -7,7 +7,7 @@ import {Injectable} from 'angular2/core';
 import {BrowserJsonp} from './browser_jsonp';
 import {makeTypeError} from 'angular2/src/facade/exceptions';
 import {StringWrapper, isPresent} from 'angular2/src/facade/lang';
-import {Observable} from 'angular2/core';
+import {Observable} from 'rxjs/Observable';
 
 const JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';
 const JSONP_ERR_WRONG_METHOD = 'JSONP requests must use GET request method.';

modules/angular2/src/http/backends/xhr_backend.ts

@@ -7,7 +7,7 @@ import {ResponseOptions, BaseResponseOptions} from '../base_response_options';
 import {Injectable} from 'angular2/core';
 import {BrowserXhr} from './browser_xhr';
 import {isPresent} from 'angular2/src/facade/lang';
-import {Observable} from 'angular2/core';
+import {Observable} from 'rxjs/Observable';
 import {isSuccess, getResponseURL} from '../http_utils';
 /**
 * Creates connections using `XMLHttpRequest`. Given a fully-qualified

modules/angular2/src/http/http.ts

@@ -6,7 +6,7 @@ import {Request} from './static_request';
 import {Response} from './static_response';
 import {BaseRequestOptions, RequestOptions} from './base_request_options';
 import {RequestMethod} from './enums';
-import {Observable} from 'angular2/core';
+import {Observable} from 'rxjs/Observable';
 
 function httpRequest(backend: ConnectionBackend, request: Request): Observable<Response> {
   return backend.createConnection(request).response;