hunk.code_window:  * that, when applied to an item emitted by the source Observable, returns an
    * Observable.
    * @return {Observable} An Observable that emits the result of applying the
    * projection function (and the optional `resultSelector`) to each item emitted
    * by the source Observable and taking only the values from the most recently
    * projected inner Observable.
    * @method switchMap
    * @owner Observable
  
hunk.labels: keep keep keep replace replace keep keep keep
hunk.after_edit:  * projection function (and the optional deprecated `resultSelector`) to each item
    * emitted by the source Observable and taking only the values from the most recently
  
hunk.file_path: src/internal/operators/switchMap.ts
hunk.type: replace
file: import { Operator } from '../Operator';
  import { Observable } from '../Observable';
  import { Subscriber } from '../Subscriber';
  import { Subscription } from '../Subscription';
  import { OuterSubscriber } from '../OuterSubscriber';
  import { InnerSubscriber } from '../InnerSubscriber';
  import { subscribeToResult } from '../util/subscribeToResult';
  import { ObservableInput, OperatorFunction } from '../types';
  import { switchMap } from './switchMap';
  
  /* tslint:disable:max-line-length */
  export function switchMapTo<R>(observable: ObservableInput<R>): OperatorFunction<any, R>;
  /** @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map */
  export function switchMapTo<T, R>(observable: ObservableInput<R>, resultSelector: undefined): OperatorFunction<T, R>;
  /** @deprecated resultSelector is no longer supported. Switch to using switchMap with an inner map */
  export function switchMapTo<T, I, R>(observable: ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;
  /* tslint:enable:max-line-length */
  
  /**
   * Projects each source value to the same Observable which is flattened multiple
   * times with {@link switchMap} in the output Observable.
   *
   * <span class="informal">It's like {@link switchMap}, but maps each value
   * always to the same inner Observable.</span>
   *
   * ![](switchMapTo.png)
   *
   * Maps each source value to the given Observable `innerObservable` regardless
   * of the source value, and then flattens those resulting Observables into one
   * single Observable, which is the output Observable. The output Observables
   * emits values only from the most recently emitted instance of
   * `innerObservable`.
   *
   * ## Example
   * Rerun an interval Observable on every click event
   * ```javascript
   * const clicks = fromEvent(document, 'click');
   * const result = clicks.pipe(switchMapTo(interval(1000)));
   * result.subscribe(x => console.log(x));
   * ```
   *
   * @see {@link concatMapTo}
   * @see {@link switchAll}
   * @see {@link switchMap}
   * @see {@link mergeMapTo}
   *
   * @param {ObservableInput} innerObservable An Observable to replace each value from
   * the source Observable.
   * @return {Observable} An Observable that emits items from the given
   * `innerObservable` (and optionally transformed through `resultSelector`) every
   * time a value is emitted on the source Observable, and taking only the values
   * from the most recently projected inner Observable.
   * @method switchMapTo
   * @owner Observable
   */
  export function switchMapTo<T, I, R>(
    innerObservable: ObservableInput<I>,
    resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R
  ): OperatorFunction<T, I|R> {
    return resultSelector ? switchMap(() => innerObservable, resultSelector) : switchMap(() => innerObservable);
  }
  