@bleedingdev/modern-js-utils 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/compiled/inquirer/rxjs/internal/ajax/types.d.ts

@@ -0,0 +1,200 @@
+import { PartialObserver } from '../types';
+/**
+ * Valid Ajax direction types. Prefixes the event `type` in the
+ * {@link AjaxResponse} object with "upload_" for events related
+ * to uploading and "download_" for events related to downloading.
+ */
+export declare type AjaxDirection = 'upload' | 'download';
+export declare type ProgressEventType = 'loadstart' | 'progress' | 'load';
+export declare type AjaxResponseType = `${AjaxDirection}_${ProgressEventType}`;
+/**
+ * The object containing values RxJS used to make the HTTP request.
+ *
+ * This is provided in {@link AjaxError} instances as the `request`
+ * object.
+ */
+export interface AjaxRequest {
+    /**
+     * The URL requested.
+     */
+    url: string;
+    /**
+     * The body to send over the HTTP request.
+     */
+    body?: any;
+    /**
+     * The HTTP method used to make the HTTP request.
+     */
+    method: string;
+    /**
+     * Whether or not the request was made asynchronously.
+     */
+    async: boolean;
+    /**
+     * The headers sent over the HTTP request.
+     */
+    headers: Readonly<Record<string, any>>;
+    /**
+     * The timeout value used for the HTTP request.
+     * Note: this is only honored if the request is asynchronous (`async` is `true`).
+     */
+    timeout: number;
+    /**
+     * The user credentials user name sent with the HTTP request.
+     */
+    user?: string;
+    /**
+     * The user credentials password sent with the HTTP request.
+     */
+    password?: string;
+    /**
+     * Whether or not the request was a CORS request.
+     */
+    crossDomain: boolean;
+    /**
+     * Whether or not a CORS request was sent with credentials.
+     * If `false`, will also ignore cookies in the CORS response.
+     */
+    withCredentials: boolean;
+    /**
+     * The [`responseType`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType) set before sending the request.
+     */
+    responseType: XMLHttpRequestResponseType;
+}
+/**
+ * Configuration for the {@link ajax} creation function.
+ */
+export interface AjaxConfig {
+    /** The address of the resource to request via HTTP. */
+    url: string;
+    /**
+     * The body of the HTTP request to send.
+     *
+     * This is serialized, by default, based off of the value of the `"content-type"` header.
+     * For example, if the `"content-type"` is `"application/json"`, the body will be serialized
+     * as JSON. If the `"content-type"` is `"application/x-www-form-urlencoded"`, whatever object passed
+     * to the body will be serialized as URL, using key-value pairs based off of the keys and values of the object.
+     * In all other cases, the body will be passed directly.
+     */
+    body?: any;
+    /**
+     * Whether or not to send the request asynchronously. Defaults to `true`.
+     * If set to `false`, this will block the thread until the AJAX request responds.
+     */
+    async?: boolean;
+    /**
+     * The HTTP Method to use for the request. Defaults to "GET".
+     */
+    method?: string;
+    /**
+     * The HTTP headers to apply.
+     *
+     * Note that, by default, RxJS will add the following headers under certain conditions:
+     *
+     * 1. If the `"content-type"` header is **NOT** set, and the `body` is [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData),
+     *    a `"content-type"` of `"application/x-www-form-urlencoded; charset=UTF-8"` will be set automatically.
+     * 2. If the `"x-requested-with"` header is **NOT** set, and the `crossDomain` configuration property is **NOT** explicitly set to `true`,
+     *    (meaning it is not a CORS request), a `"x-requested-with"` header with a value of `"XMLHttpRequest"` will be set automatically.
+     *    This header is generally meaningless, and is set by libraries and frameworks using `XMLHttpRequest` to make HTTP requests.
+     */
+    headers?: Readonly<Record<string, any>>;
+    /**
+     * The time to wait before causing the underlying XMLHttpRequest to timeout. This is only honored if the
+     * `async` configuration setting is unset or set to `true`. Defaults to `0`, which is idiomatic for "never timeout".
+     */
+    timeout?: number;
+    /** The user credentials user name to send with the HTTP request */
+    user?: string;
+    /** The user credentials password to send with the HTTP request*/
+    password?: string;
+    /**
+     * Whether or not to send the HTTP request as a CORS request.
+     * Defaults to `false`.
+     *
+     * @deprecated Will be removed in version 8. Cross domain requests and what creates a cross
+     * domain request, are dictated by the browser, and a boolean that forces it to be cross domain
+     * does not make sense. If you need to force cross domain, make sure you're making a secure request,
+     * then add a custom header to the request or use `withCredentials`. For more information on what
+     * triggers a cross domain request, see the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials).
+     * In particular, the section on [Simple Requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#Simple_requests) is useful
+     * for understanding when CORS will not be used.
+     */
+    crossDomain?: boolean;
+    /**
+     * To send user credentials in a CORS request, set to `true`. To exclude user credentials from
+     * a CORS request, _OR_ when cookies are to be ignored by the CORS response, set to `false`.
+     *
+     * Defaults to `false`.
+     */
+    withCredentials?: boolean;
+    /**
+     * The name of your site's XSRF cookie.
+     */
+    xsrfCookieName?: string;
+    /**
+     * The name of a custom header that you can use to send your XSRF cookie.
+     */
+    xsrfHeaderName?: string;
+    /**
+     * Can be set to change the response type.
+     * Valid values are `"arraybuffer"`, `"blob"`, `"document"`, `"json"`, and `"text"`.
+     * Note that the type of `"document"` (such as an XML document) is ignored if the global context is
+     * not `Window`.
+     *
+     * Defaults to `"json"`.
+     */
+    responseType?: XMLHttpRequestResponseType;
+    /**
+     * An optional factory used to create the XMLHttpRequest object used to make the AJAX request.
+     * This is useful in environments that lack `XMLHttpRequest`, or in situations where you
+     * wish to override the default `XMLHttpRequest` for some reason.
+     *
+     * If not provided, the `XMLHttpRequest` in global scope will be used.
+     *
+     * NOTE: This AJAX implementation relies on the built-in serialization and setting
+     * of Content-Type headers that is provided by standards-compliant XMLHttpRequest implementations,
+     * be sure any implementation you use meets that standard.
+     */
+    createXHR?: () => XMLHttpRequest;
+    /**
+     * An observer for watching the upload progress of an HTTP request. Will
+     * emit progress events, and completes on the final upload load event, will error for
+     * any XHR error or timeout.
+     *
+     * This will **not** error for errored status codes. Rather, it will always _complete_ when
+     * the HTTP response comes back.
+     *
+     * @deprecated If you're looking for progress events, use {@link includeDownloadProgress} and
+     * {@link includeUploadProgress} instead. Will be removed in v8.
+     */
+    progressSubscriber?: PartialObserver<ProgressEvent>;
+    /**
+     * If `true`, will emit all download progress and load complete events as {@link AjaxResponse}
+     * from the observable. The final download event will also be emitted as a {@link AjaxResponse}.
+     *
+     * If both this and {@link includeUploadProgress} are `false`, then only the {@link AjaxResponse} will
+     * be emitted from the resulting observable.
+     */
+    includeDownloadProgress?: boolean;
+    /**
+     * If `true`, will emit all upload progress and load complete events as {@link AjaxResponse}
+     * from the observable. The final download event will also be emitted as a {@link AjaxResponse}.
+     *
+     * If both this and {@link includeDownloadProgress} are `false`, then only the {@link AjaxResponse} will
+     * be emitted from the resulting observable.
+     */
+    includeUploadProgress?: boolean;
+    /**
+     * Query string parameters to add to the URL in the request.
+     * <em>This will require a polyfill for `URL` and `URLSearchParams` in Internet Explorer!</em>
+     *
+     * Accepts either a query string, a `URLSearchParams` object, a dictionary of key/value pairs, or an
+     * array of key/value entry tuples. (Essentially, it takes anything that `new URLSearchParams` would normally take).
+     *
+     * If, for some reason you have a query string in the `url` argument, this will append to the query string in the url,
+     * but it will also overwrite the value of any keys that are an exact match. In other words, a url of `/test?a=1&b=2`,
+     * with queryParams of `{ b: 5, c: 6 }` will result in a url of roughly `/test?a=1&b=5&c=6`.
+     */
+    queryParams?: string | URLSearchParams | Record<string, string | number | boolean | string[] | number[] | boolean[]> | [string, string | number | boolean | string[] | number[] | boolean[]][];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/config.d.ts

@@ -0,0 +1,73 @@
+import { Subscriber } from './Subscriber';
+import { ObservableNotification } from './types';
+/**
+ * The {@link GlobalConfig} object for RxJS. It is used to configure things
+ * like how to react on unhandled errors.
+ */
+export declare const config: GlobalConfig;
+/**
+ * The global configuration object for RxJS, used to configure things
+ * like how to react on unhandled errors. Accessible via {@link config}
+ * object.
+ */
+export interface GlobalConfig {
+    /**
+     * A registration point for unhandled errors from RxJS. These are errors that
+     * cannot were not handled by consuming code in the usual subscription path. For
+     * example, if you have this configured, and you subscribe to an observable without
+     * providing an error handler, errors from that subscription will end up here. This
+     * will _always_ be called asynchronously on another job in the runtime. This is because
+     * we do not want errors thrown in this user-configured handler to interfere with the
+     * behavior of the library.
+     */
+    onUnhandledError: ((err: any) => void) | null;
+    /**
+     * A registration point for notifications that cannot be sent to subscribers because they
+     * have completed, errored or have been explicitly unsubscribed. By default, next, complete
+     * and error notifications sent to stopped subscribers are noops. However, sometimes callers
+     * might want a different behavior. For example, with sources that attempt to report errors
+     * to stopped subscribers, a caller can configure RxJS to throw an unhandled error instead.
+     * This will _always_ be called asynchronously on another job in the runtime. This is because
+     * we do not want errors thrown in this user-configured handler to interfere with the
+     * behavior of the library.
+     */
+    onStoppedNotification: ((notification: ObservableNotification<any>, subscriber: Subscriber<any>) => void) | null;
+    /**
+     * The promise constructor used by default for {@link Observable#toPromise toPromise} and {@link Observable#forEach forEach}
+     * methods.
+     *
+     * @deprecated As of version 8, RxJS will no longer support this sort of injection of a
+     * Promise constructor. If you need a Promise implementation other than native promises,
+     * please polyfill/patch Promise as you see appropriate. Will be removed in v8.
+     */
+    Promise?: PromiseConstructorLike;
+    /**
+     * If true, turns on synchronous error rethrowing, which is a deprecated behavior
+     * in v6 and higher. This behavior enables bad patterns like wrapping a subscribe
+     * call in a try/catch block. It also enables producer interference, a nasty bug
+     * where a multicast can be broken for all observers by a downstream consumer with
+     * an unhandled error. DO NOT USE THIS FLAG UNLESS IT'S NEEDED TO BUY TIME
+     * FOR MIGRATION REASONS.
+     *
+     * @deprecated As of version 8, RxJS will no longer support synchronous throwing
+     * of unhandled errors. All errors will be thrown on a separate call stack to prevent bad
+     * behaviors described above. Will be removed in v8.
+     */
+    useDeprecatedSynchronousErrorHandling: boolean;
+    /**
+     * If true, enables an as-of-yet undocumented feature from v5: The ability to access
+     * `unsubscribe()` via `this` context in `next` functions created in observers passed
+     * to `subscribe`.
+     *
+     * This is being removed because the performance was severely problematic, and it could also cause
+     * issues when types other than POJOs are passed to subscribe as subscribers, as they will likely have
+     * their `this` context overwritten.
+     *
+     * @deprecated As of version 8, RxJS will no longer support altering the
+     * context of next functions provided as part of an observer to Subscribe. Instead,
+     * you will have access to a subscription or a signal or token that will allow you to do things like
+     * unsubscribe and test closed status. Will be removed in v8.
+     */
+    useDeprecatedNextContext: boolean;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/firstValueFrom.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from './Observable';
+export interface FirstValueFromConfig<T> {
+    defaultValue: T;
+}
+export declare function firstValueFrom<T, D>(source: Observable<T>, config: FirstValueFromConfig<D>): Promise<T | D>;
+export declare function firstValueFrom<T>(source: Observable<T>): Promise<T>;
+//# sourceMappingURL=firstValueFrom.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/lastValueFrom.d.ts

@@ -0,0 +1,7 @@
+import { Observable } from './Observable';
+export interface LastValueFromConfig<T> {
+    defaultValue: T;
+}
+export declare function lastValueFrom<T, D>(source: Observable<T>, config: LastValueFromConfig<D>): Promise<T | D>;
+export declare function lastValueFrom<T>(source: Observable<T>): Promise<T>;
+//# sourceMappingURL=lastValueFrom.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/observable/ConnectableObservable.d.ts

@@ -0,0 +1,42 @@
+import { Subject } from '../Subject';
+import { Observable } from '../Observable';
+import { Subscription } from '../Subscription';
+/**
+ * @class ConnectableObservable<T>
+ * @deprecated Will be removed in v8. Use {@link connectable} to create a connectable observable.
+ * If you are using the `refCount` method of `ConnectableObservable`, use the {@link share} operator
+ * instead.
+ * Details: https://rxjs.dev/deprecations/multicasting
+ */
+export declare class ConnectableObservable<T> extends Observable<T> {
+    source: Observable<T>;
+    protected subjectFactory: () => Subject<T>;
+    protected _subject: Subject<T> | null;
+    protected _refCount: number;
+    protected _connection: Subscription | null;
+    /**
+     * @param source The source observable
+     * @param subjectFactory The factory that creates the subject used internally.
+     * @deprecated Will be removed in v8. Use {@link connectable} to create a connectable observable.
+     * `new ConnectableObservable(source, factory)` is equivalent to
+     * `connectable(source, { connector: factory })`.
+     * When the `refCount()` method is needed, the {@link share} operator should be used instead:
+     * `new ConnectableObservable(source, factory).refCount()` is equivalent to
+     * `source.pipe(share({ connector: factory }))`.
+     * Details: https://rxjs.dev/deprecations/multicasting
+     */
+    constructor(source: Observable<T>, subjectFactory: () => Subject<T>);
+    protected getSubject(): Subject<T>;
+    protected _teardown(): void;
+    /**
+     * @deprecated {@link ConnectableObservable} will be removed in v8. Use {@link connectable} instead.
+     * Details: https://rxjs.dev/deprecations/multicasting
+     */
+    connect(): Subscription;
+    /**
+     * @deprecated {@link ConnectableObservable} will be removed in v8. Use the {@link share} operator instead.
+     * Details: https://rxjs.dev/deprecations/multicasting
+     */
+    refCount(): Observable<T>;
+}
+//# sourceMappingURL=ConnectableObservable.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/observable/bindCallback.d.ts

@@ -0,0 +1,5 @@
+import { SchedulerLike } from '../types';
+import { Observable } from '../Observable';
+export declare function bindCallback(callbackFunc: (...args: any[]) => void, resultSelector: (...args: any[]) => any, scheduler?: SchedulerLike): (...args: any[]) => Observable<any>;
+export declare function bindCallback<A extends readonly unknown[], R extends readonly unknown[]>(callbackFunc: (...args: [...A, (...res: R) => void]) => void, schedulerLike?: SchedulerLike): (...arg: A) => Observable<R extends [] ? void : R extends [any] ? R[0] : R>;
+//# sourceMappingURL=bindCallback.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/observable/bindCallbackInternals.d.ts

@@ -0,0 +1,4 @@
+import { SchedulerLike } from '../types';
+import { Observable } from '../Observable';
+export declare function bindCallbackInternals(isNodeStyle: boolean, callbackFunc: any, resultSelector?: any, scheduler?: SchedulerLike): (...args: any[]) => Observable<unknown>;
+//# sourceMappingURL=bindCallbackInternals.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/observable/bindNodeCallback.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from '../Observable';
+import { SchedulerLike } from '../types';
+export declare function bindNodeCallback(callbackFunc: (...args: any[]) => void, resultSelector: (...args: any[]) => any, scheduler?: SchedulerLike): (...args: any[]) => Observable<any>;
+export declare function bindNodeCallback<A extends readonly unknown[], R extends readonly unknown[]>(callbackFunc: (...args: [...A, (err: any, ...res: R) => void]) => void, schedulerLike?: SchedulerLike): (...arg: A) => Observable<R extends [] ? void : R extends [any] ? R[0] : R>;
+//# sourceMappingURL=bindNodeCallback.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/observable/combineLatest.d.ts

@@ -0,0 +1,33 @@
+import { Observable } from '../Observable';
+import { ObservableInput, SchedulerLike, ObservedValueOf, ObservableInputTuple } from '../types';
+import { Subscriber } from '../Subscriber';
+import { AnyCatcher } from '../AnyCatcher';
+/**
+ * You have passed `any` here, we can't figure out if it is
+ * an array or an object, so you're getting `unknown`. Use better types.
+ * @param arg Something typed as `any`
+ */
+export declare function combineLatest<T extends AnyCatcher>(arg: T): Observable<unknown>;
+export declare function combineLatest(sources: []): Observable<never>;
+export declare function combineLatest<A extends readonly unknown[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<A>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export declare function combineLatest<A extends readonly unknown[], R>(sources: readonly [...ObservableInputTuple<A>], resultSelector: (...values: A) => R, scheduler: SchedulerLike): Observable<R>;
+export declare function combineLatest<A extends readonly unknown[], R>(sources: readonly [...ObservableInputTuple<A>], resultSelector: (...values: A) => R): Observable<R>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export declare function combineLatest<A extends readonly unknown[]>(sources: readonly [...ObservableInputTuple<A>], scheduler: SchedulerLike): Observable<A>;
+/** @deprecated Pass an array of sources instead. The rest-parameters signature will be removed in v8. Details: https://rxjs.dev/deprecations/array-argument */
+export declare function combineLatest<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export declare function combineLatest<A extends readonly unknown[], R>(...sourcesAndResultSelectorAndScheduler: [...ObservableInputTuple<A>, (...values: A) => R, SchedulerLike]): Observable<R>;
+/** @deprecated Pass an array of sources instead. The rest-parameters signature will be removed in v8. Details: https://rxjs.dev/deprecations/array-argument */
+export declare function combineLatest<A extends readonly unknown[], R>(...sourcesAndResultSelector: [...ObservableInputTuple<A>, (...values: A) => R]): Observable<R>;
+/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `combineLatestAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */
+export declare function combineLatest<A extends readonly unknown[]>(...sourcesAndScheduler: [...ObservableInputTuple<A>, SchedulerLike]): Observable<A>;
+export declare function combineLatest(sourcesObject: {
+    [K in any]: never;
+}): Observable<never>;
+export declare function combineLatest<T extends Record<string, ObservableInput<any>>>(sourcesObject: T): Observable<{
+    [K in keyof T]: ObservedValueOf<T[K]>;
+}>;
+export declare function combineLatestInit(observables: ObservableInput<any>[], scheduler?: SchedulerLike, valueTransform?: (values: any[]) => any): (subscriber: Subscriber<any>) => void;
+//# sourceMappingURL=combineLatest.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/observable/concat.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from '../Observable';
+import { ObservableInputTuple, SchedulerLike } from '../types';
+export declare function concat<T extends readonly unknown[]>(...inputs: [...ObservableInputTuple<T>]): Observable<T[number]>;
+export declare function concat<T extends readonly unknown[]>(...inputsAndScheduler: [...ObservableInputTuple<T>, SchedulerLike]): Observable<T[number]>;
+//# sourceMappingURL=concat.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/observable/connectable.d.ts

@@ -0,0 +1,27 @@
+import { Connectable, ObservableInput, SubjectLike } from '../types';
+export interface ConnectableConfig<T> {
+    /**
+     * A factory function used to create the Subject through which the source
+     * is multicast. By default this creates a {@link Subject}.
+     */
+    connector: () => SubjectLike<T>;
+    /**
+     * If true, the resulting observable will reset internal state upon disconnection
+     * and return to a "cold" state. This allows the resulting observable to be
+     * reconnected.
+     * If false, upon disconnection, the connecting subject will remain the
+     * connecting subject, meaning the resulting observable will not go "cold" again,
+     * and subsequent repeats or resubscriptions will resubscribe to that same subject.
+     */
+    resetOnDisconnect?: boolean;
+}
+/**
+ * Creates an observable that multicasts once `connect()` is called on it.
+ *
+ * @param source The observable source to make connectable.
+ * @param config The configuration object for `connectable`.
+ * @returns A "connectable" observable, that has a `connect()` method, that you must call to
+ * connect the source to all consumers through the subject provided as the connector.
+ */
+export declare function connectable<T>(source: ObservableInput<T>, config?: ConnectableConfig<T>): Connectable<T>;
+//# sourceMappingURL=connectable.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/observable/defer.d.ts

@@ -0,0 +1,51 @@
+import { Observable } from '../Observable';
+import { ObservedValueOf, ObservableInput } from '../types';
+/**
+ * Creates an Observable that, on subscribe, calls an Observable factory to
+ * make an Observable for each new Observer.
+ *
+ * <span class="informal">Creates the Observable lazily, that is, only when it
+ * is subscribed.
+ * </span>
+ *
+ * ![](defer.png)
+ *
+ * `defer` allows you to create an Observable only when the Observer
+ * subscribes. It waits until an Observer subscribes to it, calls the given
+ * factory function to get an Observable -- where a factory function typically
+ * generates a new Observable -- and subscribes the Observer to this Observable.
+ * In case the factory function returns a falsy value, then EMPTY is used as
+ * Observable instead. Last but not least, an exception during the factory
+ * function call is transferred to the Observer by calling `error`.
+ *
+ * ## Example
+ *
+ * Subscribe to either an Observable of clicks or an Observable of interval, at random
+ *
+ * ```ts
+ * import { defer, fromEvent, interval } from '../..';
+ *
+ * const clicksOrInterval = defer(() => {
+ *   return Math.random() > 0.5
+ *     ? fromEvent(document, 'click')
+ *     : interval(1000);
+ * });
+ * clicksOrInterval.subscribe(x => console.log(x));
+ *
+ * // Results in the following behavior:
+ * // If the result of Math.random() is greater than 0.5 it will listen
+ * // for clicks anywhere on the "document"; when document is clicked it
+ * // will log a MouseEvent object to the console. If the result is less
+ * // than 0.5 it will emit ascending numbers, one every second(1000ms).
+ * ```
+ *
+ * @see {@link Observable}
+ *
+ * @param observableFactory The Observable factory function to invoke for each
+ * Observer that subscribes to the output Observable. May also return any
+ * `ObservableInput`, which will be converted on the fly to an Observable.
+ * @return An Observable whose Observers' subscriptions trigger an invocation of the
+ * given Observable factory function.
+ */
+export declare function defer<R extends ObservableInput<any>>(observableFactory: () => R): Observable<ObservedValueOf<R>>;
+//# sourceMappingURL=defer.d.ts.map

package/dist/compiled/inquirer/rxjs/internal/observable/dom/WebSocketSubject.d.ts

@@ -0,0 +1,173 @@
+import { AnonymousSubject } from '../../Subject';
+import { Observable } from '../../Observable';
+import { Operator } from '../../Operator';
+import { Observer, NextObserver } from '../../types';
+/**
+ * WebSocketSubjectConfig is a plain Object that allows us to make our
+ * webSocket configurable.
+ *
+ * <span class="informal">Provides flexibility to {@link webSocket}</span>
+ *
+ * It defines a set of properties to provide custom behavior in specific
+ * moments of the socket's lifecycle. When the connection opens we can
+ * use `openObserver`, when the connection is closed `closeObserver`, if we
+ * are interested in listening for data coming from server: `deserializer`,
+ * which allows us to customize the deserialization strategy of data before passing it
+ * to the socket client. By default, `deserializer` is going to apply `JSON.parse` to each message coming
+ * from the Server.
+ *
+ * ## Examples
+ *
+ * **deserializer**, the default for this property is `JSON.parse` but since there are just two options
+ * for incoming data, either be text or binary data. We can apply a custom deserialization strategy
+ * or just simply skip the default behaviour.
+ *
+ * ```ts
+ * import { webSocket } from 'rxjs/webSocket';
+ *
+ * const wsSubject = webSocket({
+ *   url: 'ws://localhost:8081',
+ *   //Apply any transformation of your choice.
+ *   deserializer: ({ data }) => data
+ * });
+ *
+ * wsSubject.subscribe(console.log);
+ *
+ * // Let's suppose we have this on the Server: ws.send('This is a msg from the server')
+ * //output
+ * //
+ * // This is a msg from the server
+ * ```
+ *
+ * **serializer** allows us to apply custom serialization strategy but for the outgoing messages.
+ *
+ * ```ts
+ * import { webSocket } from 'rxjs/webSocket';
+ *
+ * const wsSubject = webSocket({
+ *   url: 'ws://localhost:8081',
+ *   // Apply any transformation of your choice.
+ *   serializer: msg => JSON.stringify({ channel: 'webDevelopment', msg: msg })
+ * });
+ *
+ * wsSubject.subscribe(() => subject.next('msg to the server'));
+ *
+ * // Let's suppose we have this on the Server:
+ * //   ws.on('message', msg => console.log);
+ * //   ws.send('This is a msg from the server');
+ * // output at server side:
+ * //
+ * // {"channel":"webDevelopment","msg":"msg to the server"}
+ * ```
+ *
+ * **closeObserver** allows us to set a custom error when an error raises up.
+ *
+ * ```ts
+ * import { webSocket } from 'rxjs/webSocket';
+ *
+ * const wsSubject = webSocket({
+ *   url: 'ws://localhost:8081',
+ *   closeObserver: {
+ *     next() {
+ *       const customError = { code: 6666, reason: 'Custom evil reason' }
+ *       console.log(`code: ${ customError.code }, reason: ${ customError.reason }`);
+ *     }
+ *   }
+ * });
+ *
+ * // output
+ * // code: 6666, reason: Custom evil reason
+ * ```
+ *
+ * **openObserver**, Let's say we need to make some kind of init task before sending/receiving msgs to the
+ * webSocket or sending notification that the connection was successful, this is when
+ * openObserver is useful for.
+ *
+ * ```ts
+ * import { webSocket } from 'rxjs/webSocket';
+ *
+ * const wsSubject = webSocket({
+ *   url: 'ws://localhost:8081',
+ *   openObserver: {
+ *     next: () => {
+ *       console.log('Connection ok');
+ *     }
+ *   }
+ * });
+ *
+ * // output
+ * // Connection ok
+ * ```
+ */
+export interface WebSocketSubjectConfig<T> {
+    /** The url of the socket server to connect to */
+    url: string;
+    /** The protocol to use to connect */
+    protocol?: string | Array<string>;
+    /** @deprecated Will be removed in v8. Use {@link deserializer} instead. */
+    resultSelector?: (e: MessageEvent) => T;
+    /**
+     * A serializer used to create messages from passed values before the
+     * messages are sent to the server. Defaults to JSON.stringify.
+     */
+    serializer?: (value: T) => WebSocketMessage;
+    /**
+     * A deserializer used for messages arriving on the socket from the
+     * server. Defaults to JSON.parse.
+     */
+    deserializer?: (e: MessageEvent) => T;
+    /**
+     * An Observer that watches when open events occur on the underlying web socket.
+     */
+    openObserver?: NextObserver<Event>;
+    /**
+     * An Observer that watches when close events occur on the underlying web socket
+     */
+    closeObserver?: NextObserver<CloseEvent>;
+    /**
+     * An Observer that watches when a close is about to occur due to
+     * unsubscription.
+     */
+    closingObserver?: NextObserver<void>;
+    /**
+     * A WebSocket constructor to use. This is useful for situations like using a
+     * WebSocket impl in Node (WebSocket is a DOM API), or for mocking a WebSocket
+     * for testing purposes
+     */
+    WebSocketCtor?: {
+        new (url: string, protocols?: string | string[]): WebSocket;
+    };
+    /** Sets the `binaryType` property of the underlying WebSocket. */
+    binaryType?: 'blob' | 'arraybuffer';
+}
+export declare type WebSocketMessage = string | ArrayBuffer | Blob | ArrayBufferView;
+export declare class WebSocketSubject<T> extends AnonymousSubject<T> {
+    private _config;
+    private _socket;
+    constructor(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>);
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    lift<R>(operator: Operator<T, R>): WebSocketSubject<R>;
+    private _resetState;
+    /**
+     * Creates an {@link Observable}, that when subscribed to, sends a message,
+     * defined by the `subMsg` function, to the server over the socket to begin a
+     * subscription to data over that socket. Once data arrives, the
+     * `messageFilter` argument will be used to select the appropriate data for
+     * the resulting Observable. When finalization occurs, either due to
+     * unsubscription, completion, or error, a message defined by the `unsubMsg`
+     * argument will be sent to the server over the WebSocketSubject.
+     *
+     * @param subMsg A function to generate the subscription message to be sent to
+     * the server. This will still be processed by the serializer in the
+     * WebSocketSubject's config. (Which defaults to JSON serialization)
+     * @param unsubMsg A function to generate the unsubscription message to be
+     * sent to the server at finalization. This will still be processed by the
+     * serializer in the WebSocketSubject's config.
+     * @param messageFilter A predicate for selecting the appropriate messages
+     * from the server for the output stream.
+     */
+    multiplex(subMsg: () => any, unsubMsg: () => any, messageFilter: (value: T) => boolean): Observable<T>;
+    private _connectSocket;
+    unsubscribe(): void;
+}
+//# sourceMappingURL=WebSocketSubject.d.ts.map