Code coverage report for src/observable/BoundNodeCallbackObservable.ts

Statements: 98.73% (78 / 79)      Branches: 89.29% (25 / 28)      Functions: 100% (10 / 10)      Lines: 98.63% (72 / 73)      Ignored: none     

All files » src/observable/ » BoundNodeCallbackObservable.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 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 1191       1 1 1   1     1 16   23 13       13 13 13 13 13     1 14 14 14 14   14 5 5 14 5 5 5   5 1 4 2 2 1   1 1     2 2       5   5 5       5   9     1   1 9 9 9 9   9 8   26 7 7 7   7 1 6 3 3 1   2     3 3       8   8 8 1       9     1 5 5     1 1    
import {Observable} from '../Observable';
import {Subscriber} from '../Subscriber';
import {Subscription} from '../Subscription';
import {Scheduler} from '../Scheduler';
import {tryCatch} from '../util/tryCatch';
import {errorObject} from '../util/errorObject';
import {AsyncSubject} from '../subject/AsyncSubject';
 
export class BoundNodeCallbackObservable<T> extends Observable<T> {
  subject: AsyncSubject<T>;
 
  static create<T>(callbackFunc: Function,
                   selector: Function = undefined,
                   scheduler?: Scheduler): Function {
    return (...args: any[]): Observable<T> => {
      return new BoundNodeCallbackObservable(callbackFunc, selector, args, scheduler);
    };
  }
 
  constructor(private callbackFunc: Function,
              private selector: Function,
              private args: any[],
              public scheduler: Scheduler) {
    super();
  }
 
  protected _subscribe(subscriber: Subscriber<T | T[]>): Subscription {
    const callbackFunc = this.callbackFunc;
    const args = this.args;
    const scheduler = this.scheduler;
    let subject = this.subject;
 
    if (!scheduler) {
      Eif (!subject) {
        subject = this.subject = new AsyncSubject<T>();
        const handler = function handlerFn(...innerArgs: any[]) {
          const source = (<any>handlerFn).source;
          const { selector, subject } = source;
          const err = innerArgs.shift();
 
          if (err) {
            subject.error(err);
          } else if (selector) {
            const result = tryCatch(selector).apply(this, innerArgs);
            if (result === errorObject) {
              subject.error(errorObject.e);
            } else {
              subject.next(result);
              subject.complete();
            }
          } else {
            subject.next(innerArgs.length === 1 ? innerArgs[0] : innerArgs);
            subject.complete();
          }
        };
        // use named function instance to avoid closure.
        (<any>handler).source = this;
 
        const result = tryCatch(callbackFunc).apply(this, args.concat(handler));
        Iif (result === errorObject) {
          subject.error(errorObject.e);
        }
      }
      return subject.subscribe(subscriber);
    } else {
      return scheduler.schedule(dispatch, 0, { source: this, subscriber });
    }
  }
}
 
function dispatch<T>(state: { source: BoundNodeCallbackObservable<T>, subscriber: Subscriber<T> }) {
  const self = (<Subscription> this);
  const { source, subscriber } = state;
  const { callbackFunc, args, scheduler } = source;
  let subject = source.subject;
 
  if (!subject) {
    subject = source.subject = new AsyncSubject<T>();
 
    const handler = function handlerFn(...innerArgs: any[]) {
      const source = (<any>handlerFn).source;
      const { selector, subject } = source;
      const err = innerArgs.shift();
 
      if (err) {
        subject.error(err);
      } else if (selector) {
        const result = tryCatch(selector).apply(this, innerArgs);
        if (result === errorObject) {
          self.add(scheduler.schedule(dispatchError, 0, { err: errorObject.e, subject }));
        } else {
          self.add(scheduler.schedule(dispatchNext, 0, { value: result, subject }));
        }
      } else {
        const value = innerArgs.length === 1 ? innerArgs[0] : innerArgs;
        self.add(scheduler.schedule(dispatchNext, 0, { value, subject }));
      }
    };
    // use named function to pass values in without closure
    (<any>handler).source = source;
 
    const result = tryCatch(callbackFunc).apply(this, args.concat(handler));
    if (result === errorObject) {
      subject.error(errorObject.e);
    }
  }
 
  self.add(subject.subscribe(subscriber));
}
 
function dispatchNext({ value, subject }) {
  subject.next(value);
  subject.complete();
}
 
function dispatchError({ err, subject }) {
  subject.error(err);
}