Code coverage report for src/observable/fromPromise.ts

Statements: 68.75% (33 / 48)      Branches: 60% (6 / 10)      Functions: 57.14% (8 / 14)      Lines: 65% (26 / 40)      Ignored: none     

All files » src/observable/ » fromPromise.ts
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 691     1 1   1   72     46 23     73 72     87 86 86   86 86 2 2   84 54 54 54 54 30     1                                           1   1         1      
import {Observable} from '../Observable';
import {Subscriber} from '../Subscriber';
import {Scheduler} from '../Scheduler';
import {Subscription} from '../Subscription';
import {queue} from '../scheduler/queue';
 
export class PromiseObservable<T> extends Observable<T> {
 
  _isScalar: boolean = false;
  value: T;
 
  static create<T>(promise: Promise<T>, Escheduler: Scheduler = queue): Observable<T> {
    return new PromiseObservable(promise, scheduler);
  }
 
  constructor(private promise: Promise<T>, public scheduler: Scheduler = queue) {
    super();
  }
 
  _subscribe(subscriber: Subscriber<T>) {
    const scheduler = this.scheduler;
    const promise = this.promise;
 
    Eif (scheduler === queue) {
      if (this._isScalar) {
        subscriber.next(this.value);
        subscriber.complete();
      } else {
        promise.then(value => {
          this._isScalar = true;
          this.value = value;
          subscriber.next(value);
          subscriber.complete();
        }, err => subscriber.error(err))
        .then(null, err => {
          // escape the promise trap, throw unhandled errors
          setTimeout(() => { throw err; });
        });
      }
    } else {
      let subscription = new Subscription();
      if (this._isScalar) {
        const value = this.value;
        subscription.add(scheduler.schedule(dispatchNext, 0, { value, subscriber }));
      } else {
        promise.then(value => {
          this._isScalar = true;
          this.value = value;
          subscription.add(scheduler.schedule(dispatchNext, 0, { value, subscriber }));
        }, err => subscription.add(scheduler.schedule(dispatchError, 0, { err, subscriber })))
        .then(null, err => {
          // escape the promise trap, throw unhandled errors
          scheduler.schedule(() => { throw err; });
        });
      }
      return subscription;
    }
  }
}
 
function dispatchNext({ value, subscriber }) {
  subscriber.next(value);
  subscriber.complete();
}
 
function dispatchError({ err, subscriber }) {
  subscriber.error(err);
}