hunk.code_window: {
     "name": "rxjs/testing",
     "typings": "./index.d.ts",
     "main": "./index.js",
     "module": "../_esm5/testing/index.js",
     "es2015": "../_esm2015/testing/index.js"
   }
hunk.labels: keep keep keep keep keep replace keep
hunk.after_edit:   "es2015": "../_esm2015/testing/index.js",
     "sideEffects": false
  
hunk.file_path: src/testing/package.json
hunk.type: replace
file: import { Observable } from '../Observable';
  import { Operator } from '../Operator';
  import { Subscriber } from '../Subscriber';
  import { EmptyError } from '../util/EmptyError';
  
  import { Observer, MonoTypeOperatorFunction, TeardownLogic } from '../types';
  
  /**
   * Returns an Observable that emits the single item emitted by the source Observable that matches a specified
   * predicate, if that Observable emits one such item. If the source Observable emits more than one such item or no
   * such items, notify of an IllegalArgumentException or NoSuchElementException respectively.
   *
   * <img src="./img/single.png" width="100%">
   *
   * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
   * callback if the Observable completes before any `next` notification was sent.
   * @param {Function} predicate - A predicate function to evaluate items emitted by the source Observable.
   * @return {Observable<T>} An Observable that emits the single item emitted by the source Observable that matches
   * the predicate.
   .
   * @method single
   * @owner Observable
   */
  export function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): MonoTypeOperatorFunction<T> {
    return (source: Observable<T>) => source.lift(new SingleOperator(predicate, source));
  }
  
  class SingleOperator<T> implements Operator<T, T> {
    constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                private source?: Observable<T>) {
    }
  
    call(subscriber: Subscriber<T>, source: any): TeardownLogic {
      return source.subscribe(new SingleSubscriber(subscriber, this.predicate, this.source));
    }
  }
  
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  class SingleSubscriber<T> extends Subscriber<T> {
    private seenValue: boolean = false;
    private singleValue: T;
    private index: number = 0;
  
    constructor(destination: Observer<T>,
                private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                private source?: Observable<T>) {
      super(destination);
    }
  
    private applySingleValue(value: T): void {
      if (this.seenValue) {
        this.destination.error('Sequence contains more than one element');
      } else {
        this.seenValue = true;
        this.singleValue = value;
      }
    }
  
    protected _next(value: T): void {
      const index = this.index++;
  
      if (this.predicate) {
        this.tryNext(value, index);
      } else {
        this.applySingleValue(value);
      }
    }
  
    private tryNext(value: T, index: number): void {
      try {
        if (this.predicate(value, index, this.source)) {
          this.applySingleValue(value);
        }
      } catch (err) {
        this.destination.error(err);
      }
    }
  
    protected _complete(): void {
      const destination = this.destination;
  
      if (this.index > 0) {
        destination.next(this.seenValue ? this.singleValue : undefined);
        destination.complete();
      } else {
        destination.error(new EmptyError);
      }
    }
  }
  