taskninja 1.1.5 → 1.1.6

package/src/node_modules/rxjs/src/internal/operators/dematerialize.ts

@@ -1,58 +0,0 @@
-import { observeNotification } from '../Notification';
-import { OperatorFunction, ObservableNotification, ValueFromNotification } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-/**
- * Converts an Observable of {@link ObservableNotification} objects into the emissions
- * that they represent.
- *
- * <span class="informal">Unwraps {@link ObservableNotification} objects as actual `next`,
- * `error` and `complete` emissions. The opposite of {@link materialize}.</span>
- *
- * ![](dematerialize.png)
- *
- * `dematerialize` is assumed to operate an Observable that only emits
- * {@link ObservableNotification} objects as `next` emissions, and does not emit any
- * `error`. Such Observable is the output of a `materialize` operation. Those
- * notifications are then unwrapped using the metadata they contain, and emitted
- * as `next`, `error`, and `complete` on the output Observable.
- *
- * Use this operator in conjunction with {@link materialize}.
- *
- * ## Example
- *
- * Convert an Observable of Notifications to an actual Observable
- *
- * ```ts
- * import { NextNotification, ErrorNotification, of, dematerialize } from 'rxjs';
- *
- * const notifA: NextNotification<string> = { kind: 'N', value: 'A' };
- * const notifB: NextNotification<string> = { kind: 'N', value: 'B' };
- * const notifE: ErrorNotification = { kind: 'E', error: new TypeError('x.toUpperCase is not a function') };
- *
- * const materialized = of(notifA, notifB, notifE);
- *
- * const upperCase = materialized.pipe(dematerialize());
- * upperCase.subscribe({
- *   next: x => console.log(x),
- *   error: e => console.error(e)
- * });
- *
- * // Results in:
- * // A
- * // B
- * // TypeError: x.toUpperCase is not a function
- * ```
- *
- * @see {@link materialize}
- *
- * @return A function that returns an Observable that emits items and
- * notifications embedded in Notification objects emitted by the source
- * Observable.
- */
-export function dematerialize<N extends ObservableNotification<any>>(): OperatorFunction<N, ValueFromNotification<N>> {
-  return operate((source, subscriber) => {
-    source.subscribe(createOperatorSubscriber(subscriber, (notification) => observeNotification(notification, subscriber)));
-  });
-}

package/src/node_modules/rxjs/src/internal/operators/distinct.ts

@@ -1,79 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { noop } from '../util/noop';
-import { innerFrom } from '../observable/innerFrom';
-
-/**
- * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items.
- *
- * If a `keySelector` function is provided, then it will project each value from the source observable into a new value that it will
- * check for equality with previously projected values. If the `keySelector` function is not provided, it will use each value from the
- * source observable directly with an equality check against previous values.
- *
- * In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking.
- *
- * In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the
- * hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct`
- * use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so
- * that the internal `Set` can be "flushed", basically clearing it of values.
- *
- * ## Examples
- *
- * A simple example with numbers
- *
- * ```ts
- * import { of, distinct } from 'rxjs';
- *
- * of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1)
- *   .pipe(distinct())
- *   .subscribe(x => console.log(x));
- *
- * // Outputs
- * // 1
- * // 2
- * // 3
- * // 4
- * ```
- *
- * An example using the `keySelector` function
- *
- * ```ts
- * import { of, distinct } from 'rxjs';
- *
- * of(
- *   { age: 4, name: 'Foo'},
- *   { age: 7, name: 'Bar'},
- *   { age: 5, name: 'Foo'}
- * )
- * .pipe(distinct(({ name }) => name))
- * .subscribe(x => console.log(x));
- *
- * // Outputs
- * // { age: 4, name: 'Foo' }
- * // { age: 7, name: 'Bar' }
- * ```
- * @see {@link distinctUntilChanged}
- * @see {@link distinctUntilKeyChanged}
- *
- * @param keySelector Optional `function` to select which value you want to check as distinct.
- * @param flushes Optional `ObservableInput` for flushing the internal HashSet of the operator.
- * @return A function that returns an Observable that emits items from the
- * source Observable with distinct values.
- */
-export function distinct<T, K>(keySelector?: (value: T) => K, flushes?: ObservableInput<any>): MonoTypeOperatorFunction<T> {
-  return operate((source, subscriber) => {
-    const distinctKeys = new Set();
-    source.subscribe(
-      createOperatorSubscriber(subscriber, (value) => {
-        const key = keySelector ? keySelector(value) : value;
-        if (!distinctKeys.has(key)) {
-          distinctKeys.add(key);
-          subscriber.next(value);
-        }
-      })
-    );
-
-    flushes && innerFrom(flushes).subscribe(createOperatorSubscriber(subscriber, () => distinctKeys.clear(), noop));
-  });
-}

package/src/node_modules/rxjs/src/internal/operators/distinctUntilChanged.ts

@@ -1,182 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-import { identity } from '../util/identity';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-export function distinctUntilChanged<T>(comparator?: (previous: T, current: T) => boolean): MonoTypeOperatorFunction<T>;
-export function distinctUntilChanged<T, K>(
-  comparator: (previous: K, current: K) => boolean,
-  keySelector: (value: T) => K
-): MonoTypeOperatorFunction<T>;
-
-/**
- * Returns a result {@link Observable} that emits all values pushed by the source observable if they
- * are distinct in comparison to the last value the result observable emitted.
- *
- * When provided without parameters or with the first parameter (`{@link distinctUntilChanged#comparator comparator}`),
- * it behaves like this:
- *
- * 1. It will always emit the first value from the source.
- * 2. For all subsequent values pushed by the source, they will be compared to the previously emitted values
- *    using the provided `comparator` or an `===` equality check.
- * 3. If the value pushed by the source is determined to be unequal by this check, that value is emitted and
- *    becomes the new "previously emitted value" internally.
- *
- * When the second parameter (`{@link distinctUntilChanged#keySelector keySelector}`) is provided, the behavior
- * changes:
- *
- * 1. It will always emit the first value from the source.
- * 2. The `keySelector` will be run against all values, including the first value.
- * 3. For all values after the first, the selected key will be compared against the key selected from
- *    the previously emitted value using the `comparator`.
- * 4. If the keys are determined to be unequal by this check, the value (not the key), is emitted
- *    and the selected key from that value is saved for future comparisons against other keys.
- *
- * ## Examples
- *
- * A very basic example with no `{@link distinctUntilChanged#comparator comparator}`. Note that `1` is emitted more than once,
- * because it's distinct in comparison to the _previously emitted_ value,
- * not in comparison to _all other emitted values_.
- *
- * ```ts
- * import { of, distinctUntilChanged } from 'rxjs';
- *
- * of(1, 1, 1, 2, 2, 2, 1, 1, 3, 3)
- *   .pipe(distinctUntilChanged())
- *   .subscribe(console.log);
- * // Logs: 1, 2, 1, 3
- * ```
- *
- * With a `{@link distinctUntilChanged#comparator comparator}`, you can do custom comparisons. Let's say
- * you only want to emit a value when all of its components have
- * changed:
- *
- * ```ts
- * import { of, distinctUntilChanged } from 'rxjs';
- *
- * const totallyDifferentBuilds$ = of(
- *   { engineVersion: '1.1.0', transmissionVersion: '1.2.0' },
- *   { engineVersion: '1.1.0', transmissionVersion: '1.4.0' },
- *   { engineVersion: '1.3.0', transmissionVersion: '1.4.0' },
- *   { engineVersion: '1.3.0', transmissionVersion: '1.5.0' },
- *   { engineVersion: '2.0.0', transmissionVersion: '1.5.0' }
- * ).pipe(
- *   distinctUntilChanged((prev, curr) => {
- *     return (
- *       prev.engineVersion === curr.engineVersion ||
- *       prev.transmissionVersion === curr.transmissionVersion
- *     );
- *   })
- * );
- *
- * totallyDifferentBuilds$.subscribe(console.log);
- *
- * // Logs:
- * // { engineVersion: '1.1.0', transmissionVersion: '1.2.0' }
- * // { engineVersion: '1.3.0', transmissionVersion: '1.4.0' }
- * // { engineVersion: '2.0.0', transmissionVersion: '1.5.0' }
- * ```
- *
- * You can also provide a custom `{@link distinctUntilChanged#comparator comparator}` to check that emitted
- * changes are only in one direction. Let's say you only want to get
- * the next record temperature:
- *
- * ```ts
- * import { of, distinctUntilChanged } from 'rxjs';
- *
- * const temps$ = of(30, 31, 20, 34, 33, 29, 35, 20);
- *
- * const recordHighs$ = temps$.pipe(
- *   distinctUntilChanged((prevHigh, temp) => {
- *     // If the current temp is less than
- *     // or the same as the previous record,
- *     // the record hasn't changed.
- *     return temp <= prevHigh;
- *   })
- * );
- *
- * recordHighs$.subscribe(console.log);
- * // Logs: 30, 31, 34, 35
- * ```
- *
- * Selecting update events only when the `updatedBy` field shows
- * the account changed hands.
- *
- * ```ts
- * import { of, distinctUntilChanged } from 'rxjs';
- *
- * // A stream of updates to a given account
- * const accountUpdates$ = of(
- *   { updatedBy: 'blesh', data: [] },
- *   { updatedBy: 'blesh', data: [] },
- *   { updatedBy: 'ncjamieson', data: [] },
- *   { updatedBy: 'ncjamieson', data: [] },
- *   { updatedBy: 'blesh', data: [] }
- * );
- *
- * // We only want the events where it changed hands
- * const changedHands$ = accountUpdates$.pipe(
- *   distinctUntilChanged(undefined, update => update.updatedBy)
- * );
- *
- * changedHands$.subscribe(console.log);
- * // Logs:
- * // { updatedBy: 'blesh', data: Array[0] }
- * // { updatedBy: 'ncjamieson', data: Array[0] }
- * // { updatedBy: 'blesh', data: Array[0] }
- * ```
- *
- * @see {@link distinct}
- * @see {@link distinctUntilKeyChanged}
- *
- * @param comparator A function used to compare the previous and current keys for
- * equality. Defaults to a `===` check.
- * @param keySelector Used to select a key value to be passed to the `comparator`.
- *
- * @return A function that returns an Observable that emits items from the
- * source Observable with distinct values.
- */
-export function distinctUntilChanged<T, K>(
-  comparator?: (previous: K, current: K) => boolean,
-  keySelector: (value: T) => K = identity as (value: T) => K
-): MonoTypeOperatorFunction<T> {
-  // We've been allowing `null` do be passed as the `compare`, so we can't do
-  // a default value for the parameter, because that will only work
-  // for `undefined`.
-  comparator = comparator ?? defaultCompare;
-
-  return operate((source, subscriber) => {
-    // The previous key, used to compare against keys selected
-    // from new arrivals to determine "distinctiveness".
-    let previousKey: K;
-    // Whether or not this is the first value we've gotten.
-    let first = true;
-
-    source.subscribe(
-      createOperatorSubscriber(subscriber, (value) => {
-        // We always call the key selector.
-        const currentKey = keySelector(value);
-
-        // If it's the first value, we always emit it.
-        // Otherwise, we compare this key to the previous key, and
-        // if the comparer returns false, we emit.
-        if (first || !comparator!(previousKey, currentKey)) {
-          // Update our state *before* we emit the value
-          // as emission can be the source of re-entrant code
-          // in functional libraries like this. We only really
-          // need to do this if it's the first value, or if the
-          // key we're tracking in previous needs to change.
-          first = false;
-          previousKey = currentKey;
-
-          // Emit the value!
-          subscriber.next(value);
-        }
-      })
-    );
-  });
-}
-
-function defaultCompare(a: any, b: any) {
-  return a === b;
-}

package/src/node_modules/rxjs/src/internal/operators/distinctUntilKeyChanged.ts

@@ -1,75 +0,0 @@
-import { distinctUntilChanged } from './distinctUntilChanged';
-import { MonoTypeOperatorFunction } from '../types';
-
-export function distinctUntilKeyChanged<T>(key: keyof T): MonoTypeOperatorFunction<T>;
-export function distinctUntilKeyChanged<T, K extends keyof T>(key: K, compare: (x: T[K], y: T[K]) => boolean): MonoTypeOperatorFunction<T>;
-
-/**
- * Returns an Observable that emits all items emitted by the source Observable that
- * are distinct by comparison from the previous item, using a property accessed by
- * using the key provided to check if the two items are distinct.
- *
- * If a comparator function is provided, then it will be called for each item to
- * test for whether that value should be emitted or not.
- *
- * If a comparator function is not provided, an equality check is used by default.
- *
- * ## Examples
- *
- * An example comparing the name of persons
- *
- * ```ts
- * import { of, distinctUntilKeyChanged } from 'rxjs';
- *
- * of(
- *   { age: 4, name: 'Foo' },
- *   { age: 7, name: 'Bar' },
- *   { age: 5, name: 'Foo' },
- *   { age: 6, name: 'Foo' }
- * ).pipe(
- *   distinctUntilKeyChanged('name')
- * )
- * .subscribe(x => console.log(x));
- *
- * // displays:
- * // { age: 4, name: 'Foo' }
- * // { age: 7, name: 'Bar' }
- * // { age: 5, name: 'Foo' }
- * ```
- *
- * An example comparing the first letters of the name
- *
- * ```ts
- * import { of, distinctUntilKeyChanged } from 'rxjs';
- *
- * of(
- *   { age: 4, name: 'Foo1' },
- *   { age: 7, name: 'Bar' },
- *   { age: 5, name: 'Foo2' },
- *   { age: 6, name: 'Foo3' }
- * ).pipe(
- *   distinctUntilKeyChanged('name', (x, y) => x.substring(0, 3) === y.substring(0, 3))
- * )
- * .subscribe(x => console.log(x));
- *
- * // displays:
- * // { age: 4, name: 'Foo1' }
- * // { age: 7, name: 'Bar' }
- * // { age: 5, name: 'Foo2' }
- * ```
- *
- * @see {@link distinct}
- * @see {@link distinctUntilChanged}
- *
- * @param key String key for object property lookup on each item.
- * @param compare Optional comparison function called to test if an item is distinct
- * from the previous item in the source.
- * @return A function that returns an Observable that emits items from the source
- * Observable with distinct values based on the key specified.
- */
-export function distinctUntilKeyChanged<T, K extends keyof T>(
-  key: K,
-  compare?: (x: T[K], y: T[K]) => boolean
-): MonoTypeOperatorFunction<T> {
-  return distinctUntilChanged((x: T, y: T) => (compare ? compare(x[key], y[key]) : x[key] === y[key]));
-}

package/src/node_modules/rxjs/src/internal/operators/elementAt.ts

@@ -1,68 +0,0 @@
-import { ArgumentOutOfRangeError } from '../util/ArgumentOutOfRangeError';
-import { Observable } from '../Observable';
-import { OperatorFunction } from '../types';
-import { filter } from './filter';
-import { throwIfEmpty } from './throwIfEmpty';
-import { defaultIfEmpty } from './defaultIfEmpty';
-import { take } from './take';
-
-/**
- * Emits the single value at the specified `index` in a sequence of emissions
- * from the source Observable.
- *
- * <span class="informal">Emits only the i-th value, then completes.</span>
- *
- * ![](elementAt.png)
- *
- * `elementAt` returns an Observable that emits the item at the specified
- * `index` in the source Observable, or a default value if that `index` is out
- * of range and the `default` argument is provided. If the `default` argument is
- * not given and the `index` is out of range, the output Observable will emit an
- * `ArgumentOutOfRangeError` error.
- *
- * ## Example
- *
- * Emit only the third click event
- *
- * ```ts
- * import { fromEvent, elementAt } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(elementAt(2));
- * result.subscribe(x => console.log(x));
- *
- * // Results in:
- * // click 1 = nothing
- * // click 2 = nothing
- * // click 3 = MouseEvent object logged to console
- * ```
- *
- * @see {@link first}
- * @see {@link last}
- * @see {@link skip}
- * @see {@link single}
- * @see {@link take}
- *
- * @throws {ArgumentOutOfRangeError} When using `elementAt(i)`, it delivers an
- * `ArgumentOutOfRangeError` to the Observer's `error` callback if `i < 0` or the
- * Observable has completed before emitting the i-th `next` notification.
- *
- * @param index Is the number `i` for the i-th source emission that has happened
- * since the subscription, starting from the number `0`.
- * @param defaultValue The default value returned for missing indices.
- * @return A function that returns an Observable that emits a single item, if
- * it is found. Otherwise, it will emit the default value if given. If not, it
- * emits an error.
- */
-export function elementAt<T, D = T>(index: number, defaultValue?: D): OperatorFunction<T, T | D> {
-  if (index < 0) {
-    throw new ArgumentOutOfRangeError();
-  }
-  const hasDefaultValue = arguments.length >= 2;
-  return (source: Observable<T>) =>
-    source.pipe(
-      filter((v, i) => i === index),
-      take(1),
-      hasDefaultValue ? defaultIfEmpty(defaultValue!) : throwIfEmpty(() => new ArgumentOutOfRangeError())
-    );
-}

package/src/node_modules/rxjs/src/internal/operators/endWith.ts

@@ -1,68 +0,0 @@
-/** prettier */
-import { Observable } from '../Observable';
-import { concat } from '../observable/concat';
-import { of } from '../observable/of';
-import { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction, ValueFromArray } from '../types';
-
-/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
-export function endWith<T>(scheduler: SchedulerLike): MonoTypeOperatorFunction<T>;
-/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
-export function endWith<T, A extends unknown[] = T[]>(
-  ...valuesAndScheduler: [...A, SchedulerLike]
-): OperatorFunction<T, T | ValueFromArray<A>>;
-
-export function endWith<T, A extends unknown[] = T[]>(...values: A): OperatorFunction<T, T | ValueFromArray<A>>;
-
-/**
- * Returns an observable that will emit all values from the source, then synchronously emit
- * the provided value(s) immediately after the source completes.
- *
- * NOTE: Passing a last argument of a Scheduler is _deprecated_, and may result in incorrect
- * types in TypeScript.
- *
- * This is useful for knowing when an observable ends. Particularly when paired with an
- * operator like {@link takeUntil}
- *
- * ![](endWith.png)
- *
- * ## Example
- *
- * Emit values to know when an interval starts and stops. The interval will
- * stop when a user clicks anywhere on the document.
- *
- * ```ts
- * import { interval, map, fromEvent, startWith, takeUntil, endWith } from 'rxjs';
- *
- * const ticker$ = interval(5000).pipe(
- *   map(() => 'tick')
- * );
- *
- * const documentClicks$ = fromEvent(document, 'click');
- *
- * ticker$.pipe(
- *   startWith('interval started'),
- *   takeUntil(documentClicks$),
- *   endWith('interval ended by click')
- * )
- * .subscribe(x => console.log(x));
- *
- * // Result (assuming a user clicks after 15 seconds)
- * // 'interval started'
- * // 'tick'
- * // 'tick'
- * // 'tick'
- * // 'interval ended by click'
- * ```
- *
- * @see {@link startWith}
- * @see {@link concat}
- * @see {@link takeUntil}
- *
- * @param values Items you want the modified Observable to emit last.
- * @return A function that returns an Observable that emits all values from the
- * source, then synchronously emits the provided value(s) immediately after the
- * source completes.
- */
-export function endWith<T>(...values: Array<T | SchedulerLike>): MonoTypeOperatorFunction<T> {
-  return (source: Observable<T>) => concat(source, of(...values)) as Observable<T>;
-}

package/src/node_modules/rxjs/src/internal/operators/every.ts

@@ -1,66 +0,0 @@
-import { Observable } from '../Observable';
-import { Falsy, OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-
-export function every<T>(predicate: BooleanConstructor): OperatorFunction<T, Exclude<T, Falsy> extends never ? false : boolean>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export function every<T>(
-  predicate: BooleanConstructor,
-  thisArg: any
-): OperatorFunction<T, Exclude<T, Falsy> extends never ? false : boolean>;
-/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
-export function every<T, A>(
-  predicate: (this: A, value: T, index: number, source: Observable<T>) => boolean,
-  thisArg: A
-): OperatorFunction<T, boolean>;
-export function every<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean): OperatorFunction<T, boolean>;
-
-/**
- * Returns an Observable that emits whether or not every item of the source satisfies the condition specified.
- *
- * <span class="informal">If all values pass predicate before the source completes, emits true before completion,
- * otherwise emit false, then complete.</span>
- *
- * ![](every.png)
- *
- * ## Example
- *
- * A simple example emitting true if all elements are less than 5, false otherwise
- *
- * ```ts
- * import { of, every } from 'rxjs';
- *
- * of(1, 2, 3, 4, 5, 6)
- *   .pipe(every(x => x < 5))
- *   .subscribe(x => console.log(x)); // -> false
- * ```
- *
- * @param predicate A function for determining if an item meets a specified condition.
- * @param thisArg Optional object to use for `this` in the callback.
- * @return A function that returns an Observable of booleans that determines if
- * all items of the source Observable meet the condition specified.
- */
-export function every<T>(
-  predicate: (value: T, index: number, source: Observable<T>) => boolean,
-  thisArg?: any
-): OperatorFunction<T, boolean> {
-  return operate((source, subscriber) => {
-    let index = 0;
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => {
-          if (!predicate.call(thisArg, value, index++, source)) {
-            subscriber.next(false);
-            subscriber.complete();
-          }
-        },
-        () => {
-          subscriber.next(true);
-          subscriber.complete();
-        }
-      )
-    );
-  });
-}

package/src/node_modules/rxjs/src/internal/operators/exhaust.ts

@@ -1,6 +0,0 @@
-import { exhaustAll } from './exhaustAll';
-
-/**
- * @deprecated Renamed to {@link exhaustAll}. Will be removed in v8.
- */
-export const exhaust = exhaustAll;

package/src/node_modules/rxjs/src/internal/operators/exhaustAll.ts

@@ -1,51 +0,0 @@
-import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
-import { exhaustMap } from './exhaustMap';
-import { identity } from '../util/identity';
-
-/**
- * Converts a higher-order Observable into a first-order Observable by dropping
- * inner Observables while the previous inner Observable has not yet completed.
- *
- * <span class="informal">Flattens an Observable-of-Observables by dropping the
- * next inner Observables while the current inner is still executing.</span>
- *
- * ![](exhaustAll.svg)
- *
- * `exhaustAll` subscribes to an Observable that emits Observables, also known as a
- * higher-order Observable. Each time it observes one of these emitted inner
- * Observables, the output Observable begins emitting the items emitted by that
- * inner Observable. So far, it behaves like {@link mergeAll}. However,
- * `exhaustAll` ignores every new inner Observable if the previous Observable has
- * not yet completed. Once that one completes, it will accept and flatten the
- * next inner Observable and repeat this process.
- *
- * ## Example
- *
- * Run a finite timer for each click, only if there is no currently active timer
- *
- * ```ts
- * import { fromEvent, map, interval, take, exhaustAll } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const higherOrder = clicks.pipe(
- *   map(() => interval(1000).pipe(take(5)))
- * );
- * const result = higherOrder.pipe(exhaustAll());
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link combineLatestAll}
- * @see {@link concatAll}
- * @see {@link switchAll}
- * @see {@link switchMap}
- * @see {@link mergeAll}
- * @see {@link exhaustMap}
- * @see {@link zipAll}
- *
- * @return A function that returns an Observable that takes a source of
- * Observables and propagates the first Observable exclusively until it
- * completes before subscribing to the next.
- */
-export function exhaustAll<O extends ObservableInput<any>>(): OperatorFunction<O, ObservedValueOf<O>> {
-  return exhaustMap(identity);
-}