Code coverage report for src/util/subscribeToResult.ts

Statements: 73.33% (33 / 45)      Branches: 65.38% (17 / 26)      Functions: 60% (3 / 5)      Lines: 76.19% (32 / 42)      Ignored: none     

All files » src/util/ » subscribeToResult.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 69 70 71 72 73 741 1 1   1 1   1     1       2439   2439       2439 2276 470 470 470   1806       163 115 360   115 115   48 42   36 29 29     6           42 6                   6 6 6     6            
import {root} from './root';
import {isArray} from './isArray';
import {isPromise} from './isPromise';
import {Subscriber} from '../Subscriber';
import {Observable} from '../Observable';
import {SymbolShim} from '../util/SymbolShim';
import {Subscription} from '../Subscription';
import {InnerSubscriber} from '../InnerSubscriber';
import {OuterSubscriber} from '../OuterSubscriber';
 
export function subscribeToResult<T, R>(outerSubscriber: OuterSubscriber<T, R>,
                                        result: any,
                                        outerValue?: T,
                                        outerIndex?: number): Subscription {
  let destination: Subscriber<R> = new InnerSubscriber(outerSubscriber, outerValue, outerIndex);
 
  Iif (destination.isUnsubscribed) {
    return;
  }
 
  if (result instanceof Observable) {
    if (result._isScalar) {
      destination.next(result.value);
      destination.complete();
      return;
    } else {
      return result.subscribe(destination);
    }
  }
 
  if (isArray(result)) {
    for (let i = 0, len = result.length; i < len && !destination.isUnsubscribed; i++) {
      destination.next(result[i]);
    }
    Eif (!destination.isUnsubscribed) {
      destination.complete();
    }
  } else if (isPromise(result)) {
    result.then(
      (value: any) => {
        if (!destination.isUnsubscribed) {
          destination.next(value);
          destination.complete();
        }
      },
      (err: any) => destination.error(err)
    )
    .then(null, (err: any) => {
      // Escaping the Promise trap: globally throw unhandled errors
      root.setTimeout(() => { throw err; });
    });
    return destination;
  } else Iif (typeof result[SymbolShim.iterator] === 'function') {
    for (let item of result) {
      destination.next(item);
      if (destination.isUnsubscribed) {
        break;
      }
    }
    if (!destination.isUnsubscribed) {
      destination.complete();
    }
  } else Eif (typeof result[SymbolShim.observable] === 'function') {
    const obs = result[SymbolShim.observable]();
    Iif (typeof obs.subscribe !== 'function') {
      destination.error('invalid observable');
    } else {
      return obs.subscribe(new InnerSubscriber(outerSubscriber, outerValue, outerIndex));
    }
  } else {
    destination.error(new TypeError('unknown type returned'));
  }
}