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

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

@@ -1,39 +0,0 @@
-import { MonoTypeOperatorFunction } from '../types';
-/**
- * If the source observable completes without emitting a value, it will emit
- * an error. The error will be created at that time by the optional
- * `errorFactory` argument, otherwise, the error will be {@link EmptyError}.
- *
- * ![](throwIfEmpty.png)
- *
- * ## Example
- *
- * Throw an error if the document wasn't clicked within 1 second
- *
- * ```ts
- * import { fromEvent, takeUntil, timer, throwIfEmpty } from '../..';
- *
- * const click$ = fromEvent(document, 'click');
- *
- * click$.pipe(
- *   takeUntil(timer(1000)),
- *   throwIfEmpty(() => new Error('The document was not clicked within 1 second'))
- * )
- * .subscribe({
- *   next() {
- *    console.log('The document was clicked');
- *   },
- *   error(err) {
- *     console.error(err.message);
- *   }
- * });
- * ```
- *
- * @param errorFactory A factory function called to produce the
- * error to be thrown when the source observable completes without emitting a
- * value.
- * @return A function that returns an Observable that throws an error if the
- * source Observable completed without emitting.
- */
-export declare function throwIfEmpty<T>(errorFactory?: () => any): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=throwIfEmpty.d.ts.map

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

@@ -1,50 +0,0 @@
-import { SchedulerLike, OperatorFunction } from '../types';
-/**
- * Emits an object containing the current value, and the time that has
- * passed between emitting the current value and the previous value, which is
- * calculated by using the provided `scheduler`'s `now()` method to retrieve
- * the current time at each emission, then calculating the difference. The `scheduler`
- * defaults to {@link asyncScheduler}, so by default, the `interval` will be in
- * milliseconds.
- *
- * <span class="informal">Convert an Observable that emits items into one that
- * emits indications of the amount of time elapsed between those emissions.</span>
- *
- * ![](timeInterval.png)
- *
- * ## Example
- *
- * Emit interval between current value with the last value
- *
- * ```ts
- * import { interval, timeInterval } from '../..';
- *
- * const seconds = interval(1000);
- *
- * seconds
- *   .pipe(timeInterval())
- *   .subscribe(value => console.log(value));
- *
- * // NOTE: The values will never be this precise,
- * // intervals created with `interval` or `setInterval`
- * // are non-deterministic.
- *
- * // { value: 0, interval: 1000 }
- * // { value: 1, interval: 1000 }
- * // { value: 2, interval: 1000 }
- * ```
- *
- * @param scheduler Scheduler used to get the current time.
- * @return A function that returns an Observable that emits information about
- * value and interval.
- */
-export declare function timeInterval<T>(scheduler?: SchedulerLike): OperatorFunction<T, TimeInterval<T>>;
-export declare class TimeInterval<T> {
-    value: T;
-    interval: number;
-    /**
-     * @deprecated Internal implementation detail, do not construct directly. Will be made an interface in v8.
-     */
-    constructor(value: T, interval: number);
-}
-//# sourceMappingURL=timeInterval.d.ts.map

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

@@ -1,255 +0,0 @@
-import { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
-export interface TimeoutConfig<T, O extends ObservableInput<unknown> = ObservableInput<T>, M = unknown> {
-    /**
-     * The time allowed between values from the source before timeout is triggered.
-     */
-    each?: number;
-    /**
-     * The relative time as a `number` in milliseconds, or a specific time as a `Date` object,
-     * by which the first value must arrive from the source before timeout is triggered.
-     */
-    first?: number | Date;
-    /**
-     * The scheduler to use with time-related operations within this operator. Defaults to {@link asyncScheduler}
-     */
-    scheduler?: SchedulerLike;
-    /**
-     * A factory used to create observable to switch to when timeout occurs. Provides
-     * a {@link TimeoutInfo} about the source observable's emissions and what delay or
-     * exact time triggered the timeout.
-     */
-    with?: (info: TimeoutInfo<T, M>) => O;
-    /**
-     * Optional additional metadata you can provide to code that handles
-     * the timeout, will be provided through the {@link TimeoutError}.
-     * This can be used to help identify the source of a timeout or pass along
-     * other information related to the timeout.
-     */
-    meta?: M;
-}
-export interface TimeoutInfo<T, M = unknown> {
-    /** Optional metadata that was provided to the timeout configuration. */
-    readonly meta: M;
-    /** The number of messages seen before the timeout */
-    readonly seen: number;
-    /** The last message seen */
-    readonly lastValue: T | null;
-}
-/**
- * An error emitted when a timeout occurs.
- */
-export interface TimeoutError<T = unknown, M = unknown> extends Error {
-    /**
-     * The information provided to the error by the timeout
-     * operation that created the error. Will be `null` if
-     * used directly in non-RxJS code with an empty constructor.
-     * (Note that using this constructor directly is not recommended,
-     * you should create your own errors)
-     */
-    info: TimeoutInfo<T, M> | null;
-}
-export interface TimeoutErrorCtor {
-    /**
-     * @deprecated Internal implementation detail. Do not construct error instances.
-     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
-     */
-    new <T = unknown, M = unknown>(info?: TimeoutInfo<T, M>): TimeoutError<T, M>;
-}
-/**
- * An error thrown by the {@link timeout} operator.
- *
- * Provided so users can use as a type and do quality comparisons.
- * We recommend you do not subclass this or create instances of this class directly.
- * If you have need of a error representing a timeout, you should
- * create your own error class and use that.
- *
- * @see {@link timeout}
- */
-export declare const TimeoutError: TimeoutErrorCtor;
-/**
- * If `with` is provided, this will return an observable that will switch to a different observable if the source
- * does not push values within the specified time parameters.
- *
- * <span class="informal">The most flexible option for creating a timeout behavior.</span>
- *
- * The first thing to know about the configuration is if you do not provide a `with` property to the configuration,
- * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory
- * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by
- * the settings in `first` and `each`.
- *
- * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the
- * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of
- * the first value from the source _only_. The timings of all subsequent values  from the source will be checked
- * against the time period provided by `each`, if it was provided.
- *
- * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of
- * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if
- * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first
- * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first.
- *
- * ## Examples
- *
- * Emit a custom error if there is too much time between values
- *
- * ```ts
- * import { interval, timeout, throwError } from '../..';
- *
- * class CustomTimeoutError extends Error {
- *   constructor() {
- *     super('It was too slow');
- *     this.name = 'CustomTimeoutError';
- *   }
- * }
- *
- * const slow$ = interval(900);
- *
- * slow$.pipe(
- *   timeout({
- *     each: 1000,
- *     with: () => throwError(() => new CustomTimeoutError())
- *   })
- * )
- * .subscribe({
- *   error: console.error
- * });
- * ```
- *
- * Switch to a faster observable if your source is slow.
- *
- * ```ts
- * import { interval, timeout } from '../..';
- *
- * const slow$ = interval(900);
- * const fast$ = interval(500);
- *
- * slow$.pipe(
- *   timeout({
- *     each: 1000,
- *     with: () => fast$,
- *   })
- * )
- * .subscribe(console.log);
- * ```
- * @param config The configuration for the timeout.
- */
-export declare function timeout<T, O extends ObservableInput<unknown>, M = unknown>(config: TimeoutConfig<T, O, M> & {
-    with: (info: TimeoutInfo<T, M>) => O;
-}): OperatorFunction<T, T | ObservedValueOf<O>>;
-/**
- * Returns an observable that will error or switch to a different observable if the source does not push values
- * within the specified time parameters.
- *
- * <span class="informal">The most flexible option for creating a timeout behavior.</span>
- *
- * The first thing to know about the configuration is if you do not provide a `with` property to the configuration,
- * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory
- * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by
- * the settings in `first` and `each`.
- *
- * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the
- * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of
- * the first value from the source _only_. The timings of all subsequent values  from the source will be checked
- * against the time period provided by `each`, if it was provided.
- *
- * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of
- * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if
- * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first
- * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first.
- *
- * ### Handling TimeoutErrors
- *
- * If no `with` property was provided, subscriptions to the resulting observable may emit an error of {@link TimeoutError}.
- * The timeout error provides useful information you can examine when you're handling the error. The most common way to handle
- * the error would be with {@link catchError}, although you could use {@link tap} or just the error handler in your `subscribe` call
- * directly, if your error handling is only a side effect (such as notifying the user, or logging).
- *
- * In this case, you would check the error for `instanceof TimeoutError` to validate that the error was indeed from `timeout`, and
- * not from some other source. If it's not from `timeout`, you should probably rethrow it if you're in a `catchError`.
- *
- * ## Examples
- *
- * Emit a {@link TimeoutError} if the first value, and _only_ the first value, does not arrive within 5 seconds
- *
- * ```ts
- * import { interval, timeout } from '../..';
- *
- * // A random interval that lasts between 0 and 10 seconds per tick
- * const source$ = interval(Math.round(Math.random() * 10_000));
- *
- * source$.pipe(
- *   timeout({ first: 5_000 })
- * )
- * .subscribe({
- *   next: console.log,
- *   error: console.error
- * });
- * ```
- *
- * Emit a {@link TimeoutError} if the source waits longer than 5 seconds between any two values or the first value
- * and subscription.
- *
- * ```ts
- * import { timer, timeout, expand } from '../..';
- *
- * const getRandomTime = () => Math.round(Math.random() * 10_000);
- *
- * // An observable that waits a random amount of time between each delivered value
- * const source$ = timer(getRandomTime())
- *   .pipe(expand(() => timer(getRandomTime())));
- *
- * source$
- *   .pipe(timeout({ each: 5_000 }))
- *   .subscribe({
- *     next: console.log,
- *     error: console.error
- *   });
- * ```
- *
- * Emit a {@link TimeoutError} if the source does not emit before 7 seconds, _or_ if the source waits longer than
- * 5 seconds between any two values after the first.
- *
- * ```ts
- * import { timer, timeout, expand } from '../..';
- *
- * const getRandomTime = () => Math.round(Math.random() * 10_000);
- *
- * // An observable that waits a random amount of time between each delivered value
- * const source$ = timer(getRandomTime())
- *   .pipe(expand(() => timer(getRandomTime())));
- *
- * source$
- *   .pipe(timeout({ first: 7_000, each: 5_000 }))
- *   .subscribe({
- *     next: console.log,
- *     error: console.error
- *   });
- * ```
- */
-export declare function timeout<T, M = unknown>(config: Omit<TimeoutConfig<T, any, M>, 'with'>): OperatorFunction<T, T>;
-/**
- * Returns an observable that will error if the source does not push its first value before the specified time passed as a `Date`.
- * This is functionally the same as `timeout({ first: someDate })`.
- *
- * <span class="informal">Errors if the first value doesn't show up before the given date and time</span>
- *
- * ![](timeout.png)
- *
- * @param first The date to at which the resulting observable will timeout if the source observable
- * does not emit at least one value.
- * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}.
- */
-export declare function timeout<T>(first: Date, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-/**
- * Returns an observable that will error if the source does not push a value within the specified time in milliseconds.
- * This is functionally the same as `timeout({ each: milliseconds })`.
- *
- * <span class="informal">Errors if it waits too long between any value</span>
- *
- * ![](timeout.png)
- *
- * @param each The time allowed between each pushed value from the source before the resulting observable
- * will timeout.
- * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}.
- */
-export declare function timeout<T>(each: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=timeout.d.ts.map

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

@@ -1,8 +0,0 @@
-import { ObservableInput, OperatorFunction, SchedulerLike } from '../types';
-/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(someDate, a$, scheduler)`, use the configuration object
- * `timeout({ first: someDate, with: () => a$, scheduler })`. Will be removed in v8. */
-export declare function timeoutWith<T, R>(dueBy: Date, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>;
-/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(100, a$, scheduler)`, use the configuration object
- *  `timeout({ each: 100, with: () => a$, scheduler })`. Will be removed in v8. */
-export declare function timeoutWith<T, R>(waitFor: number, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>;
-//# sourceMappingURL=timeoutWith.d.ts.map

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

@@ -1,35 +0,0 @@
-import { OperatorFunction, TimestampProvider, Timestamp } from '../types';
-/**
- * Attaches a timestamp to each item emitted by an observable indicating when it was emitted
- *
- * The `timestamp` operator maps the *source* observable stream to an object of type
- * `{value: T, timestamp: R}`. The properties are generically typed. The `value` property contains the value
- * and type of the *source* observable. The `timestamp` is generated by the schedulers `now` function. By
- * default, it uses the `asyncScheduler` which simply returns `Date.now()` (milliseconds since 1970/01/01
- * 00:00:00:000) and therefore is of type `number`.
- *
- * ![](timestamp.png)
- *
- * ## Example
- *
- * In this example there is a timestamp attached to the document's click events
- *
- * ```ts
- * import { fromEvent, timestamp } from '../..';
- *
- * const clickWithTimestamp = fromEvent(document, 'click').pipe(
- *   timestamp()
- * );
- *
- * // Emits data of type { value: PointerEvent, timestamp: number }
- * clickWithTimestamp.subscribe(data => {
- *   console.log(data);
- * });
- * ```
- *
- * @param timestampProvider An object with a `now()` method used to get the current timestamp.
- * @return A function that returns an Observable that attaches a timestamp to
- * each item emitted by the source Observable indicating when it was emitted.
- */
-export declare function timestamp<T>(timestampProvider?: TimestampProvider): OperatorFunction<T, Timestamp<T>>;
-//# sourceMappingURL=timestamp.d.ts.map

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

@@ -1,33 +0,0 @@
-import { OperatorFunction } from '../types';
-/**
- * Collects all source emissions and emits them as an array when the source completes.
- *
- * <span class="informal">Get all values inside an array when the source completes</span>
- *
- * ![](toArray.png)
- *
- * `toArray` will wait until the source Observable completes before emitting
- * the array containing all emissions. When the source Observable errors no
- * array will be emitted.
- *
- * ## Example
- *
- * ```ts
- * import { interval, take, toArray } from '../..';
- *
- * const source = interval(1000);
- * const example = source.pipe(
- *   take(10),
- *   toArray()
- * );
- *
- * example.subscribe(value => console.log(value));
- *
- * // output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- * ```
- *
- * @return A function that returns an Observable that emits an array of items
- * emitted by the source Observable when source completes.
- */
-export declare function toArray<T>(): OperatorFunction<T, T[]>;
-//# sourceMappingURL=toArray.d.ts.map

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

@@ -1,48 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction, ObservableInput } from '../types';
-/**
- * Branch out the source Observable values as a nested Observable whenever
- * `windowBoundaries` emits.
- *
- * <span class="informal">It's like {@link buffer}, but emits a nested Observable
- * instead of an array.</span>
- *
- * ![](window.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits connected, non-overlapping
- * windows. It emits the current window and opens a new one whenever the
- * `windowBoundaries` emits an item. `windowBoundaries` can be any type that
- * `ObservableInput` accepts. It internally gets converted to an Observable.
- * Because each window is an Observable, the output is a higher-order Observable.
- *
- * ## Example
- *
- * In every window of 1 second each, emit at most 2 click events
- *
- * ```ts
- * import { fromEvent, interval, window, map, take, mergeAll } from '../..';
- *
- * const clicks = fromEvent(document, 'click');
- * const sec = interval(1000);
- * const result = clicks.pipe(
- *   window(sec),
- *   map(win => win.pipe(take(2))), // take at most 2 emissions from each window
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link windowCount}
- * @see {@link windowTime}
- * @see {@link windowToggle}
- * @see {@link windowWhen}
- * @see {@link buffer}
- *
- * @param windowBoundaries An `ObservableInput` that completes the
- * previous window and starts a new window.
- * @return A function that returns an Observable of windows, which are
- * Observables emitting values of the source Observable.
- */
-export declare function window<T>(windowBoundaries: ObservableInput<any>): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=window.d.ts.map

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

@@ -1,65 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction } from '../types';
-/**
- * Branch out the source Observable values as a nested Observable with each
- * nested Observable emitting at most `windowSize` values.
- *
- * <span class="informal">It's like {@link bufferCount}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowCount.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits windows every `startWindowEvery`
- * items, each containing no more than `windowSize` items. When the source
- * Observable completes or encounters an error, the output Observable emits
- * the current window and propagates the notification from the source
- * Observable. If `startWindowEvery` is not provided, then new windows are
- * started immediately at the start of the source and when each window completes
- * with size `windowSize`.
- *
- * ## Examples
- *
- * Ignore every 3rd click event, starting from the first one
- *
- * ```ts
- * import { fromEvent, windowCount, map, skip, mergeAll } from '../..';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowCount(3),
- *   map(win => win.pipe(skip(1))), // skip first of every 3 clicks
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * Ignore every 3rd click event, starting from the third one
- *
- * ```ts
- * import { fromEvent, windowCount, mergeAll } from '../..';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowCount(2, 3),
- *   mergeAll() // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowTime}
- * @see {@link windowToggle}
- * @see {@link windowWhen}
- * @see {@link bufferCount}
- *
- * @param windowSize The maximum number of values emitted by each window.
- * @param startWindowEvery Interval at which to start a new window. For example
- * if `startWindowEvery` is `2`, then a new window will be started on every
- * other value from the source. A new window is started at the beginning of the
- * source by default.
- * @return A function that returns an Observable of windows, which in turn are
- * Observable of values.
- */
-export declare function windowCount<T>(windowSize: number, startWindowEvery?: number): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=windowCount.d.ts.map

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

@@ -1,6 +0,0 @@
-import { Observable } from '../Observable';
-import { OperatorFunction, SchedulerLike } from '../types';
-export declare function windowTime<T>(windowTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;
-export declare function windowTime<T>(windowTimeSpan: number, windowCreationInterval: number, scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;
-export declare function windowTime<T>(windowTimeSpan: number, windowCreationInterval: number | null | void, maxWindowSize: number, scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=windowTime.d.ts.map

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

@@ -1,49 +0,0 @@
-import { Observable } from '../Observable';
-import { ObservableInput, OperatorFunction } from '../types';
-/**
- * Branch out the source Observable values as a nested Observable starting from
- * an emission from `openings` and ending when the output of `closingSelector`
- * emits.
- *
- * <span class="informal">It's like {@link bufferToggle}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowToggle.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits windows that contain those items
- * emitted by the source Observable between the time when the `openings`
- * Observable emits an item and when the Observable returned by
- * `closingSelector` emits an item.
- *
- * ## Example
- *
- * Every other second, emit the click events from the next 500ms
- *
- * ```ts
- * import { fromEvent, interval, windowToggle, EMPTY, mergeAll } from '../..';
- *
- * const clicks = fromEvent(document, 'click');
- * const openings = interval(1000);
- * const result = clicks.pipe(
- *   windowToggle(openings, i => i % 2 ? interval(500) : EMPTY),
- *   mergeAll()
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowCount}
- * @see {@link windowTime}
- * @see {@link windowWhen}
- * @see {@link bufferToggle}
- *
- * @param openings An observable of notifications to start new windows.
- * @param closingSelector A function that takes the value emitted by the
- * `openings` observable and returns an Observable, which, when it emits a next
- * notification, signals that the associated window should complete.
- * @return A function that returns an Observable of windows, which in turn are
- * Observables.
- */
-export declare function windowToggle<T, O>(openings: ObservableInput<O>, closingSelector: (openValue: O) => ObservableInput<any>): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=windowToggle.d.ts.map

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

@@ -1,49 +0,0 @@
-import { Observable } from '../Observable';
-import { ObservableInput, OperatorFunction } from '../types';
-/**
- * Branch out the source Observable values as a nested Observable using a
- * factory function of closing Observables to determine when to start a new
- * window.
- *
- * <span class="informal">It's like {@link bufferWhen}, but emits a nested
- * Observable instead of an array.</span>
- *
- * ![](windowWhen.png)
- *
- * Returns an Observable that emits windows of items it collects from the source
- * Observable. The output Observable emits connected, non-overlapping windows.
- * It emits the current window and opens a new one whenever the Observable
- * produced by the specified `closingSelector` function emits an item. The first
- * window is opened immediately when subscribing to the output Observable.
- *
- * ## Example
- *
- * Emit only the first two clicks events in every window of [1-5] random seconds
- *
- * ```ts
- * import { fromEvent, windowWhen, interval, map, take, mergeAll } from '../..';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(
- *   windowWhen(() => interval(1000 + Math.random() * 4000)),
- *   map(win => win.pipe(take(2))), // take at most 2 emissions from each window
- *   mergeAll()                     // flatten the Observable-of-Observables
- * );
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link window}
- * @see {@link windowCount}
- * @see {@link windowTime}
- * @see {@link windowToggle}
- * @see {@link bufferWhen}
- *
- * @param closingSelector A function that takes no arguments and returns an
- * {@link ObservableInput} (that gets converted to Observable) that signals
- * (on either `next` or `complete`) when to close the previous window and
- * start a new one.
- * @return A function that returns an Observable of windows, which in turn are
- * Observables.
- */
-export declare function windowWhen<T>(closingSelector: () => ObservableInput<any>): OperatorFunction<T, Observable<T>>;
-//# sourceMappingURL=windowWhen.d.ts.map

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

@@ -1,4 +0,0 @@
-import { OperatorFunction, ObservableInputTuple } from '../types';
-export declare function withLatestFrom<T, O extends unknown[]>(...inputs: [...ObservableInputTuple<O>]): OperatorFunction<T, [T, ...O]>;
-export declare function withLatestFrom<T, O extends unknown[], R>(...inputs: [...ObservableInputTuple<O>, (...value: [T, ...O]) => R]): OperatorFunction<T, R>;
-//# sourceMappingURL=withLatestFrom.d.ts.map

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

@@ -1,10 +0,0 @@
-import { ObservableInputTuple, OperatorFunction, Cons } from '../types';
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export declare function zip<T, A extends readonly unknown[]>(otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>;
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export declare function zip<T, A extends readonly unknown[], R>(otherInputsAndProject: [...ObservableInputTuple<A>], project: (...values: Cons<T, A>) => R): OperatorFunction<T, R>;
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export declare function zip<T, A extends readonly unknown[]>(...otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>;
-/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */
-export declare function zip<T, A extends readonly unknown[], R>(...otherInputsAndProject: [...ObservableInputTuple<A>, (...values: Cons<T, A>) => R]): OperatorFunction<T, R>;
-//# sourceMappingURL=zip.d.ts.map