diff options
Diffstat (limited to 'node_modules/rxjs/src/internal/observable')
34 files changed, 0 insertions, 4595 deletions
diff --git a/node_modules/rxjs/src/internal/observable/ConnectableObservable.ts b/node_modules/rxjs/src/internal/observable/ConnectableObservable.ts deleted file mode 100644 index bd1c76f..0000000 --- a/node_modules/rxjs/src/internal/observable/ConnectableObservable.ts +++ /dev/null @@ -1,104 +0,0 @@ -import { Subject } from '../Subject'; -import { Observable } from '../Observable'; -import { Subscriber } from '../Subscriber'; -import { Subscription } from '../Subscription'; -import { refCount as higherOrderRefCount } from '../operators/refCount'; -import { createOperatorSubscriber } from '../operators/OperatorSubscriber'; -import { hasLift } from '../util/lift'; - -/** - * @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 class ConnectableObservable<T> extends Observable<T> { - protected _subject: Subject<T> | null = null; - protected _refCount: number = 0; - protected _connection: Subscription | null = 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(public source: Observable<T>, protected subjectFactory: () => Subject<T>) { - super(); - // If we have lift, monkey patch that here. This is done so custom observable - // types will compose through multicast. Otherwise the resulting observable would - // simply be an instance of `ConnectableObservable`. - if (hasLift(source)) { - this.lift = source.lift; - } - } - - /** @internal */ - protected _subscribe(subscriber: Subscriber<T>) { - return this.getSubject().subscribe(subscriber); - } - - protected getSubject(): Subject<T> { - const subject = this._subject; - if (!subject || subject.isStopped) { - this._subject = this.subjectFactory(); - } - return this._subject!; - } - - protected _teardown() { - this._refCount = 0; - const { _connection } = this; - this._subject = this._connection = null; - _connection?.unsubscribe(); - } - - /** - * @deprecated {@link ConnectableObservable} will be removed in v8. Use {@link connectable} instead. - * Details: https://rxjs.dev/deprecations/multicasting - */ - connect(): Subscription { - let connection = this._connection; - if (!connection) { - connection = this._connection = new Subscription(); - const subject = this.getSubject(); - connection.add( - this.source.subscribe( - createOperatorSubscriber( - subject as any, - undefined, - () => { - this._teardown(); - subject.complete(); - }, - (err) => { - this._teardown(); - subject.error(err); - }, - () => this._teardown() - ) - ) - ); - - if (connection.closed) { - this._connection = null; - connection = Subscription.EMPTY; - } - } - return connection; - } - - /** - * @deprecated {@link ConnectableObservable} will be removed in v8. Use the {@link share} operator instead. - * Details: https://rxjs.dev/deprecations/multicasting - */ - refCount(): Observable<T> { - return higherOrderRefCount()(this) as Observable<T>; - } -} diff --git a/node_modules/rxjs/src/internal/observable/bindCallback.ts b/node_modules/rxjs/src/internal/observable/bindCallback.ts deleted file mode 100644 index a4bd574..0000000 --- a/node_modules/rxjs/src/internal/observable/bindCallback.ts +++ /dev/null @@ -1,149 +0,0 @@ -/* @prettier */ -import { SchedulerLike } from '../types'; -import { Observable } from '../Observable'; -import { bindCallbackInternals } from './bindCallbackInternals'; - -export function bindCallback( - callbackFunc: (...args: any[]) => void, - resultSelector: (...args: any[]) => any, - scheduler?: SchedulerLike -): (...args: any[]) => Observable<any>; - -// args is the arguments array and we push the callback on the rest tuple since the rest parameter must be last (only item) in a parameter list -export 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>; - -/** - * Converts a callback API to a function that returns an Observable. - * - * <span class="informal">Give it a function `f` of type `f(x, callback)` and - * it will return a function `g` that when called as `g(x)` will output an - * Observable.</span> - * - * `bindCallback` is not an operator because its input and output are not - * Observables. The input is a function `func` with some parameters. The - * last parameter must be a callback function that `func` calls when it is - * done. - * - * The output of `bindCallback` is a function that takes the same parameters - * as `func`, except the last one (the callback). When the output function - * is called with arguments it will return an Observable. If function `func` - * calls its callback with one argument, the Observable will emit that value. - * If on the other hand the callback is called with multiple values the resulting - * Observable will emit an array with said values as arguments. - * - * It is **very important** to remember that input function `func` is not called - * when the output function is, but rather when the Observable returned by the output - * function is subscribed. This means if `func` makes an AJAX request, that request - * will be made every time someone subscribes to the resulting Observable, but not before. - * - * The last optional parameter - `scheduler` - can be used to control when the call - * to `func` happens after someone subscribes to Observable, as well as when results - * passed to callback will be emitted. By default, the subscription to an Observable calls `func` - * synchronously, but using {@link asyncScheduler} as the last parameter will defer the call to `func`, - * just like wrapping the call in `setTimeout` with a timeout of `0` would. If you were to use the async Scheduler - * and call `subscribe` on the output Observable, all function calls that are currently executing - * will end before `func` is invoked. - * - * By default, results passed to the callback are emitted immediately after `func` invokes the callback. - * In particular, if the callback is called synchronously, then the subscription of the resulting Observable - * will call the `next` function synchronously as well. If you want to defer that call, - * you may use {@link asyncScheduler} just as before. This means that by using `Scheduler.async` you can - * ensure that `func` always calls its callback asynchronously, thus avoiding terrifying Zalgo. - * - * Note that the Observable created by the output function will always emit a single value - * and then complete immediately. If `func` calls the callback multiple times, values from subsequent - * calls will not appear in the stream. If you need to listen for multiple calls, - * you probably want to use {@link fromEvent} or {@link fromEventPattern} instead. - * - * If `func` depends on some context (`this` property) and is not already bound, the context of `func` - * will be the context that the output function has at call time. In particular, if `func` - * is called as a method of some object and if `func` is not already bound, in order to preserve the context - * it is recommended that the context of the output function is set to that object as well. - * - * If the input function calls its callback in the "node style" (i.e. first argument to callback is - * optional error parameter signaling whether the call failed or not), {@link bindNodeCallback} - * provides convenient error handling and probably is a better choice. - * `bindCallback` will treat such functions the same as any other and error parameters - * (whether passed or not) will always be interpreted as regular callback argument. - * - * ## Examples - * - * Convert jQuery's getJSON to an Observable API - * - * ```ts - * import { bindCallback } from 'rxjs'; - * import * as jQuery from 'jquery'; - * - * // Suppose we have jQuery.getJSON('/my/url', callback) - * const getJSONAsObservable = bindCallback(jQuery.getJSON); - * const result = getJSONAsObservable('/my/url'); - * result.subscribe(x => console.log(x), e => console.error(e)); - * ``` - * - * Receive an array of arguments passed to a callback - * - * ```ts - * import { bindCallback } from 'rxjs'; - * - * const someFunction = (n, s, cb) => { - * cb(n, s, { someProperty: 'someValue' }); - * }; - * - * const boundSomeFunction = bindCallback(someFunction); - * boundSomeFunction(5, 'some string').subscribe((values) => { - * console.log(values); // [5, 'some string', {someProperty: 'someValue'}] - * }); - * ``` - * - * Compare behaviour with and without `asyncScheduler` - * - * ```ts - * import { bindCallback, asyncScheduler } from 'rxjs'; - * - * function iCallMyCallbackSynchronously(cb) { - * cb(); - * } - * - * const boundSyncFn = bindCallback(iCallMyCallbackSynchronously); - * const boundAsyncFn = bindCallback(iCallMyCallbackSynchronously, null, asyncScheduler); - * - * boundSyncFn().subscribe(() => console.log('I was sync!')); - * boundAsyncFn().subscribe(() => console.log('I was async!')); - * console.log('This happened...'); - * - * // Logs: - * // I was sync! - * // This happened... - * // I was async! - * ``` - * - * Use `bindCallback` on an object method - * - * ```ts - * import { bindCallback } from 'rxjs'; - * - * const boundMethod = bindCallback(someObject.methodWithCallback); - * boundMethod - * .call(someObject) // make sure methodWithCallback has access to someObject - * .subscribe(subscriber); - * ``` - * - * @see {@link bindNodeCallback} - * @see {@link from} - * - * @param callbackFunc A function with a callback as the last parameter. - * @param resultSelector A mapping function used to transform callback events. - * @param scheduler The scheduler on which to schedule the callbacks. - * @return A function which returns the Observable that delivers the same - * values the callback would deliver. - */ -export function bindCallback( - callbackFunc: (...args: [...any[], (...res: any) => void]) => void, - resultSelector?: ((...args: any[]) => any) | SchedulerLike, - scheduler?: SchedulerLike -): (...args: any[]) => Observable<unknown> { - return bindCallbackInternals(false, callbackFunc, resultSelector, scheduler); -} diff --git a/node_modules/rxjs/src/internal/observable/bindCallbackInternals.ts b/node_modules/rxjs/src/internal/observable/bindCallbackInternals.ts deleted file mode 100644 index e614044..0000000 --- a/node_modules/rxjs/src/internal/observable/bindCallbackInternals.ts +++ /dev/null @@ -1,119 +0,0 @@ -import { SchedulerLike } from '../types'; -import { isScheduler } from '../util/isScheduler'; -import { Observable } from '../Observable'; -import { subscribeOn } from '../operators/subscribeOn'; -import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs'; -import { observeOn } from '../operators/observeOn'; -import { AsyncSubject } from '../AsyncSubject'; - -export function bindCallbackInternals( - isNodeStyle: boolean, - callbackFunc: any, - resultSelector?: any, - scheduler?: SchedulerLike -): (...args: any[]) => Observable<unknown> { - if (resultSelector) { - if (isScheduler(resultSelector)) { - scheduler = resultSelector; - } else { - // The user provided a result selector. - return function (this: any, ...args: any[]) { - return (bindCallbackInternals(isNodeStyle, callbackFunc, scheduler) as any) - .apply(this, args) - .pipe(mapOneOrManyArgs(resultSelector as any)); - }; - } - } - - // If a scheduler was passed, use our `subscribeOn` and `observeOn` operators - // to compose that behavior for the user. - if (scheduler) { - return function (this: any, ...args: any[]) { - return (bindCallbackInternals(isNodeStyle, callbackFunc) as any) - .apply(this, args) - .pipe(subscribeOn(scheduler!), observeOn(scheduler!)); - }; - } - - return function (this: any, ...args: any[]): Observable<any> { - // We're using AsyncSubject, because it emits when it completes, - // and it will play the value to all late-arriving subscribers. - const subject = new AsyncSubject<any>(); - - // If this is true, then we haven't called our function yet. - let uninitialized = true; - return new Observable((subscriber) => { - // Add our subscriber to the subject. - const subs = subject.subscribe(subscriber); - - if (uninitialized) { - uninitialized = false; - // We're going to execute the bound function - // This bit is to signal that we are hitting the callback asynchronously. - // Because we don't have any anti-"Zalgo" guarantees with whatever - // function we are handed, we use this bit to figure out whether or not - // we are getting hit in a callback synchronously during our call. - let isAsync = false; - - // This is used to signal that the callback completed synchronously. - let isComplete = false; - - // Call our function that has a callback. If at any time during this - // call, an error is thrown, it will be caught by the Observable - // subscription process and sent to the consumer. - callbackFunc.apply( - // Pass the appropriate `this` context. - this, - [ - // Pass the arguments. - ...args, - // And our callback handler. - (...results: any[]) => { - if (isNodeStyle) { - // If this is a node callback, shift the first value off of the - // results and check it, as it is the error argument. By shifting, - // we leave only the argument(s) we want to pass to the consumer. - const err = results.shift(); - if (err != null) { - subject.error(err); - // If we've errored, we can stop processing this function - // as there's nothing else to do. Just return to escape. - return; - } - } - // If we have one argument, notify the consumer - // of it as a single value, otherwise, if there's more than one, pass - // them as an array. Note that if there are no arguments, `undefined` - // will be emitted. - subject.next(1 < results.length ? results : results[0]); - // Flip this flag, so we know we can complete it in the synchronous - // case below. - isComplete = true; - // If we're not asynchronous, we need to defer the `complete` call - // until after the call to the function is over. This is because an - // error could be thrown in the function after it calls our callback, - // and if that is the case, if we complete here, we are unable to notify - // the consumer than an error occurred. - if (isAsync) { - subject.complete(); - } - }, - ] - ); - // If we flipped `isComplete` during the call, we resolved synchronously, - // notify complete, because we skipped it in the callback to wait - // to make sure there were no errors during the call. - if (isComplete) { - subject.complete(); - } - - // We're no longer synchronous. If the callback is called at this point - // we can notify complete on the spot. - isAsync = true; - } - - // Return the subscription from adding our subscriber to the subject. - return subs; - }); - }; -} diff --git a/node_modules/rxjs/src/internal/observable/bindNodeCallback.ts b/node_modules/rxjs/src/internal/observable/bindNodeCallback.ts deleted file mode 100644 index 8d83722..0000000 --- a/node_modules/rxjs/src/internal/observable/bindNodeCallback.ts +++ /dev/null @@ -1,131 +0,0 @@ -/* @prettier */ -import { Observable } from '../Observable'; -import { SchedulerLike } from '../types'; -import { bindCallbackInternals } from './bindCallbackInternals'; - -export function bindNodeCallback( - callbackFunc: (...args: any[]) => void, - resultSelector: (...args: any[]) => any, - scheduler?: SchedulerLike -): (...args: any[]) => Observable<any>; - -// args is the arguments array and we push the callback on the rest tuple since the rest parameter must be last (only item) in a parameter list -export 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>; - -/** - * Converts a Node.js-style callback API to a function that returns an - * Observable. - * - * <span class="informal">It's just like {@link bindCallback}, but the - * callback is expected to be of type `callback(error, result)`.</span> - * - * `bindNodeCallback` is not an operator because its input and output are not - * Observables. The input is a function `func` with some parameters, but the - * last parameter must be a callback function that `func` calls when it is - * done. The callback function is expected to follow Node.js conventions, - * where the first argument to the callback is an error object, signaling - * whether call was successful. If that object is passed to callback, it means - * something went wrong. - * - * The output of `bindNodeCallback` is a function that takes the same - * parameters as `func`, except the last one (the callback). When the output - * function is called with arguments, it will return an Observable. - * If `func` calls its callback with error parameter present, Observable will - * error with that value as well. If error parameter is not passed, Observable will emit - * second parameter. If there are more parameters (third and so on), - * Observable will emit an array with all arguments, except first error argument. - * - * Note that `func` will not be called at the same time output function is, - * but rather whenever resulting Observable is subscribed. By default call to - * `func` will happen synchronously after subscription, but that can be changed - * with proper `scheduler` provided as optional third parameter. {@link SchedulerLike} - * can also control when values from callback will be emitted by Observable. - * To find out more, check out documentation for {@link bindCallback}, where - * {@link SchedulerLike} works exactly the same. - * - * As in {@link bindCallback}, context (`this` property) of input function will be set to context - * of returned function, when it is called. - * - * After Observable emits value, it will complete immediately. This means - * even if `func` calls callback again, values from second and consecutive - * calls will never appear on the stream. If you need to handle functions - * that call callbacks multiple times, check out {@link fromEvent} or - * {@link fromEventPattern} instead. - * - * Note that `bindNodeCallback` can be used in non-Node.js environments as well. - * "Node.js-style" callbacks are just a convention, so if you write for - * browsers or any other environment and API you use implements that callback style, - * `bindNodeCallback` can be safely used on that API functions as well. - * - * Remember that Error object passed to callback does not have to be an instance - * of JavaScript built-in `Error` object. In fact, it does not even have to an object. - * Error parameter of callback function is interpreted as "present", when value - * of that parameter is truthy. It could be, for example, non-zero number, non-empty - * string or boolean `true`. In all of these cases resulting Observable would error - * with that value. This means usually regular style callbacks will fail very often when - * `bindNodeCallback` is used. If your Observable errors much more often then you - * would expect, check if callback really is called in Node.js-style and, if not, - * switch to {@link bindCallback} instead. - * - * Note that even if error parameter is technically present in callback, but its value - * is falsy, it still won't appear in array emitted by Observable. - * - * ## Examples - * - * Read a file from the filesystem and get the data as an Observable - * - * ```ts - * import * as fs from 'fs'; - * const readFileAsObservable = bindNodeCallback(fs.readFile); - * const result = readFileAsObservable('./roadNames.txt', 'utf8'); - * result.subscribe(x => console.log(x), e => console.error(e)); - * ``` - * - * Use on function calling callback with multiple arguments - * - * ```ts - * someFunction((err, a, b) => { - * console.log(err); // null - * console.log(a); // 5 - * console.log(b); // "some string" - * }); - * const boundSomeFunction = bindNodeCallback(someFunction); - * boundSomeFunction() - * .subscribe(value => { - * console.log(value); // [5, "some string"] - * }); - * ``` - * - * Use on function calling callback in regular style - * - * ```ts - * someFunction(a => { - * console.log(a); // 5 - * }); - * const boundSomeFunction = bindNodeCallback(someFunction); - * boundSomeFunction() - * .subscribe( - * value => {} // never gets called - * err => console.log(err) // 5 - * ); - * ``` - * - * @see {@link bindCallback} - * @see {@link from} - * - * @param callbackFunc Function with a Node.js-style callback as the last parameter. - * @param resultSelector A mapping function used to transform callback events. - * @param scheduler The scheduler on which to schedule the callbacks. - * @return A function which returns the Observable that delivers the same values the - * Node.js callback would deliver. - */ -export function bindNodeCallback( - callbackFunc: (...args: [...any[], (err: any, ...res: any) => void]) => void, - resultSelector?: ((...args: any[]) => any) | SchedulerLike, - scheduler?: SchedulerLike -): (...args: any[]) => Observable<any> { - return bindCallbackInternals(true, callbackFunc, resultSelector, scheduler); -} diff --git a/node_modules/rxjs/src/internal/observable/combineLatest.ts b/node_modules/rxjs/src/internal/observable/combineLatest.ts deleted file mode 100644 index 9044060..0000000 --- a/node_modules/rxjs/src/internal/observable/combineLatest.ts +++ /dev/null @@ -1,300 +0,0 @@ -import { Observable } from '../Observable'; -import { ObservableInput, SchedulerLike, ObservedValueOf, ObservableInputTuple } from '../types'; -import { argsArgArrayOrObject } from '../util/argsArgArrayOrObject'; -import { Subscriber } from '../Subscriber'; -import { from } from './from'; -import { identity } from '../util/identity'; -import { Subscription } from '../Subscription'; -import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs'; -import { popResultSelector, popScheduler } from '../util/args'; -import { createObject } from '../util/createObject'; -import { createOperatorSubscriber } from '../operators/OperatorSubscriber'; -import { AnyCatcher } from '../AnyCatcher'; -import { executeSchedule } from '../util/executeSchedule'; - -// combineLatest(any) -// We put this first because we need to catch cases where the user has supplied -// _exactly `any`_ as the argument. Since `any` literally matches _anything_, -// we don't want it to randomly hit one of the other type signatures below, -// as we have no idea at build-time what type we should be returning when given an any. - -/** - * 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 function combineLatest<T extends AnyCatcher>(arg: T): Observable<unknown>; - -// combineLatest([a, b, c]) -export function combineLatest(sources: []): Observable<never>; -export 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 function combineLatest<A extends readonly unknown[], R>( - sources: readonly [...ObservableInputTuple<A>], - resultSelector: (...values: A) => R, - scheduler: SchedulerLike -): Observable<R>; -export 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 function combineLatest<A extends readonly unknown[]>( - sources: readonly [...ObservableInputTuple<A>], - scheduler: SchedulerLike -): Observable<A>; - -// combineLatest(a, b, c) -/** @deprecated Pass an array of sources instead. The rest-parameters signature will be removed in v8. Details: https://rxjs.dev/deprecations/array-argument */ -export 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 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 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 function combineLatest<A extends readonly unknown[]>( - ...sourcesAndScheduler: [...ObservableInputTuple<A>, SchedulerLike] -): Observable<A>; - -// combineLatest({a, b, c}) -export function combineLatest(sourcesObject: { [K in any]: never }): Observable<never>; -export function combineLatest<T extends Record<string, ObservableInput<any>>>( - sourcesObject: T -): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>; - -/** - * Combines multiple Observables to create an Observable whose values are - * calculated from the latest values of each of its input Observables. - * - * <span class="informal">Whenever any input Observable emits a value, it - * computes a formula using the latest values from all the inputs, then emits - * the output of that formula.</span> - * - *  - * - * `combineLatest` combines the values from all the Observables passed in the - * observables array. This is done by subscribing to each Observable in order and, - * whenever any Observable emits, collecting an array of the most recent - * values from each Observable. So if you pass `n` Observables to this operator, - * the returned Observable will always emit an array of `n` values, in an order - * corresponding to the order of the passed Observables (the value from the first Observable - * will be at index 0 of the array and so on). - * - * Static version of `combineLatest` accepts an array of Observables. Note that an array of - * Observables is a good choice, if you don't know beforehand how many Observables - * you will combine. Passing an empty array will result in an Observable that - * completes immediately. - * - * To ensure the output array always has the same length, `combineLatest` will - * actually wait for all input Observables to emit at least once, - * before it starts emitting results. This means if some Observable emits - * values before other Observables started emitting, all these values but the last - * will be lost. On the other hand, if some Observable does not emit a value but - * completes, resulting Observable will complete at the same moment without - * emitting anything, since it will now be impossible to include a value from the - * completed Observable in the resulting array. Also, if some input Observable does - * not emit any value and never completes, `combineLatest` will also never emit - * and never complete, since, again, it will wait for all streams to emit some - * value. - * - * If at least one Observable was passed to `combineLatest` and all passed Observables - * emitted something, the resulting Observable will complete when all combined - * streams complete. So even if some Observable completes, the result of - * `combineLatest` will still emit values when other Observables do. In case - * of a completed Observable, its value from now on will always be the last - * emitted value. On the other hand, if any Observable errors, `combineLatest` - * will error immediately as well, and all other Observables will be unsubscribed. - * - * ## Examples - * - * Combine two timer Observables - * - * ```ts - * import { timer, combineLatest } from 'rxjs'; - * - * const firstTimer = timer(0, 1000); // emit 0, 1, 2... after every second, starting from now - * const secondTimer = timer(500, 1000); // emit 0, 1, 2... after every second, starting 0,5s from now - * const combinedTimers = combineLatest([firstTimer, secondTimer]); - * combinedTimers.subscribe(value => console.log(value)); - * // Logs - * // [0, 0] after 0.5s - * // [1, 0] after 1s - * // [1, 1] after 1.5s - * // [2, 1] after 2s - * ``` - * - * Combine a dictionary of Observables - * - * ```ts - * import { of, delay, startWith, combineLatest } from 'rxjs'; - * - * const observables = { - * a: of(1).pipe(delay(1000), startWith(0)), - * b: of(5).pipe(delay(5000), startWith(0)), - * c: of(10).pipe(delay(10000), startWith(0)) - * }; - * const combined = combineLatest(observables); - * combined.subscribe(value => console.log(value)); - * // Logs - * // { a: 0, b: 0, c: 0 } immediately - * // { a: 1, b: 0, c: 0 } after 1s - * // { a: 1, b: 5, c: 0 } after 5s - * // { a: 1, b: 5, c: 10 } after 10s - * ``` - * - * Combine an array of Observables - * - * ```ts - * import { of, delay, startWith, combineLatest } from 'rxjs'; - * - * const observables = [1, 5, 10].map( - * n => of(n).pipe( - * delay(n * 1000), // emit 0 and then emit n after n seconds - * startWith(0) - * ) - * ); - * const combined = combineLatest(observables); - * combined.subscribe(value => console.log(value)); - * // Logs - * // [0, 0, 0] immediately - * // [1, 0, 0] after 1s - * // [1, 5, 0] after 5s - * // [1, 5, 10] after 10s - * ``` - * - * Use map operator to dynamically calculate the Body-Mass Index - * - * ```ts - * import { of, combineLatest, map } from 'rxjs'; - * - * const weight = of(70, 72, 76, 79, 75); - * const height = of(1.76, 1.77, 1.78); - * const bmi = combineLatest([weight, height]).pipe( - * map(([w, h]) => w / (h * h)), - * ); - * bmi.subscribe(x => console.log('BMI is ' + x)); - * - * // With output to console: - * // BMI is 24.212293388429753 - * // BMI is 23.93948099205209 - * // BMI is 23.671253629592222 - * ``` - * - * @see {@link combineLatestAll} - * @see {@link merge} - * @see {@link withLatestFrom} - * - * @param args Any number of `ObservableInput`s provided either as an array or as an object - * to combine with each other. If the last parameter is the function, it will be used to project the - * values from the combined latest values into a new value on the output Observable. - * @return An Observable of projected values from the most recent values from each `ObservableInput`, - * or an array of the most recent values from each `ObservableInput`. - */ -export function combineLatest<O extends ObservableInput<any>, R>(...args: any[]): Observable<R> | Observable<ObservedValueOf<O>[]> { - const scheduler = popScheduler(args); - const resultSelector = popResultSelector(args); - - const { args: observables, keys } = argsArgArrayOrObject(args); - - if (observables.length === 0) { - // If no observables are passed, or someone has passed an empty array - // of observables, or even an empty object POJO, we need to just - // complete (EMPTY), but we have to honor the scheduler provided if any. - return from([], scheduler as any); - } - - const result = new Observable<ObservedValueOf<O>[]>( - combineLatestInit( - observables as ObservableInput<ObservedValueOf<O>>[], - scheduler, - keys - ? // A handler for scrubbing the array of args into a dictionary. - (values) => createObject(keys, values) - : // A passthrough to just return the array - identity - ) - ); - - return resultSelector ? (result.pipe(mapOneOrManyArgs(resultSelector)) as Observable<R>) : result; -} - -export function combineLatestInit( - observables: ObservableInput<any>[], - scheduler?: SchedulerLike, - valueTransform: (values: any[]) => any = identity -) { - return (subscriber: Subscriber<any>) => { - // The outer subscription. We're capturing this in a function - // because we may have to schedule it. - maybeSchedule( - scheduler, - () => { - const { length } = observables; - // A store for the values each observable has emitted so far. We match observable to value on index. - const values = new Array(length); - // The number of currently active subscriptions, as they complete, we decrement this number to see if - // we are all done combining values, so we can complete the result. - let active = length; - // The number of inner sources that still haven't emitted the first value - // We need to track this because all sources need to emit one value in order - // to start emitting values. - let remainingFirstValues = length; - // The loop to kick off subscription. We're keying everything on index `i` to relate the observables passed - // in to the slot in the output array or the key in the array of keys in the output dictionary. - for (let i = 0; i < length; i++) { - maybeSchedule( - scheduler, - () => { - const source = from(observables[i], scheduler as any); - let hasFirstValue = false; - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - // When we get a value, record it in our set of values. - values[i] = value; - if (!hasFirstValue) { - // If this is our first value, record that. - hasFirstValue = true; - remainingFirstValues--; - } - if (!remainingFirstValues) { - // We're not waiting for any more - // first values, so we can emit! - subscriber.next(valueTransform(values.slice())); - } - }, - () => { - if (!--active) { - // We only complete the result if we have no more active - // inner observables. - subscriber.complete(); - } - } - ) - ); - }, - subscriber - ); - } - }, - subscriber - ); - }; -} - -/** - * A small utility to handle the couple of locations where we want to schedule if a scheduler was provided, - * but we don't if there was no scheduler. - */ -function maybeSchedule(scheduler: SchedulerLike | undefined, execute: () => void, subscription: Subscription) { - if (scheduler) { - executeSchedule(subscription, scheduler, execute); - } else { - execute(); - } -} diff --git a/node_modules/rxjs/src/internal/observable/concat.ts b/node_modules/rxjs/src/internal/observable/concat.ts deleted file mode 100644 index edbaa31..0000000 --- a/node_modules/rxjs/src/internal/observable/concat.ts +++ /dev/null @@ -1,115 +0,0 @@ -import { Observable } from '../Observable'; -import { ObservableInputTuple, SchedulerLike } from '../types'; -import { concatAll } from '../operators/concatAll'; -import { popScheduler } from '../util/args'; -import { from } from './from'; - -export function concat<T extends readonly unknown[]>(...inputs: [...ObservableInputTuple<T>]): Observable<T[number]>; -export function concat<T extends readonly unknown[]>( - ...inputsAndScheduler: [...ObservableInputTuple<T>, SchedulerLike] -): Observable<T[number]>; - -/** - * Creates an output Observable which sequentially emits all values from the first given - * Observable and then moves on to the next. - * - * <span class="informal">Concatenates multiple Observables together by - * sequentially emitting their values, one Observable after the other.</span> - * - *  - * - * `concat` joins multiple Observables together, by subscribing to them one at a time and - * merging their results into the output Observable. You can pass either an array of - * Observables, or put them directly as arguments. Passing an empty array will result - * in Observable that completes immediately. - * - * `concat` will subscribe to first input Observable and emit all its values, without - * changing or affecting them in any way. When that Observable completes, it will - * subscribe to then next Observable passed and, again, emit its values. This will be - * repeated, until the operator runs out of Observables. When last input Observable completes, - * `concat` will complete as well. At any given moment only one Observable passed to operator - * emits values. If you would like to emit values from passed Observables concurrently, check out - * {@link merge} instead, especially with optional `concurrent` parameter. As a matter of fact, - * `concat` is an equivalent of `merge` operator with `concurrent` parameter set to `1`. - * - * Note that if some input Observable never completes, `concat` will also never complete - * and Observables following the one that did not complete will never be subscribed. On the other - * hand, if some Observable simply completes immediately after it is subscribed, it will be - * invisible for `concat`, which will just move on to the next Observable. - * - * If any Observable in chain errors, instead of passing control to the next Observable, - * `concat` will error immediately as well. Observables that would be subscribed after - * the one that emitted error, never will. - * - * If you pass to `concat` the same Observable many times, its stream of values - * will be "replayed" on every subscription, which means you can repeat given Observable - * as many times as you like. If passing the same Observable to `concat` 1000 times becomes tedious, - * you can always use {@link repeat}. - * - * ## Examples - * - * Concatenate a timer counting from 0 to 3 with a synchronous sequence from 1 to 10 - * - * ```ts - * import { interval, take, range, concat } from 'rxjs'; - * - * const timer = interval(1000).pipe(take(4)); - * const sequence = range(1, 10); - * const result = concat(timer, sequence); - * result.subscribe(x => console.log(x)); - * - * // results in: - * // 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 -immediate-> 1 ... 10 - * ``` - * - * Concatenate 3 Observables - * - * ```ts - * import { interval, take, concat } from 'rxjs'; - * - * const timer1 = interval(1000).pipe(take(10)); - * const timer2 = interval(2000).pipe(take(6)); - * const timer3 = interval(500).pipe(take(10)); - * - * const result = concat(timer1, timer2, timer3); - * result.subscribe(x => console.log(x)); - * - * // results in the following: - * // (Prints to console sequentially) - * // -1000ms-> 0 -1000ms-> 1 -1000ms-> ... 9 - * // -2000ms-> 0 -2000ms-> 1 -2000ms-> ... 5 - * // -500ms-> 0 -500ms-> 1 -500ms-> ... 9 - * ``` - * - * Concatenate the same Observable to repeat it - * - * ```ts - * import { interval, take, concat } from 'rxjs'; - * - * const timer = interval(1000).pipe(take(2)); - * - * concat(timer, timer) // concatenating the same Observable! - * .subscribe({ - * next: value => console.log(value), - * complete: () => console.log('...and it is done!') - * }); - * - * // Logs: - * // 0 after 1s - * // 1 after 2s - * // 0 after 3s - * // 1 after 4s - * // '...and it is done!' also after 4s - * ``` - * - * @see {@link concatAll} - * @see {@link concatMap} - * @see {@link concatMapTo} - * @see {@link startWith} - * @see {@link endWith} - * - * @param args `ObservableInput`s to concatenate. - */ -export function concat(...args: any[]): Observable<unknown> { - return concatAll()(from(args, popScheduler(args))); -} diff --git a/node_modules/rxjs/src/internal/observable/connectable.ts b/node_modules/rxjs/src/internal/observable/connectable.ts deleted file mode 100644 index 4609118..0000000 --- a/node_modules/rxjs/src/internal/observable/connectable.ts +++ /dev/null @@ -1,64 +0,0 @@ -import { Connectable, ObservableInput, SubjectLike } from '../types'; -import { Subject } from '../Subject'; -import { Subscription } from '../Subscription'; -import { Observable } from '../Observable'; -import { defer } from './defer'; - -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; -} - -/** - * The default configuration for `connectable`. - */ -const DEFAULT_CONFIG: ConnectableConfig<unknown> = { - connector: () => new Subject<unknown>(), - resetOnDisconnect: true, -}; - -/** - * 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 function connectable<T>(source: ObservableInput<T>, config: ConnectableConfig<T> = DEFAULT_CONFIG): Connectable<T> { - // The subscription representing the connection. - let connection: Subscription | null = null; - const { connector, resetOnDisconnect = true } = config; - let subject = connector(); - - const result: any = new Observable<T>((subscriber) => { - return subject.subscribe(subscriber); - }); - - // Define the `connect` function. This is what users must call - // in order to "connect" the source to the subject that is - // multicasting it. - result.connect = () => { - if (!connection || connection.closed) { - connection = defer(() => source).subscribe(subject); - if (resetOnDisconnect) { - connection.add(() => (subject = connector())); - } - } - return connection; - }; - - return result; -} diff --git a/node_modules/rxjs/src/internal/observable/defer.ts b/node_modules/rxjs/src/internal/observable/defer.ts deleted file mode 100644 index 2bd3db9..0000000 --- a/node_modules/rxjs/src/internal/observable/defer.ts +++ /dev/null @@ -1,56 +0,0 @@ -import { Observable } from '../Observable'; -import { ObservedValueOf, ObservableInput } from '../types'; -import { innerFrom } from './innerFrom'; - -/** - * 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` 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 'rxjs'; - * - * 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 function defer<R extends ObservableInput<any>>(observableFactory: () => R): Observable<ObservedValueOf<R>> { - return new Observable<ObservedValueOf<R>>((subscriber) => { - innerFrom(observableFactory()).subscribe(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/observable/dom/WebSocketSubject.ts b/node_modules/rxjs/src/internal/observable/dom/WebSocketSubject.ts deleted file mode 100644 index 9eecbf5..0000000 --- a/node_modules/rxjs/src/internal/observable/dom/WebSocketSubject.ts +++ /dev/null @@ -1,397 +0,0 @@ -import { Subject, AnonymousSubject } from '../../Subject'; -import { Subscriber } from '../../Subscriber'; -import { Observable } from '../../Observable'; -import { Subscription } from '../../Subscription'; -import { Operator } from '../../Operator'; -import { ReplaySubject } from '../../ReplaySubject'; -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'; -} - -const DEFAULT_WEBSOCKET_CONFIG: WebSocketSubjectConfig<any> = { - url: '', - deserializer: (e: MessageEvent) => JSON.parse(e.data), - serializer: (value: any) => JSON.stringify(value), -}; - -const WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT = - 'WebSocketSubject.error must be called with an object with an error code, and an optional reason: { code: number, reason: string }'; - -export type WebSocketMessage = string | ArrayBuffer | Blob | ArrayBufferView; - -export class WebSocketSubject<T> extends AnonymousSubject<T> { - // @ts-ignore: Property has no initializer and is not definitely assigned - private _config: WebSocketSubjectConfig<T>; - - /** @internal */ - // @ts-ignore: Property has no initializer and is not definitely assigned - _output: Subject<T>; - - private _socket: WebSocket | null = null; - - constructor(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>) { - super(); - if (urlConfigOrSource instanceof Observable) { - this.destination = destination; - this.source = urlConfigOrSource as Observable<T>; - } else { - const config = (this._config = { ...DEFAULT_WEBSOCKET_CONFIG }); - this._output = new Subject<T>(); - if (typeof urlConfigOrSource === 'string') { - config.url = urlConfigOrSource; - } else { - for (const key in urlConfigOrSource) { - if (urlConfigOrSource.hasOwnProperty(key)) { - (config as any)[key] = (urlConfigOrSource as any)[key]; - } - } - } - - if (!config.WebSocketCtor && WebSocket) { - config.WebSocketCtor = WebSocket; - } else if (!config.WebSocketCtor) { - throw new Error('no WebSocket constructor can be found'); - } - this.destination = new ReplaySubject(); - } - } - - /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */ - lift<R>(operator: Operator<T, R>): WebSocketSubject<R> { - const sock = new WebSocketSubject<R>(this._config as WebSocketSubjectConfig<any>, this.destination as any); - sock.operator = operator; - sock.source = this; - return sock; - } - - private _resetState() { - this._socket = null; - if (!this.source) { - this.destination = new ReplaySubject(); - } - this._output = new Subject<T>(); - } - - /** - * 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) { - const self = this; - return new Observable((observer: Observer<T>) => { - try { - self.next(subMsg()); - } catch (err) { - observer.error(err); - } - - const subscription = self.subscribe({ - next: (x) => { - try { - if (messageFilter(x)) { - observer.next(x); - } - } catch (err) { - observer.error(err); - } - }, - error: (err) => observer.error(err), - complete: () => observer.complete(), - }); - - return () => { - try { - self.next(unsubMsg()); - } catch (err) { - observer.error(err); - } - subscription.unsubscribe(); - }; - }); - } - - private _connectSocket() { - const { WebSocketCtor, protocol, url, binaryType } = this._config; - const observer = this._output; - - let socket: WebSocket | null = null; - try { - socket = protocol ? new WebSocketCtor!(url, protocol) : new WebSocketCtor!(url); - this._socket = socket; - if (binaryType) { - this._socket.binaryType = binaryType; - } - } catch (e) { - observer.error(e); - return; - } - - const subscription = new Subscription(() => { - this._socket = null; - if (socket && socket.readyState === 1) { - socket.close(); - } - }); - - socket.onopen = (evt: Event) => { - const { _socket } = this; - if (!_socket) { - socket!.close(); - this._resetState(); - return; - } - const { openObserver } = this._config; - if (openObserver) { - openObserver.next(evt); - } - - const queue = this.destination; - - this.destination = Subscriber.create<T>( - (x) => { - if (socket!.readyState === 1) { - try { - const { serializer } = this._config; - socket!.send(serializer!(x!)); - } catch (e) { - this.destination!.error(e); - } - } - }, - (err) => { - const { closingObserver } = this._config; - if (closingObserver) { - closingObserver.next(undefined); - } - if (err && err.code) { - socket!.close(err.code, err.reason); - } else { - observer.error(new TypeError(WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT)); - } - this._resetState(); - }, - () => { - const { closingObserver } = this._config; - if (closingObserver) { - closingObserver.next(undefined); - } - socket!.close(); - this._resetState(); - } - ) as Subscriber<any>; - - if (queue && queue instanceof ReplaySubject) { - subscription.add((queue as ReplaySubject<T>).subscribe(this.destination)); - } - }; - - socket.onerror = (e: Event) => { - this._resetState(); - observer.error(e); - }; - - socket.onclose = (e: CloseEvent) => { - if (socket === this._socket) { - this._resetState(); - } - const { closeObserver } = this._config; - if (closeObserver) { - closeObserver.next(e); - } - if (e.wasClean) { - observer.complete(); - } else { - observer.error(e); - } - }; - - socket.onmessage = (e: MessageEvent) => { - try { - const { deserializer } = this._config; - observer.next(deserializer!(e)); - } catch (err) { - observer.error(err); - } - }; - } - - /** @internal */ - protected _subscribe(subscriber: Subscriber<T>): Subscription { - const { source } = this; - if (source) { - return source.subscribe(subscriber); - } - if (!this._socket) { - this._connectSocket(); - } - this._output.subscribe(subscriber); - subscriber.add(() => { - const { _socket } = this; - if (this._output.observers.length === 0) { - if (_socket && (_socket.readyState === 1 || _socket.readyState === 0)) { - _socket.close(); - } - this._resetState(); - } - }); - return subscriber; - } - - unsubscribe() { - const { _socket } = this; - if (_socket && (_socket.readyState === 1 || _socket.readyState === 0)) { - _socket.close(); - } - this._resetState(); - super.unsubscribe(); - } -} diff --git a/node_modules/rxjs/src/internal/observable/dom/animationFrames.ts b/node_modules/rxjs/src/internal/observable/dom/animationFrames.ts deleted file mode 100644 index 38b338b..0000000 --- a/node_modules/rxjs/src/internal/observable/dom/animationFrames.ts +++ /dev/null @@ -1,132 +0,0 @@ -import { Observable } from '../../Observable'; -import { TimestampProvider } from '../../types'; -import { performanceTimestampProvider } from '../../scheduler/performanceTimestampProvider'; -import { animationFrameProvider } from '../../scheduler/animationFrameProvider'; - -/** - * An observable of animation frames - * - * Emits the amount of time elapsed since subscription and the timestamp on each animation frame. - * Defaults to milliseconds provided to the requestAnimationFrame's callback. Does not end on its own. - * - * Every subscription will start a separate animation loop. Since animation frames are always scheduled - * by the browser to occur directly before a repaint, scheduling more than one animation frame synchronously - * should not be much different or have more overhead than looping over an array of events during - * a single animation frame. However, if for some reason the developer would like to ensure the - * execution of animation-related handlers are all executed during the same task by the engine, - * the `share` operator can be used. - * - * This is useful for setting up animations with RxJS. - * - * ## Examples - * - * Tweening a div to move it on the screen - * - * ```ts - * import { animationFrames, map, takeWhile, endWith } from 'rxjs'; - * - * function tween(start: number, end: number, duration: number) { - * const diff = end - start; - * return animationFrames().pipe( - * // Figure out what percentage of time has passed - * map(({ elapsed }) => elapsed / duration), - * // Take the vector while less than 100% - * takeWhile(v => v < 1), - * // Finish with 100% - * endWith(1), - * // Calculate the distance traveled between start and end - * map(v => v * diff + start) - * ); - * } - * - * // Setup a div for us to move around - * const div = document.createElement('div'); - * document.body.appendChild(div); - * div.style.position = 'absolute'; - * div.style.width = '40px'; - * div.style.height = '40px'; - * div.style.backgroundColor = 'lime'; - * div.style.transform = 'translate3d(10px, 0, 0)'; - * - * tween(10, 200, 4000).subscribe(x => { - * div.style.transform = `translate3d(${ x }px, 0, 0)`; - * }); - * ``` - * - * Providing a custom timestamp provider - * - * ```ts - * import { animationFrames, TimestampProvider } from 'rxjs'; - * - * // A custom timestamp provider - * let now = 0; - * const customTSProvider: TimestampProvider = { - * now() { return now++; } - * }; - * - * const source$ = animationFrames(customTSProvider); - * - * // Log increasing numbers 0...1...2... on every animation frame. - * source$.subscribe(({ elapsed }) => console.log(elapsed)); - * ``` - * - * @param timestampProvider An object with a `now` method that provides a numeric timestamp - */ -export function animationFrames(timestampProvider?: TimestampProvider) { - return timestampProvider ? animationFramesFactory(timestampProvider) : DEFAULT_ANIMATION_FRAMES; -} - -/** - * Does the work of creating the observable for `animationFrames`. - * @param timestampProvider The timestamp provider to use to create the observable - */ -function animationFramesFactory(timestampProvider?: TimestampProvider) { - return new Observable<{ timestamp: number; elapsed: number }>((subscriber) => { - // If no timestamp provider is specified, use performance.now() - as it - // will return timestamps 'compatible' with those passed to the run - // callback and won't be affected by NTP adjustments, etc. - const provider = timestampProvider || performanceTimestampProvider; - - // Capture the start time upon subscription, as the run callback can remain - // queued for a considerable period of time and the elapsed time should - // represent the time elapsed since subscription - not the time since the - // first rendered animation frame. - const start = provider.now(); - - let id = 0; - const run = () => { - if (!subscriber.closed) { - id = animationFrameProvider.requestAnimationFrame((timestamp: DOMHighResTimeStamp | number) => { - id = 0; - // Use the provider's timestamp to calculate the elapsed time. Note that - // this means - if the caller hasn't passed a provider - that - // performance.now() will be used instead of the timestamp that was - // passed to the run callback. The reason for this is that the timestamp - // passed to the callback can be earlier than the start time, as it - // represents the time at which the browser decided it would render any - // queued frames - and that time can be earlier the captured start time. - const now = provider.now(); - subscriber.next({ - timestamp: timestampProvider ? now : timestamp, - elapsed: now - start, - }); - run(); - }); - } - }; - - run(); - - return () => { - if (id) { - animationFrameProvider.cancelAnimationFrame(id); - } - }; - }); -} - -/** - * In the common case, where the timestamp provided by the rAF API is used, - * we use this shared observable to reduce overhead. - */ -const DEFAULT_ANIMATION_FRAMES = animationFramesFactory(); diff --git a/node_modules/rxjs/src/internal/observable/dom/fetch.ts b/node_modules/rxjs/src/internal/observable/dom/fetch.ts deleted file mode 100644 index 1894d24..0000000 --- a/node_modules/rxjs/src/internal/observable/dom/fetch.ts +++ /dev/null @@ -1,180 +0,0 @@ -import { createOperatorSubscriber } from '../../operators/OperatorSubscriber'; -import { Observable } from '../../Observable'; -import { innerFrom } from '../../observable/innerFrom'; -import { ObservableInput } from '../../types'; - -export function fromFetch<T>( - input: string | Request, - init: RequestInit & { - selector: (response: Response) => ObservableInput<T>; - } -): Observable<T>; - -export function fromFetch(input: string | Request, init?: RequestInit): Observable<Response>; - -/** - * Uses [the Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) to - * make an HTTP request. - * - * **WARNING** Parts of the fetch API are still experimental. `AbortController` is - * required for this implementation to work and use cancellation appropriately. - * - * Will automatically set up an internal [AbortController](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) - * in order to finalize the internal `fetch` when the subscription tears down. - * - * If a `signal` is provided via the `init` argument, it will behave like it usually does with - * `fetch`. If the provided `signal` aborts, the error that `fetch` normally rejects with - * in that scenario will be emitted as an error from the observable. - * - * ## Examples - * - * Basic use - * - * ```ts - * import { fromFetch } from 'rxjs/fetch'; - * import { switchMap, of, catchError } from 'rxjs'; - * - * const data$ = fromFetch('https://api.github.com/users?per_page=5').pipe( - * switchMap(response => { - * if (response.ok) { - * // OK return data - * return response.json(); - * } else { - * // Server is returning a status requiring the client to try something else. - * return of({ error: true, message: `Error ${ response.status }` }); - * } - * }), - * catchError(err => { - * // Network or other error, handle appropriately - * console.error(err); - * return of({ error: true, message: err.message }) - * }) - * ); - * - * data$.subscribe({ - * next: result => console.log(result), - * complete: () => console.log('done') - * }); - * ``` - * - * ### Use with Chunked Transfer Encoding - * - * With HTTP responses that use [chunked transfer encoding](https://tools.ietf.org/html/rfc7230#section-3.3.1), - * the promise returned by `fetch` will resolve as soon as the response's headers are - * received. - * - * That means the `fromFetch` observable will emit a `Response` - and will - * then complete - before the body is received. When one of the methods on the - * `Response` - like `text()` or `json()` - is called, the returned promise will not - * resolve until the entire body has been received. Unsubscribing from any observable - * that uses the promise as an observable input will not abort the request. - * - * To facilitate aborting the retrieval of responses that use chunked transfer encoding, - * a `selector` can be specified via the `init` parameter: - * - * ```ts - * import { of } from 'rxjs'; - * import { fromFetch } from 'rxjs/fetch'; - * - * const data$ = fromFetch('https://api.github.com/users?per_page=5', { - * selector: response => response.json() - * }); - * - * data$.subscribe({ - * next: result => console.log(result), - * complete: () => console.log('done') - * }); - * ``` - * - * @param input The resource you would like to fetch. Can be a url or a request object. - * @param initWithSelector A configuration object for the fetch. - * [See MDN for more details](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) - * @returns An Observable, that when subscribed to, performs an HTTP request using the native `fetch` - * function. The {@link Subscription} is tied to an `AbortController` for the fetch. - */ -export function fromFetch<T>( - input: string | Request, - initWithSelector: RequestInit & { - selector?: (response: Response) => ObservableInput<T>; - } = {} -): Observable<Response | T> { - const { selector, ...init } = initWithSelector; - return new Observable<Response | T>((subscriber) => { - // Our controller for aborting this fetch. - // Any externally provided AbortSignal will have to call - // abort on this controller when signaled, because the - // signal from this controller is what is being passed to `fetch`. - const controller = new AbortController(); - const { signal } = controller; - // This flag exists to make sure we don't `abort()` the fetch upon tearing down - // this observable after emitting a Response. Aborting in such circumstances - // would also abort subsequent methods - like `json()` - that could be called - // on the Response. Consider: `fromFetch().pipe(take(1), mergeMap(res => res.json()))` - let abortable = true; - - // If the user provided an init configuration object, - // let's process it and chain our abort signals, if necessary. - // If a signal is provided, just have it finalized. It's a cancellation token, basically. - const { signal: outerSignal } = init; - if (outerSignal) { - if (outerSignal.aborted) { - controller.abort(); - } else { - // We got an AbortSignal from the arguments passed into `fromFetch`. - // We need to wire up our AbortController to abort when this signal aborts. - const outerSignalHandler = () => { - if (!signal.aborted) { - controller.abort(); - } - }; - outerSignal.addEventListener('abort', outerSignalHandler); - subscriber.add(() => outerSignal.removeEventListener('abort', outerSignalHandler)); - } - } - - // The initialization object passed to `fetch` as the second - // argument. This ferries in important information, including our - // AbortSignal. Create a new init, so we don't accidentally mutate the - // passed init, or reassign it. This is because the init passed in - // is shared between each subscription to the result. - const perSubscriberInit: RequestInit = { ...init, signal }; - - const handleError = (err: any) => { - abortable = false; - subscriber.error(err); - }; - - fetch(input, perSubscriberInit) - .then((response) => { - if (selector) { - // If we have a selector function, use it to project our response. - // Note that any error that comes from our selector will be - // sent to the promise `catch` below and handled. - innerFrom(selector(response)).subscribe( - createOperatorSubscriber( - subscriber, - // Values are passed through to the subscriber - undefined, - // The projected response is complete. - () => { - abortable = false; - subscriber.complete(); - }, - handleError - ) - ); - } else { - abortable = false; - subscriber.next(response); - subscriber.complete(); - } - }) - .catch(handleError); - - return () => { - if (abortable) { - controller.abort(); - } - }; - }); -} diff --git a/node_modules/rxjs/src/internal/observable/dom/webSocket.ts b/node_modules/rxjs/src/internal/observable/dom/webSocket.ts deleted file mode 100644 index b10c5d8..0000000 --- a/node_modules/rxjs/src/internal/observable/dom/webSocket.ts +++ /dev/null @@ -1,161 +0,0 @@ -import { WebSocketSubject, WebSocketSubjectConfig } from './WebSocketSubject'; - -/** - * Wrapper around the w3c-compatible WebSocket object provided by the browser. - * - * <span class="informal">{@link Subject} that communicates with a server via WebSocket</span> - * - * `webSocket` is a factory function that produces a `WebSocketSubject`, - * which can be used to make WebSocket connection with an arbitrary endpoint. - * `webSocket` accepts as an argument either a string with url of WebSocket endpoint, or an - * {@link WebSocketSubjectConfig} object for providing additional configuration, as - * well as Observers for tracking lifecycle of WebSocket connection. - * - * When `WebSocketSubject` is subscribed, it attempts to make a socket connection, - * unless there is one made already. This means that many subscribers will always listen - * on the same socket, thus saving resources. If however, two instances are made of `WebSocketSubject`, - * even if these two were provided with the same url, they will attempt to make separate - * connections. When consumer of a `WebSocketSubject` unsubscribes, socket connection is closed, - * only if there are no more subscribers still listening. If after some time a consumer starts - * subscribing again, connection is reestablished. - * - * Once connection is made, whenever a new message comes from the server, `WebSocketSubject` will emit that - * message as a value in the stream. By default, a message from the socket is parsed via `JSON.parse`. If you - * want to customize how deserialization is handled (if at all), you can provide custom `resultSelector` - * function in {@link WebSocketSubject}. When connection closes, stream will complete, provided it happened without - * any errors. If at any point (starting, maintaining or closing a connection) there is an error, - * stream will also error with whatever WebSocket API has thrown. - * - * By virtue of being a {@link Subject}, `WebSocketSubject` allows for receiving and sending messages from the server. In order - * to communicate with a connected endpoint, use `next`, `error` and `complete` methods. `next` sends a value to the server, so bear in mind - * that this value will not be serialized beforehand. Because of This, `JSON.stringify` will have to be called on a value by hand, - * before calling `next` with a result. Note also that if at the moment of nexting value - * there is no socket connection (for example no one is subscribing), those values will be buffered, and sent when connection - * is finally established. `complete` method closes socket connection. `error` does the same, - * as well as notifying the server that something went wrong via status code and string with details of what happened. - * Since status code is required in WebSocket API, `WebSocketSubject` does not allow, like regular `Subject`, - * arbitrary values being passed to the `error` method. It needs to be called with an object that has `code` - * property with status code number and optional `reason` property with string describing details - * of an error. - * - * Calling `next` does not affect subscribers of `WebSocketSubject` - they have no - * information that something was sent to the server (unless of course the server - * responds somehow to a message). On the other hand, since calling `complete` triggers - * an attempt to close socket connection. If that connection is closed without any errors, stream will - * complete, thus notifying all subscribers. And since calling `error` closes - * socket connection as well, just with a different status code for the server, if closing itself proceeds - * without errors, subscribed Observable will not error, as one might expect, but complete as usual. In both cases - * (calling `complete` or `error`), if process of closing socket connection results in some errors, *then* stream - * will error. - * - * **Multiplexing** - * - * `WebSocketSubject` has an additional operator, not found in other Subjects. It is called `multiplex` and it is - * used to simulate opening several socket connections, while in reality maintaining only one. - * For example, an application has both chat panel and real-time notifications about sport news. Since these are two distinct functions, - * it would make sense to have two separate connections for each. Perhaps there could even be two separate services with WebSocket - * endpoints, running on separate machines with only GUI combining them together. Having a socket connection - * for each functionality could become too resource expensive. It is a common pattern to have single - * WebSocket endpoint that acts as a gateway for the other services (in this case chat and sport news services). - * Even though there is a single connection in a client app, having the ability to manipulate streams as if it - * were two separate sockets is desirable. This eliminates manually registering and unregistering in a gateway for - * given service and filter out messages of interest. This is exactly what `multiplex` method is for. - * - * Method accepts three parameters. First two are functions returning subscription and unsubscription messages - * respectively. These are messages that will be sent to the server, whenever consumer of resulting Observable - * subscribes and unsubscribes. Server can use them to verify that some kind of messages should start or stop - * being forwarded to the client. In case of the above example application, after getting subscription message with proper identifier, - * gateway server can decide that it should connect to real sport news service and start forwarding messages from it. - * Note that both messages will be sent as returned by the functions, they are by default serialized using JSON.stringify, just - * as messages pushed via `next`. Also bear in mind that these messages will be sent on *every* subscription and - * unsubscription. This is potentially dangerous, because one consumer of an Observable may unsubscribe and the server - * might stop sending messages, since it got unsubscription message. This needs to be handled - * on the server or using {@link publish} on a Observable returned from 'multiplex'. - * - * Last argument to `multiplex` is a `messageFilter` function which should return a boolean. It is used to filter out messages - * sent by the server to only those that belong to simulated WebSocket stream. For example, server might mark these - * messages with some kind of string identifier on a message object and `messageFilter` would return `true` - * if there is such identifier on an object emitted by the socket. Messages which returns `false` in `messageFilter` are simply skipped, - * and are not passed down the stream. - * - * Return value of `multiplex` is an Observable with messages incoming from emulated socket connection. Note that this - * is not a `WebSocketSubject`, so calling `next` or `multiplex` again will fail. For pushing values to the - * server, use root `WebSocketSubject`. - * - * ## Examples - * - * Listening for messages from the server - * - * ```ts - * import { webSocket } from 'rxjs/webSocket'; - * - * const subject = webSocket('ws://localhost:8081'); - * - * subject.subscribe({ - * next: msg => console.log('message received: ' + msg), // Called whenever there is a message from the server. - * error: err => console.log(err), // Called if at any point WebSocket API signals some kind of error. - * complete: () => console.log('complete') // Called when connection is closed (for whatever reason). - * }); - * ``` - * - * Pushing messages to the server - * - * ```ts - * import { webSocket } from 'rxjs/webSocket'; - * - * const subject = webSocket('ws://localhost:8081'); - * - * subject.subscribe(); - * // Note that at least one consumer has to subscribe to the created subject - otherwise "nexted" values will be just buffered and not sent, - * // since no connection was established! - * - * subject.next({ message: 'some message' }); - * // This will send a message to the server once a connection is made. Remember value is serialized with JSON.stringify by default! - * - * subject.complete(); // Closes the connection. - * - * subject.error({ code: 4000, reason: 'I think our app just broke!' }); - * // Also closes the connection, but let's the server know that this closing is caused by some error. - * ``` - * - * Multiplexing WebSocket - * - * ```ts - * import { webSocket } from 'rxjs/webSocket'; - * - * const subject = webSocket('ws://localhost:8081'); - * - * const observableA = subject.multiplex( - * () => ({ subscribe: 'A' }), // When server gets this message, it will start sending messages for 'A'... - * () => ({ unsubscribe: 'A' }), // ...and when gets this one, it will stop. - * message => message.type === 'A' // If the function returns `true` message is passed down the stream. Skipped if the function returns false. - * ); - * - * const observableB = subject.multiplex( // And the same goes for 'B'. - * () => ({ subscribe: 'B' }), - * () => ({ unsubscribe: 'B' }), - * message => message.type === 'B' - * ); - * - * const subA = observableA.subscribe(messageForA => console.log(messageForA)); - * // At this moment WebSocket connection is established. Server gets '{"subscribe": "A"}' message and starts sending messages for 'A', - * // which we log here. - * - * const subB = observableB.subscribe(messageForB => console.log(messageForB)); - * // Since we already have a connection, we just send '{"subscribe": "B"}' message to the server. It starts sending messages for 'B', - * // which we log here. - * - * subB.unsubscribe(); - * // Message '{"unsubscribe": "B"}' is sent to the server, which stops sending 'B' messages. - * - * subA.unsubscribe(); - * // Message '{"unsubscribe": "A"}' makes the server stop sending messages for 'A'. Since there is no more subscribers to root Subject, - * // socket connection closes. - * ``` - * - * @param urlConfigOrSource The WebSocket endpoint as an url or an object with configuration and additional Observers. - * @return Subject which allows to both send and receive messages via WebSocket connection. - */ -export function webSocket<T>(urlConfigOrSource: string | WebSocketSubjectConfig<T>): WebSocketSubject<T> { - return new WebSocketSubject<T>(urlConfigOrSource); -} diff --git a/node_modules/rxjs/src/internal/observable/empty.ts b/node_modules/rxjs/src/internal/observable/empty.ts deleted file mode 100644 index 8f59e45..0000000 --- a/node_modules/rxjs/src/internal/observable/empty.ts +++ /dev/null @@ -1,79 +0,0 @@ -import { Observable } from '../Observable'; -import { SchedulerLike } from '../types'; - -/** - * A simple Observable that emits no items to the Observer and immediately - * emits a complete notification. - * - * <span class="informal">Just emits 'complete', and nothing else.</span> - * - *  - * - * A simple Observable that only emits the complete notification. It can be used - * for composing with other Observables, such as in a {@link mergeMap}. - * - * ## Examples - * - * Log complete notification - * - * ```ts - * import { EMPTY } from 'rxjs'; - * - * EMPTY.subscribe({ - * next: () => console.log('Next'), - * complete: () => console.log('Complete!') - * }); - * - * // Outputs - * // Complete! - * ``` - * - * Emit the number 7, then complete - * - * ```ts - * import { EMPTY, startWith } from 'rxjs'; - * - * const result = EMPTY.pipe(startWith(7)); - * result.subscribe(x => console.log(x)); - * - * // Outputs - * // 7 - * ``` - * - * Map and flatten only odd numbers to the sequence `'a'`, `'b'`, `'c'` - * - * ```ts - * import { interval, mergeMap, of, EMPTY } from 'rxjs'; - * - * const interval$ = interval(1000); - * const result = interval$.pipe( - * mergeMap(x => x % 2 === 1 ? of('a', 'b', 'c') : EMPTY), - * ); - * result.subscribe(x => console.log(x)); - * - * // Results in the following to the console: - * // x is equal to the count on the interval, e.g. (0, 1, 2, 3, ...) - * // x will occur every 1000ms - * // if x % 2 is equal to 1, print a, b, c (each on its own) - * // if x % 2 is not equal to 1, nothing will be output - * ``` - * - * @see {@link Observable} - * @see {@link NEVER} - * @see {@link of} - * @see {@link throwError} - */ -export const EMPTY = new Observable<never>((subscriber) => subscriber.complete()); - -/** - * @param scheduler A {@link SchedulerLike} to use for scheduling - * the emission of the complete notification. - * @deprecated Replaced with the {@link EMPTY} constant or {@link scheduled} (e.g. `scheduled([], scheduler)`). Will be removed in v8. - */ -export function empty(scheduler?: SchedulerLike) { - return scheduler ? emptyScheduled(scheduler) : EMPTY; -} - -function emptyScheduled(scheduler: SchedulerLike) { - return new Observable<never>((subscriber) => scheduler.schedule(() => subscriber.complete())); -} diff --git a/node_modules/rxjs/src/internal/observable/forkJoin.ts b/node_modules/rxjs/src/internal/observable/forkJoin.ts deleted file mode 100644 index ec9c418..0000000 --- a/node_modules/rxjs/src/internal/observable/forkJoin.ts +++ /dev/null @@ -1,184 +0,0 @@ -import { Observable } from '../Observable'; -import { ObservedValueOf, ObservableInputTuple, ObservableInput } from '../types'; -import { argsArgArrayOrObject } from '../util/argsArgArrayOrObject'; -import { innerFrom } from './innerFrom'; -import { popResultSelector } from '../util/args'; -import { createOperatorSubscriber } from '../operators/OperatorSubscriber'; -import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs'; -import { createObject } from '../util/createObject'; -import { AnyCatcher } from '../AnyCatcher'; - -// forkJoin(any) -// We put this first because we need to catch cases where the user has supplied -// _exactly `any`_ as the argument. Since `any` literally matches _anything_, -// we don't want it to randomly hit one of the other type signatures below, -// as we have no idea at build-time what type we should be returning when given an any. - -/** - * 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 function forkJoin<T extends AnyCatcher>(arg: T): Observable<unknown>; - -// forkJoin(null | undefined) -export function forkJoin(scheduler: null | undefined): Observable<never>; - -// forkJoin([a, b, c]) -export function forkJoin(sources: readonly []): Observable<never>; -export function forkJoin<A extends readonly unknown[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<A>; -export function forkJoin<A extends readonly unknown[], R>( - sources: readonly [...ObservableInputTuple<A>], - resultSelector: (...values: A) => R -): Observable<R>; - -// forkJoin(a, b, c) -/** @deprecated Pass an array of sources instead. The rest-parameters signature will be removed in v8. Details: https://rxjs.dev/deprecations/array-argument */ -export function forkJoin<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): 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 function forkJoin<A extends readonly unknown[], R>( - ...sourcesAndResultSelector: [...ObservableInputTuple<A>, (...values: A) => R] -): Observable<R>; - -// forkJoin({a, b, c}) -export function forkJoin(sourcesObject: { [K in any]: never }): Observable<never>; -export function forkJoin<T extends Record<string, ObservableInput<any>>>( - sourcesObject: T -): Observable<{ [K in keyof T]: ObservedValueOf<T[K]> }>; - -/** - * Accepts an `Array` of {@link ObservableInput} or a dictionary `Object` of {@link ObservableInput} and returns - * an {@link Observable} that emits either an array of values in the exact same order as the passed array, - * or a dictionary of values in the same shape as the passed dictionary. - * - * <span class="informal">Wait for Observables to complete and then combine last values they emitted; - * complete immediately if an empty array is passed.</span> - * - *  - * - * `forkJoin` is an operator that takes any number of input observables which can be passed either as an array - * or a dictionary of input observables. If no input observables are provided (e.g. an empty array is passed), - * then the resulting stream will complete immediately. - * - * `forkJoin` will wait for all passed observables to emit and complete and then it will emit an array or an object with last - * values from corresponding observables. - * - * If you pass an array of `n` observables to the operator, then the resulting - * array will have `n` values, where the first value is the last one emitted by the first observable, - * second value is the last one emitted by the second observable and so on. - * - * If you pass a dictionary of observables to the operator, then the resulting - * objects will have the same keys as the dictionary passed, with their last values they have emitted - * located at the corresponding key. - * - * That means `forkJoin` will not emit more than once and it will complete after that. If you need to emit combined - * values not only at the end of the lifecycle of passed observables, but also throughout it, try out {@link combineLatest} - * or {@link zip} instead. - * - * In order for the resulting array to have the same length as the number of input observables, whenever any of - * the given observables completes without emitting any value, `forkJoin` will complete at that moment as well - * and it will not emit anything either, even if it already has some last values from other observables. - * Conversely, if there is an observable that never completes, `forkJoin` will never complete either, - * unless at any point some other observable completes without emitting a value, which brings us back to - * the previous case. Overall, in order for `forkJoin` to emit a value, all given observables - * have to emit something at least once and complete. - * - * If any given observable errors at some point, `forkJoin` will error as well and immediately unsubscribe - * from the other observables. - * - * Optionally `forkJoin` accepts a `resultSelector` function, that will be called with values which normally - * would land in the emitted array. Whatever is returned by the `resultSelector`, will appear in the output - * observable instead. This means that the default `resultSelector` can be thought of as a function that takes - * all its arguments and puts them into an array. Note that the `resultSelector` will be called only - * when `forkJoin` is supposed to emit a result. - * - * ## Examples - * - * Use `forkJoin` with a dictionary of observable inputs - * - * ```ts - * import { forkJoin, of, timer } from 'rxjs'; - * - * const observable = forkJoin({ - * foo: of(1, 2, 3, 4), - * bar: Promise.resolve(8), - * baz: timer(4000) - * }); - * observable.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('This is how it ends!'), - * }); - * - * // Logs: - * // { foo: 4, bar: 8, baz: 0 } after 4 seconds - * // 'This is how it ends!' immediately after - * ``` - * - * Use `forkJoin` with an array of observable inputs - * - * ```ts - * import { forkJoin, of, timer } from 'rxjs'; - * - * const observable = forkJoin([ - * of(1, 2, 3, 4), - * Promise.resolve(8), - * timer(4000) - * ]); - * observable.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('This is how it ends!'), - * }); - * - * // Logs: - * // [4, 8, 0] after 4 seconds - * // 'This is how it ends!' immediately after - * ``` - * - * @see {@link combineLatest} - * @see {@link zip} - * - * @param args Any number of `ObservableInput`s provided either as an array, as an object - * or as arguments passed directly to the operator. - * @return Observable emitting either an array of last values emitted by passed Observables - * or value from project function. - */ -export function forkJoin(...args: any[]): Observable<any> { - const resultSelector = popResultSelector(args); - const { args: sources, keys } = argsArgArrayOrObject(args); - const result = new Observable((subscriber) => { - const { length } = sources; - if (!length) { - subscriber.complete(); - return; - } - const values = new Array(length); - let remainingCompletions = length; - let remainingEmissions = length; - for (let sourceIndex = 0; sourceIndex < length; sourceIndex++) { - let hasValue = false; - innerFrom(sources[sourceIndex]).subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - if (!hasValue) { - hasValue = true; - remainingEmissions--; - } - values[sourceIndex] = value; - }, - () => remainingCompletions--, - undefined, - () => { - if (!remainingCompletions || !hasValue) { - if (!remainingEmissions) { - subscriber.next(keys ? createObject(keys, values) : values); - } - subscriber.complete(); - } - } - ) - ); - } - }); - return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result; -} diff --git a/node_modules/rxjs/src/internal/observable/from.ts b/node_modules/rxjs/src/internal/observable/from.ts deleted file mode 100644 index 42e1a42..0000000 --- a/node_modules/rxjs/src/internal/observable/from.ts +++ /dev/null @@ -1,104 +0,0 @@ -import { Observable } from '../Observable'; -import { ObservableInput, SchedulerLike, ObservedValueOf } from '../types'; -import { scheduled } from '../scheduled/scheduled'; -import { innerFrom } from './innerFrom'; - -export function from<O extends ObservableInput<any>>(input: O): Observable<ObservedValueOf<O>>; -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function from<O extends ObservableInput<any>>(input: O, scheduler: SchedulerLike | undefined): Observable<ObservedValueOf<O>>; - -/** - * Creates an Observable from an Array, an array-like object, a Promise, an iterable object, or an Observable-like object. - * - * <span class="informal">Converts almost anything to an Observable.</span> - * - *  - * - * `from` converts various other objects and data types into Observables. It also converts a Promise, an array-like, or an - * <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable" target="_blank">iterable</a> - * object into an Observable that emits the items in that promise, array, or iterable. A String, in this context, is treated - * as an array of characters. Observable-like objects (contains a function named with the ES2015 Symbol for Observable) can also be - * converted through this operator. - * - * ## Examples - * - * Converts an array to an Observable - * - * ```ts - * import { from } from 'rxjs'; - * - * const array = [10, 20, 30]; - * const result = from(array); - * - * result.subscribe(x => console.log(x)); - * - * // Logs: - * // 10 - * // 20 - * // 30 - * ``` - * - * Convert an infinite iterable (from a generator) to an Observable - * - * ```ts - * import { from, take } from 'rxjs'; - * - * function* generateDoubles(seed) { - * let i = seed; - * while (true) { - * yield i; - * i = 2 * i; // double it - * } - * } - * - * const iterator = generateDoubles(3); - * const result = from(iterator).pipe(take(10)); - * - * result.subscribe(x => console.log(x)); - * - * // Logs: - * // 3 - * // 6 - * // 12 - * // 24 - * // 48 - * // 96 - * // 192 - * // 384 - * // 768 - * // 1536 - * ``` - * - * With `asyncScheduler` - * - * ```ts - * import { from, asyncScheduler } from 'rxjs'; - * - * console.log('start'); - * - * const array = [10, 20, 30]; - * const result = from(array, asyncScheduler); - * - * result.subscribe(x => console.log(x)); - * - * console.log('end'); - * - * // Logs: - * // 'start' - * // 'end' - * // 10 - * // 20 - * // 30 - * ``` - * - * @see {@link fromEvent} - * @see {@link fromEventPattern} - * - * @param input A subscription object, a Promise, an Observable-like, - * an Array, an iterable, or an array-like object to be converted. - * @param scheduler An optional {@link SchedulerLike} on which to schedule the emission of values. - * @return An Observable converted from {@link ObservableInput}. - */ -export function from<T>(input: ObservableInput<T>, scheduler?: SchedulerLike): Observable<T> { - return scheduler ? scheduled(input, scheduler) : innerFrom(input); -} diff --git a/node_modules/rxjs/src/internal/observable/fromEvent.ts b/node_modules/rxjs/src/internal/observable/fromEvent.ts deleted file mode 100644 index ef15431..0000000 --- a/node_modules/rxjs/src/internal/observable/fromEvent.ts +++ /dev/null @@ -1,339 +0,0 @@ -import { innerFrom } from '../observable/innerFrom'; -import { Observable } from '../Observable'; -import { mergeMap } from '../operators/mergeMap'; -import { isArrayLike } from '../util/isArrayLike'; -import { isFunction } from '../util/isFunction'; -import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs'; - -// These constants are used to create handler registry functions using array mapping below. -const nodeEventEmitterMethods = ['addListener', 'removeListener'] as const; -const eventTargetMethods = ['addEventListener', 'removeEventListener'] as const; -const jqueryMethods = ['on', 'off'] as const; - -export interface NodeStyleEventEmitter { - addListener(eventName: string | symbol, handler: NodeEventHandler): this; - removeListener(eventName: string | symbol, handler: NodeEventHandler): this; -} - -export type NodeEventHandler = (...args: any[]) => void; - -// For APIs that implement `addListener` and `removeListener` methods that may -// not use the same arguments or return EventEmitter values -// such as React Native -export interface NodeCompatibleEventEmitter { - addListener(eventName: string, handler: NodeEventHandler): void | {}; - removeListener(eventName: string, handler: NodeEventHandler): void | {}; -} - -// Use handler types like those in @types/jquery. See: -// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/847731ba1d7fa6db6b911c0e43aa0afe596e7723/types/jquery/misc.d.ts#L6395 -export interface JQueryStyleEventEmitter<TContext, T> { - on(eventName: string, handler: (this: TContext, t: T, ...args: any[]) => any): void; - off(eventName: string, handler: (this: TContext, t: T, ...args: any[]) => any): void; -} - -export interface EventListenerObject<E> { - handleEvent(evt: E): void; -} - -export interface HasEventTargetAddRemove<E> { - addEventListener( - type: string, - listener: ((evt: E) => void) | EventListenerObject<E> | null, - options?: boolean | AddEventListenerOptions - ): void; - removeEventListener( - type: string, - listener: ((evt: E) => void) | EventListenerObject<E> | null, - options?: EventListenerOptions | boolean - ): void; -} - -export interface EventListenerOptions { - capture?: boolean; - passive?: boolean; - once?: boolean; -} - -export interface AddEventListenerOptions extends EventListenerOptions { - once?: boolean; - passive?: boolean; -} - -export function fromEvent<T>(target: HasEventTargetAddRemove<T> | ArrayLike<HasEventTargetAddRemove<T>>, eventName: string): Observable<T>; -export function fromEvent<T, R>( - target: HasEventTargetAddRemove<T> | ArrayLike<HasEventTargetAddRemove<T>>, - eventName: string, - resultSelector: (event: T) => R -): Observable<R>; -export function fromEvent<T>( - target: HasEventTargetAddRemove<T> | ArrayLike<HasEventTargetAddRemove<T>>, - eventName: string, - options: EventListenerOptions -): Observable<T>; -export function fromEvent<T, R>( - target: HasEventTargetAddRemove<T> | ArrayLike<HasEventTargetAddRemove<T>>, - eventName: string, - options: EventListenerOptions, - resultSelector: (event: T) => R -): Observable<R>; - -export function fromEvent(target: NodeStyleEventEmitter | ArrayLike<NodeStyleEventEmitter>, eventName: string): Observable<unknown>; -/** @deprecated Do not specify explicit type parameters. Signatures with type parameters that cannot be inferred will be removed in v8. */ -export function fromEvent<T>(target: NodeStyleEventEmitter | ArrayLike<NodeStyleEventEmitter>, eventName: string): Observable<T>; -export function fromEvent<R>( - target: NodeStyleEventEmitter | ArrayLike<NodeStyleEventEmitter>, - eventName: string, - resultSelector: (...args: any[]) => R -): Observable<R>; - -export function fromEvent( - target: NodeCompatibleEventEmitter | ArrayLike<NodeCompatibleEventEmitter>, - eventName: string -): Observable<unknown>; -/** @deprecated Do not specify explicit type parameters. Signatures with type parameters that cannot be inferred will be removed in v8. */ -export function fromEvent<T>(target: NodeCompatibleEventEmitter | ArrayLike<NodeCompatibleEventEmitter>, eventName: string): Observable<T>; -export function fromEvent<R>( - target: NodeCompatibleEventEmitter | ArrayLike<NodeCompatibleEventEmitter>, - eventName: string, - resultSelector: (...args: any[]) => R -): Observable<R>; - -export function fromEvent<T>( - target: JQueryStyleEventEmitter<any, T> | ArrayLike<JQueryStyleEventEmitter<any, T>>, - eventName: string -): Observable<T>; -export function fromEvent<T, R>( - target: JQueryStyleEventEmitter<any, T> | ArrayLike<JQueryStyleEventEmitter<any, T>>, - eventName: string, - resultSelector: (value: T, ...args: any[]) => R -): Observable<R>; - -/** - * Creates an Observable that emits events of a specific type coming from the - * given event target. - * - * <span class="informal">Creates an Observable from DOM events, or Node.js - * EventEmitter events or others.</span> - * - *  - * - * `fromEvent` accepts as a first argument event target, which is an object with methods - * for registering event handler functions. As a second argument it takes string that indicates - * type of event we want to listen for. `fromEvent` supports selected types of event targets, - * which are described in detail below. If your event target does not match any of the ones listed, - * you should use {@link fromEventPattern}, which can be used on arbitrary APIs. - * When it comes to APIs supported by `fromEvent`, their methods for adding and removing event - * handler functions have different names, but they all accept a string describing event type - * and function itself, which will be called whenever said event happens. - * - * Every time resulting Observable is subscribed, event handler function will be registered - * to event target on given event type. When that event fires, value - * passed as a first argument to registered function will be emitted by output Observable. - * When Observable is unsubscribed, function will be unregistered from event target. - * - * Note that if event target calls registered function with more than one argument, second - * and following arguments will not appear in resulting stream. In order to get access to them, - * you can pass to `fromEvent` optional project function, which will be called with all arguments - * passed to event handler. Output Observable will then emit value returned by project function, - * instead of the usual value. - * - * Remember that event targets listed below are checked via duck typing. It means that - * no matter what kind of object you have and no matter what environment you work in, - * you can safely use `fromEvent` on that object if it exposes described methods (provided - * of course they behave as was described above). So for example if Node.js library exposes - * event target which has the same method names as DOM EventTarget, `fromEvent` is still - * a good choice. - * - * If the API you use is more callback then event handler oriented (subscribed - * callback function fires only once and thus there is no need to manually - * unregister it), you should use {@link bindCallback} or {@link bindNodeCallback} - * instead. - * - * `fromEvent` supports following types of event targets: - * - * **DOM EventTarget** - * - * This is an object with `addEventListener` and `removeEventListener` methods. - * - * In the browser, `addEventListener` accepts - apart from event type string and event - * handler function arguments - optional third parameter, which is either an object or boolean, - * both used for additional configuration how and when passed function will be called. When - * `fromEvent` is used with event target of that type, you can provide this values - * as third parameter as well. - * - * **Node.js EventEmitter** - * - * An object with `addListener` and `removeListener` methods. - * - * **JQuery-style event target** - * - * An object with `on` and `off` methods - * - * **DOM NodeList** - * - * List of DOM Nodes, returned for example by `document.querySelectorAll` or `Node.childNodes`. - * - * Although this collection is not event target in itself, `fromEvent` will iterate over all Nodes - * it contains and install event handler function in every of them. When returned Observable - * is unsubscribed, function will be removed from all Nodes. - * - * **DOM HtmlCollection** - * - * Just as in case of NodeList it is a collection of DOM nodes. Here as well event handler function is - * installed and removed in each of elements. - * - * - * ## Examples - * - * Emit clicks happening on the DOM document - * - * ```ts - * import { fromEvent } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * clicks.subscribe(x => console.log(x)); - * - * // Results in: - * // MouseEvent object logged to console every time a click - * // occurs on the document. - * ``` - * - * Use `addEventListener` with capture option - * - * ```ts - * import { fromEvent } from 'rxjs'; - * - * const div = document.createElement('div'); - * div.style.cssText = 'width: 200px; height: 200px; background: #09c;'; - * document.body.appendChild(div); - * - * // note optional configuration parameter which will be passed to addEventListener - * const clicksInDocument = fromEvent(document, 'click', { capture: true }); - * const clicksInDiv = fromEvent(div, 'click'); - * - * clicksInDocument.subscribe(() => console.log('document')); - * clicksInDiv.subscribe(() => console.log('div')); - * - * // By default events bubble UP in DOM tree, so normally - * // when we would click on div in document - * // "div" would be logged first and then "document". - * // Since we specified optional `capture` option, document - * // will catch event when it goes DOWN DOM tree, so console - * // will log "document" and then "div". - * ``` - * - * @see {@link bindCallback} - * @see {@link bindNodeCallback} - * @see {@link fromEventPattern} - * - * @param target The DOM EventTarget, Node.js EventEmitter, JQuery-like event target, - * NodeList or HTMLCollection to attach the event handler to. - * @param eventName The event name of interest, being emitted by the `target`. - * @param options Options to pass through to the underlying `addListener`, - * `addEventListener` or `on` functions. - * @param resultSelector A mapping function used to transform events. It takes the - * arguments from the event handler and should return a single value. - * @return An Observable emitting events registered through `target`'s - * listener handlers. - */ -export function fromEvent<T>( - target: any, - eventName: string, - options?: EventListenerOptions | ((...args: any[]) => T), - resultSelector?: (...args: any[]) => T -): Observable<T> { - if (isFunction(options)) { - resultSelector = options; - options = undefined; - } - if (resultSelector) { - return fromEvent<T>(target, eventName, options as EventListenerOptions).pipe(mapOneOrManyArgs(resultSelector)); - } - - // Figure out our add and remove methods. In order to do this, - // we are going to analyze the target in a preferred order, if - // the target matches a given signature, we take the two "add" and "remove" - // method names and apply them to a map to create opposite versions of the - // same function. This is because they all operate in duplicate pairs, - // `addListener(name, handler)`, `removeListener(name, handler)`, for example. - // The call only differs by method name, as to whether or not you're adding or removing. - const [add, remove] = - // If it is an EventTarget, we need to use a slightly different method than the other two patterns. - isEventTarget(target) - ? eventTargetMethods.map((methodName) => (handler: any) => target[methodName](eventName, handler, options as EventListenerOptions)) - : // In all other cases, the call pattern is identical with the exception of the method names. - isNodeStyleEventEmitter(target) - ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName)) - : isJQueryStyleEventEmitter(target) - ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName)) - : []; - - // If add is falsy, it's because we didn't match a pattern above. - // Check to see if it is an ArrayLike, because if it is, we want to - // try to apply fromEvent to all of it's items. We do this check last, - // because there are may be some types that are both ArrayLike *and* implement - // event registry points, and we'd rather delegate to that when possible. - if (!add) { - if (isArrayLike(target)) { - return mergeMap((subTarget: any) => fromEvent(subTarget, eventName, options as EventListenerOptions))( - innerFrom(target) - ) as Observable<T>; - } - } - - // If add is falsy and we made it here, it's because we didn't - // match any valid target objects above. - if (!add) { - throw new TypeError('Invalid event target'); - } - - return new Observable<T>((subscriber) => { - // The handler we are going to register. Forwards the event object, by itself, or - // an array of arguments to the event handler, if there is more than one argument, - // to the consumer. - const handler = (...args: any[]) => subscriber.next(1 < args.length ? args : args[0]); - // Do the work of adding the handler to the target. - add(handler); - // When we finalize, we want to remove the handler and free up memory. - return () => remove!(handler); - }); -} - -/** - * Used to create `add` and `remove` functions to register and unregister event handlers - * from a target in the most common handler pattern, where there are only two arguments. - * (e.g. `on(name, fn)`, `off(name, fn)`, `addListener(name, fn)`, or `removeListener(name, fn)`) - * @param target The target we're calling methods on - * @param eventName The event name for the event we're creating register or unregister functions for - */ -function toCommonHandlerRegistry(target: any, eventName: string) { - return (methodName: string) => (handler: any) => target[methodName](eventName, handler); -} - -/** - * Checks to see if the target implements the required node-style EventEmitter methods - * for adding and removing event handlers. - * @param target the object to check - */ -function isNodeStyleEventEmitter(target: any): target is NodeStyleEventEmitter { - return isFunction(target.addListener) && isFunction(target.removeListener); -} - -/** - * Checks to see if the target implements the required jQuery-style EventEmitter methods - * for adding and removing event handlers. - * @param target the object to check - */ -function isJQueryStyleEventEmitter(target: any): target is JQueryStyleEventEmitter<any, any> { - return isFunction(target.on) && isFunction(target.off); -} - -/** - * Checks to see if the target implements the required EventTarget methods - * for adding and removing event handlers. - * @param target the object to check - */ -function isEventTarget(target: any): target is HasEventTargetAddRemove<any> { - return isFunction(target.addEventListener) && isFunction(target.removeEventListener); -} diff --git a/node_modules/rxjs/src/internal/observable/fromEventPattern.ts b/node_modules/rxjs/src/internal/observable/fromEventPattern.ts deleted file mode 100644 index 6e700b1..0000000 --- a/node_modules/rxjs/src/internal/observable/fromEventPattern.ts +++ /dev/null @@ -1,152 +0,0 @@ -import { Observable } from '../Observable'; -import { isFunction } from '../util/isFunction'; -import { NodeEventHandler } from './fromEvent'; -import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs'; - -/* tslint:disable:max-line-length */ -export function fromEventPattern<T>( - addHandler: (handler: NodeEventHandler) => any, - removeHandler?: (handler: NodeEventHandler, signal?: any) => void -): Observable<T>; -export function fromEventPattern<T>( - addHandler: (handler: NodeEventHandler) => any, - removeHandler?: (handler: NodeEventHandler, signal?: any) => void, - resultSelector?: (...args: any[]) => T -): Observable<T>; -/* tslint:enable:max-line-length */ - -/** - * Creates an Observable from an arbitrary API for registering event handlers. - * - * <span class="informal">When that method for adding event handler was something {@link fromEvent} - * was not prepared for.</span> - * - *  - * - * `fromEventPattern` allows you to convert into an Observable any API that supports registering handler functions - * for events. It is similar to {@link fromEvent}, but far - * more flexible. In fact, all use cases of {@link fromEvent} could be easily handled by - * `fromEventPattern` (although in slightly more verbose way). - * - * This operator accepts as a first argument an `addHandler` function, which will be injected with - * handler parameter. That handler is actually an event handler function that you now can pass - * to API expecting it. `addHandler` will be called whenever Observable - * returned by the operator is subscribed, so registering handler in API will not - * necessarily happen when `fromEventPattern` is called. - * - * After registration, every time an event that we listen to happens, - * Observable returned by `fromEventPattern` will emit value that event handler - * function was called with. Note that if event handler was called with more - * than one argument, second and following arguments will not appear in the Observable. - * - * If API you are using allows to unregister event handlers as well, you can pass to `fromEventPattern` - * another function - `removeHandler` - as a second parameter. It will be injected - * with the same handler function as before, which now you can use to unregister - * it from the API. `removeHandler` will be called when consumer of resulting Observable - * unsubscribes from it. - * - * In some APIs unregistering is actually handled differently. Method registering an event handler - * returns some kind of token, which is later used to identify which function should - * be unregistered or it itself has method that unregisters event handler. - * If that is the case with your API, make sure token returned - * by registering method is returned by `addHandler`. Then it will be passed - * as a second argument to `removeHandler`, where you will be able to use it. - * - * If you need access to all event handler parameters (not only the first one), - * or you need to transform them in any way, you can call `fromEventPattern` with optional - * third parameter - project function which will accept all arguments passed to - * event handler when it is called. Whatever is returned from project function will appear on - * resulting stream instead of usual event handlers first argument. This means - * that default project can be thought of as function that takes its first parameter - * and ignores the rest. - * - * ## Examples - * - * Emits clicks happening on the DOM document - * - * ```ts - * import { fromEventPattern } from 'rxjs'; - * - * function addClickHandler(handler) { - * document.addEventListener('click', handler); - * } - * - * function removeClickHandler(handler) { - * document.removeEventListener('click', handler); - * } - * - * const clicks = fromEventPattern( - * addClickHandler, - * removeClickHandler - * ); - * clicks.subscribe(x => console.log(x)); - * - * // Whenever you click anywhere in the browser, DOM MouseEvent - * // object will be logged. - * ``` - * - * Use with API that returns cancellation token - * - * ```ts - * import { fromEventPattern } from 'rxjs'; - * - * const token = someAPI.registerEventHandler(function() {}); - * someAPI.unregisterEventHandler(token); // this APIs cancellation method accepts - * // not handler itself, but special token. - * - * const someAPIObservable = fromEventPattern( - * function(handler) { return someAPI.registerEventHandler(handler); }, // Note that we return the token here... - * function(handler, token) { someAPI.unregisterEventHandler(token); } // ...to then use it here. - * ); - * ``` - * - * Use with project function - * - * ```ts - * import { fromEventPattern } from 'rxjs'; - * - * someAPI.registerEventHandler((eventType, eventMessage) => { - * console.log(eventType, eventMessage); // Logs 'EVENT_TYPE' 'EVENT_MESSAGE' to console. - * }); - * - * const someAPIObservable = fromEventPattern( - * handler => someAPI.registerEventHandler(handler), - * handler => someAPI.unregisterEventHandler(handler) - * (eventType, eventMessage) => eventType + ' --- ' + eventMessage // without that function only 'EVENT_TYPE' - * ); // would be emitted by the Observable - * - * someAPIObservable.subscribe(value => console.log(value)); - * - * // Logs: - * // 'EVENT_TYPE --- EVENT_MESSAGE' - * ``` - * - * @see {@link fromEvent} - * @see {@link bindCallback} - * @see {@link bindNodeCallback} - * - * @param addHandler A function that takes a `handler` function as argument and attaches it - * somehow to the actual source of events. - * @param removeHandler A function that takes a `handler` function as an argument and removes - * it from the event source. If `addHandler` returns some kind of token, `removeHandler` function - * will have it as a second parameter. - * @param resultSelector A function to transform results. It takes the arguments from the event - * handler and should return a single value. - * @return Observable which, when an event happens, emits first parameter passed to registered - * event handler. Alternatively it emits whatever project function returns at that moment. - */ -export function fromEventPattern<T>( - addHandler: (handler: NodeEventHandler) => any, - removeHandler?: (handler: NodeEventHandler, signal?: any) => void, - resultSelector?: (...args: any[]) => T -): Observable<T | T[]> { - if (resultSelector) { - return fromEventPattern<T>(addHandler, removeHandler).pipe(mapOneOrManyArgs(resultSelector)); - } - - return new Observable<T | T[]>((subscriber) => { - const handler = (...e: T[]) => subscriber.next(e.length === 1 ? e[0] : e); - const retValue = addHandler(handler); - return isFunction(removeHandler) ? () => removeHandler(handler, retValue) : undefined; - }); -} diff --git a/node_modules/rxjs/src/internal/observable/fromSubscribable.ts b/node_modules/rxjs/src/internal/observable/fromSubscribable.ts deleted file mode 100644 index 12e45bf..0000000 --- a/node_modules/rxjs/src/internal/observable/fromSubscribable.ts +++ /dev/null @@ -1,17 +0,0 @@ -import { Observable } from '../Observable'; -import { Subscriber } from '../Subscriber'; -import { Subscribable } from '../types'; - -/** - * Used to convert a subscribable to an observable. - * - * Currently, this is only used within internals. - * - * TODO: Discuss ObservableInput supporting "Subscribable". - * https://github.com/ReactiveX/rxjs/issues/5909 - * - * @param subscribable A subscribable - */ -export function fromSubscribable<T>(subscribable: Subscribable<T>) { - return new Observable((subscriber: Subscriber<T>) => subscribable.subscribe(subscriber)); -} diff --git a/node_modules/rxjs/src/internal/observable/generate.ts b/node_modules/rxjs/src/internal/observable/generate.ts deleted file mode 100644 index 0b728be..0000000 --- a/node_modules/rxjs/src/internal/observable/generate.ts +++ /dev/null @@ -1,387 +0,0 @@ -import { Observable } from '../Observable'; -import { identity } from '../util/identity'; -import { ObservableInput, SchedulerLike } from '../types'; -import { isScheduler } from '../util/isScheduler'; -import { defer } from './defer'; -import { scheduleIterable } from '../scheduled/scheduleIterable'; - -type ConditionFunc<S> = (state: S) => boolean; -type IterateFunc<S> = (state: S) => S; -type ResultFunc<S, T> = (state: S) => T; - -export interface GenerateBaseOptions<S> { - /** - * Initial state. - */ - initialState: S; - /** - * Condition function that accepts state and returns boolean. - * When it returns false, the generator stops. - * If not specified, a generator never stops. - */ - condition?: ConditionFunc<S>; - /** - * Iterate function that accepts state and returns new state. - */ - iterate: IterateFunc<S>; - /** - * SchedulerLike to use for generation process. - * By default, a generator starts immediately. - */ - scheduler?: SchedulerLike; -} - -export interface GenerateOptions<T, S> extends GenerateBaseOptions<S> { - /** - * Result selection function that accepts state and returns a value to emit. - */ - resultSelector: ResultFunc<S, T>; -} - -/** - * Generates an observable sequence by running a state-driven loop - * producing the sequence's elements, using the specified scheduler - * to send out observer messages. - * - *  - * - * ## Examples - * - * Produces sequence of numbers - * - * ```ts - * import { generate } from 'rxjs'; - * - * const result = generate(0, x => x < 3, x => x + 1, x => x); - * - * result.subscribe(x => console.log(x)); - * - * // Logs: - * // 0 - * // 1 - * // 2 - * ``` - * - * Use `asapScheduler` - * - * ```ts - * import { generate, asapScheduler } from 'rxjs'; - * - * const result = generate(1, x => x < 5, x => x * 2, x => x + 1, asapScheduler); - * - * result.subscribe(x => console.log(x)); - * - * // Logs: - * // 2 - * // 3 - * // 5 - * ``` - * - * @see {@link from} - * @see {@link Observable} - * - * @param initialState Initial state. - * @param condition Condition to terminate generation (upon returning false). - * @param iterate Iteration step function. - * @param resultSelector Selector function for results produced in the sequence. - * @param scheduler A {@link SchedulerLike} on which to run the generator loop. - * If not provided, defaults to emit immediately. - * @returns The generated sequence. - * @deprecated Instead of passing separate arguments, use the options argument. - * Signatures taking separate arguments will be removed in v8. - */ -export function generate<T, S>( - initialState: S, - condition: ConditionFunc<S>, - iterate: IterateFunc<S>, - resultSelector: ResultFunc<S, T>, - scheduler?: SchedulerLike -): Observable<T>; - -/** - * Generates an Observable by running a state-driven loop - * that emits an element on each iteration. - * - * <span class="informal">Use it instead of nexting values in a for loop.</span> - * - *  - * - * `generate` allows you to create a stream of values generated with a loop very similar to - * a traditional for loop. The first argument of `generate` is a beginning value. The second argument - * is a function that accepts this value and tests if some condition still holds. If it does, - * then the loop continues, if not, it stops. The third value is a function which takes the - * previously defined value and modifies it in some way on each iteration. Note how these three parameters - * are direct equivalents of three expressions in a traditional for loop: the first expression - * initializes some state (for example, a numeric index), the second tests if the loop can perform the next - * iteration (for example, if the index is lower than 10) and the third states how the defined value - * will be modified on every step (for example, the index will be incremented by one). - * - * Return value of a `generate` operator is an Observable that on each loop iteration - * emits a value. First of all, the condition function is ran. If it returns true, then the Observable - * emits the currently stored value (initial value at the first iteration) and finally updates - * that value with iterate function. If at some point the condition returns false, then the Observable - * completes at that moment. - * - * Optionally you can pass a fourth parameter to `generate` - a result selector function which allows you - * to immediately map the value that would normally be emitted by an Observable. - * - * If you find three anonymous functions in `generate` call hard to read, you can provide - * a single object to the operator instead where the object has the properties: `initialState`, - * `condition`, `iterate` and `resultSelector`, which should have respective values that you - * would normally pass to `generate`. `resultSelector` is still optional, but that form - * of calling `generate` allows you to omit `condition` as well. If you omit it, that means - * condition always holds, or in other words the resulting Observable will never complete. - * - * Both forms of `generate` can optionally accept a scheduler. In case of a multi-parameter call, - * scheduler simply comes as a last argument (no matter if there is a `resultSelector` - * function or not). In case of a single-parameter call, you can provide it as a - * `scheduler` property on the object passed to the operator. In both cases, a scheduler decides when - * the next iteration of the loop will happen and therefore when the next value will be emitted - * by the Observable. For example, to ensure that each value is pushed to the Observer - * on a separate task in the event loop, you could use the `async` scheduler. Note that - * by default (when no scheduler is passed) values are simply emitted synchronously. - * - * - * ## Examples - * - * Use with condition and iterate functions - * - * ```ts - * import { generate } from 'rxjs'; - * - * const result = generate(0, x => x < 3, x => x + 1); - * - * result.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('Complete!') - * }); - * - * // Logs: - * // 0 - * // 1 - * // 2 - * // 'Complete!' - * ``` - * - * Use with condition, iterate and resultSelector functions - * - * ```ts - * import { generate } from 'rxjs'; - * - * const result = generate(0, x => x < 3, x => x + 1, x => x * 1000); - * - * result.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('Complete!') - * }); - * - * // Logs: - * // 0 - * // 1000 - * // 2000 - * // 'Complete!' - * ``` - * - * Use with options object - * - * ```ts - * import { generate } from 'rxjs'; - * - * const result = generate({ - * initialState: 0, - * condition(value) { return value < 3; }, - * iterate(value) { return value + 1; }, - * resultSelector(value) { return value * 1000; } - * }); - * - * result.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('Complete!') - * }); - * - * // Logs: - * // 0 - * // 1000 - * // 2000 - * // 'Complete!' - * ``` - * - * Use options object without condition function - * - * ```ts - * import { generate } from 'rxjs'; - * - * const result = generate({ - * initialState: 0, - * iterate(value) { return value + 1; }, - * resultSelector(value) { return value * 1000; } - * }); - * - * result.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('Complete!') // This will never run - * }); - * - * // Logs: - * // 0 - * // 1000 - * // 2000 - * // 3000 - * // ...and never stops. - * ``` - * - * @see {@link from} - * - * @param initialState Initial state. - * @param condition Condition to terminate generation (upon returning false). - * @param iterate Iteration step function. - * @param scheduler A {@link Scheduler} on which to run the generator loop. If not - * provided, defaults to emitting immediately. - * @return The generated sequence. - * @deprecated Instead of passing separate arguments, use the options argument. - * Signatures taking separate arguments will be removed in v8. - */ -export function generate<S>( - initialState: S, - condition: ConditionFunc<S>, - iterate: IterateFunc<S>, - scheduler?: SchedulerLike -): Observable<S>; - -/** - * Generates an observable sequence by running a state-driven loop - * producing the sequence's elements, using the specified scheduler - * to send out observer messages. - * The overload accepts options object that might contain initial state, iterate, - * condition and scheduler. - * - *  - * - * ## Examples - * - * Use options object with condition function - * - * ```ts - * import { generate } from 'rxjs'; - * - * const result = generate({ - * initialState: 0, - * condition: x => x < 3, - * iterate: x => x + 1 - * }); - * - * result.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('Complete!') - * }); - * - * // Logs: - * // 0 - * // 1 - * // 2 - * // 'Complete!' - * ``` - * - * @see {@link from} - * @see {@link Observable} - * - * @param options Object that must contain initialState, iterate and might contain condition and scheduler. - * @returns The generated sequence. - */ -export function generate<S>(options: GenerateBaseOptions<S>): Observable<S>; - -/** - * Generates an observable sequence by running a state-driven loop - * producing the sequence's elements, using the specified scheduler - * to send out observer messages. - * The overload accepts options object that might contain initial state, iterate, - * condition, result selector and scheduler. - * - *  - * - * ## Examples - * - * Use options object with condition and iterate function - * - * ```ts - * import { generate } from 'rxjs'; - * - * const result = generate({ - * initialState: 0, - * condition: x => x < 3, - * iterate: x => x + 1, - * resultSelector: x => x - * }); - * - * result.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('Complete!') - * }); - * - * // Logs: - * // 0 - * // 1 - * // 2 - * // 'Complete!' - * ``` - * - * @see {@link from} - * @see {@link Observable} - * - * @param options Object that must contain initialState, iterate, resultSelector and might contain condition and scheduler. - * @returns The generated sequence. - */ -export function generate<T, S>(options: GenerateOptions<T, S>): Observable<T>; - -export function generate<T, S>( - initialStateOrOptions: S | GenerateOptions<T, S>, - condition?: ConditionFunc<S>, - iterate?: IterateFunc<S>, - resultSelectorOrScheduler?: ResultFunc<S, T> | SchedulerLike, - scheduler?: SchedulerLike -): Observable<T> { - let resultSelector: ResultFunc<S, T>; - let initialState: S; - - // TODO: Remove this as we move away from deprecated signatures - // and move towards a configuration object argument. - if (arguments.length === 1) { - // If we only have one argument, we can assume it is a configuration object. - // Note that folks not using TypeScript may trip over this. - ({ - initialState, - condition, - iterate, - resultSelector = identity as ResultFunc<S, T>, - scheduler, - } = initialStateOrOptions as GenerateOptions<T, S>); - } else { - // Deprecated arguments path. Figure out what the user - // passed and set it here. - initialState = initialStateOrOptions as S; - if (!resultSelectorOrScheduler || isScheduler(resultSelectorOrScheduler)) { - resultSelector = identity as ResultFunc<S, T>; - scheduler = resultSelectorOrScheduler as SchedulerLike; - } else { - resultSelector = resultSelectorOrScheduler as ResultFunc<S, T>; - } - } - - // The actual generator used to "generate" values. - function* gen() { - for (let state = initialState; !condition || condition(state); state = iterate!(state)) { - yield resultSelector(state); - } - } - - // We use `defer` because we want to defer the creation of the iterator from the iterable. - return defer( - (scheduler - ? // If a scheduler was provided, use `scheduleIterable` to ensure that iteration/generation - // happens on the scheduler. - () => scheduleIterable(gen(), scheduler!) - : // Otherwise, if there's no scheduler, we can just use the generator function directly in - // `defer` and executing it will return the generator (which is iterable). - gen) as () => ObservableInput<T> - ); -} diff --git a/node_modules/rxjs/src/internal/observable/iif.ts b/node_modules/rxjs/src/internal/observable/iif.ts deleted file mode 100644 index d9ea9f1..0000000 --- a/node_modules/rxjs/src/internal/observable/iif.ts +++ /dev/null @@ -1,85 +0,0 @@ -import { Observable } from '../Observable'; -import { defer } from './defer'; -import { ObservableInput } from '../types'; - -/** - * Checks a boolean at subscription time, and chooses between one of two observable sources - * - * `iif` expects a function that returns a boolean (the `condition` function), and two sources, - * the `trueResult` and the `falseResult`, and returns an Observable. - * - * At the moment of subscription, the `condition` function is called. If the result is `true`, the - * subscription will be to the source passed as the `trueResult`, otherwise, the subscription will be - * to the source passed as the `falseResult`. - * - * If you need to check more than two options to choose between more than one observable, have a look at the {@link defer} creation method. - * - * ## Examples - * - * Change at runtime which Observable will be subscribed - * - * ```ts - * import { iif, of } from 'rxjs'; - * - * let subscribeToFirst; - * const firstOrSecond = iif( - * () => subscribeToFirst, - * of('first'), - * of('second') - * ); - * - * subscribeToFirst = true; - * firstOrSecond.subscribe(value => console.log(value)); - * - * // Logs: - * // 'first' - * - * subscribeToFirst = false; - * firstOrSecond.subscribe(value => console.log(value)); - * - * // Logs: - * // 'second' - * ``` - * - * Control access to an Observable - * - * ```ts - * import { iif, of, EMPTY } from 'rxjs'; - * - * let accessGranted; - * const observableIfYouHaveAccess = iif( - * () => accessGranted, - * of('It seems you have an access...'), - * EMPTY - * ); - * - * accessGranted = true; - * observableIfYouHaveAccess.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('The end') - * }); - * - * // Logs: - * // 'It seems you have an access...' - * // 'The end' - * - * accessGranted = false; - * observableIfYouHaveAccess.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('The end') - * }); - * - * // Logs: - * // 'The end' - * ``` - * - * @see {@link defer} - * - * @param condition Condition which Observable should be chosen. - * @param trueResult An Observable that will be subscribed if condition is true. - * @param falseResult An Observable that will be subscribed if condition is false. - * @return An observable that proxies to `trueResult` or `falseResult`, depending on the result of the `condition` function. - */ -export function iif<T, F>(condition: () => boolean, trueResult: ObservableInput<T>, falseResult: ObservableInput<F>): Observable<T | F> { - return defer(() => (condition() ? trueResult : falseResult)); -} diff --git a/node_modules/rxjs/src/internal/observable/innerFrom.ts b/node_modules/rxjs/src/internal/observable/innerFrom.ts deleted file mode 100644 index c3852c1..0000000 --- a/node_modules/rxjs/src/internal/observable/innerFrom.ts +++ /dev/null @@ -1,132 +0,0 @@ -import { isArrayLike } from '../util/isArrayLike'; -import { isPromise } from '../util/isPromise'; -import { Observable } from '../Observable'; -import { ObservableInput, ObservedValueOf, ReadableStreamLike } from '../types'; -import { isInteropObservable } from '../util/isInteropObservable'; -import { isAsyncIterable } from '../util/isAsyncIterable'; -import { createInvalidObservableTypeError } from '../util/throwUnobservableError'; -import { isIterable } from '../util/isIterable'; -import { isReadableStreamLike, readableStreamLikeToAsyncGenerator } from '../util/isReadableStreamLike'; -import { Subscriber } from '../Subscriber'; -import { isFunction } from '../util/isFunction'; -import { reportUnhandledError } from '../util/reportUnhandledError'; -import { observable as Symbol_observable } from '../symbol/observable'; - -export function innerFrom<O extends ObservableInput<any>>(input: O): Observable<ObservedValueOf<O>>; -export function innerFrom<T>(input: ObservableInput<T>): Observable<T> { - if (input instanceof Observable) { - return input; - } - if (input != null) { - if (isInteropObservable(input)) { - return fromInteropObservable(input); - } - if (isArrayLike(input)) { - return fromArrayLike(input); - } - if (isPromise(input)) { - return fromPromise(input); - } - if (isAsyncIterable(input)) { - return fromAsyncIterable(input); - } - if (isIterable(input)) { - return fromIterable(input); - } - if (isReadableStreamLike(input)) { - return fromReadableStreamLike(input); - } - } - - throw createInvalidObservableTypeError(input); -} - -/** - * Creates an RxJS Observable from an object that implements `Symbol.observable`. - * @param obj An object that properly implements `Symbol.observable`. - */ -export function fromInteropObservable<T>(obj: any) { - return new Observable((subscriber: Subscriber<T>) => { - const obs = obj[Symbol_observable](); - if (isFunction(obs.subscribe)) { - return obs.subscribe(subscriber); - } - // Should be caught by observable subscribe function error handling. - throw new TypeError('Provided object does not correctly implement Symbol.observable'); - }); -} - -/** - * Synchronously emits the values of an array like and completes. - * This is exported because there are creation functions and operators that need to - * make direct use of the same logic, and there's no reason to make them run through - * `from` conditionals because we *know* they're dealing with an array. - * @param array The array to emit values from - */ -export function fromArrayLike<T>(array: ArrayLike<T>) { - return new Observable((subscriber: Subscriber<T>) => { - // Loop over the array and emit each value. Note two things here: - // 1. We're making sure that the subscriber is not closed on each loop. - // This is so we don't continue looping over a very large array after - // something like a `take`, `takeWhile`, or other synchronous unsubscription - // has already unsubscribed. - // 2. In this form, reentrant code can alter that array we're looping over. - // This is a known issue, but considered an edge case. The alternative would - // be to copy the array before executing the loop, but this has - // performance implications. - for (let i = 0; i < array.length && !subscriber.closed; i++) { - subscriber.next(array[i]); - } - subscriber.complete(); - }); -} - -export function fromPromise<T>(promise: PromiseLike<T>) { - return new Observable((subscriber: Subscriber<T>) => { - promise - .then( - (value) => { - if (!subscriber.closed) { - subscriber.next(value); - subscriber.complete(); - } - }, - (err: any) => subscriber.error(err) - ) - .then(null, reportUnhandledError); - }); -} - -export function fromIterable<T>(iterable: Iterable<T>) { - return new Observable((subscriber: Subscriber<T>) => { - for (const value of iterable) { - subscriber.next(value); - if (subscriber.closed) { - return; - } - } - subscriber.complete(); - }); -} - -export function fromAsyncIterable<T>(asyncIterable: AsyncIterable<T>) { - return new Observable((subscriber: Subscriber<T>) => { - process(asyncIterable, subscriber).catch((err) => subscriber.error(err)); - }); -} - -export function fromReadableStreamLike<T>(readableStream: ReadableStreamLike<T>) { - return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream)); -} - -async function process<T>(asyncIterable: AsyncIterable<T>, subscriber: Subscriber<T>) { - for await (const value of asyncIterable) { - subscriber.next(value); - // A side-effect may have closed our subscriber, - // check before the next iteration. - if (subscriber.closed) { - return; - } - } - subscriber.complete(); -} diff --git a/node_modules/rxjs/src/internal/observable/interval.ts b/node_modules/rxjs/src/internal/observable/interval.ts deleted file mode 100644 index a21809b..0000000 --- a/node_modules/rxjs/src/internal/observable/interval.ts +++ /dev/null @@ -1,57 +0,0 @@ -import { Observable } from '../Observable'; -import { asyncScheduler } from '../scheduler/async'; -import { SchedulerLike } from '../types'; -import { timer } from './timer'; - -/** - * Creates an Observable that emits sequential numbers every specified - * interval of time, on a specified {@link SchedulerLike}. - * - * <span class="informal">Emits incremental numbers periodically in time.</span> - * - *  - * - * `interval` returns an Observable that emits an infinite sequence of - * ascending integers, with a constant interval of time of your choosing - * between those emissions. The first emission is not sent immediately, but - * only after the first period has passed. By default, this operator uses the - * `async` {@link SchedulerLike} to provide a notion of time, but you may pass any - * {@link SchedulerLike} to it. - * - * ## Example - * - * Emits ascending numbers, one every second (1000ms) up to the number 3 - * - * ```ts - * import { interval, take } from 'rxjs'; - * - * const numbers = interval(1000); - * - * const takeFourNumbers = numbers.pipe(take(4)); - * - * takeFourNumbers.subscribe(x => console.log('Next: ', x)); - * - * // Logs: - * // Next: 0 - * // Next: 1 - * // Next: 2 - * // Next: 3 - * ``` - * - * @see {@link timer} - * @see {@link delay} - * - * @param period The interval size in milliseconds (by default) or the time unit determined - * by the scheduler's clock. - * @param scheduler The {@link SchedulerLike} to use for scheduling the emission of values, - * and providing a notion of "time". - * @return An Observable that emits a sequential number each time interval. - */ -export function interval(period = 0, scheduler: SchedulerLike = asyncScheduler): Observable<number> { - if (period < 0) { - // We cannot schedule an interval in the past. - period = 0; - } - - return timer(period, period, scheduler); -} diff --git a/node_modules/rxjs/src/internal/observable/merge.ts b/node_modules/rxjs/src/internal/observable/merge.ts deleted file mode 100644 index de8ac13..0000000 --- a/node_modules/rxjs/src/internal/observable/merge.ts +++ /dev/null @@ -1,100 +0,0 @@ -import { Observable } from '../Observable'; -import { ObservableInput, ObservableInputTuple, SchedulerLike } from '../types'; -import { mergeAll } from '../operators/mergeAll'; -import { innerFrom } from './innerFrom'; -import { EMPTY } from './empty'; -import { popNumber, popScheduler } from '../util/args'; -import { from } from './from'; - -export function merge<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A[number]>; -export function merge<A extends readonly unknown[]>(...sourcesAndConcurrency: [...ObservableInputTuple<A>, number?]): Observable<A[number]>; -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `mergeAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function merge<A extends readonly unknown[]>( - ...sourcesAndScheduler: [...ObservableInputTuple<A>, SchedulerLike?] -): Observable<A[number]>; -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `mergeAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function merge<A extends readonly unknown[]>( - ...sourcesAndConcurrencyAndScheduler: [...ObservableInputTuple<A>, number?, SchedulerLike?] -): Observable<A[number]>; - -/** - * Creates an output Observable which concurrently emits all values from every - * given input Observable. - * - * <span class="informal">Flattens multiple Observables together by blending - * their values into one Observable.</span> - * - *  - * - * `merge` subscribes to each given input Observable (as arguments), and simply - * forwards (without doing any transformation) all the values from all the input - * Observables to the output Observable. The output Observable only completes - * once all input Observables have completed. Any error delivered by an input - * Observable will be immediately emitted on the output Observable. - * - * ## Examples - * - * Merge together two Observables: 1s interval and clicks - * - * ```ts - * import { merge, fromEvent, interval } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const timer = interval(1000); - * const clicksOrTimer = merge(clicks, timer); - * clicksOrTimer.subscribe(x => console.log(x)); - * - * // Results in the following: - * // timer will emit ascending values, one every second(1000ms) to console - * // clicks logs MouseEvents to console every time the "document" is clicked - * // Since the two streams are merged you see these happening - * // as they occur. - * ``` - * - * Merge together 3 Observables, but run only 2 concurrently - * - * ```ts - * import { interval, take, merge } from 'rxjs'; - * - * const timer1 = interval(1000).pipe(take(10)); - * const timer2 = interval(2000).pipe(take(6)); - * const timer3 = interval(500).pipe(take(10)); - * - * const concurrent = 2; // the argument - * const merged = merge(timer1, timer2, timer3, concurrent); - * merged.subscribe(x => console.log(x)); - * - * // Results in the following: - * // - First timer1 and timer2 will run concurrently - * // - timer1 will emit a value every 1000ms for 10 iterations - * // - timer2 will emit a value every 2000ms for 6 iterations - * // - after timer1 hits its max iteration, timer2 will - * // continue, and timer3 will start to run concurrently with timer2 - * // - when timer2 hits its max iteration it terminates, and - * // timer3 will continue to emit a value every 500ms until it is complete - * ``` - * - * @see {@link mergeAll} - * @see {@link mergeMap} - * @see {@link mergeMapTo} - * @see {@link mergeScan} - * - * @param args `ObservableInput`s to merge together. If the last parameter - * is of type number, `merge` will use it to limit number of concurrently - * subscribed `ObservableInput`s. If the last parameter is {@link SchedulerLike}, - * it will be used for scheduling the emission of values. - * @return An Observable that emits items that are the result of every input Observable. - */ -export function merge(...args: (ObservableInput<unknown> | number | SchedulerLike)[]): Observable<unknown> { - const scheduler = popScheduler(args); - const concurrent = popNumber(args, Infinity); - const sources = args as ObservableInput<unknown>[]; - return !sources.length - ? // No source provided - EMPTY - : sources.length === 1 - ? // One source? Just return it. - innerFrom(sources[0]) - : // Merge all sources - mergeAll(concurrent)(from(sources, scheduler)); -} diff --git a/node_modules/rxjs/src/internal/observable/never.ts b/node_modules/rxjs/src/internal/observable/never.ts deleted file mode 100644 index cfbec7d..0000000 --- a/node_modules/rxjs/src/internal/observable/never.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { Observable } from '../Observable'; -import { noop } from '../util/noop'; - -/** - * An Observable that emits no items to the Observer and never completes. - * - *  - * - * A simple Observable that emits neither values nor errors nor the completion - * notification. It can be used for testing purposes or for composing with other - * Observables. Please note that by never emitting a complete notification, this - * Observable keeps the subscription from being disposed automatically. - * Subscriptions need to be manually disposed. - * - * ## Example - * - * Emit the number 7, then never emit anything else (not even complete) - * - * ```ts - * import { NEVER, startWith } from 'rxjs'; - * - * const info = () => console.log('Will not be called'); - * - * const result = NEVER.pipe(startWith(7)); - * result.subscribe({ - * next: x => console.log(x), - * error: info, - * complete: info - * }); - * ``` - * - * @see {@link Observable} - * @see {@link EMPTY} - * @see {@link of} - * @see {@link throwError} - */ -export const NEVER = new Observable<never>(noop); - -/** - * @deprecated Replaced with the {@link NEVER} constant. Will be removed in v8. - */ -export function never() { - return NEVER; -} diff --git a/node_modules/rxjs/src/internal/observable/of.ts b/node_modules/rxjs/src/internal/observable/of.ts deleted file mode 100644 index a1c9357..0000000 --- a/node_modules/rxjs/src/internal/observable/of.ts +++ /dev/null @@ -1,83 +0,0 @@ -import { SchedulerLike, ValueFromArray } from '../types'; -import { Observable } from '../Observable'; -import { popScheduler } from '../util/args'; -import { from } from './from'; - -// Devs are more likely to pass null or undefined than they are a scheduler -// without accompanying values. To make things easier for (naughty) devs who -// use the `strictNullChecks: false` TypeScript compiler option, these -// overloads with explicit null and undefined values are included. - -export function of(value: null): Observable<null>; -export function of(value: undefined): Observable<undefined>; - -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function of(scheduler: SchedulerLike): Observable<never>; -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function of<A extends readonly unknown[]>(...valuesAndScheduler: [...A, SchedulerLike]): Observable<ValueFromArray<A>>; - -export function of(): Observable<never>; -/** @deprecated Do not specify explicit type parameters. Signatures with type parameters that cannot be inferred will be removed in v8. */ -export function of<T>(): Observable<T>; -export function of<T>(value: T): Observable<T>; -export function of<A extends readonly unknown[]>(...values: A): Observable<ValueFromArray<A>>; - -/** - * Converts the arguments to an observable sequence. - * - * <span class="informal">Each argument becomes a `next` notification.</span> - * - *  - * - * Unlike {@link from}, it does not do any flattening and emits each argument in whole - * as a separate `next` notification. - * - * ## Examples - * - * Emit the values `10, 20, 30` - * - * ```ts - * import { of } from 'rxjs'; - * - * of(10, 20, 30) - * .subscribe({ - * next: value => console.log('next:', value), - * error: err => console.log('error:', err), - * complete: () => console.log('the end'), - * }); - * - * // Outputs - * // next: 10 - * // next: 20 - * // next: 30 - * // the end - * ``` - * - * Emit the array `[1, 2, 3]` - * - * ```ts - * import { of } from 'rxjs'; - * - * of([1, 2, 3]) - * .subscribe({ - * next: value => console.log('next:', value), - * error: err => console.log('error:', err), - * complete: () => console.log('the end'), - * }); - * - * // Outputs - * // next: [1, 2, 3] - * // the end - * ``` - * - * @see {@link from} - * @see {@link range} - * - * @param args A comma separated list of arguments you want to be emitted. - * @return An Observable that synchronously emits the arguments described - * above and then immediately completes. - */ -export function of<T>(...args: Array<T | SchedulerLike>): Observable<T> { - const scheduler = popScheduler(args); - return from(args as T[], scheduler); -} diff --git a/node_modules/rxjs/src/internal/observable/onErrorResumeNext.ts b/node_modules/rxjs/src/internal/observable/onErrorResumeNext.ts deleted file mode 100644 index d2133ea..0000000 --- a/node_modules/rxjs/src/internal/observable/onErrorResumeNext.ts +++ /dev/null @@ -1,98 +0,0 @@ -import { Observable } from '../Observable'; -import { ObservableInputTuple } from '../types'; -import { argsOrArgArray } from '../util/argsOrArgArray'; -import { OperatorSubscriber } from '../operators/OperatorSubscriber'; -import { noop } from '../util/noop'; -import { innerFrom } from './innerFrom'; - -export function onErrorResumeNext<A extends readonly unknown[]>(sources: [...ObservableInputTuple<A>]): Observable<A[number]>; -export function onErrorResumeNext<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A[number]>; - -/** - * When any of the provided Observable emits a complete or an error notification, it immediately subscribes to the next one - * that was passed. - * - * <span class="informal">Execute series of Observables no matter what, even if it means swallowing errors.</span> - * - *  - * - * `onErrorResumeNext` will subscribe to each observable source it is provided, in order. - * If the source it's subscribed to emits an error or completes, it will move to the next source - * without error. - * - * If `onErrorResumeNext` is provided no arguments, or a single, empty array, it will return {@link EMPTY}. - * - * `onErrorResumeNext` is basically {@link concat}, only it will continue, even if one of its - * sources emits an error. - * - * Note that there is no way to handle any errors thrown by sources via the result of - * `onErrorResumeNext`. If you want to handle errors thrown in any given source, you can - * always use the {@link catchError} operator on them before passing them into `onErrorResumeNext`. - * - * ## Example - * - * Subscribe to the next Observable after map fails - * - * ```ts - * import { onErrorResumeNext, of, map } from 'rxjs'; - * - * onErrorResumeNext( - * of(1, 2, 3, 0).pipe( - * map(x => { - * if (x === 0) { - * throw Error(); - * } - * return 10 / x; - * }) - * ), - * of(1, 2, 3) - * ) - * .subscribe({ - * next: value => console.log(value), - * error: err => console.log(err), // Will never be called. - * complete: () => console.log('done') - * }); - * - * // Logs: - * // 10 - * // 5 - * // 3.3333333333333335 - * // 1 - * // 2 - * // 3 - * // 'done' - * ``` - * - * @see {@link concat} - * @see {@link catchError} - * - * @param sources `ObservableInput`s passed either directly or as an array. - * @return An Observable that concatenates all sources, one after the other, - * ignoring all errors, such that any error causes it to move on to the next source. - */ -export function onErrorResumeNext<A extends readonly unknown[]>( - ...sources: [[...ObservableInputTuple<A>]] | [...ObservableInputTuple<A>] -): Observable<A[number]> { - const nextSources: ObservableInputTuple<A> = argsOrArgArray(sources) as any; - - return new Observable((subscriber) => { - let sourceIndex = 0; - const subscribeNext = () => { - if (sourceIndex < nextSources.length) { - let nextSource: Observable<A[number]>; - try { - nextSource = innerFrom(nextSources[sourceIndex++]); - } catch (err) { - subscribeNext(); - return; - } - const innerSubscriber = new OperatorSubscriber(subscriber, undefined, noop, noop); - nextSource.subscribe(innerSubscriber); - innerSubscriber.add(subscribeNext); - } else { - subscriber.complete(); - } - }; - subscribeNext(); - }); -} diff --git a/node_modules/rxjs/src/internal/observable/pairs.ts b/node_modules/rxjs/src/internal/observable/pairs.ts deleted file mode 100644 index ca4d7f0..0000000 --- a/node_modules/rxjs/src/internal/observable/pairs.ts +++ /dev/null @@ -1,80 +0,0 @@ -import { Observable } from '../Observable'; -import { SchedulerLike } from '../types'; -import { from } from './from'; - -/** - * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8. - */ -export function pairs<T>(arr: readonly T[], scheduler?: SchedulerLike): Observable<[string, T]>; -/** - * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8. - */ -export function pairs<O extends Record<string, unknown>>(obj: O, scheduler?: SchedulerLike): Observable<[keyof O, O[keyof O]]>; -/** - * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8. - */ -export function pairs<T>(iterable: Iterable<T>, scheduler?: SchedulerLike): Observable<[string, T]>; -/** - * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8. - */ -export function pairs( - n: number | bigint | boolean | ((...args: any[]) => any) | symbol, - scheduler?: SchedulerLike -): Observable<[never, never]>; - -/** - * Convert an object into an Observable of `[key, value]` pairs. - * - * <span class="informal">Turn entries of an object into a stream.</span> - * - *  - * - * `pairs` takes an arbitrary object and returns an Observable that emits arrays. Each - * emitted array has exactly two elements - the first is a key from the object - * and the second is a value corresponding to that key. Keys are extracted from - * an object via `Object.keys` function, which means that they will be only - * enumerable keys that are present on an object directly - not ones inherited - * via prototype chain. - * - * By default, these arrays are emitted synchronously. To change that you can - * pass a {@link SchedulerLike} as a second argument to `pairs`. - * - * ## Example - * - * Converts an object to an Observable - * - * ```ts - * import { pairs } from 'rxjs'; - * - * const obj = { - * foo: 42, - * bar: 56, - * baz: 78 - * }; - * - * pairs(obj).subscribe({ - * next: value => console.log(value), - * complete: () => console.log('Complete!') - * }); - * - * // Logs: - * // ['foo', 42] - * // ['bar', 56] - * // ['baz', 78] - * // 'Complete!' - * ``` - * - * ### Object.entries required - * - * In IE, you will need to polyfill `Object.entries` in order to use this. - * [MDN has a polyfill here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries) - * - * @param obj The object to inspect and turn into an Observable sequence. - * @param scheduler An optional IScheduler to schedule when resulting - * Observable will emit values. - * @returns An observable sequence of [key, value] pairs from the object. - * @deprecated Use `from(Object.entries(obj))` instead. Will be removed in v8. - */ -export function pairs(obj: any, scheduler?: SchedulerLike) { - return from(Object.entries(obj), scheduler as any); -} diff --git a/node_modules/rxjs/src/internal/observable/partition.ts b/node_modules/rxjs/src/internal/observable/partition.ts deleted file mode 100644 index 34a61a1..0000000 --- a/node_modules/rxjs/src/internal/observable/partition.ts +++ /dev/null @@ -1,88 +0,0 @@ -import { not } from '../util/not'; -import { filter } from '../operators/filter'; -import { ObservableInput } from '../types'; -import { Observable } from '../Observable'; -import { innerFrom } from './innerFrom'; - -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function partition<T, U extends T, A>( - source: ObservableInput<T>, - predicate: (this: A, value: T, index: number) => value is U, - thisArg: A -): [Observable<U>, Observable<Exclude<T, U>>]; -export function partition<T, U extends T>( - source: ObservableInput<T>, - predicate: (value: T, index: number) => value is U -): [Observable<U>, Observable<Exclude<T, U>>]; - -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function partition<T, A>( - source: ObservableInput<T>, - predicate: (this: A, value: T, index: number) => boolean, - thisArg: A -): [Observable<T>, Observable<T>]; -export function partition<T>(source: ObservableInput<T>, predicate: (value: T, index: number) => boolean): [Observable<T>, Observable<T>]; - -/** - * Splits the source Observable into two, one with values that satisfy a - * predicate, and another with values that don't satisfy the predicate. - * - * <span class="informal">It's like {@link filter}, but returns two Observables: - * one like the output of {@link filter}, and the other with values that did not - * pass the condition.</span> - * - *  - * - * `partition` outputs an array with two Observables that partition the values - * from the source Observable through the given `predicate` function. The first - * Observable in that array emits source values for which the predicate argument - * returns true. The second Observable emits source values for which the - * predicate returns false. The first behaves like {@link filter} and the second - * behaves like {@link filter} with the predicate negated. - * - * ## Example - * - * Partition a set of numbers into odds and evens observables - * - * ```ts - * import { of, partition } from 'rxjs'; - * - * const observableValues = of(1, 2, 3, 4, 5, 6); - * const [evens$, odds$] = partition(observableValues, value => value % 2 === 0); - * - * odds$.subscribe(x => console.log('odds', x)); - * evens$.subscribe(x => console.log('evens', x)); - * - * // Logs: - * // odds 1 - * // odds 3 - * // odds 5 - * // evens 2 - * // evens 4 - * // evens 6 - * ``` - * - * @see {@link filter} - * - * @param source The source `ObservableInput` that will be split into a tuple of - * two Observable elements. - * @param predicate A function that evaluates each value emitted by the source - * Observable. If it returns `true`, the value is emitted on the first Observable - * in the returned array, if `false` the value is emitted on the second Observable - * in the array. The `index` parameter is the number `i` for the i-th source - * emission that has happened since the subscription, starting from the number `0`. - * @param thisArg An optional argument to determine the value of `this` in the - * `predicate` function. - * @return An array with two Observables: one with values that passed the - * predicate, and another with values that did not pass the predicate. - */ -export function partition<T>( - source: ObservableInput<T>, - predicate: (this: any, value: T, index: number) => boolean, - thisArg?: any -): [Observable<T>, Observable<T>] { - return [filter(predicate, thisArg)(innerFrom(source)), filter(not(predicate, thisArg))(innerFrom(source))] as [ - Observable<T>, - Observable<T> - ]; -} diff --git a/node_modules/rxjs/src/internal/observable/race.ts b/node_modules/rxjs/src/internal/observable/race.ts deleted file mode 100644 index d87293f..0000000 --- a/node_modules/rxjs/src/internal/observable/race.ts +++ /dev/null @@ -1,88 +0,0 @@ -import { Observable } from '../Observable'; -import { innerFrom } from './innerFrom'; -import { Subscription } from '../Subscription'; -import { ObservableInput, ObservableInputTuple } from '../types'; -import { argsOrArgArray } from '../util/argsOrArgArray'; -import { createOperatorSubscriber } from '../operators/OperatorSubscriber'; -import { Subscriber } from '../Subscriber'; - -export function race<T extends readonly unknown[]>(inputs: [...ObservableInputTuple<T>]): Observable<T[number]>; -export function race<T extends readonly unknown[]>(...inputs: [...ObservableInputTuple<T>]): Observable<T[number]>; - -/** - * Returns an observable that mirrors the first source observable to emit an item. - * - *  - * - * `race` returns an observable, that when subscribed to, subscribes to all source observables immediately. - * As soon as one of the source observables emits a value, the result unsubscribes from the other sources. - * The resulting observable will forward all notifications, including error and completion, from the "winning" - * source observable. - * - * If one of the used source observable throws an errors before a first notification - * the race operator will also throw an error, no matter if another source observable - * could potentially win the race. - * - * `race` can be useful for selecting the response from the fastest network connection for - * HTTP or WebSockets. `race` can also be useful for switching observable context based on user - * input. - * - * ## Example - * - * Subscribes to the observable that was the first to start emitting. - * - * ```ts - * import { interval, map, race } from 'rxjs'; - * - * const obs1 = interval(7000).pipe(map(() => 'slow one')); - * const obs2 = interval(3000).pipe(map(() => 'fast one')); - * const obs3 = interval(5000).pipe(map(() => 'medium one')); - * - * race(obs1, obs2, obs3) - * .subscribe(winner => console.log(winner)); - * - * // Outputs - * // a series of 'fast one' - * ``` - * - * @param sources Used to race for which `ObservableInput` emits first. - * @return An Observable that mirrors the output of the first Observable to emit an item. - */ -export function race<T>(...sources: (ObservableInput<T> | ObservableInput<T>[])[]): Observable<any> { - sources = argsOrArgArray(sources); - // If only one source was passed, just return it. Otherwise return the race. - return sources.length === 1 ? innerFrom(sources[0] as ObservableInput<T>) : new Observable<T>(raceInit(sources as ObservableInput<T>[])); -} - -/** - * An observable initializer function for both the static version and the - * operator version of race. - * @param sources The sources to race - */ -export function raceInit<T>(sources: ObservableInput<T>[]) { - return (subscriber: Subscriber<T>) => { - let subscriptions: Subscription[] = []; - - // Subscribe to all of the sources. Note that we are checking `subscriptions` here - // Is is an array of all actively "racing" subscriptions, and it is `null` after the - // race has been won. So, if we have racer that synchronously "wins", this loop will - // stop before it subscribes to any more. - for (let i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) { - subscriptions.push( - innerFrom(sources[i] as ObservableInput<T>).subscribe( - createOperatorSubscriber(subscriber, (value) => { - if (subscriptions) { - // We're still racing, but we won! So unsubscribe - // all other subscriptions that we have, except this one. - for (let s = 0; s < subscriptions.length; s++) { - s !== i && subscriptions[s].unsubscribe(); - } - subscriptions = null!; - } - subscriber.next(value); - }) - ) - ); - } - }; -} diff --git a/node_modules/rxjs/src/internal/observable/range.ts b/node_modules/rxjs/src/internal/observable/range.ts deleted file mode 100644 index cfc82cf..0000000 --- a/node_modules/rxjs/src/internal/observable/range.ts +++ /dev/null @@ -1,93 +0,0 @@ -import { SchedulerLike } from '../types'; -import { Observable } from '../Observable'; -import { EMPTY } from './empty'; - -export function range(start: number, count?: number): Observable<number>; - -/** - * @deprecated The `scheduler` parameter will be removed in v8. Use `range(start, count).pipe(observeOn(scheduler))` instead. Details: Details: https://rxjs.dev/deprecations/scheduler-argument - */ -export function range(start: number, count: number | undefined, scheduler: SchedulerLike): Observable<number>; - -/** - * Creates an Observable that emits a sequence of numbers within a specified - * range. - * - * <span class="informal">Emits a sequence of numbers in a range.</span> - * - *  - * - * `range` operator emits a range of sequential integers, in order, where you - * select the `start` of the range and its `length`. By default, uses no - * {@link SchedulerLike} and just delivers the notifications synchronously, but may use - * an optional {@link SchedulerLike} to regulate those deliveries. - * - * ## Example - * - * Produce a range of numbers - * - * ```ts - * import { range } from 'rxjs'; - * - * const numbers = range(1, 3); - * - * numbers.subscribe({ - * next: value => console.log(value), - * complete: () => console.log('Complete!') - * }); - * - * // Logs: - * // 1 - * // 2 - * // 3 - * // 'Complete!' - * ``` - * - * @see {@link timer} - * @see {@link interval} - * - * @param start The value of the first integer in the sequence. - * @param count The number of sequential integers to generate. - * @param scheduler A {@link SchedulerLike} to use for scheduling the emissions - * of the notifications. - * @return An Observable of numbers that emits a finite range of sequential integers. - */ -export function range(start: number, count?: number, scheduler?: SchedulerLike): Observable<number> { - if (count == null) { - // If one argument was passed, it's the count, not the start. - count = start; - start = 0; - } - - if (count <= 0) { - // No count? We're going nowhere. Return EMPTY. - return EMPTY; - } - - // Where the range should stop. - const end = count + start; - - return new Observable( - scheduler - ? // The deprecated scheduled path. - (subscriber) => { - let n = start; - return scheduler.schedule(function () { - if (n < end) { - subscriber.next(n++); - this.schedule(); - } else { - subscriber.complete(); - } - }); - } - : // Standard synchronous range. - (subscriber) => { - let n = start; - while (n < end && !subscriber.closed) { - subscriber.next(n++); - } - subscriber.complete(); - } - ); -} diff --git a/node_modules/rxjs/src/internal/observable/throwError.ts b/node_modules/rxjs/src/internal/observable/throwError.ts deleted file mode 100644 index a307f5a..0000000 --- a/node_modules/rxjs/src/internal/observable/throwError.ts +++ /dev/null @@ -1,125 +0,0 @@ -import { Observable } from '../Observable'; -import { Subscriber } from '../Subscriber'; -import { SchedulerLike } from '../types'; -import { isFunction } from '../util/isFunction'; - -/** - * Creates an observable that will create an error instance and push it to the consumer as an error - * immediately upon subscription. - * - * <span class="informal">Just errors and does nothing else</span> - * - *  - * - * This creation function is useful for creating an observable that will create an error and error every - * time it is subscribed to. Generally, inside of most operators when you might want to return an errored - * observable, this is unnecessary. In most cases, such as in the inner return of {@link concatMap}, - * {@link mergeMap}, {@link defer}, and many others, you can simply throw the error, and RxJS will pick - * that up and notify the consumer of the error. - * - * ## Example - * - * Create a simple observable that will create a new error with a timestamp and log it - * and the message every time you subscribe to it - * - * ```ts - * import { throwError } from 'rxjs'; - * - * let errorCount = 0; - * - * const errorWithTimestamp$ = throwError(() => { - * const error: any = new Error(`This is error number ${ ++errorCount }`); - * error.timestamp = Date.now(); - * return error; - * }); - * - * errorWithTimestamp$.subscribe({ - * error: err => console.log(err.timestamp, err.message) - * }); - * - * errorWithTimestamp$.subscribe({ - * error: err => console.log(err.timestamp, err.message) - * }); - * - * // Logs the timestamp and a new error message for each subscription - * ``` - * - * ### Unnecessary usage - * - * Using `throwError` inside of an operator or creation function - * with a callback, is usually not necessary - * - * ```ts - * import { of, concatMap, timer, throwError } from 'rxjs'; - * - * const delays$ = of(1000, 2000, Infinity, 3000); - * - * delays$.pipe( - * concatMap(ms => { - * if (ms < 10000) { - * return timer(ms); - * } else { - * // This is probably overkill. - * return throwError(() => new Error(`Invalid time ${ ms }`)); - * } - * }) - * ) - * .subscribe({ - * next: console.log, - * error: console.error - * }); - * ``` - * - * You can just throw the error instead - * - * ```ts - * import { of, concatMap, timer } from 'rxjs'; - * - * const delays$ = of(1000, 2000, Infinity, 3000); - * - * delays$.pipe( - * concatMap(ms => { - * if (ms < 10000) { - * return timer(ms); - * } else { - * // Cleaner and easier to read for most folks. - * throw new Error(`Invalid time ${ ms }`); - * } - * }) - * ) - * .subscribe({ - * next: console.log, - * error: console.error - * }); - * ``` - * - * @param errorFactory A factory function that will create the error instance that is pushed. - */ -export function throwError(errorFactory: () => any): Observable<never>; - -/** - * Returns an observable that will error with the specified error immediately upon subscription. - * - * @param error The error instance to emit - * @deprecated Support for passing an error value will be removed in v8. Instead, pass a factory function to `throwError(() => new Error('test'))`. This is - * because it will create the error at the moment it should be created and capture a more appropriate stack trace. If - * for some reason you need to create the error ahead of time, you can still do that: `const err = new Error('test'); throwError(() => err);`. - */ -export function throwError(error: any): Observable<never>; - -/** - * Notifies the consumer of an error using a given scheduler by scheduling it at delay `0` upon subscription. - * - * @param errorOrErrorFactory An error instance or error factory - * @param scheduler A scheduler to use to schedule the error notification - * @deprecated The `scheduler` parameter will be removed in v8. - * Use `throwError` in combination with {@link observeOn}: `throwError(() => new Error('test')).pipe(observeOn(scheduler));`. - * Details: https://rxjs.dev/deprecations/scheduler-argument - */ -export function throwError(errorOrErrorFactory: any, scheduler: SchedulerLike): Observable<never>; - -export function throwError(errorOrErrorFactory: any, scheduler?: SchedulerLike): Observable<never> { - const errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : () => errorOrErrorFactory; - const init = (subscriber: Subscriber<never>) => subscriber.error(errorFactory()); - return new Observable(scheduler ? (subscriber) => scheduler.schedule(init as any, 0, subscriber) : init); -} diff --git a/node_modules/rxjs/src/internal/observable/timer.ts b/node_modules/rxjs/src/internal/observable/timer.ts deleted file mode 100644 index dcc2745..0000000 --- a/node_modules/rxjs/src/internal/observable/timer.ts +++ /dev/null @@ -1,186 +0,0 @@ -import { Observable } from '../Observable'; -import { SchedulerLike } from '../types'; -import { async as asyncScheduler } from '../scheduler/async'; -import { isScheduler } from '../util/isScheduler'; -import { isValidDate } from '../util/isDate'; - -/** - * Creates an observable that will wait for a specified time period, or exact date, before - * emitting the number 0. - * - * <span class="informal">Used to emit a notification after a delay.</span> - * - * This observable is useful for creating delays in code, or racing against other values - * for ad-hoc timeouts. - * - * The `delay` is specified by default in milliseconds, however providing a custom scheduler could - * create a different behavior. - * - * ## Examples - * - * Wait 3 seconds and start another observable - * - * You might want to use `timer` to delay subscription to an - * observable by a set amount of time. Here we use a timer with - * {@link concatMapTo} or {@link concatMap} in order to wait - * a few seconds and start a subscription to a source. - * - * ```ts - * import { of, timer, concatMap } from 'rxjs'; - * - * // This could be any observable - * const source = of(1, 2, 3); - * - * timer(3000) - * .pipe(concatMap(() => source)) - * .subscribe(console.log); - * ``` - * - * Take all values until the start of the next minute - * - * Using a `Date` as the trigger for the first emission, you can - * do things like wait until midnight to fire an event, or in this case, - * wait until a new minute starts (chosen so the example wouldn't take - * too long to run) in order to stop watching a stream. Leveraging - * {@link takeUntil}. - * - * ```ts - * import { interval, takeUntil, timer } from 'rxjs'; - * - * // Build a Date object that marks the - * // next minute. - * const currentDate = new Date(); - * const startOfNextMinute = new Date( - * currentDate.getFullYear(), - * currentDate.getMonth(), - * currentDate.getDate(), - * currentDate.getHours(), - * currentDate.getMinutes() + 1 - * ); - * - * // This could be any observable stream - * const source = interval(1000); - * - * const result = source.pipe( - * takeUntil(timer(startOfNextMinute)) - * ); - * - * result.subscribe(console.log); - * ``` - * - * ### Known Limitations - * - * - The {@link asyncScheduler} uses `setTimeout` which has limitations for how far in the future it can be scheduled. - * - * - If a `scheduler` is provided that returns a timestamp other than an epoch from `now()`, and - * a `Date` object is passed to the `dueTime` argument, the calculation for when the first emission - * should occur will be incorrect. In this case, it would be best to do your own calculations - * ahead of time, and pass a `number` in as the `dueTime`. - * - * @param due If a `number`, the amount of time in milliseconds to wait before emitting. - * If a `Date`, the exact time at which to emit. - * @param scheduler The scheduler to use to schedule the delay. Defaults to {@link asyncScheduler}. - */ -export function timer(due: number | Date, scheduler?: SchedulerLike): Observable<0>; - -/** - * Creates an observable that starts an interval after a specified delay, emitting incrementing numbers -- starting at `0` -- - * on each interval after words. - * - * The `delay` and `intervalDuration` are specified by default in milliseconds, however providing a custom scheduler could - * create a different behavior. - * - * ## Example - * - * ### Start an interval that starts right away - * - * Since {@link interval} waits for the passed delay before starting, - * sometimes that's not ideal. You may want to start an interval immediately. - * `timer` works well for this. Here we have both side-by-side so you can - * see them in comparison. - * - * Note that this observable will never complete. - * - * ```ts - * import { timer, interval } from 'rxjs'; - * - * timer(0, 1000).subscribe(n => console.log('timer', n)); - * interval(1000).subscribe(n => console.log('interval', n)); - * ``` - * - * ### Known Limitations - * - * - The {@link asyncScheduler} uses `setTimeout` which has limitations for how far in the future it can be scheduled. - * - * - If a `scheduler` is provided that returns a timestamp other than an epoch from `now()`, and - * a `Date` object is passed to the `dueTime` argument, the calculation for when the first emission - * should occur will be incorrect. In this case, it would be best to do your own calculations - * ahead of time, and pass a `number` in as the `startDue`. - * @param startDue If a `number`, is the time to wait before starting the interval. - * If a `Date`, is the exact time at which to start the interval. - * @param intervalDuration The delay between each value emitted in the interval. Passing a - * negative number here will result in immediate completion after the first value is emitted, as though - * no `intervalDuration` was passed at all. - * @param scheduler The scheduler to use to schedule the delay. Defaults to {@link asyncScheduler}. - */ -export function timer(startDue: number | Date, intervalDuration: number, scheduler?: SchedulerLike): Observable<number>; - -/** - * @deprecated The signature allowing `undefined` to be passed for `intervalDuration` will be removed in v8. Use the `timer(dueTime, scheduler?)` signature instead. - */ -export function timer(dueTime: number | Date, unused: undefined, scheduler?: SchedulerLike): Observable<0>; - -export function timer( - dueTime: number | Date = 0, - intervalOrScheduler?: number | SchedulerLike, - scheduler: SchedulerLike = asyncScheduler -): Observable<number> { - // Since negative intervalDuration is treated as though no - // interval was specified at all, we start with a negative number. - let intervalDuration = -1; - - if (intervalOrScheduler != null) { - // If we have a second argument, and it's a scheduler, - // override the scheduler we had defaulted. Otherwise, - // it must be an interval. - if (isScheduler(intervalOrScheduler)) { - scheduler = intervalOrScheduler; - } else { - // Note that this *could* be negative, in which case - // it's like not passing an intervalDuration at all. - intervalDuration = intervalOrScheduler; - } - } - - return new Observable((subscriber) => { - // If a valid date is passed, calculate how long to wait before - // executing the first value... otherwise, if it's a number just schedule - // that many milliseconds (or scheduler-specified unit size) in the future. - let due = isValidDate(dueTime) ? +dueTime - scheduler!.now() : dueTime; - - if (due < 0) { - // Ensure we don't schedule in the future. - due = 0; - } - - // The incrementing value we emit. - let n = 0; - - // Start the timer. - return scheduler.schedule(function () { - if (!subscriber.closed) { - // Emit the next value and increment. - subscriber.next(n++); - - if (0 <= intervalDuration) { - // If we have a interval after the initial timer, - // reschedule with the period. - this.schedule(undefined, intervalDuration); - } else { - // We didn't have an interval. So just complete. - subscriber.complete(); - } - } - }, due); - }); -} diff --git a/node_modules/rxjs/src/internal/observable/using.ts b/node_modules/rxjs/src/internal/observable/using.ts deleted file mode 100644 index e95b1f0..0000000 --- a/node_modules/rxjs/src/internal/observable/using.ts +++ /dev/null @@ -1,49 +0,0 @@ -import { Observable } from '../Observable'; -import { Unsubscribable, ObservableInput, ObservedValueOf } from '../types'; -import { innerFrom } from './innerFrom'; -import { EMPTY } from './empty'; - -/** - * Creates an Observable that uses a resource which will be disposed at the same time as the Observable. - * - * <span class="informal">Use it when you catch yourself cleaning up after an Observable.</span> - * - * `using` is a factory operator, which accepts two functions. First function returns a disposable resource. - * It can be an arbitrary object that implements `unsubscribe` method. Second function will be injected with - * that object and should return an Observable. That Observable can use resource object during its execution. - * Both functions passed to `using` will be called every time someone subscribes - neither an Observable nor - * resource object will be shared in any way between subscriptions. - * - * When Observable returned by `using` is subscribed, Observable returned from the second function will be subscribed - * as well. All its notifications (nexted values, completion and error events) will be emitted unchanged by the output - * Observable. If however someone unsubscribes from the Observable or source Observable completes or errors by itself, - * the `unsubscribe` method on resource object will be called. This can be used to do any necessary clean up, which - * otherwise would have to be handled by hand. Note that complete or error notifications are not emitted when someone - * cancels subscription to an Observable via `unsubscribe`, so `using` can be used as a hook, allowing you to make - * sure that all resources which need to exist during an Observable execution will be disposed at appropriate time. - * - * @see {@link defer} - * - * @param resourceFactory A function which creates any resource object that implements `unsubscribe` method. - * @param observableFactory A function which creates an Observable, that can use injected resource object. - * @return An Observable that behaves the same as Observable returned by `observableFactory`, but - * which - when completed, errored or unsubscribed - will also call `unsubscribe` on created resource object. - */ -export function using<T extends ObservableInput<any>>( - resourceFactory: () => Unsubscribable | void, - observableFactory: (resource: Unsubscribable | void) => T | void -): Observable<ObservedValueOf<T>> { - return new Observable<ObservedValueOf<T>>((subscriber) => { - const resource = resourceFactory(); - const result = observableFactory(resource); - const source = result ? innerFrom(result) : EMPTY; - source.subscribe(subscriber); - return () => { - // NOTE: Optional chaining did not work here. - // Related TS Issue: https://github.com/microsoft/TypeScript/issues/40818 - if (resource) { - resource.unsubscribe(); - } - }; - }); -} diff --git a/node_modules/rxjs/src/internal/observable/zip.ts b/node_modules/rxjs/src/internal/observable/zip.ts deleted file mode 100644 index d6d2adf..0000000 --- a/node_modules/rxjs/src/internal/observable/zip.ts +++ /dev/null @@ -1,117 +0,0 @@ -import { Observable } from '../Observable'; -import { ObservableInputTuple } from '../types'; -import { innerFrom } from './innerFrom'; -import { argsOrArgArray } from '../util/argsOrArgArray'; -import { EMPTY } from './empty'; -import { createOperatorSubscriber } from '../operators/OperatorSubscriber'; -import { popResultSelector } from '../util/args'; - -export function zip<A extends readonly unknown[]>(sources: [...ObservableInputTuple<A>]): Observable<A>; -export function zip<A extends readonly unknown[], R>( - sources: [...ObservableInputTuple<A>], - resultSelector: (...values: A) => R -): Observable<R>; -export function zip<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A>; -export function zip<A extends readonly unknown[], R>( - ...sourcesAndResultSelector: [...ObservableInputTuple<A>, (...values: A) => R] -): Observable<R>; - -/** - * Combines multiple Observables to create an Observable whose values are calculated from the values, in order, of each - * of its input Observables. - * - * If the last parameter is a function, this function is used to compute the created value from the input values. - * Otherwise, an array of the input values is returned. - * - * ## Example - * - * Combine age and name from different sources - * - * ```ts - * import { of, zip, map } from 'rxjs'; - * - * const age$ = of(27, 25, 29); - * const name$ = of('Foo', 'Bar', 'Beer'); - * const isDev$ = of(true, true, false); - * - * zip(age$, name$, isDev$).pipe( - * map(([age, name, isDev]) => ({ age, name, isDev })) - * ) - * .subscribe(x => console.log(x)); - * - * // Outputs - * // { age: 27, name: 'Foo', isDev: true } - * // { age: 25, name: 'Bar', isDev: true } - * // { age: 29, name: 'Beer', isDev: false } - * ``` - * - * @param args Any number of `ObservableInput`s provided either as an array or as an object - * to combine with each other. - * @return An Observable of array values of the values emitted at the same index from each - * individual `ObservableInput`. - */ -export function zip(...args: unknown[]): Observable<unknown> { - const resultSelector = popResultSelector(args); - - const sources = argsOrArgArray(args) as Observable<unknown>[]; - - return sources.length - ? new Observable<unknown[]>((subscriber) => { - // A collection of buffers of values from each source. - // Keyed by the same index with which the sources were passed in. - let buffers: unknown[][] = sources.map(() => []); - - // An array of flags of whether or not the sources have completed. - // This is used to check to see if we should complete the result. - // Keyed by the same index with which the sources were passed in. - let completed = sources.map(() => false); - - // When everything is done, release the arrays above. - subscriber.add(() => { - buffers = completed = null!; - }); - - // Loop over our sources and subscribe to each one. The index `i` is - // especially important here, because we use it in closures below to - // access the related buffers and completion properties - for (let sourceIndex = 0; !subscriber.closed && sourceIndex < sources.length; sourceIndex++) { - innerFrom(sources[sourceIndex]).subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - buffers[sourceIndex].push(value); - // if every buffer has at least one value in it, then we - // can shift out the oldest value from each buffer and emit - // them as an array. - if (buffers.every((buffer) => buffer.length)) { - const result: any = buffers.map((buffer) => buffer.shift()!); - // Emit the array. If theres' a result selector, use that. - subscriber.next(resultSelector ? resultSelector(...result) : result); - // If any one of the sources is both complete and has an empty buffer - // then we complete the result. This is because we cannot possibly have - // any more values to zip together. - if (buffers.some((buffer, i) => !buffer.length && completed[i])) { - subscriber.complete(); - } - } - }, - () => { - // This source completed. Mark it as complete so we can check it later - // if we have to. - completed[sourceIndex] = true; - // But, if this complete source has nothing in its buffer, then we - // can complete the result, because we can't possibly have any more - // values from this to zip together with the other values. - !buffers[sourceIndex].length && subscriber.complete(); - } - ) - ); - } - - // When everything is done, release the arrays above. - return () => { - buffers = completed = null!; - }; - }) - : EMPTY; -} |