appiq-solution 1.0.0

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

@@ -0,0 +1,58 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/distinct.ts

@@ -0,0 +1,79 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/distinctUntilChanged.ts

@@ -0,0 +1,182 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/distinctUntilKeyChanged.ts

@@ -0,0 +1,75 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/elementAt.ts

@@ -0,0 +1,68 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/endWith.ts

@@ -0,0 +1,68 @@
+/** 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/tools/installer/node_modules/rxjs/src/internal/operators/every.ts

@@ -0,0 +1,66 @@
+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/tools/installer/node_modules/rxjs/src/internal/operators/exhaust.ts

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

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

@@ -0,0 +1,51 @@
+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);
+}