­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ ­ import { Observable } from '../Observable'; import { MonoTypeOperatorFunction } from '../types'; import { concat } from '../observable/concat'; import { take } from './take'; import { ignoreElements } from './ignoreElements'; import { mapTo } from './mapTo'; import { mergeMap } from './mergeMap'; /** @deprecated The `subscriptionDelay` parameter will be removed in v8. */ export function delayWhen( delayDurationSelector: (value: T, index: number) => Observable, subscriptionDelay: Observable ): MonoTypeOperatorFunction; export function delayWhen(delayDurationSelector: (value: T, index: number) => Observable): MonoTypeOperatorFunction; /** * Delays the emission of items from the source Observable by a given time span * determined by the emissions of another Observable. * * It's like {@link delay}, but the time span of the * delay duration is determined by a second Observable. * * ![](delayWhen.png) * * `delayWhen` time shifts each emitted value from the source Observable by a * time span determined by another Observable. When the source emits a value, * the `delayDurationSelector` function is called with the source value as * argument, and should return an Observable, called the "duration" Observable. * The source value is emitted on the output Observable only when the duration * Observable emits a value or completes. * The completion of the notifier triggering the emission of the source value * is deprecated behavior and will be removed in future versions. * * Optionally, `delayWhen` takes a second argument, `subscriptionDelay`, which * is an Observable. When `subscriptionDelay` emits its first value or * completes, the source Observable is subscribed to and starts behaving like * described in the previous paragraph. If `subscriptionDelay` is not provided, * `delayWhen` will subscribe to the source Observable as soon as the output * Observable is subscribed. * * ## Example * Delay each click by a random amount of time, between 0 and 5 seconds * ```ts * import { fromEvent, interval } from 'rxjs'; * import { delayWhen } from 'rxjs/operators'; * * const clicks = fromEvent(document, 'click'); * const delayedClicks = clicks.pipe( * delayWhen(event => interval(Math.random() * 5000)), * ); * delayedClicks.subscribe(x => console.log(x)); * ``` * * @see {@link delay} * @see {@link throttle} * @see {@link throttleTime} * @see {@link debounce} * @see {@link debounceTime} * @see {@link sample} * @see {@link sampleTime} * @see {@link audit} * @see {@link auditTime} * * @param {function(value: T, index: number): Observable} delayDurationSelector A function that * returns an Observable for each value emitted by the source Observable, which * is then used to delay the emission of that item on the output Observable * until the Observable returned from this function emits a value. * @param {Observable} subscriptionDelay An Observable that triggers the * subscription to the source Observable once it emits any value. * @return A function that returns an Observable that delays the emissions of * the source Observable by an amount of time specified by the Observable * returned by `delayDurationSelector`. */ export function delayWhen( delayDurationSelector: (value: T, index: number) => Observable, subscriptionDelay?: Observable ): MonoTypeOperatorFunction { if (subscriptionDelay) { // DEPRECATED PATH return (source: Observable) => concat(subscriptionDelay.pipe(take(1), ignoreElements()), source.pipe(delayWhen(delayDurationSelector))); } return mergeMap((value, index) => delayDurationSelector(value, index).pipe(take(1), mapTo(value))); }