feat(TypeScript): fromPromise accepts PromiseLike object (#2505)

* fix(PromiseObservable): can not create observable from promise conform to Promises/A+ spec

* docs(PromiseObservable): update the doc to reflect more relaxed type of promise

* test(fromPromise): ensure Observables can be created from other promise implementations

Author: Sarun Rattanasiri

spec/observables/from-promise-spec.ts

@@ -72,6 +72,25 @@ describe('Observable.fromPromise', () => {
     });
   });
 
+  it('should accept PromiseLike object for interoperability', (done: MochaDone) => {
+    class CustomPromise<T> implements PromiseLike<T> {
+      constructor(private promise: PromiseLike<T>) {
+      }
+      then(onFulfilled?, onRejected?): PromiseLike<T> {
+        return new CustomPromise(this.promise.then(onFulfilled, onRejected));
+      };
+    }
+    const promise = new CustomPromise(Promise.resolve(42));
+    Observable.fromPromise(promise)
+      .subscribe(
+        (x: number) => { expect(x).to.equal(42); },
+        () => {
+          done(new Error('should not be called'));
+        }, () => {
+          done();
+        });
+  });
+
   it('should emit a value from a resolved promise on a separate scheduler', (done: MochaDone) => {
     const promise = Promise.resolve(42);
     Observable.fromPromise(promise, Rx.Scheduler.asap)

src/observable/PromiseObservable.ts

@@ -31,19 +31,19 @@ export class PromiseObservable<T> extends Observable<T> {
    * @see {@link bindCallback}
    * @see {@link from}
    *
-   * @param {Promise<T>} promise The promise to be converted.
+   * @param {PromiseLike<T>} promise The promise to be converted.
    * @param {Scheduler} [scheduler] An optional IScheduler to use for scheduling
    * the delivery of the resolved value (or the rejection).
    * @return {Observable<T>} An Observable which wraps the Promise.
    * @static true
    * @name fromPromise
    * @owner Observable
    */
-  static create<T>(promise: Promise<T>, scheduler?: IScheduler): Observable<T> {
+  static create<T>(promise: PromiseLike<T>, scheduler?: IScheduler): Observable<T> {
     return new PromiseObservable(promise, scheduler);
   }
 
-  constructor(private promise: Promise<T>, private scheduler?: IScheduler) {
+  constructor(private promise: PromiseLike<T>, private scheduler?: IScheduler) {
     super();
   }