@bleedingdev/modern-js-utils 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/compiled/inquirer/rxjs/internal/operators/skip.d.ts

@@ -1,36 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * Returns an Observable that skips the first `count` items emitted by the source Observable.
- *
- * ![](skip.png)
- *
- * Skips the values until the sent notifications are equal or less than provided skip count. It raises
- * an error if skip count is equal or more than the actual number of emits and source raises an error.
- *
- * ## Example
- *
- * Skip the values before the emission
- *
- * ```ts
- * import { interval, skip } from '../..';
- *
- * // emit every half second
- * const source = interval(500);
- * // skip the first 10 emitted values
- * const result = source.pipe(skip(10));
- *
- * result.subscribe(value => console.log(value));
- * // output: 10...11...12...13...
- * ```
- *
- * @see {@link last}
- * @see {@link skipWhile}
- * @see {@link skipUntil}
- * @see {@link skipLast}
- *
- * @param count The number of times, items emitted by source Observable should be skipped.
- * @return A function that returns an Observable that skips the first `count`
- * values emitted by the source Observable.
- */
-export declare function skip<T>(count: number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=skip.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/skipLast.d.ts

@@ -1,45 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * Skip a specified number of values before the completion of an observable.
- *
- * ![](skipLast.png)
- *
- * Returns an observable that will emit values as soon as it can, given a number of
- * skipped values. For example, if you `skipLast(3)` on a source, when the source
- * emits its fourth value, the first value the source emitted will finally be emitted
- * from the returned observable, as it is no longer part of what needs to be skipped.
- *
- * All values emitted by the result of `skipLast(N)` will be delayed by `N` emissions,
- * as each value is held in a buffer until enough values have been emitted that that
- * the buffered value may finally be sent to the consumer.
- *
- * After subscribing, unsubscribing will not result in the emission of the buffered
- * skipped values.
- *
- * ## Example
- *
- * Skip the last 2 values of an observable with many values
- *
- * ```ts
- * import { of, skipLast } from '../..';
- *
- * const numbers = of(1, 2, 3, 4, 5);
- * const skipLastTwo = numbers.pipe(skipLast(2));
- * skipLastTwo.subscribe(x => console.log(x));
- *
- * // Results in:
- * // 1 2 3
- * // (4 and 5 are skipped)
- * ```
- *
- * @see {@link skip}
- * @see {@link skipUntil}
- * @see {@link skipWhile}
- * @see {@link take}
- *
- * @param skipCount Number of elements to skip from the end of the source Observable.
- * @return A function that returns an Observable that skips the last `count`
- * values emitted by the source Observable.
- */
-export declare function skipLast<T>(skipCount: number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=skipLast.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/skipUntil.d.ts

@@ -1,48 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-/**
- * Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item.
- *
- * The `skipUntil` operator causes the observable stream to skip the emission of values until the passed in observable
- * emits the first value. This can be particularly useful in combination with user interactions, responses of HTTP
- * requests or waiting for specific times to pass by.
- *
- * ![](skipUntil.png)
- *
- * Internally, the `skipUntil` operator subscribes to the passed in `notifier` `ObservableInput` (which gets converted
- * to an Observable) in order to recognize the emission of its first value. When `notifier` emits next, the operator
- * unsubscribes from it and starts emitting the values of the *source* observable until it completes or errors. It
- * will never let the *source* observable emit any values if the `notifier` completes or throws an error without
- * emitting a value before.
- *
- * ## Example
- *
- * In the following example, all emitted values of the interval observable are skipped until the user clicks anywhere
- * within the page
- *
- * ```ts
- * import { interval, fromEvent, skipUntil } from '../..';
- *
- * const intervalObservable = interval(1000);
- * const click = fromEvent(document, 'click');
- *
- * const emitAfterClick = intervalObservable.pipe(
- *   skipUntil(click)
- * );
- * // clicked at 4.6s. output: 5...6...7...8........ or
- * // clicked at 7.3s. output: 8...9...10..11.......
- * emitAfterClick.subscribe(value => console.log(value));
- * ```
- *
- * @see {@link last}
- * @see {@link skip}
- * @see {@link skipWhile}
- * @see {@link skipLast}
- *
- * @param notifier An `ObservableInput` that has to emit an item before the source Observable elements begin to
- * be mirrored by the resulting Observable.
- * @return A function that returns an Observable that skips items from the
- * source Observable until the `notifier` Observable emits an item, then emits the
- * remaining items.
- */
-export declare function skipUntil<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=skipUntil.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/skipWhile.d.ts

@@ -1,5 +0,0 @@
-import { Falsy, MonoTypeOperatorFunction, OperatorFunction } from '../types';
-export declare function skipWhile<T>(predicate: BooleanConstructor): OperatorFunction<T, Extract<T, Falsy> extends never ? never : T>;
-export declare function skipWhile<T>(predicate: (value: T, index: number) => true): OperatorFunction<T, never>;
-export declare function skipWhile<T>(predicate: (value: T, index: number) => boolean): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=skipWhile.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/startWith.d.ts

@@ -1,7 +0,0 @@
-import { OperatorFunction, SchedulerLike, ValueFromArray } from '../types';
-export declare function startWith<T>(value: null): OperatorFunction<T, T | null>;
-export declare function startWith<T>(value: undefined): OperatorFunction<T, T | undefined>;
-/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
-export declare function startWith<T, A extends readonly unknown[] = T[]>(...valuesAndScheduler: [...A, SchedulerLike]): OperatorFunction<T, T | ValueFromArray<A>>;
-export declare function startWith<T, A extends readonly unknown[] = T[]>(...values: A): OperatorFunction<T, T | ValueFromArray<A>>;
-//# sourceMappingURL=startWith.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/subscribeOn.d.ts

@@ -1,62 +0,0 @@
-import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
-/**
- * Asynchronously subscribes Observers to this Observable on the specified {@link SchedulerLike}.
- *
- * With `subscribeOn` you can decide what type of scheduler a specific Observable will be using when it is subscribed to.
- *
- * Schedulers control the speed and order of emissions to observers from an Observable stream.
- *
- * ![](subscribeOn.png)
- *
- * ## Example
- *
- * Given the following code:
- *
- * ```ts
- * import { of, merge } from '../..';
- *
- * const a = of(1, 2, 3);
- * const b = of(4, 5, 6);
- *
- * merge(a, b).subscribe(console.log);
- *
- * // Outputs
- * // 1
- * // 2
- * // 3
- * // 4
- * // 5
- * // 6
- * ```
- *
- * Both Observable `a` and `b` will emit their values directly and synchronously once they are subscribed to.
- *
- * If we instead use the `subscribeOn` operator declaring that we want to use the {@link asyncScheduler} for values emitted by Observable `a`:
- *
- * ```ts
- * import { of, subscribeOn, asyncScheduler, merge } from '../..';
- *
- * const a = of(1, 2, 3).pipe(subscribeOn(asyncScheduler));
- * const b = of(4, 5, 6);
- *
- * merge(a, b).subscribe(console.log);
- *
- * // Outputs
- * // 4
- * // 5
- * // 6
- * // 1
- * // 2
- * // 3
- * ```
- *
- * The reason for this is that Observable `b` emits its values directly and synchronously like before
- * but the emissions from `a` are scheduled on the event loop because we are now using the {@link asyncScheduler} for that specific Observable.
- *
- * @param scheduler The {@link SchedulerLike} to perform subscription actions on.
- * @param delay A delay to pass to the scheduler to delay subscriptions
- * @return A function that returns an Observable modified so that its
- * subscriptions happen on the specified {@link SchedulerLike}.
- */
-export declare function subscribeOn<T>(scheduler: SchedulerLike, delay?: number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=subscribeOn.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/switchAll.d.ts

@@ -1,61 +0,0 @@
-import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
-/**
- * Converts a higher-order Observable into a first-order Observable
- * producing values only from the most recent observable sequence
- *
- * <span class="informal">Flattens an Observable-of-Observables.</span>
- *
- * ![](switchAll.png)
- *
- * `switchAll` subscribes to a source that is an observable of observables, also known as a
- * "higher-order observable" (or `Observable<Observable<T>>`). It subscribes to the most recently
- * provided "inner observable" emitted by the source, unsubscribing from any previously subscribed
- * to inner observable, such that only the most recent inner observable may be subscribed to at
- * any point in time. The resulting observable returned by `switchAll` will only complete if the
- * source observable completes, *and* any currently subscribed to inner observable also has completed,
- * if there are any.
- *
- * ## Examples
- *
- * Spawn a new interval observable for each click event, but for every new
- * click, cancel the previous interval and subscribe to the new one
- *
- * ```ts
- * import { fromEvent, tap, map, interval, switchAll } from '../..';
- *
- * const clicks = fromEvent(document, 'click').pipe(tap(() => console.log('click')));
- * const source = clicks.pipe(map(() => interval(1000)));
- *
- * source
- *   .pipe(switchAll())
- *   .subscribe(x => console.log(x));
- *
- * // Output
- * // click
- * // 0
- * // 1
- * // 2
- * // 3
- * // ...
- * // click
- * // 0
- * // 1
- * // 2
- * // ...
- * // click
- * // ...
- * ```
- *
- * @see {@link combineLatestAll}
- * @see {@link concatAll}
- * @see {@link exhaustAll}
- * @see {@link switchMap}
- * @see {@link switchMapTo}
- * @see {@link mergeAll}
- *
- * @return A function that returns an Observable that converts a higher-order
- * Observable into a first-order Observable producing values only from the most
- * recent Observable sequence.
- */
-export declare function switchAll<O extends ObservableInput<any>>(): OperatorFunction<O, ObservedValueOf<O>>;
-//# sourceMappingURL=switchAll.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/switchMap.d.ts

@@ -1,7 +0,0 @@
-import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
-export declare function switchMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O): OperatorFunction<T, ObservedValueOf<O>>;
-/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
-export declare function switchMap<T, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: undefined): OperatorFunction<T, ObservedValueOf<O>>;
-/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
-export declare function switchMap<T, R, O extends ObservableInput<any>>(project: (value: T, index: number) => O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;
-//# sourceMappingURL=switchMap.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/switchMapTo.d.ts

@@ -1,8 +0,0 @@
-import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types';
-/** @deprecated Will be removed in v9. Use {@link switchMap} instead: `switchMap(() => result)` */
-export declare function switchMapTo<O extends ObservableInput<unknown>>(observable: O): OperatorFunction<unknown, ObservedValueOf<O>>;
-/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
-export declare function switchMapTo<O extends ObservableInput<unknown>>(observable: O, resultSelector: undefined): OperatorFunction<unknown, ObservedValueOf<O>>;
-/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */
-export declare function switchMapTo<T, R, O extends ObservableInput<unknown>>(observable: O, resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R): OperatorFunction<T, R>;
-//# sourceMappingURL=switchMapTo.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/switchScan.d.ts

@@ -1,20 +0,0 @@
-import { ObservableInput, ObservedValueOf, OperatorFunction } from '../types';
-/**
- * Applies an accumulator function over the source Observable where the
- * accumulator function itself returns an Observable, emitting values
- * only from the most recently returned Observable.
- *
- * <span class="informal">It's like {@link mergeScan}, but only the most recent
- * Observable returned by the accumulator is merged into the outer Observable.</span>
- *
- * @see {@link scan}
- * @see {@link mergeScan}
- * @see {@link switchMap}
- *
- * @param accumulator
- * The accumulator function called on each source value.
- * @param seed The initial accumulation value.
- * @return A function that returns an observable of the accumulated values.
- */
-export declare function switchScan<T, R, O extends ObservableInput<any>>(accumulator: (acc: R, value: T, index: number) => O, seed: R): OperatorFunction<T, ObservedValueOf<O>>;
-//# sourceMappingURL=switchScan.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/take.d.ts

@@ -1,45 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * Emits only the first `count` values emitted by the source Observable.
- *
- * <span class="informal">Takes the first `count` values from the source, then
- * completes.</span>
- *
- * ![](take.png)
- *
- * `take` returns an Observable that emits only the first `count` values emitted
- * by the source Observable. If the source emits fewer than `count` values then
- * all of its values are emitted. After that, it completes, regardless if the
- * source completes.
- *
- * ## Example
- *
- * Take the first 5 seconds of an infinite 1-second interval Observable
- *
- * ```ts
- * import { interval, take } from '../..';
- *
- * const intervalCount = interval(1000);
- * const takeFive = intervalCount.pipe(take(5));
- * takeFive.subscribe(x => console.log(x));
- *
- * // Logs:
- * // 0
- * // 1
- * // 2
- * // 3
- * // 4
- * ```
- *
- * @see {@link takeLast}
- * @see {@link takeUntil}
- * @see {@link takeWhile}
- * @see {@link skip}
- *
- * @param count The maximum number of `next` values to emit.
- * @return A function that returns an Observable that emits only the first
- * `count` values emitted by the source Observable, or all of the values from
- * the source if the source emits fewer than `count` values.
- */
-export declare function take<T>(count: number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=take.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/takeLast.d.ts

@@ -1,42 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * Waits for the source to complete, then emits the last N values from the source,
- * as specified by the `count` argument.
- *
- * ![](takeLast.png)
- *
- * `takeLast` results in an observable that will hold values up to `count` values in memory,
- * until the source completes. It then pushes all values in memory to the consumer, in the
- * order they were received from the source, then notifies the consumer that it is
- * complete.
- *
- * If for some reason the source completes before the `count` supplied to `takeLast` is reached,
- * all values received until that point are emitted, and then completion is notified.
- *
- * **Warning**: Using `takeLast` with an observable that never completes will result
- * in an observable that never emits a value.
- *
- * ## Example
- *
- * Take the last 3 values of an Observable with many values
- *
- * ```ts
- * import { range, takeLast } from '../..';
- *
- * const many = range(1, 100);
- * const lastThree = many.pipe(takeLast(3));
- * lastThree.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link take}
- * @see {@link takeUntil}
- * @see {@link takeWhile}
- * @see {@link skip}
- *
- * @param count The maximum number of values to emit from the end of
- * the sequence of values emitted by the source Observable.
- * @return A function that returns an Observable that emits at most the last
- * `count` values emitted by the source Observable.
- */
-export declare function takeLast<T>(count: number): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=takeLast.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/takeUntil.d.ts

@@ -1,41 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-/**
- * Emits the values emitted by the source Observable until a `notifier`
- * Observable emits a value.
- *
- * <span class="informal">Lets values pass until a second Observable,
- * `notifier`, emits a value. Then, it completes.</span>
- *
- * ![](takeUntil.png)
- *
- * `takeUntil` subscribes and begins mirroring the source Observable. It also
- * monitors a second Observable, `notifier` that you provide. If the `notifier`
- * emits a value, the output Observable stops mirroring the source Observable
- * and completes. If the `notifier` doesn't emit any value and completes
- * then `takeUntil` will pass all values.
- *
- * ## Example
- *
- * Tick every second until the first click happens
- *
- * ```ts
- * import { interval, fromEvent, takeUntil } from '../..';
- *
- * const source = interval(1000);
- * const clicks = fromEvent(document, 'click');
- * const result = source.pipe(takeUntil(clicks));
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link take}
- * @see {@link takeLast}
- * @see {@link takeWhile}
- * @see {@link skip}
- *
- * @param notifier The `ObservableInput` whose first emitted value will cause the output
- * Observable of `takeUntil` to stop emitting values from the source Observable.
- * @return A function that returns an Observable that emits the values from the
- * source Observable until `notifier` emits its first value.
- */
-export declare function takeUntil<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=takeUntil.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/takeWhile.d.ts

@@ -1,8 +0,0 @@
-import { OperatorFunction, MonoTypeOperatorFunction, TruthyTypesOf } from '../types';
-export declare function takeWhile<T>(predicate: BooleanConstructor, inclusive: true): MonoTypeOperatorFunction<T>;
-export declare function takeWhile<T>(predicate: BooleanConstructor, inclusive: false): OperatorFunction<T, TruthyTypesOf<T>>;
-export declare function takeWhile<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>;
-export declare function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S): OperatorFunction<T, S>;
-export declare function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S, inclusive: false): OperatorFunction<T, S>;
-export declare function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive?: boolean): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=takeWhile.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/tap.d.ts

@@ -1,72 +0,0 @@
-import { MonoTypeOperatorFunction, Observer } from '../types';
-/**
- * An extension to the {@link Observer} interface used only by the {@link tap} operator.
- *
- * It provides a useful set of callbacks a user can register to do side-effects in
- * cases other than what the usual {@link Observer} callbacks are
- * ({@link guide/glossary-and-semantics#next next},
- * {@link guide/glossary-and-semantics#error error} and/or
- * {@link guide/glossary-and-semantics#complete complete}).
- *
- * ## Example
- *
- * ```ts
- * import { fromEvent, switchMap, tap, interval, take } from '../..';
- *
- * const source$ = fromEvent(document, 'click');
- * const result$ = source$.pipe(
- *   switchMap((_, i) => i % 2 === 0
- *     ? fromEvent(document, 'mousemove').pipe(
- *         tap({
- *           subscribe: () => console.log('Subscribed to the mouse move events after click #' + i),
- *           unsubscribe: () => console.log('Mouse move events #' + i + ' unsubscribed'),
- *           finalize: () => console.log('Mouse move events #' + i + ' finalized')
- *         })
- *       )
- *     : interval(1_000).pipe(
- *         take(5),
- *         tap({
- *           subscribe: () => console.log('Subscribed to the 1-second interval events after click #' + i),
- *           unsubscribe: () => console.log('1-second interval events #' + i + ' unsubscribed'),
- *           finalize: () => console.log('1-second interval events #' + i + ' finalized')
- *         })
- *       )
- *   )
- * );
- *
- * const subscription = result$.subscribe({
- *   next: console.log
- * });
- *
- * setTimeout(() => {
- *   console.log('Unsubscribe after 60 seconds');
- *   subscription.unsubscribe();
- * }, 60_000);
- * ```
- */
-export interface TapObserver<T> extends Observer<T> {
-    /**
-     * The callback that `tap` operator invokes at the moment when the source Observable
-     * gets subscribed to.
-     */
-    subscribe: () => void;
-    /**
-     * The callback that `tap` operator invokes when an explicit
-     * {@link guide/glossary-and-semantics#unsubscription unsubscribe} happens. It won't get invoked on
-     * `error` or `complete` events.
-     */
-    unsubscribe: () => void;
-    /**
-     * The callback that `tap` operator invokes when any kind of
-     * {@link guide/glossary-and-semantics#finalization finalization} happens - either when
-     * the source Observable `error`s or `complete`s or when it gets explicitly unsubscribed
-     * by the user. There is no difference in using this callback or the {@link finalize}
-     * operator, but if you're already using `tap` operator, you can use this callback
-     * instead. You'd get the same result in either case.
-     */
-    finalize: () => void;
-}
-export declare function tap<T>(observerOrNext?: Partial<TapObserver<T>> | ((value: T) => void)): MonoTypeOperatorFunction<T>;
-/** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
-export declare function tap<T>(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=tap.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/throttle.d.ts

@@ -1,78 +0,0 @@
-import { MonoTypeOperatorFunction, ObservableInput } from '../types';
-/**
- * An object interface used by {@link throttle} or {@link throttleTime} that ensure
- * configuration options of these operators.
- *
- * @see {@link throttle}
- * @see {@link throttleTime}
- */
-export interface ThrottleConfig {
-    /**
-     * If `true`, the resulting Observable will emit the first value from the source
-     * Observable at the **start** of the "throttling" process (when starting an
-     * internal timer that prevents other emissions from the source to pass through).
-     * If `false`, it will not emit the first value from the source Observable at the
-     * start of the "throttling" process.
-     *
-     * If not provided, defaults to: `true`.
-     */
-    leading?: boolean;
-    /**
-     * If `true`, the resulting Observable will emit the last value from the source
-     * Observable at the **end** of the "throttling" process (when ending an internal
-     * timer that prevents other emissions from the source to pass through).
-     * If `false`, it will not emit the last value from the source Observable at the
-     * end of the "throttling" process.
-     *
-     * If not provided, defaults to: `false`.
-     */
-    trailing?: boolean;
-}
-/**
- * Emits a value from the source Observable, then ignores subsequent source
- * values for a duration determined by another Observable, then repeats this
- * process.
- *
- * <span class="informal">It's like {@link throttleTime}, but the silencing
- * duration is determined by a second Observable.</span>
- *
- * ![](throttle.svg)
- *
- * `throttle` emits the source Observable values on the output Observable
- * when its internal timer is disabled, and ignores source values when the timer
- * is enabled. Initially, the timer is disabled. As soon as the first source
- * value arrives, it is forwarded to the output Observable, and then the timer
- * is enabled by calling the `durationSelector` function with the source value,
- * which returns the "duration" Observable. When the duration Observable emits a
- * value, the timer is disabled, and this process repeats for the
- * next source value.
- *
- * ## Example
- *
- * Emit clicks at a rate of at most one click per second
- *
- * ```ts
- * import { fromEvent, throttle, interval } from '../..';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(throttle(() => interval(1000)));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link audit}
- * @see {@link debounce}
- * @see {@link delayWhen}
- * @see {@link sample}
- * @see {@link throttleTime}
- *
- * @param durationSelector A function that receives a value from the source
- * Observable, for computing the silencing duration for each source value,
- * returned as an `ObservableInput`.
- * @param config A configuration object to define `leading` and `trailing`
- * behavior. Defaults to `{ leading: true, trailing: false }`.
- * @return A function that returns an Observable that performs the throttle
- * operation to limit the rate of emissions from the source.
- */
-export declare function throttle<T>(durationSelector: (value: T) => ObservableInput<any>, config?: ThrottleConfig): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=throttle.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/operators/throttleTime.d.ts

@@ -1,53 +0,0 @@
-import { ThrottleConfig } from './throttle';
-import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
-/**
- * Emits a value from the source Observable, then ignores subsequent source
- * values for `duration` milliseconds, then repeats this process.
- *
- * <span class="informal">Lets a value pass, then ignores source values for the
- * next `duration` milliseconds.</span>
- *
- * ![](throttleTime.png)
- *
- * `throttleTime` emits the source Observable values on the output Observable
- * when its internal timer is disabled, and ignores source values when the timer
- * is enabled. Initially, the timer is disabled. As soon as the first source
- * value arrives, it is forwarded to the output Observable, and then the timer
- * is enabled. After `duration` milliseconds (or the time unit determined
- * internally by the optional `scheduler`) has passed, the timer is disabled,
- * and this process repeats for the next source value. Optionally takes a
- * {@link SchedulerLike} for managing timers.
- *
- * ## Examples
- *
- * ### Limit click rate
- *
- * Emit clicks at a rate of at most one click per second
- *
- * ```ts
- * import { fromEvent, throttleTime } from '../..';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(throttleTime(1000));
- *
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link auditTime}
- * @see {@link debounceTime}
- * @see {@link delay}
- * @see {@link sampleTime}
- * @see {@link throttle}
- *
- * @param duration Time to wait before emitting another value after
- * emitting the last value, measured in milliseconds or the time unit determined
- * internally by the optional `scheduler`.
- * @param scheduler The {@link SchedulerLike} to use for
- * managing the timers that handle the throttling. Defaults to {@link asyncScheduler}.
- * @param config A configuration object to define `leading` and
- * `trailing` behavior. Defaults to `{ leading: true, trailing: false }`.
- * @return A function that returns an Observable that performs the throttle
- * operation to limit the rate of emissions from the source.
- */
-export declare function throttleTime<T>(duration: number, scheduler?: SchedulerLike, config?: ThrottleConfig): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=throttleTime.d.ts.map