Code coverage report for src/observable/fromEventPattern.ts

Statements: 96.67% (29 / 30)      Branches: 100% (6 / 6)      Functions: 85.71% (6 / 7)      Lines: 96.3% (26 / 27)      Ignored: none     

All files » src/observable/ » fromEventPattern.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 441 1 1 1   1   1     5     5 5 5 5     1 5 5 5   5 2 2 1   1       5 5 1   5   4     1  
import {Observable} from '../Observable';
import {Subscription} from '../Subscription';
import {tryCatch} from '../util/tryCatch';
import {errorObject} from '../util/errorObject';
 
export class FromEventPatternObservable<T, R> extends Observable<T> {
 
  static create<T>(addHandler: (handler: Function) => any,
                   removeHandler: (handler: Function) => void,
                   selector?: (...args: Array<any>) => T) {
    return new FromEventPatternObservable(addHandler, removeHandler, selector);
  }
 
  constructor(private addHandler: (handler: Function) => any,
              private removeHandler: (handler: Function) => void,
              private selector?: (...args: Array<any>) => T) {
    super();
  }
 
  _subscribe(subscriber) {
    const addHandler = this.addHandler;
    const removeHandler = this.removeHandler;
    const selector = this.selector;
 
    const handler = selector ? function(e) {
      let result = tryCatch(selector).apply(null, arguments);
      if (result === errorObject) {
        subscriber.error(result.e);
      } else {
        subscriber.next(result);
      }
    } : function(e) { subscriber.next(e); };
 
    let result = tryCatch(addHandler)(handler);
    if (result === errorObject) {
      subscriber.error(result.e);
    }
    subscriber.add(new Subscription(() => {
      //TODO: determine whether or not to forward to error handler
      removeHandler(handler);
    }));
  }
}