diff options
Diffstat (limited to 'node_modules/rxjs/src')
260 files changed, 0 insertions, 21464 deletions
diff --git a/node_modules/rxjs/src/Rx.global.js b/node_modules/rxjs/src/Rx.global.js deleted file mode 100644 index d75682b..0000000 --- a/node_modules/rxjs/src/Rx.global.js +++ /dev/null @@ -1,5 +0,0 @@ -(function (root, factory) { - root.Rx = factory(); -})(window || global || this, function () { - return require('../dist/package/Rx'); -});
\ No newline at end of file diff --git a/node_modules/rxjs/src/ajax/index.ts b/node_modules/rxjs/src/ajax/index.ts deleted file mode 100644 index f30f026..0000000 --- a/node_modules/rxjs/src/ajax/index.ts +++ /dev/null @@ -1,4 +0,0 @@ -export { ajax } from '../internal/ajax/ajax'; -export { AjaxError, AjaxTimeoutError } from '../internal/ajax/errors'; -export { AjaxResponse } from '../internal/ajax/AjaxResponse'; -export { AjaxRequest, AjaxConfig, AjaxDirection } from '../internal/ajax/types'; diff --git a/node_modules/rxjs/src/fetch/index.ts b/node_modules/rxjs/src/fetch/index.ts deleted file mode 100644 index e6ff01d..0000000 --- a/node_modules/rxjs/src/fetch/index.ts +++ /dev/null @@ -1 +0,0 @@ -export { fromFetch } from '../internal/observable/dom/fetch'; diff --git a/node_modules/rxjs/src/index.ts b/node_modules/rxjs/src/index.ts deleted file mode 100644 index 1805341..0000000 --- a/node_modules/rxjs/src/index.ts +++ /dev/null @@ -1,209 +0,0 @@ -////////////////////////////////////////////////////////// -// Here we need to reference our other deep imports -// so VS code will figure out where they are -// see conversation here: -// https://github.com/microsoft/TypeScript/issues/43034 -////////////////////////////////////////////////////////// - -// tslint:disable: no-reference -// It's tempting to add references to all of the deep-import locations, but -// adding references to those that require DOM types breaks Node projects. -/// <reference path="./operators/index.ts" /> -/// <reference path="./testing/index.ts" /> -// tslint:enable: no-reference - -/* Observable */ -export { Observable } from './internal/Observable'; -export { ConnectableObservable } from './internal/observable/ConnectableObservable'; -export { GroupedObservable } from './internal/operators/groupBy'; -export { Operator } from './internal/Operator'; -export { observable } from './internal/symbol/observable'; -export { animationFrames } from './internal/observable/dom/animationFrames'; - -/* Subjects */ -export { Subject } from './internal/Subject'; -export { BehaviorSubject } from './internal/BehaviorSubject'; -export { ReplaySubject } from './internal/ReplaySubject'; -export { AsyncSubject } from './internal/AsyncSubject'; - -/* Schedulers */ -export { asap, asapScheduler } from './internal/scheduler/asap'; -export { async, asyncScheduler } from './internal/scheduler/async'; -export { queue, queueScheduler } from './internal/scheduler/queue'; -export { animationFrame, animationFrameScheduler } from './internal/scheduler/animationFrame'; -export { VirtualTimeScheduler, VirtualAction } from './internal/scheduler/VirtualTimeScheduler'; -export { Scheduler } from './internal/Scheduler'; - -/* Subscription */ -export { Subscription } from './internal/Subscription'; -export { Subscriber } from './internal/Subscriber'; - -/* Notification */ -export { Notification, NotificationKind } from './internal/Notification'; - -/* Utils */ -export { pipe } from './internal/util/pipe'; -export { noop } from './internal/util/noop'; -export { identity } from './internal/util/identity'; -export { isObservable } from './internal/util/isObservable'; - -/* Promise Conversion */ -export { lastValueFrom } from './internal/lastValueFrom'; -export { firstValueFrom } from './internal/firstValueFrom'; - -/* Error types */ -export { ArgumentOutOfRangeError } from './internal/util/ArgumentOutOfRangeError'; -export { EmptyError } from './internal/util/EmptyError'; -export { NotFoundError } from './internal/util/NotFoundError'; -export { ObjectUnsubscribedError } from './internal/util/ObjectUnsubscribedError'; -export { SequenceError } from './internal/util/SequenceError'; -export { TimeoutError } from './internal/operators/timeout'; -export { UnsubscriptionError } from './internal/util/UnsubscriptionError'; - -/* Static observable creation exports */ -export { bindCallback } from './internal/observable/bindCallback'; -export { bindNodeCallback } from './internal/observable/bindNodeCallback'; -export { combineLatest } from './internal/observable/combineLatest'; -export { concat } from './internal/observable/concat'; -export { connectable } from './internal/observable/connectable'; -export { defer } from './internal/observable/defer'; -export { empty } from './internal/observable/empty'; -export { forkJoin } from './internal/observable/forkJoin'; -export { from } from './internal/observable/from'; -export { fromEvent } from './internal/observable/fromEvent'; -export { fromEventPattern } from './internal/observable/fromEventPattern'; -export { generate } from './internal/observable/generate'; -export { iif } from './internal/observable/iif'; -export { interval } from './internal/observable/interval'; -export { merge } from './internal/observable/merge'; -export { never } from './internal/observable/never'; -export { of } from './internal/observable/of'; -export { onErrorResumeNext } from './internal/observable/onErrorResumeNext'; -export { pairs } from './internal/observable/pairs'; -export { partition } from './internal/observable/partition'; -export { race } from './internal/observable/race'; -export { range } from './internal/observable/range'; -export { throwError } from './internal/observable/throwError'; -export { timer } from './internal/observable/timer'; -export { using } from './internal/observable/using'; -export { zip } from './internal/observable/zip'; -export { scheduled } from './internal/scheduled/scheduled'; - -/* Constants */ -export { EMPTY } from './internal/observable/empty'; -export { NEVER } from './internal/observable/never'; - -/* Types */ -export * from './internal/types'; - -/* Config */ -export { config, GlobalConfig } from './internal/config'; - -/* Operators */ -export { audit } from './internal/operators/audit'; -export { auditTime } from './internal/operators/auditTime'; -export { buffer } from './internal/operators/buffer'; -export { bufferCount } from './internal/operators/bufferCount'; -export { bufferTime } from './internal/operators/bufferTime'; -export { bufferToggle } from './internal/operators/bufferToggle'; -export { bufferWhen } from './internal/operators/bufferWhen'; -export { catchError } from './internal/operators/catchError'; -export { combineAll } from './internal/operators/combineAll'; -export { combineLatestAll } from './internal/operators/combineLatestAll'; -export { combineLatestWith } from './internal/operators/combineLatestWith'; -export { concatAll } from './internal/operators/concatAll'; -export { concatMap } from './internal/operators/concatMap'; -export { concatMapTo } from './internal/operators/concatMapTo'; -export { concatWith } from './internal/operators/concatWith'; -export { connect, ConnectConfig } from './internal/operators/connect'; -export { count } from './internal/operators/count'; -export { debounce } from './internal/operators/debounce'; -export { debounceTime } from './internal/operators/debounceTime'; -export { defaultIfEmpty } from './internal/operators/defaultIfEmpty'; -export { delay } from './internal/operators/delay'; -export { delayWhen } from './internal/operators/delayWhen'; -export { dematerialize } from './internal/operators/dematerialize'; -export { distinct } from './internal/operators/distinct'; -export { distinctUntilChanged } from './internal/operators/distinctUntilChanged'; -export { distinctUntilKeyChanged } from './internal/operators/distinctUntilKeyChanged'; -export { elementAt } from './internal/operators/elementAt'; -export { endWith } from './internal/operators/endWith'; -export { every } from './internal/operators/every'; -export { exhaust } from './internal/operators/exhaust'; -export { exhaustAll } from './internal/operators/exhaustAll'; -export { exhaustMap } from './internal/operators/exhaustMap'; -export { expand } from './internal/operators/expand'; -export { filter } from './internal/operators/filter'; -export { finalize } from './internal/operators/finalize'; -export { find } from './internal/operators/find'; -export { findIndex } from './internal/operators/findIndex'; -export { first } from './internal/operators/first'; -export { groupBy, BasicGroupByOptions, GroupByOptionsWithElement } from './internal/operators/groupBy'; -export { ignoreElements } from './internal/operators/ignoreElements'; -export { isEmpty } from './internal/operators/isEmpty'; -export { last } from './internal/operators/last'; -export { map } from './internal/operators/map'; -export { mapTo } from './internal/operators/mapTo'; -export { materialize } from './internal/operators/materialize'; -export { max } from './internal/operators/max'; -export { mergeAll } from './internal/operators/mergeAll'; -export { flatMap } from './internal/operators/flatMap'; -export { mergeMap } from './internal/operators/mergeMap'; -export { mergeMapTo } from './internal/operators/mergeMapTo'; -export { mergeScan } from './internal/operators/mergeScan'; -export { mergeWith } from './internal/operators/mergeWith'; -export { min } from './internal/operators/min'; -export { multicast } from './internal/operators/multicast'; -export { observeOn } from './internal/operators/observeOn'; -export { onErrorResumeNextWith } from './internal/operators/onErrorResumeNextWith'; -export { pairwise } from './internal/operators/pairwise'; -export { pluck } from './internal/operators/pluck'; -export { publish } from './internal/operators/publish'; -export { publishBehavior } from './internal/operators/publishBehavior'; -export { publishLast } from './internal/operators/publishLast'; -export { publishReplay } from './internal/operators/publishReplay'; -export { raceWith } from './internal/operators/raceWith'; -export { reduce } from './internal/operators/reduce'; -export { repeat, RepeatConfig } from './internal/operators/repeat'; -export { repeatWhen } from './internal/operators/repeatWhen'; -export { retry, RetryConfig } from './internal/operators/retry'; -export { retryWhen } from './internal/operators/retryWhen'; -export { refCount } from './internal/operators/refCount'; -export { sample } from './internal/operators/sample'; -export { sampleTime } from './internal/operators/sampleTime'; -export { scan } from './internal/operators/scan'; -export { sequenceEqual } from './internal/operators/sequenceEqual'; -export { share, ShareConfig } from './internal/operators/share'; -export { shareReplay, ShareReplayConfig } from './internal/operators/shareReplay'; -export { single } from './internal/operators/single'; -export { skip } from './internal/operators/skip'; -export { skipLast } from './internal/operators/skipLast'; -export { skipUntil } from './internal/operators/skipUntil'; -export { skipWhile } from './internal/operators/skipWhile'; -export { startWith } from './internal/operators/startWith'; -export { subscribeOn } from './internal/operators/subscribeOn'; -export { switchAll } from './internal/operators/switchAll'; -export { switchMap } from './internal/operators/switchMap'; -export { switchMapTo } from './internal/operators/switchMapTo'; -export { switchScan } from './internal/operators/switchScan'; -export { take } from './internal/operators/take'; -export { takeLast } from './internal/operators/takeLast'; -export { takeUntil } from './internal/operators/takeUntil'; -export { takeWhile } from './internal/operators/takeWhile'; -export { tap, TapObserver } from './internal/operators/tap'; -export { throttle, ThrottleConfig } from './internal/operators/throttle'; -export { throttleTime } from './internal/operators/throttleTime'; -export { throwIfEmpty } from './internal/operators/throwIfEmpty'; -export { timeInterval } from './internal/operators/timeInterval'; -export { timeout, TimeoutConfig, TimeoutInfo } from './internal/operators/timeout'; -export { timeoutWith } from './internal/operators/timeoutWith'; -export { timestamp } from './internal/operators/timestamp'; -export { toArray } from './internal/operators/toArray'; -export { window } from './internal/operators/window'; -export { windowCount } from './internal/operators/windowCount'; -export { windowTime } from './internal/operators/windowTime'; -export { windowToggle } from './internal/operators/windowToggle'; -export { windowWhen } from './internal/operators/windowWhen'; -export { withLatestFrom } from './internal/operators/withLatestFrom'; -export { zipAll } from './internal/operators/zipAll'; -export { zipWith } from './internal/operators/zipWith'; diff --git a/node_modules/rxjs/src/internal/AnyCatcher.ts b/node_modules/rxjs/src/internal/AnyCatcher.ts deleted file mode 100644 index e69ebe1..0000000 --- a/node_modules/rxjs/src/internal/AnyCatcher.ts +++ /dev/null @@ -1,14 +0,0 @@ -/* - * Note that we cannot apply the `internal` tag here because the declaration - * needs to survive the `stripInternal` option. Otherwise, `AnyCatcher` will - * be `any` in the `.d.ts` files. - */ -declare const anyCatcherSymbol: unique symbol; - -/** - * This is just a type that we're using to identify `any` being passed to - * function overloads. This is used because of situations like {@link forkJoin}, - * where it could return an `Observable<T[]>` or an `Observable<{ [key: K]: T }>`, - * so `forkJoin(any)` would mean we need to return `Observable<unknown>`. - */ -export type AnyCatcher = typeof anyCatcherSymbol; diff --git a/node_modules/rxjs/src/internal/AsyncSubject.ts b/node_modules/rxjs/src/internal/AsyncSubject.ts deleted file mode 100644 index abb086c..0000000 --- a/node_modules/rxjs/src/internal/AsyncSubject.ts +++ /dev/null @@ -1,39 +0,0 @@ -import { Subject } from './Subject'; -import { Subscriber } from './Subscriber'; - -/** - * A variant of Subject that only emits a value when it completes. It will emit - * its latest value to all its observers on completion. - */ -export class AsyncSubject<T> extends Subject<T> { - private _value: T | null = null; - private _hasValue = false; - private _isComplete = false; - - /** @internal */ - protected _checkFinalizedStatuses(subscriber: Subscriber<T>) { - const { hasError, _hasValue, _value, thrownError, isStopped, _isComplete } = this; - if (hasError) { - subscriber.error(thrownError); - } else if (isStopped || _isComplete) { - _hasValue && subscriber.next(_value!); - subscriber.complete(); - } - } - - next(value: T): void { - if (!this.isStopped) { - this._value = value; - this._hasValue = true; - } - } - - complete(): void { - const { _hasValue, _value, _isComplete } = this; - if (!_isComplete) { - this._isComplete = true; - _hasValue && super.next(_value!); - super.complete(); - } - } -} diff --git a/node_modules/rxjs/src/internal/BehaviorSubject.ts b/node_modules/rxjs/src/internal/BehaviorSubject.ts deleted file mode 100644 index 6540f13..0000000 --- a/node_modules/rxjs/src/internal/BehaviorSubject.ts +++ /dev/null @@ -1,37 +0,0 @@ -import { Subject } from './Subject'; -import { Subscriber } from './Subscriber'; -import { Subscription } from './Subscription'; - -/** - * A variant of Subject that requires an initial value and emits its current - * value whenever it is subscribed to. - */ -export class BehaviorSubject<T> extends Subject<T> { - constructor(private _value: T) { - super(); - } - - get value(): T { - return this.getValue(); - } - - /** @internal */ - protected _subscribe(subscriber: Subscriber<T>): Subscription { - const subscription = super._subscribe(subscriber); - !subscription.closed && subscriber.next(this._value); - return subscription; - } - - getValue(): T { - const { hasError, thrownError, _value } = this; - if (hasError) { - throw thrownError; - } - this._throwIfClosed(); - return _value; - } - - next(value: T): void { - super.next((this._value = value)); - } -} diff --git a/node_modules/rxjs/src/internal/Notification.ts b/node_modules/rxjs/src/internal/Notification.ts deleted file mode 100644 index cf344c4..0000000 --- a/node_modules/rxjs/src/internal/Notification.ts +++ /dev/null @@ -1,238 +0,0 @@ -import { PartialObserver, ObservableNotification, CompleteNotification, NextNotification, ErrorNotification } from './types'; -import { Observable } from './Observable'; -import { EMPTY } from './observable/empty'; -import { of } from './observable/of'; -import { throwError } from './observable/throwError'; -import { isFunction } from './util/isFunction'; - -// TODO: When this enum is removed, replace it with a type alias. See #4556. -/** - * @deprecated Use a string literal instead. `NotificationKind` will be replaced with a type alias in v8. - * It will not be replaced with a const enum as those are not compatible with isolated modules. - */ -export enum NotificationKind { - NEXT = 'N', - ERROR = 'E', - COMPLETE = 'C', -} - -/** - * Represents a push-based event or value that an {@link Observable} can emit. - * This class is particularly useful for operators that manage notifications, - * like {@link materialize}, {@link dematerialize}, {@link observeOn}, and - * others. Besides wrapping the actual delivered value, it also annotates it - * with metadata of, for instance, what type of push message it is (`next`, - * `error`, or `complete`). - * - * @see {@link materialize} - * @see {@link dematerialize} - * @see {@link observeOn} - * @deprecated It is NOT recommended to create instances of `Notification` directly. - * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}. - * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`. - * Will be removed in v8. - */ -export class Notification<T> { - /** - * A value signifying that the notification will "next" if observed. In truth, - * This is really synonymous with just checking `kind === "N"`. - * @deprecated Will be removed in v8. Instead, just check to see if the value of `kind` is `"N"`. - */ - readonly hasValue: boolean; - - /** - * Creates a "Next" notification object. - * @param kind Always `'N'` - * @param value The value to notify with if observed. - * @deprecated Internal implementation detail. Use {@link Notification#createNext createNext} instead. - */ - constructor(kind: 'N', value?: T); - /** - * Creates an "Error" notification object. - * @param kind Always `'E'` - * @param value Always `undefined` - * @param error The error to notify with if observed. - * @deprecated Internal implementation detail. Use {@link Notification#createError createError} instead. - */ - constructor(kind: 'E', value: undefined, error: any); - /** - * Creates a "completion" notification object. - * @param kind Always `'C'` - * @deprecated Internal implementation detail. Use {@link Notification#createComplete createComplete} instead. - */ - constructor(kind: 'C'); - constructor(public readonly kind: 'N' | 'E' | 'C', public readonly value?: T, public readonly error?: any) { - this.hasValue = kind === 'N'; - } - - /** - * Executes the appropriate handler on a passed `observer` given the `kind` of notification. - * If the handler is missing it will do nothing. Even if the notification is an error, if - * there is no error handler on the observer, an error will not be thrown, it will noop. - * @param observer The observer to notify. - */ - observe(observer: PartialObserver<T>): void { - return observeNotification(this as ObservableNotification<T>, observer); - } - - /** - * Executes a notification on the appropriate handler from a list provided. - * If a handler is missing for the kind of notification, nothing is called - * and no error is thrown, it will be a noop. - * @param next A next handler - * @param error An error handler - * @param complete A complete handler - * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8. - */ - do(next: (value: T) => void, error: (err: any) => void, complete: () => void): void; - /** - * Executes a notification on the appropriate handler from a list provided. - * If a handler is missing for the kind of notification, nothing is called - * and no error is thrown, it will be a noop. - * @param next A next handler - * @param error An error handler - * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8. - */ - do(next: (value: T) => void, error: (err: any) => void): void; - /** - * Executes the next handler if the Notification is of `kind` `"N"`. Otherwise - * this will not error, and it will be a noop. - * @param next The next handler - * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8. - */ - do(next: (value: T) => void): void; - do(nextHandler: (value: T) => void, errorHandler?: (err: any) => void, completeHandler?: () => void): void { - const { kind, value, error } = this; - return kind === 'N' ? nextHandler?.(value!) : kind === 'E' ? errorHandler?.(error) : completeHandler?.(); - } - - /** - * Executes a notification on the appropriate handler from a list provided. - * If a handler is missing for the kind of notification, nothing is called - * and no error is thrown, it will be a noop. - * @param next A next handler - * @param error An error handler - * @param complete A complete handler - * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8. - */ - accept(next: (value: T) => void, error: (err: any) => void, complete: () => void): void; - /** - * Executes a notification on the appropriate handler from a list provided. - * If a handler is missing for the kind of notification, nothing is called - * and no error is thrown, it will be a noop. - * @param next A next handler - * @param error An error handler - * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8. - */ - accept(next: (value: T) => void, error: (err: any) => void): void; - /** - * Executes the next handler if the Notification is of `kind` `"N"`. Otherwise - * this will not error, and it will be a noop. - * @param next The next handler - * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8. - */ - accept(next: (value: T) => void): void; - - /** - * Executes the appropriate handler on a passed `observer` given the `kind` of notification. - * If the handler is missing it will do nothing. Even if the notification is an error, if - * there is no error handler on the observer, an error will not be thrown, it will noop. - * @param observer The observer to notify. - * @deprecated Replaced with {@link Notification#observe observe}. Will be removed in v8. - */ - accept(observer: PartialObserver<T>): void; - accept(nextOrObserver: PartialObserver<T> | ((value: T) => void), error?: (err: any) => void, complete?: () => void) { - return isFunction((nextOrObserver as any)?.next) - ? this.observe(nextOrObserver as PartialObserver<T>) - : this.do(nextOrObserver as (value: T) => void, error as any, complete as any); - } - - /** - * Returns a simple Observable that just delivers the notification represented - * by this Notification instance. - * - * @deprecated Will be removed in v8. To convert a `Notification` to an {@link Observable}, - * use {@link of} and {@link dematerialize}: `of(notification).pipe(dematerialize())`. - */ - toObservable(): Observable<T> { - const { kind, value, error } = this; - // Select the observable to return by `kind` - const result = - kind === 'N' - ? // Next kind. Return an observable of that value. - of(value!) - : // - kind === 'E' - ? // Error kind. Return an observable that emits the error. - throwError(() => error) - : // - kind === 'C' - ? // Completion kind. Kind is "C", return an observable that just completes. - EMPTY - : // Unknown kind, return falsy, so we error below. - 0; - if (!result) { - // TODO: consider removing this check. The only way to cause this would be to - // use the Notification constructor directly in a way that is not type-safe. - // and direct use of the Notification constructor is deprecated. - throw new TypeError(`Unexpected notification kind ${kind}`); - } - return result; - } - - private static completeNotification = new Notification('C') as Notification<never> & CompleteNotification; - /** - * A shortcut to create a Notification instance of the type `next` from a - * given value. - * @param value The `next` value. - * @return The "next" Notification representing the argument. - * @deprecated It is NOT recommended to create instances of `Notification` directly. - * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}. - * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`. - * Will be removed in v8. - */ - static createNext<T>(value: T) { - return new Notification('N', value) as Notification<T> & NextNotification<T>; - } - - /** - * A shortcut to create a Notification instance of the type `error` from a - * given error. - * @param err The `error` error. - * @return The "error" Notification representing the argument. - * @deprecated It is NOT recommended to create instances of `Notification` directly. - * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}. - * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`. - * Will be removed in v8. - */ - static createError(err?: any) { - return new Notification('E', undefined, err) as Notification<never> & ErrorNotification; - } - - /** - * A shortcut to create a Notification instance of the type `complete`. - * @return The valueless "complete" Notification. - * @deprecated It is NOT recommended to create instances of `Notification` directly. - * Rather, try to create POJOs matching the signature outlined in {@link ObservableNotification}. - * For example: `{ kind: 'N', value: 1 }`, `{ kind: 'E', error: new Error('bad') }`, or `{ kind: 'C' }`. - * Will be removed in v8. - */ - static createComplete(): Notification<never> & CompleteNotification { - return Notification.completeNotification; - } -} - -/** - * Executes the appropriate handler on a passed `observer` given the `kind` of notification. - * If the handler is missing it will do nothing. Even if the notification is an error, if - * there is no error handler on the observer, an error will not be thrown, it will noop. - * @param notification The notification object to observe. - * @param observer The observer to notify. - */ -export function observeNotification<T>(notification: ObservableNotification<T>, observer: PartialObserver<T>) { - const { kind, value, error } = notification as any; - if (typeof kind !== 'string') { - throw new TypeError('Invalid notification, missing "kind"'); - } - kind === 'N' ? observer.next?.(value!) : kind === 'E' ? observer.error?.(error) : observer.complete?.(); -} diff --git a/node_modules/rxjs/src/internal/NotificationFactories.ts b/node_modules/rxjs/src/internal/NotificationFactories.ts deleted file mode 100644 index 5d2080a..0000000 --- a/node_modules/rxjs/src/internal/NotificationFactories.ts +++ /dev/null @@ -1,40 +0,0 @@ -import { CompleteNotification, NextNotification, ErrorNotification } from './types'; - -/** - * A completion object optimized for memory use and created to be the - * same "shape" as other notifications in v8. - * @internal - */ -export const COMPLETE_NOTIFICATION = (() => createNotification('C', undefined, undefined) as CompleteNotification)(); - -/** - * Internal use only. Creates an optimized error notification that is the same "shape" - * as other notifications. - * @internal - */ -export function errorNotification(error: any): ErrorNotification { - return createNotification('E', undefined, error) as any; -} - -/** - * Internal use only. Creates an optimized next notification that is the same "shape" - * as other notifications. - * @internal - */ -export function nextNotification<T>(value: T) { - return createNotification('N', value, undefined) as NextNotification<T>; -} - -/** - * Ensures that all notifications created internally have the same "shape" in v8. - * - * TODO: This is only exported to support a crazy legacy test in `groupBy`. - * @internal - */ -export function createNotification(kind: 'N' | 'E' | 'C', value: any, error: any) { - return { - kind, - value, - error, - }; -} diff --git a/node_modules/rxjs/src/internal/Observable.ts b/node_modules/rxjs/src/internal/Observable.ts deleted file mode 100644 index 2da026f..0000000 --- a/node_modules/rxjs/src/internal/Observable.ts +++ /dev/null @@ -1,487 +0,0 @@ -import { Operator } from './Operator'; -import { SafeSubscriber, Subscriber } from './Subscriber'; -import { isSubscription, Subscription } from './Subscription'; -import { TeardownLogic, OperatorFunction, Subscribable, Observer } from './types'; -import { observable as Symbol_observable } from './symbol/observable'; -import { pipeFromArray } from './util/pipe'; -import { config } from './config'; -import { isFunction } from './util/isFunction'; -import { errorContext } from './util/errorContext'; - -/** - * A representation of any set of values over any amount of time. This is the most basic building block - * of RxJS. - */ -export class Observable<T> implements Subscribable<T> { - /** - * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. - */ - source: Observable<any> | undefined; - - /** - * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. - */ - operator: Operator<any, T> | undefined; - - /** - * @param subscribe The function that is called when the Observable is - * initially subscribed to. This function is given a Subscriber, to which new values - * can be `next`ed, or an `error` method can be called to raise an error, or - * `complete` can be called to notify of a successful completion. - */ - constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic) { - if (subscribe) { - this._subscribe = subscribe; - } - } - - // HACK: Since TypeScript inherits static properties too, we have to - // fight against TypeScript here so Subject can have a different static create signature - /** - * Creates a new Observable by calling the Observable constructor - * @param subscribe the subscriber function to be passed to the Observable constructor - * @return A new observable. - * @deprecated Use `new Observable()` instead. Will be removed in v8. - */ - static create: (...args: any[]) => any = <T>(subscribe?: (subscriber: Subscriber<T>) => TeardownLogic) => { - return new Observable<T>(subscribe); - }; - - /** - * Creates a new Observable, with this Observable instance as the source, and the passed - * operator defined as the new observable's operator. - * @param operator the operator defining the operation to take on the observable - * @return A new observable with the Operator applied. - * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. - * If you have implemented an operator using `lift`, it is recommended that you create an - * operator by simply returning `new Observable()` directly. See "Creating new operators from - * scratch" section here: https://rxjs.dev/guide/operators - */ - lift<R>(operator?: Operator<T, R>): Observable<R> { - const observable = new Observable<R>(); - observable.source = this; - observable.operator = operator; - return observable; - } - - subscribe(observerOrNext?: Partial<Observer<T>> | ((value: T) => void)): Subscription; - /** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */ - subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription; - /** - * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit. - * - * <span class="informal">Use it when you have all these Observables, but still nothing is happening.</span> - * - * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It - * might be for example a function that you passed to Observable's constructor, but most of the time it is - * a library implementation, which defines what will be emitted by an Observable, and when it be will emitted. This means - * that calling `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often - * the thought. - * - * Apart from starting the execution of an Observable, this method allows you to listen for values - * that an Observable emits, as well as for when it completes or errors. You can achieve this in two - * of the following ways. - * - * The first way is creating an object that implements {@link Observer} interface. It should have methods - * defined by that interface, but note that it should be just a regular JavaScript object, which you can create - * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular, do - * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also - * that your object does not have to implement all methods. If you find yourself creating a method that doesn't - * do anything, you can simply omit it. Note however, if the `error` method is not provided and an error happens, - * it will be thrown asynchronously. Errors thrown asynchronously cannot be caught using `try`/`catch`. Instead, - * use the {@link onUnhandledError} configuration option or use a runtime handler (like `window.onerror` or - * `process.on('error)`) to be notified of unhandled errors. Because of this, it's recommended that you provide - * an `error` method to avoid missing thrown errors. - * - * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods. - * This means you can provide three functions as arguments to `subscribe`, where the first function is equivalent - * of a `next` method, the second of an `error` method and the third of a `complete` method. Just as in case of an Observer, - * if you do not need to listen for something, you can omit a function by passing `undefined` or `null`, - * since `subscribe` recognizes these functions by where they were placed in function call. When it comes - * to the `error` function, as with an Observer, if not provided, errors emitted by an Observable will be thrown asynchronously. - * - * You can, however, subscribe with no parameters at all. This may be the case where you're not interested in terminal events - * and you also handled emissions internally by using operators (e.g. using `tap`). - * - * Whichever style of calling `subscribe` you use, in both cases it returns a Subscription object. - * This object allows you to call `unsubscribe` on it, which in turn will stop the work that an Observable does and will clean - * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback - * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable. - * - * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously. - * It is an Observable itself that decides when these functions will be called. For example {@link of} - * by default emits all its values synchronously. Always check documentation for how given Observable - * will behave when subscribed and if its default behavior can be modified with a `scheduler`. - * - * #### Examples - * - * Subscribe with an {@link guide/observer Observer} - * - * ```ts - * import { of } from 'rxjs'; - * - * const sumObserver = { - * sum: 0, - * next(value) { - * console.log('Adding: ' + value); - * this.sum = this.sum + value; - * }, - * error() { - * // We actually could just remove this method, - * // since we do not really care about errors right now. - * }, - * complete() { - * console.log('Sum equals: ' + this.sum); - * } - * }; - * - * of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes. - * .subscribe(sumObserver); - * - * // Logs: - * // 'Adding: 1' - * // 'Adding: 2' - * // 'Adding: 3' - * // 'Sum equals: 6' - * ``` - * - * Subscribe with functions ({@link deprecations/subscribe-arguments deprecated}) - * - * ```ts - * import { of } from 'rxjs' - * - * let sum = 0; - * - * of(1, 2, 3).subscribe( - * value => { - * console.log('Adding: ' + value); - * sum = sum + value; - * }, - * undefined, - * () => console.log('Sum equals: ' + sum) - * ); - * - * // Logs: - * // 'Adding: 1' - * // 'Adding: 2' - * // 'Adding: 3' - * // 'Sum equals: 6' - * ``` - * - * Cancel a subscription - * - * ```ts - * import { interval } from 'rxjs'; - * - * const subscription = interval(1000).subscribe({ - * next(num) { - * console.log(num) - * }, - * complete() { - * // Will not be called, even when cancelling subscription. - * console.log('completed!'); - * } - * }); - * - * setTimeout(() => { - * subscription.unsubscribe(); - * console.log('unsubscribed!'); - * }, 2500); - * - * // Logs: - * // 0 after 1s - * // 1 after 2s - * // 'unsubscribed!' after 2.5s - * ``` - * - * @param observerOrNext Either an {@link Observer} with some or all callback methods, - * or the `next` handler that is called for each value emitted from the subscribed Observable. - * @param error A handler for a terminal event resulting from an error. If no error handler is provided, - * the error will be thrown asynchronously as unhandled. - * @param complete A handler for a terminal event resulting from successful completion. - * @return A subscription reference to the registered handlers. - */ - subscribe( - observerOrNext?: Partial<Observer<T>> | ((value: T) => void) | null, - error?: ((error: any) => void) | null, - complete?: (() => void) | null - ): Subscription { - const subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete); - - errorContext(() => { - const { operator, source } = this; - subscriber.add( - operator - ? // We're dealing with a subscription in the - // operator chain to one of our lifted operators. - operator.call(subscriber, source) - : source - ? // If `source` has a value, but `operator` does not, something that - // had intimate knowledge of our API, like our `Subject`, must have - // set it. We're going to just call `_subscribe` directly. - this._subscribe(subscriber) - : // In all other cases, we're likely wrapping a user-provided initializer - // function, so we need to catch errors and handle them appropriately. - this._trySubscribe(subscriber) - ); - }); - - return subscriber; - } - - /** @internal */ - protected _trySubscribe(sink: Subscriber<T>): TeardownLogic { - try { - return this._subscribe(sink); - } catch (err) { - // We don't need to return anything in this case, - // because it's just going to try to `add()` to a subscription - // above. - sink.error(err); - } - } - - /** - * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with - * APIs that expect promises, like `async/await`. You cannot unsubscribe from this. - * - * **WARNING**: Only use this with observables you *know* will complete. If the source - * observable does not complete, you will end up with a promise that is hung up, and - * potentially all of the state of an async function hanging out in memory. To avoid - * this situation, look into adding something like {@link timeout}, {@link take}, - * {@link takeWhile}, or {@link takeUntil} amongst others. - * - * #### Example - * - * ```ts - * import { interval, take } from 'rxjs'; - * - * const source$ = interval(1000).pipe(take(4)); - * - * async function getTotal() { - * let total = 0; - * - * await source$.forEach(value => { - * total += value; - * console.log('observable -> ' + value); - * }); - * - * return total; - * } - * - * getTotal().then( - * total => console.log('Total: ' + total) - * ); - * - * // Expected: - * // 'observable -> 0' - * // 'observable -> 1' - * // 'observable -> 2' - * // 'observable -> 3' - * // 'Total: 6' - * ``` - * - * @param next A handler for each value emitted by the observable. - * @return A promise that either resolves on observable completion or - * rejects with the handled error. - */ - forEach(next: (value: T) => void): Promise<void>; - - /** - * @param next a handler for each value emitted by the observable - * @param promiseCtor a constructor function used to instantiate the Promise - * @return a promise that either resolves on observable completion or - * rejects with the handled error - * @deprecated Passing a Promise constructor will no longer be available - * in upcoming versions of RxJS. This is because it adds weight to the library, for very - * little benefit. If you need this functionality, it is recommended that you either - * polyfill Promise, or you create an adapter to convert the returned native promise - * to whatever promise implementation you wanted. Will be removed in v8. - */ - forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>; - - forEach(next: (value: T) => void, promiseCtor?: PromiseConstructorLike): Promise<void> { - promiseCtor = getPromiseCtor(promiseCtor); - - return new promiseCtor<void>((resolve, reject) => { - const subscriber = new SafeSubscriber<T>({ - next: (value) => { - try { - next(value); - } catch (err) { - reject(err); - subscriber.unsubscribe(); - } - }, - error: reject, - complete: resolve, - }); - this.subscribe(subscriber); - }) as Promise<void>; - } - - /** @internal */ - protected _subscribe(subscriber: Subscriber<any>): TeardownLogic { - return this.source?.subscribe(subscriber); - } - - /** - * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable - * @return This instance of the observable. - */ - [Symbol_observable]() { - return this; - } - - /* tslint:disable:max-line-length */ - pipe(): Observable<T>; - pipe<A>(op1: OperatorFunction<T, A>): Observable<A>; - pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>; - pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>; - pipe<A, B, C, D>( - op1: OperatorFunction<T, A>, - op2: OperatorFunction<A, B>, - op3: OperatorFunction<B, C>, - op4: OperatorFunction<C, D> - ): Observable<D>; - pipe<A, B, C, D, E>( - op1: OperatorFunction<T, A>, - op2: OperatorFunction<A, B>, - op3: OperatorFunction<B, C>, - op4: OperatorFunction<C, D>, - op5: OperatorFunction<D, E> - ): Observable<E>; - pipe<A, B, C, D, E, F>( - op1: OperatorFunction<T, A>, - op2: OperatorFunction<A, B>, - op3: OperatorFunction<B, C>, - op4: OperatorFunction<C, D>, - op5: OperatorFunction<D, E>, - op6: OperatorFunction<E, F> - ): Observable<F>; - pipe<A, B, C, D, E, F, G>( - op1: OperatorFunction<T, A>, - op2: OperatorFunction<A, B>, - op3: OperatorFunction<B, C>, - op4: OperatorFunction<C, D>, - op5: OperatorFunction<D, E>, - op6: OperatorFunction<E, F>, - op7: OperatorFunction<F, G> - ): Observable<G>; - pipe<A, B, C, D, E, F, G, H>( - op1: OperatorFunction<T, A>, - op2: OperatorFunction<A, B>, - op3: OperatorFunction<B, C>, - op4: OperatorFunction<C, D>, - op5: OperatorFunction<D, E>, - op6: OperatorFunction<E, F>, - op7: OperatorFunction<F, G>, - op8: OperatorFunction<G, H> - ): Observable<H>; - pipe<A, B, C, D, E, F, G, H, I>( - op1: OperatorFunction<T, A>, - op2: OperatorFunction<A, B>, - op3: OperatorFunction<B, C>, - op4: OperatorFunction<C, D>, - op5: OperatorFunction<D, E>, - op6: OperatorFunction<E, F>, - op7: OperatorFunction<F, G>, - op8: OperatorFunction<G, H>, - op9: OperatorFunction<H, I> - ): Observable<I>; - pipe<A, B, C, D, E, F, G, H, I>( - op1: OperatorFunction<T, A>, - op2: OperatorFunction<A, B>, - op3: OperatorFunction<B, C>, - op4: OperatorFunction<C, D>, - op5: OperatorFunction<D, E>, - op6: OperatorFunction<E, F>, - op7: OperatorFunction<F, G>, - op8: OperatorFunction<G, H>, - op9: OperatorFunction<H, I>, - ...operations: OperatorFunction<any, any>[] - ): Observable<unknown>; - /* tslint:enable:max-line-length */ - - /** - * Used to stitch together functional operators into a chain. - * - * ## Example - * - * ```ts - * import { interval, filter, map, scan } from 'rxjs'; - * - * interval(1000) - * .pipe( - * filter(x => x % 2 === 0), - * map(x => x + x), - * scan((acc, x) => acc + x) - * ) - * .subscribe(x => console.log(x)); - * ``` - * - * @return The Observable result of all the operators having been called - * in the order they were passed in. - */ - pipe(...operations: OperatorFunction<any, any>[]): Observable<any> { - return pipeFromArray(operations)(this); - } - - /* tslint:disable:max-line-length */ - /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */ - toPromise(): Promise<T | undefined>; - /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */ - toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>; - /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */ - toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>; - /* tslint:enable:max-line-length */ - - /** - * Subscribe to this Observable and get a Promise resolving on - * `complete` with the last emission (if any). - * - * **WARNING**: Only use this with observables you *know* will complete. If the source - * observable does not complete, you will end up with a promise that is hung up, and - * potentially all of the state of an async function hanging out in memory. To avoid - * this situation, look into adding something like {@link timeout}, {@link take}, - * {@link takeWhile}, or {@link takeUntil} amongst others. - * - * @param [promiseCtor] a constructor function used to instantiate - * the Promise - * @return A Promise that resolves with the last value emit, or - * rejects on an error. If there were no emissions, Promise - * resolves with undefined. - * @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise - */ - toPromise(promiseCtor?: PromiseConstructorLike): Promise<T | undefined> { - promiseCtor = getPromiseCtor(promiseCtor); - - return new promiseCtor((resolve, reject) => { - let value: T | undefined; - this.subscribe( - (x: T) => (value = x), - (err: any) => reject(err), - () => resolve(value) - ); - }) as Promise<T | undefined>; - } -} - -/** - * Decides between a passed promise constructor from consuming code, - * A default configured promise constructor, and the native promise - * constructor and returns it. If nothing can be found, it will throw - * an error. - * @param promiseCtor The optional promise constructor to passed by consuming code - */ -function getPromiseCtor(promiseCtor: PromiseConstructorLike | undefined) { - return promiseCtor ?? config.Promise ?? Promise; -} - -function isObserver<T>(value: any): value is Observer<T> { - return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete); -} - -function isSubscriber<T>(value: any): value is Subscriber<T> { - return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value)); -} diff --git a/node_modules/rxjs/src/internal/Operator.ts b/node_modules/rxjs/src/internal/Operator.ts deleted file mode 100644 index ab7bc50..0000000 --- a/node_modules/rxjs/src/internal/Operator.ts +++ /dev/null @@ -1,9 +0,0 @@ -import { Subscriber } from './Subscriber'; -import { TeardownLogic } from './types'; - -/*** - * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. - */ -export interface Operator<T, R> { - call(subscriber: Subscriber<R>, source: any): TeardownLogic; -} diff --git a/node_modules/rxjs/src/internal/ReplaySubject.ts b/node_modules/rxjs/src/internal/ReplaySubject.ts deleted file mode 100644 index 67394b7..0000000 --- a/node_modules/rxjs/src/internal/ReplaySubject.ts +++ /dev/null @@ -1,110 +0,0 @@ -import { Subject } from './Subject'; -import { TimestampProvider } from './types'; -import { Subscriber } from './Subscriber'; -import { Subscription } from './Subscription'; -import { dateTimestampProvider } from './scheduler/dateTimestampProvider'; - -/** - * A variant of {@link Subject} that "replays" old values to new subscribers by emitting them when they first subscribe. - * - * `ReplaySubject` has an internal buffer that will store a specified number of values that it has observed. Like `Subject`, - * `ReplaySubject` "observes" values by having them passed to its `next` method. When it observes a value, it will store that - * value for a time determined by the configuration of the `ReplaySubject`, as passed to its constructor. - * - * When a new subscriber subscribes to the `ReplaySubject` instance, it will synchronously emit all values in its buffer in - * a First-In-First-Out (FIFO) manner. The `ReplaySubject` will also complete, if it has observed completion; and it will - * error if it has observed an error. - * - * There are two main configuration items to be concerned with: - * - * 1. `bufferSize` - This will determine how many items are stored in the buffer, defaults to infinite. - * 2. `windowTime` - The amount of time to hold a value in the buffer before removing it from the buffer. - * - * Both configurations may exist simultaneously. So if you would like to buffer a maximum of 3 values, as long as the values - * are less than 2 seconds old, you could do so with a `new ReplaySubject(3, 2000)`. - * - * ### Differences with BehaviorSubject - * - * `BehaviorSubject` is similar to `new ReplaySubject(1)`, with a couple of exceptions: - * - * 1. `BehaviorSubject` comes "primed" with a single value upon construction. - * 2. `ReplaySubject` will replay values, even after observing an error, where `BehaviorSubject` will not. - * - * @see {@link Subject} - * @see {@link BehaviorSubject} - * @see {@link shareReplay} - */ -export class ReplaySubject<T> extends Subject<T> { - private _buffer: (T | number)[] = []; - private _infiniteTimeWindow = true; - - /** - * @param _bufferSize The size of the buffer to replay on subscription - * @param _windowTime The amount of time the buffered items will stay buffered - * @param _timestampProvider An object with a `now()` method that provides the current timestamp. This is used to - * calculate the amount of time something has been buffered. - */ - constructor( - private _bufferSize = Infinity, - private _windowTime = Infinity, - private _timestampProvider: TimestampProvider = dateTimestampProvider - ) { - super(); - this._infiniteTimeWindow = _windowTime === Infinity; - this._bufferSize = Math.max(1, _bufferSize); - this._windowTime = Math.max(1, _windowTime); - } - - next(value: T): void { - const { isStopped, _buffer, _infiniteTimeWindow, _timestampProvider, _windowTime } = this; - if (!isStopped) { - _buffer.push(value); - !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime); - } - this._trimBuffer(); - super.next(value); - } - - /** @internal */ - protected _subscribe(subscriber: Subscriber<T>): Subscription { - this._throwIfClosed(); - this._trimBuffer(); - - const subscription = this._innerSubscribe(subscriber); - - const { _infiniteTimeWindow, _buffer } = this; - // We use a copy here, so reentrant code does not mutate our array while we're - // emitting it to a new subscriber. - const copy = _buffer.slice(); - for (let i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) { - subscriber.next(copy[i] as T); - } - - this._checkFinalizedStatuses(subscriber); - - return subscription; - } - - private _trimBuffer() { - const { _bufferSize, _timestampProvider, _buffer, _infiniteTimeWindow } = this; - // If we don't have an infinite buffer size, and we're over the length, - // use splice to truncate the old buffer values off. Note that we have to - // double the size for instances where we're not using an infinite time window - // because we're storing the values and the timestamps in the same array. - const adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize; - _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize); - - // Now, if we're not in an infinite time window, remove all values where the time is - // older than what is allowed. - if (!_infiniteTimeWindow) { - const now = _timestampProvider.now(); - let last = 0; - // Search the array for the first timestamp that isn't expired and - // truncate the buffer up to that point. - for (let i = 1; i < _buffer.length && (_buffer[i] as number) <= now; i += 2) { - last = i; - } - last && _buffer.splice(0, last + 1); - } - } -} diff --git a/node_modules/rxjs/src/internal/Scheduler.ts b/node_modules/rxjs/src/internal/Scheduler.ts deleted file mode 100644 index 0c3d6b6..0000000 --- a/node_modules/rxjs/src/internal/Scheduler.ts +++ /dev/null @@ -1,60 +0,0 @@ -import { Action } from './scheduler/Action'; -import { Subscription } from './Subscription'; -import { SchedulerLike, SchedulerAction } from './types'; -import { dateTimestampProvider } from './scheduler/dateTimestampProvider'; - -/** - * An execution context and a data structure to order tasks and schedule their - * execution. Provides a notion of (potentially virtual) time, through the - * `now()` getter method. - * - * Each unit of work in a Scheduler is called an `Action`. - * - * ```ts - * class Scheduler { - * now(): number; - * schedule(work, delay?, state?): Subscription; - * } - * ``` - * - * @deprecated Scheduler is an internal implementation detail of RxJS, and - * should not be used directly. Rather, create your own class and implement - * {@link SchedulerLike}. Will be made internal in v8. - */ -export class Scheduler implements SchedulerLike { - public static now: () => number = dateTimestampProvider.now; - - constructor(private schedulerActionCtor: typeof Action, now: () => number = Scheduler.now) { - this.now = now; - } - - /** - * A getter method that returns a number representing the current time - * (at the time this function was called) according to the scheduler's own - * internal clock. - * @return A number that represents the current time. May or may not - * have a relation to wall-clock time. May or may not refer to a time unit - * (e.g. milliseconds). - */ - public now: () => number; - - /** - * Schedules a function, `work`, for execution. May happen at some point in - * the future, according to the `delay` parameter, if specified. May be passed - * some context object, `state`, which will be passed to the `work` function. - * - * The given arguments will be processed an stored as an Action object in a - * queue of actions. - * - * @param work A function representing a task, or some unit of work to be - * executed by the Scheduler. - * @param delay Time to wait before executing the work, where the time unit is - * implicit and defined by the Scheduler itself. - * @param state Some contextual data that the `work` function uses when called - * by the Scheduler. - * @return A subscription in order to be able to unsubscribe the scheduled work. - */ - public schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay: number = 0, state?: T): Subscription { - return new this.schedulerActionCtor<T>(this, work).schedule(state, delay); - } -} diff --git a/node_modules/rxjs/src/internal/Subject.ts b/node_modules/rxjs/src/internal/Subject.ts deleted file mode 100644 index 61ed267..0000000 --- a/node_modules/rxjs/src/internal/Subject.ts +++ /dev/null @@ -1,185 +0,0 @@ -import { Operator } from './Operator'; -import { Observable } from './Observable'; -import { Subscriber } from './Subscriber'; -import { Subscription, EMPTY_SUBSCRIPTION } from './Subscription'; -import { Observer, SubscriptionLike, TeardownLogic } from './types'; -import { ObjectUnsubscribedError } from './util/ObjectUnsubscribedError'; -import { arrRemove } from './util/arrRemove'; -import { errorContext } from './util/errorContext'; - -/** - * A Subject is a special type of Observable that allows values to be - * multicasted to many Observers. Subjects are like EventEmitters. - * - * Every Subject is an Observable and an Observer. You can subscribe to a - * Subject, and you can call next to feed values as well as error and complete. - */ -export class Subject<T> extends Observable<T> implements SubscriptionLike { - closed = false; - - private currentObservers: Observer<T>[] | null = null; - - /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */ - observers: Observer<T>[] = []; - /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */ - isStopped = false; - /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */ - hasError = false; - /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */ - thrownError: any = null; - - /** - * Creates a "subject" by basically gluing an observer to an observable. - * - * @deprecated Recommended you do not use. Will be removed at some point in the future. Plans for replacement still under discussion. - */ - static create: (...args: any[]) => any = <T>(destination: Observer<T>, source: Observable<T>): AnonymousSubject<T> => { - return new AnonymousSubject<T>(destination, source); - }; - - constructor() { - // NOTE: This must be here to obscure Observable's constructor. - super(); - } - - /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */ - lift<R>(operator: Operator<T, R>): Observable<R> { - const subject = new AnonymousSubject(this, this); - subject.operator = operator as any; - return subject as any; - } - - /** @internal */ - protected _throwIfClosed() { - if (this.closed) { - throw new ObjectUnsubscribedError(); - } - } - - next(value: T) { - errorContext(() => { - this._throwIfClosed(); - if (!this.isStopped) { - if (!this.currentObservers) { - this.currentObservers = Array.from(this.observers); - } - for (const observer of this.currentObservers) { - observer.next(value); - } - } - }); - } - - error(err: any) { - errorContext(() => { - this._throwIfClosed(); - if (!this.isStopped) { - this.hasError = this.isStopped = true; - this.thrownError = err; - const { observers } = this; - while (observers.length) { - observers.shift()!.error(err); - } - } - }); - } - - complete() { - errorContext(() => { - this._throwIfClosed(); - if (!this.isStopped) { - this.isStopped = true; - const { observers } = this; - while (observers.length) { - observers.shift()!.complete(); - } - } - }); - } - - unsubscribe() { - this.isStopped = this.closed = true; - this.observers = this.currentObservers = null!; - } - - get observed() { - return this.observers?.length > 0; - } - - /** @internal */ - protected _trySubscribe(subscriber: Subscriber<T>): TeardownLogic { - this._throwIfClosed(); - return super._trySubscribe(subscriber); - } - - /** @internal */ - protected _subscribe(subscriber: Subscriber<T>): Subscription { - this._throwIfClosed(); - this._checkFinalizedStatuses(subscriber); - return this._innerSubscribe(subscriber); - } - - /** @internal */ - protected _innerSubscribe(subscriber: Subscriber<any>) { - const { hasError, isStopped, observers } = this; - if (hasError || isStopped) { - return EMPTY_SUBSCRIPTION; - } - this.currentObservers = null; - observers.push(subscriber); - return new Subscription(() => { - this.currentObservers = null; - arrRemove(observers, subscriber); - }); - } - - /** @internal */ - protected _checkFinalizedStatuses(subscriber: Subscriber<any>) { - const { hasError, thrownError, isStopped } = this; - if (hasError) { - subscriber.error(thrownError); - } else if (isStopped) { - subscriber.complete(); - } - } - - /** - * Creates a new Observable with this Subject as the source. You can do this - * to create custom Observer-side logic of the Subject and conceal it from - * code that uses the Observable. - * @return Observable that this Subject casts to. - */ - asObservable(): Observable<T> { - const observable: any = new Observable<T>(); - observable.source = this; - return observable; - } -} - -export class AnonymousSubject<T> extends Subject<T> { - constructor( - /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */ - public destination?: Observer<T>, - source?: Observable<T> - ) { - super(); - this.source = source; - } - - next(value: T) { - this.destination?.next?.(value); - } - - error(err: any) { - this.destination?.error?.(err); - } - - complete() { - this.destination?.complete?.(); - } - - /** @internal */ - protected _subscribe(subscriber: Subscriber<T>): Subscription { - return this.source?.subscribe(subscriber) ?? EMPTY_SUBSCRIPTION; - } -} diff --git a/node_modules/rxjs/src/internal/Subscriber.ts b/node_modules/rxjs/src/internal/Subscriber.ts deleted file mode 100644 index 4a96c0e..0000000 --- a/node_modules/rxjs/src/internal/Subscriber.ts +++ /dev/null @@ -1,270 +0,0 @@ -import { isFunction } from './util/isFunction'; -import { Observer, ObservableNotification } from './types'; -import { isSubscription, Subscription } from './Subscription'; -import { config } from './config'; -import { reportUnhandledError } from './util/reportUnhandledError'; -import { noop } from './util/noop'; -import { nextNotification, errorNotification, COMPLETE_NOTIFICATION } from './NotificationFactories'; -import { timeoutProvider } from './scheduler/timeoutProvider'; -import { captureError } from './util/errorContext'; - -/** - * Implements the {@link Observer} interface and extends the - * {@link Subscription} class. While the {@link Observer} is the public API for - * consuming the values of an {@link Observable}, all Observers get converted to - * a Subscriber, in order to provide Subscription-like capabilities such as - * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for - * implementing operators, but it is rarely used as a public API. - */ -export class Subscriber<T> extends Subscription implements Observer<T> { - /** - * A static factory for a Subscriber, given a (potentially partial) definition - * of an Observer. - * @param next The `next` callback of an Observer. - * @param error The `error` callback of an - * Observer. - * @param complete The `complete` callback of an - * Observer. - * @return A Subscriber wrapping the (partially defined) - * Observer represented by the given arguments. - * @deprecated Do not use. Will be removed in v8. There is no replacement for this - * method, and there is no reason to be creating instances of `Subscriber` directly. - * If you have a specific use case, please file an issue. - */ - static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T> { - return new SafeSubscriber(next, error, complete); - } - - /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */ - protected isStopped: boolean = false; - /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */ - protected destination: Subscriber<any> | Observer<any>; // this `any` is the escape hatch to erase extra type param (e.g. R) - - /** - * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. - * There is no reason to directly create an instance of Subscriber. This type is exported for typings reasons. - */ - constructor(destination?: Subscriber<any> | Observer<any>) { - super(); - if (destination) { - this.destination = destination; - // Automatically chain subscriptions together here. - // if destination is a Subscription, then it is a Subscriber. - if (isSubscription(destination)) { - destination.add(this); - } - } else { - this.destination = EMPTY_OBSERVER; - } - } - - /** - * The {@link Observer} callback to receive notifications of type `next` from - * the Observable, with a value. The Observable may call this method 0 or more - * times. - * @param value The `next` value. - */ - next(value: T): void { - if (this.isStopped) { - handleStoppedNotification(nextNotification(value), this); - } else { - this._next(value!); - } - } - - /** - * The {@link Observer} callback to receive notifications of type `error` from - * the Observable, with an attached `Error`. Notifies the Observer that - * the Observable has experienced an error condition. - * @param err The `error` exception. - */ - error(err?: any): void { - if (this.isStopped) { - handleStoppedNotification(errorNotification(err), this); - } else { - this.isStopped = true; - this._error(err); - } - } - - /** - * The {@link Observer} callback to receive a valueless notification of type - * `complete` from the Observable. Notifies the Observer that the Observable - * has finished sending push-based notifications. - */ - complete(): void { - if (this.isStopped) { - handleStoppedNotification(COMPLETE_NOTIFICATION, this); - } else { - this.isStopped = true; - this._complete(); - } - } - - unsubscribe(): void { - if (!this.closed) { - this.isStopped = true; - super.unsubscribe(); - this.destination = null!; - } - } - - protected _next(value: T): void { - this.destination.next(value); - } - - protected _error(err: any): void { - try { - this.destination.error(err); - } finally { - this.unsubscribe(); - } - } - - protected _complete(): void { - try { - this.destination.complete(); - } finally { - this.unsubscribe(); - } - } -} - -/** - * This bind is captured here because we want to be able to have - * compatibility with monoid libraries that tend to use a method named - * `bind`. In particular, a library called Monio requires this. - */ -const _bind = Function.prototype.bind; - -function bind<Fn extends (...args: any[]) => any>(fn: Fn, thisArg: any): Fn { - return _bind.call(fn, thisArg); -} - -/** - * Internal optimization only, DO NOT EXPOSE. - * @internal - */ -class ConsumerObserver<T> implements Observer<T> { - constructor(private partialObserver: Partial<Observer<T>>) {} - - next(value: T): void { - const { partialObserver } = this; - if (partialObserver.next) { - try { - partialObserver.next(value); - } catch (error) { - handleUnhandledError(error); - } - } - } - - error(err: any): void { - const { partialObserver } = this; - if (partialObserver.error) { - try { - partialObserver.error(err); - } catch (error) { - handleUnhandledError(error); - } - } else { - handleUnhandledError(err); - } - } - - complete(): void { - const { partialObserver } = this; - if (partialObserver.complete) { - try { - partialObserver.complete(); - } catch (error) { - handleUnhandledError(error); - } - } - } -} - -export class SafeSubscriber<T> extends Subscriber<T> { - constructor( - observerOrNext?: Partial<Observer<T>> | ((value: T) => void) | null, - error?: ((e?: any) => void) | null, - complete?: (() => void) | null - ) { - super(); - - let partialObserver: Partial<Observer<T>>; - if (isFunction(observerOrNext) || !observerOrNext) { - // The first argument is a function, not an observer. The next - // two arguments *could* be observers, or they could be empty. - partialObserver = { - next: (observerOrNext ?? undefined) as ((value: T) => void) | undefined, - error: error ?? undefined, - complete: complete ?? undefined, - }; - } else { - // The first argument is a partial observer. - let context: any; - if (this && config.useDeprecatedNextContext) { - // This is a deprecated path that made `this.unsubscribe()` available in - // next handler functions passed to subscribe. This only exists behind a flag - // now, as it is *very* slow. - context = Object.create(observerOrNext); - context.unsubscribe = () => this.unsubscribe(); - partialObserver = { - next: observerOrNext.next && bind(observerOrNext.next, context), - error: observerOrNext.error && bind(observerOrNext.error, context), - complete: observerOrNext.complete && bind(observerOrNext.complete, context), - }; - } else { - // The "normal" path. Just use the partial observer directly. - partialObserver = observerOrNext; - } - } - - // Wrap the partial observer to ensure it's a full observer, and - // make sure proper error handling is accounted for. - this.destination = new ConsumerObserver(partialObserver); - } -} - -function handleUnhandledError(error: any) { - if (config.useDeprecatedSynchronousErrorHandling) { - captureError(error); - } else { - // Ideal path, we report this as an unhandled error, - // which is thrown on a new call stack. - reportUnhandledError(error); - } -} - -/** - * An error handler used when no error handler was supplied - * to the SafeSubscriber -- meaning no error handler was supplied - * do the `subscribe` call on our observable. - * @param err The error to handle - */ -function defaultErrorHandler(err: any) { - throw err; -} - -/** - * A handler for notifications that cannot be sent to a stopped subscriber. - * @param notification The notification being sent. - * @param subscriber The stopped subscriber. - */ -function handleStoppedNotification(notification: ObservableNotification<any>, subscriber: Subscriber<any>) { - const { onStoppedNotification } = config; - onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber)); -} - -/** - * The observer used as a stub for subscriptions where the user did not - * pass any arguments to `subscribe`. Comes with the default error handling - * behavior. - */ -export const EMPTY_OBSERVER: Readonly<Observer<any>> & { closed: true } = { - closed: true, - next: noop, - error: defaultErrorHandler, - complete: noop, -}; diff --git a/node_modules/rxjs/src/internal/Subscription.ts b/node_modules/rxjs/src/internal/Subscription.ts deleted file mode 100644 index 97f7b33..0000000 --- a/node_modules/rxjs/src/internal/Subscription.ts +++ /dev/null @@ -1,212 +0,0 @@ -import { isFunction } from './util/isFunction'; -import { UnsubscriptionError } from './util/UnsubscriptionError'; -import { SubscriptionLike, TeardownLogic, Unsubscribable } from './types'; -import { arrRemove } from './util/arrRemove'; - -/** - * Represents a disposable resource, such as the execution of an Observable. A - * Subscription has one important method, `unsubscribe`, that takes no argument - * and just disposes the resource held by the subscription. - * - * Additionally, subscriptions may be grouped together through the `add()` - * method, which will attach a child Subscription to the current Subscription. - * When a Subscription is unsubscribed, all its children (and its grandchildren) - * will be unsubscribed as well. - */ -export class Subscription implements SubscriptionLike { - public static EMPTY = (() => { - const empty = new Subscription(); - empty.closed = true; - return empty; - })(); - - /** - * A flag to indicate whether this Subscription has already been unsubscribed. - */ - public closed = false; - - private _parentage: Subscription[] | Subscription | null = null; - - /** - * The list of registered finalizers to execute upon unsubscription. Adding and removing from this - * list occurs in the {@link #add} and {@link #remove} methods. - */ - private _finalizers: Exclude<TeardownLogic, void>[] | null = null; - - /** - * @param initialTeardown A function executed first as part of the finalization - * process that is kicked off when {@link #unsubscribe} is called. - */ - constructor(private initialTeardown?: () => void) {} - - /** - * Disposes the resources held by the subscription. May, for instance, cancel - * an ongoing Observable execution or cancel any other type of work that - * started when the Subscription was created. - */ - unsubscribe(): void { - let errors: any[] | undefined; - - if (!this.closed) { - this.closed = true; - - // Remove this from it's parents. - const { _parentage } = this; - if (_parentage) { - this._parentage = null; - if (Array.isArray(_parentage)) { - for (const parent of _parentage) { - parent.remove(this); - } - } else { - _parentage.remove(this); - } - } - - const { initialTeardown: initialFinalizer } = this; - if (isFunction(initialFinalizer)) { - try { - initialFinalizer(); - } catch (e) { - errors = e instanceof UnsubscriptionError ? e.errors : [e]; - } - } - - const { _finalizers } = this; - if (_finalizers) { - this._finalizers = null; - for (const finalizer of _finalizers) { - try { - execFinalizer(finalizer); - } catch (err) { - errors = errors ?? []; - if (err instanceof UnsubscriptionError) { - errors = [...errors, ...err.errors]; - } else { - errors.push(err); - } - } - } - } - - if (errors) { - throw new UnsubscriptionError(errors); - } - } - } - - /** - * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called - * when this subscription is unsubscribed. If this subscription is already {@link #closed}, - * because it has already been unsubscribed, then whatever finalizer is passed to it - * will automatically be executed (unless the finalizer itself is also a closed subscription). - * - * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed - * subscription to a any subscription will result in no operation. (A noop). - * - * Adding a subscription to itself, or adding `null` or `undefined` will not perform any - * operation at all. (A noop). - * - * `Subscription` instances that are added to this instance will automatically remove themselves - * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove - * will need to be removed manually with {@link #remove} - * - * @param teardown The finalization logic to add to this subscription. - */ - add(teardown: TeardownLogic): void { - // Only add the finalizer if it's not undefined - // and don't add a subscription to itself. - if (teardown && teardown !== this) { - if (this.closed) { - // If this subscription is already closed, - // execute whatever finalizer is handed to it automatically. - execFinalizer(teardown); - } else { - if (teardown instanceof Subscription) { - // We don't add closed subscriptions, and we don't add the same subscription - // twice. Subscription unsubscribe is idempotent. - if (teardown.closed || teardown._hasParent(this)) { - return; - } - teardown._addParent(this); - } - (this._finalizers = this._finalizers ?? []).push(teardown); - } - } - } - - /** - * Checks to see if a this subscription already has a particular parent. - * This will signal that this subscription has already been added to the parent in question. - * @param parent the parent to check for - */ - private _hasParent(parent: Subscription) { - const { _parentage } = this; - return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent)); - } - - /** - * Adds a parent to this subscription so it can be removed from the parent if it - * unsubscribes on it's own. - * - * NOTE: THIS ASSUMES THAT {@link _hasParent} HAS ALREADY BEEN CHECKED. - * @param parent The parent subscription to add - */ - private _addParent(parent: Subscription) { - const { _parentage } = this; - this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent; - } - - /** - * Called on a child when it is removed via {@link #remove}. - * @param parent The parent to remove - */ - private _removeParent(parent: Subscription) { - const { _parentage } = this; - if (_parentage === parent) { - this._parentage = null; - } else if (Array.isArray(_parentage)) { - arrRemove(_parentage, parent); - } - } - - /** - * Removes a finalizer from this subscription that was previously added with the {@link #add} method. - * - * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves - * from every other `Subscription` they have been added to. This means that using the `remove` method - * is not a common thing and should be used thoughtfully. - * - * If you add the same finalizer instance of a function or an unsubscribable object to a `Subscription` instance - * more than once, you will need to call `remove` the same number of times to remove all instances. - * - * All finalizer instances are removed to free up memory upon unsubscription. - * - * @param teardown The finalizer to remove from this subscription - */ - remove(teardown: Exclude<TeardownLogic, void>): void { - const { _finalizers } = this; - _finalizers && arrRemove(_finalizers, teardown); - - if (teardown instanceof Subscription) { - teardown._removeParent(this); - } - } -} - -export const EMPTY_SUBSCRIPTION = Subscription.EMPTY; - -export function isSubscription(value: any): value is Subscription { - return ( - value instanceof Subscription || - (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)) - ); -} - -function execFinalizer(finalizer: Unsubscribable | (() => void)) { - if (isFunction(finalizer)) { - finalizer(); - } else { - finalizer.unsubscribe(); - } -} diff --git a/node_modules/rxjs/src/internal/ajax/AjaxResponse.ts b/node_modules/rxjs/src/internal/ajax/AjaxResponse.ts deleted file mode 100644 index c9ca915..0000000 --- a/node_modules/rxjs/src/internal/ajax/AjaxResponse.ts +++ /dev/null @@ -1,124 +0,0 @@ -import { AjaxRequest, AjaxResponseType } from './types'; -import { getXHRResponse } from './getXHRResponse'; - -/** - * A normalized response from an AJAX request. To get the data from the response, - * you will want to read the `response` property. - * - * - DO NOT create instances of this class directly. - * - DO NOT subclass this class. - * - * It is advised not to hold this object in memory, as it has a reference to - * the original XHR used to make the request, as well as properties containing - * request and response data. - * - * @see {@link ajax} - * @see {@link AjaxConfig} - */ -export class AjaxResponse<T> { - /** The HTTP status code */ - readonly status: number; - - /** - * The response data, if any. Note that this will automatically be converted to the proper type - */ - readonly response: T; - - /** - * The responseType set on the request. (For example: `""`, `"arraybuffer"`, `"blob"`, `"document"`, `"json"`, or `"text"`) - * @deprecated There isn't much reason to examine this. It's the same responseType set (or defaulted) on the ajax config. - * If you really need to examine this value, you can check it on the `request` or the `xhr`. Will be removed in v8. - */ - readonly responseType: XMLHttpRequestResponseType; - - /** - * The total number of bytes loaded so far. To be used with {@link total} while - * calculating progress. (You will want to set {@link includeDownloadProgress} or - * {@link includeDownloadProgress}) - */ - readonly loaded: number; - - /** - * The total number of bytes to be loaded. To be used with {@link loaded} while - * calculating progress. (You will want to set {@link includeDownloadProgress} or - * {@link includeDownloadProgress}) - */ - readonly total: number; - - /** - * A dictionary of the response headers. - */ - readonly responseHeaders: Record<string, string>; - - /** - * A normalized response from an AJAX request. To get the data from the response, - * you will want to read the `response` property. - * - * - DO NOT create instances of this class directly. - * - DO NOT subclass this class. - * - * @param originalEvent The original event object from the XHR `onload` event. - * @param xhr The `XMLHttpRequest` object used to make the request. This is useful for examining status code, etc. - * @param request The request settings used to make the HTTP request. - * @param type The type of the event emitted by the {@link ajax} Observable - */ - constructor( - /** - * The original event object from the raw XHR event. - */ - public readonly originalEvent: ProgressEvent, - /** - * The XMLHttpRequest object used to make the request. - * NOTE: It is advised not to hold this in memory, as it will retain references to all of it's event handlers - * and many other things related to the request. - */ - public readonly xhr: XMLHttpRequest, - /** - * The request parameters used to make the HTTP request. - */ - public readonly request: AjaxRequest, - /** - * The event type. This can be used to discern between different events - * if you're using progress events with {@link includeDownloadProgress} or - * {@link includeUploadProgress} settings in {@link AjaxConfig}. - * - * The event type consists of two parts: the {@link AjaxDirection} and the - * the event type. Merged with `_`, they form the `type` string. The - * direction can be an `upload` or a `download` direction, while an event can - * be `loadstart`, `progress` or `load`. - * - * `download_load` is the type of event when download has finished and the - * response is available. - */ - public readonly type: AjaxResponseType = 'download_load' - ) { - const { status, responseType } = xhr; - this.status = status ?? 0; - this.responseType = responseType ?? ''; - - // Parse the response headers in advance for the user. There's really - // not a great way to get all of them. So we need to parse the header string - // we get back. It comes in a simple enough format: - // - // header-name: value here - // content-type: application/json - // other-header-here: some, other, values, or, whatever - const allHeaders = xhr.getAllResponseHeaders(); - this.responseHeaders = allHeaders - ? // Split the header text into lines - allHeaders.split('\n').reduce((headers: Record<string, string>, line) => { - // Split the lines on the first ": " as - // "key: value". Note that the value could - // technically have a ": " in it. - const index = line.indexOf(': '); - headers[line.slice(0, index)] = line.slice(index + 2); - return headers; - }, {}) - : {}; - - this.response = getXHRResponse(xhr); - const { loaded, total } = originalEvent; - this.loaded = loaded; - this.total = total; - } -} diff --git a/node_modules/rxjs/src/internal/ajax/ajax.ts b/node_modules/rxjs/src/internal/ajax/ajax.ts deleted file mode 100644 index b1628da..0000000 --- a/node_modules/rxjs/src/internal/ajax/ajax.ts +++ /dev/null @@ -1,622 +0,0 @@ -import { map } from '../operators/map'; -import { Observable } from '../Observable'; -import { AjaxConfig, AjaxRequest, AjaxDirection, ProgressEventType } from './types'; -import { AjaxResponse } from './AjaxResponse'; -import { AjaxTimeoutError, AjaxError } from './errors'; - -export interface AjaxCreationMethod { - /** - * Creates an observable that will perform an AJAX request using the - * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in - * global scope by default. - * - * This is the most configurable option, and the basis for all other AJAX calls in the library. - * - * ## Example - * - * ```ts - * import { ajax } from 'rxjs/ajax'; - * import { map, catchError, of } from 'rxjs'; - * - * const obs$ = ajax({ - * method: 'GET', - * url: 'https://api.github.com/users?per_page=5', - * responseType: 'json' - * }).pipe( - * map(userResponse => console.log('users: ', userResponse)), - * catchError(error => { - * console.log('error: ', error); - * return of(error); - * }) - * ); - * ``` - */ - <T>(config: AjaxConfig): Observable<AjaxResponse<T>>; - - /** - * Perform an HTTP GET using the - * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in - * global scope. Defaults to a `responseType` of `"json"`. - * - * ## Example - * - * ```ts - * import { ajax } from 'rxjs/ajax'; - * import { map, catchError, of } from 'rxjs'; - * - * const obs$ = ajax('https://api.github.com/users?per_page=5').pipe( - * map(userResponse => console.log('users: ', userResponse)), - * catchError(error => { - * console.log('error: ', error); - * return of(error); - * }) - * ); - * ``` - */ - <T>(url: string): Observable<AjaxResponse<T>>; - - /** - * Performs an HTTP GET using the - * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in - * global scope by default, and a `responseType` of `"json"`. - * - * @param url The URL to get the resource from - * @param headers Optional headers. Case-Insensitive. - */ - get<T>(url: string, headers?: Record<string, string>): Observable<AjaxResponse<T>>; - - /** - * Performs an HTTP POST using the - * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in - * global scope by default, and a `responseType` of `"json"`. - * - * Before sending the value passed to the `body` argument, it is automatically serialized - * based on the specified `responseType`. By default, a JavaScript object will be serialized - * to JSON. A `responseType` of `application/x-www-form-urlencoded` will flatten any provided - * dictionary object to a url-encoded string. - * - * @param url The URL to get the resource from - * @param body The content to send. The body is automatically serialized. - * @param headers Optional headers. Case-Insensitive. - */ - post<T>(url: string, body?: any, headers?: Record<string, string>): Observable<AjaxResponse<T>>; - - /** - * Performs an HTTP PUT using the - * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in - * global scope by default, and a `responseType` of `"json"`. - * - * Before sending the value passed to the `body` argument, it is automatically serialized - * based on the specified `responseType`. By default, a JavaScript object will be serialized - * to JSON. A `responseType` of `application/x-www-form-urlencoded` will flatten any provided - * dictionary object to a url-encoded string. - * - * @param url The URL to get the resource from - * @param body The content to send. The body is automatically serialized. - * @param headers Optional headers. Case-Insensitive. - */ - put<T>(url: string, body?: any, headers?: Record<string, string>): Observable<AjaxResponse<T>>; - - /** - * Performs an HTTP PATCH using the - * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in - * global scope by default, and a `responseType` of `"json"`. - * - * Before sending the value passed to the `body` argument, it is automatically serialized - * based on the specified `responseType`. By default, a JavaScript object will be serialized - * to JSON. A `responseType` of `application/x-www-form-urlencoded` will flatten any provided - * dictionary object to a url-encoded string. - * - * @param url The URL to get the resource from - * @param body The content to send. The body is automatically serialized. - * @param headers Optional headers. Case-Insensitive. - */ - patch<T>(url: string, body?: any, headers?: Record<string, string>): Observable<AjaxResponse<T>>; - - /** - * Performs an HTTP DELETE using the - * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in - * global scope by default, and a `responseType` of `"json"`. - * - * @param url The URL to get the resource from - * @param headers Optional headers. Case-Insensitive. - */ - delete<T>(url: string, headers?: Record<string, string>): Observable<AjaxResponse<T>>; - - /** - * Performs an HTTP GET using the - * [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) in - * global scope by default, and returns the hydrated JavaScript object from the - * response. - * - * @param url The URL to get the resource from - * @param headers Optional headers. Case-Insensitive. - */ - getJSON<T>(url: string, headers?: Record<string, string>): Observable<T>; -} - -function ajaxGet<T>(url: string, headers?: Record<string, string>): Observable<AjaxResponse<T>> { - return ajax({ method: 'GET', url, headers }); -} - -function ajaxPost<T>(url: string, body?: any, headers?: Record<string, string>): Observable<AjaxResponse<T>> { - return ajax({ method: 'POST', url, body, headers }); -} - -function ajaxDelete<T>(url: string, headers?: Record<string, string>): Observable<AjaxResponse<T>> { - return ajax({ method: 'DELETE', url, headers }); -} - -function ajaxPut<T>(url: string, body?: any, headers?: Record<string, string>): Observable<AjaxResponse<T>> { - return ajax({ method: 'PUT', url, body, headers }); -} - -function ajaxPatch<T>(url: string, body?: any, headers?: Record<string, string>): Observable<AjaxResponse<T>> { - return ajax({ method: 'PATCH', url, body, headers }); -} - -const mapResponse = map((x: AjaxResponse<any>) => x.response); - -function ajaxGetJSON<T>(url: string, headers?: Record<string, string>): Observable<T> { - return mapResponse( - ajax<T>({ - method: 'GET', - url, - headers, - }) - ); -} - -/** - * There is an ajax operator on the Rx object. - * - * It creates an observable for an Ajax request with either a request object with - * url, headers, etc or a string for a URL. - * - * ## Examples - * - * Using `ajax()` to fetch the response object that is being returned from API - * - * ```ts - * import { ajax } from 'rxjs/ajax'; - * import { map, catchError, of } from 'rxjs'; - * - * const obs$ = ajax('https://api.github.com/users?per_page=5').pipe( - * map(userResponse => console.log('users: ', userResponse)), - * catchError(error => { - * console.log('error: ', error); - * return of(error); - * }) - * ); - * - * obs$.subscribe({ - * next: value => console.log(value), - * error: err => console.log(err) - * }); - * ``` - * - * Using `ajax.getJSON()` to fetch data from API - * - * ```ts - * import { ajax } from 'rxjs/ajax'; - * import { map, catchError, of } from 'rxjs'; - * - * const obs$ = ajax.getJSON('https://api.github.com/users?per_page=5').pipe( - * map(userResponse => console.log('users: ', userResponse)), - * catchError(error => { - * console.log('error: ', error); - * return of(error); - * }) - * ); - * - * obs$.subscribe({ - * next: value => console.log(value), - * error: err => console.log(err) - * }); - * ``` - * - * Using `ajax()` with object as argument and method POST with a two seconds delay - * - * ```ts - * import { ajax } from 'rxjs/ajax'; - * import { map, catchError, of } from 'rxjs'; - * - * const users = ajax({ - * url: 'https://httpbin.org/delay/2', - * method: 'POST', - * headers: { - * 'Content-Type': 'application/json', - * 'rxjs-custom-header': 'Rxjs' - * }, - * body: { - * rxjs: 'Hello World!' - * } - * }).pipe( - * map(response => console.log('response: ', response)), - * catchError(error => { - * console.log('error: ', error); - * return of(error); - * }) - * ); - * - * users.subscribe({ - * next: value => console.log(value), - * error: err => console.log(err) - * }); - * ``` - * - * Using `ajax()` to fetch. An error object that is being returned from the request - * - * ```ts - * import { ajax } from 'rxjs/ajax'; - * import { map, catchError, of } from 'rxjs'; - * - * const obs$ = ajax('https://api.github.com/404').pipe( - * map(userResponse => console.log('users: ', userResponse)), - * catchError(error => { - * console.log('error: ', error); - * return of(error); - * }) - * ); - * - * obs$.subscribe({ - * next: value => console.log(value), - * error: err => console.log(err) - * }); - * ``` - */ -export const ajax: AjaxCreationMethod = (() => { - const create = <T>(urlOrConfig: string | AjaxConfig) => { - const config: AjaxConfig = - typeof urlOrConfig === 'string' - ? { - url: urlOrConfig, - } - : urlOrConfig; - return fromAjax<T>(config); - }; - - create.get = ajaxGet; - create.post = ajaxPost; - create.delete = ajaxDelete; - create.put = ajaxPut; - create.patch = ajaxPatch; - create.getJSON = ajaxGetJSON; - - return create; -})(); - -const UPLOAD = 'upload'; -const DOWNLOAD = 'download'; -const LOADSTART = 'loadstart'; -const PROGRESS = 'progress'; -const LOAD = 'load'; - -export function fromAjax<T>(init: AjaxConfig): Observable<AjaxResponse<T>> { - return new Observable((destination) => { - const config = { - // Defaults - async: true, - crossDomain: false, - withCredentials: false, - method: 'GET', - timeout: 0, - responseType: 'json' as XMLHttpRequestResponseType, - - ...init, - }; - - const { queryParams, body: configuredBody, headers: configuredHeaders } = config; - - let url = config.url; - if (!url) { - throw new TypeError('url is required'); - } - - if (queryParams) { - let searchParams: URLSearchParams; - if (url.includes('?')) { - // If the user has passed a URL with a querystring already in it, - // we need to combine them. So we're going to split it. There - // should only be one `?` in a valid URL. - const parts = url.split('?'); - if (2 < parts.length) { - throw new TypeError('invalid url'); - } - // Add the passed queryParams to the params already in the url provided. - searchParams = new URLSearchParams(parts[1]); - // queryParams is converted to any because the runtime is *much* more permissive than - // the types are. - new URLSearchParams(queryParams as any).forEach((value, key) => searchParams.set(key, value)); - // We have to do string concatenation here, because `new URL(url)` does - // not like relative URLs like `/this` without a base url, which we can't - // specify, nor can we assume `location` will exist, because of node. - url = parts[0] + '?' + searchParams; - } else { - // There is no preexisting querystring, so we can just use URLSearchParams - // to convert the passed queryParams into the proper format and encodings. - // queryParams is converted to any because the runtime is *much* more permissive than - // the types are. - searchParams = new URLSearchParams(queryParams as any); - url = url + '?' + searchParams; - } - } - - // Normalize the headers. We're going to make them all lowercase, since - // Headers are case insensitive by design. This makes it easier to verify - // that we aren't setting or sending duplicates. - const headers: Record<string, any> = {}; - if (configuredHeaders) { - for (const key in configuredHeaders) { - if (configuredHeaders.hasOwnProperty(key)) { - headers[key.toLowerCase()] = configuredHeaders[key]; - } - } - } - - const crossDomain = config.crossDomain; - - // Set the x-requested-with header. This is a non-standard header that has - // come to be a de facto standard for HTTP requests sent by libraries and frameworks - // using XHR. However, we DO NOT want to set this if it is a CORS request. This is - // because sometimes this header can cause issues with CORS. To be clear, - // None of this is necessary, it's only being set because it's "the thing libraries do" - // Starting back as far as JQuery, and continuing with other libraries such as Angular 1, - // Axios, et al. - if (!crossDomain && !('x-requested-with' in headers)) { - headers['x-requested-with'] = 'XMLHttpRequest'; - } - - // Allow users to provide their XSRF cookie name and the name of a custom header to use to - // send the cookie. - const { withCredentials, xsrfCookieName, xsrfHeaderName } = config; - if ((withCredentials || !crossDomain) && xsrfCookieName && xsrfHeaderName) { - const xsrfCookie = document?.cookie.match(new RegExp(`(^|;\\s*)(${xsrfCookieName})=([^;]*)`))?.pop() ?? ''; - if (xsrfCookie) { - headers[xsrfHeaderName] = xsrfCookie; - } - } - - // Examine the body and determine whether or not to serialize it - // and set the content-type in `headers`, if we're able. - const body = extractContentTypeAndMaybeSerializeBody(configuredBody, headers); - - // The final request settings. - const _request: Readonly<AjaxRequest> = { - ...config, - - // Set values we ensured above - url, - headers, - body, - }; - - let xhr: XMLHttpRequest; - - // Create our XHR so we can get started. - xhr = init.createXHR ? init.createXHR() : new XMLHttpRequest(); - - { - /////////////////////////////////////////////////// - // set up the events before open XHR - // https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest - // You need to add the event listeners before calling open() on the request. - // Otherwise the progress events will not fire. - /////////////////////////////////////////////////// - - const { progressSubscriber, includeDownloadProgress = false, includeUploadProgress = false } = init; - - /** - * Wires up an event handler that will emit an error when fired. Used - * for timeout and abort events. - * @param type The type of event we're treating as an error - * @param errorFactory A function that creates the type of error to emit. - */ - const addErrorEvent = (type: string, errorFactory: () => any) => { - xhr.addEventListener(type, () => { - const error = errorFactory(); - progressSubscriber?.error?.(error); - destination.error(error); - }); - }; - - // If the request times out, handle errors appropriately. - addErrorEvent('timeout', () => new AjaxTimeoutError(xhr, _request)); - - // If the request aborts (due to a network disconnection or the like), handle - // it as an error. - addErrorEvent('abort', () => new AjaxError('aborted', xhr, _request)); - - /** - * Creates a response object to emit to the consumer. - * @param direction the direction related to the event. Prefixes the event `type` in the - * `AjaxResponse` object with "upload_" for events related to uploading and "download_" - * for events related to downloading. - * @param event the actual event object. - */ - const createResponse = (direction: AjaxDirection, event: ProgressEvent) => - new AjaxResponse<T>(event, xhr, _request, `${direction}_${event.type as ProgressEventType}` as const); - - /** - * Wires up an event handler that emits a Response object to the consumer, used for - * all events that emit responses, loadstart, progress, and load. - * Note that download load handling is a bit different below, because it has - * more logic it needs to run. - * @param target The target, either the XHR itself or the Upload object. - * @param type The type of event to wire up - * @param direction The "direction", used to prefix the response object that is - * emitted to the consumer. (e.g. "upload_" or "download_") - */ - const addProgressEvent = (target: any, type: string, direction: AjaxDirection) => { - target.addEventListener(type, (event: ProgressEvent) => { - destination.next(createResponse(direction, event)); - }); - }; - - if (includeUploadProgress) { - [LOADSTART, PROGRESS, LOAD].forEach((type) => addProgressEvent(xhr.upload, type, UPLOAD)); - } - - if (progressSubscriber) { - [LOADSTART, PROGRESS].forEach((type) => xhr.upload.addEventListener(type, (e: any) => progressSubscriber?.next?.(e))); - } - - if (includeDownloadProgress) { - [LOADSTART, PROGRESS].forEach((type) => addProgressEvent(xhr, type, DOWNLOAD)); - } - - const emitError = (status?: number) => { - const msg = 'ajax error' + (status ? ' ' + status : ''); - destination.error(new AjaxError(msg, xhr, _request)); - }; - - xhr.addEventListener('error', (e) => { - progressSubscriber?.error?.(e); - emitError(); - }); - - xhr.addEventListener(LOAD, (event) => { - const { status } = xhr; - // 4xx and 5xx should error (https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html) - if (status < 400) { - progressSubscriber?.complete?.(); - - let response: AjaxResponse<T>; - try { - // This can throw in IE, because we end up needing to do a JSON.parse - // of the response in some cases to produce object we'd expect from - // modern browsers. - response = createResponse(DOWNLOAD, event); - } catch (err) { - destination.error(err); - return; - } - - destination.next(response); - destination.complete(); - } else { - progressSubscriber?.error?.(event); - emitError(status); - } - }); - } - - const { user, method, async } = _request; - // open XHR - if (user) { - xhr.open(method, url, async, user, _request.password); - } else { - xhr.open(method, url, async); - } - - // timeout, responseType and withCredentials can be set once the XHR is open - if (async) { - xhr.timeout = _request.timeout; - xhr.responseType = _request.responseType; - } - - if ('withCredentials' in xhr) { - xhr.withCredentials = _request.withCredentials; - } - - // set headers - for (const key in headers) { - if (headers.hasOwnProperty(key)) { - xhr.setRequestHeader(key, headers[key]); - } - } - - // finally send the request - if (body) { - xhr.send(body); - } else { - xhr.send(); - } - - return () => { - if (xhr && xhr.readyState !== 4 /*XHR done*/) { - xhr.abort(); - } - }; - }); -} - -/** - * Examines the body to determine if we need to serialize it for them or not. - * If the body is a type that XHR handles natively, we just allow it through, - * otherwise, if the body is something that *we* can serialize for the user, - * we will serialize it, and attempt to set the `content-type` header, if it's - * not already set. - * @param body The body passed in by the user - * @param headers The normalized headers - */ -function extractContentTypeAndMaybeSerializeBody(body: any, headers: Record<string, string>) { - if ( - !body || - typeof body === 'string' || - isFormData(body) || - isURLSearchParams(body) || - isArrayBuffer(body) || - isFile(body) || - isBlob(body) || - isReadableStream(body) - ) { - // The XHR instance itself can handle serializing these, and set the content-type for us - // so we don't need to do that. https://xhr.spec.whatwg.org/#the-send()-method - return body; - } - - if (isArrayBufferView(body)) { - // This is a typed array (e.g. Float32Array or Uint8Array), or a DataView. - // XHR can handle this one too: https://fetch.spec.whatwg.org/#concept-bodyinit-extract - return body.buffer; - } - - if (typeof body === 'object') { - // If we have made it here, this is an object, probably a POJO, and we'll try - // to serialize it for them. If this doesn't work, it will throw, obviously, which - // is okay. The workaround for users would be to manually set the body to their own - // serialized string (accounting for circular references or whatever), then set - // the content-type manually as well. - headers['content-type'] = headers['content-type'] ?? 'application/json;charset=utf-8'; - return JSON.stringify(body); - } - - // If we've gotten past everything above, this is something we don't quite know how to - // handle. Throw an error. This will be caught and emitted from the observable. - throw new TypeError('Unknown body type'); -} - -const _toString = Object.prototype.toString; - -function toStringCheck(obj: any, name: string): boolean { - return _toString.call(obj) === `[object ${name}]`; -} - -function isArrayBuffer(body: any): body is ArrayBuffer { - return toStringCheck(body, 'ArrayBuffer'); -} - -function isFile(body: any): body is File { - return toStringCheck(body, 'File'); -} - -function isBlob(body: any): body is Blob { - return toStringCheck(body, 'Blob'); -} - -function isArrayBufferView(body: any): body is ArrayBufferView { - return typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView(body); -} - -function isFormData(body: any): body is FormData { - return typeof FormData !== 'undefined' && body instanceof FormData; -} - -function isURLSearchParams(body: any): body is URLSearchParams { - return typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams; -} - -function isReadableStream(body: any): body is ReadableStream { - return typeof ReadableStream !== 'undefined' && body instanceof ReadableStream; -} diff --git a/node_modules/rxjs/src/internal/ajax/errors.ts b/node_modules/rxjs/src/internal/ajax/errors.ts deleted file mode 100644 index 36b6dc7..0000000 --- a/node_modules/rxjs/src/internal/ajax/errors.ts +++ /dev/null @@ -1,102 +0,0 @@ -import { AjaxRequest } from './types'; -import { getXHRResponse } from './getXHRResponse'; -import { createErrorClass } from '../util/createErrorClass'; - -/** - * A normalized AJAX error. - * - * @see {@link ajax} - */ -export interface AjaxError extends Error { - /** - * The XHR instance associated with the error. - */ - xhr: XMLHttpRequest; - - /** - * The AjaxRequest associated with the error. - */ - request: AjaxRequest; - - /** - * The HTTP status code, if the request has completed. If not, - * it is set to `0`. - */ - status: number; - - /** - * The responseType (e.g. 'json', 'arraybuffer', or 'xml'). - */ - responseType: XMLHttpRequestResponseType; - - /** - * The response data. - */ - response: any; -} - -export interface AjaxErrorCtor { - /** - * @deprecated Internal implementation detail. Do not construct error instances. - * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269 - */ - new (message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError; -} - -/** - * Thrown when an error occurs during an AJAX request. - * This is only exported because it is useful for checking to see if an error - * is an `instanceof AjaxError`. DO NOT create new instances of `AjaxError` with - * the constructor. - * - * @see {@link ajax} - */ -export const AjaxError: AjaxErrorCtor = createErrorClass( - (_super) => - function AjaxErrorImpl(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest) { - this.message = message; - this.name = 'AjaxError'; - this.xhr = xhr; - this.request = request; - this.status = xhr.status; - this.responseType = xhr.responseType; - let response: any; - try { - // This can throw in IE, because we have to do a JSON.parse of - // the response in some cases to get the expected response property. - response = getXHRResponse(xhr); - } catch (err) { - response = xhr.responseText; - } - this.response = response; - } -); - -export interface AjaxTimeoutError extends AjaxError {} - -export interface AjaxTimeoutErrorCtor { - /** - * @deprecated Internal implementation detail. Do not construct error instances. - * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269 - */ - new (xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError; -} - -/** - * Thrown when an AJAX request times out. Not to be confused with {@link TimeoutError}. - * - * This is exported only because it is useful for checking to see if errors are an - * `instanceof AjaxTimeoutError`. DO NOT use the constructor to create an instance of - * this type. - * - * @see {@link ajax} - */ -export const AjaxTimeoutError: AjaxTimeoutErrorCtor = (() => { - function AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) { - AjaxError.call(this, 'ajax timeout', xhr, request); - this.name = 'AjaxTimeoutError'; - return this; - } - AjaxTimeoutErrorImpl.prototype = Object.create(AjaxError.prototype); - return AjaxTimeoutErrorImpl; -})() as any; diff --git a/node_modules/rxjs/src/internal/ajax/getXHRResponse.ts b/node_modules/rxjs/src/internal/ajax/getXHRResponse.ts deleted file mode 100644 index 34d7031..0000000 --- a/node_modules/rxjs/src/internal/ajax/getXHRResponse.ts +++ /dev/null @@ -1,37 +0,0 @@ -/** - * Gets what should be in the `response` property of the XHR. However, - * since we still support the final versions of IE, we need to do a little - * checking here to make sure that we get the right thing back. Consequently, - * we need to do a JSON.parse() in here, which *could* throw if the response - * isn't valid JSON. - * - * This is used both in creating an AjaxResponse, and in creating certain errors - * that we throw, so we can give the user whatever was in the response property. - * - * @param xhr The XHR to examine the response of - */ -export function getXHRResponse(xhr: XMLHttpRequest) { - switch (xhr.responseType) { - case 'json': { - if ('response' in xhr) { - return xhr.response; - } else { - // IE - const ieXHR: any = xhr; - return JSON.parse(ieXHR.responseText); - } - } - case 'document': - return xhr.responseXML; - case 'text': - default: { - if ('response' in xhr) { - return xhr.response; - } else { - // IE - const ieXHR: any = xhr; - return ieXHR.responseText; - } - } - } -} diff --git a/node_modules/rxjs/src/internal/ajax/types.ts b/node_modules/rxjs/src/internal/ajax/types.ts deleted file mode 100644 index 96e8a91..0000000 --- a/node_modules/rxjs/src/internal/ajax/types.ts +++ /dev/null @@ -1,235 +0,0 @@ -import { PartialObserver } from '../types'; - -/** - * Valid Ajax direction types. Prefixes the event `type` in the - * {@link AjaxResponse} object with "upload_" for events related - * to uploading and "download_" for events related to downloading. - */ -export type AjaxDirection = 'upload' | 'download'; - -export type ProgressEventType = 'loadstart' | 'progress' | 'load'; - -export type AjaxResponseType = `${AjaxDirection}_${ProgressEventType}`; - -/** - * The object containing values RxJS used to make the HTTP request. - * - * This is provided in {@link AjaxError} instances as the `request` - * object. - */ -export interface AjaxRequest { - /** - * The URL requested. - */ - url: string; - - /** - * The body to send over the HTTP request. - */ - body?: any; - - /** - * The HTTP method used to make the HTTP request. - */ - method: string; - - /** - * Whether or not the request was made asynchronously. - */ - async: boolean; - - /** - * The headers sent over the HTTP request. - */ - headers: Readonly<Record<string, any>>; - - /** - * The timeout value used for the HTTP request. - * Note: this is only honored if the request is asynchronous (`async` is `true`). - */ - timeout: number; - - /** - * The user credentials user name sent with the HTTP request. - */ - user?: string; - - /** - * The user credentials password sent with the HTTP request. - */ - password?: string; - - /** - * Whether or not the request was a CORS request. - */ - crossDomain: boolean; - - /** - * Whether or not a CORS request was sent with credentials. - * If `false`, will also ignore cookies in the CORS response. - */ - withCredentials: boolean; - - /** - * The [`responseType`](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType) set before sending the request. - */ - responseType: XMLHttpRequestResponseType; -} - -/** - * Configuration for the {@link ajax} creation function. - */ -export interface AjaxConfig { - /** The address of the resource to request via HTTP. */ - url: string; - - /** - * The body of the HTTP request to send. - * - * This is serialized, by default, based off of the value of the `"content-type"` header. - * For example, if the `"content-type"` is `"application/json"`, the body will be serialized - * as JSON. If the `"content-type"` is `"application/x-www-form-urlencoded"`, whatever object passed - * to the body will be serialized as URL, using key-value pairs based off of the keys and values of the object. - * In all other cases, the body will be passed directly. - */ - body?: any; - - /** - * Whether or not to send the request asynchronously. Defaults to `true`. - * If set to `false`, this will block the thread until the AJAX request responds. - */ - async?: boolean; - - /** - * The HTTP Method to use for the request. Defaults to "GET". - */ - method?: string; - - /** - * The HTTP headers to apply. - * - * Note that, by default, RxJS will add the following headers under certain conditions: - * - * 1. If the `"content-type"` header is **NOT** set, and the `body` is [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData), - * a `"content-type"` of `"application/x-www-form-urlencoded; charset=UTF-8"` will be set automatically. - * 2. If the `"x-requested-with"` header is **NOT** set, and the `crossDomain` configuration property is **NOT** explicitly set to `true`, - * (meaning it is not a CORS request), a `"x-requested-with"` header with a value of `"XMLHttpRequest"` will be set automatically. - * This header is generally meaningless, and is set by libraries and frameworks using `XMLHttpRequest` to make HTTP requests. - */ - headers?: Readonly<Record<string, any>>; - - /** - * The time to wait before causing the underlying XMLHttpRequest to timeout. This is only honored if the - * `async` configuration setting is unset or set to `true`. Defaults to `0`, which is idiomatic for "never timeout". - */ - timeout?: number; - - /** The user credentials user name to send with the HTTP request */ - user?: string; - - /** The user credentials password to send with the HTTP request*/ - password?: string; - - /** - * Whether or not to send the HTTP request as a CORS request. - * Defaults to `false`. - * - * @deprecated Will be removed in version 8. Cross domain requests and what creates a cross - * domain request, are dictated by the browser, and a boolean that forces it to be cross domain - * does not make sense. If you need to force cross domain, make sure you're making a secure request, - * then add a custom header to the request or use `withCredentials`. For more information on what - * triggers a cross domain request, see the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials). - * In particular, the section on [Simple Requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#Simple_requests) is useful - * for understanding when CORS will not be used. - */ - crossDomain?: boolean; - - /** - * To send user credentials in a CORS request, set to `true`. To exclude user credentials from - * a CORS request, _OR_ when cookies are to be ignored by the CORS response, set to `false`. - * - * Defaults to `false`. - */ - withCredentials?: boolean; - - /** - * The name of your site's XSRF cookie. - */ - xsrfCookieName?: string; - - /** - * The name of a custom header that you can use to send your XSRF cookie. - */ - xsrfHeaderName?: string; - - /** - * Can be set to change the response type. - * Valid values are `"arraybuffer"`, `"blob"`, `"document"`, `"json"`, and `"text"`. - * Note that the type of `"document"` (such as an XML document) is ignored if the global context is - * not `Window`. - * - * Defaults to `"json"`. - */ - responseType?: XMLHttpRequestResponseType; - - /** - * An optional factory used to create the XMLHttpRequest object used to make the AJAX request. - * This is useful in environments that lack `XMLHttpRequest`, or in situations where you - * wish to override the default `XMLHttpRequest` for some reason. - * - * If not provided, the `XMLHttpRequest` in global scope will be used. - * - * NOTE: This AJAX implementation relies on the built-in serialization and setting - * of Content-Type headers that is provided by standards-compliant XMLHttpRequest implementations, - * be sure any implementation you use meets that standard. - */ - createXHR?: () => XMLHttpRequest; - - /** - * An observer for watching the upload progress of an HTTP request. Will - * emit progress events, and completes on the final upload load event, will error for - * any XHR error or timeout. - * - * This will **not** error for errored status codes. Rather, it will always _complete_ when - * the HTTP response comes back. - * - * @deprecated If you're looking for progress events, use {@link includeDownloadProgress} and - * {@link includeUploadProgress} instead. Will be removed in v8. - */ - progressSubscriber?: PartialObserver<ProgressEvent>; - - /** - * If `true`, will emit all download progress and load complete events as {@link AjaxResponse} - * from the observable. The final download event will also be emitted as a {@link AjaxResponse}. - * - * If both this and {@link includeUploadProgress} are `false`, then only the {@link AjaxResponse} will - * be emitted from the resulting observable. - */ - includeDownloadProgress?: boolean; - - /** - * If `true`, will emit all upload progress and load complete events as {@link AjaxResponse} - * from the observable. The final download event will also be emitted as a {@link AjaxResponse}. - * - * If both this and {@link includeDownloadProgress} are `false`, then only the {@link AjaxResponse} will - * be emitted from the resulting observable. - */ - includeUploadProgress?: boolean; - - /** - * Query string parameters to add to the URL in the request. - * <em>This will require a polyfill for `URL` and `URLSearchParams` in Internet Explorer!</em> - * - * Accepts either a query string, a `URLSearchParams` object, a dictionary of key/value pairs, or an - * array of key/value entry tuples. (Essentially, it takes anything that `new URLSearchParams` would normally take). - * - * If, for some reason you have a query string in the `url` argument, this will append to the query string in the url, - * but it will also overwrite the value of any keys that are an exact match. In other words, a url of `/test?a=1&b=2`, - * with queryParams of `{ b: 5, c: 6 }` will result in a url of roughly `/test?a=1&b=5&c=6`. - */ - queryParams?: - | string - | URLSearchParams - | Record<string, string | number | boolean | string[] | number[] | boolean[]> - | [string, string | number | boolean | string[] | number[] | boolean[]][]; -} diff --git a/node_modules/rxjs/src/internal/config.ts b/node_modules/rxjs/src/internal/config.ts deleted file mode 100644 index 99461db..0000000 --- a/node_modules/rxjs/src/internal/config.ts +++ /dev/null @@ -1,84 +0,0 @@ -import { Subscriber } from './Subscriber'; -import { ObservableNotification } from './types'; - -/** - * The {@link GlobalConfig} object for RxJS. It is used to configure things - * like how to react on unhandled errors. - */ -export const config: GlobalConfig = { - onUnhandledError: null, - onStoppedNotification: null, - Promise: undefined, - useDeprecatedSynchronousErrorHandling: false, - useDeprecatedNextContext: false, -}; - -/** - * The global configuration object for RxJS, used to configure things - * like how to react on unhandled errors. Accessible via {@link config} - * object. - */ -export interface GlobalConfig { - /** - * A registration point for unhandled errors from RxJS. These are errors that - * cannot were not handled by consuming code in the usual subscription path. For - * example, if you have this configured, and you subscribe to an observable without - * providing an error handler, errors from that subscription will end up here. This - * will _always_ be called asynchronously on another job in the runtime. This is because - * we do not want errors thrown in this user-configured handler to interfere with the - * behavior of the library. - */ - onUnhandledError: ((err: any) => void) | null; - - /** - * A registration point for notifications that cannot be sent to subscribers because they - * have completed, errored or have been explicitly unsubscribed. By default, next, complete - * and error notifications sent to stopped subscribers are noops. However, sometimes callers - * might want a different behavior. For example, with sources that attempt to report errors - * to stopped subscribers, a caller can configure RxJS to throw an unhandled error instead. - * This will _always_ be called asynchronously on another job in the runtime. This is because - * we do not want errors thrown in this user-configured handler to interfere with the - * behavior of the library. - */ - onStoppedNotification: ((notification: ObservableNotification<any>, subscriber: Subscriber<any>) => void) | null; - - /** - * The promise constructor used by default for {@link Observable#toPromise toPromise} and {@link Observable#forEach forEach} - * methods. - * - * @deprecated As of version 8, RxJS will no longer support this sort of injection of a - * Promise constructor. If you need a Promise implementation other than native promises, - * please polyfill/patch Promise as you see appropriate. Will be removed in v8. - */ - Promise?: PromiseConstructorLike; - - /** - * If true, turns on synchronous error rethrowing, which is a deprecated behavior - * in v6 and higher. This behavior enables bad patterns like wrapping a subscribe - * call in a try/catch block. It also enables producer interference, a nasty bug - * where a multicast can be broken for all observers by a downstream consumer with - * an unhandled error. DO NOT USE THIS FLAG UNLESS IT'S NEEDED TO BUY TIME - * FOR MIGRATION REASONS. - * - * @deprecated As of version 8, RxJS will no longer support synchronous throwing - * of unhandled errors. All errors will be thrown on a separate call stack to prevent bad - * behaviors described above. Will be removed in v8. - */ - useDeprecatedSynchronousErrorHandling: boolean; - - /** - * If true, enables an as-of-yet undocumented feature from v5: The ability to access - * `unsubscribe()` via `this` context in `next` functions created in observers passed - * to `subscribe`. - * - * This is being removed because the performance was severely problematic, and it could also cause - * issues when types other than POJOs are passed to subscribe as subscribers, as they will likely have - * their `this` context overwritten. - * - * @deprecated As of version 8, RxJS will no longer support altering the - * context of next functions provided as part of an observer to Subscribe. Instead, - * you will have access to a subscription or a signal or token that will allow you to do things like - * unsubscribe and test closed status. Will be removed in v8. - */ - useDeprecatedNextContext: boolean; -} diff --git a/node_modules/rxjs/src/internal/firstValueFrom.ts b/node_modules/rxjs/src/internal/firstValueFrom.ts deleted file mode 100644 index 2fc4bcf..0000000 --- a/node_modules/rxjs/src/internal/firstValueFrom.ts +++ /dev/null @@ -1,75 +0,0 @@ -import { Observable } from './Observable'; -import { EmptyError } from './util/EmptyError'; -import { SafeSubscriber } from './Subscriber'; - -export interface FirstValueFromConfig<T> { - defaultValue: T; -} - -export function firstValueFrom<T, D>(source: Observable<T>, config: FirstValueFromConfig<D>): Promise<T | D>; -export function firstValueFrom<T>(source: Observable<T>): Promise<T>; - -/** - * Converts an observable to a promise by subscribing to the observable, - * and returning a promise that will resolve as soon as the first value - * arrives from the observable. The subscription will then be closed. - * - * If the observable stream completes before any values were emitted, the - * returned promise will reject with {@link EmptyError} or will resolve - * with the default value if a default was specified. - * - * If the observable stream emits an error, the returned promise will reject - * with that error. - * - * **WARNING**: Only use this with observables you *know* will emit at least one value, - * *OR* complete. If the source observable does not emit one value or complete, you will - * end up with a promise that is hung up, and potentially all of the state of an - * async function hanging out in memory. To avoid this situation, look into adding - * something like {@link timeout}, {@link take}, {@link takeWhile}, or {@link takeUntil} - * amongst others. - * - * ## Example - * - * Wait for the first value from a stream and emit it from a promise in - * an async function - * - * ```ts - * import { interval, firstValueFrom } from 'rxjs'; - * - * async function execute() { - * const source$ = interval(2000); - * const firstNumber = await firstValueFrom(source$); - * console.log(`The first number is ${ firstNumber }`); - * } - * - * execute(); - * - * // Expected output: - * // 'The first number is 0' - * ``` - * - * @see {@link lastValueFrom} - * - * @param source the observable to convert to a promise - * @param config a configuration object to define the `defaultValue` to use if the source completes without emitting a value - */ -export function firstValueFrom<T, D>(source: Observable<T>, config?: FirstValueFromConfig<D>): Promise<T | D> { - const hasConfig = typeof config === 'object'; - return new Promise<T | D>((resolve, reject) => { - const subscriber = new SafeSubscriber<T>({ - next: (value) => { - resolve(value); - subscriber.unsubscribe(); - }, - error: reject, - complete: () => { - if (hasConfig) { - resolve(config!.defaultValue); - } else { - reject(new EmptyError()); - } - }, - }); - source.subscribe(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/lastValueFrom.ts b/node_modules/rxjs/src/internal/lastValueFrom.ts deleted file mode 100644 index 90fcebf..0000000 --- a/node_modules/rxjs/src/internal/lastValueFrom.ts +++ /dev/null @@ -1,76 +0,0 @@ -import { Observable } from './Observable'; -import { EmptyError } from './util/EmptyError'; - -export interface LastValueFromConfig<T> { - defaultValue: T; -} - -export function lastValueFrom<T, D>(source: Observable<T>, config: LastValueFromConfig<D>): Promise<T | D>; -export function lastValueFrom<T>(source: Observable<T>): Promise<T>; - -/** - * Converts an observable to a promise by subscribing to the observable, - * waiting for it to complete, and resolving the returned promise with the - * last value from the observed stream. - * - * If the observable stream completes before any values were emitted, the - * returned promise will reject with {@link EmptyError} or will resolve - * with the default value if a default was specified. - * - * If the observable stream emits an error, the returned promise will reject - * with that error. - * - * **WARNING**: Only use this with observables you *know* will complete. If the source - * observable does not complete, you will end up with a promise that is hung up, and - * potentially all of the state of an async function hanging out in memory. To avoid - * this situation, look into adding something like {@link timeout}, {@link take}, - * {@link takeWhile}, or {@link takeUntil} amongst others. - * - * ## Example - * - * Wait for the last value from a stream and emit it from a promise in - * an async function - * - * ```ts - * import { interval, take, lastValueFrom } from 'rxjs'; - * - * async function execute() { - * const source$ = interval(2000).pipe(take(10)); - * const finalNumber = await lastValueFrom(source$); - * console.log(`The final number is ${ finalNumber }`); - * } - * - * execute(); - * - * // Expected output: - * // 'The final number is 9' - * ``` - * - * @see {@link firstValueFrom} - * - * @param source the observable to convert to a promise - * @param config a configuration object to define the `defaultValue` to use if the source completes without emitting a value - */ -export function lastValueFrom<T, D>(source: Observable<T>, config?: LastValueFromConfig<D>): Promise<T | D> { - const hasConfig = typeof config === 'object'; - return new Promise<T | D>((resolve, reject) => { - let _hasValue = false; - let _value: T; - source.subscribe({ - next: (value) => { - _value = value; - _hasValue = true; - }, - error: reject, - complete: () => { - if (_hasValue) { - resolve(_value); - } else if (hasConfig) { - resolve(config!.defaultValue); - } else { - reject(new EmptyError()); - } - }, - }); - }); -} 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; -} diff --git a/node_modules/rxjs/src/internal/operators/OperatorSubscriber.ts b/node_modules/rxjs/src/internal/operators/OperatorSubscriber.ts deleted file mode 100644 index 593b937..0000000 --- a/node_modules/rxjs/src/internal/operators/OperatorSubscriber.ts +++ /dev/null @@ -1,112 +0,0 @@ -import { Subscriber } from '../Subscriber'; - -/** - * Creates an instance of an `OperatorSubscriber`. - * @param destination The downstream subscriber. - * @param onNext Handles next values, only called if this subscriber is not stopped or closed. Any - * error that occurs in this function is caught and sent to the `error` method of this subscriber. - * @param onError Handles errors from the subscription, any errors that occur in this handler are caught - * and send to the `destination` error handler. - * @param onComplete Handles completion notification from the subscription. Any errors that occur in - * this handler are sent to the `destination` error handler. - * @param onFinalize Additional teardown logic here. This will only be called on teardown if the - * subscriber itself is not already closed. This is called after all other teardown logic is executed. - */ -export function createOperatorSubscriber<T>( - destination: Subscriber<any>, - onNext?: (value: T) => void, - onComplete?: () => void, - onError?: (err: any) => void, - onFinalize?: () => void -): Subscriber<T> { - return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize); -} - -/** - * A generic helper for allowing operators to be created with a Subscriber and - * use closures to capture necessary state from the operator function itself. - */ -export class OperatorSubscriber<T> extends Subscriber<T> { - /** - * Creates an instance of an `OperatorSubscriber`. - * @param destination The downstream subscriber. - * @param onNext Handles next values, only called if this subscriber is not stopped or closed. Any - * error that occurs in this function is caught and sent to the `error` method of this subscriber. - * @param onError Handles errors from the subscription, any errors that occur in this handler are caught - * and send to the `destination` error handler. - * @param onComplete Handles completion notification from the subscription. Any errors that occur in - * this handler are sent to the `destination` error handler. - * @param onFinalize Additional finalization logic here. This will only be called on finalization if the - * subscriber itself is not already closed. This is called after all other finalization logic is executed. - * @param shouldUnsubscribe An optional check to see if an unsubscribe call should truly unsubscribe. - * NOTE: This currently **ONLY** exists to support the strange behavior of {@link groupBy}, where unsubscription - * to the resulting observable does not actually disconnect from the source if there are active subscriptions - * to any grouped observable. (DO NOT EXPOSE OR USE EXTERNALLY!!!) - */ - constructor( - destination: Subscriber<any>, - onNext?: (value: T) => void, - onComplete?: () => void, - onError?: (err: any) => void, - private onFinalize?: () => void, - private shouldUnsubscribe?: () => boolean - ) { - // It's important - for performance reasons - that all of this class's - // members are initialized and that they are always initialized in the same - // order. This will ensure that all OperatorSubscriber instances have the - // same hidden class in V8. This, in turn, will help keep the number of - // hidden classes involved in property accesses within the base class as - // low as possible. If the number of hidden classes involved exceeds four, - // the property accesses will become megamorphic and performance penalties - // will be incurred - i.e. inline caches won't be used. - // - // The reasons for ensuring all instances have the same hidden class are - // further discussed in this blog post from Benedikt Meurer: - // https://benediktmeurer.de/2018/03/23/impact-of-polymorphism-on-component-based-frameworks-like-react/ - super(destination); - this._next = onNext - ? function (this: OperatorSubscriber<T>, value: T) { - try { - onNext(value); - } catch (err) { - destination.error(err); - } - } - : super._next; - this._error = onError - ? function (this: OperatorSubscriber<T>, err: any) { - try { - onError(err); - } catch (err) { - // Send any errors that occur down stream. - destination.error(err); - } finally { - // Ensure finalization. - this.unsubscribe(); - } - } - : super._error; - this._complete = onComplete - ? function (this: OperatorSubscriber<T>) { - try { - onComplete(); - } catch (err) { - // Send any errors that occur down stream. - destination.error(err); - } finally { - // Ensure finalization. - this.unsubscribe(); - } - } - : super._complete; - } - - unsubscribe() { - if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) { - const { closed } = this; - super.unsubscribe(); - // Execute additional teardown if we have any and we didn't already do so. - !closed && this.onFinalize?.(); - } - } -} diff --git a/node_modules/rxjs/src/internal/operators/audit.ts b/node_modules/rxjs/src/internal/operators/audit.ts deleted file mode 100644 index da13800..0000000 --- a/node_modules/rxjs/src/internal/operators/audit.ts +++ /dev/null @@ -1,96 +0,0 @@ -import { Subscriber } from '../Subscriber'; -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; - -import { operate } from '../util/lift'; -import { innerFrom } from '../observable/innerFrom'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Ignores source values for a duration determined by another Observable, then - * emits the most recent value from the source Observable, then repeats this - * process. - * - * <span class="informal">It's like {@link auditTime}, but the silencing - * duration is determined by a second Observable.</span> - * - *  - * - * `audit` is similar to `throttle`, but emits the last value from the silenced - * time window, instead of the first value. `audit` emits the most recent value - * from the source Observable on the output Observable as soon as its internal - * timer becomes disabled, and ignores source values while the timer is enabled. - * Initially, the timer is disabled. As soon as the first source value arrives, - * the timer is enabled by calling the `durationSelector` function with the - * source value, which returns the "duration" Observable. When the duration - * Observable emits a value, the timer is disabled, then the most - * recent source value is emitted on the output Observable, and this process - * repeats for the next source value. - * - * ## Example - * - * Emit clicks at a rate of at most one click per second - * - * ```ts - * import { fromEvent, audit, interval } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(audit(ev => interval(1000))); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link auditTime} - * @see {@link debounce} - * @see {@link delayWhen} - * @see {@link sample} - * @see {@link throttle} - * - * @param durationSelector A function - * that receives a value from the source Observable, for computing the silencing - * duration, returned as an Observable or a Promise. - * @return A function that returns an Observable that performs rate-limiting of - * emissions from the source Observable. - */ -export function audit<T>(durationSelector: (value: T) => ObservableInput<any>): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let hasValue = false; - let lastValue: T | null = null; - let durationSubscriber: Subscriber<any> | null = null; - let isComplete = false; - - const endDuration = () => { - durationSubscriber?.unsubscribe(); - durationSubscriber = null; - if (hasValue) { - hasValue = false; - const value = lastValue!; - lastValue = null; - subscriber.next(value); - } - isComplete && subscriber.complete(); - }; - - const cleanupDuration = () => { - durationSubscriber = null; - isComplete && subscriber.complete(); - }; - - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - hasValue = true; - lastValue = value; - if (!durationSubscriber) { - innerFrom(durationSelector(value)).subscribe( - (durationSubscriber = createOperatorSubscriber(subscriber, endDuration, cleanupDuration)) - ); - } - }, - () => { - isComplete = true; - (!hasValue || !durationSubscriber || durationSubscriber.closed) && subscriber.complete(); - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/auditTime.ts b/node_modules/rxjs/src/internal/operators/auditTime.ts deleted file mode 100644 index c2beddf..0000000 --- a/node_modules/rxjs/src/internal/operators/auditTime.ts +++ /dev/null @@ -1,55 +0,0 @@ -import { asyncScheduler } from '../scheduler/async'; -import { audit } from './audit'; -import { timer } from '../observable/timer'; -import { MonoTypeOperatorFunction, SchedulerLike } from '../types'; - -/** - * Ignores source values for `duration` milliseconds, then emits the most recent - * value from the source Observable, then repeats this process. - * - * <span class="informal">When it sees a source value, it ignores that plus - * the next ones for `duration` milliseconds, and then it emits the most recent - * value from the source.</span> - * - *  - * - * `auditTime` is similar to `throttleTime`, but emits the last value from the - * silenced time window, instead of the first value. `auditTime` emits the most - * recent value from the source Observable on the output Observable as soon as - * its internal timer becomes disabled, and ignores source values while the - * timer is enabled. Initially, the timer is disabled. As soon as the first - * source value arrives, the timer is enabled. After `duration` milliseconds (or - * the time unit determined internally by the optional `scheduler`) has passed, - * the timer is disabled, then the most recent source value is emitted on the - * output Observable, and this process repeats for the next source value. - * Optionally takes a {@link SchedulerLike} for managing timers. - * - * ## Example - * - * Emit clicks at a rate of at most one click per second - * - * ```ts - * import { fromEvent, auditTime } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(auditTime(1000)); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link audit} - * @see {@link debounceTime} - * @see {@link delay} - * @see {@link sampleTime} - * @see {@link throttleTime} - * - * @param duration Time to wait before emitting the most recent source value, - * measured in milliseconds or the time unit determined internally by the - * optional `scheduler`. - * @param scheduler The {@link SchedulerLike} to use for managing the timers - * that handle the rate-limiting behavior. - * @return A function that returns an Observable that performs rate-limiting of - * emissions from the source Observable. - */ -export function auditTime<T>(duration: number, scheduler: SchedulerLike = asyncScheduler): MonoTypeOperatorFunction<T> { - return audit(() => timer(duration, scheduler)); -} diff --git a/node_modules/rxjs/src/internal/operators/buffer.ts b/node_modules/rxjs/src/internal/operators/buffer.ts deleted file mode 100644 index 2ca2fde..0000000 --- a/node_modules/rxjs/src/internal/operators/buffer.ts +++ /dev/null @@ -1,81 +0,0 @@ -import { OperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { noop } from '../util/noop'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; - -/** - * Buffers the source Observable values until `closingNotifier` emits. - * - * <span class="informal">Collects values from the past as an array, and emits - * that array only when another Observable emits.</span> - * - *  - * - * Buffers the incoming Observable values until the given `closingNotifier` - * `ObservableInput` (that internally gets converted to an Observable) - * emits a value, at which point it emits the buffer on the output - * Observable and starts a new buffer internally, awaiting the next time - * `closingNotifier` emits. - * - * ## Example - * - * On every click, emit array of most recent interval events - * - * ```ts - * import { fromEvent, interval, buffer } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const intervalEvents = interval(1000); - * const buffered = intervalEvents.pipe(buffer(clicks)); - * buffered.subscribe(x => console.log(x)); - * ``` - * - * @see {@link bufferCount} - * @see {@link bufferTime} - * @see {@link bufferToggle} - * @see {@link bufferWhen} - * @see {@link window} - * - * @param closingNotifier An `ObservableInput` that signals the - * buffer to be emitted on the output Observable. - * @return A function that returns an Observable of buffers, which are arrays - * of values. - */ -export function buffer<T>(closingNotifier: ObservableInput<any>): OperatorFunction<T, T[]> { - return operate((source, subscriber) => { - // The current buffered values. - let currentBuffer: T[] = []; - - // Subscribe to our source. - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => currentBuffer.push(value), - () => { - subscriber.next(currentBuffer); - subscriber.complete(); - } - ) - ); - - // Subscribe to the closing notifier. - innerFrom(closingNotifier).subscribe( - createOperatorSubscriber( - subscriber, - () => { - // Start a new buffer and emit the previous one. - const b = currentBuffer; - currentBuffer = []; - subscriber.next(b); - }, - noop - ) - ); - - return () => { - // Ensure buffered values are released on finalization. - currentBuffer = null!; - }; - }); -} diff --git a/node_modules/rxjs/src/internal/operators/bufferCount.ts b/node_modules/rxjs/src/internal/operators/bufferCount.ts deleted file mode 100644 index 1d82d2c..0000000 --- a/node_modules/rxjs/src/internal/operators/bufferCount.ts +++ /dev/null @@ -1,120 +0,0 @@ -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { arrRemove } from '../util/arrRemove'; - -/** - * Buffers the source Observable values until the size hits the maximum - * `bufferSize` given. - * - * <span class="informal">Collects values from the past as an array, and emits - * that array only when its size reaches `bufferSize`.</span> - * - *  - * - * Buffers a number of values from the source Observable by `bufferSize` then - * emits the buffer and clears it, and starts a new buffer each - * `startBufferEvery` values. If `startBufferEvery` is not provided or is - * `null`, then new buffers are started immediately at the start of the source - * and when each buffer closes and is emitted. - * - * ## Examples - * - * Emit the last two click events as an array - * - * ```ts - * import { fromEvent, bufferCount } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const buffered = clicks.pipe(bufferCount(2)); - * buffered.subscribe(x => console.log(x)); - * ``` - * - * On every click, emit the last two click events as an array - * - * ```ts - * import { fromEvent, bufferCount } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const buffered = clicks.pipe(bufferCount(2, 1)); - * buffered.subscribe(x => console.log(x)); - * ``` - * - * @see {@link buffer} - * @see {@link bufferTime} - * @see {@link bufferToggle} - * @see {@link bufferWhen} - * @see {@link pairwise} - * @see {@link windowCount} - * - * @param bufferSize The maximum size of the buffer emitted. - * @param startBufferEvery Interval at which to start a new buffer. - * For example if `startBufferEvery` is `2`, then a new buffer will be started - * on every other value from the source. A new buffer is started at the - * beginning of the source by default. - * @return A function that returns an Observable of arrays of buffered values. - */ -export function bufferCount<T>(bufferSize: number, startBufferEvery: number | null = null): OperatorFunction<T, T[]> { - // If no `startBufferEvery` value was supplied, then we're - // opening and closing on the bufferSize itself. - startBufferEvery = startBufferEvery ?? bufferSize; - - return operate((source, subscriber) => { - let buffers: T[][] = []; - let count = 0; - - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - let toEmit: T[][] | null = null; - - // Check to see if we need to start a buffer. - // This will start one at the first value, and then - // a new one every N after that. - if (count++ % startBufferEvery! === 0) { - buffers.push([]); - } - - // Push our value into our active buffers. - for (const buffer of buffers) { - buffer.push(value); - // Check to see if we're over the bufferSize - // if we are, record it so we can emit it later. - // If we emitted it now and removed it, it would - // mutate the `buffers` array while we're looping - // over it. - if (bufferSize <= buffer.length) { - toEmit = toEmit ?? []; - toEmit.push(buffer); - } - } - - if (toEmit) { - // We have found some buffers that are over the - // `bufferSize`. Emit them, and remove them from our - // buffers list. - for (const buffer of toEmit) { - arrRemove(buffers, buffer); - subscriber.next(buffer); - } - } - }, - () => { - // When the source completes, emit all of our - // active buffers. - for (const buffer of buffers) { - subscriber.next(buffer); - } - subscriber.complete(); - }, - // Pass all errors through to consumer. - undefined, - () => { - // Clean up our memory when we finalize - buffers = null!; - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/bufferTime.ts b/node_modules/rxjs/src/internal/operators/bufferTime.ts deleted file mode 100644 index 43a7b13..0000000 --- a/node_modules/rxjs/src/internal/operators/bufferTime.ts +++ /dev/null @@ -1,165 +0,0 @@ -import { Subscription } from '../Subscription'; -import { OperatorFunction, SchedulerLike } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { arrRemove } from '../util/arrRemove'; -import { asyncScheduler } from '../scheduler/async'; -import { popScheduler } from '../util/args'; -import { executeSchedule } from '../util/executeSchedule'; - -export function bufferTime<T>(bufferTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, T[]>; -export function bufferTime<T>( - bufferTimeSpan: number, - bufferCreationInterval: number | null | undefined, - scheduler?: SchedulerLike -): OperatorFunction<T, T[]>; -export function bufferTime<T>( - bufferTimeSpan: number, - bufferCreationInterval: number | null | undefined, - maxBufferSize: number, - scheduler?: SchedulerLike -): OperatorFunction<T, T[]>; - -/** - * Buffers the source Observable values for a specific time period. - * - * <span class="informal">Collects values from the past as an array, and emits - * those arrays periodically in time.</span> - * - *  - * - * Buffers values from the source for a specific time duration `bufferTimeSpan`. - * Unless the optional argument `bufferCreationInterval` is given, it emits and - * resets the buffer every `bufferTimeSpan` milliseconds. If - * `bufferCreationInterval` is given, this operator opens the buffer every - * `bufferCreationInterval` milliseconds and closes (emits and resets) the - * buffer every `bufferTimeSpan` milliseconds. When the optional argument - * `maxBufferSize` is specified, the buffer will be closed either after - * `bufferTimeSpan` milliseconds or when it contains `maxBufferSize` elements. - * - * ## Examples - * - * Every second, emit an array of the recent click events - * - * ```ts - * import { fromEvent, bufferTime } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const buffered = clicks.pipe(bufferTime(1000)); - * buffered.subscribe(x => console.log(x)); - * ``` - * - * Every 5 seconds, emit the click events from the next 2 seconds - * - * ```ts - * import { fromEvent, bufferTime } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const buffered = clicks.pipe(bufferTime(2000, 5000)); - * buffered.subscribe(x => console.log(x)); - * ``` - * - * @see {@link buffer} - * @see {@link bufferCount} - * @see {@link bufferToggle} - * @see {@link bufferWhen} - * @see {@link windowTime} - * - * @param bufferTimeSpan The amount of time to fill each buffer array. - * @param otherArgs Other configuration arguments such as: - * - `bufferCreationInterval` - the interval at which to start new buffers; - * - `maxBufferSize` - the maximum buffer size; - * - `scheduler` - the scheduler on which to schedule the intervals that determine buffer boundaries. - * @return A function that returns an Observable of arrays of buffered values. - */ -export function bufferTime<T>(bufferTimeSpan: number, ...otherArgs: any[]): OperatorFunction<T, T[]> { - const scheduler = popScheduler(otherArgs) ?? asyncScheduler; - const bufferCreationInterval = (otherArgs[0] as number) ?? null; - const maxBufferSize = (otherArgs[1] as number) || Infinity; - - return operate((source, subscriber) => { - // The active buffers, their related subscriptions, and removal functions. - let bufferRecords: { buffer: T[]; subs: Subscription }[] | null = []; - // If true, it means that every time we emit a buffer, we want to start a new buffer - // this is only really used for when *just* the buffer time span is passed. - let restartOnEmit = false; - - /** - * Does the work of emitting the buffer from the record, ensuring that the - * record is removed before the emission so reentrant code (from some custom scheduling, perhaps) - * does not alter the buffer. Also checks to see if a new buffer needs to be started - * after the emit. - */ - const emit = (record: { buffer: T[]; subs: Subscription }) => { - const { buffer, subs } = record; - subs.unsubscribe(); - arrRemove(bufferRecords, record); - subscriber.next(buffer); - restartOnEmit && startBuffer(); - }; - - /** - * Called every time we start a new buffer. This does - * the work of scheduling a job at the requested bufferTimeSpan - * that will emit the buffer (if it's not unsubscribed before then). - */ - const startBuffer = () => { - if (bufferRecords) { - const subs = new Subscription(); - subscriber.add(subs); - const buffer: T[] = []; - const record = { - buffer, - subs, - }; - bufferRecords.push(record); - executeSchedule(subs, scheduler, () => emit(record), bufferTimeSpan); - } - }; - - if (bufferCreationInterval !== null && bufferCreationInterval >= 0) { - // The user passed both a bufferTimeSpan (required), and a creation interval - // That means we need to start new buffers on the interval, and those buffers need - // to wait the required time span before emitting. - executeSchedule(subscriber, scheduler, startBuffer, bufferCreationInterval, true); - } else { - restartOnEmit = true; - } - - startBuffer(); - - const bufferTimeSubscriber = createOperatorSubscriber( - subscriber, - (value: T) => { - // Copy the records, so if we need to remove one we - // don't mutate the array. It's hard, but not impossible to - // set up a buffer time that could mutate the array and - // cause issues here. - const recordsCopy = bufferRecords!.slice(); - for (const record of recordsCopy) { - // Loop over all buffers and - const { buffer } = record; - buffer.push(value); - // If the buffer is over the max size, we need to emit it. - maxBufferSize <= buffer.length && emit(record); - } - }, - () => { - // The source completed, emit all of the active - // buffers we have before we complete. - while (bufferRecords?.length) { - subscriber.next(bufferRecords.shift()!.buffer); - } - bufferTimeSubscriber?.unsubscribe(); - subscriber.complete(); - subscriber.unsubscribe(); - }, - // Pass all errors through to consumer. - undefined, - // Clean up - () => (bufferRecords = null) - ); - - source.subscribe(bufferTimeSubscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/bufferToggle.ts b/node_modules/rxjs/src/internal/operators/bufferToggle.ts deleted file mode 100644 index fabefbc..0000000 --- a/node_modules/rxjs/src/internal/operators/bufferToggle.ts +++ /dev/null @@ -1,102 +0,0 @@ -import { Subscription } from '../Subscription'; -import { OperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { innerFrom } from '../observable/innerFrom'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { noop } from '../util/noop'; -import { arrRemove } from '../util/arrRemove'; - -/** - * Buffers the source Observable values starting from an emission from - * `openings` and ending when the output of `closingSelector` emits. - * - * <span class="informal">Collects values from the past as an array. Starts - * collecting only when `opening` emits, and calls the `closingSelector` - * function to get an Observable that tells when to close the buffer.</span> - * - *  - * - * Buffers values from the source by opening the buffer via signals from an - * Observable provided to `openings`, and closing and sending the buffers when - * a Subscribable or Promise returned by the `closingSelector` function emits. - * - * ## Example - * - * Every other second, emit the click events from the next 500ms - * - * ```ts - * import { fromEvent, interval, bufferToggle, EMPTY } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const openings = interval(1000); - * const buffered = clicks.pipe(bufferToggle(openings, i => - * i % 2 ? interval(500) : EMPTY - * )); - * buffered.subscribe(x => console.log(x)); - * ``` - * - * @see {@link buffer} - * @see {@link bufferCount} - * @see {@link bufferTime} - * @see {@link bufferWhen} - * @see {@link windowToggle} - * - * @param openings A Subscribable or Promise of notifications to start new - * buffers. - * @param closingSelector A function that takes - * the value emitted by the `openings` observable and returns a Subscribable or Promise, - * which, when it emits, signals that the associated buffer should be emitted - * and cleared. - * @return A function that returns an Observable of arrays of buffered values. - */ -export function bufferToggle<T, O>( - openings: ObservableInput<O>, - closingSelector: (value: O) => ObservableInput<any> -): OperatorFunction<T, T[]> { - return operate((source, subscriber) => { - const buffers: T[][] = []; - - // Subscribe to the openings notifier first - innerFrom(openings).subscribe( - createOperatorSubscriber( - subscriber, - (openValue) => { - const buffer: T[] = []; - buffers.push(buffer); - // We use this composite subscription, so that - // when the closing notifier emits, we can tear it down. - const closingSubscription = new Subscription(); - - const emitBuffer = () => { - arrRemove(buffers, buffer); - subscriber.next(buffer); - closingSubscription.unsubscribe(); - }; - - // The line below will add the subscription to the parent subscriber *and* the closing subscription. - closingSubscription.add(innerFrom(closingSelector(openValue)).subscribe(createOperatorSubscriber(subscriber, emitBuffer, noop))); - }, - noop - ) - ); - - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - // Value from our source. Add it to all pending buffers. - for (const buffer of buffers) { - buffer.push(value); - } - }, - () => { - // Source complete. Emit all pending buffers. - while (buffers.length > 0) { - subscriber.next(buffers.shift()!); - } - subscriber.complete(); - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/bufferWhen.ts b/node_modules/rxjs/src/internal/operators/bufferWhen.ts deleted file mode 100644 index ee64402..0000000 --- a/node_modules/rxjs/src/internal/operators/bufferWhen.ts +++ /dev/null @@ -1,94 +0,0 @@ -import { Subscriber } from '../Subscriber'; -import { ObservableInput, OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { noop } from '../util/noop'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; - -/** - * Buffers the source Observable values, using a factory function of closing - * Observables to determine when to close, emit, and reset the buffer. - * - * <span class="informal">Collects values from the past as an array. When it - * starts collecting values, it calls a function that returns an Observable that - * tells when to close the buffer and restart collecting.</span> - * - *  - * - * Opens a buffer immediately, then closes the buffer when the observable - * returned by calling `closingSelector` function emits a value. When it closes - * the buffer, it immediately opens a new buffer and repeats the process. - * - * ## Example - * - * Emit an array of the last clicks every [1-5] random seconds - * - * ```ts - * import { fromEvent, bufferWhen, interval } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const buffered = clicks.pipe( - * bufferWhen(() => interval(1000 + Math.random() * 4000)) - * ); - * buffered.subscribe(x => console.log(x)); - * ``` - * - * @see {@link buffer} - * @see {@link bufferCount} - * @see {@link bufferTime} - * @see {@link bufferToggle} - * @see {@link windowWhen} - * - * @param closingSelector A function that takes no arguments and returns an - * Observable that signals buffer closure. - * @return A function that returns an Observable of arrays of buffered values. - */ -export function bufferWhen<T>(closingSelector: () => ObservableInput<any>): OperatorFunction<T, T[]> { - return operate((source, subscriber) => { - // The buffer we keep and emit. - let buffer: T[] | null = null; - // A reference to the subscriber used to subscribe to - // the closing notifier. We need to hold this so we can - // end the subscription after the first notification. - let closingSubscriber: Subscriber<T> | null = null; - - // Ends the previous closing notifier subscription, so it - // terminates after the first emission, then emits - // the current buffer if there is one, starts a new buffer, and starts a - // new closing notifier. - const openBuffer = () => { - // Make sure to finalize the closing subscription, we only cared - // about one notification. - closingSubscriber?.unsubscribe(); - // emit the buffer if we have one, and start a new buffer. - const b = buffer; - buffer = []; - b && subscriber.next(b); - - // Get a new closing notifier and subscribe to it. - innerFrom(closingSelector()).subscribe((closingSubscriber = createOperatorSubscriber(subscriber, openBuffer, noop))); - }; - - // Start the first buffer. - openBuffer(); - - // Subscribe to our source. - source.subscribe( - createOperatorSubscriber( - subscriber, - // Add every new value to the current buffer. - (value) => buffer?.push(value), - // When we complete, emit the buffer if we have one, - // then complete the result. - () => { - buffer && subscriber.next(buffer); - subscriber.complete(); - }, - // Pass all errors through to consumer. - undefined, - // Release memory on finalization - () => (buffer = closingSubscriber = null!) - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/catchError.ts b/node_modules/rxjs/src/internal/operators/catchError.ts deleted file mode 100644 index 0e2fc6d..0000000 --- a/node_modules/rxjs/src/internal/operators/catchError.ts +++ /dev/null @@ -1,139 +0,0 @@ -import { Observable } from '../Observable'; - -import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types'; -import { Subscription } from '../Subscription'; -import { innerFrom } from '../observable/innerFrom'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { operate } from '../util/lift'; - -export function catchError<T, O extends ObservableInput<any>>( - selector: (err: any, caught: Observable<T>) => O -): OperatorFunction<T, T | ObservedValueOf<O>>; - -/** - * Catches errors on the observable to be handled by returning a new observable or throwing an error. - * - * <span class="informal"> - * It only listens to the error channel and ignores notifications. - * Handles errors from the source observable, and maps them to a new observable. - * The error may also be rethrown, or a new error can be thrown to emit an error from the result. - * </span> - * - *  - * - * This operator handles errors, but forwards along all other events to the resulting observable. - * If the source observable terminates with an error, it will map that error to a new observable, - * subscribe to it, and forward all of its events to the resulting observable. - * - * ## Examples - * - * Continue with a different Observable when there's an error - * - * ```ts - * import { of, map, catchError } from 'rxjs'; - * - * of(1, 2, 3, 4, 5) - * .pipe( - * map(n => { - * if (n === 4) { - * throw 'four!'; - * } - * return n; - * }), - * catchError(err => of('I', 'II', 'III', 'IV', 'V')) - * ) - * .subscribe(x => console.log(x)); - * // 1, 2, 3, I, II, III, IV, V - * ``` - * - * Retry the caught source Observable again in case of error, similar to `retry()` operator - * - * ```ts - * import { of, map, catchError, take } from 'rxjs'; - * - * of(1, 2, 3, 4, 5) - * .pipe( - * map(n => { - * if (n === 4) { - * throw 'four!'; - * } - * return n; - * }), - * catchError((err, caught) => caught), - * take(30) - * ) - * .subscribe(x => console.log(x)); - * // 1, 2, 3, 1, 2, 3, ... - * ``` - * - * Throw a new error when the source Observable throws an error - * - * ```ts - * import { of, map, catchError } from 'rxjs'; - * - * of(1, 2, 3, 4, 5) - * .pipe( - * map(n => { - * if (n === 4) { - * throw 'four!'; - * } - * return n; - * }), - * catchError(err => { - * throw 'error in source. Details: ' + err; - * }) - * ) - * .subscribe({ - * next: x => console.log(x), - * error: err => console.log(err) - * }); - * // 1, 2, 3, error in source. Details: four! - * ``` - * - * @see {@link onErrorResumeNext} - * @see {@link repeat} - * @see {@link repeatWhen} - * @see {@link retry } - * @see {@link retryWhen} - * - * @param selector A function that takes as arguments `err`, which is the error, and `caught`, which - * is the source observable, in case you'd like to "retry" that observable by returning it again. - * Whatever observable is returned by the `selector` will be used to continue the observable chain. - * @return A function that returns an Observable that originates from either - * the source or the Observable returned by the `selector` function. - */ -export function catchError<T, O extends ObservableInput<any>>( - selector: (err: any, caught: Observable<T>) => O -): OperatorFunction<T, T | ObservedValueOf<O>> { - return operate((source, subscriber) => { - let innerSub: Subscription | null = null; - let syncUnsub = false; - let handledResult: Observable<ObservedValueOf<O>>; - - innerSub = source.subscribe( - createOperatorSubscriber(subscriber, undefined, undefined, (err) => { - handledResult = innerFrom(selector(err, catchError(selector)(source))); - if (innerSub) { - innerSub.unsubscribe(); - innerSub = null; - handledResult.subscribe(subscriber); - } else { - // We don't have an innerSub yet, that means the error was synchronous - // because the subscribe call hasn't returned yet. - syncUnsub = true; - } - }) - ); - - if (syncUnsub) { - // We have a synchronous error, we need to make sure to - // finalize right away. This ensures that callbacks in the `finalize` operator are called - // at the right time, and that finalization occurs at the expected - // time between the source error and the subscription to the - // next observable. - innerSub.unsubscribe(); - innerSub = null; - handledResult!.subscribe(subscriber); - } - }); -} diff --git a/node_modules/rxjs/src/internal/operators/combineAll.ts b/node_modules/rxjs/src/internal/operators/combineAll.ts deleted file mode 100644 index c24157e..0000000 --- a/node_modules/rxjs/src/internal/operators/combineAll.ts +++ /dev/null @@ -1,6 +0,0 @@ -import { combineLatestAll } from './combineLatestAll'; - -/** - * @deprecated Renamed to {@link combineLatestAll}. Will be removed in v8. - */ -export const combineAll = combineLatestAll; diff --git a/node_modules/rxjs/src/internal/operators/combineLatest.ts b/node_modules/rxjs/src/internal/operators/combineLatest.ts deleted file mode 100644 index 3f0f3a6..0000000 --- a/node_modules/rxjs/src/internal/operators/combineLatest.ts +++ /dev/null @@ -1,34 +0,0 @@ -import { combineLatestInit } from '../observable/combineLatest'; -import { ObservableInput, ObservableInputTuple, OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { argsOrArgArray } from '../util/argsOrArgArray'; -import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs'; -import { pipe } from '../util/pipe'; -import { popResultSelector } from '../util/args'; - -/** @deprecated Replaced with {@link combineLatestWith}. Will be removed in v8. */ -export function combineLatest<T, A extends readonly unknown[], R>( - sources: [...ObservableInputTuple<A>], - project: (...values: [T, ...A]) => R -): OperatorFunction<T, R>; -/** @deprecated Replaced with {@link combineLatestWith}. Will be removed in v8. */ -export function combineLatest<T, A extends readonly unknown[], R>(sources: [...ObservableInputTuple<A>]): OperatorFunction<T, [T, ...A]>; - -/** @deprecated Replaced with {@link combineLatestWith}. Will be removed in v8. */ -export function combineLatest<T, A extends readonly unknown[], R>( - ...sourcesAndProject: [...ObservableInputTuple<A>, (...values: [T, ...A]) => R] -): OperatorFunction<T, R>; -/** @deprecated Replaced with {@link combineLatestWith}. Will be removed in v8. */ -export function combineLatest<T, A extends readonly unknown[], R>(...sources: [...ObservableInputTuple<A>]): OperatorFunction<T, [T, ...A]>; - -/** - * @deprecated Replaced with {@link combineLatestWith}. Will be removed in v8. - */ -export function combineLatest<T, R>(...args: (ObservableInput<any> | ((...values: any[]) => R))[]): OperatorFunction<T, unknown> { - const resultSelector = popResultSelector(args); - return resultSelector - ? pipe(combineLatest(...(args as Array<ObservableInput<any>>)), mapOneOrManyArgs(resultSelector)) - : operate((source, subscriber) => { - combineLatestInit([source, ...argsOrArgArray(args)])(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/combineLatestAll.ts b/node_modules/rxjs/src/internal/operators/combineLatestAll.ts deleted file mode 100644 index 434f621..0000000 --- a/node_modules/rxjs/src/internal/operators/combineLatestAll.ts +++ /dev/null @@ -1,50 +0,0 @@ -import { combineLatest } from '../observable/combineLatest'; -import { OperatorFunction, ObservableInput } from '../types'; -import { joinAllInternals } from './joinAllInternals'; - -export function combineLatestAll<T>(): OperatorFunction<ObservableInput<T>, T[]>; -export function combineLatestAll<T>(): OperatorFunction<any, T[]>; -export function combineLatestAll<T, R>(project: (...values: T[]) => R): OperatorFunction<ObservableInput<T>, R>; -export function combineLatestAll<R>(project: (...values: Array<any>) => R): OperatorFunction<any, R>; - -/** - * Flattens an Observable-of-Observables by applying {@link combineLatest} when the Observable-of-Observables completes. - * - * `combineLatestAll` takes an Observable of Observables, and collects all Observables from it. Once the outer Observable completes, - * it subscribes to all collected Observables and combines their values using the {@link combineLatest} strategy, such that: - * - * * Every time an inner Observable emits, the output Observable emits - * * When the returned observable emits, it emits all of the latest values by: - * * If a `project` function is provided, it is called with each recent value from each inner Observable in whatever order they - * arrived, and the result of the `project` function is what is emitted by the output Observable. - * * If there is no `project` function, an array of all the most recent values is emitted by the output Observable. - * - * ## Example - * - * Map two click events to a finite interval Observable, then apply `combineLatestAll` - * - * ```ts - * import { fromEvent, map, interval, take, combineLatestAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const higherOrder = clicks.pipe( - * map(() => interval(Math.random() * 2000).pipe(take(3))), - * take(2) - * ); - * const result = higherOrder.pipe(combineLatestAll()); - * - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link combineLatest} - * @see {@link combineLatestWith} - * @see {@link mergeAll} - * - * @param project optional function to map the most recent values from each inner Observable into a new result. - * Takes each of the most recent values from each collected inner Observable as arguments, in order. - * @return A function that returns an Observable that flattens Observables - * emitted by the source Observable. - */ -export function combineLatestAll<R>(project?: (...values: Array<any>) => R) { - return joinAllInternals(combineLatest, project); -} diff --git a/node_modules/rxjs/src/internal/operators/combineLatestWith.ts b/node_modules/rxjs/src/internal/operators/combineLatestWith.ts deleted file mode 100644 index b262f89..0000000 --- a/node_modules/rxjs/src/internal/operators/combineLatestWith.ts +++ /dev/null @@ -1,48 +0,0 @@ -import { ObservableInputTuple, OperatorFunction, Cons } from '../types'; -import { combineLatest } from './combineLatest'; - -/** - * Create an observable that combines the latest values from all passed observables and the source - * into arrays and emits them. - * - * Returns an observable, that when subscribed to, will subscribe to the source observable and all - * sources provided as arguments. Once all sources emit at least one value, all of the latest values - * will be emitted as an array. After that, every time any source emits a value, all of the latest values - * will be emitted as an array. - * - * This is a useful operator for eagerly calculating values based off of changed inputs. - * - * ## Example - * - * Simple concatenation of values from two inputs - * - * ```ts - * import { fromEvent, combineLatestWith, map } from 'rxjs'; - * - * // Setup: Add two inputs to the page - * const input1 = document.createElement('input'); - * document.body.appendChild(input1); - * const input2 = document.createElement('input'); - * document.body.appendChild(input2); - * - * // Get streams of changes - * const input1Changes$ = fromEvent(input1, 'change'); - * const input2Changes$ = fromEvent(input2, 'change'); - * - * // Combine the changes by adding them together - * input1Changes$.pipe( - * combineLatestWith(input2Changes$), - * map(([e1, e2]) => (<HTMLInputElement>e1.target).value + ' - ' + (<HTMLInputElement>e2.target).value) - * ) - * .subscribe(x => console.log(x)); - * ``` - * - * @param otherSources the other sources to subscribe to. - * @return A function that returns an Observable that emits the latest - * emissions from both source and provided Observables. - */ -export function combineLatestWith<T, A extends readonly unknown[]>( - ...otherSources: [...ObservableInputTuple<A>] -): OperatorFunction<T, Cons<T, A>> { - return combineLatest(...otherSources); -} diff --git a/node_modules/rxjs/src/internal/operators/concat.ts b/node_modules/rxjs/src/internal/operators/concat.ts deleted file mode 100644 index eadb595..0000000 --- a/node_modules/rxjs/src/internal/operators/concat.ts +++ /dev/null @@ -1,22 +0,0 @@ -import { ObservableInputTuple, OperatorFunction, SchedulerLike } from '../types'; -import { operate } from '../util/lift'; -import { concatAll } from './concatAll'; -import { popScheduler } from '../util/args'; -import { from } from '../observable/from'; - -/** @deprecated Replaced with {@link concatWith}. Will be removed in v8. */ -export function concat<T, A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>; -/** @deprecated Replaced with {@link concatWith}. Will be removed in v8. */ -export function concat<T, A extends readonly unknown[]>( - ...sourcesAndScheduler: [...ObservableInputTuple<A>, SchedulerLike] -): OperatorFunction<T, T | A[number]>; - -/** - * @deprecated Replaced with {@link concatWith}. Will be removed in v8. - */ -export function concat<T, R>(...args: any[]): OperatorFunction<T, R> { - const scheduler = popScheduler(args); - return operate((source, subscriber) => { - concatAll()(from([source, ...args], scheduler)).subscribe(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/concatAll.ts b/node_modules/rxjs/src/internal/operators/concatAll.ts deleted file mode 100644 index 05be4fc..0000000 --- a/node_modules/rxjs/src/internal/operators/concatAll.ts +++ /dev/null @@ -1,62 +0,0 @@ -import { mergeAll } from './mergeAll'; -import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types'; - -/** - * Converts a higher-order Observable into a first-order Observable by - * concatenating the inner Observables in order. - * - * <span class="informal">Flattens an Observable-of-Observables by putting one - * inner Observable after the other.</span> - * - *  - * - * Joins every Observable emitted by the source (a higher-order Observable), in - * a serial fashion. It subscribes to each inner Observable only after the - * previous inner Observable has completed, and merges all of their values into - * the returned observable. - * - * __Warning:__ If the source Observable emits Observables quickly and - * endlessly, and the inner Observables it emits generally complete slower than - * the source emits, you can run into memory issues as the incoming Observables - * collect in an unbounded buffer. - * - * Note: `concatAll` is equivalent to `mergeAll` with concurrency parameter set - * to `1`. - * - * ## Example - * - * For each click event, tick every second from 0 to 3, with no concurrency - * - * ```ts - * import { fromEvent, map, interval, take, concatAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const higherOrder = clicks.pipe( - * map(() => interval(1000).pipe(take(4))) - * ); - * const firstOrder = higherOrder.pipe(concatAll()); - * firstOrder.subscribe(x => console.log(x)); - * - * // Results in the following: - * // (results are not concurrent) - * // For every click on the "document" it will emit values 0 to 3 spaced - * // on a 1000ms interval - * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 - * ``` - * - * @see {@link combineLatestAll} - * @see {@link concat} - * @see {@link concatMap} - * @see {@link concatMapTo} - * @see {@link exhaustAll} - * @see {@link mergeAll} - * @see {@link switchAll} - * @see {@link switchMap} - * @see {@link zipAll} - * - * @return A function that returns an Observable emitting values from all the - * inner Observables concatenated. - */ -export function concatAll<O extends ObservableInput<any>>(): OperatorFunction<O, ObservedValueOf<O>> { - return mergeAll(1); -} diff --git a/node_modules/rxjs/src/internal/operators/concatMap.ts b/node_modules/rxjs/src/internal/operators/concatMap.ts deleted file mode 100644 index 1a6dc67..0000000 --- a/node_modules/rxjs/src/internal/operators/concatMap.ts +++ /dev/null @@ -1,83 +0,0 @@ -import { mergeMap } from './mergeMap'; -import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types'; -import { isFunction } from '../util/isFunction'; - -/* tslint:disable:max-line-length */ -export function concatMap<T, O extends ObservableInput<any>>( - project: (value: T, index: number) => O -): OperatorFunction<T, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function concatMap<T, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector: undefined -): OperatorFunction<T, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function concatMap<T, R, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, R>; -/* tslint:enable:max-line-length */ - -/** - * Projects each source value to an Observable which is merged in the output - * Observable, in a serialized fashion waiting for each one to complete before - * merging the next. - * - * <span class="informal">Maps each value to an Observable, then flattens all of - * these inner Observables using {@link concatAll}.</span> - * - *  - * - * Returns an Observable that emits items based on applying a function that you - * supply to each item emitted by the source Observable, where that function - * returns an (so-called "inner") Observable. Each new inner Observable is - * concatenated with the previous inner Observable. - * - * __Warning:__ if source values arrive endlessly and faster than their - * corresponding inner Observables can complete, it will result in memory issues - * as inner Observables amass in an unbounded buffer waiting for their turn to - * be subscribed to. - * - * Note: `concatMap` is equivalent to `mergeMap` with concurrency parameter set - * to `1`. - * - * ## Example - * - * For each click event, tick every second from 0 to 3, with no concurrency - * - * ```ts - * import { fromEvent, concatMap, interval, take } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * concatMap(ev => interval(1000).pipe(take(4))) - * ); - * result.subscribe(x => console.log(x)); - * - * // Results in the following: - * // (results are not concurrent) - * // For every click on the "document" it will emit values 0 to 3 spaced - * // on a 1000ms interval - * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 - * ``` - * - * @see {@link concat} - * @see {@link concatAll} - * @see {@link concatMapTo} - * @see {@link exhaustMap} - * @see {@link mergeMap} - * @see {@link switchMap} - * - * @param project A function that, when applied to an item emitted by the source - * Observable, returns an Observable. - * @return A function that returns an Observable that emits the result of - * applying the projection function (and the optional deprecated - * `resultSelector`) to each item emitted by the source Observable and taking - * values from each projected inner Observable sequentially. - */ -export function concatMap<T, R, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, ObservedValueOf<O> | R> { - return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1); -} diff --git a/node_modules/rxjs/src/internal/operators/concatMapTo.ts b/node_modules/rxjs/src/internal/operators/concatMapTo.ts deleted file mode 100644 index 9c04b8e..0000000 --- a/node_modules/rxjs/src/internal/operators/concatMapTo.ts +++ /dev/null @@ -1,79 +0,0 @@ -import { concatMap } from './concatMap'; -import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types'; -import { isFunction } from '../util/isFunction'; - -/** @deprecated Will be removed in v9. Use {@link concatMap} instead: `concatMap(() => result)` */ -export function concatMapTo<O extends ObservableInput<unknown>>(observable: O): OperatorFunction<unknown, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function concatMapTo<O extends ObservableInput<unknown>>( - observable: O, - resultSelector: undefined -): OperatorFunction<unknown, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function concatMapTo<T, R, O extends ObservableInput<unknown>>( - observable: O, - resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, R>; - -/** - * Projects each source value to the same Observable which is merged multiple - * times in a serialized fashion on the output Observable. - * - * <span class="informal">It's like {@link concatMap}, but maps each value - * always to the same inner Observable.</span> - * - *  - * - * Maps each source value to the given Observable `innerObservable` regardless - * of the source value, and then flattens those resulting Observables into one - * single Observable, which is the output Observable. Each new `innerObservable` - * instance emitted on the output Observable is concatenated with the previous - * `innerObservable` instance. - * - * __Warning:__ if source values arrive endlessly and faster than their - * corresponding inner Observables can complete, it will result in memory issues - * as inner Observables amass in an unbounded buffer waiting for their turn to - * be subscribed to. - * - * Note: `concatMapTo` is equivalent to `mergeMapTo` with concurrency parameter - * set to `1`. - * - * ## Example - * - * For each click event, tick every second from 0 to 3, with no concurrency - * - * ```ts - * import { fromEvent, concatMapTo, interval, take } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * concatMapTo(interval(1000).pipe(take(4))) - * ); - * result.subscribe(x => console.log(x)); - * - * // Results in the following: - * // (results are not concurrent) - * // For every click on the "document" it will emit values 0 to 3 spaced - * // on a 1000ms interval - * // one click = 1000ms-> 0 -1000ms-> 1 -1000ms-> 2 -1000ms-> 3 - * ``` - * - * @see {@link concat} - * @see {@link concatAll} - * @see {@link concatMap} - * @see {@link mergeMapTo} - * @see {@link switchMapTo} - * - * @param innerObservable An `ObservableInput` to replace each value from the - * source Observable. - * @return A function that returns an Observable of values merged together by - * joining the passed Observable with itself, one after the other, for each - * value emitted from the source. - * @deprecated Will be removed in v9. Use {@link concatMap} instead: `concatMap(() => result)` - */ -export function concatMapTo<T, R, O extends ObservableInput<unknown>>( - innerObservable: O, - resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, ObservedValueOf<O> | R> { - return isFunction(resultSelector) ? concatMap(() => innerObservable, resultSelector) : concatMap(() => innerObservable); -} diff --git a/node_modules/rxjs/src/internal/operators/concatWith.ts b/node_modules/rxjs/src/internal/operators/concatWith.ts deleted file mode 100644 index b836b29..0000000 --- a/node_modules/rxjs/src/internal/operators/concatWith.ts +++ /dev/null @@ -1,48 +0,0 @@ -import { ObservableInputTuple, OperatorFunction } from '../types'; -import { concat } from './concat'; - -/** - * Emits all of the values from the source observable, then, once it completes, subscribes - * to each observable source provided, one at a time, emitting all of their values, and not subscribing - * to the next one until it completes. - * - * `concat(a$, b$, c$)` is the same as `a$.pipe(concatWith(b$, c$))`. - * - * ## Example - * - * Listen for one mouse click, then listen for all mouse moves. - * - * ```ts - * import { fromEvent, map, take, concatWith } from 'rxjs'; - * - * const clicks$ = fromEvent(document, 'click'); - * const moves$ = fromEvent(document, 'mousemove'); - * - * clicks$.pipe( - * map(() => 'click'), - * take(1), - * concatWith( - * moves$.pipe( - * map(() => 'move') - * ) - * ) - * ) - * .subscribe(x => console.log(x)); - * - * // 'click' - * // 'move' - * // 'move' - * // 'move' - * // ... - * ``` - * - * @param otherSources Other observable sources to subscribe to, in sequence, after the original source is complete. - * @return A function that returns an Observable that concatenates - * subscriptions to the source and provided Observables subscribing to the next - * only once the current subscription completes. - */ -export function concatWith<T, A extends readonly unknown[]>( - ...otherSources: [...ObservableInputTuple<A>] -): OperatorFunction<T, T | A[number]> { - return concat(...otherSources); -} diff --git a/node_modules/rxjs/src/internal/operators/connect.ts b/node_modules/rxjs/src/internal/operators/connect.ts deleted file mode 100644 index 4a6b3c4..0000000 --- a/node_modules/rxjs/src/internal/operators/connect.ts +++ /dev/null @@ -1,109 +0,0 @@ -import { OperatorFunction, ObservableInput, ObservedValueOf, SubjectLike } from '../types'; -import { Observable } from '../Observable'; -import { Subject } from '../Subject'; -import { innerFrom } from '../observable/innerFrom'; -import { operate } from '../util/lift'; -import { fromSubscribable } from '../observable/fromSubscribable'; - -/** - * An object used to configure {@link connect} operator. - */ -export interface ConnectConfig<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>; -} - -/** - * The default configuration for `connect`. - */ -const DEFAULT_CONFIG: ConnectConfig<unknown> = { - connector: () => new Subject<unknown>(), -}; - -/** - * Creates an observable by multicasting the source within a function that - * allows the developer to define the usage of the multicast prior to connection. - * - * This is particularly useful if the observable source you wish to multicast could - * be synchronous or asynchronous. This sets it apart from {@link share}, which, in the - * case of totally synchronous sources will fail to share a single subscription with - * multiple consumers, as by the time the subscription to the result of {@link share} - * has returned, if the source is synchronous its internal reference count will jump from - * 0 to 1 back to 0 and reset. - * - * To use `connect`, you provide a `selector` function that will give you - * a multicast observable that is not yet connected. You then use that multicast observable - * to create a resulting observable that, when subscribed, will set up your multicast. This is - * generally, but not always, accomplished with {@link merge}. - * - * Note that using a {@link takeUntil} inside of `connect`'s `selector` _might_ mean you were looking - * to use the {@link takeWhile} operator instead. - * - * When you subscribe to the result of `connect`, the `selector` function will be called. After - * the `selector` function returns, the observable it returns will be subscribed to, _then_ the - * multicast will be connected to the source. - * - * ## Example - * - * Sharing a totally synchronous observable - * - * ```ts - * import { of, tap, connect, merge, map, filter } from 'rxjs'; - * - * const source$ = of(1, 2, 3, 4, 5).pipe( - * tap({ - * subscribe: () => console.log('subscription started'), - * next: n => console.log(`source emitted ${ n }`) - * }) - * ); - * - * source$.pipe( - * // Notice in here we're merging 3 subscriptions to `shared$`. - * connect(shared$ => merge( - * shared$.pipe(map(n => `all ${ n }`)), - * shared$.pipe(filter(n => n % 2 === 0), map(n => `even ${ n }`)), - * shared$.pipe(filter(n => n % 2 === 1), map(n => `odd ${ n }`)) - * )) - * ) - * .subscribe(console.log); - * - * // Expected output: (notice only one subscription) - * 'subscription started' - * 'source emitted 1' - * 'all 1' - * 'odd 1' - * 'source emitted 2' - * 'all 2' - * 'even 2' - * 'source emitted 3' - * 'all 3' - * 'odd 3' - * 'source emitted 4' - * 'all 4' - * 'even 4' - * 'source emitted 5' - * 'all 5' - * 'odd 5' - * ``` - * - * @param selector A function used to set up the multicast. Gives you a multicast observable - * that is not yet connected. With that, you're expected to create and return - * and Observable, that when subscribed to, will utilize the multicast observable. - * After this function is executed -- and its return value subscribed to -- the - * operator will subscribe to the source, and the connection will be made. - * @param config The configuration object for `connect`. - */ -export function connect<T, O extends ObservableInput<unknown>>( - selector: (shared: Observable<T>) => O, - config: ConnectConfig<T> = DEFAULT_CONFIG -): OperatorFunction<T, ObservedValueOf<O>> { - const { connector } = config; - return operate((source, subscriber) => { - const subject = connector(); - innerFrom(selector(fromSubscribable(subject))).subscribe(subscriber); - subscriber.add(source.subscribe(subject)); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/count.ts b/node_modules/rxjs/src/internal/operators/count.ts deleted file mode 100644 index 8b764f8..0000000 --- a/node_modules/rxjs/src/internal/operators/count.ts +++ /dev/null @@ -1,61 +0,0 @@ -import { OperatorFunction } from '../types'; -import { reduce } from './reduce'; - -/** - * Counts the number of emissions on the source and emits that number when the - * source completes. - * - * <span class="informal">Tells how many values were emitted, when the source - * completes.</span> - * - *  - * - * `count` transforms an Observable that emits values into an Observable that - * emits a single value that represents the number of values emitted by the - * source Observable. If the source Observable terminates with an error, `count` - * will pass this error notification along without emitting a value first. If - * the source Observable does not terminate at all, `count` will neither emit - * a value nor terminate. This operator takes an optional `predicate` function - * as argument, in which case the output emission will represent the number of - * source values that matched `true` with the `predicate`. - * - * ## Examples - * - * Counts how many seconds have passed before the first click happened - * - * ```ts - * import { interval, fromEvent, takeUntil, count } from 'rxjs'; - * - * const seconds = interval(1000); - * const clicks = fromEvent(document, 'click'); - * const secondsBeforeClick = seconds.pipe(takeUntil(clicks)); - * const result = secondsBeforeClick.pipe(count()); - * result.subscribe(x => console.log(x)); - * ``` - * - * Counts how many odd numbers are there between 1 and 7 - * - * ```ts - * import { range, count } from 'rxjs'; - * - * const numbers = range(1, 7); - * const result = numbers.pipe(count(i => i % 2 === 1)); - * result.subscribe(x => console.log(x)); - * // Results in: - * // 4 - * ``` - * - * @see {@link max} - * @see {@link min} - * @see {@link reduce} - * - * @param predicate A function that is used to analyze the value and the index and - * determine whether or not to increment the count. Return `true` to increment the count, - * and return `false` to keep the count the same. - * If the predicate is not provided, every value will be counted. - * @return A function that returns an Observable that emits one number that - * represents the count of emissions. - */ -export function count<T>(predicate?: (value: T, index: number) => boolean): OperatorFunction<T, number> { - return reduce((total, value, i) => (!predicate || predicate(value, i) ? total + 1 : total), 0); -} diff --git a/node_modules/rxjs/src/internal/operators/debounce.ts b/node_modules/rxjs/src/internal/operators/debounce.ts deleted file mode 100644 index b644855..0000000 --- a/node_modules/rxjs/src/internal/operators/debounce.ts +++ /dev/null @@ -1,119 +0,0 @@ -import { Subscriber } from '../Subscriber'; -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { noop } from '../util/noop'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; - -/** - * Emits a notification from the source Observable only after a particular time span - * determined by another Observable has passed without another source emission. - * - * <span class="informal">It's like {@link debounceTime}, but the time span of - * emission silence is determined by a second Observable.</span> - * - *  - * - * `debounce` delays notifications emitted by the source Observable, but drops previous - * pending delayed emissions if a new notification arrives on the source Observable. - * This operator keeps track of the most recent notification from the source - * Observable, and spawns a duration Observable by calling the - * `durationSelector` function. The notification is emitted only when the duration - * Observable emits a next notification, and if no other notification was emitted on - * the source Observable since the duration Observable was spawned. If a new - * notification appears before the duration Observable emits, the previous notification will - * not be emitted and a new duration is scheduled from `durationSelector` is scheduled. - * If the completing event happens during the scheduled duration the last cached notification - * is emitted before the completion event is forwarded to the output observable. - * If the error event happens during the scheduled duration or after it only the error event is - * forwarded to the output observable. The cache notification is not emitted in this case. - * - * Like {@link debounceTime}, this is a rate-limiting operator, and also a - * delay-like operator since output emissions do not necessarily occur at the - * same time as they did on the source Observable. - * - * ## Example - * - * Emit the most recent click after a burst of clicks - * - * ```ts - * import { fromEvent, scan, debounce, interval } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * scan(i => ++i, 1), - * debounce(i => interval(200 * i)) - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link audit} - * @see {@link auditTime} - * @see {@link debounceTime} - * @see {@link delay} - * @see {@link sample} - * @see {@link sampleTime} - * @see {@link throttle} - * @see {@link throttleTime} - * - * @param durationSelector A function - * that receives a value from the source Observable, for computing the timeout - * duration for each source value, returned as an Observable or a Promise. - * @return A function that returns an Observable that delays the emissions of - * the source Observable by the specified duration Observable returned by - * `durationSelector`, and may drop some values if they occur too frequently. - */ -export function debounce<T>(durationSelector: (value: T) => ObservableInput<any>): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let hasValue = false; - let lastValue: T | null = null; - // The subscriber/subscription for the current debounce, if there is one. - let durationSubscriber: Subscriber<any> | null = null; - - const emit = () => { - // Unsubscribe any current debounce subscription we have, - // we only cared about the first notification from it, and we - // want to clean that subscription up as soon as possible. - durationSubscriber?.unsubscribe(); - durationSubscriber = null; - if (hasValue) { - // We have a value! Free up memory first, then emit the value. - hasValue = false; - const value = lastValue!; - lastValue = null; - subscriber.next(value); - } - }; - - source.subscribe( - createOperatorSubscriber( - subscriber, - (value: T) => { - // Cancel any pending debounce duration. We don't - // need to null it out here yet tho, because we're just going - // to create another one in a few lines. - durationSubscriber?.unsubscribe(); - hasValue = true; - lastValue = value; - // Capture our duration subscriber, so we can unsubscribe it when we're notified - // and we're going to emit the value. - durationSubscriber = createOperatorSubscriber(subscriber, emit, noop); - // Subscribe to the duration. - innerFrom(durationSelector(value)).subscribe(durationSubscriber); - }, - () => { - // Source completed. - // Emit any pending debounced values then complete - emit(); - subscriber.complete(); - }, - // Pass all errors through to consumer - undefined, - () => { - // Finalization. - lastValue = durationSubscriber = null; - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/debounceTime.ts b/node_modules/rxjs/src/internal/operators/debounceTime.ts deleted file mode 100644 index 0992bce..0000000 --- a/node_modules/rxjs/src/internal/operators/debounceTime.ts +++ /dev/null @@ -1,123 +0,0 @@ -import { asyncScheduler } from '../scheduler/async'; -import { Subscription } from '../Subscription'; -import { MonoTypeOperatorFunction, SchedulerAction, SchedulerLike } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Emits a notification from the source Observable only after a particular time span - * has passed without another source emission. - * - * <span class="informal">It's like {@link delay}, but passes only the most - * recent notification from each burst of emissions.</span> - * - *  - * - * `debounceTime` delays notifications emitted by the source Observable, but drops - * previous pending delayed emissions if a new notification arrives on the source - * Observable. This operator keeps track of the most recent notification from the - * source Observable, and emits that only when `dueTime` has passed - * without any other notification appearing on the source Observable. If a new value - * appears before `dueTime` silence occurs, the previous notification will be dropped - * and will not be emitted and a new `dueTime` is scheduled. - * If the completing event happens during `dueTime` the last cached notification - * is emitted before the completion event is forwarded to the output observable. - * If the error event happens during `dueTime` or after it only the error event is - * forwarded to the output observable. The cache notification is not emitted in this case. - * - * This is a rate-limiting operator, because it is impossible for more than one - * notification to be emitted in any time window of duration `dueTime`, but it is also - * a delay-like operator since output emissions do not occur at the same time as - * they did on the source Observable. Optionally takes a {@link SchedulerLike} for - * managing timers. - * - * ## Example - * - * Emit the most recent click after a burst of clicks - * - * ```ts - * import { fromEvent, debounceTime } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(debounceTime(1000)); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link audit} - * @see {@link auditTime} - * @see {@link debounce} - * @see {@link sample} - * @see {@link sampleTime} - * @see {@link throttle} - * @see {@link throttleTime} - * - * @param dueTime The timeout duration in milliseconds (or the time unit determined - * internally by the optional `scheduler`) for the window of time required to wait - * for emission silence before emitting the most recent source value. - * @param scheduler The {@link SchedulerLike} to use for managing the timers that - * handle the timeout for each value. - * @return A function that returns an Observable that delays the emissions of - * the source Observable by the specified `dueTime`, and may drop some values - * if they occur too frequently. - */ -export function debounceTime<T>(dueTime: number, scheduler: SchedulerLike = asyncScheduler): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let activeTask: Subscription | null = null; - let lastValue: T | null = null; - let lastTime: number | null = null; - - const emit = () => { - if (activeTask) { - // We have a value! Free up memory first, then emit the value. - activeTask.unsubscribe(); - activeTask = null; - const value = lastValue!; - lastValue = null; - subscriber.next(value); - } - }; - function emitWhenIdle(this: SchedulerAction<unknown>) { - // This is called `dueTime` after the first value - // but we might have received new values during this window! - - const targetTime = lastTime! + dueTime; - const now = scheduler.now(); - if (now < targetTime) { - // On that case, re-schedule to the new target - activeTask = this.schedule(undefined, targetTime - now); - subscriber.add(activeTask); - return; - } - - emit(); - } - - source.subscribe( - createOperatorSubscriber( - subscriber, - (value: T) => { - lastValue = value; - lastTime = scheduler.now(); - - // Only set up a task if it's not already up - if (!activeTask) { - activeTask = scheduler.schedule(emitWhenIdle, dueTime); - subscriber.add(activeTask); - } - }, - () => { - // Source completed. - // Emit any pending debounced values then complete - emit(); - subscriber.complete(); - }, - // Pass all errors through to consumer. - undefined, - () => { - // Finalization. - lastValue = activeTask = null; - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/defaultIfEmpty.ts b/node_modules/rxjs/src/internal/operators/defaultIfEmpty.ts deleted file mode 100644 index 9e0d277..0000000 --- a/node_modules/rxjs/src/internal/operators/defaultIfEmpty.ts +++ /dev/null @@ -1,59 +0,0 @@ -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Emits a given value if the source Observable completes without emitting any - * `next` value, otherwise mirrors the source Observable. - * - * <span class="informal">If the source Observable turns out to be empty, then - * this operator will emit a default value.</span> - * - *  - * - * `defaultIfEmpty` emits the values emitted by the source Observable or a - * specified default value if the source Observable is empty (completes without - * having emitted any `next` value). - * - * ## Example - * - * If no clicks happen in 5 seconds, then emit 'no clicks' - * - * ```ts - * import { fromEvent, takeUntil, interval, defaultIfEmpty } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const clicksBeforeFive = clicks.pipe(takeUntil(interval(5000))); - * const result = clicksBeforeFive.pipe(defaultIfEmpty('no clicks')); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link empty} - * @see {@link last} - * - * @param defaultValue The default value used if the source - * Observable is empty. - * @return A function that returns an Observable that emits either the - * specified `defaultValue` if the source Observable emits no items, or the - * values emitted by the source Observable. - */ -export function defaultIfEmpty<T, R>(defaultValue: R): OperatorFunction<T, T | R> { - return operate((source, subscriber) => { - let hasValue = false; - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - hasValue = true; - subscriber.next(value); - }, - () => { - if (!hasValue) { - subscriber.next(defaultValue!); - } - subscriber.complete(); - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/delay.ts b/node_modules/rxjs/src/internal/operators/delay.ts deleted file mode 100644 index 47fae49..0000000 --- a/node_modules/rxjs/src/internal/operators/delay.ts +++ /dev/null @@ -1,65 +0,0 @@ -import { asyncScheduler } from '../scheduler/async'; -import { MonoTypeOperatorFunction, SchedulerLike } from '../types'; -import { delayWhen } from './delayWhen'; -import { timer } from '../observable/timer'; - -/** - * Delays the emission of items from the source Observable by a given timeout or - * until a given Date. - * - * <span class="informal">Time shifts each item by some specified amount of - * milliseconds.</span> - * - *  - * - * If the delay argument is a Number, this operator time shifts the source - * Observable by that amount of time expressed in milliseconds. The relative - * time intervals between the values are preserved. - * - * If the delay argument is a Date, this operator time shifts the start of the - * Observable execution until the given date occurs. - * - * ## Examples - * - * Delay each click by one second - * - * ```ts - * import { fromEvent, delay } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const delayedClicks = clicks.pipe(delay(1000)); // each click emitted after 1 second - * delayedClicks.subscribe(x => console.log(x)); - * ``` - * - * Delay all clicks until a future date happens - * - * ```ts - * import { fromEvent, delay } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const date = new Date('March 15, 2050 12:00:00'); // in the future - * const delayedClicks = clicks.pipe(delay(date)); // click emitted only after that date - * delayedClicks.subscribe(x => console.log(x)); - * ``` - * - * @see {@link delayWhen} - * @see {@link throttle} - * @see {@link throttleTime} - * @see {@link debounce} - * @see {@link debounceTime} - * @see {@link sample} - * @see {@link sampleTime} - * @see {@link audit} - * @see {@link auditTime} - * - * @param due The delay duration in milliseconds (a `number`) or a `Date` until - * which the emission of the source items is delayed. - * @param scheduler The {@link SchedulerLike} to use for managing the timers - * that handle the time-shift for each item. - * @return A function that returns an Observable that delays the emissions of - * the source Observable by the specified timeout or Date. - */ -export function delay<T>(due: number | Date, scheduler: SchedulerLike = asyncScheduler): MonoTypeOperatorFunction<T> { - const duration = timer(due, scheduler); - return delayWhen(() => duration); -} diff --git a/node_modules/rxjs/src/internal/operators/delayWhen.ts b/node_modules/rxjs/src/internal/operators/delayWhen.ts deleted file mode 100644 index 0755507..0000000 --- a/node_modules/rxjs/src/internal/operators/delayWhen.ts +++ /dev/null @@ -1,103 +0,0 @@ -import { Observable } from '../Observable'; -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { concat } from '../observable/concat'; -import { take } from './take'; -import { ignoreElements } from './ignoreElements'; -import { mapTo } from './mapTo'; -import { mergeMap } from './mergeMap'; -import { innerFrom } from '../observable/innerFrom'; - -/** @deprecated The `subscriptionDelay` parameter will be removed in v8. */ -export function delayWhen<T>( - delayDurationSelector: (value: T, index: number) => ObservableInput<any>, - subscriptionDelay: Observable<any> -): MonoTypeOperatorFunction<T>; -export function delayWhen<T>(delayDurationSelector: (value: T, index: number) => ObservableInput<any>): MonoTypeOperatorFunction<T>; - -/** - * Delays the emission of items from the source Observable by a given time span - * determined by the emissions of another Observable. - * - * <span class="informal">It's like {@link delay}, but the time span of the - * delay duration is determined by a second Observable.</span> - * - *  - * - * `delayWhen` operator shifts each emitted value from the source Observable by - * a time span determined by another Observable. When the source emits a value, - * the `delayDurationSelector` function is called with the value emitted from - * the source Observable as the first argument to the `delayDurationSelector`. - * The `delayDurationSelector` function should return an {@link ObservableInput}, - * that is internally converted to an Observable that is called the "duration" - * Observable. - * - * The source value is emitted on the output Observable only when the "duration" - * Observable emits ({@link guide/glossary-and-semantics#next next}s) any value. - * Upon that, the "duration" Observable gets unsubscribed. - * - * Before RxJS V7, the {@link guide/glossary-and-semantics#complete completion} - * of the "duration" Observable would have been triggering the emission of the - * source value to the output Observable, but with RxJS V7, this is not the case - * anymore. - * - * Only next notifications (from the "duration" Observable) trigger values from - * the source Observable to be passed to the output Observable. If the "duration" - * Observable only emits the complete notification (without next), the value - * emitted by the source Observable will never get to the output Observable - it - * will be swallowed. If the "duration" Observable errors, the error will be - * propagated to the output Observable. - * - * Optionally, `delayWhen` takes a second argument, `subscriptionDelay`, which - * is an Observable. When `subscriptionDelay` emits its first value or - * completes, the source Observable is subscribed to and starts behaving like - * described in the previous paragraph. If `subscriptionDelay` is not provided, - * `delayWhen` will subscribe to the source Observable as soon as the output - * Observable is subscribed. - * - * ## Example - * - * Delay each click by a random amount of time, between 0 and 5 seconds - * - * ```ts - * import { fromEvent, delayWhen, interval } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const delayedClicks = clicks.pipe( - * delayWhen(() => interval(Math.random() * 5000)) - * ); - * delayedClicks.subscribe(x => console.log(x)); - * ``` - * - * @see {@link delay} - * @see {@link throttle} - * @see {@link throttleTime} - * @see {@link debounce} - * @see {@link debounceTime} - * @see {@link sample} - * @see {@link sampleTime} - * @see {@link audit} - * @see {@link auditTime} - * - * @param delayDurationSelector A function that returns an `ObservableInput` for - * each `value` emitted by the source Observable, which is then used to delay the - * emission of that `value` on the output Observable until the `ObservableInput` - * returned from this function emits a next value. When called, beside `value`, - * this function receives a zero-based `index` of the emission order. - * @param subscriptionDelay An Observable that triggers the subscription to the - * source Observable once it emits any value. - * @return A function that returns an Observable that delays the emissions of - * the source Observable by an amount of time specified by the Observable - * returned by `delayDurationSelector`. - */ -export function delayWhen<T>( - delayDurationSelector: (value: T, index: number) => ObservableInput<any>, - subscriptionDelay?: Observable<any> -): MonoTypeOperatorFunction<T> { - if (subscriptionDelay) { - // DEPRECATED PATH - return (source: Observable<T>) => - concat(subscriptionDelay.pipe(take(1), ignoreElements()), source.pipe(delayWhen(delayDurationSelector))); - } - - return mergeMap((value, index) => innerFrom(delayDurationSelector(value, index)).pipe(take(1), mapTo(value))); -} diff --git a/node_modules/rxjs/src/internal/operators/dematerialize.ts b/node_modules/rxjs/src/internal/operators/dematerialize.ts deleted file mode 100644 index 3a4e17f..0000000 --- a/node_modules/rxjs/src/internal/operators/dematerialize.ts +++ /dev/null @@ -1,58 +0,0 @@ -import { observeNotification } from '../Notification'; -import { OperatorFunction, ObservableNotification, ValueFromNotification } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Converts an Observable of {@link ObservableNotification} objects into the emissions - * that they represent. - * - * <span class="informal">Unwraps {@link ObservableNotification} objects as actual `next`, - * `error` and `complete` emissions. The opposite of {@link materialize}.</span> - * - *  - * - * `dematerialize` is assumed to operate an Observable that only emits - * {@link ObservableNotification} objects as `next` emissions, and does not emit any - * `error`. Such Observable is the output of a `materialize` operation. Those - * notifications are then unwrapped using the metadata they contain, and emitted - * as `next`, `error`, and `complete` on the output Observable. - * - * Use this operator in conjunction with {@link materialize}. - * - * ## Example - * - * Convert an Observable of Notifications to an actual Observable - * - * ```ts - * import { NextNotification, ErrorNotification, of, dematerialize } from 'rxjs'; - * - * const notifA: NextNotification<string> = { kind: 'N', value: 'A' }; - * const notifB: NextNotification<string> = { kind: 'N', value: 'B' }; - * const notifE: ErrorNotification = { kind: 'E', error: new TypeError('x.toUpperCase is not a function') }; - * - * const materialized = of(notifA, notifB, notifE); - * - * const upperCase = materialized.pipe(dematerialize()); - * upperCase.subscribe({ - * next: x => console.log(x), - * error: e => console.error(e) - * }); - * - * // Results in: - * // A - * // B - * // TypeError: x.toUpperCase is not a function - * ``` - * - * @see {@link materialize} - * - * @return A function that returns an Observable that emits items and - * notifications embedded in Notification objects emitted by the source - * Observable. - */ -export function dematerialize<N extends ObservableNotification<any>>(): OperatorFunction<N, ValueFromNotification<N>> { - return operate((source, subscriber) => { - source.subscribe(createOperatorSubscriber(subscriber, (notification) => observeNotification(notification, subscriber))); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/distinct.ts b/node_modules/rxjs/src/internal/operators/distinct.ts deleted file mode 100644 index 70ed2c2..0000000 --- a/node_modules/rxjs/src/internal/operators/distinct.ts +++ /dev/null @@ -1,79 +0,0 @@ -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { noop } from '../util/noop'; -import { innerFrom } from '../observable/innerFrom'; - -/** - * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items. - * - * If a `keySelector` function is provided, then it will project each value from the source observable into a new value that it will - * check for equality with previously projected values. If the `keySelector` function is not provided, it will use each value from the - * source observable directly with an equality check against previous values. - * - * In JavaScript runtimes that support `Set`, this operator will use a `Set` to improve performance of the distinct value checking. - * - * In other runtimes, this operator will use a minimal implementation of `Set` that relies on an `Array` and `indexOf` under the - * hood, so performance will degrade as more values are checked for distinction. Even in newer browsers, a long-running `distinct` - * use might result in memory leaks. To help alleviate this in some scenarios, an optional `flushes` parameter is also provided so - * that the internal `Set` can be "flushed", basically clearing it of values. - * - * ## Examples - * - * A simple example with numbers - * - * ```ts - * import { of, distinct } from 'rxjs'; - * - * of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1) - * .pipe(distinct()) - * .subscribe(x => console.log(x)); - * - * // Outputs - * // 1 - * // 2 - * // 3 - * // 4 - * ``` - * - * An example using the `keySelector` function - * - * ```ts - * import { of, distinct } from 'rxjs'; - * - * of( - * { age: 4, name: 'Foo'}, - * { age: 7, name: 'Bar'}, - * { age: 5, name: 'Foo'} - * ) - * .pipe(distinct(({ name }) => name)) - * .subscribe(x => console.log(x)); - * - * // Outputs - * // { age: 4, name: 'Foo' } - * // { age: 7, name: 'Bar' } - * ``` - * @see {@link distinctUntilChanged} - * @see {@link distinctUntilKeyChanged} - * - * @param keySelector Optional `function` to select which value you want to check as distinct. - * @param flushes Optional `ObservableInput` for flushing the internal HashSet of the operator. - * @return A function that returns an Observable that emits items from the - * source Observable with distinct values. - */ -export function distinct<T, K>(keySelector?: (value: T) => K, flushes?: ObservableInput<any>): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - const distinctKeys = new Set(); - source.subscribe( - createOperatorSubscriber(subscriber, (value) => { - const key = keySelector ? keySelector(value) : value; - if (!distinctKeys.has(key)) { - distinctKeys.add(key); - subscriber.next(value); - } - }) - ); - - flushes && innerFrom(flushes).subscribe(createOperatorSubscriber(subscriber, () => distinctKeys.clear(), noop)); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/distinctUntilChanged.ts b/node_modules/rxjs/src/internal/operators/distinctUntilChanged.ts deleted file mode 100644 index 5db2f98..0000000 --- a/node_modules/rxjs/src/internal/operators/distinctUntilChanged.ts +++ /dev/null @@ -1,182 +0,0 @@ -import { MonoTypeOperatorFunction } from '../types'; -import { identity } from '../util/identity'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -export function distinctUntilChanged<T>(comparator?: (previous: T, current: T) => boolean): MonoTypeOperatorFunction<T>; -export function distinctUntilChanged<T, K>( - comparator: (previous: K, current: K) => boolean, - keySelector: (value: T) => K -): MonoTypeOperatorFunction<T>; - -/** - * Returns a result {@link Observable} that emits all values pushed by the source observable if they - * are distinct in comparison to the last value the result observable emitted. - * - * When provided without parameters or with the first parameter (`{@link distinctUntilChanged#comparator comparator}`), - * it behaves like this: - * - * 1. It will always emit the first value from the source. - * 2. For all subsequent values pushed by the source, they will be compared to the previously emitted values - * using the provided `comparator` or an `===` equality check. - * 3. If the value pushed by the source is determined to be unequal by this check, that value is emitted and - * becomes the new "previously emitted value" internally. - * - * When the second parameter (`{@link distinctUntilChanged#keySelector keySelector}`) is provided, the behavior - * changes: - * - * 1. It will always emit the first value from the source. - * 2. The `keySelector` will be run against all values, including the first value. - * 3. For all values after the first, the selected key will be compared against the key selected from - * the previously emitted value using the `comparator`. - * 4. If the keys are determined to be unequal by this check, the value (not the key), is emitted - * and the selected key from that value is saved for future comparisons against other keys. - * - * ## Examples - * - * A very basic example with no `{@link distinctUntilChanged#comparator comparator}`. Note that `1` is emitted more than once, - * because it's distinct in comparison to the _previously emitted_ value, - * not in comparison to _all other emitted values_. - * - * ```ts - * import { of, distinctUntilChanged } from 'rxjs'; - * - * of(1, 1, 1, 2, 2, 2, 1, 1, 3, 3) - * .pipe(distinctUntilChanged()) - * .subscribe(console.log); - * // Logs: 1, 2, 1, 3 - * ``` - * - * With a `{@link distinctUntilChanged#comparator comparator}`, you can do custom comparisons. Let's say - * you only want to emit a value when all of its components have - * changed: - * - * ```ts - * import { of, distinctUntilChanged } from 'rxjs'; - * - * const totallyDifferentBuilds$ = of( - * { engineVersion: '1.1.0', transmissionVersion: '1.2.0' }, - * { engineVersion: '1.1.0', transmissionVersion: '1.4.0' }, - * { engineVersion: '1.3.0', transmissionVersion: '1.4.0' }, - * { engineVersion: '1.3.0', transmissionVersion: '1.5.0' }, - * { engineVersion: '2.0.0', transmissionVersion: '1.5.0' } - * ).pipe( - * distinctUntilChanged((prev, curr) => { - * return ( - * prev.engineVersion === curr.engineVersion || - * prev.transmissionVersion === curr.transmissionVersion - * ); - * }) - * ); - * - * totallyDifferentBuilds$.subscribe(console.log); - * - * // Logs: - * // { engineVersion: '1.1.0', transmissionVersion: '1.2.0' } - * // { engineVersion: '1.3.0', transmissionVersion: '1.4.0' } - * // { engineVersion: '2.0.0', transmissionVersion: '1.5.0' } - * ``` - * - * You can also provide a custom `{@link distinctUntilChanged#comparator comparator}` to check that emitted - * changes are only in one direction. Let's say you only want to get - * the next record temperature: - * - * ```ts - * import { of, distinctUntilChanged } from 'rxjs'; - * - * const temps$ = of(30, 31, 20, 34, 33, 29, 35, 20); - * - * const recordHighs$ = temps$.pipe( - * distinctUntilChanged((prevHigh, temp) => { - * // If the current temp is less than - * // or the same as the previous record, - * // the record hasn't changed. - * return temp <= prevHigh; - * }) - * ); - * - * recordHighs$.subscribe(console.log); - * // Logs: 30, 31, 34, 35 - * ``` - * - * Selecting update events only when the `updatedBy` field shows - * the account changed hands. - * - * ```ts - * import { of, distinctUntilChanged } from 'rxjs'; - * - * // A stream of updates to a given account - * const accountUpdates$ = of( - * { updatedBy: 'blesh', data: [] }, - * { updatedBy: 'blesh', data: [] }, - * { updatedBy: 'ncjamieson', data: [] }, - * { updatedBy: 'ncjamieson', data: [] }, - * { updatedBy: 'blesh', data: [] } - * ); - * - * // We only want the events where it changed hands - * const changedHands$ = accountUpdates$.pipe( - * distinctUntilChanged(undefined, update => update.updatedBy) - * ); - * - * changedHands$.subscribe(console.log); - * // Logs: - * // { updatedBy: 'blesh', data: Array[0] } - * // { updatedBy: 'ncjamieson', data: Array[0] } - * // { updatedBy: 'blesh', data: Array[0] } - * ``` - * - * @see {@link distinct} - * @see {@link distinctUntilKeyChanged} - * - * @param comparator A function used to compare the previous and current keys for - * equality. Defaults to a `===` check. - * @param keySelector Used to select a key value to be passed to the `comparator`. - * - * @return A function that returns an Observable that emits items from the - * source Observable with distinct values. - */ -export function distinctUntilChanged<T, K>( - comparator?: (previous: K, current: K) => boolean, - keySelector: (value: T) => K = identity as (value: T) => K -): MonoTypeOperatorFunction<T> { - // We've been allowing `null` do be passed as the `compare`, so we can't do - // a default value for the parameter, because that will only work - // for `undefined`. - comparator = comparator ?? defaultCompare; - - return operate((source, subscriber) => { - // The previous key, used to compare against keys selected - // from new arrivals to determine "distinctiveness". - let previousKey: K; - // Whether or not this is the first value we've gotten. - let first = true; - - source.subscribe( - createOperatorSubscriber(subscriber, (value) => { - // We always call the key selector. - const currentKey = keySelector(value); - - // If it's the first value, we always emit it. - // Otherwise, we compare this key to the previous key, and - // if the comparer returns false, we emit. - if (first || !comparator!(previousKey, currentKey)) { - // Update our state *before* we emit the value - // as emission can be the source of re-entrant code - // in functional libraries like this. We only really - // need to do this if it's the first value, or if the - // key we're tracking in previous needs to change. - first = false; - previousKey = currentKey; - - // Emit the value! - subscriber.next(value); - } - }) - ); - }); -} - -function defaultCompare(a: any, b: any) { - return a === b; -} diff --git a/node_modules/rxjs/src/internal/operators/distinctUntilKeyChanged.ts b/node_modules/rxjs/src/internal/operators/distinctUntilKeyChanged.ts deleted file mode 100644 index b7c4593..0000000 --- a/node_modules/rxjs/src/internal/operators/distinctUntilKeyChanged.ts +++ /dev/null @@ -1,75 +0,0 @@ -import { distinctUntilChanged } from './distinctUntilChanged'; -import { MonoTypeOperatorFunction } from '../types'; - -export function distinctUntilKeyChanged<T>(key: keyof T): MonoTypeOperatorFunction<T>; -export function distinctUntilKeyChanged<T, K extends keyof T>(key: K, compare: (x: T[K], y: T[K]) => boolean): MonoTypeOperatorFunction<T>; - -/** - * Returns an Observable that emits all items emitted by the source Observable that - * are distinct by comparison from the previous item, using a property accessed by - * using the key provided to check if the two items are distinct. - * - * If a comparator function is provided, then it will be called for each item to - * test for whether that value should be emitted or not. - * - * If a comparator function is not provided, an equality check is used by default. - * - * ## Examples - * - * An example comparing the name of persons - * - * ```ts - * import { of, distinctUntilKeyChanged } from 'rxjs'; - * - * of( - * { age: 4, name: 'Foo' }, - * { age: 7, name: 'Bar' }, - * { age: 5, name: 'Foo' }, - * { age: 6, name: 'Foo' } - * ).pipe( - * distinctUntilKeyChanged('name') - * ) - * .subscribe(x => console.log(x)); - * - * // displays: - * // { age: 4, name: 'Foo' } - * // { age: 7, name: 'Bar' } - * // { age: 5, name: 'Foo' } - * ``` - * - * An example comparing the first letters of the name - * - * ```ts - * import { of, distinctUntilKeyChanged } from 'rxjs'; - * - * of( - * { age: 4, name: 'Foo1' }, - * { age: 7, name: 'Bar' }, - * { age: 5, name: 'Foo2' }, - * { age: 6, name: 'Foo3' } - * ).pipe( - * distinctUntilKeyChanged('name', (x, y) => x.substring(0, 3) === y.substring(0, 3)) - * ) - * .subscribe(x => console.log(x)); - * - * // displays: - * // { age: 4, name: 'Foo1' } - * // { age: 7, name: 'Bar' } - * // { age: 5, name: 'Foo2' } - * ``` - * - * @see {@link distinct} - * @see {@link distinctUntilChanged} - * - * @param key String key for object property lookup on each item. - * @param compare Optional comparison function called to test if an item is distinct - * from the previous item in the source. - * @return A function that returns an Observable that emits items from the source - * Observable with distinct values based on the key specified. - */ -export function distinctUntilKeyChanged<T, K extends keyof T>( - key: K, - compare?: (x: T[K], y: T[K]) => boolean -): MonoTypeOperatorFunction<T> { - return distinctUntilChanged((x: T, y: T) => (compare ? compare(x[key], y[key]) : x[key] === y[key])); -} diff --git a/node_modules/rxjs/src/internal/operators/elementAt.ts b/node_modules/rxjs/src/internal/operators/elementAt.ts deleted file mode 100644 index 47a1d34..0000000 --- a/node_modules/rxjs/src/internal/operators/elementAt.ts +++ /dev/null @@ -1,68 +0,0 @@ -import { ArgumentOutOfRangeError } from '../util/ArgumentOutOfRangeError'; -import { Observable } from '../Observable'; -import { OperatorFunction } from '../types'; -import { filter } from './filter'; -import { throwIfEmpty } from './throwIfEmpty'; -import { defaultIfEmpty } from './defaultIfEmpty'; -import { take } from './take'; - -/** - * Emits the single value at the specified `index` in a sequence of emissions - * from the source Observable. - * - * <span class="informal">Emits only the i-th value, then completes.</span> - * - *  - * - * `elementAt` returns an Observable that emits the item at the specified - * `index` in the source Observable, or a default value if that `index` is out - * of range and the `default` argument is provided. If the `default` argument is - * not given and the `index` is out of range, the output Observable will emit an - * `ArgumentOutOfRangeError` error. - * - * ## Example - * - * Emit only the third click event - * - * ```ts - * import { fromEvent, elementAt } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(elementAt(2)); - * result.subscribe(x => console.log(x)); - * - * // Results in: - * // click 1 = nothing - * // click 2 = nothing - * // click 3 = MouseEvent object logged to console - * ``` - * - * @see {@link first} - * @see {@link last} - * @see {@link skip} - * @see {@link single} - * @see {@link take} - * - * @throws {ArgumentOutOfRangeError} When using `elementAt(i)`, it delivers an - * `ArgumentOutOfRangeError` to the Observer's `error` callback if `i < 0` or the - * Observable has completed before emitting the i-th `next` notification. - * - * @param index Is the number `i` for the i-th source emission that has happened - * since the subscription, starting from the number `0`. - * @param defaultValue The default value returned for missing indices. - * @return A function that returns an Observable that emits a single item, if - * it is found. Otherwise, it will emit the default value if given. If not, it - * emits an error. - */ -export function elementAt<T, D = T>(index: number, defaultValue?: D): OperatorFunction<T, T | D> { - if (index < 0) { - throw new ArgumentOutOfRangeError(); - } - const hasDefaultValue = arguments.length >= 2; - return (source: Observable<T>) => - source.pipe( - filter((v, i) => i === index), - take(1), - hasDefaultValue ? defaultIfEmpty(defaultValue!) : throwIfEmpty(() => new ArgumentOutOfRangeError()) - ); -} diff --git a/node_modules/rxjs/src/internal/operators/endWith.ts b/node_modules/rxjs/src/internal/operators/endWith.ts deleted file mode 100644 index 436e5b3..0000000 --- a/node_modules/rxjs/src/internal/operators/endWith.ts +++ /dev/null @@ -1,68 +0,0 @@ -/** prettier */ -import { Observable } from '../Observable'; -import { concat } from '../observable/concat'; -import { of } from '../observable/of'; -import { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction, ValueFromArray } from '../types'; - -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function endWith<T>(scheduler: SchedulerLike): MonoTypeOperatorFunction<T>; -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function endWith<T, A extends unknown[] = T[]>( - ...valuesAndScheduler: [...A, SchedulerLike] -): OperatorFunction<T, T | ValueFromArray<A>>; - -export function endWith<T, A extends unknown[] = T[]>(...values: A): OperatorFunction<T, T | ValueFromArray<A>>; - -/** - * Returns an observable that will emit all values from the source, then synchronously emit - * the provided value(s) immediately after the source completes. - * - * NOTE: Passing a last argument of a Scheduler is _deprecated_, and may result in incorrect - * types in TypeScript. - * - * This is useful for knowing when an observable ends. Particularly when paired with an - * operator like {@link takeUntil} - * - *  - * - * ## Example - * - * Emit values to know when an interval starts and stops. The interval will - * stop when a user clicks anywhere on the document. - * - * ```ts - * import { interval, map, fromEvent, startWith, takeUntil, endWith } from 'rxjs'; - * - * const ticker$ = interval(5000).pipe( - * map(() => 'tick') - * ); - * - * const documentClicks$ = fromEvent(document, 'click'); - * - * ticker$.pipe( - * startWith('interval started'), - * takeUntil(documentClicks$), - * endWith('interval ended by click') - * ) - * .subscribe(x => console.log(x)); - * - * // Result (assuming a user clicks after 15 seconds) - * // 'interval started' - * // 'tick' - * // 'tick' - * // 'tick' - * // 'interval ended by click' - * ``` - * - * @see {@link startWith} - * @see {@link concat} - * @see {@link takeUntil} - * - * @param values Items you want the modified Observable to emit last. - * @return A function that returns an Observable that emits all values from the - * source, then synchronously emits the provided value(s) immediately after the - * source completes. - */ -export function endWith<T>(...values: Array<T | SchedulerLike>): MonoTypeOperatorFunction<T> { - return (source: Observable<T>) => concat(source, of(...values)) as Observable<T>; -} diff --git a/node_modules/rxjs/src/internal/operators/every.ts b/node_modules/rxjs/src/internal/operators/every.ts deleted file mode 100644 index a6a86bf..0000000 --- a/node_modules/rxjs/src/internal/operators/every.ts +++ /dev/null @@ -1,66 +0,0 @@ -import { Observable } from '../Observable'; -import { Falsy, OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -export function every<T>(predicate: BooleanConstructor): OperatorFunction<T, Exclude<T, Falsy> extends never ? false : boolean>; -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function every<T>( - predicate: BooleanConstructor, - thisArg: any -): OperatorFunction<T, Exclude<T, Falsy> extends never ? false : boolean>; -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function every<T, A>( - predicate: (this: A, value: T, index: number, source: Observable<T>) => boolean, - thisArg: A -): OperatorFunction<T, boolean>; -export function every<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean): OperatorFunction<T, boolean>; - -/** - * Returns an Observable that emits whether or not every item of the source satisfies the condition specified. - * - * <span class="informal">If all values pass predicate before the source completes, emits true before completion, - * otherwise emit false, then complete.</span> - * - *  - * - * ## Example - * - * A simple example emitting true if all elements are less than 5, false otherwise - * - * ```ts - * import { of, every } from 'rxjs'; - * - * of(1, 2, 3, 4, 5, 6) - * .pipe(every(x => x < 5)) - * .subscribe(x => console.log(x)); // -> false - * ``` - * - * @param predicate A function for determining if an item meets a specified condition. - * @param thisArg Optional object to use for `this` in the callback. - * @return A function that returns an Observable of booleans that determines if - * all items of the source Observable meet the condition specified. - */ -export function every<T>( - predicate: (value: T, index: number, source: Observable<T>) => boolean, - thisArg?: any -): OperatorFunction<T, boolean> { - return operate((source, subscriber) => { - let index = 0; - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - if (!predicate.call(thisArg, value, index++, source)) { - subscriber.next(false); - subscriber.complete(); - } - }, - () => { - subscriber.next(true); - subscriber.complete(); - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/exhaust.ts b/node_modules/rxjs/src/internal/operators/exhaust.ts deleted file mode 100644 index a4410db..0000000 --- a/node_modules/rxjs/src/internal/operators/exhaust.ts +++ /dev/null @@ -1,6 +0,0 @@ -import { exhaustAll } from './exhaustAll'; - -/** - * @deprecated Renamed to {@link exhaustAll}. Will be removed in v8. - */ -export const exhaust = exhaustAll; diff --git a/node_modules/rxjs/src/internal/operators/exhaustAll.ts b/node_modules/rxjs/src/internal/operators/exhaustAll.ts deleted file mode 100644 index 4a58a5e..0000000 --- a/node_modules/rxjs/src/internal/operators/exhaustAll.ts +++ /dev/null @@ -1,51 +0,0 @@ -import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types'; -import { exhaustMap } from './exhaustMap'; -import { identity } from '../util/identity'; - -/** - * Converts a higher-order Observable into a first-order Observable by dropping - * inner Observables while the previous inner Observable has not yet completed. - * - * <span class="informal">Flattens an Observable-of-Observables by dropping the - * next inner Observables while the current inner is still executing.</span> - * - *  - * - * `exhaustAll` subscribes to an Observable that emits Observables, also known as a - * higher-order Observable. Each time it observes one of these emitted inner - * Observables, the output Observable begins emitting the items emitted by that - * inner Observable. So far, it behaves like {@link mergeAll}. However, - * `exhaustAll` ignores every new inner Observable if the previous Observable has - * not yet completed. Once that one completes, it will accept and flatten the - * next inner Observable and repeat this process. - * - * ## Example - * - * Run a finite timer for each click, only if there is no currently active timer - * - * ```ts - * import { fromEvent, map, interval, take, exhaustAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const higherOrder = clicks.pipe( - * map(() => interval(1000).pipe(take(5))) - * ); - * const result = higherOrder.pipe(exhaustAll()); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link combineLatestAll} - * @see {@link concatAll} - * @see {@link switchAll} - * @see {@link switchMap} - * @see {@link mergeAll} - * @see {@link exhaustMap} - * @see {@link zipAll} - * - * @return A function that returns an Observable that takes a source of - * Observables and propagates the first Observable exclusively until it - * completes before subscribing to the next. - */ -export function exhaustAll<O extends ObservableInput<any>>(): OperatorFunction<O, ObservedValueOf<O>> { - return exhaustMap(identity); -} diff --git a/node_modules/rxjs/src/internal/operators/exhaustMap.ts b/node_modules/rxjs/src/internal/operators/exhaustMap.ts deleted file mode 100644 index bf66683..0000000 --- a/node_modules/rxjs/src/internal/operators/exhaustMap.ts +++ /dev/null @@ -1,100 +0,0 @@ -import { Observable } from '../Observable'; -import { Subscriber } from '../Subscriber'; -import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types'; -import { map } from './map'; -import { innerFrom } from '../observable/innerFrom'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/* tslint:disable:max-line-length */ -export function exhaustMap<T, O extends ObservableInput<any>>( - project: (value: T, index: number) => O -): OperatorFunction<T, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function exhaustMap<T, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector: undefined -): OperatorFunction<T, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function exhaustMap<T, I, R>( - project: (value: T, index: number) => ObservableInput<I>, - resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, R>; -/* tslint:enable:max-line-length */ - -/** - * Projects each source value to an Observable which is merged in the output - * Observable only if the previous projected Observable has completed. - * - * <span class="informal">Maps each value to an Observable, then flattens all of - * these inner Observables using {@link exhaustAll}.</span> - * - *  - * - * Returns an Observable that emits items based on applying a function that you - * supply to each item emitted by the source Observable, where that function - * returns an (so-called "inner") Observable. When it projects a source value to - * an Observable, the output Observable begins emitting the items emitted by - * that projected Observable. However, `exhaustMap` ignores every new projected - * Observable if the previous projected Observable has not yet completed. Once - * that one completes, it will accept and flatten the next projected Observable - * and repeat this process. - * - * ## Example - * - * Run a finite timer for each click, only if there is no currently active timer - * - * ```ts - * import { fromEvent, exhaustMap, interval, take } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * exhaustMap(() => interval(1000).pipe(take(5))) - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link concatMap} - * @see {@link exhaust} - * @see {@link mergeMap} - * @see {@link switchMap} - * - * @param project A function that, when applied to an item emitted by the source - * Observable, returns an Observable. - * @return A function that returns an Observable containing projected - * Observables of each item of the source, ignoring projected Observables that - * start before their preceding Observable has completed. - */ -export function exhaustMap<T, R, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, ObservedValueOf<O> | R> { - if (resultSelector) { - // DEPRECATED PATH - return (source: Observable<T>) => - source.pipe(exhaustMap((a, i) => innerFrom(project(a, i)).pipe(map((b: any, ii: any) => resultSelector(a, b, i, ii))))); - } - return operate((source, subscriber) => { - let index = 0; - let innerSub: Subscriber<T> | null = null; - let isComplete = false; - source.subscribe( - createOperatorSubscriber( - subscriber, - (outerValue) => { - if (!innerSub) { - innerSub = createOperatorSubscriber(subscriber, undefined, () => { - innerSub = null; - isComplete && subscriber.complete(); - }); - innerFrom(project(outerValue, index++)).subscribe(innerSub); - } - }, - () => { - isComplete = true; - !innerSub && subscriber.complete(); - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/expand.ts b/node_modules/rxjs/src/internal/operators/expand.ts deleted file mode 100644 index 481a373..0000000 --- a/node_modules/rxjs/src/internal/operators/expand.ts +++ /dev/null @@ -1,95 +0,0 @@ -import { OperatorFunction, ObservableInput, ObservedValueOf, SchedulerLike } from '../types'; -import { operate } from '../util/lift'; -import { mergeInternals } from './mergeInternals'; - -/* tslint:disable:max-line-length */ -export function expand<T, O extends ObservableInput<unknown>>( - project: (value: T, index: number) => O, - concurrent?: number, - scheduler?: SchedulerLike -): OperatorFunction<T, ObservedValueOf<O>>; -/** - * @deprecated The `scheduler` parameter will be removed in v8. If you need to schedule the inner subscription, - * use `subscribeOn` within the projection function: `expand((value) => fn(value).pipe(subscribeOn(scheduler)))`. - * Details: Details: https://rxjs.dev/deprecations/scheduler-argument - */ -export function expand<T, O extends ObservableInput<unknown>>( - project: (value: T, index: number) => O, - concurrent: number | undefined, - scheduler: SchedulerLike -): OperatorFunction<T, ObservedValueOf<O>>; -/* tslint:enable:max-line-length */ - -/** - * Recursively projects each source value to an Observable which is merged in - * the output Observable. - * - * <span class="informal">It's similar to {@link mergeMap}, but applies the - * projection function to every source value as well as every output value. - * It's recursive.</span> - * - *  - * - * Returns an Observable that emits items based on applying a function that you - * supply to each item emitted by the source Observable, where that function - * returns an Observable, and then merging those resulting Observables and - * emitting the results of this merger. *Expand* will re-emit on the output - * Observable every source value. Then, each output value is given to the - * `project` function which returns an inner Observable to be merged on the - * output Observable. Those output values resulting from the projection are also - * given to the `project` function to produce new output values. This is how - * *expand* behaves recursively. - * - * ## Example - * - * Start emitting the powers of two on every click, at most 10 of them - * - * ```ts - * import { fromEvent, map, expand, of, delay, take } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const powersOfTwo = clicks.pipe( - * map(() => 1), - * expand(x => of(2 * x).pipe(delay(1000))), - * take(10) - * ); - * powersOfTwo.subscribe(x => console.log(x)); - * ``` - * - * @see {@link mergeMap} - * @see {@link mergeScan} - * - * @param project A function that, when applied to an item emitted by the source - * or the output Observable, returns an Observable. - * @param concurrent Maximum number of input Observables being subscribed to - * concurrently. - * @param scheduler The {@link SchedulerLike} to use for subscribing to - * each projected inner Observable. - * @return A function that returns an Observable that emits the source values - * and also result of applying the projection function to each value emitted on - * the output Observable and merging the results of the Observables obtained - * from this transformation. - */ -export function expand<T, O extends ObservableInput<unknown>>( - project: (value: T, index: number) => O, - concurrent = Infinity, - scheduler?: SchedulerLike -): OperatorFunction<T, ObservedValueOf<O>> { - concurrent = (concurrent || 0) < 1 ? Infinity : concurrent; - return operate((source, subscriber) => - mergeInternals( - // General merge params - source, - subscriber, - project, - concurrent, - - // onBeforeNext - undefined, - - // Expand-specific - true, // Use expand path - scheduler // Inner subscription scheduler - ) - ); -} diff --git a/node_modules/rxjs/src/internal/operators/filter.ts b/node_modules/rxjs/src/internal/operators/filter.ts deleted file mode 100644 index ccc1dec..0000000 --- a/node_modules/rxjs/src/internal/operators/filter.ts +++ /dev/null @@ -1,75 +0,0 @@ -import { OperatorFunction, MonoTypeOperatorFunction, TruthyTypesOf } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function filter<T, S extends T, A>(predicate: (this: A, value: T, index: number) => value is S, thisArg: A): OperatorFunction<T, S>; -export function filter<T, S extends T>(predicate: (value: T, index: number) => value is S): OperatorFunction<T, S>; -export function filter<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>; -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function filter<T, A>(predicate: (this: A, value: T, index: number) => boolean, thisArg: A): MonoTypeOperatorFunction<T>; -export function filter<T>(predicate: (value: T, index: number) => boolean): MonoTypeOperatorFunction<T>; - -/** - * Filter items emitted by the source Observable by only emitting those that - * satisfy a specified predicate. - * - * <span class="informal">Like - * [Array.prototype.filter()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter), - * it only emits a value from the source if it passes a criterion function.</span> - * - *  - * - * Similar to the well-known `Array.prototype.filter` method, this operator - * takes values from the source Observable, passes them through a `predicate` - * function and only emits those values that yielded `true`. - * - * ## Example - * - * Emit only click events whose target was a DIV element - * - * ```ts - * import { fromEvent, filter } from 'rxjs'; - * - * const div = document.createElement('div'); - * div.style.cssText = 'width: 200px; height: 200px; background: #09c;'; - * document.body.appendChild(div); - * - * const clicks = fromEvent(document, 'click'); - * const clicksOnDivs = clicks.pipe(filter(ev => (<HTMLElement>ev.target).tagName === 'DIV')); - * clicksOnDivs.subscribe(x => console.log(x)); - * ``` - * - * @see {@link distinct} - * @see {@link distinctUntilChanged} - * @see {@link distinctUntilKeyChanged} - * @see {@link ignoreElements} - * @see {@link partition} - * @see {@link skip} - * - * @param predicate A function that - * evaluates each value emitted by the source Observable. If it returns `true`, - * the value is emitted, if `false` the value is not passed to the output - * Observable. 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 A function that returns an Observable that emits items from the - * source Observable that satisfy the specified `predicate`. - */ -export function filter<T>(predicate: (value: T, index: number) => boolean, thisArg?: any): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - // An index passed to our predicate function on each call. - let index = 0; - - // Subscribe to the source, all errors and completions are - // forwarded to the consumer. - source.subscribe( - // Call the predicate with the appropriate `this` context, - // if the predicate returns `true`, then send the value - // to the consumer. - createOperatorSubscriber(subscriber, (value) => predicate.call(thisArg, value, index++) && subscriber.next(value)) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/finalize.ts b/node_modules/rxjs/src/internal/operators/finalize.ts deleted file mode 100644 index 12821fd..0000000 --- a/node_modules/rxjs/src/internal/operators/finalize.ts +++ /dev/null @@ -1,75 +0,0 @@ -import { MonoTypeOperatorFunction } from '../types'; -import { operate } from '../util/lift'; - -/** - * Returns an Observable that mirrors the source Observable, but will call a specified function when - * the source terminates on complete or error. - * The specified function will also be called when the subscriber explicitly unsubscribes. - * - * ## Examples - * - * Execute callback function when the observable completes - * - * ```ts - * import { interval, take, finalize } from 'rxjs'; - * - * // emit value in sequence every 1 second - * const source = interval(1000); - * const example = source.pipe( - * take(5), //take only the first 5 values - * finalize(() => console.log('Sequence complete')) // Execute when the observable completes - * ); - * const subscribe = example.subscribe(val => console.log(val)); - * - * // results: - * // 0 - * // 1 - * // 2 - * // 3 - * // 4 - * // 'Sequence complete' - * ``` - * - * Execute callback function when the subscriber explicitly unsubscribes - * - * ```ts - * import { interval, finalize, tap, noop, timer } from 'rxjs'; - * - * const source = interval(100).pipe( - * finalize(() => console.log('[finalize] Called')), - * tap({ - * next: () => console.log('[next] Called'), - * error: () => console.log('[error] Not called'), - * complete: () => console.log('[tap complete] Not called') - * }) - * ); - * - * const sub = source.subscribe({ - * next: x => console.log(x), - * error: noop, - * complete: () => console.log('[complete] Not called') - * }); - * - * timer(150).subscribe(() => sub.unsubscribe()); - * - * // results: - * // '[next] Called' - * // 0 - * // '[finalize] Called' - * ``` - * - * @param callback Function to be called when source terminates. - * @return A function that returns an Observable that mirrors the source, but - * will call the specified function on termination. - */ -export function finalize<T>(callback: () => void): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - // TODO: This try/finally was only added for `useDeprecatedSynchronousErrorHandling`. - // REMOVE THIS WHEN THAT HOT GARBAGE IS REMOVED IN V8. - try { - source.subscribe(subscriber); - } finally { - subscriber.add(callback); - } - }); -} diff --git a/node_modules/rxjs/src/internal/operators/find.ts b/node_modules/rxjs/src/internal/operators/find.ts deleted file mode 100644 index 0697abf..0000000 --- a/node_modules/rxjs/src/internal/operators/find.ts +++ /dev/null @@ -1,96 +0,0 @@ -import { Observable } from '../Observable'; -import { Subscriber } from '../Subscriber'; -import { OperatorFunction, TruthyTypesOf } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -export function find<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>; -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function find<T, S extends T, A>( - predicate: (this: A, value: T, index: number, source: Observable<T>) => value is S, - thisArg: A -): OperatorFunction<T, S | undefined>; -export function find<T, S extends T>( - predicate: (value: T, index: number, source: Observable<T>) => value is S -): OperatorFunction<T, S | undefined>; -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function find<T, A>( - predicate: (this: A, value: T, index: number, source: Observable<T>) => boolean, - thisArg: A -): OperatorFunction<T, T | undefined>; -export function find<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean): OperatorFunction<T, T | undefined>; -/** - * Emits only the first value emitted by the source Observable that meets some - * condition. - * - * <span class="informal">Finds the first value that passes some test and emits - * that.</span> - * - *  - * - * `find` searches for the first item in the source Observable that matches the - * specified condition embodied by the `predicate`, and returns the first - * occurrence in the source. Unlike {@link first}, the `predicate` is required - * in `find`, and does not emit an error if a valid value is not found - * (emits `undefined` instead). - * - * ## Example - * - * Find and emit the first click that happens on a DIV element - * - * ```ts - * import { fromEvent, find } from 'rxjs'; - * - * const div = document.createElement('div'); - * div.style.cssText = 'width: 200px; height: 200px; background: #09c;'; - * document.body.appendChild(div); - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(find(ev => (<HTMLElement>ev.target).tagName === 'DIV')); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link filter} - * @see {@link first} - * @see {@link findIndex} - * @see {@link take} - * - * @param predicate A function called with each item to test for condition matching. - * @param thisArg An optional argument to determine the value of `this` in the - * `predicate` function. - * @return A function that returns an Observable that emits the first item that - * matches the condition. - */ -export function find<T>( - predicate: (value: T, index: number, source: Observable<T>) => boolean, - thisArg?: any -): OperatorFunction<T, T | undefined> { - return operate(createFind(predicate, thisArg, 'value')); -} - -export function createFind<T>( - predicate: (value: T, index: number, source: Observable<T>) => boolean, - thisArg: any, - emit: 'value' | 'index' -) { - const findIndex = emit === 'index'; - return (source: Observable<T>, subscriber: Subscriber<any>) => { - let index = 0; - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - const i = index++; - if (predicate.call(thisArg, value, i, source)) { - subscriber.next(findIndex ? i : value); - subscriber.complete(); - } - }, - () => { - subscriber.next(findIndex ? -1 : undefined); - subscriber.complete(); - } - ) - ); - }; -} diff --git a/node_modules/rxjs/src/internal/operators/findIndex.ts b/node_modules/rxjs/src/internal/operators/findIndex.ts deleted file mode 100644 index e1ef757..0000000 --- a/node_modules/rxjs/src/internal/operators/findIndex.ts +++ /dev/null @@ -1,63 +0,0 @@ -import { Observable } from '../Observable'; -import { Falsy, OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createFind } from './find'; - -export function findIndex<T>(predicate: BooleanConstructor): OperatorFunction<T, T extends Falsy ? -1 : number>; -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function findIndex<T>(predicate: BooleanConstructor, thisArg: any): OperatorFunction<T, T extends Falsy ? -1 : number>; -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function findIndex<T, A>( - predicate: (this: A, value: T, index: number, source: Observable<T>) => boolean, - thisArg: A -): OperatorFunction<T, number>; -export function findIndex<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean): OperatorFunction<T, number>; - -/** - * Emits only the index of the first value emitted by the source Observable that - * meets some condition. - * - * <span class="informal">It's like {@link find}, but emits the index of the - * found value, not the value itself.</span> - * - *  - * - * `findIndex` searches for the first item in the source Observable that matches - * the specified condition embodied by the `predicate`, and returns the - * (zero-based) index of the first occurrence in the source. Unlike - * {@link first}, the `predicate` is required in `findIndex`, and does not emit - * an error if a valid value is not found. - * - * ## Example - * - * Emit the index of first click that happens on a DIV element - * - * ```ts - * import { fromEvent, findIndex } from 'rxjs'; - * - * const div = document.createElement('div'); - * div.style.cssText = 'width: 200px; height: 200px; background: #09c;'; - * document.body.appendChild(div); - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(findIndex(ev => (<HTMLElement>ev.target).tagName === 'DIV')); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link filter} - * @see {@link find} - * @see {@link first} - * @see {@link take} - * - * @param predicate A function called with each item to test for condition matching. - * @param thisArg An optional argument to determine the value of `this` in the - * `predicate` function. - * @return A function that returns an Observable that emits the index of the - * first item that matches the condition. - */ -export function findIndex<T>( - predicate: (value: T, index: number, source: Observable<T>) => boolean, - thisArg?: any -): OperatorFunction<T, number> { - return operate(createFind(predicate, thisArg, 'index')); -} diff --git a/node_modules/rxjs/src/internal/operators/first.ts b/node_modules/rxjs/src/internal/operators/first.ts deleted file mode 100644 index 337aa59..0000000 --- a/node_modules/rxjs/src/internal/operators/first.ts +++ /dev/null @@ -1,93 +0,0 @@ -import { Observable } from '../Observable'; -import { EmptyError } from '../util/EmptyError'; -import { OperatorFunction, TruthyTypesOf } from '../types'; -import { filter } from './filter'; -import { take } from './take'; -import { defaultIfEmpty } from './defaultIfEmpty'; -import { throwIfEmpty } from './throwIfEmpty'; -import { identity } from '../util/identity'; - -export function first<T, D = T>(predicate?: null, defaultValue?: D): OperatorFunction<T, T | D>; -export function first<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>; -export function first<T, D>(predicate: BooleanConstructor, defaultValue: D): OperatorFunction<T, TruthyTypesOf<T> | D>; -export function first<T, S extends T>( - predicate: (value: T, index: number, source: Observable<T>) => value is S, - defaultValue?: S -): OperatorFunction<T, S>; -export function first<T, S extends T, D>( - predicate: (value: T, index: number, source: Observable<T>) => value is S, - defaultValue: D -): OperatorFunction<T, S | D>; -export function first<T, D = T>( - predicate: (value: T, index: number, source: Observable<T>) => boolean, - defaultValue?: D -): OperatorFunction<T, T | D>; - -/** - * Emits only the first value (or the first value that meets some condition) - * emitted by the source Observable. - * - * <span class="informal">Emits only the first value. Or emits only the first - * value that passes some test.</span> - * - *  - * - * If called with no arguments, `first` emits the first value of the source - * Observable, then completes. If called with a `predicate` function, `first` - * emits the first value of the source that matches the specified condition. Emits an error - * notification if `defaultValue` was not provided and a matching element is not found. - * - * ## Examples - * - * Emit only the first click that happens on the DOM - * - * ```ts - * import { fromEvent, first } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(first()); - * result.subscribe(x => console.log(x)); - * ``` - * - * Emits the first click that happens on a DIV - * - * ```ts - * import { fromEvent, first } from 'rxjs'; - * - * const div = document.createElement('div'); - * div.style.cssText = 'width: 200px; height: 200px; background: #09c;'; - * document.body.appendChild(div); - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(first(ev => (<HTMLElement>ev.target).tagName === 'DIV')); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link filter} - * @see {@link find} - * @see {@link take} - * @see {@link last} - * - * @throws {EmptyError} Delivers an `EmptyError` to the Observer's `error` - * callback if the Observable completes before any `next` notification was sent. - * This is how `first()` is different from `take(1)` which completes instead. - * - * @param predicate An optional function called with each item to test for condition - * matching. - * @param defaultValue The default value emitted in case no valid value was found on - * the source. - * @return A function that returns an Observable that emits the first item that - * matches the condition. - */ -export function first<T, D>( - predicate?: ((value: T, index: number, source: Observable<T>) => boolean) | null, - defaultValue?: D -): OperatorFunction<T, T | D> { - const hasDefaultValue = arguments.length >= 2; - return (source: Observable<T>) => - source.pipe( - predicate ? filter((v, i) => predicate(v, i, source)) : identity, - take(1), - hasDefaultValue ? defaultIfEmpty(defaultValue!) : throwIfEmpty(() => new EmptyError()) - ); -} diff --git a/node_modules/rxjs/src/internal/operators/flatMap.ts b/node_modules/rxjs/src/internal/operators/flatMap.ts deleted file mode 100644 index 817917c..0000000 --- a/node_modules/rxjs/src/internal/operators/flatMap.ts +++ /dev/null @@ -1,6 +0,0 @@ -import { mergeMap } from './mergeMap'; - -/** - * @deprecated Renamed to {@link mergeMap}. Will be removed in v8. - */ -export const flatMap = mergeMap; diff --git a/node_modules/rxjs/src/internal/operators/groupBy.ts b/node_modules/rxjs/src/internal/operators/groupBy.ts deleted file mode 100644 index 17bbb9a..0000000 --- a/node_modules/rxjs/src/internal/operators/groupBy.ts +++ /dev/null @@ -1,288 +0,0 @@ -import { Observable } from '../Observable'; -import { innerFrom } from '../observable/innerFrom'; -import { Subject } from '../Subject'; -import { ObservableInput, Observer, OperatorFunction, SubjectLike } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber, OperatorSubscriber } from './OperatorSubscriber'; - -export interface BasicGroupByOptions<K, T> { - element?: undefined; - duration?: (grouped: GroupedObservable<K, T>) => ObservableInput<any>; - connector?: () => SubjectLike<T>; -} - -export interface GroupByOptionsWithElement<K, E, T> { - element: (value: T) => E; - duration?: (grouped: GroupedObservable<K, E>) => ObservableInput<any>; - connector?: () => SubjectLike<E>; -} - -export function groupBy<T, K>(key: (value: T) => K, options: BasicGroupByOptions<K, T>): OperatorFunction<T, GroupedObservable<K, T>>; - -export function groupBy<T, K, E>( - key: (value: T) => K, - options: GroupByOptionsWithElement<K, E, T> -): OperatorFunction<T, GroupedObservable<K, E>>; - -export function groupBy<T, K extends T>( - key: (value: T) => value is K -): OperatorFunction<T, GroupedObservable<true, K> | GroupedObservable<false, Exclude<T, K>>>; - -export function groupBy<T, K>(key: (value: T) => K): OperatorFunction<T, GroupedObservable<K, T>>; - -/** - * @deprecated use the options parameter instead. - */ -export function groupBy<T, K>( - key: (value: T) => K, - element: void, - duration: (grouped: GroupedObservable<K, T>) => Observable<any> -): OperatorFunction<T, GroupedObservable<K, T>>; - -/** - * @deprecated use the options parameter instead. - */ -export function groupBy<T, K, R>( - key: (value: T) => K, - element?: (value: T) => R, - duration?: (grouped: GroupedObservable<K, R>) => Observable<any> -): OperatorFunction<T, GroupedObservable<K, R>>; - -/** - * Groups the items emitted by an Observable according to a specified criterion, - * and emits these grouped items as `GroupedObservables`, one - * {@link GroupedObservable} per group. - * - *  - * - * When the Observable emits an item, a key is computed for this item with the key function. - * - * If a {@link GroupedObservable} for this key exists, this {@link GroupedObservable} emits. Otherwise, a new - * {@link GroupedObservable} for this key is created and emits. - * - * A {@link GroupedObservable} represents values belonging to the same group represented by a common key. The common - * key is available as the `key` field of a {@link GroupedObservable} instance. - * - * The elements emitted by {@link GroupedObservable}s are by default the items emitted by the Observable, or elements - * returned by the element function. - * - * ## Examples - * - * Group objects by `id` and return as array - * - * ```ts - * import { of, groupBy, mergeMap, reduce } from 'rxjs'; - * - * of( - * { id: 1, name: 'JavaScript' }, - * { id: 2, name: 'Parcel' }, - * { id: 2, name: 'webpack' }, - * { id: 1, name: 'TypeScript' }, - * { id: 3, name: 'TSLint' } - * ).pipe( - * groupBy(p => p.id), - * mergeMap(group$ => group$.pipe(reduce((acc, cur) => [...acc, cur], []))) - * ) - * .subscribe(p => console.log(p)); - * - * // displays: - * // [{ id: 1, name: 'JavaScript' }, { id: 1, name: 'TypeScript'}] - * // [{ id: 2, name: 'Parcel' }, { id: 2, name: 'webpack'}] - * // [{ id: 3, name: 'TSLint' }] - * ``` - * - * Pivot data on the `id` field - * - * ```ts - * import { of, groupBy, mergeMap, reduce, map } from 'rxjs'; - * - * of( - * { id: 1, name: 'JavaScript' }, - * { id: 2, name: 'Parcel' }, - * { id: 2, name: 'webpack' }, - * { id: 1, name: 'TypeScript' }, - * { id: 3, name: 'TSLint' } - * ).pipe( - * groupBy(p => p.id, { element: p => p.name }), - * mergeMap(group$ => group$.pipe(reduce((acc, cur) => [...acc, cur], [`${ group$.key }`]))), - * map(arr => ({ id: parseInt(arr[0], 10), values: arr.slice(1) })) - * ) - * .subscribe(p => console.log(p)); - * - * // displays: - * // { id: 1, values: [ 'JavaScript', 'TypeScript' ] } - * // { id: 2, values: [ 'Parcel', 'webpack' ] } - * // { id: 3, values: [ 'TSLint' ] } - * ``` - * - * @param key A function that extracts the key - * for each item. - * @param element A function that extracts the - * return element for each item. - * @param duration - * A function that returns an Observable to determine how long each group should - * exist. - * @param connector Factory function to create an - * intermediate Subject through which grouped elements are emitted. - * @return A function that returns an Observable that emits GroupedObservables, - * each of which corresponds to a unique key value and each of which emits - * those items from the source Observable that share that key value. - * - * @deprecated Use the options parameter instead. - */ -export function groupBy<T, K, R>( - key: (value: T) => K, - element?: (value: T) => R, - duration?: (grouped: GroupedObservable<K, R>) => Observable<any>, - connector?: () => Subject<R> -): OperatorFunction<T, GroupedObservable<K, R>>; - -// Impl -export function groupBy<T, K, R>( - keySelector: (value: T) => K, - elementOrOptions?: ((value: any) => any) | void | BasicGroupByOptions<K, T> | GroupByOptionsWithElement<K, R, T>, - duration?: (grouped: GroupedObservable<any, any>) => ObservableInput<any>, - connector?: () => SubjectLike<any> -): OperatorFunction<T, GroupedObservable<K, R>> { - return operate((source, subscriber) => { - let element: ((value: any) => any) | void; - if (!elementOrOptions || typeof elementOrOptions === 'function') { - element = elementOrOptions as ((value: any) => any); - } else { - ({ duration, element, connector } = elementOrOptions); - } - - // A lookup for the groups that we have so far. - const groups = new Map<K, SubjectLike<any>>(); - - // Used for notifying all groups and the subscriber in the same way. - const notify = (cb: (group: Observer<any>) => void) => { - groups.forEach(cb); - cb(subscriber); - }; - - // Used to handle errors from the source, AND errors that occur during the - // next call from the source. - const handleError = (err: any) => notify((consumer) => consumer.error(err)); - - // The number of actively subscribed groups - let activeGroups = 0; - - // Whether or not teardown was attempted on this subscription. - let teardownAttempted = false; - - // Capturing a reference to this, because we need a handle to it - // in `createGroupedObservable` below. This is what we use to - // subscribe to our source observable. This sometimes needs to be unsubscribed - // out-of-band with our `subscriber` which is the downstream subscriber, or destination, - // in cases where a user unsubscribes from the main resulting subscription, but - // still has groups from this subscription subscribed and would expect values from it - // Consider: `source.pipe(groupBy(fn), take(2))`. - const groupBySourceSubscriber = new OperatorSubscriber( - subscriber, - (value: T) => { - // Because we have to notify all groups of any errors that occur in here, - // we have to add our own try/catch to ensure that those errors are propagated. - // OperatorSubscriber will only send the error to the main subscriber. - try { - const key = keySelector(value); - - let group = groups.get(key); - if (!group) { - // Create our group subject - groups.set(key, (group = connector ? connector() : new Subject<any>())); - - // Emit the grouped observable. Note that we can't do a simple `asObservable()` here, - // because the grouped observable has special semantics around reference counting - // to ensure we don't sever our connection to the source prematurely. - const grouped = createGroupedObservable(key, group); - subscriber.next(grouped); - - if (duration) { - const durationSubscriber = createOperatorSubscriber( - // Providing the group here ensures that it is disposed of -- via `unsubscribe` -- - // when the duration subscription is torn down. That is important, because then - // if someone holds a handle to the grouped observable and tries to subscribe to it - // after the connection to the source has been severed, they will get an - // `ObjectUnsubscribedError` and know they can't possibly get any notifications. - group as any, - () => { - // Our duration notified! We can complete the group. - // The group will be removed from the map in the finalization phase. - group!.complete(); - durationSubscriber?.unsubscribe(); - }, - // Completions are also sent to the group, but just the group. - undefined, - // Errors on the duration subscriber are sent to the group - // but only the group. They are not sent to the main subscription. - undefined, - // Finalization: Remove this group from our map. - () => groups.delete(key) - ); - - // Start our duration notifier. - groupBySourceSubscriber.add(innerFrom(duration(grouped)).subscribe(durationSubscriber)); - } - } - - // Send the value to our group. - group.next(element ? element(value) : value); - } catch (err) { - handleError(err); - } - }, - // Source completes. - () => notify((consumer) => consumer.complete()), - // Error from the source. - handleError, - // Free up memory. - // When the source subscription is _finally_ torn down, release the subjects and keys - // in our groups Map, they may be quite large and we don't want to keep them around if we - // don't have to. - () => groups.clear(), - () => { - teardownAttempted = true; - // We only kill our subscription to the source if we have - // no active groups. As stated above, consider this scenario: - // source$.pipe(groupBy(fn), take(2)). - return activeGroups === 0; - } - ); - - // Subscribe to the source - source.subscribe(groupBySourceSubscriber); - - /** - * Creates the actual grouped observable returned. - * @param key The key of the group - * @param groupSubject The subject that fuels the group - */ - function createGroupedObservable(key: K, groupSubject: SubjectLike<any>) { - const result: any = new Observable<T>((groupSubscriber) => { - activeGroups++; - const innerSub = groupSubject.subscribe(groupSubscriber); - return () => { - innerSub.unsubscribe(); - // We can kill the subscription to our source if we now have no more - // active groups subscribed, and a finalization was already attempted on - // the source. - --activeGroups === 0 && teardownAttempted && groupBySourceSubscriber.unsubscribe(); - }; - }); - result.key = key; - return result; - } - }); -} - -/** - * An observable of values that is the emitted by the result of a {@link groupBy} operator, - * contains a `key` property for the grouping. - */ -export interface GroupedObservable<K, T> extends Observable<T> { - /** - * The key value for the grouped notifications. - */ - readonly key: K; -} diff --git a/node_modules/rxjs/src/internal/operators/ignoreElements.ts b/node_modules/rxjs/src/internal/operators/ignoreElements.ts deleted file mode 100644 index d4977ac..0000000 --- a/node_modules/rxjs/src/internal/operators/ignoreElements.ts +++ /dev/null @@ -1,45 +0,0 @@ -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { noop } from '../util/noop'; - -/** - * Ignores all items emitted by the source Observable and only passes calls of `complete` or `error`. - * - *  - * - * The `ignoreElements` operator suppresses all items emitted by the source Observable, - * but allows its termination notification (either `error` or `complete`) to pass through unchanged. - * - * If you do not care about the items being emitted by an Observable, but you do want to be notified - * when it completes or when it terminates with an error, you can apply the `ignoreElements` operator - * to the Observable, which will ensure that it will never call its observers’ `next` handlers. - * - * ## Example - * - * Ignore all `next` emissions from the source - * - * ```ts - * import { of, ignoreElements } from 'rxjs'; - * - * of('you', 'talking', 'to', 'me') - * .pipe(ignoreElements()) - * .subscribe({ - * next: word => console.log(word), - * error: err => console.log('error:', err), - * complete: () => console.log('the end'), - * }); - * - * // result: - * // 'the end' - * ``` - * - * @return A function that returns an empty Observable that only calls - * `complete` or `error`, based on which one is called by the source - * Observable. - */ -export function ignoreElements(): OperatorFunction<unknown, never> { - return operate((source, subscriber) => { - source.subscribe(createOperatorSubscriber(subscriber, noop)); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/isEmpty.ts b/node_modules/rxjs/src/internal/operators/isEmpty.ts deleted file mode 100644 index 5de8deb..0000000 --- a/node_modules/rxjs/src/internal/operators/isEmpty.ts +++ /dev/null @@ -1,82 +0,0 @@ -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Emits `false` if the input Observable emits any values, or emits `true` if the - * input Observable completes without emitting any values. - * - * <span class="informal">Tells whether any values are emitted by an Observable.</span> - * - *  - * - * `isEmpty` transforms an Observable that emits values into an Observable that - * emits a single boolean value representing whether or not any values were - * emitted by the source Observable. As soon as the source Observable emits a - * value, `isEmpty` will emit a `false` and complete. If the source Observable - * completes having not emitted anything, `isEmpty` will emit a `true` and - * complete. - * - * A similar effect could be achieved with {@link count}, but `isEmpty` can emit - * a `false` value sooner. - * - * ## Examples - * - * Emit `false` for a non-empty Observable - * - * ```ts - * import { Subject, isEmpty } from 'rxjs'; - * - * const source = new Subject<string>(); - * const result = source.pipe(isEmpty()); - * - * source.subscribe(x => console.log(x)); - * result.subscribe(x => console.log(x)); - * - * source.next('a'); - * source.next('b'); - * source.next('c'); - * source.complete(); - * - * // Outputs - * // 'a' - * // false - * // 'b' - * // 'c' - * ``` - * - * Emit `true` for an empty Observable - * - * ```ts - * import { EMPTY, isEmpty } from 'rxjs'; - * - * const result = EMPTY.pipe(isEmpty()); - * result.subscribe(x => console.log(x)); - * - * // Outputs - * // true - * ``` - * - * @see {@link count} - * @see {@link EMPTY} - * - * @return A function that returns an Observable that emits boolean value - * indicating whether the source Observable was empty or not. - */ -export function isEmpty<T>(): OperatorFunction<T, boolean> { - return operate((source, subscriber) => { - source.subscribe( - createOperatorSubscriber( - subscriber, - () => { - subscriber.next(false); - subscriber.complete(); - }, - () => { - subscriber.next(true); - subscriber.complete(); - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/joinAllInternals.ts b/node_modules/rxjs/src/internal/operators/joinAllInternals.ts deleted file mode 100644 index 74876e9..0000000 --- a/node_modules/rxjs/src/internal/operators/joinAllInternals.ts +++ /dev/null @@ -1,29 +0,0 @@ -import { Observable } from '../Observable'; -import { ObservableInput, OperatorFunction } from '../types'; -import { identity } from '../util/identity'; -import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs'; -import { pipe } from '../util/pipe'; -import { mergeMap } from './mergeMap'; -import { toArray } from './toArray'; - -/** - * Collects all of the inner sources from source observable. Then, once the - * source completes, joins the values using the given static. - * - * This is used for {@link combineLatestAll} and {@link zipAll} which both have the - * same behavior of collecting all inner observables, then operating on them. - * - * @param joinFn The type of static join to apply to the sources collected - * @param project The projection function to apply to the values, if any - */ -export function joinAllInternals<T, R>(joinFn: (sources: ObservableInput<T>[]) => Observable<T>, project?: (...args: any[]) => R) { - return pipe( - // Collect all inner sources into an array, and emit them when the - // source completes. - toArray() as OperatorFunction<ObservableInput<T>, ObservableInput<T>[]>, - // Run the join function on the collected array of inner sources. - mergeMap((sources) => joinFn(sources)), - // If a projection function was supplied, apply it to each result. - project ? mapOneOrManyArgs(project) : (identity as any) - ); -} diff --git a/node_modules/rxjs/src/internal/operators/last.ts b/node_modules/rxjs/src/internal/operators/last.ts deleted file mode 100644 index 698ce23..0000000 --- a/node_modules/rxjs/src/internal/operators/last.ts +++ /dev/null @@ -1,91 +0,0 @@ -import { Observable } from '../Observable'; -import { EmptyError } from '../util/EmptyError'; -import { OperatorFunction, TruthyTypesOf } from '../types'; -import { filter } from './filter'; -import { takeLast } from './takeLast'; -import { throwIfEmpty } from './throwIfEmpty'; -import { defaultIfEmpty } from './defaultIfEmpty'; -import { identity } from '../util/identity'; - -export function last<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>; -export function last<T, D>(predicate: BooleanConstructor, defaultValue: D): OperatorFunction<T, TruthyTypesOf<T> | D>; -export function last<T, D = T>(predicate?: null, defaultValue?: D): OperatorFunction<T, T | D>; -export function last<T, S extends T>( - predicate: (value: T, index: number, source: Observable<T>) => value is S, - defaultValue?: S -): OperatorFunction<T, S>; -export function last<T, D = T>( - predicate: (value: T, index: number, source: Observable<T>) => boolean, - defaultValue?: D -): OperatorFunction<T, T | D>; - -/** - * Returns an Observable that emits only the last item emitted by the source Observable. - * It optionally takes a predicate function as a parameter, in which case, rather than emitting - * the last item from the source Observable, the resulting Observable will emit the last item - * from the source Observable that satisfies the predicate. - * - *  - * - * It will emit an error notification if the source completes without notification or one that matches - * the predicate. It returns the last value or if a predicate is provided last value that matches the - * predicate. It returns the given default value if no notification is emitted or matches the predicate. - * - * ## Examples - * - * Last alphabet from the sequence - * - * ```ts - * import { from, last } from 'rxjs'; - * - * const source = from(['x', 'y', 'z']); - * const result = source.pipe(last()); - * - * result.subscribe(value => console.log(`Last alphabet: ${ value }`)); - * - * // Outputs - * // Last alphabet: z - * ``` - * - * Default value when the value in the predicate is not matched - * - * ```ts - * import { from, last } from 'rxjs'; - * - * const source = from(['x', 'y', 'z']); - * const result = source.pipe(last(char => char === 'a', 'not found')); - * - * result.subscribe(value => console.log(`'a' is ${ value }.`)); - * - * // Outputs - * // 'a' is not found. - * ``` - * - * @see {@link skip} - * @see {@link skipUntil} - * @see {@link skipLast} - * @see {@link skipWhile} - * @see {@link first} - * - * @throws {EmptyError} Delivers an `EmptyError` to the Observer's `error` - * callback if the Observable completes before any `next` notification was sent. - * - * @param predicate The condition any source emitted item has to satisfy. - * @param defaultValue An optional default value to provide if last `predicate` - * isn't met or no values were emitted. - * @return A function that returns an Observable that emits only the last item - * satisfying the given condition from the source, or an error notification - * with an `EmptyError` object if no such items are emitted. - */ -export function last<T, D>( - predicate?: ((value: T, index: number, source: Observable<T>) => boolean) | null, - defaultValue?: D -): OperatorFunction<T, T | D> { - const hasDefaultValue = arguments.length >= 2; - return (source: Observable<T>) => - source.pipe( - predicate ? filter((v, i) => predicate(v, i, source)) : identity, - takeLast(1), - hasDefaultValue ? defaultIfEmpty(defaultValue!) : throwIfEmpty(() => new EmptyError()) - ); -} diff --git a/node_modules/rxjs/src/internal/operators/map.ts b/node_modules/rxjs/src/internal/operators/map.ts deleted file mode 100644 index fa7305d..0000000 --- a/node_modules/rxjs/src/internal/operators/map.ts +++ /dev/null @@ -1,61 +0,0 @@ -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -export function map<T, R>(project: (value: T, index: number) => R): OperatorFunction<T, R>; -/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */ -export function map<T, R, A>(project: (this: A, value: T, index: number) => R, thisArg: A): OperatorFunction<T, R>; - -/** - * Applies a given `project` function to each value emitted by the source - * Observable, and emits the resulting values as an Observable. - * - * <span class="informal">Like [Array.prototype.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map), - * it passes each source value through a transformation function to get - * corresponding output values.</span> - * - *  - * - * Similar to the well known `Array.prototype.map` function, this operator - * applies a projection to each value and emits that projection in the output - * Observable. - * - * ## Example - * - * Map every click to the `clientX` position of that click - * - * ```ts - * import { fromEvent, map } from 'rxjs'; - * - * const clicks = fromEvent<PointerEvent>(document, 'click'); - * const positions = clicks.pipe(map(ev => ev.clientX)); - * - * positions.subscribe(x => console.log(x)); - * ``` - * - * @see {@link mapTo} - * @see {@link pluck} - * - * @param project The function to apply to each `value` emitted by the source - * Observable. The `index` parameter is the number `i` for the i-th emission - * that has happened since the subscription, starting from the number `0`. - * @param thisArg An optional argument to define what `this` is in the - * `project` function. - * @return A function that returns an Observable that emits the values from the - * source Observable transformed by the given `project` function. - */ -export function map<T, R>(project: (value: T, index: number) => R, thisArg?: any): OperatorFunction<T, R> { - return operate((source, subscriber) => { - // The index of the value from the source. Used with projection. - let index = 0; - // Subscribe to the source, all errors and completions are sent along - // to the consumer. - source.subscribe( - createOperatorSubscriber(subscriber, (value: T) => { - // Call the projection function with the appropriate this context, - // and send the resulting value to the consumer. - subscriber.next(project.call(thisArg, value, index++)); - }) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/mapTo.ts b/node_modules/rxjs/src/internal/operators/mapTo.ts deleted file mode 100644 index 9fb8a8e..0000000 --- a/node_modules/rxjs/src/internal/operators/mapTo.ts +++ /dev/null @@ -1,48 +0,0 @@ -import { OperatorFunction } from '../types'; -import { map } from './map'; - -/** @deprecated To be removed in v9. Use {@link map} instead: `map(() => value)`. */ -export function mapTo<R>(value: R): OperatorFunction<unknown, R>; -/** - * @deprecated Do not specify explicit type parameters. Signatures with type parameters - * that cannot be inferred will be removed in v8. `mapTo` itself will be removed in v9, - * use {@link map} instead: `map(() => value)`. - * */ -export function mapTo<T, R>(value: R): OperatorFunction<T, R>; - -/** - * Emits the given constant value on the output Observable every time the source - * Observable emits a value. - * - * <span class="informal">Like {@link map}, but it maps every source value to - * the same output value every time.</span> - * - *  - * - * Takes a constant `value` as argument, and emits that whenever the source - * Observable emits a value. In other words, ignores the actual source value, - * and simply uses the emission moment to know when to emit the given `value`. - * - * ## Example - * - * Map every click to the string `'Hi'` - * - * ```ts - * import { fromEvent, mapTo } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const greetings = clicks.pipe(mapTo('Hi')); - * - * greetings.subscribe(x => console.log(x)); - * ``` - * - * @see {@link map} - * - * @param value The value to map each source value to. - * @return A function that returns an Observable that emits the given `value` - * every time the source Observable emits. - * @deprecated To be removed in v9. Use {@link map} instead: `map(() => value)`. - */ -export function mapTo<R>(value: R): OperatorFunction<unknown, R> { - return map(() => value); -} diff --git a/node_modules/rxjs/src/internal/operators/materialize.ts b/node_modules/rxjs/src/internal/operators/materialize.ts deleted file mode 100644 index 5f9a629..0000000 --- a/node_modules/rxjs/src/internal/operators/materialize.ts +++ /dev/null @@ -1,73 +0,0 @@ -import { Notification } from '../Notification'; -import { OperatorFunction, ObservableNotification } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Represents all of the notifications from the source Observable as `next` - * emissions marked with their original types within {@link Notification} - * objects. - * - * <span class="informal">Wraps `next`, `error` and `complete` emissions in - * {@link Notification} objects, emitted as `next` on the output Observable. - * </span> - * - *  - * - * `materialize` returns an Observable that emits a `next` notification for each - * `next`, `error`, or `complete` emission of the source Observable. When the - * source Observable emits `complete`, the output Observable will emit `next` as - * a Notification of type "complete", and then it will emit `complete` as well. - * When the source Observable emits `error`, the output will emit `next` as a - * Notification of type "error", and then `complete`. - * - * This operator is useful for producing metadata of the source Observable, to - * be consumed as `next` emissions. Use it in conjunction with - * {@link dematerialize}. - * - * ## Example - * - * Convert a faulty Observable to an Observable of Notifications - * - * ```ts - * import { of, materialize, map } from 'rxjs'; - * - * const letters = of('a', 'b', 13, 'd'); - * const upperCase = letters.pipe(map((x: any) => x.toUpperCase())); - * const materialized = upperCase.pipe(materialize()); - * - * materialized.subscribe(x => console.log(x)); - * - * // Results in the following: - * // - Notification { kind: 'N', value: 'A', error: undefined, hasValue: true } - * // - Notification { kind: 'N', value: 'B', error: undefined, hasValue: true } - * // - Notification { kind: 'E', value: undefined, error: TypeError { message: x.toUpperCase is not a function }, hasValue: false } - * ``` - * - * @see {@link Notification} - * @see {@link dematerialize} - * - * @return A function that returns an Observable that emits - * {@link Notification} objects that wrap the original emissions from the - * source Observable with metadata. - */ -export function materialize<T>(): OperatorFunction<T, Notification<T> & ObservableNotification<T>> { - return operate((source, subscriber) => { - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - subscriber.next(Notification.createNext(value)); - }, - () => { - subscriber.next(Notification.createComplete()); - subscriber.complete(); - }, - (err) => { - subscriber.next(Notification.createError(err)); - subscriber.complete(); - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/max.ts b/node_modules/rxjs/src/internal/operators/max.ts deleted file mode 100644 index 8c2f5d0..0000000 --- a/node_modules/rxjs/src/internal/operators/max.ts +++ /dev/null @@ -1,54 +0,0 @@ -import { reduce } from './reduce'; -import { MonoTypeOperatorFunction } from '../types'; -import { isFunction } from '../util/isFunction'; - -/** - * The `max` operator operates on an Observable that emits numbers (or items that - * can be compared with a provided function), and when source Observable completes - * it emits a single item: the item with the largest value. - * - *  - * - * ## Examples - * - * Get the maximal value of a series of numbers - * - * ```ts - * import { of, max } from 'rxjs'; - * - * of(5, 4, 7, 2, 8) - * .pipe(max()) - * .subscribe(x => console.log(x)); - * - * // Outputs - * // 8 - * ``` - * - * Use a comparer function to get the maximal item - * - * ```ts - * import { of, max } from 'rxjs'; - * - * of( - * { age: 7, name: 'Foo' }, - * { age: 5, name: 'Bar' }, - * { age: 9, name: 'Beer' } - * ).pipe( - * max((a, b) => a.age < b.age ? -1 : 1) - * ) - * .subscribe(x => console.log(x.name)); - * - * // Outputs - * // 'Beer' - * ``` - * - * @see {@link min} - * - * @param comparer Optional comparer function that it will use instead of its - * default to compare the value of two items. - * @return A function that returns an Observable that emits item with the - * largest value. - */ -export function max<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T> { - return reduce(isFunction(comparer) ? (x, y) => (comparer(x, y) > 0 ? x : y) : (x, y) => (x > y ? x : y)); -} diff --git a/node_modules/rxjs/src/internal/operators/merge.ts b/node_modules/rxjs/src/internal/operators/merge.ts deleted file mode 100644 index 73fff7d..0000000 --- a/node_modules/rxjs/src/internal/operators/merge.ts +++ /dev/null @@ -1,29 +0,0 @@ -import { ObservableInput, ObservableInputTuple, OperatorFunction, SchedulerLike } from '../types'; -import { operate } from '../util/lift'; -import { mergeAll } from './mergeAll'; -import { popNumber, popScheduler } from '../util/args'; -import { from } from '../observable/from'; - -/** @deprecated Replaced with {@link mergeWith}. Will be removed in v8. */ -export function merge<T, A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>; -/** @deprecated Replaced with {@link mergeWith}. Will be removed in v8. */ -export function merge<T, A extends readonly unknown[]>( - ...sourcesAndConcurrency: [...ObservableInputTuple<A>, number] -): OperatorFunction<T, T | A[number]>; -/** @deprecated Replaced with {@link mergeWith}. Will be removed in v8. */ -export function merge<T, A extends readonly unknown[]>( - ...sourcesAndScheduler: [...ObservableInputTuple<A>, SchedulerLike] -): OperatorFunction<T, T | A[number]>; -/** @deprecated Replaced with {@link mergeWith}. Will be removed in v8. */ -export function merge<T, A extends readonly unknown[]>( - ...sourcesAndConcurrencyAndScheduler: [...ObservableInputTuple<A>, number, SchedulerLike] -): OperatorFunction<T, T | A[number]>; - -export function merge<T>(...args: unknown[]): OperatorFunction<T, unknown> { - const scheduler = popScheduler(args); - const concurrent = popNumber(args, Infinity); - - return operate((source, subscriber) => { - mergeAll(concurrent)(from([source, ...(args as ObservableInput<T>[])], scheduler)).subscribe(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/mergeAll.ts b/node_modules/rxjs/src/internal/operators/mergeAll.ts deleted file mode 100644 index 51f28fd..0000000 --- a/node_modules/rxjs/src/internal/operators/mergeAll.ts +++ /dev/null @@ -1,66 +0,0 @@ -import { mergeMap } from './mergeMap'; -import { identity } from '../util/identity'; -import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types'; - -/** - * Converts a higher-order Observable into a first-order Observable which - * concurrently delivers all values that are emitted on the inner Observables. - * - * <span class="informal">Flattens an Observable-of-Observables.</span> - * - *  - * - * `mergeAll` subscribes to an Observable that emits Observables, also known as - * a higher-order Observable. Each time it observes one of these emitted inner - * Observables, it subscribes to that and delivers all the values from the - * inner Observable on the output Observable. The output Observable only - * completes once all inner Observables have completed. Any error delivered by - * a inner Observable will be immediately emitted on the output Observable. - * - * ## Examples - * - * Spawn a new interval Observable for each click event, and blend their outputs as one Observable - * - * ```ts - * import { fromEvent, map, interval, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const higherOrder = clicks.pipe(map(() => interval(1000))); - * const firstOrder = higherOrder.pipe(mergeAll()); - * - * firstOrder.subscribe(x => console.log(x)); - * ``` - * - * Count from 0 to 9 every second for each click, but only allow 2 concurrent timers - * - * ```ts - * import { fromEvent, map, interval, take, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const higherOrder = clicks.pipe( - * map(() => interval(1000).pipe(take(10))) - * ); - * const firstOrder = higherOrder.pipe(mergeAll(2)); - * - * firstOrder.subscribe(x => console.log(x)); - * ``` - * - * @see {@link combineLatestAll} - * @see {@link concatAll} - * @see {@link exhaustAll} - * @see {@link merge} - * @see {@link mergeMap} - * @see {@link mergeMapTo} - * @see {@link mergeScan} - * @see {@link switchAll} - * @see {@link switchMap} - * @see {@link zipAll} - * - * @param concurrent Maximum number of inner Observables being subscribed to - * concurrently. - * @return A function that returns an Observable that emits values coming from - * all the inner Observables emitted by the source Observable. - */ -export function mergeAll<O extends ObservableInput<any>>(concurrent: number = Infinity): OperatorFunction<O, ObservedValueOf<O>> { - return mergeMap(identity, concurrent); -} diff --git a/node_modules/rxjs/src/internal/operators/mergeInternals.ts b/node_modules/rxjs/src/internal/operators/mergeInternals.ts deleted file mode 100644 index dab3a2b..0000000 --- a/node_modules/rxjs/src/internal/operators/mergeInternals.ts +++ /dev/null @@ -1,149 +0,0 @@ -import { Observable } from '../Observable'; -import { innerFrom } from '../observable/innerFrom'; -import { Subscriber } from '../Subscriber'; -import { ObservableInput, SchedulerLike } from '../types'; -import { executeSchedule } from '../util/executeSchedule'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * A process embodying the general "merge" strategy. This is used in - * `mergeMap` and `mergeScan` because the logic is otherwise nearly identical. - * @param source The original source observable - * @param subscriber The consumer subscriber - * @param project The projection function to get our inner sources - * @param concurrent The number of concurrent inner subscriptions - * @param onBeforeNext Additional logic to apply before nexting to our consumer - * @param expand If `true` this will perform an "expand" strategy, which differs only - * in that it recurses, and the inner subscription must be schedule-able. - * @param innerSubScheduler A scheduler to use to schedule inner subscriptions, - * this is to support the expand strategy, mostly, and should be deprecated - */ -export function mergeInternals<T, R>( - source: Observable<T>, - subscriber: Subscriber<R>, - project: (value: T, index: number) => ObservableInput<R>, - concurrent: number, - onBeforeNext?: (innerValue: R) => void, - expand?: boolean, - innerSubScheduler?: SchedulerLike, - additionalFinalizer?: () => void -) { - // Buffered values, in the event of going over our concurrency limit - const buffer: T[] = []; - // The number of active inner subscriptions. - let active = 0; - // An index to pass to our accumulator function - let index = 0; - // Whether or not the outer source has completed. - let isComplete = false; - - /** - * Checks to see if we can complete our result or not. - */ - const checkComplete = () => { - // If the outer has completed, and nothing is left in the buffer, - // and we don't have any active inner subscriptions, then we can - // Emit the state and complete. - if (isComplete && !buffer.length && !active) { - subscriber.complete(); - } - }; - - // If we're under our concurrency limit, just start the inner subscription, otherwise buffer and wait. - const outerNext = (value: T) => (active < concurrent ? doInnerSub(value) : buffer.push(value)); - - const doInnerSub = (value: T) => { - // If we're expanding, we need to emit the outer values and the inner values - // as the inners will "become outers" in a way as they are recursively fed - // back to the projection mechanism. - expand && subscriber.next(value as any); - - // Increment the number of active subscriptions so we can track it - // against our concurrency limit later. - active++; - - // A flag used to show that the inner observable completed. - // This is checked during finalization to see if we should - // move to the next item in the buffer, if there is on. - let innerComplete = false; - - // Start our inner subscription. - innerFrom(project(value, index++)).subscribe( - createOperatorSubscriber( - subscriber, - (innerValue) => { - // `mergeScan` has additional handling here. For example - // taking the inner value and updating state. - onBeforeNext?.(innerValue); - - if (expand) { - // If we're expanding, then just recurse back to our outer - // handler. It will emit the value first thing. - outerNext(innerValue as any); - } else { - // Otherwise, emit the inner value. - subscriber.next(innerValue); - } - }, - () => { - // Flag that we have completed, so we know to check the buffer - // during finalization. - innerComplete = true; - }, - // Errors are passed to the destination. - undefined, - () => { - // During finalization, if the inner completed (it wasn't errored or - // cancelled), then we want to try the next item in the buffer if - // there is one. - if (innerComplete) { - // We have to wrap this in a try/catch because it happens during - // finalization, possibly asynchronously, and we want to pass - // any errors that happen (like in a projection function) to - // the outer Subscriber. - try { - // INNER SOURCE COMPLETE - // Decrement the active count to ensure that the next time - // we try to call `doInnerSub`, the number is accurate. - active--; - // If we have more values in the buffer, try to process those - // Note that this call will increment `active` ahead of the - // next conditional, if there were any more inner subscriptions - // to start. - while (buffer.length && active < concurrent) { - const bufferedValue = buffer.shift()!; - // Particularly for `expand`, we need to check to see if a scheduler was provided - // for when we want to start our inner subscription. Otherwise, we just start - // are next inner subscription. - if (innerSubScheduler) { - executeSchedule(subscriber, innerSubScheduler, () => doInnerSub(bufferedValue)); - } else { - doInnerSub(bufferedValue); - } - } - // Check to see if we can complete, and complete if so. - checkComplete(); - } catch (err) { - subscriber.error(err); - } - } - } - ) - ); - }; - - // Subscribe to our source observable. - source.subscribe( - createOperatorSubscriber(subscriber, outerNext, () => { - // Outer completed, make a note of it, and check to see if we can complete everything. - isComplete = true; - checkComplete(); - }) - ); - - // Additional finalization (for when the destination is torn down). - // Other finalization is added implicitly via subscription above. - return () => { - additionalFinalizer?.(); - }; -} diff --git a/node_modules/rxjs/src/internal/operators/mergeMap.ts b/node_modules/rxjs/src/internal/operators/mergeMap.ts deleted file mode 100644 index 5b698ea..0000000 --- a/node_modules/rxjs/src/internal/operators/mergeMap.ts +++ /dev/null @@ -1,94 +0,0 @@ -import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types'; -import { map } from './map'; -import { innerFrom } from '../observable/innerFrom'; -import { operate } from '../util/lift'; -import { mergeInternals } from './mergeInternals'; -import { isFunction } from '../util/isFunction'; - -/* tslint:disable:max-line-length */ -export function mergeMap<T, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - concurrent?: number -): OperatorFunction<T, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function mergeMap<T, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector: undefined, - concurrent?: number -): OperatorFunction<T, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function mergeMap<T, R, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R, - concurrent?: number -): OperatorFunction<T, R>; -/* tslint:enable:max-line-length */ - -/** - * Projects each source value to an Observable which is merged in the output - * Observable. - * - * <span class="informal">Maps each value to an Observable, then flattens all of - * these inner Observables using {@link mergeAll}.</span> - * - *  - * - * Returns an Observable that emits items based on applying a function that you - * supply to each item emitted by the source Observable, where that function - * returns an Observable, and then merging those resulting Observables and - * emitting the results of this merger. - * - * ## Example - * - * Map and flatten each letter to an Observable ticking every 1 second - * - * ```ts - * import { of, mergeMap, interval, map } from 'rxjs'; - * - * const letters = of('a', 'b', 'c'); - * const result = letters.pipe( - * mergeMap(x => interval(1000).pipe(map(i => x + i))) - * ); - * - * result.subscribe(x => console.log(x)); - * - * // Results in the following: - * // a0 - * // b0 - * // c0 - * // a1 - * // b1 - * // c1 - * // continues to list a, b, c every second with respective ascending integers - * ``` - * - * @see {@link concatMap} - * @see {@link exhaustMap} - * @see {@link merge} - * @see {@link mergeAll} - * @see {@link mergeMapTo} - * @see {@link mergeScan} - * @see {@link switchMap} - * - * @param project A function that, when applied to an item emitted by the source - * Observable, returns an Observable. - * @param concurrent Maximum number of `ObservableInput`s being subscribed to concurrently. - * @return A function that returns an Observable that emits the result of - * applying the projection function (and the optional deprecated - * `resultSelector`) to each item emitted by the source Observable and merging - * the results of the Observables obtained from this transformation. - */ -export function mergeMap<T, R, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector?: ((outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R) | number, - concurrent: number = Infinity -): OperatorFunction<T, ObservedValueOf<O> | R> { - if (isFunction(resultSelector)) { - // DEPRECATED PATH - return mergeMap((a, i) => map((b: any, ii: number) => resultSelector(a, b, i, ii))(innerFrom(project(a, i))), concurrent); - } else if (typeof resultSelector === 'number') { - concurrent = resultSelector; - } - - return operate((source, subscriber) => mergeInternals(source, subscriber, project, concurrent)); -} diff --git a/node_modules/rxjs/src/internal/operators/mergeMapTo.ts b/node_modules/rxjs/src/internal/operators/mergeMapTo.ts deleted file mode 100644 index bcc4654..0000000 --- a/node_modules/rxjs/src/internal/operators/mergeMapTo.ts +++ /dev/null @@ -1,74 +0,0 @@ -import { OperatorFunction, ObservedValueOf, ObservableInput } from '../types'; -import { mergeMap } from './mergeMap'; -import { isFunction } from '../util/isFunction'; - -/** @deprecated Will be removed in v9. Use {@link mergeMap} instead: `mergeMap(() => result)` */ -export function mergeMapTo<O extends ObservableInput<unknown>>( - innerObservable: O, - concurrent?: number -): OperatorFunction<unknown, ObservedValueOf<O>>; -/** - * @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. - * Details: https://rxjs.dev/deprecations/resultSelector - */ -export function mergeMapTo<T, R, O extends ObservableInput<unknown>>( - innerObservable: O, - resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R, - concurrent?: number -): OperatorFunction<T, R>; -/* tslint:enable:max-line-length */ - -/** - * Projects each source value to the same Observable which is merged multiple - * times in the output Observable. - * - * <span class="informal">It's like {@link mergeMap}, but maps each value always - * to the same inner Observable.</span> - * - *  - * - * Maps each source value to the given Observable `innerObservable` regardless - * of the source value, and then merges those resulting Observables into one - * single Observable, which is the output Observable. - * - * ## Example - * - * For each click event, start an interval Observable ticking every 1 second - * - * ```ts - * import { fromEvent, mergeMapTo, interval } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(mergeMapTo(interval(1000))); - * - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link concatMapTo} - * @see {@link merge} - * @see {@link mergeAll} - * @see {@link mergeMap} - * @see {@link mergeScan} - * @see {@link switchMapTo} - * - * @param innerObservable An `ObservableInput` to replace each value from the - * source Observable. - * @param concurrent Maximum number of input Observables being subscribed to - * concurrently. - * @return A function that returns an Observable that emits items from the - * given `innerObservable`. - * @deprecated Will be removed in v9. Use {@link mergeMap} instead: `mergeMap(() => result)` - */ -export function mergeMapTo<T, R, O extends ObservableInput<unknown>>( - innerObservable: O, - resultSelector?: ((outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R) | number, - concurrent: number = Infinity -): OperatorFunction<T, ObservedValueOf<O> | R> { - if (isFunction(resultSelector)) { - return mergeMap(() => innerObservable, resultSelector, concurrent); - } - if (typeof resultSelector === 'number') { - concurrent = resultSelector; - } - return mergeMap(() => innerObservable, concurrent); -} diff --git a/node_modules/rxjs/src/internal/operators/mergeScan.ts b/node_modules/rxjs/src/internal/operators/mergeScan.ts deleted file mode 100644 index c9c520b..0000000 --- a/node_modules/rxjs/src/internal/operators/mergeScan.ts +++ /dev/null @@ -1,92 +0,0 @@ -import { ObservableInput, OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { mergeInternals } from './mergeInternals'; - -/** - * Applies an accumulator function over the source Observable where the - * accumulator function itself returns an Observable, then each intermediate - * Observable returned is merged into the output Observable. - * - * <span class="informal">It's like {@link scan}, but the Observables returned - * by the accumulator are merged into the outer Observable.</span> - * - * The first parameter of the `mergeScan` is an `accumulator` function which is - * being called every time the source Observable emits a value. `mergeScan` will - * subscribe to the value returned by the `accumulator` function and will emit - * values to the subscriber emitted by inner Observable. - * - * The `accumulator` function is being called with three parameters passed to it: - * `acc`, `value` and `index`. The `acc` parameter is used as the state parameter - * whose value is initially set to the `seed` parameter (the second parameter - * passed to the `mergeScan` operator). - * - * `mergeScan` internally keeps the value of the `acc` parameter: as long as the - * source Observable emits without inner Observable emitting, the `acc` will be - * set to `seed`. The next time the inner Observable emits a value, `mergeScan` - * will internally remember it and it will be passed to the `accumulator` - * function as `acc` parameter the next time source emits. - * - * The `value` parameter of the `accumulator` function is the value emitted by the - * source Observable, while the `index` is a number which represent the order of the - * current emission by the source Observable. It starts with 0. - * - * The last parameter to the `mergeScan` is the `concurrent` value which defaults - * to Infinity. It represents the maximum number of inner Observable subscriptions - * at a time. - * - * ## Example - * - * Count the number of click events - * - * ```ts - * import { fromEvent, map, mergeScan, of } from 'rxjs'; - * - * const click$ = fromEvent(document, 'click'); - * const one$ = click$.pipe(map(() => 1)); - * const seed = 0; - * const count$ = one$.pipe( - * mergeScan((acc, one) => of(acc + one), seed) - * ); - * - * count$.subscribe(x => console.log(x)); - * - * // Results: - * // 1 - * // 2 - * // 3 - * // 4 - * // ...and so on for each click - * ``` - * - * @see {@link scan} - * @see {@link switchScan} - * - * @param accumulator The accumulator function called on each source value. - * @param seed The initial accumulation value. - * @param concurrent Maximum number of input Observables being subscribed to - * concurrently. - * @return A function that returns an Observable of the accumulated values. - */ -export function mergeScan<T, R>( - accumulator: (acc: R, value: T, index: number) => ObservableInput<R>, - seed: R, - concurrent = Infinity -): OperatorFunction<T, R> { - return operate((source, subscriber) => { - // The accumulated state. - let state = seed; - - return mergeInternals( - source, - subscriber, - (value, index) => accumulator(state, value, index), - concurrent, - (value) => { - state = value; - }, - false, - undefined, - () => (state = null!) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/mergeWith.ts b/node_modules/rxjs/src/internal/operators/mergeWith.ts deleted file mode 100644 index b0c8142..0000000 --- a/node_modules/rxjs/src/internal/operators/mergeWith.ts +++ /dev/null @@ -1,49 +0,0 @@ -import { ObservableInputTuple, OperatorFunction } from '../types'; -import { merge } from './merge'; - -/** - * Merge the values from all observables to a single observable result. - * - * Creates an observable, that when subscribed to, subscribes to the source - * observable, and all other sources provided as arguments. All values from - * every source are emitted from the resulting subscription. - * - * When all sources complete, the resulting observable will complete. - * - * When any source errors, the resulting observable will error. - * - * ## Example - * - * Joining all outputs from multiple user input event streams - * - * ```ts - * import { fromEvent, map, mergeWith } from 'rxjs'; - * - * const clicks$ = fromEvent(document, 'click').pipe(map(() => 'click')); - * const mousemoves$ = fromEvent(document, 'mousemove').pipe(map(() => 'mousemove')); - * const dblclicks$ = fromEvent(document, 'dblclick').pipe(map(() => 'dblclick')); - * - * mousemoves$ - * .pipe(mergeWith(clicks$, dblclicks$)) - * .subscribe(x => console.log(x)); - * - * // result (assuming user interactions) - * // 'mousemove' - * // 'mousemove' - * // 'mousemove' - * // 'click' - * // 'click' - * // 'dblclick' - * ``` - * - * @see {@link merge} - * - * @param otherSources the sources to combine the current source with. - * @return A function that returns an Observable that merges the values from - * all given Observables. - */ -export function mergeWith<T, A extends readonly unknown[]>( - ...otherSources: [...ObservableInputTuple<A>] -): OperatorFunction<T, T | A[number]> { - return merge(...otherSources); -} diff --git a/node_modules/rxjs/src/internal/operators/min.ts b/node_modules/rxjs/src/internal/operators/min.ts deleted file mode 100644 index 41dcd09..0000000 --- a/node_modules/rxjs/src/internal/operators/min.ts +++ /dev/null @@ -1,54 +0,0 @@ -import { reduce } from './reduce'; -import { MonoTypeOperatorFunction } from '../types'; -import { isFunction } from '../util/isFunction'; - -/** - * The `min` operator operates on an Observable that emits numbers (or items that - * can be compared with a provided function), and when source Observable completes - * it emits a single item: the item with the smallest value. - * - *  - * - * ## Examples - * - * Get the minimal value of a series of numbers - * - * ```ts - * import { of, min } from 'rxjs'; - * - * of(5, 4, 7, 2, 8) - * .pipe(min()) - * .subscribe(x => console.log(x)); - * - * // Outputs - * // 2 - * ``` - * - * Use a comparer function to get the minimal item - * - * ```ts - * import { of, min } from 'rxjs'; - * - * of( - * { age: 7, name: 'Foo' }, - * { age: 5, name: 'Bar' }, - * { age: 9, name: 'Beer' } - * ).pipe( - * min((a, b) => a.age < b.age ? -1 : 1) - * ) - * .subscribe(x => console.log(x.name)); - * - * // Outputs - * // 'Bar' - * ``` - * - * @see {@link max} - * - * @param comparer Optional comparer function that it will use instead of its - * default to compare the value of two items. - * @return A function that returns an Observable that emits item with the - * smallest value. - */ -export function min<T>(comparer?: (x: T, y: T) => number): MonoTypeOperatorFunction<T> { - return reduce(isFunction(comparer) ? (x, y) => (comparer(x, y) < 0 ? x : y) : (x, y) => (x < y ? x : y)); -} diff --git a/node_modules/rxjs/src/internal/operators/multicast.ts b/node_modules/rxjs/src/internal/operators/multicast.ts deleted file mode 100644 index 4ea03d2..0000000 --- a/node_modules/rxjs/src/internal/operators/multicast.ts +++ /dev/null @@ -1,98 +0,0 @@ -import { Subject } from '../Subject'; -import { Observable } from '../Observable'; -import { ConnectableObservable } from '../observable/ConnectableObservable'; -import { OperatorFunction, UnaryFunction, ObservedValueOf, ObservableInput } from '../types'; -import { isFunction } from '../util/isFunction'; -import { connect } from './connect'; - -/** - * An operator that creates a {@link ConnectableObservable}, that when connected, - * with the `connect` method, will use the provided subject to multicast the values - * from the source to all consumers. - * - * @param subject The subject to multicast through. - * @return A function that returns a {@link ConnectableObservable} - * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}. - * If you're using {@link refCount} after `multicast`, use the {@link share} operator instead. - * `multicast(subject), refCount()` is equivalent to - * `share({ connector: () => subject, resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function multicast<T>(subject: Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>; - -/** - * Because this is deprecated in favor of the {@link connect} operator, and was otherwise poorly documented, - * rather than duplicate the effort of documenting the same behavior, please see documentation for the - * {@link connect} operator. - * - * @param subject The subject used to multicast. - * @param selector A setup function to setup the multicast - * @return A function that returns an observable that mirrors the observable returned by the selector. - * @deprecated Will be removed in v8. Use the {@link connect} operator instead. - * `multicast(subject, selector)` is equivalent to - * `connect(selector, { connector: () => subject })`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function multicast<T, O extends ObservableInput<any>>( - subject: Subject<T>, - selector: (shared: Observable<T>) => O -): OperatorFunction<T, ObservedValueOf<O>>; - -/** - * An operator that creates a {@link ConnectableObservable}, that when connected, - * with the `connect` method, will use the provided subject to multicast the values - * from the source to all consumers. - * - * @param subjectFactory A factory that will be called to create the subject. Passing a function here - * will cause the underlying subject to be "reset" on error, completion, or refCounted unsubscription of - * the source. - * @return A function that returns a {@link ConnectableObservable} - * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}. - * If you're using {@link refCount} after `multicast`, use the {@link share} operator instead. - * `multicast(() => new BehaviorSubject('test')), refCount()` is equivalent to - * `share({ connector: () => new BehaviorSubject('test') })`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function multicast<T>(subjectFactory: () => Subject<T>): UnaryFunction<Observable<T>, ConnectableObservable<T>>; - -/** - * Because this is deprecated in favor of the {@link connect} operator, and was otherwise poorly documented, - * rather than duplicate the effort of documenting the same behavior, please see documentation for the - * {@link connect} operator. - * - * @param subjectFactory A factory that creates the subject used to multicast. - * @param selector A function to setup the multicast and select the output. - * @return A function that returns an observable that mirrors the observable returned by the selector. - * @deprecated Will be removed in v8. Use the {@link connect} operator instead. - * `multicast(subjectFactory, selector)` is equivalent to - * `connect(selector, { connector: subjectFactory })`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function multicast<T, O extends ObservableInput<any>>( - subjectFactory: () => Subject<T>, - selector: (shared: Observable<T>) => O -): OperatorFunction<T, ObservedValueOf<O>>; - -/** - * @deprecated Will be removed in v8. Use the {@link connectable} observable, the {@link connect} operator or the - * {@link share} operator instead. See the overloads below for equivalent replacement examples of this operator's - * behaviors. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function multicast<T, R>( - subjectOrSubjectFactory: Subject<T> | (() => Subject<T>), - selector?: (source: Observable<T>) => Observable<R> -): OperatorFunction<T, R> { - const subjectFactory = isFunction(subjectOrSubjectFactory) ? subjectOrSubjectFactory : () => subjectOrSubjectFactory; - - if (isFunction(selector)) { - // If a selector function is provided, then we're a "normal" operator that isn't - // going to return a ConnectableObservable. We can use `connect` to do what we - // need to do. - return connect(selector, { - connector: subjectFactory, - }); - } - - return (source: Observable<T>) => new ConnectableObservable<any>(source, subjectFactory); -} diff --git a/node_modules/rxjs/src/internal/operators/observeOn.ts b/node_modules/rxjs/src/internal/operators/observeOn.ts deleted file mode 100644 index bd37111..0000000 --- a/node_modules/rxjs/src/internal/operators/observeOn.ts +++ /dev/null @@ -1,70 +0,0 @@ -/** @prettier */ -import { MonoTypeOperatorFunction, SchedulerLike } from '../types'; -import { executeSchedule } from '../util/executeSchedule'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Re-emits all notifications from source Observable with specified scheduler. - * - * <span class="informal">Ensure a specific scheduler is used, from outside of an Observable.</span> - * - * `observeOn` is an operator that accepts a scheduler as a first parameter, which will be used to reschedule - * notifications emitted by the source Observable. It might be useful, if you do not have control over - * internal scheduler of a given Observable, but want to control when its values are emitted nevertheless. - * - * Returned Observable emits the same notifications (nexted values, complete and error events) as the source Observable, - * but rescheduled with provided scheduler. Note that this doesn't mean that source Observables internal - * scheduler will be replaced in any way. Original scheduler still will be used, but when the source Observable emits - * notification, it will be immediately scheduled again - this time with scheduler passed to `observeOn`. - * An anti-pattern would be calling `observeOn` on Observable that emits lots of values synchronously, to split - * that emissions into asynchronous chunks. For this to happen, scheduler would have to be passed into the source - * Observable directly (usually into the operator that creates it). `observeOn` simply delays notifications a - * little bit more, to ensure that they are emitted at expected moments. - * - * As a matter of fact, `observeOn` accepts second parameter, which specifies in milliseconds with what delay notifications - * will be emitted. The main difference between {@link delay} operator and `observeOn` is that `observeOn` - * will delay all notifications - including error notifications - while `delay` will pass through error - * from source Observable immediately when it is emitted. In general it is highly recommended to use `delay` operator - * for any kind of delaying of values in the stream, while using `observeOn` to specify which scheduler should be used - * for notification emissions in general. - * - * ## Example - * - * Ensure values in subscribe are called just before browser repaint - * - * ```ts - * import { interval, observeOn, animationFrameScheduler } from 'rxjs'; - * - * const someDiv = document.createElement('div'); - * someDiv.style.cssText = 'width: 200px;background: #09c'; - * document.body.appendChild(someDiv); - * const intervals = interval(10); // Intervals are scheduled - * // with async scheduler by default... - * intervals.pipe( - * observeOn(animationFrameScheduler) // ...but we will observe on animationFrame - * ) // scheduler to ensure smooth animation. - * .subscribe(val => { - * someDiv.style.height = val + 'px'; - * }); - * ``` - * - * @see {@link delay} - * - * @param scheduler Scheduler that will be used to reschedule notifications from source Observable. - * @param delay Number of milliseconds that states with what delay every notification should be rescheduled. - * @return A function that returns an Observable that emits the same - * notifications as the source Observable, but with provided scheduler. - */ -export function observeOn<T>(scheduler: SchedulerLike, delay = 0): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => executeSchedule(subscriber, scheduler, () => subscriber.next(value), delay), - () => executeSchedule(subscriber, scheduler, () => subscriber.complete(), delay), - (err) => executeSchedule(subscriber, scheduler, () => subscriber.error(err), delay) - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/onErrorResumeNextWith.ts b/node_modules/rxjs/src/internal/operators/onErrorResumeNextWith.ts deleted file mode 100644 index 9355c3f..0000000 --- a/node_modules/rxjs/src/internal/operators/onErrorResumeNextWith.ts +++ /dev/null @@ -1,99 +0,0 @@ -import { ObservableInputTuple, OperatorFunction } from '../types'; -import { argsOrArgArray } from '../util/argsOrArgArray'; -import { onErrorResumeNext as oERNCreate } from '../observable/onErrorResumeNext'; - -export function onErrorResumeNextWith<T, A extends readonly unknown[]>( - sources: [...ObservableInputTuple<A>] -): OperatorFunction<T, T | A[number]>; -export function onErrorResumeNextWith<T, A extends readonly unknown[]>( - ...sources: [...ObservableInputTuple<A>] -): OperatorFunction<T, T | A[number]>; - -/** - * When any of the provided Observable emits an complete or error notification, it immediately subscribes to the next one - * that was passed. - * - * <span class="informal">Execute series of Observables, subscribes to next one on error or complete.</span> - * - *  - * - * `onErrorResumeNext` is an operator that accepts a series of Observables, provided either directly as - * arguments or as an array. If no single Observable is provided, returned Observable will simply behave the same - * as the source. - * - * `onErrorResumeNext` returns an Observable that starts by subscribing and re-emitting values from the source Observable. - * When its stream of values ends - no matter if Observable completed or emitted an error - `onErrorResumeNext` - * will subscribe to the first Observable that was passed as an argument to the method. It will start re-emitting - * its values as well and - again - when that stream ends, `onErrorResumeNext` will proceed to subscribing yet another - * Observable in provided series, no matter if previous Observable completed or ended with an error. This will - * be happening until there is no more Observables left in the series, at which point returned Observable will - * complete - even if the last subscribed stream ended with an error. - * - * `onErrorResumeNext` can be therefore thought of as version of {@link concat} operator, which is more permissive - * when it comes to the errors emitted by its input Observables. While `concat` subscribes to the next Observable - * in series only if previous one successfully completed, `onErrorResumeNext` subscribes even if it ended with - * an error. - * - * Note that you do not get any access to errors emitted by the Observables. In particular do not - * expect these errors to appear in error callback passed to {@link Observable#subscribe}. If you want to take - * specific actions based on what error was emitted by an Observable, you should try out {@link catchError} instead. - * - * - * ## Example - * - * Subscribe to the next Observable after map fails - * - * ```ts - * import { of, onErrorResumeNext, map } from 'rxjs'; - * - * of(1, 2, 3, 0) - * .pipe( - * map(x => { - * if (x === 0) { - * throw Error(); - * } - * - * return 10 / x; - * }), - * onErrorResumeNext(of(1, 2, 3)) - * ) - * .subscribe({ - * next: val => console.log(val), - * error: err => console.log(err), // Will never be called. - * complete: () => console.log('that\'s it!') - * }); - * - * // Logs: - * // 10 - * // 5 - * // 3.3333333333333335 - * // 1 - * // 2 - * // 3 - * // 'that's it!' - * ``` - * - * @see {@link concat} - * @see {@link catchError} - * - * @param sources `ObservableInput`s passed either directly or as an array. - * @return A function that returns an Observable that emits values from source - * Observable, but - if it errors - subscribes to the next passed Observable - * and so on, until it completes or runs out of Observables. - */ -export function onErrorResumeNextWith<T, A extends readonly unknown[]>( - ...sources: [[...ObservableInputTuple<A>]] | [...ObservableInputTuple<A>] -): OperatorFunction<T, T | A[number]> { - // For some reason, TS 4.1 RC gets the inference wrong here and infers the - // result to be `A[number][]` - completely dropping the ObservableInput part - // of the type. This makes no sense whatsoever. As a workaround, the type is - // asserted explicitly. - const nextSources = argsOrArgArray(sources) as unknown as ObservableInputTuple<A>; - - return (source) => oERNCreate(source, ...nextSources); -} - -/** - * @deprecated Renamed. Use {@link onErrorResumeNextWith} instead. Will be removed in v8. - */ -export const onErrorResumeNext = onErrorResumeNextWith; diff --git a/node_modules/rxjs/src/internal/operators/pairwise.ts b/node_modules/rxjs/src/internal/operators/pairwise.ts deleted file mode 100644 index e2b0eba..0000000 --- a/node_modules/rxjs/src/internal/operators/pairwise.ts +++ /dev/null @@ -1,61 +0,0 @@ -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Groups pairs of consecutive emissions together and emits them as an array of - * two values. - * - * <span class="informal">Puts the current value and previous value together as - * an array, and emits that.</span> - * - *  - * - * The Nth emission from the source Observable will cause the output Observable - * to emit an array [(N-1)th, Nth] of the previous and the current value, as a - * pair. For this reason, `pairwise` emits on the second and subsequent - * emissions from the source Observable, but not on the first emission, because - * there is no previous value in that case. - * - * ## Example - * - * On every click (starting from the second), emit the relative distance to the previous click - * - * ```ts - * import { fromEvent, pairwise, map } from 'rxjs'; - * - * const clicks = fromEvent<PointerEvent>(document, 'click'); - * const pairs = clicks.pipe(pairwise()); - * const distance = pairs.pipe( - * map(([first, second]) => { - * const x0 = first.clientX; - * const y0 = first.clientY; - * const x1 = second.clientX; - * const y1 = second.clientY; - * return Math.sqrt(Math.pow(x0 - x1, 2) + Math.pow(y0 - y1, 2)); - * }) - * ); - * - * distance.subscribe(x => console.log(x)); - * ``` - * - * @see {@link buffer} - * @see {@link bufferCount} - * - * @return A function that returns an Observable of pairs (as arrays) of - * consecutive values from the source Observable. - */ -export function pairwise<T>(): OperatorFunction<T, [T, T]> { - return operate((source, subscriber) => { - let prev: T; - let hasPrev = false; - source.subscribe( - createOperatorSubscriber(subscriber, (value) => { - const p = prev; - prev = value; - hasPrev && subscriber.next([p, value]); - hasPrev = true; - }) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/partition.ts b/node_modules/rxjs/src/internal/operators/partition.ts deleted file mode 100644 index 9f29f85..0000000 --- a/node_modules/rxjs/src/internal/operators/partition.ts +++ /dev/null @@ -1,62 +0,0 @@ -import { not } from '../util/not'; -import { filter } from './filter'; -import { Observable } from '../Observable'; -import { UnaryFunction } from '../types'; - -/** - * 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 click events into those on DIV elements and those elsewhere - * - * ```ts - * import { fromEvent } from 'rxjs'; - * import { partition } from 'rxjs/operators'; - * - * const div = document.createElement('div'); - * div.style.cssText = 'width: 200px; height: 200px; background: #09c;'; - * document.body.appendChild(div); - * - * const clicks = fromEvent(document, 'click'); - * const [clicksOnDivs, clicksElsewhere] = clicks.pipe(partition(ev => (<HTMLElement>ev.target).tagName === 'DIV')); - * - * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x)); - * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x)); - * ``` - * - * @see {@link filter} - * - * @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 A function that returns an array with two Observables: one with - * values that passed the predicate, and another with values that did not pass - * the predicate. - * @deprecated Replaced with the {@link partition} static creation function. Will be removed in v8. - */ -export function partition<T>( - predicate: (value: T, index: number) => boolean, - thisArg?: any -): UnaryFunction<Observable<T>, [Observable<T>, Observable<T>]> { - return (source: Observable<T>) => - [filter(predicate, thisArg)(source), filter(not(predicate, thisArg))(source)] as [Observable<T>, Observable<T>]; -} diff --git a/node_modules/rxjs/src/internal/operators/pluck.ts b/node_modules/rxjs/src/internal/operators/pluck.ts deleted file mode 100644 index b80da73..0000000 --- a/node_modules/rxjs/src/internal/operators/pluck.ts +++ /dev/null @@ -1,106 +0,0 @@ -import { map } from './map'; -import { OperatorFunction } from '../types'; - -/* tslint:disable:max-line-length */ -/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */ -export function pluck<T, K1 extends keyof T>(k1: K1): OperatorFunction<T, T[K1]>; -/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */ -export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1]>(k1: K1, k2: K2): OperatorFunction<T, T[K1][K2]>; -/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */ -export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>( - k1: K1, - k2: K2, - k3: K3 -): OperatorFunction<T, T[K1][K2][K3]>; -/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */ -export function pluck<T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2], K4 extends keyof T[K1][K2][K3]>( - k1: K1, - k2: K2, - k3: K3, - k4: K4 -): OperatorFunction<T, T[K1][K2][K3][K4]>; -/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */ -export function pluck< - T, - K1 extends keyof T, - K2 extends keyof T[K1], - K3 extends keyof T[K1][K2], - K4 extends keyof T[K1][K2][K3], - K5 extends keyof T[K1][K2][K3][K4] ->(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5): OperatorFunction<T, T[K1][K2][K3][K4][K5]>; -/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */ -export function pluck< - T, - K1 extends keyof T, - K2 extends keyof T[K1], - K3 extends keyof T[K1][K2], - K4 extends keyof T[K1][K2][K3], - K5 extends keyof T[K1][K2][K3][K4], - K6 extends keyof T[K1][K2][K3][K4][K5] ->(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6): OperatorFunction<T, T[K1][K2][K3][K4][K5][K6]>; -/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */ -export function pluck< - T, - K1 extends keyof T, - K2 extends keyof T[K1], - K3 extends keyof T[K1][K2], - K4 extends keyof T[K1][K2][K3], - K5 extends keyof T[K1][K2][K3][K4], - K6 extends keyof T[K1][K2][K3][K4][K5] ->(k1: K1, k2: K2, k3: K3, k4: K4, k5: K5, k6: K6, ...rest: string[]): OperatorFunction<T, unknown>; -/** @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. */ -export function pluck<T>(...properties: string[]): OperatorFunction<T, unknown>; -/* tslint:enable:max-line-length */ - -/** - * Maps each source value to its specified nested property. - * - * <span class="informal">Like {@link map}, but meant only for picking one of - * the nested properties of every emitted value.</span> - * - *  - * - * Given a list of strings or numbers describing a path to a property, retrieves - * the value of a specified nested property from all values in the source - * Observable. If a property can't be resolved, it will return `undefined` for - * that value. - * - * ## Example - * - * Map every click to the tagName of the clicked target element - * - * ```ts - * import { fromEvent, pluck } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const tagNames = clicks.pipe(pluck('target', 'tagName')); - * - * tagNames.subscribe(x => console.log(x)); - * ``` - * - * @see {@link map} - * - * @param properties The nested properties to pluck from each source - * value. - * @return A function that returns an Observable of property values from the - * source values. - * @deprecated Use {@link map} and optional chaining: `pluck('foo', 'bar')` is `map(x => x?.foo?.bar)`. Will be removed in v8. - */ -export function pluck<T, R>(...properties: Array<string | number | symbol>): OperatorFunction<T, R> { - const length = properties.length; - if (length === 0) { - throw new Error('list of properties cannot be empty.'); - } - return map((x) => { - let currentProp: any = x; - for (let i = 0; i < length; i++) { - const p = currentProp?.[properties[i]]; - if (typeof p !== 'undefined') { - currentProp = p; - } else { - return undefined; - } - } - return currentProp; - }); -} diff --git a/node_modules/rxjs/src/internal/operators/publish.ts b/node_modules/rxjs/src/internal/operators/publish.ts deleted file mode 100644 index 6a42705..0000000 --- a/node_modules/rxjs/src/internal/operators/publish.ts +++ /dev/null @@ -1,93 +0,0 @@ -import { Observable } from '../Observable'; -import { Subject } from '../Subject'; -import { multicast } from './multicast'; -import { ConnectableObservable } from '../observable/ConnectableObservable'; -import { MonoTypeOperatorFunction, OperatorFunction, UnaryFunction, ObservableInput, ObservedValueOf } from '../types'; -import { connect } from './connect'; - -/** - * Returns a connectable observable that, when connected, will multicast - * all values through a single underlying {@link Subject} instance. - * - * @deprecated Will be removed in v8. To create a connectable observable, use {@link connectable}. - * `source.pipe(publish())` is equivalent to - * `connectable(source, { connector: () => new Subject(), resetOnDisconnect: false })`. - * If you're using {@link refCount} after `publish`, use {@link share} operator instead. - * `source.pipe(publish(), refCount())` is equivalent to - * `source.pipe(share({ resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }))`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function publish<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>>; - -/** - * Returns an observable, that when subscribed to, creates an underlying {@link Subject}, - * provides an observable view of it to a `selector` function, takes the observable result of - * that selector function and subscribes to it, sending its values to the consumer, _then_ connects - * the subject to the original source. - * - * @param selector A function used to setup multicasting prior to automatic connection. - * - * @deprecated Will be removed in v8. Use the {@link connect} operator instead. - * `publish(selector)` is equivalent to `connect(selector)`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function publish<T, O extends ObservableInput<any>>(selector: (shared: Observable<T>) => O): OperatorFunction<T, ObservedValueOf<O>>; - -/** - * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called - * before it begins emitting items to those Observers that have subscribed to it. - * - * <span class="informal">Makes a cold Observable hot</span> - * - *  - * - * ## Examples - * - * Make `source$` hot by applying `publish` operator, then merge each inner observable into a single one - * and subscribe - * - * ```ts - * import { zip, interval, of, map, publish, merge, tap } from 'rxjs'; - * - * const source$ = zip(interval(2000), of(1, 2, 3, 4, 5, 6, 7, 8, 9)) - * .pipe(map(([, number]) => number)); - * - * source$ - * .pipe( - * publish(multicasted$ => - * merge( - * multicasted$.pipe(tap(x => console.log('Stream 1:', x))), - * multicasted$.pipe(tap(x => console.log('Stream 2:', x))), - * multicasted$.pipe(tap(x => console.log('Stream 3:', x))) - * ) - * ) - * ) - * .subscribe(); - * - * // Results every two seconds - * // Stream 1: 1 - * // Stream 2: 1 - * // Stream 3: 1 - * // ... - * // Stream 1: 9 - * // Stream 2: 9 - * // Stream 3: 9 - * ``` - * - * @see {@link publishLast} - * @see {@link publishReplay} - * @see {@link publishBehavior} - * - * @param selector Optional selector function which can use the multicasted source sequence as many times - * as needed, without causing multiple subscriptions to the source sequence. - * Subscribers to the given source will receive all notifications of the source from the time of the subscription on. - * @return A function that returns a ConnectableObservable that upon connection - * causes the source Observable to emit items to its Observers. - * @deprecated Will be removed in v8. Use the {@link connectable} observable, the {@link connect} operator or the - * {@link share} operator instead. See the overloads below for equivalent replacement examples of this operator's - * behaviors. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function publish<T, R>(selector?: OperatorFunction<T, R>): MonoTypeOperatorFunction<T> | OperatorFunction<T, R> { - return selector ? (source) => connect(selector)(source) : (source) => multicast(new Subject<T>())(source); -} diff --git a/node_modules/rxjs/src/internal/operators/publishBehavior.ts b/node_modules/rxjs/src/internal/operators/publishBehavior.ts deleted file mode 100644 index d94589c..0000000 --- a/node_modules/rxjs/src/internal/operators/publishBehavior.ts +++ /dev/null @@ -1,26 +0,0 @@ -import { Observable } from '../Observable'; -import { BehaviorSubject } from '../BehaviorSubject'; -import { ConnectableObservable } from '../observable/ConnectableObservable'; -import { UnaryFunction } from '../types'; - -/** - * Creates a {@link ConnectableObservable} that utilizes a {@link BehaviorSubject}. - * - * @param initialValue The initial value passed to the {@link BehaviorSubject}. - * @return A function that returns a {@link ConnectableObservable} - * @deprecated Will be removed in v8. To create a connectable observable that uses a - * {@link BehaviorSubject} under the hood, use {@link connectable}. - * `source.pipe(publishBehavior(initValue))` is equivalent to - * `connectable(source, { connector: () => new BehaviorSubject(initValue), resetOnDisconnect: false })`. - * If you're using {@link refCount} after `publishBehavior`, use the {@link share} operator instead. - * `source.pipe(publishBehavior(initValue), refCount())` is equivalent to - * `source.pipe(share({ connector: () => new BehaviorSubject(initValue), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }))`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function publishBehavior<T>(initialValue: T): UnaryFunction<Observable<T>, ConnectableObservable<T>> { - // Note that this has *never* supported the selector function. - return (source) => { - const subject = new BehaviorSubject<T>(initialValue); - return new ConnectableObservable(source, () => subject); - }; -} diff --git a/node_modules/rxjs/src/internal/operators/publishLast.ts b/node_modules/rxjs/src/internal/operators/publishLast.ts deleted file mode 100644 index ded47fb..0000000 --- a/node_modules/rxjs/src/internal/operators/publishLast.ts +++ /dev/null @@ -1,76 +0,0 @@ -import { Observable } from '../Observable'; -import { AsyncSubject } from '../AsyncSubject'; -import { ConnectableObservable } from '../observable/ConnectableObservable'; -import { UnaryFunction } from '../types'; - -/** - * Returns a connectable observable sequence that shares a single subscription to the - * underlying sequence containing only the last notification. - * - *  - * - * Similar to {@link publish}, but it waits until the source observable completes and stores - * the last emitted value. - * Similarly to {@link publishReplay} and {@link publishBehavior}, this keeps storing the last - * value even if it has no more subscribers. If subsequent subscriptions happen, they will - * immediately get that last stored value and complete. - * - * ## Example - * - * ```ts - * import { ConnectableObservable, interval, publishLast, tap, take } from 'rxjs'; - * - * const connectable = <ConnectableObservable<number>>interval(1000) - * .pipe( - * tap(x => console.log('side effect', x)), - * take(3), - * publishLast() - * ); - * - * connectable.subscribe({ - * next: x => console.log('Sub. A', x), - * error: err => console.log('Sub. A Error', err), - * complete: () => console.log('Sub. A Complete') - * }); - * - * connectable.subscribe({ - * next: x => console.log('Sub. B', x), - * error: err => console.log('Sub. B Error', err), - * complete: () => console.log('Sub. B Complete') - * }); - * - * connectable.connect(); - * - * // Results: - * // 'side effect 0' - after one second - * // 'side effect 1' - after two seconds - * // 'side effect 2' - after three seconds - * // 'Sub. A 2' - immediately after 'side effect 2' - * // 'Sub. B 2' - * // 'Sub. A Complete' - * // 'Sub. B Complete' - * ``` - * - * @see {@link ConnectableObservable} - * @see {@link publish} - * @see {@link publishReplay} - * @see {@link publishBehavior} - * - * @return A function that returns an Observable that emits elements of a - * sequence produced by multicasting the source sequence. - * @deprecated Will be removed in v8. To create a connectable observable with an - * {@link AsyncSubject} under the hood, use {@link connectable}. - * `source.pipe(publishLast())` is equivalent to - * `connectable(source, { connector: () => new AsyncSubject(), resetOnDisconnect: false })`. - * If you're using {@link refCount} after `publishLast`, use the {@link share} operator instead. - * `source.pipe(publishLast(), refCount())` is equivalent to - * `source.pipe(share({ connector: () => new AsyncSubject(), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false }))`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function publishLast<T>(): UnaryFunction<Observable<T>, ConnectableObservable<T>> { - // Note that this has *never* supported a selector function like `publish` and `publishReplay`. - return (source) => { - const subject = new AsyncSubject<T>(); - return new ConnectableObservable(source, () => subject); - }; -} diff --git a/node_modules/rxjs/src/internal/operators/publishReplay.ts b/node_modules/rxjs/src/internal/operators/publishReplay.ts deleted file mode 100644 index 47494e2..0000000 --- a/node_modules/rxjs/src/internal/operators/publishReplay.ts +++ /dev/null @@ -1,96 +0,0 @@ -import { Observable } from '../Observable'; -import { ReplaySubject } from '../ReplaySubject'; -import { multicast } from './multicast'; -import { MonoTypeOperatorFunction, OperatorFunction, TimestampProvider, ObservableInput, ObservedValueOf } from '../types'; -import { isFunction } from '../util/isFunction'; - -/** - * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject} - * internally. - * - * @param bufferSize The buffer size for the underlying {@link ReplaySubject}. - * @param windowTime The window time for the underlying {@link ReplaySubject}. - * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}. - * @deprecated Will be removed in v8. To create a connectable observable that uses a - * {@link ReplaySubject} under the hood, use {@link connectable}. - * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to - * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`. - * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead. - * `publishReplay(size, time, scheduler), refCount()` is equivalent to - * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function publishReplay<T>( - bufferSize?: number, - windowTime?: number, - timestampProvider?: TimestampProvider -): MonoTypeOperatorFunction<T>; - -/** - * Creates an observable, that when subscribed to, will create a {@link ReplaySubject}, - * and pass an observable from it (using [asObservable](api/index/class/Subject#asObservable)) to - * the `selector` function, which then returns an observable that is subscribed to before - * "connecting" the source to the internal `ReplaySubject`. - * - * Since this is deprecated, for additional details see the documentation for {@link connect}. - * - * @param bufferSize The buffer size for the underlying {@link ReplaySubject}. - * @param windowTime The window time for the underlying {@link ReplaySubject}. - * @param selector A function used to setup the multicast. - * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}. - * @deprecated Will be removed in v8. Use the {@link connect} operator instead. - * `source.pipe(publishReplay(size, window, selector, scheduler))` is equivalent to - * `source.pipe(connect(selector, { connector: () => new ReplaySubject(size, window, scheduler) }))`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function publishReplay<T, O extends ObservableInput<any>>( - bufferSize: number | undefined, - windowTime: number | undefined, - selector: (shared: Observable<T>) => O, - timestampProvider?: TimestampProvider -): OperatorFunction<T, ObservedValueOf<O>>; - -/** - * Creates a {@link ConnectableObservable} that uses a {@link ReplaySubject} - * internally. - * - * @param bufferSize The buffer size for the underlying {@link ReplaySubject}. - * @param windowTime The window time for the underlying {@link ReplaySubject}. - * @param selector Passing `undefined` here determines that this operator will return a {@link ConnectableObservable}. - * @param timestampProvider The timestamp provider for the underlying {@link ReplaySubject}. - * @deprecated Will be removed in v8. To create a connectable observable that uses a - * {@link ReplaySubject} under the hood, use {@link connectable}. - * `source.pipe(publishReplay(size, time, scheduler))` is equivalent to - * `connectable(source, { connector: () => new ReplaySubject(size, time, scheduler), resetOnDisconnect: false })`. - * If you're using {@link refCount} after `publishReplay`, use the {@link share} operator instead. - * `publishReplay(size, time, scheduler), refCount()` is equivalent to - * `share({ connector: () => new ReplaySubject(size, time, scheduler), resetOnError: false, resetOnComplete: false, resetOnRefCountZero: false })`. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function publishReplay<T, O extends ObservableInput<any>>( - bufferSize: number | undefined, - windowTime: number | undefined, - selector: undefined, - timestampProvider: TimestampProvider -): OperatorFunction<T, ObservedValueOf<O>>; - -/** - * @deprecated Will be removed in v8. Use the {@link connectable} observable, the {@link connect} operator or the - * {@link share} operator instead. See the overloads below for equivalent replacement examples of this operator's - * behaviors. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function publishReplay<T, R>( - bufferSize?: number, - windowTime?: number, - selectorOrScheduler?: TimestampProvider | OperatorFunction<T, R>, - timestampProvider?: TimestampProvider -) { - if (selectorOrScheduler && !isFunction(selectorOrScheduler)) { - timestampProvider = selectorOrScheduler; - } - const selector = isFunction(selectorOrScheduler) ? selectorOrScheduler : undefined; - // Note, we're passing `selector!` here, because at runtime, `undefined` is an acceptable argument - // but it makes our TypeScript signature for `multicast` unhappy (as it should, because it's gross). - return (source: Observable<T>) => multicast(new ReplaySubject<T>(bufferSize, windowTime, timestampProvider), selector!)(source); -} diff --git a/node_modules/rxjs/src/internal/operators/race.ts b/node_modules/rxjs/src/internal/operators/race.ts deleted file mode 100644 index efa8cd9..0000000 --- a/node_modules/rxjs/src/internal/operators/race.ts +++ /dev/null @@ -1,20 +0,0 @@ -import { ObservableInputTuple, OperatorFunction } from '../types'; -import { argsOrArgArray } from '../util/argsOrArgArray'; -import { raceWith } from './raceWith'; - -/** @deprecated Replaced with {@link raceWith}. Will be removed in v8. */ -export function race<T, A extends readonly unknown[]>(otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>; -/** @deprecated Replaced with {@link raceWith}. Will be removed in v8. */ -export function race<T, A extends readonly unknown[]>(...otherSources: [...ObservableInputTuple<A>]): OperatorFunction<T, T | A[number]>; - -/** - * Returns an Observable that mirrors the first source Observable to emit a next, - * error or complete notification from the combination of this Observable and supplied Observables. - * @param args Sources used to race for which Observable emits first. - * @return A function that returns an Observable that mirrors the output of the - * first Observable to emit an item. - * @deprecated Replaced with {@link raceWith}. Will be removed in v8. - */ -export function race<T>(...args: any[]): OperatorFunction<T, unknown> { - return raceWith(...argsOrArgArray(args)); -} diff --git a/node_modules/rxjs/src/internal/operators/raceWith.ts b/node_modules/rxjs/src/internal/operators/raceWith.ts deleted file mode 100644 index 6e72929..0000000 --- a/node_modules/rxjs/src/internal/operators/raceWith.ts +++ /dev/null @@ -1,40 +0,0 @@ -import { OperatorFunction, ObservableInputTuple } from '../types'; -import { raceInit } from '../observable/race'; -import { operate } from '../util/lift'; -import { identity } from '../util/identity'; - -/** - * Creates an Observable that mirrors the first source Observable to emit a next, - * error or complete notification from the combination of the Observable to which - * the operator is applied and supplied Observables. - * - * ## Example - * - * ```ts - * import { interval, map, raceWith } 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')); - * - * obs1 - * .pipe(raceWith(obs2, obs3)) - * .subscribe(winner => console.log(winner)); - * - * // Outputs - * // a series of 'fast one' - * ``` - * - * @param otherSources Sources used to race for which Observable emits first. - * @return A function that returns an Observable that mirrors the output of the - * first Observable to emit an item. - */ -export function raceWith<T, A extends readonly unknown[]>( - ...otherSources: [...ObservableInputTuple<A>] -): OperatorFunction<T, T | A[number]> { - return !otherSources.length - ? identity - : operate((source, subscriber) => { - raceInit<T | A[number]>([source, ...otherSources])(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/reduce.ts b/node_modules/rxjs/src/internal/operators/reduce.ts deleted file mode 100644 index 5ee565e..0000000 --- a/node_modules/rxjs/src/internal/operators/reduce.ts +++ /dev/null @@ -1,61 +0,0 @@ -import { scanInternals } from './scanInternals'; -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; - -export function reduce<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>; -export function reduce<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>; -export function reduce<V, A, S = A>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>; - -/** - * Applies an accumulator function over the source Observable, and returns the - * accumulated result when the source completes, given an optional seed value. - * - * <span class="informal">Combines together all values emitted on the source, - * using an accumulator function that knows how to join a new source value into - * the accumulation from the past.</span> - * - *  - * - * Like - * [Array.prototype.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce), - * `reduce` applies an `accumulator` function against an accumulation and each - * value of the source Observable (from the past) to reduce it to a single - * value, emitted on the output Observable. Note that `reduce` will only emit - * one value, only when the source Observable completes. It is equivalent to - * applying operator {@link scan} followed by operator {@link last}. - * - * Returns an Observable that applies a specified `accumulator` function to each - * item emitted by the source Observable. If a `seed` value is specified, then - * that value will be used as the initial value for the accumulator. If no seed - * value is specified, the first item of the source is used as the seed. - * - * ## Example - * - * Count the number of click events that happened in 5 seconds - * - * ```ts - * import { fromEvent, takeUntil, interval, map, reduce } from 'rxjs'; - * - * const clicksInFiveSeconds = fromEvent(document, 'click') - * .pipe(takeUntil(interval(5000))); - * - * const ones = clicksInFiveSeconds.pipe(map(() => 1)); - * const seed = 0; - * const count = ones.pipe(reduce((acc, one) => acc + one, seed)); - * - * count.subscribe(x => console.log(x)); - * ``` - * - * @see {@link count} - * @see {@link expand} - * @see {@link mergeScan} - * @see {@link scan} - * - * @param accumulator The accumulator function called on each source value. - * @param seed The initial accumulation value. - * @return A function that returns an Observable that emits a single value that - * is the result of accumulating the values emitted by the source Observable. - */ -export function reduce<V, A>(accumulator: (acc: V | A, value: V, index: number) => A, seed?: any): OperatorFunction<V, V | A> { - return operate(scanInternals(accumulator, seed, arguments.length >= 2, false, true)); -} diff --git a/node_modules/rxjs/src/internal/operators/refCount.ts b/node_modules/rxjs/src/internal/operators/refCount.ts deleted file mode 100644 index c4162c0..0000000 --- a/node_modules/rxjs/src/internal/operators/refCount.ts +++ /dev/null @@ -1,119 +0,0 @@ -import { ConnectableObservable } from '../observable/ConnectableObservable'; -import { Subscription } from '../Subscription'; -import { MonoTypeOperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Make a {@link ConnectableObservable} behave like a ordinary observable and automates the way - * you can connect to it. - * - * Internally it counts the subscriptions to the observable and subscribes (only once) to the source if - * the number of subscriptions is larger than 0. If the number of subscriptions is smaller than 1, it - * unsubscribes from the source. This way you can make sure that everything before the *published* - * refCount has only a single subscription independently of the number of subscribers to the target - * observable. - * - * Note that using the {@link share} operator is exactly the same as using the `multicast(() => new Subject())` operator - * (making the observable hot) and the *refCount* operator in a sequence. - * - *  - * - * ## Example - * - * In the following example there are two intervals turned into connectable observables - * by using the *publish* operator. The first one uses the *refCount* operator, the - * second one does not use it. You will notice that a connectable observable does nothing - * until you call its connect function. - * - * ```ts - * import { interval, tap, publish, refCount } from 'rxjs'; - * - * // Turn the interval observable into a ConnectableObservable (hot) - * const refCountInterval = interval(400).pipe( - * tap(num => console.log(`refCount ${ num }`)), - * publish(), - * refCount() - * ); - * - * const publishedInterval = interval(400).pipe( - * tap(num => console.log(`publish ${ num }`)), - * publish() - * ); - * - * refCountInterval.subscribe(); - * refCountInterval.subscribe(); - * // 'refCount 0' -----> 'refCount 1' -----> etc - * // All subscriptions will receive the same value and the tap (and - * // every other operator) before the `publish` operator will be executed - * // only once per event independently of the number of subscriptions. - * - * publishedInterval.subscribe(); - * // Nothing happens until you call .connect() on the observable. - * ``` - * - * @return A function that returns an Observable that automates the connection - * to ConnectableObservable. - * @see {@link ConnectableObservable} - * @see {@link share} - * @see {@link publish} - * @deprecated Replaced with the {@link share} operator. How `share` is used - * will depend on the connectable observable you created just prior to the - * `refCount` operator. - * Details: https://rxjs.dev/deprecations/multicasting - */ -export function refCount<T>(): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let connection: Subscription | null = null; - - (source as any)._refCount++; - - const refCounter = createOperatorSubscriber(subscriber, undefined, undefined, undefined, () => { - if (!source || (source as any)._refCount <= 0 || 0 < --(source as any)._refCount) { - connection = null; - return; - } - - /// - // Compare the local RefCountSubscriber's connection Subscription to the - // connection Subscription on the shared ConnectableObservable. In cases - // where the ConnectableObservable source synchronously emits values, and - // the RefCountSubscriber's downstream Observers synchronously unsubscribe, - // execution continues to here before the RefCountOperator has a chance to - // supply the RefCountSubscriber with the shared connection Subscription. - // For example: - // ``` - // range(0, 10).pipe( - // publish(), - // refCount(), - // take(5), - // ) - // .subscribe(); - // ``` - // In order to account for this case, RefCountSubscriber should only dispose - // the ConnectableObservable's shared connection Subscription if the - // connection Subscription exists, *and* either: - // a. RefCountSubscriber doesn't have a reference to the shared connection - // Subscription yet, or, - // b. RefCountSubscriber's connection Subscription reference is identical - // to the shared connection Subscription - /// - - const sharedConnection = (source as any)._connection; - const conn = connection; - connection = null; - - if (sharedConnection && (!conn || sharedConnection === conn)) { - sharedConnection.unsubscribe(); - } - - subscriber.unsubscribe(); - }); - - source.subscribe(refCounter); - - if (!refCounter.closed) { - connection = (source as ConnectableObservable<T>).connect(); - } - }); -} diff --git a/node_modules/rxjs/src/internal/operators/repeat.ts b/node_modules/rxjs/src/internal/operators/repeat.ts deleted file mode 100644 index 21a8cce..0000000 --- a/node_modules/rxjs/src/internal/operators/repeat.ts +++ /dev/null @@ -1,172 +0,0 @@ -import { Subscription } from '../Subscription'; -import { EMPTY } from '../observable/empty'; -import { operate } from '../util/lift'; -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; -import { timer } from '../observable/timer'; - -export interface RepeatConfig { - /** - * The number of times to repeat the source. Defaults to `Infinity`. - */ - count?: number; - - /** - * If a `number`, will delay the repeat of the source by that number of milliseconds. - * If a function, it will provide the number of times the source has been subscribed to, - * and the return value should be a valid observable input that will notify when the source - * should be repeated. If the notifier observable is empty, the result will complete. - */ - delay?: number | ((count: number) => ObservableInput<any>); -} - -/** - * Returns an Observable that will resubscribe to the source stream when the source stream completes. - * - * <span class="informal">Repeats all values emitted on the source. It's like {@link retry}, but for non error cases.</span> - * - *  - * - * Repeat will output values from a source until the source completes, then it will resubscribe to the - * source a specified number of times, with a specified delay. Repeat can be particularly useful in - * combination with closing operators like {@link take}, {@link takeUntil}, {@link first}, or {@link takeWhile}, - * as it can be used to restart a source again from scratch. - * - * Repeat is very similar to {@link retry}, where {@link retry} will resubscribe to the source in the error case, but - * `repeat` will resubscribe if the source completes. - * - * Note that `repeat` will _not_ catch errors. Use {@link retry} for that. - * - * - `repeat(0)` returns an empty observable - * - `repeat()` will repeat forever - * - `repeat({ delay: 200 })` will repeat forever, with a delay of 200ms between repetitions. - * - `repeat({ count: 2, delay: 400 })` will repeat twice, with a delay of 400ms between repetitions. - * - `repeat({ delay: (count) => timer(count * 1000) })` will repeat forever, but will have a delay that grows by one second for each repetition. - * - * ## Example - * - * Repeat a message stream - * - * ```ts - * import { of, repeat } from 'rxjs'; - * - * const source = of('Repeat message'); - * const result = source.pipe(repeat(3)); - * - * result.subscribe(x => console.log(x)); - * - * // Results - * // 'Repeat message' - * // 'Repeat message' - * // 'Repeat message' - * ``` - * - * Repeat 3 values, 2 times - * - * ```ts - * import { interval, take, repeat } from 'rxjs'; - * - * const source = interval(1000); - * const result = source.pipe(take(3), repeat(2)); - * - * result.subscribe(x => console.log(x)); - * - * // Results every second - * // 0 - * // 1 - * // 2 - * // 0 - * // 1 - * // 2 - * ``` - * - * Defining two complex repeats with delays on the same source. - * Note that the second repeat cannot be called until the first - * repeat as exhausted it's count. - * - * ```ts - * import { defer, of, repeat } from 'rxjs'; - * - * const source = defer(() => { - * return of(`Hello, it is ${new Date()}`) - * }); - * - * source.pipe( - * // Repeat 3 times with a delay of 1 second between repetitions - * repeat({ - * count: 3, - * delay: 1000, - * }), - * - * // *Then* repeat forever, but with an exponential step-back - * // maxing out at 1 minute. - * repeat({ - * delay: (count) => timer(Math.min(60000, 2 ^ count * 1000)) - * }) - * ) - * ``` - * - * @see {@link repeatWhen} - * @see {@link retry} - * - * @param countOrConfig Either the number of times the source Observable items are repeated - * (a count of 0 will yield an empty Observable) or a {@link RepeatConfig} object. - */ -export function repeat<T>(countOrConfig?: number | RepeatConfig): MonoTypeOperatorFunction<T> { - let count = Infinity; - let delay: RepeatConfig['delay']; - - if (countOrConfig != null) { - if (typeof countOrConfig === 'object') { - ({ count = Infinity, delay } = countOrConfig); - } else { - count = countOrConfig; - } - } - - return count <= 0 - ? () => EMPTY - : operate((source, subscriber) => { - let soFar = 0; - let sourceSub: Subscription | null; - - const resubscribe = () => { - sourceSub?.unsubscribe(); - sourceSub = null; - if (delay != null) { - const notifier = typeof delay === 'number' ? timer(delay) : innerFrom(delay(soFar)); - const notifierSubscriber = createOperatorSubscriber(subscriber, () => { - notifierSubscriber.unsubscribe(); - subscribeToSource(); - }); - notifier.subscribe(notifierSubscriber); - } else { - subscribeToSource(); - } - }; - - const subscribeToSource = () => { - let syncUnsub = false; - sourceSub = source.subscribe( - createOperatorSubscriber(subscriber, undefined, () => { - if (++soFar < count) { - if (sourceSub) { - resubscribe(); - } else { - syncUnsub = true; - } - } else { - subscriber.complete(); - } - }) - ); - - if (syncUnsub) { - resubscribe(); - } - }; - - subscribeToSource(); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/repeatWhen.ts b/node_modules/rxjs/src/internal/operators/repeatWhen.ts deleted file mode 100644 index 403b2c6..0000000 --- a/node_modules/rxjs/src/internal/operators/repeatWhen.ts +++ /dev/null @@ -1,125 +0,0 @@ -import { Observable } from '../Observable'; -import { innerFrom } from '../observable/innerFrom'; -import { Subject } from '../Subject'; -import { Subscription } from '../Subscription'; - -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Returns an Observable that mirrors the source Observable with the exception of a `complete`. If the source - * Observable calls `complete`, this method will emit to the Observable returned from `notifier`. If that Observable - * calls `complete` or `error`, then this method will call `complete` or `error` on the child subscription. Otherwise - * this method will resubscribe to the source Observable. - * - *  - * - * ## Example - * - * Repeat a message stream on click - * - * ```ts - * import { of, fromEvent, repeatWhen } from 'rxjs'; - * - * const source = of('Repeat message'); - * const documentClick$ = fromEvent(document, 'click'); - * - * const result = source.pipe(repeatWhen(() => documentClick$)); - * - * result.subscribe(data => console.log(data)) - * ``` - * - * @see {@link repeat} - * @see {@link retry} - * @see {@link retryWhen} - * - * @param notifier Function that receives an Observable of notifications with - * which a user can `complete` or `error`, aborting the repetition. - * @return A function that returns an Observable that mirrors the source - * Observable with the exception of a `complete`. - * @deprecated Will be removed in v9 or v10. Use {@link repeat}'s {@link RepeatConfig#delay delay} option instead. - * Instead of `repeatWhen(() => notify$)`, use: `repeat({ delay: () => notify$ })`. - */ -export function repeatWhen<T>(notifier: (notifications: Observable<void>) => ObservableInput<any>): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let innerSub: Subscription | null; - let syncResub = false; - let completions$: Subject<void>; - let isNotifierComplete = false; - let isMainComplete = false; - - /** - * Checks to see if we can complete the result, completes it, and returns `true` if it was completed. - */ - const checkComplete = () => isMainComplete && isNotifierComplete && (subscriber.complete(), true); - /** - * Gets the subject to send errors through. If it doesn't exist, - * we know we need to setup the notifier. - */ - const getCompletionSubject = () => { - if (!completions$) { - completions$ = new Subject(); - - // If the call to `notifier` throws, it will be caught by the OperatorSubscriber - // In the main subscription -- in `subscribeForRepeatWhen`. - innerFrom(notifier(completions$)).subscribe( - createOperatorSubscriber( - subscriber, - () => { - if (innerSub) { - subscribeForRepeatWhen(); - } else { - // If we don't have an innerSub yet, that's because the inner subscription - // call hasn't even returned yet. We've arrived here synchronously. - // So we flag that we want to resub, such that we can ensure finalization - // happens before we resubscribe. - syncResub = true; - } - }, - () => { - isNotifierComplete = true; - checkComplete(); - } - ) - ); - } - return completions$; - }; - - const subscribeForRepeatWhen = () => { - isMainComplete = false; - - innerSub = source.subscribe( - createOperatorSubscriber(subscriber, undefined, () => { - isMainComplete = true; - // Check to see if we are complete, and complete if so. - // If we are not complete. Get the subject. This calls the `notifier` function. - // If that function fails, it will throw and `.next()` will not be reached on this - // line. The thrown error is caught by the _complete handler in this - // `OperatorSubscriber` and handled appropriately. - !checkComplete() && getCompletionSubject().next(); - }) - ); - - if (syncResub) { - // Ensure that the inner subscription is torn down before - // moving on to the next subscription in the synchronous case. - // If we don't do this here, all inner subscriptions will not be - // torn down until the entire observable is done. - innerSub.unsubscribe(); - // It is important to null this out. Not only to free up memory, but - // to make sure code above knows we are in a subscribing state to - // handle synchronous resubscription. - innerSub = null; - // We may need to do this multiple times, so reset the flags. - syncResub = false; - // Resubscribe - subscribeForRepeatWhen(); - } - }; - - // Start the subscription - subscribeForRepeatWhen(); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/retry.ts b/node_modules/rxjs/src/internal/operators/retry.ts deleted file mode 100644 index dbb5164..0000000 --- a/node_modules/rxjs/src/internal/operators/retry.ts +++ /dev/null @@ -1,168 +0,0 @@ -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { Subscription } from '../Subscription'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { identity } from '../util/identity'; -import { timer } from '../observable/timer'; -import { innerFrom } from '../observable/innerFrom'; - -/** - * The {@link retry} operator configuration object. `retry` either accepts a `number` - * or an object described by this interface. - */ -export interface RetryConfig { - /** - * The maximum number of times to retry. If `count` is omitted, `retry` will try to - * resubscribe on errors infinite number of times. - */ - count?: number; - /** - * The number of milliseconds to delay before retrying, OR a function to - * return a notifier for delaying. If a function is given, that function should - * return a notifier that, when it emits will retry the source. If the notifier - * completes _without_ emitting, the resulting observable will complete without error, - * if the notifier errors, the error will be pushed to the result. - */ - delay?: number | ((error: any, retryCount: number) => ObservableInput<any>); - /** - * Whether or not to reset the retry counter when the retried subscription - * emits its first value. - */ - resetOnSuccess?: boolean; -} - -export function retry<T>(count?: number): MonoTypeOperatorFunction<T>; -export function retry<T>(config: RetryConfig): MonoTypeOperatorFunction<T>; - -/** - * Returns an Observable that mirrors the source Observable with the exception of an `error`. - * - * If the source Observable calls `error`, this method will resubscribe to the source Observable for a maximum of - * `count` resubscriptions rather than propagating the `error` call. - * - *  - * - * The number of retries is determined by the `count` parameter. It can be set either by passing a number to - * `retry` function or by setting `count` property when `retry` is configured using {@link RetryConfig}. If - * `count` is omitted, `retry` will try to resubscribe on errors infinite number of times. - * - * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those - * emitted during failed subscriptions. For example, if an Observable fails at first but emits `[1, 2]` then - * succeeds the second time and emits: `[1, 2, 3, 4, 5, complete]` then the complete stream of emissions and - * notifications would be: `[1, 2, 1, 2, 3, 4, 5, complete]`. - * - * ## Example - * - * ```ts - * import { interval, mergeMap, throwError, of, retry } from 'rxjs'; - * - * const source = interval(1000); - * const result = source.pipe( - * mergeMap(val => val > 5 ? throwError(() => 'Error!') : of(val)), - * retry(2) // retry 2 times on error - * ); - * - * result.subscribe({ - * next: value => console.log(value), - * error: err => console.log(`${ err }: Retried 2 times then quit!`) - * }); - * - * // Output: - * // 0..1..2..3..4..5.. - * // 0..1..2..3..4..5.. - * // 0..1..2..3..4..5.. - * // 'Error!: Retried 2 times then quit!' - * ``` - * - * @see {@link retryWhen} - * - * @param configOrCount Either number of retry attempts before failing or a - * {@link RetryConfig} object. - * @return A function that returns an Observable that will resubscribe to the - * source stream when the source stream errors, at most `count` times. - */ -export function retry<T>(configOrCount: number | RetryConfig = Infinity): MonoTypeOperatorFunction<T> { - let config: RetryConfig; - if (configOrCount && typeof configOrCount === 'object') { - config = configOrCount; - } else { - config = { - count: configOrCount as number, - }; - } - const { count = Infinity, delay, resetOnSuccess: resetOnSuccess = false } = config; - - return count <= 0 - ? identity - : operate((source, subscriber) => { - let soFar = 0; - let innerSub: Subscription | null; - const subscribeForRetry = () => { - let syncUnsub = false; - innerSub = source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - // If we're resetting on success - if (resetOnSuccess) { - soFar = 0; - } - subscriber.next(value); - }, - // Completions are passed through to consumer. - undefined, - (err) => { - if (soFar++ < count) { - // We are still under our retry count - const resub = () => { - if (innerSub) { - innerSub.unsubscribe(); - innerSub = null; - subscribeForRetry(); - } else { - syncUnsub = true; - } - }; - - if (delay != null) { - // The user specified a retry delay. - // They gave us a number, use a timer, otherwise, it's a function, - // and we're going to call it to get a notifier. - const notifier = typeof delay === 'number' ? timer(delay) : innerFrom(delay(err, soFar)); - const notifierSubscriber = createOperatorSubscriber( - subscriber, - () => { - // After we get the first notification, we - // unsubscribe from the notifier, because we don't want anymore - // and we resubscribe to the source. - notifierSubscriber.unsubscribe(); - resub(); - }, - () => { - // The notifier completed without emitting. - // The author is telling us they want to complete. - subscriber.complete(); - } - ); - notifier.subscribe(notifierSubscriber); - } else { - // There was no notifier given. Just resub immediately. - resub(); - } - } else { - // We're past our maximum number of retries. - // Just send along the error. - subscriber.error(err); - } - } - ) - ); - if (syncUnsub) { - innerSub.unsubscribe(); - innerSub = null; - subscribeForRetry(); - } - }; - subscribeForRetry(); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/retryWhen.ts b/node_modules/rxjs/src/internal/operators/retryWhen.ts deleted file mode 100644 index 0b83ad6..0000000 --- a/node_modules/rxjs/src/internal/operators/retryWhen.ts +++ /dev/null @@ -1,113 +0,0 @@ -import { Observable } from '../Observable'; -import { innerFrom } from '../observable/innerFrom'; -import { Subject } from '../Subject'; -import { Subscription } from '../Subscription'; - -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Returns an Observable that mirrors the source Observable with the exception of an `error`. If the source Observable - * calls `error`, this method will emit the Throwable that caused the error to the `ObservableInput` returned from `notifier`. - * If that Observable calls `complete` or `error` then this method will call `complete` or `error` on the child - * subscription. Otherwise this method will resubscribe to the source Observable. - * - *  - * - * Retry an observable sequence on error based on custom criteria. - * - * ## Example - * - * ```ts - * import { interval, map, retryWhen, tap, delayWhen, timer } from 'rxjs'; - * - * const source = interval(1000); - * const result = source.pipe( - * map(value => { - * if (value > 5) { - * // error will be picked up by retryWhen - * throw value; - * } - * return value; - * }), - * retryWhen(errors => - * errors.pipe( - * // log error message - * tap(value => console.log(`Value ${ value } was too high!`)), - * // restart in 5 seconds - * delayWhen(value => timer(value * 1000)) - * ) - * ) - * ); - * - * result.subscribe(value => console.log(value)); - * - * // results: - * // 0 - * // 1 - * // 2 - * // 3 - * // 4 - * // 5 - * // 'Value 6 was too high!' - * // - Wait 5 seconds then repeat - * ``` - * - * @see {@link retry} - * - * @param notifier Function that receives an Observable of notifications with which a - * user can `complete` or `error`, aborting the retry. - * @return A function that returns an Observable that mirrors the source - * Observable with the exception of an `error`. - * @deprecated Will be removed in v9 or v10, use {@link retry}'s `delay` option instead. - * Will be removed in v9 or v10. Use {@link retry}'s {@link RetryConfig#delay delay} option instead. - * Instead of `retryWhen(() => notify$)`, use: `retry({ delay: () => notify$ })`. - */ -export function retryWhen<T>(notifier: (errors: Observable<any>) => ObservableInput<any>): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let innerSub: Subscription | null; - let syncResub = false; - let errors$: Subject<any>; - - const subscribeForRetryWhen = () => { - innerSub = source.subscribe( - createOperatorSubscriber(subscriber, undefined, undefined, (err) => { - if (!errors$) { - errors$ = new Subject(); - innerFrom(notifier(errors$)).subscribe( - createOperatorSubscriber(subscriber, () => - // If we have an innerSub, this was an asynchronous call, kick off the retry. - // Otherwise, if we don't have an innerSub yet, that's because the inner subscription - // call hasn't even returned yet. We've arrived here synchronously. - // So we flag that we want to resub, such that we can ensure finalization - // happens before we resubscribe. - innerSub ? subscribeForRetryWhen() : (syncResub = true) - ) - ); - } - if (errors$) { - // We have set up the notifier without error. - errors$.next(err); - } - }) - ); - - if (syncResub) { - // Ensure that the inner subscription is torn down before - // moving on to the next subscription in the synchronous case. - // If we don't do this here, all inner subscriptions will not be - // torn down until the entire observable is done. - innerSub.unsubscribe(); - innerSub = null; - // We may need to do this multiple times, so reset the flag. - syncResub = false; - // Resubscribe - subscribeForRetryWhen(); - } - }; - - // Start the subscription - subscribeForRetryWhen(); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/sample.ts b/node_modules/rxjs/src/internal/operators/sample.ts deleted file mode 100644 index 9008af2..0000000 --- a/node_modules/rxjs/src/internal/operators/sample.ts +++ /dev/null @@ -1,72 +0,0 @@ -import { innerFrom } from '../observable/innerFrom'; -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { noop } from '../util/noop'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Emits the most recently emitted value from the source Observable whenever - * another Observable, the `notifier`, emits. - * - * <span class="informal">It's like {@link sampleTime}, but samples whenever - * the `notifier` `ObservableInput` emits something.</span> - * - *  - * - * Whenever the `notifier` `ObservableInput` emits a value, `sample` - * looks at the source Observable and emits whichever value it has most recently - * emitted since the previous sampling, unless the source has not emitted - * anything since the previous sampling. The `notifier` is subscribed to as soon - * as the output Observable is subscribed. - * - * ## Example - * - * On every click, sample the most recent `seconds` timer - * - * ```ts - * import { fromEvent, interval, sample } from 'rxjs'; - * - * const seconds = interval(1000); - * const clicks = fromEvent(document, 'click'); - * const result = seconds.pipe(sample(clicks)); - * - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link audit} - * @see {@link debounce} - * @see {@link sampleTime} - * @see {@link throttle} - * - * @param notifier The `ObservableInput` to use for sampling the - * source Observable. - * @return A function that returns an Observable that emits the results of - * sampling the values emitted by the source Observable whenever the notifier - * Observable emits value or completes. - */ -export function sample<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let hasValue = false; - let lastValue: T | null = null; - source.subscribe( - createOperatorSubscriber(subscriber, (value) => { - hasValue = true; - lastValue = value; - }) - ); - innerFrom(notifier).subscribe( - createOperatorSubscriber( - subscriber, - () => { - if (hasValue) { - hasValue = false; - const value = lastValue!; - lastValue = null; - subscriber.next(value); - } - }, - noop - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/sampleTime.ts b/node_modules/rxjs/src/internal/operators/sampleTime.ts deleted file mode 100644 index e4af047..0000000 --- a/node_modules/rxjs/src/internal/operators/sampleTime.ts +++ /dev/null @@ -1,51 +0,0 @@ -import { asyncScheduler } from '../scheduler/async'; -import { MonoTypeOperatorFunction, SchedulerLike } from '../types'; -import { sample } from './sample'; -import { interval } from '../observable/interval'; - -/** - * Emits the most recently emitted value from the source Observable within - * periodic time intervals. - * - * <span class="informal">Samples the source Observable at periodic time - * intervals, emitting what it samples.</span> - * - *  - * - * `sampleTime` periodically looks at the source Observable and emits whichever - * value it has most recently emitted since the previous sampling, unless the - * source has not emitted anything since the previous sampling. The sampling - * happens periodically in time every `period` milliseconds (or the time unit - * defined by the optional `scheduler` argument). The sampling starts as soon as - * the output Observable is subscribed. - * - * ## Example - * - * Every second, emit the most recent click at most once - * - * ```ts - * import { fromEvent, sampleTime } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(sampleTime(1000)); - * - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link auditTime} - * @see {@link debounceTime} - * @see {@link delay} - * @see {@link sample} - * @see {@link throttleTime} - * - * @param period The sampling period expressed in milliseconds or the time unit - * determined internally by the optional `scheduler`. - * @param scheduler The {@link SchedulerLike} to use for managing the timers - * that handle the sampling. - * @return A function that returns an Observable that emits the results of - * sampling the values emitted by the source Observable at the specified time - * interval. - */ -export function sampleTime<T>(period: number, scheduler: SchedulerLike = asyncScheduler): MonoTypeOperatorFunction<T> { - return sample(interval(period, scheduler)); -} diff --git a/node_modules/rxjs/src/internal/operators/scan.ts b/node_modules/rxjs/src/internal/operators/scan.ts deleted file mode 100644 index ce30695..0000000 --- a/node_modules/rxjs/src/internal/operators/scan.ts +++ /dev/null @@ -1,95 +0,0 @@ -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { scanInternals } from './scanInternals'; - -export function scan<V, A = V>(accumulator: (acc: A | V, value: V, index: number) => A): OperatorFunction<V, V | A>; -export function scan<V, A>(accumulator: (acc: A, value: V, index: number) => A, seed: A): OperatorFunction<V, A>; -export function scan<V, A, S>(accumulator: (acc: A | S, value: V, index: number) => A, seed: S): OperatorFunction<V, A>; - -// TODO: link to a "redux pattern" section in the guide (location TBD) - -/** - * Useful for encapsulating and managing state. Applies an accumulator (or "reducer function") - * to each value from the source after an initial state is established -- either via - * a `seed` value (second argument), or from the first value from the source. - * - * <span class="informal">It's like {@link reduce}, but emits the current - * accumulation state after each update</span> - * - *  - * - * This operator maintains an internal state and emits it after processing each value as follows: - * - * 1. First value arrives - * - If a `seed` value was supplied (as the second argument to `scan`), let `state = seed` and `value = firstValue`. - * - If NO `seed` value was supplied (no second argument), let `state = firstValue` and go to 3. - * 2. Let `state = accumulator(state, value)`. - * - If an error is thrown by `accumulator`, notify the consumer of an error. The process ends. - * 3. Emit `state`. - * 4. Next value arrives, let `value = nextValue`, go to 2. - * - * ## Examples - * - * An average of previous numbers. This example shows how - * not providing a `seed` can prime the stream with the - * first value from the source. - * - * ```ts - * import { of, scan, map } from 'rxjs'; - * - * const numbers$ = of(1, 2, 3); - * - * numbers$ - * .pipe( - * // Get the sum of the numbers coming in. - * scan((total, n) => total + n), - * // Get the average by dividing the sum by the total number - * // received so far (which is 1 more than the zero-based index). - * map((sum, index) => sum / (index + 1)) - * ) - * .subscribe(console.log); - * ``` - * - * The Fibonacci sequence. This example shows how you can use - * a seed to prime accumulation process. Also... you know... Fibonacci. - * So important to like, computers and stuff that its whiteboarded - * in job interviews. Now you can show them the Rx version! (Please don't, haha) - * - * ```ts - * import { interval, scan, map, startWith } from 'rxjs'; - * - * const firstTwoFibs = [0, 1]; - * // An endless stream of Fibonacci numbers. - * const fibonacci$ = interval(1000).pipe( - * // Scan to get the fibonacci numbers (after 0, 1) - * scan(([a, b]) => [b, a + b], firstTwoFibs), - * // Get the second number in the tuple, it's the one you calculated - * map(([, n]) => n), - * // Start with our first two digits :) - * startWith(...firstTwoFibs) - * ); - * - * fibonacci$.subscribe(console.log); - * ``` - * - * @see {@link expand} - * @see {@link mergeScan} - * @see {@link reduce} - * @see {@link switchScan} - * - * @param accumulator A "reducer function". This will be called for each value after an initial state is - * acquired. - * @param seed The initial state. If this is not provided, the first value from the source will - * be used as the initial state, and emitted without going through the accumulator. All subsequent values - * will be processed by the accumulator function. If this is provided, all values will go through - * the accumulator function. - * @return A function that returns an Observable of the accumulated values. - */ -export function scan<V, A, S>(accumulator: (acc: V | A | S, value: V, index: number) => A, seed?: S): OperatorFunction<V, V | A> { - // providing a seed of `undefined` *should* be valid and trigger - // hasSeed! so don't use `seed !== undefined` checks! - // For this reason, we have to check it here at the original call site - // otherwise inside Operator/Subscriber we won't know if `undefined` - // means they didn't provide anything or if they literally provided `undefined` - return operate(scanInternals(accumulator, seed as S, arguments.length >= 2, true)); -} diff --git a/node_modules/rxjs/src/internal/operators/scanInternals.ts b/node_modules/rxjs/src/internal/operators/scanInternals.ts deleted file mode 100644 index f2c2e5a..0000000 --- a/node_modules/rxjs/src/internal/operators/scanInternals.ts +++ /dev/null @@ -1,62 +0,0 @@ -import { Observable } from '../Observable'; -import { Subscriber } from '../Subscriber'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * A basic scan operation. This is used for `scan` and `reduce`. - * @param accumulator The accumulator to use - * @param seed The seed value for the state to accumulate - * @param hasSeed Whether or not a seed was provided - * @param emitOnNext Whether or not to emit the state on next - * @param emitBeforeComplete Whether or not to emit the before completion - */ - -export function scanInternals<V, A, S>( - accumulator: (acc: V | A | S, value: V, index: number) => A, - seed: S, - hasSeed: boolean, - emitOnNext: boolean, - emitBeforeComplete?: undefined | true -) { - return (source: Observable<V>, subscriber: Subscriber<any>) => { - // Whether or not we have state yet. This will only be - // false before the first value arrives if we didn't get - // a seed value. - let hasState = hasSeed; - // The state that we're tracking, starting with the seed, - // if there is one, and then updated by the return value - // from the accumulator on each emission. - let state: any = seed; - // An index to pass to the accumulator function. - let index = 0; - - // Subscribe to our source. All errors and completions are passed through. - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - // Always increment the index. - const i = index++; - // Set the state - state = hasState - ? // We already have state, so we can get the new state from the accumulator - accumulator(state, value, i) - : // We didn't have state yet, a seed value was not provided, so - - // we set the state to the first value, and mark that we have state now - ((hasState = true), value); - - // Maybe send it to the consumer. - emitOnNext && subscriber.next(state); - }, - // If an onComplete was given, call it, otherwise - // just pass through the complete notification to the consumer. - emitBeforeComplete && - (() => { - hasState && subscriber.next(state); - subscriber.complete(); - }) - ) - ); - }; -} diff --git a/node_modules/rxjs/src/internal/operators/sequenceEqual.ts b/node_modules/rxjs/src/internal/operators/sequenceEqual.ts deleted file mode 100644 index a6f9bec..0000000 --- a/node_modules/rxjs/src/internal/operators/sequenceEqual.ts +++ /dev/null @@ -1,146 +0,0 @@ -import { OperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; - -/** - * Compares all values of two observables in sequence using an optional comparator function - * and returns an observable of a single boolean value representing whether or not the two sequences - * are equal. - * - * <span class="informal">Checks to see of all values emitted by both observables are equal, in order.</span> - * - *  - * - * `sequenceEqual` subscribes to source observable and `compareTo` `ObservableInput` (that internally - * gets converted to an observable) and buffers incoming values from each observable. Whenever either - * observable emits a value, the value is buffered and the buffers are shifted and compared from the bottom - * up; If any value pair doesn't match, the returned observable will emit `false` and complete. If one of the - * observables completes, the operator will wait for the other observable to complete; If the other - * observable emits before completing, the returned observable will emit `false` and complete. If one observable never - * completes or emits after the other completes, the returned observable will never complete. - * - * ## Example - * - * Figure out if the Konami code matches - * - * ```ts - * import { from, fromEvent, map, bufferCount, mergeMap, sequenceEqual } from 'rxjs'; - * - * const codes = from([ - * 'ArrowUp', - * 'ArrowUp', - * 'ArrowDown', - * 'ArrowDown', - * 'ArrowLeft', - * 'ArrowRight', - * 'ArrowLeft', - * 'ArrowRight', - * 'KeyB', - * 'KeyA', - * 'Enter', // no start key, clearly. - * ]); - * - * const keys = fromEvent<KeyboardEvent>(document, 'keyup').pipe(map(e => e.code)); - * const matches = keys.pipe( - * bufferCount(11, 1), - * mergeMap(last11 => from(last11).pipe(sequenceEqual(codes))) - * ); - * matches.subscribe(matched => console.log('Successful cheat at Contra? ', matched)); - * ``` - * - * @see {@link combineLatest} - * @see {@link zip} - * @see {@link withLatestFrom} - * - * @param compareTo The `ObservableInput` sequence to compare the source sequence to. - * @param comparator An optional function to compare each value pair. - * - * @return A function that returns an Observable that emits a single boolean - * value representing whether or not the values emitted by the source - * Observable and provided `ObservableInput` were equal in sequence. - */ -export function sequenceEqual<T>( - compareTo: ObservableInput<T>, - comparator: (a: T, b: T) => boolean = (a, b) => a === b -): OperatorFunction<T, boolean> { - return operate((source, subscriber) => { - // The state for the source observable - const aState = createState<T>(); - // The state for the compareTo observable; - const bState = createState<T>(); - - /** A utility to emit and complete */ - const emit = (isEqual: boolean) => { - subscriber.next(isEqual); - subscriber.complete(); - }; - - /** - * Creates a subscriber that subscribes to one of the sources, and compares its collected - * state -- `selfState` -- to the other source's collected state -- `otherState`. This - * is used for both streams. - */ - const createSubscriber = (selfState: SequenceState<T>, otherState: SequenceState<T>) => { - const sequenceEqualSubscriber = createOperatorSubscriber( - subscriber, - (a: T) => { - const { buffer, complete } = otherState; - if (buffer.length === 0) { - // If there's no values in the other buffer - // and the other stream is complete, we know - // this isn't a match, because we got one more value. - // Otherwise, we push onto our buffer, so when the other - // stream emits, it can pull this value off our buffer and check it - // at the appropriate time. - complete ? emit(false) : selfState.buffer.push(a); - } else { - // If the other stream *does* have values in its buffer, - // pull the oldest one off so we can compare it to what we - // just got. If it wasn't a match, emit `false` and complete. - !comparator(a, buffer.shift()!) && emit(false); - } - }, - () => { - // Or observable completed - selfState.complete = true; - const { complete, buffer } = otherState; - // If the other observable is also complete, and there's - // still stuff left in their buffer, it doesn't match, if their - // buffer is empty, then it does match. This is because we can't - // possibly get more values here anymore. - complete && emit(buffer.length === 0); - // Be sure to clean up our stream as soon as possible if we can. - sequenceEqualSubscriber?.unsubscribe(); - } - ); - - return sequenceEqualSubscriber; - }; - - // Subscribe to each source. - source.subscribe(createSubscriber(aState, bState)); - innerFrom(compareTo).subscribe(createSubscriber(bState, aState)); - }); -} - -/** - * A simple structure for the data used to test each sequence - */ -interface SequenceState<T> { - /** A temporary store for arrived values before they are checked */ - buffer: T[]; - /** Whether or not the sequence source has completed. */ - complete: boolean; -} - -/** - * Creates a simple structure that is used to represent - * data used to test each sequence. - */ -function createState<T>(): SequenceState<T> { - return { - buffer: [], - complete: false, - }; -} diff --git a/node_modules/rxjs/src/internal/operators/share.ts b/node_modules/rxjs/src/internal/operators/share.ts deleted file mode 100644 index bc0c270..0000000 --- a/node_modules/rxjs/src/internal/operators/share.ts +++ /dev/null @@ -1,267 +0,0 @@ -import { innerFrom } from '../observable/innerFrom'; -import { Subject } from '../Subject'; -import { SafeSubscriber } from '../Subscriber'; -import { Subscription } from '../Subscription'; -import { MonoTypeOperatorFunction, SubjectLike, ObservableInput } from '../types'; -import { operate } from '../util/lift'; - -export interface ShareConfig<T> { - /** - * The factory used to create the subject that will connect the source observable to - * multicast consumers. - */ - connector?: () => SubjectLike<T>; - /** - * If `true`, the resulting observable will reset internal state on error from source and return to a "cold" state. This - * allows the resulting observable to be "retried" in the event of an error. - * If `false`, when an error comes from the source it will push the error into the connecting subject, and the subject - * will remain the connecting subject, meaning the resulting observable will not go "cold" again, and subsequent retries - * or resubscriptions will resubscribe to that same subject. In all cases, RxJS subjects will emit the same error again, however - * {@link ReplaySubject} will also push its buffered values before pushing the error. - * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained - * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets. - */ - resetOnError?: boolean | ((error: any) => ObservableInput<any>); - /** - * If `true`, the resulting observable will reset internal state on completion from source and return to a "cold" state. This - * allows the resulting observable to be "repeated" after it is done. - * If `false`, when the source completes, it will push the completion through the connecting subject, and the 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. - * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained - * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets. - */ - resetOnComplete?: boolean | (() => ObservableInput<any>); - /** - * If `true`, when the number of subscribers to the resulting observable reaches zero due to those subscribers unsubscribing, the - * internal state will be reset and the resulting observable will return to a "cold" state. This means that the next - * time the resulting observable is subscribed to, a new subject will be created and the source will be subscribed to - * again. - * If `false`, when the number of subscribers to the resulting observable reaches zero due to unsubscription, the subject - * will remain connected to the source, and new subscriptions to the result will be connected through that same subject. - * It is also possible to pass a notifier factory returning an `ObservableInput` instead which grants more fine-grained - * control over how and when the reset should happen. This allows behaviors like conditional or delayed resets. - */ - resetOnRefCountZero?: boolean | (() => ObservableInput<any>); -} - -export function share<T>(): MonoTypeOperatorFunction<T>; - -export function share<T>(options: ShareConfig<T>): MonoTypeOperatorFunction<T>; - -/** - * Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one - * Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will - * unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream `hot`. - * This is an alias for `multicast(() => new Subject()), refCount()`. - * - * The subscription to the underlying source Observable can be reset (unsubscribe and resubscribe for new subscribers), - * if the subscriber count to the shared observable drops to 0, or if the source Observable errors or completes. It is - * possible to use notifier factories for the resets to allow for behaviors like conditional or delayed resets. Please - * note that resetting on error or complete of the source Observable does not behave like a transparent retry or restart - * of the source because the error or complete will be forwarded to all subscribers and their subscription will be - * closed. Only new subscribers after a reset on error or complete happened will cause a fresh subscription to the - * source. To achieve transparent retries or restarts pipe the source through appropriate operators before sharing. - * - *  - * - * ## Example - * - * Generate new multicast Observable from the `source` Observable value - * - * ```ts - * import { interval, tap, map, take, share } from 'rxjs'; - * - * const source = interval(1000).pipe( - * tap(x => console.log('Processing: ', x)), - * map(x => x * x), - * take(6), - * share() - * ); - * - * source.subscribe(x => console.log('subscription 1: ', x)); - * source.subscribe(x => console.log('subscription 2: ', x)); - * - * // Logs: - * // Processing: 0 - * // subscription 1: 0 - * // subscription 2: 0 - * // Processing: 1 - * // subscription 1: 1 - * // subscription 2: 1 - * // Processing: 2 - * // subscription 1: 4 - * // subscription 2: 4 - * // Processing: 3 - * // subscription 1: 9 - * // subscription 2: 9 - * // Processing: 4 - * // subscription 1: 16 - * // subscription 2: 16 - * // Processing: 5 - * // subscription 1: 25 - * // subscription 2: 25 - * ``` - * - * ## Example with notifier factory: Delayed reset - * - * ```ts - * import { interval, take, share, timer } from 'rxjs'; - * - * const source = interval(1000).pipe( - * take(3), - * share({ - * resetOnRefCountZero: () => timer(1000) - * }) - * ); - * - * const subscriptionOne = source.subscribe(x => console.log('subscription 1: ', x)); - * setTimeout(() => subscriptionOne.unsubscribe(), 1300); - * - * setTimeout(() => source.subscribe(x => console.log('subscription 2: ', x)), 1700); - * - * setTimeout(() => source.subscribe(x => console.log('subscription 3: ', x)), 5000); - * - * // Logs: - * // subscription 1: 0 - * // (subscription 1 unsubscribes here) - * // (subscription 2 subscribes here ~400ms later, source was not reset) - * // subscription 2: 1 - * // subscription 2: 2 - * // (subscription 2 unsubscribes here) - * // (subscription 3 subscribes here ~2000ms later, source did reset before) - * // subscription 3: 0 - * // subscription 3: 1 - * // subscription 3: 2 - * ``` - * - * @see {@link shareReplay} - * - * @return A function that returns an Observable that mirrors the source. - */ -export function share<T>(options: ShareConfig<T> = {}): MonoTypeOperatorFunction<T> { - const { connector = () => new Subject<T>(), resetOnError = true, resetOnComplete = true, resetOnRefCountZero = true } = options; - // It's necessary to use a wrapper here, as the _operator_ must be - // referentially transparent. Otherwise, it cannot be used in calls to the - // static `pipe` function - to create a partial pipeline. - // - // The _operator function_ - the function returned by the _operator_ - will - // not be referentially transparent - as it shares its source - but the - // _operator function_ is called when the complete pipeline is composed via a - // call to a source observable's `pipe` method - not when the static `pipe` - // function is called. - return (wrapperSource) => { - let connection: SafeSubscriber<T> | undefined; - let resetConnection: Subscription | undefined; - let subject: SubjectLike<T> | undefined; - let refCount = 0; - let hasCompleted = false; - let hasErrored = false; - - const cancelReset = () => { - resetConnection?.unsubscribe(); - resetConnection = undefined; - }; - // Used to reset the internal state to a "cold" - // state, as though it had never been subscribed to. - const reset = () => { - cancelReset(); - connection = subject = undefined; - hasCompleted = hasErrored = false; - }; - const resetAndUnsubscribe = () => { - // We need to capture the connection before - // we reset (if we need to reset). - const conn = connection; - reset(); - conn?.unsubscribe(); - }; - - return operate<T, T>((source, subscriber) => { - refCount++; - if (!hasErrored && !hasCompleted) { - cancelReset(); - } - - // Create the subject if we don't have one yet. Grab a local reference to - // it as well, which avoids non-null assertions when using it and, if we - // connect to it now, then error/complete need a reference after it was - // reset. - const dest = (subject = subject ?? connector()); - - // Add the finalization directly to the subscriber - instead of returning it - - // so that the handling of the subscriber's unsubscription will be wired - // up _before_ the subscription to the source occurs. This is done so that - // the assignment to the source connection's `closed` property will be seen - // by synchronous firehose sources. - subscriber.add(() => { - refCount--; - - // If we're resetting on refCount === 0, and it's 0, we only want to do - // that on "unsubscribe", really. Resetting on error or completion is a different - // configuration. - if (refCount === 0 && !hasErrored && !hasCompleted) { - resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero); - } - }); - - // The following line adds the subscription to the subscriber passed. - // Basically, `subscriber === dest.subscribe(subscriber)` is `true`. - dest.subscribe(subscriber); - - if ( - !connection && - // Check this shareReplay is still activate - it can be reset to 0 - // and be "unsubscribed" _before_ it actually subscribes. - // If we were to subscribe then, it'd leak and get stuck. - refCount > 0 - ) { - // We need to create a subscriber here - rather than pass an observer and - // assign the returned subscription to connection - because it's possible - // for reentrant subscriptions to the shared observable to occur and in - // those situations we want connection to be already-assigned so that we - // don't create another connection to the source. - connection = new SafeSubscriber({ - next: (value) => dest.next(value), - error: (err) => { - hasErrored = true; - cancelReset(); - resetConnection = handleReset(reset, resetOnError, err); - dest.error(err); - }, - complete: () => { - hasCompleted = true; - cancelReset(); - resetConnection = handleReset(reset, resetOnComplete); - dest.complete(); - }, - }); - innerFrom(source).subscribe(connection); - } - })(wrapperSource); - }; -} - -function handleReset<T extends unknown[] = never[]>( - reset: () => void, - on: boolean | ((...args: T) => ObservableInput<any>), - ...args: T -): Subscription | undefined { - if (on === true) { - reset(); - return; - } - - if (on === false) { - return; - } - - const onSubscriber = new SafeSubscriber({ - next: () => { - onSubscriber.unsubscribe(); - reset(); - }, - }); - - return innerFrom(on(...args)).subscribe(onSubscriber); -} diff --git a/node_modules/rxjs/src/internal/operators/shareReplay.ts b/node_modules/rxjs/src/internal/operators/shareReplay.ts deleted file mode 100644 index b43f363..0000000 --- a/node_modules/rxjs/src/internal/operators/shareReplay.ts +++ /dev/null @@ -1,173 +0,0 @@ -import { ReplaySubject } from '../ReplaySubject'; -import { MonoTypeOperatorFunction, SchedulerLike } from '../types'; -import { share } from './share'; - -export interface ShareReplayConfig { - bufferSize?: number; - windowTime?: number; - refCount: boolean; - scheduler?: SchedulerLike; -} - -export function shareReplay<T>(config: ShareReplayConfig): MonoTypeOperatorFunction<T>; -export function shareReplay<T>(bufferSize?: number, windowTime?: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>; - -/** - * Share source and replay specified number of emissions on subscription. - * - * This operator is a specialization of `replay` that connects to a source observable - * and multicasts through a `ReplaySubject` constructed with the specified arguments. - * A successfully completed source will stay cached in the `shareReplay`ed observable forever, - * but an errored source can be retried. - * - * ## Why use `shareReplay`? - * - * You generally want to use `shareReplay` when you have side-effects or taxing computations - * that you do not wish to be executed amongst multiple subscribers. - * It may also be valuable in situations where you know you will have late subscribers to - * a stream that need access to previously emitted values. - * This ability to replay values on subscription is what differentiates {@link share} and `shareReplay`. - * - * ## Reference counting - * - * By default `shareReplay` will use `refCount` of false, meaning that it will _not_ unsubscribe the - * source when the reference counter drops to zero, i.e. the inner `ReplaySubject` will _not_ be unsubscribed - * (and potentially run for ever). - * This is the default as it is expected that `shareReplay` is often used to keep around expensive to setup - * observables which we want to keep running instead of having to do the expensive setup again. - * - * As of RXJS version 6.4.0 a new overload signature was added to allow for manual control over what - * happens when the operators internal reference counter drops to zero. - * If `refCount` is true, the source will be unsubscribed from once the reference count drops to zero, i.e. - * the inner `ReplaySubject` will be unsubscribed. All new subscribers will receive value emissions from a - * new `ReplaySubject` which in turn will cause a new subscription to the source observable. - * - * ## Examples - * - * Example with a third subscriber coming late to the party - * - * ```ts - * import { interval, take, shareReplay } from 'rxjs'; - * - * const shared$ = interval(2000).pipe( - * take(6), - * shareReplay(3) - * ); - * - * shared$.subscribe(x => console.log('sub A: ', x)); - * shared$.subscribe(y => console.log('sub B: ', y)); - * - * setTimeout(() => { - * shared$.subscribe(y => console.log('sub C: ', y)); - * }, 11000); - * - * // Logs: - * // (after ~2000 ms) - * // sub A: 0 - * // sub B: 0 - * // (after ~4000 ms) - * // sub A: 1 - * // sub B: 1 - * // (after ~6000 ms) - * // sub A: 2 - * // sub B: 2 - * // (after ~8000 ms) - * // sub A: 3 - * // sub B: 3 - * // (after ~10000 ms) - * // sub A: 4 - * // sub B: 4 - * // (after ~11000 ms, sub C gets the last 3 values) - * // sub C: 2 - * // sub C: 3 - * // sub C: 4 - * // (after ~12000 ms) - * // sub A: 5 - * // sub B: 5 - * // sub C: 5 - * ``` - * - * Example for `refCount` usage - * - * ```ts - * import { Observable, tap, interval, shareReplay, take } from 'rxjs'; - * - * const log = <T>(name: string, source: Observable<T>) => source.pipe( - * tap({ - * subscribe: () => console.log(`${ name }: subscribed`), - * next: value => console.log(`${ name }: ${ value }`), - * complete: () => console.log(`${ name }: completed`), - * finalize: () => console.log(`${ name }: unsubscribed`) - * }) - * ); - * - * const obs$ = log('source', interval(1000)); - * - * const shared$ = log('shared', obs$.pipe( - * shareReplay({ bufferSize: 1, refCount: true }), - * take(2) - * )); - * - * shared$.subscribe(x => console.log('sub A: ', x)); - * shared$.subscribe(y => console.log('sub B: ', y)); - * - * // PRINTS: - * // shared: subscribed <-- reference count = 1 - * // source: subscribed - * // shared: subscribed <-- reference count = 2 - * // source: 0 - * // shared: 0 - * // sub A: 0 - * // shared: 0 - * // sub B: 0 - * // source: 1 - * // shared: 1 - * // sub A: 1 - * // shared: completed <-- take(2) completes the subscription for sub A - * // shared: unsubscribed <-- reference count = 1 - * // shared: 1 - * // sub B: 1 - * // shared: completed <-- take(2) completes the subscription for sub B - * // shared: unsubscribed <-- reference count = 0 - * // source: unsubscribed <-- replaySubject unsubscribes from source observable because the reference count dropped to 0 and refCount is true - * - * // In case of refCount being false, the unsubscribe is never called on the source and the source would keep on emitting, even if no subscribers - * // are listening. - * // source: 2 - * // source: 3 - * // source: 4 - * // ... - * ``` - * - * @see {@link publish} - * @see {@link share} - * @see {@link publishReplay} - * - * @param configOrBufferSize Maximum element count of the replay buffer or {@link ShareReplayConfig configuration} - * object. - * @param windowTime Maximum time length of the replay buffer in milliseconds. - * @param scheduler Scheduler where connected observers within the selector function - * will be invoked on. - * @return A function that returns an Observable sequence that contains the - * elements of a sequence produced by multicasting the source sequence within a - * selector function. - */ -export function shareReplay<T>( - configOrBufferSize?: ShareReplayConfig | number, - windowTime?: number, - scheduler?: SchedulerLike -): MonoTypeOperatorFunction<T> { - let bufferSize: number; - let refCount = false; - if (configOrBufferSize && typeof configOrBufferSize === 'object') { - ({ bufferSize = Infinity, windowTime = Infinity, refCount = false, scheduler } = configOrBufferSize); - } else { - bufferSize = (configOrBufferSize ?? Infinity) as number; - } - return share<T>({ - connector: () => new ReplaySubject(bufferSize, windowTime, scheduler), - resetOnError: true, - resetOnComplete: false, - resetOnRefCountZero: refCount, - }); -} diff --git a/node_modules/rxjs/src/internal/operators/single.ts b/node_modules/rxjs/src/internal/operators/single.ts deleted file mode 100644 index 59c21c5..0000000 --- a/node_modules/rxjs/src/internal/operators/single.ts +++ /dev/null @@ -1,121 +0,0 @@ -import { Observable } from '../Observable'; -import { EmptyError } from '../util/EmptyError'; - -import { MonoTypeOperatorFunction, OperatorFunction, TruthyTypesOf } from '../types'; -import { SequenceError } from '../util/SequenceError'; -import { NotFoundError } from '../util/NotFoundError'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -export function single<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>; -export function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): MonoTypeOperatorFunction<T>; - -/** - * Returns an observable that asserts that only one value is - * emitted from the observable that matches the predicate. If no - * predicate is provided, then it will assert that the observable - * only emits one value. - * - * If the source Observable did not emit `next` before completion, it - * will emit an {@link EmptyError} to the Observer's `error` callback. - * - * In the event that two values are found that match the predicate, - * or when there are two values emitted and no predicate, it will - * emit a {@link SequenceError} to the Observer's `error` callback. - * - * In the event that no values match the predicate, if one is provided, - * it will emit a {@link NotFoundError} to the Observer's `error` callback. - * - * ## Example - * - * Expect only `name` beginning with `'B'` - * - * ```ts - * import { of, single } from 'rxjs'; - * - * const source1 = of( - * { name: 'Ben' }, - * { name: 'Tracy' }, - * { name: 'Laney' }, - * { name: 'Lily' } - * ); - * - * source1 - * .pipe(single(x => x.name.startsWith('B'))) - * .subscribe(x => console.log(x)); - * // Emits 'Ben' - * - * - * const source2 = of( - * { name: 'Ben' }, - * { name: 'Tracy' }, - * { name: 'Bradley' }, - * { name: 'Lincoln' } - * ); - * - * source2 - * .pipe(single(x => x.name.startsWith('B'))) - * .subscribe({ error: err => console.error(err) }); - * // Error emitted: SequenceError('Too many values match') - * - * - * const source3 = of( - * { name: 'Laney' }, - * { name: 'Tracy' }, - * { name: 'Lily' }, - * { name: 'Lincoln' } - * ); - * - * source3 - * .pipe(single(x => x.name.startsWith('B'))) - * .subscribe({ error: err => console.error(err) }); - * // Error emitted: NotFoundError('No values match') - * ``` - * - * @see {@link first} - * @see {@link find} - * @see {@link findIndex} - * @see {@link elementAt} - * - * @throws {NotFoundError} Delivers a `NotFoundError` to the Observer's `error` - * callback if the Observable completes before any `next` notification was sent. - * @throws {SequenceError} Delivers a `SequenceError` if more than one value is - * emitted that matches the provided predicate. If no predicate is provided, it - * will deliver a `SequenceError` if more than one value comes from the source. - * @throws {EmptyError} Delivers an `EmptyError` if no values were `next`ed prior - * to completion. - * - * @param predicate A predicate function to evaluate items emitted by the source - * Observable. - * @return A function that returns an Observable that emits the single item - * emitted by the source Observable that matches the predicate. - */ -export function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let hasValue = false; - let singleValue: T; - let seenValue = false; - let index = 0; - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - seenValue = true; - if (!predicate || predicate(value, index++, source)) { - hasValue && subscriber.error(new SequenceError('Too many matching values')); - hasValue = true; - singleValue = value; - } - }, - () => { - if (hasValue) { - subscriber.next(singleValue); - subscriber.complete(); - } else { - subscriber.error(seenValue ? new NotFoundError('No matching values') : new EmptyError()); - } - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/skip.ts b/node_modules/rxjs/src/internal/operators/skip.ts deleted file mode 100644 index 424ad65..0000000 --- a/node_modules/rxjs/src/internal/operators/skip.ts +++ /dev/null @@ -1,39 +0,0 @@ -import { MonoTypeOperatorFunction } from '../types'; -import { filter } from './filter'; - -/** - * Returns an Observable that skips the first `count` items emitted by the source Observable. - * - *  - * - * Skips the values until the sent notifications are equal or less than provided skip count. It raises - * an error if skip count is equal or more than the actual number of emits and source raises an error. - * - * ## Example - * - * Skip the values before the emission - * - * ```ts - * import { interval, skip } from 'rxjs'; - * - * // emit every half second - * const source = interval(500); - * // skip the first 10 emitted values - * const result = source.pipe(skip(10)); - * - * result.subscribe(value => console.log(value)); - * // output: 10...11...12...13... - * ``` - * - * @see {@link last} - * @see {@link skipWhile} - * @see {@link skipUntil} - * @see {@link skipLast} - * - * @param count The number of times, items emitted by source Observable should be skipped. - * @return A function that returns an Observable that skips the first `count` - * values emitted by the source Observable. - */ -export function skip<T>(count: number): MonoTypeOperatorFunction<T> { - return filter((_, index) => count <= index); -} diff --git a/node_modules/rxjs/src/internal/operators/skipLast.ts b/node_modules/rxjs/src/internal/operators/skipLast.ts deleted file mode 100644 index e0f75b5..0000000 --- a/node_modules/rxjs/src/internal/operators/skipLast.ts +++ /dev/null @@ -1,95 +0,0 @@ -import { MonoTypeOperatorFunction } from '../types'; -import { identity } from '../util/identity'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Skip a specified number of values before the completion of an observable. - * - *  - * - * Returns an observable that will emit values as soon as it can, given a number of - * skipped values. For example, if you `skipLast(3)` on a source, when the source - * emits its fourth value, the first value the source emitted will finally be emitted - * from the returned observable, as it is no longer part of what needs to be skipped. - * - * All values emitted by the result of `skipLast(N)` will be delayed by `N` emissions, - * as each value is held in a buffer until enough values have been emitted that that - * the buffered value may finally be sent to the consumer. - * - * After subscribing, unsubscribing will not result in the emission of the buffered - * skipped values. - * - * ## Example - * - * Skip the last 2 values of an observable with many values - * - * ```ts - * import { of, skipLast } from 'rxjs'; - * - * const numbers = of(1, 2, 3, 4, 5); - * const skipLastTwo = numbers.pipe(skipLast(2)); - * skipLastTwo.subscribe(x => console.log(x)); - * - * // Results in: - * // 1 2 3 - * // (4 and 5 are skipped) - * ``` - * - * @see {@link skip} - * @see {@link skipUntil} - * @see {@link skipWhile} - * @see {@link take} - * - * @param skipCount Number of elements to skip from the end of the source Observable. - * @return A function that returns an Observable that skips the last `count` - * values emitted by the source Observable. - */ -export function skipLast<T>(skipCount: number): MonoTypeOperatorFunction<T> { - return skipCount <= 0 - ? // For skipCounts less than or equal to zero, we are just mirroring the source. - identity - : operate((source, subscriber) => { - // A ring buffer to hold the values while we wait to see - // if we can emit it or it's part of the "skipped" last values. - // Note that it is the _same size_ as the skip count. - let ring: T[] = new Array(skipCount); - // The number of values seen so far. This is used to get - // the index of the current value when it arrives. - let seen = 0; - source.subscribe( - createOperatorSubscriber(subscriber, (value) => { - // Get the index of the value we have right now - // relative to all other values we've seen, then - // increment `seen`. This ensures we've moved to - // the next slot in our ring buffer. - const valueIndex = seen++; - if (valueIndex < skipCount) { - // If we haven't seen enough values to fill our buffer yet, - // Then we aren't to a number of seen values where we can - // emit anything, so let's just start by filling the ring buffer. - ring[valueIndex] = value; - } else { - // We are traversing over the ring array in such - // a way that when we get to the end, we loop back - // and go to the start. - const index = valueIndex % skipCount; - // Pull the oldest value out so we can emit it, - // and stuff the new value in it's place. - const oldValue = ring[index]; - ring[index] = value; - // Emit the old value. It is important that this happens - // after we swap the value in the buffer, if it happens - // before we swap the value in the buffer, then a synchronous - // source can get the buffer out of whack. - subscriber.next(oldValue); - } - }) - ); - - return () => { - // Release our values in memory - ring = null!; - }; - }); -} diff --git a/node_modules/rxjs/src/internal/operators/skipUntil.ts b/node_modules/rxjs/src/internal/operators/skipUntil.ts deleted file mode 100644 index e6984e5..0000000 --- a/node_modules/rxjs/src/internal/operators/skipUntil.ts +++ /dev/null @@ -1,69 +0,0 @@ -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; -import { noop } from '../util/noop'; - -/** - * Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item. - * - * The `skipUntil` operator causes the observable stream to skip the emission of values until the passed in observable - * emits the first value. This can be particularly useful in combination with user interactions, responses of HTTP - * requests or waiting for specific times to pass by. - * - *  - * - * Internally, the `skipUntil` operator subscribes to the passed in `notifier` `ObservableInput` (which gets converted - * to an Observable) in order to recognize the emission of its first value. When `notifier` emits next, the operator - * unsubscribes from it and starts emitting the values of the *source* observable until it completes or errors. It - * will never let the *source* observable emit any values if the `notifier` completes or throws an error without - * emitting a value before. - * - * ## Example - * - * In the following example, all emitted values of the interval observable are skipped until the user clicks anywhere - * within the page - * - * ```ts - * import { interval, fromEvent, skipUntil } from 'rxjs'; - * - * const intervalObservable = interval(1000); - * const click = fromEvent(document, 'click'); - * - * const emitAfterClick = intervalObservable.pipe( - * skipUntil(click) - * ); - * // clicked at 4.6s. output: 5...6...7...8........ or - * // clicked at 7.3s. output: 8...9...10..11....... - * emitAfterClick.subscribe(value => console.log(value)); - * ``` - * - * @see {@link last} - * @see {@link skip} - * @see {@link skipWhile} - * @see {@link skipLast} - * - * @param notifier An `ObservableInput` that has to emit an item before the source Observable elements begin to - * be mirrored by the resulting Observable. - * @return A function that returns an Observable that skips items from the - * source Observable until the `notifier` Observable emits an item, then emits the - * remaining items. - */ -export function skipUntil<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let taking = false; - - const skipSubscriber = createOperatorSubscriber( - subscriber, - () => { - skipSubscriber?.unsubscribe(); - taking = true; - }, - noop - ); - - innerFrom(notifier).subscribe(skipSubscriber); - - source.subscribe(createOperatorSubscriber(subscriber, (value) => taking && subscriber.next(value))); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/skipWhile.ts b/node_modules/rxjs/src/internal/operators/skipWhile.ts deleted file mode 100644 index 84b7379..0000000 --- a/node_modules/rxjs/src/internal/operators/skipWhile.ts +++ /dev/null @@ -1,60 +0,0 @@ -import { Falsy, MonoTypeOperatorFunction, OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -export function skipWhile<T>(predicate: BooleanConstructor): OperatorFunction<T, Extract<T, Falsy> extends never ? never : T>; -export function skipWhile<T>(predicate: (value: T, index: number) => true): OperatorFunction<T, never>; -export function skipWhile<T>(predicate: (value: T, index: number) => boolean): MonoTypeOperatorFunction<T>; - -/** - * Returns an Observable that skips all items emitted by the source Observable as long as a specified condition holds - * true, but emits all further source items as soon as the condition becomes false. - * - *  - * - * Skips all the notifications with a truthy predicate. It will not skip the notifications when the predicate is falsy. - * It can also be skipped using index. Once the predicate is true, it will not be called again. - * - * ## Example - * - * Skip some super heroes - * - * ```ts - * import { from, skipWhile } from 'rxjs'; - * - * const source = from(['Green Arrow', 'SuperMan', 'Flash', 'SuperGirl', 'Black Canary']) - * // Skip the heroes until SuperGirl - * const example = source.pipe(skipWhile(hero => hero !== 'SuperGirl')); - * // output: SuperGirl, Black Canary - * example.subscribe(femaleHero => console.log(femaleHero)); - * ``` - * - * Skip values from the array until index 5 - * - * ```ts - * import { from, skipWhile } from 'rxjs'; - * - * const source = from([1, 2, 3, 4, 5, 6, 7, 9, 10]); - * const example = source.pipe(skipWhile((_, i) => i !== 5)); - * // output: 6, 7, 9, 10 - * example.subscribe(value => console.log(value)); - * ``` - * - * @see {@link last} - * @see {@link skip} - * @see {@link skipUntil} - * @see {@link skipLast} - * - * @param predicate A function to test each item emitted from the source Observable. - * @return A function that returns an Observable that begins emitting items - * emitted by the source Observable when the specified predicate becomes false. - */ -export function skipWhile<T>(predicate: (value: T, index: number) => boolean): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let taking = false; - let index = 0; - source.subscribe( - createOperatorSubscriber(subscriber, (value) => (taking || (taking = !predicate(value, index++))) && subscriber.next(value)) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/startWith.ts b/node_modules/rxjs/src/internal/operators/startWith.ts deleted file mode 100644 index 8c11ddb..0000000 --- a/node_modules/rxjs/src/internal/operators/startWith.ts +++ /dev/null @@ -1,67 +0,0 @@ -import { concat } from '../observable/concat'; -import { OperatorFunction, SchedulerLike, ValueFromArray } from '../types'; -import { popScheduler } from '../util/args'; -import { operate } from '../util/lift'; - -// 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 startWith<T>(value: null): OperatorFunction<T, T | null>; -export function startWith<T>(value: undefined): OperatorFunction<T, T | undefined>; - -/** @deprecated The `scheduler` parameter will be removed in v8. Use `scheduled` and `concatAll`. Details: https://rxjs.dev/deprecations/scheduler-argument */ -export function startWith<T, A extends readonly unknown[] = T[]>( - ...valuesAndScheduler: [...A, SchedulerLike] -): OperatorFunction<T, T | ValueFromArray<A>>; -export function startWith<T, A extends readonly unknown[] = T[]>(...values: A): OperatorFunction<T, T | ValueFromArray<A>>; - -/** - * Returns an observable that, at the moment of subscription, will synchronously emit all - * values provided to this operator, then subscribe to the source and mirror all of its emissions - * to subscribers. - * - * This is a useful way to know when subscription has occurred on an existing observable. - * - * <span class="informal">First emits its arguments in order, and then any - * emissions from the source.</span> - * - *  - * - * ## Examples - * - * Emit a value when a timer starts. - * - * ```ts - * import { timer, map, startWith } from 'rxjs'; - * - * timer(1000) - * .pipe( - * map(() => 'timer emit'), - * startWith('timer start') - * ) - * .subscribe(x => console.log(x)); - * - * // results: - * // 'timer start' - * // 'timer emit' - * ``` - * - * @param values Items you want the modified Observable to emit first. - * @return A function that returns an Observable that synchronously emits - * provided values before subscribing to the source Observable. - * - * @see {@link endWith} - * @see {@link finalize} - * @see {@link concat} - */ -export function startWith<T, D>(...values: D[]): OperatorFunction<T, T | D> { - const scheduler = popScheduler(values); - return operate((source, subscriber) => { - // Here we can't pass `undefined` as a scheduler, because if we did, the - // code inside of `concat` would be confused by the `undefined`, and treat it - // like an invalid observable. So we have to split it two different ways. - (scheduler ? concat(values, source, scheduler) : concat(values, source)).subscribe(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/subscribeOn.ts b/node_modules/rxjs/src/internal/operators/subscribeOn.ts deleted file mode 100644 index 17240d0..0000000 --- a/node_modules/rxjs/src/internal/operators/subscribeOn.ts +++ /dev/null @@ -1,67 +0,0 @@ -import { MonoTypeOperatorFunction, SchedulerLike } from '../types'; -import { operate } from '../util/lift'; - -/** - * Asynchronously subscribes Observers to this Observable on the specified {@link SchedulerLike}. - * - * With `subscribeOn` you can decide what type of scheduler a specific Observable will be using when it is subscribed to. - * - * Schedulers control the speed and order of emissions to observers from an Observable stream. - * - *  - * - * ## Example - * - * Given the following code: - * - * ```ts - * import { of, merge } from 'rxjs'; - * - * const a = of(1, 2, 3); - * const b = of(4, 5, 6); - * - * merge(a, b).subscribe(console.log); - * - * // Outputs - * // 1 - * // 2 - * // 3 - * // 4 - * // 5 - * // 6 - * ``` - * - * Both Observable `a` and `b` will emit their values directly and synchronously once they are subscribed to. - * - * If we instead use the `subscribeOn` operator declaring that we want to use the {@link asyncScheduler} for values emitted by Observable `a`: - * - * ```ts - * import { of, subscribeOn, asyncScheduler, merge } from 'rxjs'; - * - * const a = of(1, 2, 3).pipe(subscribeOn(asyncScheduler)); - * const b = of(4, 5, 6); - * - * merge(a, b).subscribe(console.log); - * - * // Outputs - * // 4 - * // 5 - * // 6 - * // 1 - * // 2 - * // 3 - * ``` - * - * The reason for this is that Observable `b` emits its values directly and synchronously like before - * but the emissions from `a` are scheduled on the event loop because we are now using the {@link asyncScheduler} for that specific Observable. - * - * @param scheduler The {@link SchedulerLike} to perform subscription actions on. - * @param delay A delay to pass to the scheduler to delay subscriptions - * @return A function that returns an Observable modified so that its - * subscriptions happen on the specified {@link SchedulerLike}. - */ -export function subscribeOn<T>(scheduler: SchedulerLike, delay: number = 0): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - subscriber.add(scheduler.schedule(() => source.subscribe(subscriber), delay)); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/switchAll.ts b/node_modules/rxjs/src/internal/operators/switchAll.ts deleted file mode 100644 index 69e9cbb..0000000 --- a/node_modules/rxjs/src/internal/operators/switchAll.ts +++ /dev/null @@ -1,65 +0,0 @@ -import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types'; -import { switchMap } from './switchMap'; -import { identity } from '../util/identity'; - -/** - * Converts a higher-order Observable into a first-order Observable - * producing values only from the most recent observable sequence - * - * <span class="informal">Flattens an Observable-of-Observables.</span> - * - *  - * - * `switchAll` subscribes to a source that is an observable of observables, also known as a - * "higher-order observable" (or `Observable<Observable<T>>`). It subscribes to the most recently - * provided "inner observable" emitted by the source, unsubscribing from any previously subscribed - * to inner observable, such that only the most recent inner observable may be subscribed to at - * any point in time. The resulting observable returned by `switchAll` will only complete if the - * source observable completes, *and* any currently subscribed to inner observable also has completed, - * if there are any. - * - * ## Examples - * - * Spawn a new interval observable for each click event, but for every new - * click, cancel the previous interval and subscribe to the new one - * - * ```ts - * import { fromEvent, tap, map, interval, switchAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click').pipe(tap(() => console.log('click'))); - * const source = clicks.pipe(map(() => interval(1000))); - * - * source - * .pipe(switchAll()) - * .subscribe(x => console.log(x)); - * - * // Output - * // click - * // 0 - * // 1 - * // 2 - * // 3 - * // ... - * // click - * // 0 - * // 1 - * // 2 - * // ... - * // click - * // ... - * ``` - * - * @see {@link combineLatestAll} - * @see {@link concatAll} - * @see {@link exhaustAll} - * @see {@link switchMap} - * @see {@link switchMapTo} - * @see {@link mergeAll} - * - * @return A function that returns an Observable that converts a higher-order - * Observable into a first-order Observable producing values only from the most - * recent Observable sequence. - */ -export function switchAll<O extends ObservableInput<any>>(): OperatorFunction<O, ObservedValueOf<O>> { - return switchMap(identity); -} diff --git a/node_modules/rxjs/src/internal/operators/switchMap.ts b/node_modules/rxjs/src/internal/operators/switchMap.ts deleted file mode 100644 index 0ded7ba..0000000 --- a/node_modules/rxjs/src/internal/operators/switchMap.ts +++ /dev/null @@ -1,132 +0,0 @@ -import { Subscriber } from '../Subscriber'; -import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types'; -import { innerFrom } from '../observable/innerFrom'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/* tslint:disable:max-line-length */ -export function switchMap<T, O extends ObservableInput<any>>( - project: (value: T, index: number) => O -): OperatorFunction<T, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function switchMap<T, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector: undefined -): OperatorFunction<T, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function switchMap<T, R, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, R>; -/* tslint:enable:max-line-length */ - -/** - * Projects each source value to an Observable which is merged in the output - * Observable, emitting values only from the most recently projected Observable. - * - * <span class="informal">Maps each value to an Observable, then flattens all of - * these inner Observables using {@link switchAll}.</span> - * - *  - * - * Returns an Observable that emits items based on applying a function that you - * supply to each item emitted by the source Observable, where that function - * returns an (so-called "inner") Observable. Each time it observes one of these - * inner Observables, the output Observable begins emitting the items emitted by - * that inner Observable. When a new inner Observable is emitted, `switchMap` - * stops emitting items from the earlier-emitted inner Observable and begins - * emitting items from the new one. It continues to behave like this for - * subsequent inner Observables. - * - * ## Example - * - * Generate new Observable according to source Observable values - * - * ```ts - * import { of, switchMap } from 'rxjs'; - * - * const switched = of(1, 2, 3).pipe(switchMap(x => of(x, x ** 2, x ** 3))); - * switched.subscribe(x => console.log(x)); - * // outputs - * // 1 - * // 1 - * // 1 - * // 2 - * // 4 - * // 8 - * // 3 - * // 9 - * // 27 - * ``` - * - * Restart an interval Observable on every click event - * - * ```ts - * import { fromEvent, switchMap, interval } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(switchMap(() => interval(1000))); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link concatMap} - * @see {@link exhaustMap} - * @see {@link mergeMap} - * @see {@link switchAll} - * @see {@link switchMapTo} - * - * @param project A function that, when applied to an item emitted by the source - * Observable, returns an Observable. - * @return A function that returns an Observable that emits the result of - * applying the projection function (and the optional deprecated - * `resultSelector`) to each item emitted by the source Observable and taking - * only the values from the most recently projected inner Observable. - */ -export function switchMap<T, R, O extends ObservableInput<any>>( - project: (value: T, index: number) => O, - resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, ObservedValueOf<O> | R> { - return operate((source, subscriber) => { - let innerSubscriber: Subscriber<ObservedValueOf<O>> | null = null; - let index = 0; - // Whether or not the source subscription has completed - let isComplete = false; - - // We only complete the result if the source is complete AND we don't have an active inner subscription. - // This is called both when the source completes and when the inners complete. - const checkComplete = () => isComplete && !innerSubscriber && subscriber.complete(); - - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - // Cancel the previous inner subscription if there was one - innerSubscriber?.unsubscribe(); - let innerIndex = 0; - const outerIndex = index++; - // Start the next inner subscription - innerFrom(project(value, outerIndex)).subscribe( - (innerSubscriber = createOperatorSubscriber( - subscriber, - // When we get a new inner value, next it through. Note that this is - // handling the deprecate result selector here. This is because with this architecture - // it ends up being smaller than using the map operator. - (innerValue) => subscriber.next(resultSelector ? resultSelector(value, innerValue, outerIndex, innerIndex++) : innerValue), - () => { - // The inner has completed. Null out the inner subscriber to - // free up memory and to signal that we have no inner subscription - // currently. - innerSubscriber = null!; - checkComplete(); - } - )) - ); - }, - () => { - isComplete = true; - checkComplete(); - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/switchMapTo.ts b/node_modules/rxjs/src/internal/operators/switchMapTo.ts deleted file mode 100644 index 9819bdf..0000000 --- a/node_modules/rxjs/src/internal/operators/switchMapTo.ts +++ /dev/null @@ -1,64 +0,0 @@ -import { switchMap } from './switchMap'; -import { ObservableInput, OperatorFunction, ObservedValueOf } from '../types'; -import { isFunction } from '../util/isFunction'; - -/** @deprecated Will be removed in v9. Use {@link switchMap} instead: `switchMap(() => result)` */ -export function switchMapTo<O extends ObservableInput<unknown>>(observable: O): OperatorFunction<unknown, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function switchMapTo<O extends ObservableInput<unknown>>( - observable: O, - resultSelector: undefined -): OperatorFunction<unknown, ObservedValueOf<O>>; -/** @deprecated The `resultSelector` parameter will be removed in v8. Use an inner `map` instead. Details: https://rxjs.dev/deprecations/resultSelector */ -export function switchMapTo<T, R, O extends ObservableInput<unknown>>( - observable: O, - resultSelector: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, R>; - -/** - * Projects each source value to the same Observable which is flattened multiple - * times with {@link switchMap} in the output Observable. - * - * <span class="informal">It's like {@link switchMap}, but maps each value - * always to the same inner Observable.</span> - * - *  - * - * Maps each source value to the given Observable `innerObservable` regardless - * of the source value, and then flattens those resulting Observables into one - * single Observable, which is the output Observable. The output Observables - * emits values only from the most recently emitted instance of - * `innerObservable`. - * - * ## Example - * - * Restart an interval Observable on every click event - * - * ```ts - * import { fromEvent, switchMapTo, interval } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(switchMapTo(interval(1000))); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link concatMapTo} - * @see {@link switchAll} - * @see {@link switchMap} - * @see {@link mergeMapTo} - * - * @param innerObservable An `ObservableInput` to replace each value from the - * source Observable. - * @return A function that returns an Observable that emits items from the - * given `innerObservable` (and optionally transformed through the deprecated - * `resultSelector`) every time a value is emitted on the source Observable, - * and taking only the values from the most recently projected inner - * Observable. - * @deprecated Will be removed in v9. Use {@link switchMap} instead: `switchMap(() => result)` - */ -export function switchMapTo<T, R, O extends ObservableInput<unknown>>( - innerObservable: O, - resultSelector?: (outerValue: T, innerValue: ObservedValueOf<O>, outerIndex: number, innerIndex: number) => R -): OperatorFunction<T, ObservedValueOf<O> | R> { - return isFunction(resultSelector) ? switchMap(() => innerObservable, resultSelector) : switchMap(() => innerObservable); -} diff --git a/node_modules/rxjs/src/internal/operators/switchScan.ts b/node_modules/rxjs/src/internal/operators/switchScan.ts deleted file mode 100644 index 902a2a7..0000000 --- a/node_modules/rxjs/src/internal/operators/switchScan.ts +++ /dev/null @@ -1,50 +0,0 @@ -import { ObservableInput, ObservedValueOf, OperatorFunction } from '../types'; -import { switchMap } from './switchMap'; -import { operate } from '../util/lift'; - -// TODO: Generate a marble diagram for these docs. - -/** - * Applies an accumulator function over the source Observable where the - * accumulator function itself returns an Observable, emitting values - * only from the most recently returned Observable. - * - * <span class="informal">It's like {@link mergeScan}, but only the most recent - * Observable returned by the accumulator is merged into the outer Observable.</span> - * - * @see {@link scan} - * @see {@link mergeScan} - * @see {@link switchMap} - * - * @param accumulator - * The accumulator function called on each source value. - * @param seed The initial accumulation value. - * @return A function that returns an observable of the accumulated values. - */ -export function switchScan<T, R, O extends ObservableInput<any>>( - accumulator: (acc: R, value: T, index: number) => O, - seed: R -): OperatorFunction<T, ObservedValueOf<O>> { - return operate((source, subscriber) => { - // The state we will keep up to date to pass into our - // accumulator function at each new value from the source. - let state = seed; - - // Use `switchMap` on our `source` to do the work of creating - // this operator. Note the backwards order here of `switchMap()(source)` - // to avoid needing to use `pipe` unnecessarily - switchMap( - // On each value from the source, call the accumulator with - // our previous state, the value and the index. - (value: T, index) => accumulator(state, value, index), - // Using the deprecated result selector here as a dirty trick - // to update our state with the flattened value. - (_, innerValue) => ((state = innerValue), innerValue) - )(source).subscribe(subscriber); - - return () => { - // Release state on finalization - state = null!; - }; - }); -} diff --git a/node_modules/rxjs/src/internal/operators/take.ts b/node_modules/rxjs/src/internal/operators/take.ts deleted file mode 100644 index b2054e7..0000000 --- a/node_modules/rxjs/src/internal/operators/take.ts +++ /dev/null @@ -1,71 +0,0 @@ -import { MonoTypeOperatorFunction } from '../types'; -import { EMPTY } from '../observable/empty'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Emits only the first `count` values emitted by the source Observable. - * - * <span class="informal">Takes the first `count` values from the source, then - * completes.</span> - * - *  - * - * `take` returns an Observable that emits only the first `count` values emitted - * by the source Observable. If the source emits fewer than `count` values then - * all of its values are emitted. After that, it completes, regardless if the - * source completes. - * - * ## Example - * - * Take the first 5 seconds of an infinite 1-second interval Observable - * - * ```ts - * import { interval, take } from 'rxjs'; - * - * const intervalCount = interval(1000); - * const takeFive = intervalCount.pipe(take(5)); - * takeFive.subscribe(x => console.log(x)); - * - * // Logs: - * // 0 - * // 1 - * // 2 - * // 3 - * // 4 - * ``` - * - * @see {@link takeLast} - * @see {@link takeUntil} - * @see {@link takeWhile} - * @see {@link skip} - * - * @param count The maximum number of `next` values to emit. - * @return A function that returns an Observable that emits only the first - * `count` values emitted by the source Observable, or all of the values from - * the source if the source emits fewer than `count` values. - */ -export function take<T>(count: number): MonoTypeOperatorFunction<T> { - return count <= 0 - ? // If we are taking no values, that's empty. - () => EMPTY - : operate((source, subscriber) => { - let seen = 0; - source.subscribe( - createOperatorSubscriber(subscriber, (value) => { - // Increment the number of values we have seen, - // then check it against the allowed count to see - // if we are still letting values through. - if (++seen <= count) { - subscriber.next(value); - // If we have met or passed our allowed count, - // we need to complete. We have to do <= here, - // because re-entrant code will increment `seen` twice. - if (count <= seen) { - subscriber.complete(); - } - } - }) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/takeLast.ts b/node_modules/rxjs/src/internal/operators/takeLast.ts deleted file mode 100644 index 972d147..0000000 --- a/node_modules/rxjs/src/internal/operators/takeLast.ts +++ /dev/null @@ -1,81 +0,0 @@ -import { EMPTY } from '../observable/empty'; -import { MonoTypeOperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Waits for the source to complete, then emits the last N values from the source, - * as specified by the `count` argument. - * - *  - * - * `takeLast` results in an observable that will hold values up to `count` values in memory, - * until the source completes. It then pushes all values in memory to the consumer, in the - * order they were received from the source, then notifies the consumer that it is - * complete. - * - * If for some reason the source completes before the `count` supplied to `takeLast` is reached, - * all values received until that point are emitted, and then completion is notified. - * - * **Warning**: Using `takeLast` with an observable that never completes will result - * in an observable that never emits a value. - * - * ## Example - * - * Take the last 3 values of an Observable with many values - * - * ```ts - * import { range, takeLast } from 'rxjs'; - * - * const many = range(1, 100); - * const lastThree = many.pipe(takeLast(3)); - * lastThree.subscribe(x => console.log(x)); - * ``` - * - * @see {@link take} - * @see {@link takeUntil} - * @see {@link takeWhile} - * @see {@link skip} - * - * @param count The maximum number of values to emit from the end of - * the sequence of values emitted by the source Observable. - * @return A function that returns an Observable that emits at most the last - * `count` values emitted by the source Observable. - */ -export function takeLast<T>(count: number): MonoTypeOperatorFunction<T> { - return count <= 0 - ? () => EMPTY - : operate((source, subscriber) => { - // This buffer will hold the values we are going to emit - // when the source completes. Since we only want to take the - // last N values, we can't emit until we're sure we're not getting - // any more values. - let buffer: T[] = []; - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - // Add the most recent value onto the end of our buffer. - buffer.push(value); - // If our buffer is now larger than the number of values we - // want to take, we remove the oldest value from the buffer. - count < buffer.length && buffer.shift(); - }, - () => { - // The source completed, we now know what are last values - // are, emit them in the order they were received. - for (const value of buffer) { - subscriber.next(value); - } - subscriber.complete(); - }, - // Errors are passed through to the consumer - undefined, - () => { - // During finalization release the values in our buffer. - buffer = null!; - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/takeUntil.ts b/node_modules/rxjs/src/internal/operators/takeUntil.ts deleted file mode 100644 index 177141d..0000000 --- a/node_modules/rxjs/src/internal/operators/takeUntil.ts +++ /dev/null @@ -1,50 +0,0 @@ -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; -import { noop } from '../util/noop'; - -/** - * Emits the values emitted by the source Observable until a `notifier` - * Observable emits a value. - * - * <span class="informal">Lets values pass until a second Observable, - * `notifier`, emits a value. Then, it completes.</span> - * - *  - * - * `takeUntil` subscribes and begins mirroring the source Observable. It also - * monitors a second Observable, `notifier` that you provide. If the `notifier` - * emits a value, the output Observable stops mirroring the source Observable - * and completes. If the `notifier` doesn't emit any value and completes - * then `takeUntil` will pass all values. - * - * ## Example - * - * Tick every second until the first click happens - * - * ```ts - * import { interval, fromEvent, takeUntil } from 'rxjs'; - * - * const source = interval(1000); - * const clicks = fromEvent(document, 'click'); - * const result = source.pipe(takeUntil(clicks)); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link take} - * @see {@link takeLast} - * @see {@link takeWhile} - * @see {@link skip} - * - * @param notifier The `ObservableInput` whose first emitted value will cause the output - * Observable of `takeUntil` to stop emitting values from the source Observable. - * @return A function that returns an Observable that emits the values from the - * source Observable until `notifier` emits its first value. - */ -export function takeUntil<T>(notifier: ObservableInput<any>): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, () => subscriber.complete(), noop)); - !subscriber.closed && source.subscribe(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/takeWhile.ts b/node_modules/rxjs/src/internal/operators/takeWhile.ts deleted file mode 100644 index b48e34c..0000000 --- a/node_modules/rxjs/src/internal/operators/takeWhile.ts +++ /dev/null @@ -1,66 +0,0 @@ -import { OperatorFunction, MonoTypeOperatorFunction, TruthyTypesOf } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -export function takeWhile<T>(predicate: BooleanConstructor, inclusive: true): MonoTypeOperatorFunction<T>; -export function takeWhile<T>(predicate: BooleanConstructor, inclusive: false): OperatorFunction<T, TruthyTypesOf<T>>; -export function takeWhile<T>(predicate: BooleanConstructor): OperatorFunction<T, TruthyTypesOf<T>>; -export function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S): OperatorFunction<T, S>; -export function takeWhile<T, S extends T>(predicate: (value: T, index: number) => value is S, inclusive: false): OperatorFunction<T, S>; -export function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive?: boolean): MonoTypeOperatorFunction<T>; - -/** - * Emits values emitted by the source Observable so long as each value satisfies - * the given `predicate`, and then completes as soon as this `predicate` is not - * satisfied. - * - * <span class="informal">Takes values from the source only while they pass the - * condition given. When the first value does not satisfy, it completes.</span> - * - *  - * - * `takeWhile` subscribes and begins mirroring the source Observable. Each value - * emitted on the source is given to the `predicate` function which returns a - * boolean, representing a condition to be satisfied by the source values. The - * output Observable emits the source values until such time as the `predicate` - * returns false, at which point `takeWhile` stops mirroring the source - * Observable and completes the output Observable. - * - * ## Example - * - * Emit click events only while the clientX property is greater than 200 - * - * ```ts - * import { fromEvent, takeWhile } from 'rxjs'; - * - * const clicks = fromEvent<PointerEvent>(document, 'click'); - * const result = clicks.pipe(takeWhile(ev => ev.clientX > 200)); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link take} - * @see {@link takeLast} - * @see {@link takeUntil} - * @see {@link skip} - * - * @param predicate A function that evaluates a value emitted by the source - * Observable and returns a boolean. Also takes the (zero-based) index as the - * second argument. - * @param inclusive When set to `true` the value that caused `predicate` to - * return `false` will also be emitted. - * @return A function that returns an Observable that emits values from the - * source Observable so long as each value satisfies the condition defined by - * the `predicate`, then completes. - */ -export function takeWhile<T>(predicate: (value: T, index: number) => boolean, inclusive = false): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let index = 0; - source.subscribe( - createOperatorSubscriber(subscriber, (value) => { - const result = predicate(value, index++); - (result || inclusive) && subscriber.next(value); - !result && subscriber.complete(); - }) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/tap.ts b/node_modules/rxjs/src/internal/operators/tap.ts deleted file mode 100644 index bc6243e..0000000 --- a/node_modules/rxjs/src/internal/operators/tap.ts +++ /dev/null @@ -1,215 +0,0 @@ -import { MonoTypeOperatorFunction, Observer } from '../types'; -import { isFunction } from '../util/isFunction'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { identity } from '../util/identity'; - -/** - * An extension to the {@link Observer} interface used only by the {@link tap} operator. - * - * It provides a useful set of callbacks a user can register to do side-effects in - * cases other than what the usual {@link Observer} callbacks are - * ({@link guide/glossary-and-semantics#next next}, - * {@link guide/glossary-and-semantics#error error} and/or - * {@link guide/glossary-and-semantics#complete complete}). - * - * ## Example - * - * ```ts - * import { fromEvent, switchMap, tap, interval, take } from 'rxjs'; - * - * const source$ = fromEvent(document, 'click'); - * const result$ = source$.pipe( - * switchMap((_, i) => i % 2 === 0 - * ? fromEvent(document, 'mousemove').pipe( - * tap({ - * subscribe: () => console.log('Subscribed to the mouse move events after click #' + i), - * unsubscribe: () => console.log('Mouse move events #' + i + ' unsubscribed'), - * finalize: () => console.log('Mouse move events #' + i + ' finalized') - * }) - * ) - * : interval(1_000).pipe( - * take(5), - * tap({ - * subscribe: () => console.log('Subscribed to the 1-second interval events after click #' + i), - * unsubscribe: () => console.log('1-second interval events #' + i + ' unsubscribed'), - * finalize: () => console.log('1-second interval events #' + i + ' finalized') - * }) - * ) - * ) - * ); - * - * const subscription = result$.subscribe({ - * next: console.log - * }); - * - * setTimeout(() => { - * console.log('Unsubscribe after 60 seconds'); - * subscription.unsubscribe(); - * }, 60_000); - * ``` - */ -export interface TapObserver<T> extends Observer<T> { - /** - * The callback that `tap` operator invokes at the moment when the source Observable - * gets subscribed to. - */ - subscribe: () => void; - /** - * The callback that `tap` operator invokes when an explicit - * {@link guide/glossary-and-semantics#unsubscription unsubscribe} happens. It won't get invoked on - * `error` or `complete` events. - */ - unsubscribe: () => void; - /** - * The callback that `tap` operator invokes when any kind of - * {@link guide/glossary-and-semantics#finalization finalization} happens - either when - * the source Observable `error`s or `complete`s or when it gets explicitly unsubscribed - * by the user. There is no difference in using this callback or the {@link finalize} - * operator, but if you're already using `tap` operator, you can use this callback - * instead. You'd get the same result in either case. - */ - finalize: () => void; -} -export function tap<T>(observerOrNext?: Partial<TapObserver<T>> | ((value: T) => void)): MonoTypeOperatorFunction<T>; -/** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */ -export function tap<T>( - next?: ((value: T) => void) | null, - error?: ((error: any) => void) | null, - complete?: (() => void) | null -): MonoTypeOperatorFunction<T>; - -/** - * Used to perform side-effects for notifications from the source observable - * - * <span class="informal">Used when you want to affect outside state with a notification without altering the notification</span> - * - *  - * - * Tap is designed to allow the developer a designated place to perform side effects. While you _could_ perform side-effects - * inside of a `map` or a `mergeMap`, that would make their mapping functions impure, which isn't always a big deal, but will - * make it so you can't do things like memoize those functions. The `tap` operator is designed solely for such side-effects to - * help you remove side-effects from other operations. - * - * For any notification, next, error, or complete, `tap` will call the appropriate callback you have provided to it, via a function - * reference, or a partial observer, then pass that notification down the stream. - * - * The observable returned by `tap` is an exact mirror of the source, with one exception: Any error that occurs -- synchronously -- in a handler - * provided to `tap` will be emitted as an error from the returned observable. - * - * > Be careful! You can mutate objects as they pass through the `tap` operator's handlers. - * - * The most common use of `tap` is actually for debugging. You can place a `tap(console.log)` anywhere - * in your observable `pipe`, log out the notifications as they are emitted by the source returned by the previous - * operation. - * - * ## Examples - * - * Check a random number before it is handled. Below is an observable that will use a random number between 0 and 1, - * and emit `'big'` or `'small'` depending on the size of that number. But we wanted to log what the original number - * was, so we have added a `tap(console.log)`. - * - * ```ts - * import { of, tap, map } from 'rxjs'; - * - * of(Math.random()).pipe( - * tap(console.log), - * map(n => n > 0.5 ? 'big' : 'small') - * ).subscribe(console.log); - * ``` - * - * Using `tap` to analyze a value and force an error. Below is an observable where in our system we only - * want to emit numbers 3 or less we get from another source. We can force our observable to error - * using `tap`. - * - * ```ts - * import { of, tap } from 'rxjs'; - * - * const source = of(1, 2, 3, 4, 5); - * - * source.pipe( - * tap(n => { - * if (n > 3) { - * throw new TypeError(`Value ${ n } is greater than 3`); - * } - * }) - * ) - * .subscribe({ next: console.log, error: err => console.log(err.message) }); - * ``` - * - * We want to know when an observable completes before moving on to the next observable. The system - * below will emit a random series of `'X'` characters from 3 different observables in sequence. The - * only way we know when one observable completes and moves to the next one, in this case, is because - * we have added a `tap` with the side effect of logging to console. - * - * ```ts - * import { of, concatMap, interval, take, map, tap } from 'rxjs'; - * - * of(1, 2, 3).pipe( - * concatMap(n => interval(1000).pipe( - * take(Math.round(Math.random() * 10)), - * map(() => 'X'), - * tap({ complete: () => console.log(`Done with ${ n }`) }) - * )) - * ) - * .subscribe(console.log); - * ``` - * - * @see {@link finalize} - * @see {@link TapObserver} - * - * @param observerOrNext A next handler or partial observer - * @param error An error handler - * @param complete A completion handler - * @return A function that returns an Observable identical to the source, but - * runs the specified Observer or callback(s) for each item. - */ -export function tap<T>( - observerOrNext?: Partial<TapObserver<T>> | ((value: T) => void) | null, - error?: ((e: any) => void) | null, - complete?: (() => void) | null -): MonoTypeOperatorFunction<T> { - // We have to check to see not only if next is a function, - // but if error or complete were passed. This is because someone - // could technically call tap like `tap(null, fn)` or `tap(null, null, fn)`. - const tapObserver = - isFunction(observerOrNext) || error || complete - ? // tslint:disable-next-line: no-object-literal-type-assertion - ({ next: observerOrNext as Exclude<typeof observerOrNext, Partial<TapObserver<T>>>, error, complete } as Partial<TapObserver<T>>) - : observerOrNext; - - return tapObserver - ? operate((source, subscriber) => { - tapObserver.subscribe?.(); - let isUnsub = true; - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - tapObserver.next?.(value); - subscriber.next(value); - }, - () => { - isUnsub = false; - tapObserver.complete?.(); - subscriber.complete(); - }, - (err) => { - isUnsub = false; - tapObserver.error?.(err); - subscriber.error(err); - }, - () => { - if (isUnsub) { - tapObserver.unsubscribe?.(); - } - tapObserver.finalize?.(); - } - ) - ); - }) - : // Tap was called with no valid tap observer or handler - // (e.g. `tap(null, null, null)` or `tap(null)` or `tap()`) - // so we're going to just mirror the source. - identity; -} diff --git a/node_modules/rxjs/src/internal/operators/throttle.ts b/node_modules/rxjs/src/internal/operators/throttle.ts deleted file mode 100644 index 8c53a1c..0000000 --- a/node_modules/rxjs/src/internal/operators/throttle.ts +++ /dev/null @@ -1,143 +0,0 @@ -import { Subscription } from '../Subscription'; - -import { MonoTypeOperatorFunction, ObservableInput } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; - -/** - * An object interface used by {@link throttle} or {@link throttleTime} that ensure - * configuration options of these operators. - * - * @see {@link throttle} - * @see {@link throttleTime} - */ -export interface ThrottleConfig { - /** - * If `true`, the resulting Observable will emit the first value from the source - * Observable at the **start** of the "throttling" process (when starting an - * internal timer that prevents other emissions from the source to pass through). - * If `false`, it will not emit the first value from the source Observable at the - * start of the "throttling" process. - * - * If not provided, defaults to: `true`. - */ - leading?: boolean; - /** - * If `true`, the resulting Observable will emit the last value from the source - * Observable at the **end** of the "throttling" process (when ending an internal - * timer that prevents other emissions from the source to pass through). - * If `false`, it will not emit the last value from the source Observable at the - * end of the "throttling" process. - * - * If not provided, defaults to: `false`. - */ - trailing?: boolean; -} - -/** - * Emits a value from the source Observable, then ignores subsequent source - * values for a duration determined by another Observable, then repeats this - * process. - * - * <span class="informal">It's like {@link throttleTime}, but the silencing - * duration is determined by a second Observable.</span> - * - *  - * - * `throttle` emits the source Observable values on the output Observable - * when its internal timer is disabled, and ignores source values when the timer - * is enabled. Initially, the timer is disabled. As soon as the first source - * value arrives, it is forwarded to the output Observable, and then the timer - * is enabled by calling the `durationSelector` function with the source value, - * which returns the "duration" Observable. When the duration Observable emits a - * value, the timer is disabled, and this process repeats for the - * next source value. - * - * ## Example - * - * Emit clicks at a rate of at most one click per second - * - * ```ts - * import { fromEvent, throttle, interval } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(throttle(() => interval(1000))); - * - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link audit} - * @see {@link debounce} - * @see {@link delayWhen} - * @see {@link sample} - * @see {@link throttleTime} - * - * @param durationSelector A function that receives a value from the source - * Observable, for computing the silencing duration for each source value, - * returned as an `ObservableInput`. - * @param config A configuration object to define `leading` and `trailing` - * behavior. Defaults to `{ leading: true, trailing: false }`. - * @return A function that returns an Observable that performs the throttle - * operation to limit the rate of emissions from the source. - */ -export function throttle<T>(durationSelector: (value: T) => ObservableInput<any>, config?: ThrottleConfig): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - const { leading = true, trailing = false } = config ?? {}; - let hasValue = false; - let sendValue: T | null = null; - let throttled: Subscription | null = null; - let isComplete = false; - - const endThrottling = () => { - throttled?.unsubscribe(); - throttled = null; - if (trailing) { - send(); - isComplete && subscriber.complete(); - } - }; - - const cleanupThrottling = () => { - throttled = null; - isComplete && subscriber.complete(); - }; - - const startThrottle = (value: T) => - (throttled = innerFrom(durationSelector(value)).subscribe(createOperatorSubscriber(subscriber, endThrottling, cleanupThrottling))); - - const send = () => { - if (hasValue) { - // Ensure we clear out our value and hasValue flag - // before we emit, otherwise reentrant code can cause - // issues here. - hasValue = false; - const value = sendValue!; - sendValue = null; - // Emit the value. - subscriber.next(value); - !isComplete && startThrottle(value); - } - }; - - source.subscribe( - createOperatorSubscriber( - subscriber, - // Regarding the presence of throttled.closed in the following - // conditions, if a synchronous duration selector is specified - weird, - // but legal - an already-closed subscription will be assigned to - // throttled, so the subscription's closed property needs to be checked, - // too. - (value) => { - hasValue = true; - sendValue = value; - !(throttled && !throttled.closed) && (leading ? send() : startThrottle(value)); - }, - () => { - isComplete = true; - !(trailing && hasValue && throttled && !throttled.closed) && subscriber.complete(); - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/throttleTime.ts b/node_modules/rxjs/src/internal/operators/throttleTime.ts deleted file mode 100644 index de325fe..0000000 --- a/node_modules/rxjs/src/internal/operators/throttleTime.ts +++ /dev/null @@ -1,62 +0,0 @@ -import { asyncScheduler } from '../scheduler/async'; -import { throttle, ThrottleConfig } from './throttle'; -import { MonoTypeOperatorFunction, SchedulerLike } from '../types'; -import { timer } from '../observable/timer'; - -/** - * Emits a value from the source Observable, then ignores subsequent source - * values for `duration` milliseconds, then repeats this process. - * - * <span class="informal">Lets a value pass, then ignores source values for the - * next `duration` milliseconds.</span> - * - *  - * - * `throttleTime` emits the source Observable values on the output Observable - * when its internal timer is disabled, and ignores source values when the timer - * is enabled. Initially, the timer is disabled. As soon as the first source - * value arrives, it is forwarded to the output Observable, and then the timer - * is enabled. After `duration` milliseconds (or the time unit determined - * internally by the optional `scheduler`) has passed, the timer is disabled, - * and this process repeats for the next source value. Optionally takes a - * {@link SchedulerLike} for managing timers. - * - * ## Examples - * - * ### Limit click rate - * - * Emit clicks at a rate of at most one click per second - * - * ```ts - * import { fromEvent, throttleTime } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe(throttleTime(1000)); - * - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link auditTime} - * @see {@link debounceTime} - * @see {@link delay} - * @see {@link sampleTime} - * @see {@link throttle} - * - * @param duration Time to wait before emitting another value after - * emitting the last value, measured in milliseconds or the time unit determined - * internally by the optional `scheduler`. - * @param scheduler The {@link SchedulerLike} to use for - * managing the timers that handle the throttling. Defaults to {@link asyncScheduler}. - * @param config A configuration object to define `leading` and - * `trailing` behavior. Defaults to `{ leading: true, trailing: false }`. - * @return A function that returns an Observable that performs the throttle - * operation to limit the rate of emissions from the source. - */ -export function throttleTime<T>( - duration: number, - scheduler: SchedulerLike = asyncScheduler, - config?: ThrottleConfig -): MonoTypeOperatorFunction<T> { - const duration$ = timer(duration, scheduler); - return throttle(() => duration$, config); -} diff --git a/node_modules/rxjs/src/internal/operators/throwIfEmpty.ts b/node_modules/rxjs/src/internal/operators/throwIfEmpty.ts deleted file mode 100644 index 76497a2..0000000 --- a/node_modules/rxjs/src/internal/operators/throwIfEmpty.ts +++ /dev/null @@ -1,60 +0,0 @@ -import { EmptyError } from '../util/EmptyError'; -import { MonoTypeOperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * If the source observable completes without emitting a value, it will emit - * an error. The error will be created at that time by the optional - * `errorFactory` argument, otherwise, the error will be {@link EmptyError}. - * - *  - * - * ## Example - * - * Throw an error if the document wasn't clicked within 1 second - * - * ```ts - * import { fromEvent, takeUntil, timer, throwIfEmpty } from 'rxjs'; - * - * const click$ = fromEvent(document, 'click'); - * - * click$.pipe( - * takeUntil(timer(1000)), - * throwIfEmpty(() => new Error('The document was not clicked within 1 second')) - * ) - * .subscribe({ - * next() { - * console.log('The document was clicked'); - * }, - * error(err) { - * console.error(err.message); - * } - * }); - * ``` - * - * @param errorFactory A factory function called to produce the - * error to be thrown when the source observable completes without emitting a - * value. - * @return A function that returns an Observable that throws an error if the - * source Observable completed without emitting. - */ -export function throwIfEmpty<T>(errorFactory: () => any = defaultErrorFactory): MonoTypeOperatorFunction<T> { - return operate((source, subscriber) => { - let hasValue = false; - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - hasValue = true; - subscriber.next(value); - }, - () => (hasValue ? subscriber.complete() : subscriber.error(errorFactory())) - ) - ); - }); -} - -function defaultErrorFactory() { - return new EmptyError(); -} diff --git a/node_modules/rxjs/src/internal/operators/timeInterval.ts b/node_modules/rxjs/src/internal/operators/timeInterval.ts deleted file mode 100644 index 6a58ab2..0000000 --- a/node_modules/rxjs/src/internal/operators/timeInterval.ts +++ /dev/null @@ -1,67 +0,0 @@ -import { asyncScheduler } from '../scheduler/async'; -import { SchedulerLike, OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Emits an object containing the current value, and the time that has - * passed between emitting the current value and the previous value, which is - * calculated by using the provided `scheduler`'s `now()` method to retrieve - * the current time at each emission, then calculating the difference. The `scheduler` - * defaults to {@link asyncScheduler}, so by default, the `interval` will be in - * milliseconds. - * - * <span class="informal">Convert an Observable that emits items into one that - * emits indications of the amount of time elapsed between those emissions.</span> - * - *  - * - * ## Example - * - * Emit interval between current value with the last value - * - * ```ts - * import { interval, timeInterval } from 'rxjs'; - * - * const seconds = interval(1000); - * - * seconds - * .pipe(timeInterval()) - * .subscribe(value => console.log(value)); - * - * // NOTE: The values will never be this precise, - * // intervals created with `interval` or `setInterval` - * // are non-deterministic. - * - * // { value: 0, interval: 1000 } - * // { value: 1, interval: 1000 } - * // { value: 2, interval: 1000 } - * ``` - * - * @param scheduler Scheduler used to get the current time. - * @return A function that returns an Observable that emits information about - * value and interval. - */ -export function timeInterval<T>(scheduler: SchedulerLike = asyncScheduler): OperatorFunction<T, TimeInterval<T>> { - return operate((source, subscriber) => { - let last = scheduler.now(); - source.subscribe( - createOperatorSubscriber(subscriber, (value) => { - const now = scheduler.now(); - const interval = now - last; - last = now; - subscriber.next(new TimeInterval(value, interval)); - }) - ); - }); -} - -// TODO(benlesh): make this an interface, export the interface, but not the implemented class, -// there's no reason users should be manually creating this type. - -export class TimeInterval<T> { - /** - * @deprecated Internal implementation detail, do not construct directly. Will be made an interface in v8. - */ - constructor(public value: T, public interval: number) {} -} diff --git a/node_modules/rxjs/src/internal/operators/timeout.ts b/node_modules/rxjs/src/internal/operators/timeout.ts deleted file mode 100644 index a2e1635..0000000 --- a/node_modules/rxjs/src/internal/operators/timeout.ts +++ /dev/null @@ -1,403 +0,0 @@ -import { asyncScheduler } from '../scheduler/async'; -import { MonoTypeOperatorFunction, SchedulerLike, OperatorFunction, ObservableInput, ObservedValueOf } from '../types'; -import { isValidDate } from '../util/isDate'; -import { Subscription } from '../Subscription'; -import { operate } from '../util/lift'; -import { Observable } from '../Observable'; -import { innerFrom } from '../observable/innerFrom'; -import { createErrorClass } from '../util/createErrorClass'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { executeSchedule } from '../util/executeSchedule'; - -export interface TimeoutConfig<T, O extends ObservableInput<unknown> = ObservableInput<T>, M = unknown> { - /** - * The time allowed between values from the source before timeout is triggered. - */ - each?: number; - - /** - * The relative time as a `number` in milliseconds, or a specific time as a `Date` object, - * by which the first value must arrive from the source before timeout is triggered. - */ - first?: number | Date; - - /** - * The scheduler to use with time-related operations within this operator. Defaults to {@link asyncScheduler} - */ - scheduler?: SchedulerLike; - - /** - * A factory used to create observable to switch to when timeout occurs. Provides - * a {@link TimeoutInfo} about the source observable's emissions and what delay or - * exact time triggered the timeout. - */ - with?: (info: TimeoutInfo<T, M>) => O; - - /** - * Optional additional metadata you can provide to code that handles - * the timeout, will be provided through the {@link TimeoutError}. - * This can be used to help identify the source of a timeout or pass along - * other information related to the timeout. - */ - meta?: M; -} - -export interface TimeoutInfo<T, M = unknown> { - /** Optional metadata that was provided to the timeout configuration. */ - readonly meta: M; - /** The number of messages seen before the timeout */ - readonly seen: number; - /** The last message seen */ - readonly lastValue: T | null; -} - -/** - * An error emitted when a timeout occurs. - */ -export interface TimeoutError<T = unknown, M = unknown> extends Error { - /** - * The information provided to the error by the timeout - * operation that created the error. Will be `null` if - * used directly in non-RxJS code with an empty constructor. - * (Note that using this constructor directly is not recommended, - * you should create your own errors) - */ - info: TimeoutInfo<T, M> | null; -} - -export interface TimeoutErrorCtor { - /** - * @deprecated Internal implementation detail. Do not construct error instances. - * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269 - */ - new <T = unknown, M = unknown>(info?: TimeoutInfo<T, M>): TimeoutError<T, M>; -} - -/** - * An error thrown by the {@link timeout} operator. - * - * Provided so users can use as a type and do quality comparisons. - * We recommend you do not subclass this or create instances of this class directly. - * If you have need of a error representing a timeout, you should - * create your own error class and use that. - * - * @see {@link timeout} - */ -export const TimeoutError: TimeoutErrorCtor = createErrorClass( - (_super) => - function TimeoutErrorImpl(this: any, info: TimeoutInfo<any> | null = null) { - _super(this); - this.message = 'Timeout has occurred'; - this.name = 'TimeoutError'; - this.info = info; - } -); - -/** - * If `with` is provided, this will return an observable that will switch to a different observable if the source - * does not push values within the specified time parameters. - * - * <span class="informal">The most flexible option for creating a timeout behavior.</span> - * - * The first thing to know about the configuration is if you do not provide a `with` property to the configuration, - * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory - * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by - * the settings in `first` and `each`. - * - * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the - * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of - * the first value from the source _only_. The timings of all subsequent values from the source will be checked - * against the time period provided by `each`, if it was provided. - * - * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of - * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if - * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first - * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first. - * - * ## Examples - * - * Emit a custom error if there is too much time between values - * - * ```ts - * import { interval, timeout, throwError } from 'rxjs'; - * - * class CustomTimeoutError extends Error { - * constructor() { - * super('It was too slow'); - * this.name = 'CustomTimeoutError'; - * } - * } - * - * const slow$ = interval(900); - * - * slow$.pipe( - * timeout({ - * each: 1000, - * with: () => throwError(() => new CustomTimeoutError()) - * }) - * ) - * .subscribe({ - * error: console.error - * }); - * ``` - * - * Switch to a faster observable if your source is slow. - * - * ```ts - * import { interval, timeout } from 'rxjs'; - * - * const slow$ = interval(900); - * const fast$ = interval(500); - * - * slow$.pipe( - * timeout({ - * each: 1000, - * with: () => fast$, - * }) - * ) - * .subscribe(console.log); - * ``` - * @param config The configuration for the timeout. - */ -export function timeout<T, O extends ObservableInput<unknown>, M = unknown>( - config: TimeoutConfig<T, O, M> & { with: (info: TimeoutInfo<T, M>) => O } -): OperatorFunction<T, T | ObservedValueOf<O>>; - -/** - * Returns an observable that will error or switch to a different observable if the source does not push values - * within the specified time parameters. - * - * <span class="informal">The most flexible option for creating a timeout behavior.</span> - * - * The first thing to know about the configuration is if you do not provide a `with` property to the configuration, - * when timeout conditions are met, this operator will emit a {@link TimeoutError}. Otherwise, it will use the factory - * function provided by `with`, and switch your subscription to the result of that. Timeout conditions are provided by - * the settings in `first` and `each`. - * - * The `first` property can be either a `Date` for a specific time, a `number` for a time period relative to the - * point of subscription, or it can be skipped. This property is to check timeout conditions for the arrival of - * the first value from the source _only_. The timings of all subsequent values from the source will be checked - * against the time period provided by `each`, if it was provided. - * - * The `each` property can be either a `number` or skipped. If a value for `each` is provided, it represents the amount of - * time the resulting observable will wait between the arrival of values from the source before timing out. Note that if - * `first` is _not_ provided, the value from `each` will be used to check timeout conditions for the arrival of the first - * value and all subsequent values. If `first` _is_ provided, `each` will only be use to check all values after the first. - * - * ### Handling TimeoutErrors - * - * If no `with` property was provided, subscriptions to the resulting observable may emit an error of {@link TimeoutError}. - * The timeout error provides useful information you can examine when you're handling the error. The most common way to handle - * the error would be with {@link catchError}, although you could use {@link tap} or just the error handler in your `subscribe` call - * directly, if your error handling is only a side effect (such as notifying the user, or logging). - * - * In this case, you would check the error for `instanceof TimeoutError` to validate that the error was indeed from `timeout`, and - * not from some other source. If it's not from `timeout`, you should probably rethrow it if you're in a `catchError`. - * - * ## Examples - * - * Emit a {@link TimeoutError} if the first value, and _only_ the first value, does not arrive within 5 seconds - * - * ```ts - * import { interval, timeout } from 'rxjs'; - * - * // A random interval that lasts between 0 and 10 seconds per tick - * const source$ = interval(Math.round(Math.random() * 10_000)); - * - * source$.pipe( - * timeout({ first: 5_000 }) - * ) - * .subscribe({ - * next: console.log, - * error: console.error - * }); - * ``` - * - * Emit a {@link TimeoutError} if the source waits longer than 5 seconds between any two values or the first value - * and subscription. - * - * ```ts - * import { timer, timeout, expand } from 'rxjs'; - * - * const getRandomTime = () => Math.round(Math.random() * 10_000); - * - * // An observable that waits a random amount of time between each delivered value - * const source$ = timer(getRandomTime()) - * .pipe(expand(() => timer(getRandomTime()))); - * - * source$ - * .pipe(timeout({ each: 5_000 })) - * .subscribe({ - * next: console.log, - * error: console.error - * }); - * ``` - * - * Emit a {@link TimeoutError} if the source does not emit before 7 seconds, _or_ if the source waits longer than - * 5 seconds between any two values after the first. - * - * ```ts - * import { timer, timeout, expand } from 'rxjs'; - * - * const getRandomTime = () => Math.round(Math.random() * 10_000); - * - * // An observable that waits a random amount of time between each delivered value - * const source$ = timer(getRandomTime()) - * .pipe(expand(() => timer(getRandomTime()))); - * - * source$ - * .pipe(timeout({ first: 7_000, each: 5_000 })) - * .subscribe({ - * next: console.log, - * error: console.error - * }); - * ``` - */ -export function timeout<T, M = unknown>(config: Omit<TimeoutConfig<T, any, M>, 'with'>): OperatorFunction<T, T>; - -/** - * Returns an observable that will error if the source does not push its first value before the specified time passed as a `Date`. - * This is functionally the same as `timeout({ first: someDate })`. - * - * <span class="informal">Errors if the first value doesn't show up before the given date and time</span> - * - *  - * - * @param first The date to at which the resulting observable will timeout if the source observable - * does not emit at least one value. - * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}. - */ -export function timeout<T>(first: Date, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>; - -/** - * Returns an observable that will error if the source does not push a value within the specified time in milliseconds. - * This is functionally the same as `timeout({ each: milliseconds })`. - * - * <span class="informal">Errors if it waits too long between any value</span> - * - *  - * - * @param each The time allowed between each pushed value from the source before the resulting observable - * will timeout. - * @param scheduler The scheduler to use. Defaults to {@link asyncScheduler}. - */ -export function timeout<T>(each: number, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>; - -/** - * - * Errors if Observable does not emit a value in given time span. - * - * <span class="informal">Timeouts on Observable that doesn't emit values fast enough.</span> - * - *  - * - * @see {@link timeoutWith} - * - * @return A function that returns an Observable that mirrors behaviour of the - * source Observable, unless timeout happens when it throws an error. - */ -export function timeout<T, O extends ObservableInput<any>, M>( - config: number | Date | TimeoutConfig<T, O, M>, - schedulerArg?: SchedulerLike -): OperatorFunction<T, T | ObservedValueOf<O>> { - // Intentionally terse code. - // If the first argument is a valid `Date`, then we use it as the `first` config. - // Otherwise, if the first argument is a `number`, then we use it as the `each` config. - // Otherwise, it can be assumed the first argument is the configuration object itself, and - // we destructure that into what we're going to use, setting important defaults as we do. - // NOTE: The default for `scheduler` will be the `scheduler` argument if it exists, or - // it will default to the `asyncScheduler`. - const { - first, - each, - with: _with = timeoutErrorFactory, - scheduler = schedulerArg ?? asyncScheduler, - meta = null!, - } = (isValidDate(config) ? { first: config } : typeof config === 'number' ? { each: config } : config) as TimeoutConfig<T, O, M>; - - if (first == null && each == null) { - // Ensure timeout was provided at runtime. - throw new TypeError('No timeout provided.'); - } - - return operate((source, subscriber) => { - // This subscription encapsulates our subscription to the - // source for this operator. We're capturing it separately, - // because if there is a `with` observable to fail over to, - // we want to unsubscribe from our original subscription, and - // hand of the subscription to that one. - let originalSourceSubscription: Subscription; - // The subscription for our timeout timer. This changes - // every time we get a new value. - let timerSubscription: Subscription; - // A bit of state we pass to our with and error factories to - // tell what the last value we saw was. - let lastValue: T | null = null; - // A bit of state we pass to the with and error factories to - // tell how many values we have seen so far. - let seen = 0; - const startTimer = (delay: number) => { - timerSubscription = executeSchedule( - subscriber, - scheduler, - () => { - try { - originalSourceSubscription.unsubscribe(); - innerFrom( - _with!({ - meta, - lastValue, - seen, - }) - ).subscribe(subscriber); - } catch (err) { - subscriber.error(err); - } - }, - delay - ); - }; - - originalSourceSubscription = source.subscribe( - createOperatorSubscriber( - subscriber, - (value: T) => { - // clear the timer so we can emit and start another one. - timerSubscription?.unsubscribe(); - seen++; - // Emit - subscriber.next((lastValue = value)); - // null | undefined are both < 0. Thanks, JavaScript. - each! > 0 && startTimer(each!); - }, - undefined, - undefined, - () => { - if (!timerSubscription?.closed) { - timerSubscription?.unsubscribe(); - } - // Be sure not to hold the last value in memory after unsubscription - // it could be quite large. - lastValue = null; - } - ) - ); - - // Intentionally terse code. - // If we've `seen` a value, that means the "first" clause was met already, if it existed. - // it also means that a timer was already started for "each" (in the next handler above). - // If `first` was provided, and it's a number, then use it. - // If `first` was provided and it's not a number, it's a Date, and we get the difference between it and "now". - // If `first` was not provided at all, then our first timer will be the value from `each`. - !seen && startTimer(first != null ? (typeof first === 'number' ? first : +first - scheduler!.now()) : each!); - }); -} - -/** - * The default function to use to emit an error when timeout occurs and a `with` function - * is not specified. - * @param info The information about the timeout to pass along to the error - */ -function timeoutErrorFactory(info: TimeoutInfo<any>): Observable<never> { - throw new TimeoutError(info); -} diff --git a/node_modules/rxjs/src/internal/operators/timeoutWith.ts b/node_modules/rxjs/src/internal/operators/timeoutWith.ts deleted file mode 100644 index 1a4d0ca..0000000 --- a/node_modules/rxjs/src/internal/operators/timeoutWith.ts +++ /dev/null @@ -1,116 +0,0 @@ -import { async } from '../scheduler/async'; -import { isValidDate } from '../util/isDate'; -import { ObservableInput, OperatorFunction, SchedulerLike } from '../types'; -import { timeout } from './timeout'; - -/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(someDate, a$, scheduler)`, use the configuration object - * `timeout({ first: someDate, with: () => a$, scheduler })`. Will be removed in v8. */ -export function timeoutWith<T, R>(dueBy: Date, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>; -/** @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(100, a$, scheduler)`, use the configuration object - * `timeout({ each: 100, with: () => a$, scheduler })`. Will be removed in v8. */ -export function timeoutWith<T, R>(waitFor: number, switchTo: ObservableInput<R>, scheduler?: SchedulerLike): OperatorFunction<T, T | R>; - -/** - * When the passed timespan elapses before the source emits any given value, it will unsubscribe from the source, - * and switch the subscription to another observable. - * - * <span class="informal">Used to switch to a different observable if your source is being slow.</span> - * - * Useful in cases where: - * - * - You want to switch to a different source that may be faster. - * - You want to notify a user that the data stream is slow. - * - You want to emit a custom error rather than the {@link TimeoutError} emitted - * by the default usage of {@link timeout}. - * - * If the first parameter is passed as Date and the time of the Date arrives before the first value arrives from the source, - * it will unsubscribe from the source and switch the subscription to another observable. - * - * <span class="informal">Use Date object to switch to a different observable if the first value doesn't arrive by a specific time.</span> - * - * Can be used to set a timeout only for the first value, however it's recommended to use the {@link timeout} operator with - * the `first` configuration to get the same effect. - * - * ## Examples - * - * Fallback to a faster observable - * - * ```ts - * import { interval, timeoutWith } from 'rxjs'; - * - * const slow$ = interval(1000); - * const faster$ = interval(500); - * - * slow$ - * .pipe(timeoutWith(900, faster$)) - * .subscribe(console.log); - * ``` - * - * Emit your own custom timeout error - * - * ```ts - * import { interval, timeoutWith, throwError } from 'rxjs'; - * - * class CustomTimeoutError extends Error { - * constructor() { - * super('It was too slow'); - * this.name = 'CustomTimeoutError'; - * } - * } - * - * const slow$ = interval(1000); - * - * slow$ - * .pipe(timeoutWith(900, throwError(() => new CustomTimeoutError()))) - * .subscribe({ - * error: err => console.error(err.message) - * }); - * ``` - * - * @see {@link timeout} - * - * @param due When passed a number, used as the time (in milliseconds) allowed between each value from the source before timeout - * is triggered. When passed a Date, used as the exact time at which the timeout will be triggered if the first value does not arrive. - * @param withObservable The observable to switch to when timeout occurs. - * @param scheduler The scheduler to use with time-related operations within this operator. Defaults to {@link asyncScheduler} - * @return A function that returns an Observable that mirrors behaviour of the - * source Observable, unless timeout happens when it starts emitting values - * from the `ObservableInput` passed as a second parameter. - * @deprecated Replaced with {@link timeout}. Instead of `timeoutWith(100, a$, scheduler)`, use {@link timeout} with the configuration - * object: `timeout({ each: 100, with: () => a$, scheduler })`. Instead of `timeoutWith(someDate, a$, scheduler)`, use {@link timeout} - * with the configuration object: `timeout({ first: someDate, with: () => a$, scheduler })`. Will be removed in v8. - */ -export function timeoutWith<T, R>( - due: number | Date, - withObservable: ObservableInput<R>, - scheduler?: SchedulerLike -): OperatorFunction<T, T | R> { - let first: number | Date | undefined; - let each: number | undefined; - let _with: () => ObservableInput<R>; - scheduler = scheduler ?? async; - - if (isValidDate(due)) { - first = due; - } else if (typeof due === 'number') { - each = due; - } - - if (withObservable) { - _with = () => withObservable; - } else { - throw new TypeError('No observable provided to switch to'); - } - - if (first == null && each == null) { - // Ensure timeout was provided at runtime. - throw new TypeError('No timeout provided.'); - } - - return timeout<T, ObservableInput<R>>({ - first, - each, - scheduler, - with: _with, - }); -} diff --git a/node_modules/rxjs/src/internal/operators/timestamp.ts b/node_modules/rxjs/src/internal/operators/timestamp.ts deleted file mode 100644 index bb388de..0000000 --- a/node_modules/rxjs/src/internal/operators/timestamp.ts +++ /dev/null @@ -1,39 +0,0 @@ -import { OperatorFunction, TimestampProvider, Timestamp } from '../types'; -import { dateTimestampProvider } from '../scheduler/dateTimestampProvider'; -import { map } from './map'; - -/** - * Attaches a timestamp to each item emitted by an observable indicating when it was emitted - * - * The `timestamp` operator maps the *source* observable stream to an object of type - * `{value: T, timestamp: R}`. The properties are generically typed. The `value` property contains the value - * and type of the *source* observable. The `timestamp` is generated by the schedulers `now` function. By - * default, it uses the `asyncScheduler` which simply returns `Date.now()` (milliseconds since 1970/01/01 - * 00:00:00:000) and therefore is of type `number`. - * - *  - * - * ## Example - * - * In this example there is a timestamp attached to the document's click events - * - * ```ts - * import { fromEvent, timestamp } from 'rxjs'; - * - * const clickWithTimestamp = fromEvent(document, 'click').pipe( - * timestamp() - * ); - * - * // Emits data of type { value: PointerEvent, timestamp: number } - * clickWithTimestamp.subscribe(data => { - * console.log(data); - * }); - * ``` - * - * @param timestampProvider An object with a `now()` method used to get the current timestamp. - * @return A function that returns an Observable that attaches a timestamp to - * each item emitted by the source Observable indicating when it was emitted. - */ -export function timestamp<T>(timestampProvider: TimestampProvider = dateTimestampProvider): OperatorFunction<T, Timestamp<T>> { - return map((value: T) => ({ value, timestamp: timestampProvider.now() })); -} diff --git a/node_modules/rxjs/src/internal/operators/toArray.ts b/node_modules/rxjs/src/internal/operators/toArray.ts deleted file mode 100644 index 2678472..0000000 --- a/node_modules/rxjs/src/internal/operators/toArray.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { reduce } from './reduce'; -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; - -const arrReducer = (arr: any[], value: any) => (arr.push(value), arr); - -/** - * Collects all source emissions and emits them as an array when the source completes. - * - * <span class="informal">Get all values inside an array when the source completes</span> - * - *  - * - * `toArray` will wait until the source Observable completes before emitting - * the array containing all emissions. When the source Observable errors no - * array will be emitted. - * - * ## Example - * - * ```ts - * import { interval, take, toArray } from 'rxjs'; - * - * const source = interval(1000); - * const example = source.pipe( - * take(10), - * toArray() - * ); - * - * example.subscribe(value => console.log(value)); - * - * // output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - * ``` - * - * @return A function that returns an Observable that emits an array of items - * emitted by the source Observable when source completes. - */ -export function toArray<T>(): OperatorFunction<T, T[]> { - // Because arrays are mutable, and we're mutating the array in this - // reducer process, we have to encapsulate the creation of the initial - // array within this `operate` function. - return operate((source, subscriber) => { - reduce(arrReducer, [] as T[])(source).subscribe(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/window.ts b/node_modules/rxjs/src/internal/operators/window.ts deleted file mode 100644 index b8250cb..0000000 --- a/node_modules/rxjs/src/internal/operators/window.ts +++ /dev/null @@ -1,98 +0,0 @@ -import { Observable } from '../Observable'; -import { OperatorFunction, ObservableInput } from '../types'; -import { Subject } from '../Subject'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { noop } from '../util/noop'; -import { innerFrom } from '../observable/innerFrom'; - -/** - * Branch out the source Observable values as a nested Observable whenever - * `windowBoundaries` emits. - * - * <span class="informal">It's like {@link buffer}, but emits a nested Observable - * instead of an array.</span> - * - *  - * - * Returns an Observable that emits windows of items it collects from the source - * Observable. The output Observable emits connected, non-overlapping - * windows. It emits the current window and opens a new one whenever the - * `windowBoundaries` emits an item. `windowBoundaries` can be any type that - * `ObservableInput` accepts. It internally gets converted to an Observable. - * Because each window is an Observable, the output is a higher-order Observable. - * - * ## Example - * - * In every window of 1 second each, emit at most 2 click events - * - * ```ts - * import { fromEvent, interval, window, map, take, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const sec = interval(1000); - * const result = clicks.pipe( - * window(sec), - * map(win => win.pipe(take(2))), // take at most 2 emissions from each window - * mergeAll() // flatten the Observable-of-Observables - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link windowCount} - * @see {@link windowTime} - * @see {@link windowToggle} - * @see {@link windowWhen} - * @see {@link buffer} - * - * @param windowBoundaries An `ObservableInput` that completes the - * previous window and starts a new window. - * @return A function that returns an Observable of windows, which are - * Observables emitting values of the source Observable. - */ -export function window<T>(windowBoundaries: ObservableInput<any>): OperatorFunction<T, Observable<T>> { - return operate((source, subscriber) => { - let windowSubject: Subject<T> = new Subject<T>(); - - subscriber.next(windowSubject.asObservable()); - - const errorHandler = (err: any) => { - windowSubject.error(err); - subscriber.error(err); - }; - - // Subscribe to our source - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => windowSubject?.next(value), - () => { - windowSubject.complete(); - subscriber.complete(); - }, - errorHandler - ) - ); - - // Subscribe to the window boundaries. - innerFrom(windowBoundaries).subscribe( - createOperatorSubscriber( - subscriber, - () => { - windowSubject.complete(); - subscriber.next((windowSubject = new Subject())); - }, - noop, - errorHandler - ) - ); - - return () => { - // Unsubscribing the subject ensures that anyone who has captured - // a reference to this window that tries to use it after it can - // no longer get values from the source will get an ObjectUnsubscribedError. - windowSubject?.unsubscribe(); - windowSubject = null!; - }; - }); -} diff --git a/node_modules/rxjs/src/internal/operators/windowCount.ts b/node_modules/rxjs/src/internal/operators/windowCount.ts deleted file mode 100644 index cf24e1b..0000000 --- a/node_modules/rxjs/src/internal/operators/windowCount.ts +++ /dev/null @@ -1,129 +0,0 @@ -import { Observable } from '../Observable'; -import { Subject } from '../Subject'; -import { OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; - -/** - * Branch out the source Observable values as a nested Observable with each - * nested Observable emitting at most `windowSize` values. - * - * <span class="informal">It's like {@link bufferCount}, but emits a nested - * Observable instead of an array.</span> - * - *  - * - * Returns an Observable that emits windows of items it collects from the source - * Observable. The output Observable emits windows every `startWindowEvery` - * items, each containing no more than `windowSize` items. When the source - * Observable completes or encounters an error, the output Observable emits - * the current window and propagates the notification from the source - * Observable. If `startWindowEvery` is not provided, then new windows are - * started immediately at the start of the source and when each window completes - * with size `windowSize`. - * - * ## Examples - * - * Ignore every 3rd click event, starting from the first one - * - * ```ts - * import { fromEvent, windowCount, map, skip, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * windowCount(3), - * map(win => win.pipe(skip(1))), // skip first of every 3 clicks - * mergeAll() // flatten the Observable-of-Observables - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * Ignore every 3rd click event, starting from the third one - * - * ```ts - * import { fromEvent, windowCount, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * windowCount(2, 3), - * mergeAll() // flatten the Observable-of-Observables - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link window} - * @see {@link windowTime} - * @see {@link windowToggle} - * @see {@link windowWhen} - * @see {@link bufferCount} - * - * @param windowSize The maximum number of values emitted by each window. - * @param startWindowEvery Interval at which to start a new window. For example - * if `startWindowEvery` is `2`, then a new window will be started on every - * other value from the source. A new window is started at the beginning of the - * source by default. - * @return A function that returns an Observable of windows, which in turn are - * Observable of values. - */ -export function windowCount<T>(windowSize: number, startWindowEvery: number = 0): OperatorFunction<T, Observable<T>> { - const startEvery = startWindowEvery > 0 ? startWindowEvery : windowSize; - - return operate((source, subscriber) => { - let windows = [new Subject<T>()]; - let starts: number[] = []; - let count = 0; - - // Open the first window. - subscriber.next(windows[0].asObservable()); - - source.subscribe( - createOperatorSubscriber( - subscriber, - (value: T) => { - // Emit the value through all current windows. - // We don't need to create a new window yet, we - // do that as soon as we close one. - for (const window of windows) { - window.next(value); - } - // Here we're using the size of the window array to figure - // out if the oldest window has emitted enough values. We can do this - // because the size of the window array is a function of the values - // seen by the subscription. If it's time to close it, we complete - // it and remove it. - const c = count - windowSize + 1; - if (c >= 0 && c % startEvery === 0) { - windows.shift()!.complete(); - } - - // Look to see if the next count tells us it's time to open a new window. - // TODO: We need to figure out if this really makes sense. We're technically - // emitting windows *before* we have a value to emit them for. It's probably - // more expected that we should be emitting the window when the start - // count is reached -- not before. - if (++count % startEvery === 0) { - const window = new Subject<T>(); - windows.push(window); - subscriber.next(window.asObservable()); - } - }, - () => { - while (windows.length > 0) { - windows.shift()!.complete(); - } - subscriber.complete(); - }, - (err) => { - while (windows.length > 0) { - windows.shift()!.error(err); - } - subscriber.error(err); - }, - () => { - starts = null!; - windows = null!; - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/windowTime.ts b/node_modules/rxjs/src/internal/operators/windowTime.ts deleted file mode 100644 index b54656b..0000000 --- a/node_modules/rxjs/src/internal/operators/windowTime.ts +++ /dev/null @@ -1,207 +0,0 @@ -import { Subject } from '../Subject'; -import { asyncScheduler } from '../scheduler/async'; -import { Observable } from '../Observable'; -import { Subscription } from '../Subscription'; -import { Observer, OperatorFunction, SchedulerLike } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { arrRemove } from '../util/arrRemove'; -import { popScheduler } from '../util/args'; -import { executeSchedule } from '../util/executeSchedule'; - -export function windowTime<T>(windowTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, Observable<T>>; -export function windowTime<T>( - windowTimeSpan: number, - windowCreationInterval: number, - scheduler?: SchedulerLike -): OperatorFunction<T, Observable<T>>; -export function windowTime<T>( - windowTimeSpan: number, - windowCreationInterval: number | null | void, - maxWindowSize: number, - scheduler?: SchedulerLike -): OperatorFunction<T, Observable<T>>; - -/** - * Branch out the source Observable values as a nested Observable periodically - * in time. - * - * <span class="informal">It's like {@link bufferTime}, but emits a nested - * Observable instead of an array.</span> - * - *  - * - * Returns an Observable that emits windows of items it collects from the source - * Observable. The output Observable starts a new window periodically, as - * determined by the `windowCreationInterval` argument. It emits each window - * after a fixed timespan, specified by the `windowTimeSpan` argument. When the - * source Observable completes or encounters an error, the output Observable - * emits the current window and propagates the notification from the source - * Observable. If `windowCreationInterval` is not provided, the output - * Observable starts a new window when the previous window of duration - * `windowTimeSpan` completes. If `maxWindowCount` is provided, each window - * will emit at most fixed number of values. Window will complete immediately - * after emitting last value and next one still will open as specified by - * `windowTimeSpan` and `windowCreationInterval` arguments. - * - * ## Examples - * - * In every window of 1 second each, emit at most 2 click events - * - * ```ts - * import { fromEvent, windowTime, map, take, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * windowTime(1000), - * map(win => win.pipe(take(2))), // take at most 2 emissions from each window - * mergeAll() // flatten the Observable-of-Observables - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * Every 5 seconds start a window 1 second long, and emit at most 2 click events per window - * - * ```ts - * import { fromEvent, windowTime, map, take, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * windowTime(1000, 5000), - * map(win => win.pipe(take(2))), // take at most 2 emissions from each window - * mergeAll() // flatten the Observable-of-Observables - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * Same as example above but with `maxWindowCount` instead of `take` - * - * ```ts - * import { fromEvent, windowTime, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * windowTime(1000, 5000, 2), // take at most 2 emissions from each window - * mergeAll() // flatten the Observable-of-Observables - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link window} - * @see {@link windowCount} - * @see {@link windowToggle} - * @see {@link windowWhen} - * @see {@link bufferTime} - * - * @param windowTimeSpan The amount of time, in milliseconds, to fill each window. - * @param windowCreationInterval The interval at which to start new - * windows. - * @param maxWindowSize Max number of - * values each window can emit before completion. - * @param scheduler The scheduler on which to schedule the - * intervals that determine window boundaries. - * @return A function that returns an Observable of windows, which in turn are - * Observables. - */ -export function windowTime<T>(windowTimeSpan: number, ...otherArgs: any[]): OperatorFunction<T, Observable<T>> { - const scheduler = popScheduler(otherArgs) ?? asyncScheduler; - const windowCreationInterval = (otherArgs[0] as number) ?? null; - const maxWindowSize = (otherArgs[1] as number) || Infinity; - - return operate((source, subscriber) => { - // The active windows, their related subscriptions, and removal functions. - let windowRecords: WindowRecord<T>[] | null = []; - // If true, it means that every time we close a window, we want to start a new window. - // This is only really used for when *just* the time span is passed. - let restartOnClose = false; - - const closeWindow = (record: { window: Subject<T>; subs: Subscription }) => { - const { window, subs } = record; - window.complete(); - subs.unsubscribe(); - arrRemove(windowRecords, record); - restartOnClose && startWindow(); - }; - - /** - * Called every time we start a new window. This also does - * the work of scheduling the job to close the window. - */ - const startWindow = () => { - if (windowRecords) { - const subs = new Subscription(); - subscriber.add(subs); - const window = new Subject<T>(); - const record = { - window, - subs, - seen: 0, - }; - windowRecords.push(record); - subscriber.next(window.asObservable()); - executeSchedule(subs, scheduler, () => closeWindow(record), windowTimeSpan); - } - }; - - if (windowCreationInterval !== null && windowCreationInterval >= 0) { - // The user passed both a windowTimeSpan (required), and a creation interval - // That means we need to start new window on the interval, and those windows need - // to wait the required time span before completing. - executeSchedule(subscriber, scheduler, startWindow, windowCreationInterval, true); - } else { - restartOnClose = true; - } - - startWindow(); - - /** - * We need to loop over a copy of the window records several times in this operator. - * This is to save bytes over the wire more than anything. - * The reason we copy the array is that reentrant code could mutate the array while - * we are iterating over it. - */ - const loop = (cb: (record: WindowRecord<T>) => void) => windowRecords!.slice().forEach(cb); - - /** - * Used to notify all of the windows and the subscriber in the same way - * in the error and complete handlers. - */ - const terminate = (cb: (consumer: Observer<any>) => void) => { - loop(({ window }) => cb(window)); - cb(subscriber); - subscriber.unsubscribe(); - }; - - source.subscribe( - createOperatorSubscriber( - subscriber, - (value: T) => { - // Notify all windows of the value. - loop((record) => { - record.window.next(value); - // If the window is over the max size, we need to close it. - maxWindowSize <= ++record.seen && closeWindow(record); - }); - }, - // Complete the windows and the downstream subscriber and clean up. - () => terminate((consumer) => consumer.complete()), - // Notify the windows and the downstream subscriber of the error and clean up. - (err) => terminate((consumer) => consumer.error(err)) - ) - ); - - // Additional finalization. This will be called when the - // destination tears down. Other finalizations are registered implicitly - // above via subscription. - return () => { - // Ensure that the buffer is released. - windowRecords = null!; - }; - }); -} - -interface WindowRecord<T> { - seen: number; - window: Subject<T>; - subs: Subscription; -} diff --git a/node_modules/rxjs/src/internal/operators/windowToggle.ts b/node_modules/rxjs/src/internal/operators/windowToggle.ts deleted file mode 100644 index a17bef5..0000000 --- a/node_modules/rxjs/src/internal/operators/windowToggle.ts +++ /dev/null @@ -1,132 +0,0 @@ -import { Observable } from '../Observable'; -import { Subject } from '../Subject'; -import { Subscription } from '../Subscription'; -import { ObservableInput, OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { innerFrom } from '../observable/innerFrom'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { noop } from '../util/noop'; -import { arrRemove } from '../util/arrRemove'; - -/** - * Branch out the source Observable values as a nested Observable starting from - * an emission from `openings` and ending when the output of `closingSelector` - * emits. - * - * <span class="informal">It's like {@link bufferToggle}, but emits a nested - * Observable instead of an array.</span> - * - *  - * - * Returns an Observable that emits windows of items it collects from the source - * Observable. The output Observable emits windows that contain those items - * emitted by the source Observable between the time when the `openings` - * Observable emits an item and when the Observable returned by - * `closingSelector` emits an item. - * - * ## Example - * - * Every other second, emit the click events from the next 500ms - * - * ```ts - * import { fromEvent, interval, windowToggle, EMPTY, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const openings = interval(1000); - * const result = clicks.pipe( - * windowToggle(openings, i => i % 2 ? interval(500) : EMPTY), - * mergeAll() - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link window} - * @see {@link windowCount} - * @see {@link windowTime} - * @see {@link windowWhen} - * @see {@link bufferToggle} - * - * @param openings An observable of notifications to start new windows. - * @param closingSelector A function that takes the value emitted by the - * `openings` observable and returns an Observable, which, when it emits a next - * notification, signals that the associated window should complete. - * @return A function that returns an Observable of windows, which in turn are - * Observables. - */ -export function windowToggle<T, O>( - openings: ObservableInput<O>, - closingSelector: (openValue: O) => ObservableInput<any> -): OperatorFunction<T, Observable<T>> { - return operate((source, subscriber) => { - const windows: Subject<T>[] = []; - - const handleError = (err: any) => { - while (0 < windows.length) { - windows.shift()!.error(err); - } - subscriber.error(err); - }; - - innerFrom(openings).subscribe( - createOperatorSubscriber( - subscriber, - (openValue) => { - const window = new Subject<T>(); - windows.push(window); - const closingSubscription = new Subscription(); - const closeWindow = () => { - arrRemove(windows, window); - window.complete(); - closingSubscription.unsubscribe(); - }; - - let closingNotifier: Observable<any>; - try { - closingNotifier = innerFrom(closingSelector(openValue)); - } catch (err) { - handleError(err); - return; - } - - subscriber.next(window.asObservable()); - - closingSubscription.add(closingNotifier.subscribe(createOperatorSubscriber(subscriber, closeWindow, noop, handleError))); - }, - noop - ) - ); - - // Subscribe to the source to get things started. - source.subscribe( - createOperatorSubscriber( - subscriber, - (value: T) => { - // Copy the windows array before we emit to - // make sure we don't have issues with reentrant code. - const windowsCopy = windows.slice(); - for (const window of windowsCopy) { - window.next(value); - } - }, - () => { - // Complete all of our windows before we complete. - while (0 < windows.length) { - windows.shift()!.complete(); - } - subscriber.complete(); - }, - handleError, - () => { - // Add this finalization so that all window subjects are - // disposed of. This way, if a user tries to subscribe - // to a window *after* the outer subscription has been unsubscribed, - // they will get an error, instead of waiting forever to - // see if a value arrives. - while (0 < windows.length) { - windows.shift()!.unsubscribe(); - } - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/windowWhen.ts b/node_modules/rxjs/src/internal/operators/windowWhen.ts deleted file mode 100644 index ec31be0..0000000 --- a/node_modules/rxjs/src/internal/operators/windowWhen.ts +++ /dev/null @@ -1,125 +0,0 @@ -import { Subscriber } from '../Subscriber'; -import { Observable } from '../Observable'; -import { Subject } from '../Subject'; -import { ObservableInput, OperatorFunction } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; - -/** - * Branch out the source Observable values as a nested Observable using a - * factory function of closing Observables to determine when to start a new - * window. - * - * <span class="informal">It's like {@link bufferWhen}, but emits a nested - * Observable instead of an array.</span> - * - *  - * - * Returns an Observable that emits windows of items it collects from the source - * Observable. The output Observable emits connected, non-overlapping windows. - * It emits the current window and opens a new one whenever the Observable - * produced by the specified `closingSelector` function emits an item. The first - * window is opened immediately when subscribing to the output Observable. - * - * ## Example - * - * Emit only the first two clicks events in every window of [1-5] random seconds - * - * ```ts - * import { fromEvent, windowWhen, interval, map, take, mergeAll } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const result = clicks.pipe( - * windowWhen(() => interval(1000 + Math.random() * 4000)), - * map(win => win.pipe(take(2))), // take at most 2 emissions from each window - * mergeAll() // flatten the Observable-of-Observables - * ); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link window} - * @see {@link windowCount} - * @see {@link windowTime} - * @see {@link windowToggle} - * @see {@link bufferWhen} - * - * @param closingSelector A function that takes no arguments and returns an - * {@link ObservableInput} (that gets converted to Observable) that signals - * (on either `next` or `complete`) when to close the previous window and - * start a new one. - * @return A function that returns an Observable of windows, which in turn are - * Observables. - */ -export function windowWhen<T>(closingSelector: () => ObservableInput<any>): OperatorFunction<T, Observable<T>> { - return operate((source, subscriber) => { - let window: Subject<T> | null; - let closingSubscriber: Subscriber<any> | undefined; - - /** - * When we get an error, we have to notify both the - * destination subscriber and the window. - */ - const handleError = (err: any) => { - window!.error(err); - subscriber.error(err); - }; - - /** - * Called every time we need to open a window. - * Recursive, as it will start the closing notifier, which - * inevitably *should* call openWindow -- but may not if - * it is a "never" observable. - */ - const openWindow = () => { - // We need to clean up our closing subscription, - // we only cared about the first next or complete notification. - closingSubscriber?.unsubscribe(); - - // Close our window before starting a new one. - window?.complete(); - - // Start the new window. - window = new Subject<T>(); - subscriber.next(window.asObservable()); - - // Get our closing notifier. - let closingNotifier: Observable<any>; - try { - closingNotifier = innerFrom(closingSelector()); - } catch (err) { - handleError(err); - return; - } - - // Subscribe to the closing notifier, be sure - // to capture the subscriber (aka Subscription) - // so we can clean it up when we close the window - // and open a new one. - closingNotifier.subscribe((closingSubscriber = createOperatorSubscriber(subscriber, openWindow, openWindow, handleError))); - }; - - // Start the first window. - openWindow(); - - // Subscribe to the source - source.subscribe( - createOperatorSubscriber( - subscriber, - (value) => window!.next(value), - () => { - // The source completed, close the window and complete. - window!.complete(); - subscriber.complete(); - }, - handleError, - () => { - // Be sure to clean up our closing subscription - // when this tears down. - closingSubscriber?.unsubscribe(); - window = null!; - } - ) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/withLatestFrom.ts b/node_modules/rxjs/src/internal/operators/withLatestFrom.ts deleted file mode 100644 index 6cd7e4a..0000000 --- a/node_modules/rxjs/src/internal/operators/withLatestFrom.ts +++ /dev/null @@ -1,111 +0,0 @@ -import { OperatorFunction, ObservableInputTuple } from '../types'; -import { operate } from '../util/lift'; -import { createOperatorSubscriber } from './OperatorSubscriber'; -import { innerFrom } from '../observable/innerFrom'; -import { identity } from '../util/identity'; -import { noop } from '../util/noop'; -import { popResultSelector } from '../util/args'; - -export function withLatestFrom<T, O extends unknown[]>(...inputs: [...ObservableInputTuple<O>]): OperatorFunction<T, [T, ...O]>; - -export function withLatestFrom<T, O extends unknown[], R>( - ...inputs: [...ObservableInputTuple<O>, (...value: [T, ...O]) => R] -): OperatorFunction<T, R>; - -/** - * Combines the source Observable with other Observables to create an Observable - * whose values are calculated from the latest values of each, only when the - * source emits. - * - * <span class="informal">Whenever the source Observable emits a value, it - * computes a formula using that value plus the latest values from other input - * Observables, then emits the output of that formula.</span> - * - *  - * - * `withLatestFrom` combines each value from the source Observable (the - * instance) with the latest values from the other input Observables only when - * the source emits a value, optionally using a `project` function to determine - * the value to be emitted on the output Observable. All input Observables must - * emit at least one value before the output Observable will emit a value. - * - * ## Example - * - * On every click event, emit an array with the latest timer event plus the click event - * - * ```ts - * import { fromEvent, interval, withLatestFrom } from 'rxjs'; - * - * const clicks = fromEvent(document, 'click'); - * const timer = interval(1000); - * const result = clicks.pipe(withLatestFrom(timer)); - * result.subscribe(x => console.log(x)); - * ``` - * - * @see {@link combineLatest} - * - * @param inputs An input Observable to combine with the source Observable. More - * than one input Observables may be given as argument. If the last parameter is - * a function, it will be used as a projection function for combining values - * together. When the function is called, it receives all values in order of the - * Observables passed, where the first parameter is a value from the source - * Observable. (e.g. - * `a.pipe(withLatestFrom(b, c), map(([a1, b1, c1]) => a1 + b1 + c1))`). If this - * is not passed, arrays will be emitted on the output Observable. - * @return A function that returns an Observable of projected values from the - * most recent values from each input Observable, or an array of the most - * recent values from each input Observable. - */ -export function withLatestFrom<T, R>(...inputs: any[]): OperatorFunction<T, R | any[]> { - const project = popResultSelector(inputs) as ((...args: any[]) => R) | undefined; - - return operate((source, subscriber) => { - const len = inputs.length; - const otherValues = new Array(len); - // An array of whether or not the other sources have emitted. Matched with them by index. - // TODO: At somepoint, we should investigate the performance implications here, and look - // into using a `Set()` and checking the `size` to see if we're ready. - let hasValue = inputs.map(() => false); - // Flipped true when we have at least one value from all other sources and - // we are ready to start emitting values. - let ready = false; - - // Other sources. Note that here we are not checking `subscriber.closed`, - // this causes all inputs to be subscribed to, even if nothing can be emitted - // from them. This is an important distinction because subscription constitutes - // a side-effect. - for (let i = 0; i < len; i++) { - innerFrom(inputs[i]).subscribe( - createOperatorSubscriber( - subscriber, - (value) => { - otherValues[i] = value; - if (!ready && !hasValue[i]) { - // If we're not ready yet, flag to show this observable has emitted. - hasValue[i] = true; - // Intentionally terse code. - // If all of our other observables have emitted, set `ready` to `true`, - // so we know we can start emitting values, then clean up the `hasValue` array, - // because we don't need it anymore. - (ready = hasValue.every(identity)) && (hasValue = null!); - } - }, - // Completing one of the other sources has - // no bearing on the completion of our result. - noop - ) - ); - } - - // Source subscription - source.subscribe( - createOperatorSubscriber(subscriber, (value) => { - if (ready) { - // We have at least one value from the other sources. Go ahead and emit. - const values = [value, ...otherValues]; - subscriber.next(project ? project(...values) : values); - } - }) - ); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/zip.ts b/node_modules/rxjs/src/internal/operators/zip.ts deleted file mode 100644 index f8c2f68..0000000 --- a/node_modules/rxjs/src/internal/operators/zip.ts +++ /dev/null @@ -1,26 +0,0 @@ -import { zip as zipStatic } from '../observable/zip'; -import { ObservableInput, ObservableInputTuple, OperatorFunction, Cons } from '../types'; -import { operate } from '../util/lift'; - -/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */ -export function zip<T, A extends readonly unknown[]>(otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>; -/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */ -export function zip<T, A extends readonly unknown[], R>( - otherInputsAndProject: [...ObservableInputTuple<A>], - project: (...values: Cons<T, A>) => R -): OperatorFunction<T, R>; -/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */ -export function zip<T, A extends readonly unknown[]>(...otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>>; -/** @deprecated Replaced with {@link zipWith}. Will be removed in v8. */ -export function zip<T, A extends readonly unknown[], R>( - ...otherInputsAndProject: [...ObservableInputTuple<A>, (...values: Cons<T, A>) => R] -): OperatorFunction<T, R>; - -/** - * @deprecated Replaced with {@link zipWith}. Will be removed in v8. - */ -export function zip<T, R>(...sources: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, any> { - return operate((source, subscriber) => { - zipStatic(source as ObservableInput<any>, ...(sources as Array<ObservableInput<any>>)).subscribe(subscriber); - }); -} diff --git a/node_modules/rxjs/src/internal/operators/zipAll.ts b/node_modules/rxjs/src/internal/operators/zipAll.ts deleted file mode 100644 index 697cff5..0000000 --- a/node_modules/rxjs/src/internal/operators/zipAll.ts +++ /dev/null @@ -1,20 +0,0 @@ -import { OperatorFunction, ObservableInput } from '../types'; -import { zip } from '../observable/zip'; -import { joinAllInternals } from './joinAllInternals'; - -/** - * Collects all observable inner sources from the source, once the source completes, - * it will subscribe to all inner sources, combining their values by index and emitting - * them. - * - * @see {@link zipWith} - * @see {@link zip} - */ -export function zipAll<T>(): OperatorFunction<ObservableInput<T>, T[]>; -export function zipAll<T>(): OperatorFunction<any, T[]>; -export function zipAll<T, R>(project: (...values: T[]) => R): OperatorFunction<ObservableInput<T>, R>; -export function zipAll<R>(project: (...values: Array<any>) => R): OperatorFunction<any, R>; - -export function zipAll<T, R>(project?: (...values: T[]) => R) { - return joinAllInternals(zip, project); -} diff --git a/node_modules/rxjs/src/internal/operators/zipWith.ts b/node_modules/rxjs/src/internal/operators/zipWith.ts deleted file mode 100644 index 22eaad7..0000000 --- a/node_modules/rxjs/src/internal/operators/zipWith.ts +++ /dev/null @@ -1,29 +0,0 @@ -import { ObservableInputTuple, OperatorFunction, Cons } from '../types'; -import { zip } from './zip'; - -/** - * Subscribes to the source, and the observable inputs provided as arguments, and combines their values, by index, into arrays. - * - * What is meant by "combine by index": The first value from each will be made into a single array, then emitted, - * then the second value from each will be combined into a single array and emitted, then the third value - * from each will be combined into a single array and emitted, and so on. - * - * This will continue until it is no longer able to combine values of the same index into an array. - * - * After the last value from any one completed source is emitted in an array, the resulting observable will complete, - * as there is no way to continue "zipping" values together by index. - * - * Use-cases for this operator are limited. There are memory concerns if one of the streams is emitting - * values at a much faster rate than the others. Usage should likely be limited to streams that emit - * at a similar pace, or finite streams of known length. - * - * In many cases, authors want `combineLatestWith` and not `zipWith`. - * - * @param otherInputs other observable inputs to collate values from. - * @return A function that returns an Observable that emits items by index - * combined from the source Observable and provided Observables, in form of an - * array. - */ -export function zipWith<T, A extends readonly unknown[]>(...otherInputs: [...ObservableInputTuple<A>]): OperatorFunction<T, Cons<T, A>> { - return zip(...otherInputs); -} diff --git a/node_modules/rxjs/src/internal/scheduled/scheduleArray.ts b/node_modules/rxjs/src/internal/scheduled/scheduleArray.ts deleted file mode 100644 index ea8fa24..0000000 --- a/node_modules/rxjs/src/internal/scheduled/scheduleArray.ts +++ /dev/null @@ -1,27 +0,0 @@ -import { Observable } from '../Observable'; -import { SchedulerLike } from '../types'; - -export function scheduleArray<T>(input: ArrayLike<T>, scheduler: SchedulerLike) { - return new Observable<T>((subscriber) => { - // The current array index. - let i = 0; - // Start iterating over the array like on a schedule. - return scheduler.schedule(function () { - if (i === input.length) { - // If we have hit the end of the array like in the - // previous job, we can complete. - subscriber.complete(); - } else { - // Otherwise let's next the value at the current index, - // then increment our index. - subscriber.next(input[i++]); - // If the last emission didn't cause us to close the subscriber - // (via take or some side effect), reschedule the job and we'll - // make another pass. - if (!subscriber.closed) { - this.schedule(); - } - } - }); - }); -} diff --git a/node_modules/rxjs/src/internal/scheduled/scheduleAsyncIterable.ts b/node_modules/rxjs/src/internal/scheduled/scheduleAsyncIterable.ts deleted file mode 100644 index daa0346..0000000 --- a/node_modules/rxjs/src/internal/scheduled/scheduleAsyncIterable.ts +++ /dev/null @@ -1,31 +0,0 @@ -import { SchedulerLike } from '../types'; -import { Observable } from '../Observable'; -import { executeSchedule } from '../util/executeSchedule'; - -export function scheduleAsyncIterable<T>(input: AsyncIterable<T>, scheduler: SchedulerLike) { - if (!input) { - throw new Error('Iterable cannot be null'); - } - return new Observable<T>((subscriber) => { - executeSchedule(subscriber, scheduler, () => { - const iterator = input[Symbol.asyncIterator](); - executeSchedule( - subscriber, - scheduler, - () => { - iterator.next().then((result) => { - if (result.done) { - // This will remove the subscriptions from - // the parent subscription. - subscriber.complete(); - } else { - subscriber.next(result.value); - } - }); - }, - 0, - true - ); - }); - }); -} diff --git a/node_modules/rxjs/src/internal/scheduled/scheduleIterable.ts b/node_modules/rxjs/src/internal/scheduled/scheduleIterable.ts deleted file mode 100644 index aa1459d..0000000 --- a/node_modules/rxjs/src/internal/scheduled/scheduleIterable.ts +++ /dev/null @@ -1,60 +0,0 @@ -import { Observable } from '../Observable'; -import { SchedulerLike } from '../types'; -import { iterator as Symbol_iterator } from '../symbol/iterator'; -import { isFunction } from '../util/isFunction'; -import { executeSchedule } from '../util/executeSchedule'; - -/** - * Used in {@link scheduled} to create an observable from an Iterable. - * @param input The iterable to create an observable from - * @param scheduler The scheduler to use - */ -export function scheduleIterable<T>(input: Iterable<T>, scheduler: SchedulerLike) { - return new Observable<T>((subscriber) => { - let iterator: Iterator<T, T>; - - // Schedule the initial creation of the iterator from - // the iterable. This is so the code in the iterable is - // not called until the scheduled job fires. - executeSchedule(subscriber, scheduler, () => { - // Create the iterator. - iterator = (input as any)[Symbol_iterator](); - - executeSchedule( - subscriber, - scheduler, - () => { - let value: T; - let done: boolean | undefined; - try { - // Pull the value out of the iterator - ({ value, done } = iterator.next()); - } catch (err) { - // We got an error while pulling from the iterator - subscriber.error(err); - return; - } - - if (done) { - // If it is "done" we just complete. This mimics the - // behavior of JavaScript's `for..of` consumption of - // iterables, which will not emit the value from an iterator - // result of `{ done: true: value: 'here' }`. - subscriber.complete(); - } else { - // The iterable is not done, emit the value. - subscriber.next(value); - } - }, - 0, - true - ); - }); - - // During finalization, if we see this iterator has a `return` method, - // then we know it is a Generator, and not just an Iterator. So we call - // the `return()` function. This will ensure that any `finally { }` blocks - // inside of the generator we can hit will be hit properly. - return () => isFunction(iterator?.return) && iterator.return(); - }); -} diff --git a/node_modules/rxjs/src/internal/scheduled/scheduleObservable.ts b/node_modules/rxjs/src/internal/scheduled/scheduleObservable.ts deleted file mode 100644 index 29ba3b5..0000000 --- a/node_modules/rxjs/src/internal/scheduled/scheduleObservable.ts +++ /dev/null @@ -1,8 +0,0 @@ -import { innerFrom } from '../observable/innerFrom'; -import { observeOn } from '../operators/observeOn'; -import { subscribeOn } from '../operators/subscribeOn'; -import { InteropObservable, SchedulerLike } from '../types'; - -export function scheduleObservable<T>(input: InteropObservable<T>, scheduler: SchedulerLike) { - return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler)); -} diff --git a/node_modules/rxjs/src/internal/scheduled/schedulePromise.ts b/node_modules/rxjs/src/internal/scheduled/schedulePromise.ts deleted file mode 100644 index f1211d0..0000000 --- a/node_modules/rxjs/src/internal/scheduled/schedulePromise.ts +++ /dev/null @@ -1,8 +0,0 @@ -import { innerFrom } from '../observable/innerFrom'; -import { observeOn } from '../operators/observeOn'; -import { subscribeOn } from '../operators/subscribeOn'; -import { SchedulerLike } from '../types'; - -export function schedulePromise<T>(input: PromiseLike<T>, scheduler: SchedulerLike) { - return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler)); -} diff --git a/node_modules/rxjs/src/internal/scheduled/scheduleReadableStreamLike.ts b/node_modules/rxjs/src/internal/scheduled/scheduleReadableStreamLike.ts deleted file mode 100644 index d742f10..0000000 --- a/node_modules/rxjs/src/internal/scheduled/scheduleReadableStreamLike.ts +++ /dev/null @@ -1,8 +0,0 @@ -import { SchedulerLike, ReadableStreamLike } from '../types'; -import { Observable } from '../Observable'; -import { scheduleAsyncIterable } from './scheduleAsyncIterable'; -import { readableStreamLikeToAsyncGenerator } from '../util/isReadableStreamLike'; - -export function scheduleReadableStreamLike<T>(input: ReadableStreamLike<T>, scheduler: SchedulerLike): Observable<T> { - return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler); -} diff --git a/node_modules/rxjs/src/internal/scheduled/scheduled.ts b/node_modules/rxjs/src/internal/scheduled/scheduled.ts deleted file mode 100644 index bb2e425..0000000 --- a/node_modules/rxjs/src/internal/scheduled/scheduled.ts +++ /dev/null @@ -1,50 +0,0 @@ -import { scheduleObservable } from './scheduleObservable'; -import { schedulePromise } from './schedulePromise'; -import { scheduleArray } from './scheduleArray'; -import { scheduleIterable } from './scheduleIterable'; -import { scheduleAsyncIterable } from './scheduleAsyncIterable'; -import { isInteropObservable } from '../util/isInteropObservable'; -import { isPromise } from '../util/isPromise'; -import { isArrayLike } from '../util/isArrayLike'; -import { isIterable } from '../util/isIterable'; -import { ObservableInput, SchedulerLike } from '../types'; -import { Observable } from '../Observable'; -import { isAsyncIterable } from '../util/isAsyncIterable'; -import { createInvalidObservableTypeError } from '../util/throwUnobservableError'; -import { isReadableStreamLike } from '../util/isReadableStreamLike'; -import { scheduleReadableStreamLike } from './scheduleReadableStreamLike'; - -/** - * Converts from a common {@link ObservableInput} type to an observable where subscription and emissions - * are scheduled on the provided scheduler. - * - * @see {@link from} - * @see {@link of} - * - * @param input The observable, array, promise, iterable, etc you would like to schedule - * @param scheduler The scheduler to use to schedule the subscription and emissions from - * the returned observable. - */ -export function scheduled<T>(input: ObservableInput<T>, scheduler: SchedulerLike): Observable<T> { - if (input != null) { - if (isInteropObservable(input)) { - return scheduleObservable(input, scheduler); - } - if (isArrayLike(input)) { - return scheduleArray(input, scheduler); - } - if (isPromise(input)) { - return schedulePromise(input, scheduler); - } - if (isAsyncIterable(input)) { - return scheduleAsyncIterable(input, scheduler); - } - if (isIterable(input)) { - return scheduleIterable(input, scheduler); - } - if (isReadableStreamLike(input)) { - return scheduleReadableStreamLike(input, scheduler); - } - } - throw createInvalidObservableTypeError(input); -} diff --git a/node_modules/rxjs/src/internal/scheduler/Action.ts b/node_modules/rxjs/src/internal/scheduler/Action.ts deleted file mode 100644 index a9c543b..0000000 --- a/node_modules/rxjs/src/internal/scheduler/Action.ts +++ /dev/null @@ -1,34 +0,0 @@ -import { Scheduler } from '../Scheduler'; -import { Subscription } from '../Subscription'; -import { SchedulerAction } from '../types'; - -/** - * A unit of work to be executed in a `scheduler`. An action is typically - * created from within a {@link SchedulerLike} and an RxJS user does not need to concern - * themselves about creating and manipulating an Action. - * - * ```ts - * class Action<T> extends Subscription { - * new (scheduler: Scheduler, work: (state?: T) => void); - * schedule(state?: T, delay: number = 0): Subscription; - * } - * ``` - */ -export class Action<T> extends Subscription { - constructor(scheduler: Scheduler, work: (this: SchedulerAction<T>, state?: T) => void) { - super(); - } - /** - * Schedules this action on its parent {@link SchedulerLike} for execution. May be passed - * some context object, `state`. May happen at some point in the future, - * according to the `delay` parameter, if specified. - * @param state Some contextual data that the `work` function uses when called by the - * Scheduler. - * @param delay Time to wait before executing the work, where the time unit is implicit - * and defined by the Scheduler. - * @return A subscription in order to be able to unsubscribe the scheduled work. - */ - public schedule(state?: T, delay: number = 0): Subscription { - return this; - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts b/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts deleted file mode 100644 index 502bbc7..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AnimationFrameAction.ts +++ /dev/null @@ -1,43 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AnimationFrameScheduler } from './AnimationFrameScheduler'; -import { SchedulerAction } from '../types'; -import { animationFrameProvider } from './animationFrameProvider'; -import { TimerHandle } from './timerHandle'; - -export class AnimationFrameAction<T> extends AsyncAction<T> { - constructor(protected scheduler: AnimationFrameScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) { - super(scheduler, work); - } - - protected requestAsyncId(scheduler: AnimationFrameScheduler, id?: TimerHandle, delay: number = 0): TimerHandle { - // If delay is greater than 0, request as an async action. - if (delay !== null && delay > 0) { - return super.requestAsyncId(scheduler, id, delay); - } - // Push the action to the end of the scheduler queue. - scheduler.actions.push(this); - // If an animation frame has already been requested, don't request another - // one. If an animation frame hasn't been requested yet, request one. Return - // the current animation frame request id. - return scheduler._scheduled || (scheduler._scheduled = animationFrameProvider.requestAnimationFrame(() => scheduler.flush(undefined))); - } - - protected recycleAsyncId(scheduler: AnimationFrameScheduler, id?: TimerHandle, delay: number = 0): TimerHandle | undefined { - // If delay exists and is greater than 0, or if the delay is null (the - // action wasn't rescheduled) but was originally scheduled as an async - // action, then recycle as an async action. - if (delay != null ? delay > 0 : this.delay > 0) { - return super.recycleAsyncId(scheduler, id, delay); - } - // If the scheduler queue has no remaining actions with the same async id, - // cancel the requested animation frame and set the scheduled flag to - // undefined so the next AnimationFrameAction will request its own. - const { actions } = scheduler; - if (id != null && id === scheduler._scheduled && actions[actions.length - 1]?.id !== id) { - animationFrameProvider.cancelAnimationFrame(id as number); - scheduler._scheduled = undefined; - } - // Return undefined so the action knows to request a new async id if it's rescheduled. - return undefined; - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts b/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts deleted file mode 100644 index 1f21ffa..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AnimationFrameScheduler.ts +++ /dev/null @@ -1,43 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AsyncScheduler } from './AsyncScheduler'; - -export class AnimationFrameScheduler extends AsyncScheduler { - public flush(action?: AsyncAction<any>): void { - this._active = true; - // The async id that effects a call to flush is stored in _scheduled. - // Before executing an action, it's necessary to check the action's async - // id to determine whether it's supposed to be executed in the current - // flush. - // Previous implementations of this method used a count to determine this, - // but that was unsound, as actions that are unsubscribed - i.e. cancelled - - // are removed from the actions array and that can shift actions that are - // scheduled to be executed in a subsequent flush into positions at which - // they are executed within the current flush. - let flushId; - if (action) { - flushId = action.id; - } else { - flushId = this._scheduled; - this._scheduled = undefined; - } - - const { actions } = this; - let error: any; - action = action || actions.shift()!; - - do { - if ((error = action.execute(action.state, action.delay))) { - break; - } - } while ((action = actions[0]) && action.id === flushId && actions.shift()); - - this._active = false; - - if (error) { - while ((action = actions[0]) && action.id === flushId && actions.shift()) { - action.unsubscribe(); - } - throw error; - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AsapAction.ts b/node_modules/rxjs/src/internal/scheduler/AsapAction.ts deleted file mode 100644 index 178f677..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AsapAction.ts +++ /dev/null @@ -1,45 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AsapScheduler } from './AsapScheduler'; -import { SchedulerAction } from '../types'; -import { immediateProvider } from './immediateProvider'; -import { TimerHandle } from './timerHandle'; - -export class AsapAction<T> extends AsyncAction<T> { - constructor(protected scheduler: AsapScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) { - super(scheduler, work); - } - - protected requestAsyncId(scheduler: AsapScheduler, id?: TimerHandle, delay: number = 0): TimerHandle { - // If delay is greater than 0, request as an async action. - if (delay !== null && delay > 0) { - return super.requestAsyncId(scheduler, id, delay); - } - // Push the action to the end of the scheduler queue. - scheduler.actions.push(this); - // If a microtask has already been scheduled, don't schedule another - // one. If a microtask hasn't been scheduled yet, schedule one now. Return - // the current scheduled microtask id. - return scheduler._scheduled || (scheduler._scheduled = immediateProvider.setImmediate(scheduler.flush.bind(scheduler, undefined))); - } - - protected recycleAsyncId(scheduler: AsapScheduler, id?: TimerHandle, delay: number = 0): TimerHandle | undefined { - // If delay exists and is greater than 0, or if the delay is null (the - // action wasn't rescheduled) but was originally scheduled as an async - // action, then recycle as an async action. - if (delay != null ? delay > 0 : this.delay > 0) { - return super.recycleAsyncId(scheduler, id, delay); - } - // If the scheduler queue has no remaining actions with the same async id, - // cancel the requested microtask and set the scheduled flag to undefined - // so the next AsapAction will request its own. - const { actions } = scheduler; - if (id != null && actions[actions.length - 1]?.id !== id) { - immediateProvider.clearImmediate(id); - if (scheduler._scheduled === id) { - scheduler._scheduled = undefined; - } - } - // Return undefined so the action knows to request a new async id if it's rescheduled. - return undefined; - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AsapScheduler.ts b/node_modules/rxjs/src/internal/scheduler/AsapScheduler.ts deleted file mode 100644 index 95874bd..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AsapScheduler.ts +++ /dev/null @@ -1,38 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AsyncScheduler } from './AsyncScheduler'; - -export class AsapScheduler extends AsyncScheduler { - public flush(action?: AsyncAction<any>): void { - this._active = true; - // The async id that effects a call to flush is stored in _scheduled. - // Before executing an action, it's necessary to check the action's async - // id to determine whether it's supposed to be executed in the current - // flush. - // Previous implementations of this method used a count to determine this, - // but that was unsound, as actions that are unsubscribed - i.e. cancelled - - // are removed from the actions array and that can shift actions that are - // scheduled to be executed in a subsequent flush into positions at which - // they are executed within the current flush. - const flushId = this._scheduled; - this._scheduled = undefined; - - const { actions } = this; - let error: any; - action = action || actions.shift()!; - - do { - if ((error = action.execute(action.state, action.delay))) { - break; - } - } while ((action = actions[0]) && action.id === flushId && actions.shift()); - - this._active = false; - - if (error) { - while ((action = actions[0]) && action.id === flushId && actions.shift()) { - action.unsubscribe(); - } - throw error; - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AsyncAction.ts b/node_modules/rxjs/src/internal/scheduler/AsyncAction.ts deleted file mode 100644 index 704b571..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AsyncAction.ts +++ /dev/null @@ -1,150 +0,0 @@ -import { Action } from './Action'; -import { SchedulerAction } from '../types'; -import { Subscription } from '../Subscription'; -import { AsyncScheduler } from './AsyncScheduler'; -import { intervalProvider } from './intervalProvider'; -import { arrRemove } from '../util/arrRemove'; -import { TimerHandle } from './timerHandle'; - -export class AsyncAction<T> extends Action<T> { - public id: TimerHandle | undefined; - public state?: T; - // @ts-ignore: Property has no initializer and is not definitely assigned - public delay: number; - protected pending: boolean = false; - - constructor(protected scheduler: AsyncScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) { - super(scheduler, work); - } - - public schedule(state?: T, delay: number = 0): Subscription { - if (this.closed) { - return this; - } - - // Always replace the current state with the new state. - this.state = state; - - const id = this.id; - const scheduler = this.scheduler; - - // - // Important implementation note: - // - // Actions only execute once by default, unless rescheduled from within the - // scheduled callback. This allows us to implement single and repeat - // actions via the same code path, without adding API surface area, as well - // as mimic traditional recursion but across asynchronous boundaries. - // - // However, JS runtimes and timers distinguish between intervals achieved by - // serial `setTimeout` calls vs. a single `setInterval` call. An interval of - // serial `setTimeout` calls can be individually delayed, which delays - // scheduling the next `setTimeout`, and so on. `setInterval` attempts to - // guarantee the interval callback will be invoked more precisely to the - // interval period, regardless of load. - // - // Therefore, we use `setInterval` to schedule single and repeat actions. - // If the action reschedules itself with the same delay, the interval is not - // canceled. If the action doesn't reschedule, or reschedules with a - // different delay, the interval will be canceled after scheduled callback - // execution. - // - if (id != null) { - this.id = this.recycleAsyncId(scheduler, id, delay); - } - - // Set the pending flag indicating that this action has been scheduled, or - // has recursively rescheduled itself. - this.pending = true; - - this.delay = delay; - // If this action has already an async Id, don't request a new one. - this.id = this.id ?? this.requestAsyncId(scheduler, this.id, delay); - - return this; - } - - protected requestAsyncId(scheduler: AsyncScheduler, _id?: TimerHandle, delay: number = 0): TimerHandle { - return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay); - } - - protected recycleAsyncId(_scheduler: AsyncScheduler, id?: TimerHandle, delay: number | null = 0): TimerHandle | undefined { - // If this action is rescheduled with the same delay time, don't clear the interval id. - if (delay != null && this.delay === delay && this.pending === false) { - return id; - } - // Otherwise, if the action's delay time is different from the current delay, - // or the action has been rescheduled before it's executed, clear the interval id - if (id != null) { - intervalProvider.clearInterval(id); - } - - return undefined; - } - - /** - * Immediately executes this action and the `work` it contains. - */ - public execute(state: T, delay: number): any { - if (this.closed) { - return new Error('executing a cancelled action'); - } - - this.pending = false; - const error = this._execute(state, delay); - if (error) { - return error; - } else if (this.pending === false && this.id != null) { - // Dequeue if the action didn't reschedule itself. Don't call - // unsubscribe(), because the action could reschedule later. - // For example: - // ``` - // scheduler.schedule(function doWork(counter) { - // /* ... I'm a busy worker bee ... */ - // var originalAction = this; - // /* wait 100ms before rescheduling the action */ - // setTimeout(function () { - // originalAction.schedule(counter + 1); - // }, 100); - // }, 1000); - // ``` - this.id = this.recycleAsyncId(this.scheduler, this.id, null); - } - } - - protected _execute(state: T, _delay: number): any { - let errored: boolean = false; - let errorValue: any; - try { - this.work(state); - } catch (e) { - errored = true; - // HACK: Since code elsewhere is relying on the "truthiness" of the - // return here, we can't have it return "" or 0 or false. - // TODO: Clean this up when we refactor schedulers mid-version-8 or so. - errorValue = e ? e : new Error('Scheduled action threw falsy error'); - } - if (errored) { - this.unsubscribe(); - return errorValue; - } - } - - unsubscribe() { - if (!this.closed) { - const { id, scheduler } = this; - const { actions } = scheduler; - - this.work = this.state = this.scheduler = null!; - this.pending = false; - - arrRemove(actions, this); - if (id != null) { - this.id = this.recycleAsyncId(scheduler, id, null); - } - - this.delay = null!; - super.unsubscribe(); - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/AsyncScheduler.ts b/node_modules/rxjs/src/internal/scheduler/AsyncScheduler.ts deleted file mode 100644 index b05e2e3..0000000 --- a/node_modules/rxjs/src/internal/scheduler/AsyncScheduler.ts +++ /dev/null @@ -1,52 +0,0 @@ -import { Scheduler } from '../Scheduler'; -import { Action } from './Action'; -import { AsyncAction } from './AsyncAction'; -import { TimerHandle } from './timerHandle'; - -export class AsyncScheduler extends Scheduler { - public actions: Array<AsyncAction<any>> = []; - /** - * A flag to indicate whether the Scheduler is currently executing a batch of - * queued actions. - * @internal - */ - public _active: boolean = false; - /** - * An internal ID used to track the latest asynchronous task such as those - * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and - * others. - * @internal - */ - public _scheduled: TimerHandle | undefined; - - constructor(SchedulerAction: typeof Action, now: () => number = Scheduler.now) { - super(SchedulerAction, now); - } - - public flush(action: AsyncAction<any>): void { - const { actions } = this; - - if (this._active) { - actions.push(action); - return; - } - - let error: any; - this._active = true; - - do { - if ((error = action.execute(action.state, action.delay))) { - break; - } - } while ((action = actions.shift()!)); // exhaust the scheduler queue - - this._active = false; - - if (error) { - while ((action = actions.shift()!)) { - action.unsubscribe(); - } - throw error; - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/QueueAction.ts b/node_modules/rxjs/src/internal/scheduler/QueueAction.ts deleted file mode 100644 index 9016edb..0000000 --- a/node_modules/rxjs/src/internal/scheduler/QueueAction.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { Subscription } from '../Subscription'; -import { QueueScheduler } from './QueueScheduler'; -import { SchedulerAction } from '../types'; -import { TimerHandle } from './timerHandle'; - -export class QueueAction<T> extends AsyncAction<T> { - constructor(protected scheduler: QueueScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) { - super(scheduler, work); - } - - public schedule(state?: T, delay: number = 0): Subscription { - if (delay > 0) { - return super.schedule(state, delay); - } - this.delay = delay; - this.state = state; - this.scheduler.flush(this); - return this; - } - - public execute(state: T, delay: number): any { - return delay > 0 || this.closed ? super.execute(state, delay) : this._execute(state, delay); - } - - protected requestAsyncId(scheduler: QueueScheduler, id?: TimerHandle, delay: number = 0): TimerHandle { - // If delay exists and is greater than 0, or if the delay is null (the - // action wasn't rescheduled) but was originally scheduled as an async - // action, then recycle as an async action. - - if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) { - return super.requestAsyncId(scheduler, id, delay); - } - - // Otherwise flush the scheduler starting with this action. - scheduler.flush(this); - - // HACK: In the past, this was returning `void`. However, `void` isn't a valid - // `TimerHandle`, and generally the return value here isn't really used. So the - // compromise is to return `0` which is both "falsy" and a valid `TimerHandle`, - // as opposed to refactoring every other instanceo of `requestAsyncId`. - return 0; - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/QueueScheduler.ts b/node_modules/rxjs/src/internal/scheduler/QueueScheduler.ts deleted file mode 100644 index e9dab3d..0000000 --- a/node_modules/rxjs/src/internal/scheduler/QueueScheduler.ts +++ /dev/null @@ -1,4 +0,0 @@ -import { AsyncScheduler } from './AsyncScheduler'; - -export class QueueScheduler extends AsyncScheduler { -} diff --git a/node_modules/rxjs/src/internal/scheduler/VirtualTimeScheduler.ts b/node_modules/rxjs/src/internal/scheduler/VirtualTimeScheduler.ts deleted file mode 100644 index 70fec02..0000000 --- a/node_modules/rxjs/src/internal/scheduler/VirtualTimeScheduler.ts +++ /dev/null @@ -1,128 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { Subscription } from '../Subscription'; -import { AsyncScheduler } from './AsyncScheduler'; -import { SchedulerAction } from '../types'; -import { TimerHandle } from './timerHandle'; - -export class VirtualTimeScheduler extends AsyncScheduler { - /** @deprecated Not used in VirtualTimeScheduler directly. Will be removed in v8. */ - static frameTimeFactor = 10; - - /** - * The current frame for the state of the virtual scheduler instance. The difference - * between two "frames" is synonymous with the passage of "virtual time units". So if - * you record `scheduler.frame` to be `1`, then later, observe `scheduler.frame` to be at `11`, - * that means `10` virtual time units have passed. - */ - public frame: number = 0; - - /** - * Used internally to examine the current virtual action index being processed. - * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. - */ - public index: number = -1; - - /** - * This creates an instance of a `VirtualTimeScheduler`. Experts only. The signature of - * this constructor is likely to change in the long run. - * - * @param schedulerActionCtor The type of Action to initialize when initializing actions during scheduling. - * @param maxFrames The maximum number of frames to process before stopping. Used to prevent endless flush cycles. - */ - constructor(schedulerActionCtor: typeof AsyncAction = VirtualAction as any, public maxFrames: number = Infinity) { - super(schedulerActionCtor, () => this.frame); - } - - /** - * Prompt the Scheduler to execute all of its queued actions, therefore - * clearing its queue. - */ - public flush(): void { - const { actions, maxFrames } = this; - let error: any; - let action: AsyncAction<any> | undefined; - - while ((action = actions[0]) && action.delay <= maxFrames) { - actions.shift(); - this.frame = action.delay; - - if ((error = action.execute(action.state, action.delay))) { - break; - } - } - - if (error) { - while ((action = actions.shift())) { - action.unsubscribe(); - } - throw error; - } - } -} - -export class VirtualAction<T> extends AsyncAction<T> { - protected active: boolean = true; - - constructor( - protected scheduler: VirtualTimeScheduler, - protected work: (this: SchedulerAction<T>, state?: T) => void, - protected index: number = (scheduler.index += 1) - ) { - super(scheduler, work); - this.index = scheduler.index = index; - } - - public schedule(state?: T, delay: number = 0): Subscription { - if (Number.isFinite(delay)) { - if (!this.id) { - return super.schedule(state, delay); - } - this.active = false; - // If an action is rescheduled, we save allocations by mutating its state, - // pushing it to the end of the scheduler queue, and recycling the action. - // But since the VirtualTimeScheduler is used for testing, VirtualActions - // must be immutable so they can be inspected later. - const action = new VirtualAction(this.scheduler, this.work); - this.add(action); - return action.schedule(state, delay); - } else { - // If someone schedules something with Infinity, it'll never happen. So we - // don't even schedule it. - return Subscription.EMPTY; - } - } - - protected requestAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay: number = 0): TimerHandle { - this.delay = scheduler.frame + delay; - const { actions } = scheduler; - actions.push(this); - (actions as Array<VirtualAction<T>>).sort(VirtualAction.sortActions); - return 1; - } - - protected recycleAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay: number = 0): TimerHandle | undefined { - return undefined; - } - - protected _execute(state: T, delay: number): any { - if (this.active === true) { - return super._execute(state, delay); - } - } - - private static sortActions<T>(a: VirtualAction<T>, b: VirtualAction<T>) { - if (a.delay === b.delay) { - if (a.index === b.index) { - return 0; - } else if (a.index > b.index) { - return 1; - } else { - return -1; - } - } else if (a.delay > b.delay) { - return 1; - } else { - return -1; - } - } -} diff --git a/node_modules/rxjs/src/internal/scheduler/animationFrame.ts b/node_modules/rxjs/src/internal/scheduler/animationFrame.ts deleted file mode 100644 index 2ce033d..0000000 --- a/node_modules/rxjs/src/internal/scheduler/animationFrame.ts +++ /dev/null @@ -1,41 +0,0 @@ -import { AnimationFrameAction } from './AnimationFrameAction'; -import { AnimationFrameScheduler } from './AnimationFrameScheduler'; - -/** - * - * Animation Frame Scheduler - * - * <span class="informal">Perform task when `window.requestAnimationFrame` would fire</span> - * - * When `animationFrame` scheduler is used with delay, it will fall back to {@link asyncScheduler} scheduler - * behaviour. - * - * Without delay, `animationFrame` scheduler can be used to create smooth browser animations. - * It makes sure scheduled task will happen just before next browser content repaint, - * thus performing animations as efficiently as possible. - * - * ## Example - * Schedule div height animation - * ```ts - * // html: <div style="background: #0ff;"></div> - * import { animationFrameScheduler } from 'rxjs'; - * - * const div = document.querySelector('div'); - * - * animationFrameScheduler.schedule(function(height) { - * div.style.height = height + "px"; - * - * this.schedule(height + 1); // `this` references currently executing Action, - * // which we reschedule with new state - * }, 0, 0); - * - * // You will see a div element growing in height - * ``` - */ - -export const animationFrameScheduler = new AnimationFrameScheduler(AnimationFrameAction); - -/** - * @deprecated Renamed to {@link animationFrameScheduler}. Will be removed in v8. - */ -export const animationFrame = animationFrameScheduler; diff --git a/node_modules/rxjs/src/internal/scheduler/animationFrameProvider.ts b/node_modules/rxjs/src/internal/scheduler/animationFrameProvider.ts deleted file mode 100644 index 610093b..0000000 --- a/node_modules/rxjs/src/internal/scheduler/animationFrameProvider.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { Subscription } from '../Subscription'; - -interface AnimationFrameProvider { - schedule(callback: FrameRequestCallback): Subscription; - requestAnimationFrame: typeof requestAnimationFrame; - cancelAnimationFrame: typeof cancelAnimationFrame; - delegate: - | { - requestAnimationFrame: typeof requestAnimationFrame; - cancelAnimationFrame: typeof cancelAnimationFrame; - } - | undefined; -} - -export const animationFrameProvider: AnimationFrameProvider = { - // When accessing the delegate, use the variable rather than `this` so that - // the functions can be called without being bound to the provider. - schedule(callback) { - let request = requestAnimationFrame; - let cancel: typeof cancelAnimationFrame | undefined = cancelAnimationFrame; - const { delegate } = animationFrameProvider; - if (delegate) { - request = delegate.requestAnimationFrame; - cancel = delegate.cancelAnimationFrame; - } - const handle = request((timestamp) => { - // Clear the cancel function. The request has been fulfilled, so - // attempting to cancel the request upon unsubscription would be - // pointless. - cancel = undefined; - callback(timestamp); - }); - return new Subscription(() => cancel?.(handle)); - }, - requestAnimationFrame(...args) { - const { delegate } = animationFrameProvider; - return (delegate?.requestAnimationFrame || requestAnimationFrame)(...args); - }, - cancelAnimationFrame(...args) { - const { delegate } = animationFrameProvider; - return (delegate?.cancelAnimationFrame || cancelAnimationFrame)(...args); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/asap.ts b/node_modules/rxjs/src/internal/scheduler/asap.ts deleted file mode 100644 index 5be1be4..0000000 --- a/node_modules/rxjs/src/internal/scheduler/asap.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { AsapAction } from './AsapAction'; -import { AsapScheduler } from './AsapScheduler'; - -/** - * - * Asap Scheduler - * - * <span class="informal">Perform task as fast as it can be performed asynchronously</span> - * - * `asap` scheduler behaves the same as {@link asyncScheduler} scheduler when you use it to delay task - * in time. If however you set delay to `0`, `asap` will wait for current synchronously executing - * code to end and then it will try to execute given task as fast as possible. - * - * `asap` scheduler will do its best to minimize time between end of currently executing code - * and start of scheduled task. This makes it best candidate for performing so called "deferring". - * Traditionally this was achieved by calling `setTimeout(deferredTask, 0)`, but that technique involves - * some (although minimal) unwanted delay. - * - * Note that using `asap` scheduler does not necessarily mean that your task will be first to process - * after currently executing code. In particular, if some task was also scheduled with `asap` before, - * that task will execute first. That being said, if you need to schedule task asynchronously, but - * as soon as possible, `asap` scheduler is your best bet. - * - * ## Example - * Compare async and asap scheduler< - * ```ts - * import { asapScheduler, asyncScheduler } from 'rxjs'; - * - * asyncScheduler.schedule(() => console.log('async')); // scheduling 'async' first... - * asapScheduler.schedule(() => console.log('asap')); - * - * // Logs: - * // "asap" - * // "async" - * // ... but 'asap' goes first! - * ``` - */ - -export const asapScheduler = new AsapScheduler(AsapAction); - -/** - * @deprecated Renamed to {@link asapScheduler}. Will be removed in v8. - */ -export const asap = asapScheduler; diff --git a/node_modules/rxjs/src/internal/scheduler/async.ts b/node_modules/rxjs/src/internal/scheduler/async.ts deleted file mode 100644 index 76f9dc8..0000000 --- a/node_modules/rxjs/src/internal/scheduler/async.ts +++ /dev/null @@ -1,56 +0,0 @@ -import { AsyncAction } from './AsyncAction'; -import { AsyncScheduler } from './AsyncScheduler'; - -/** - * - * Async Scheduler - * - * <span class="informal">Schedule task as if you used setTimeout(task, duration)</span> - * - * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript - * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating - * in intervals. - * - * If you just want to "defer" task, that is to perform it right after currently - * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`), - * better choice will be the {@link asapScheduler} scheduler. - * - * ## Examples - * Use async scheduler to delay task - * ```ts - * import { asyncScheduler } from 'rxjs'; - * - * const task = () => console.log('it works!'); - * - * asyncScheduler.schedule(task, 2000); - * - * // After 2 seconds logs: - * // "it works!" - * ``` - * - * Use async scheduler to repeat task in intervals - * ```ts - * import { asyncScheduler } from 'rxjs'; - * - * function task(state) { - * console.log(state); - * this.schedule(state + 1, 1000); // `this` references currently executing Action, - * // which we reschedule with new state and delay - * } - * - * asyncScheduler.schedule(task, 3000, 0); - * - * // Logs: - * // 0 after 3s - * // 1 after 4s - * // 2 after 5s - * // 3 after 6s - * ``` - */ - -export const asyncScheduler = new AsyncScheduler(AsyncAction); - -/** - * @deprecated Renamed to {@link asyncScheduler}. Will be removed in v8. - */ -export const async = asyncScheduler; diff --git a/node_modules/rxjs/src/internal/scheduler/dateTimestampProvider.ts b/node_modules/rxjs/src/internal/scheduler/dateTimestampProvider.ts deleted file mode 100644 index 9e8339d..0000000 --- a/node_modules/rxjs/src/internal/scheduler/dateTimestampProvider.ts +++ /dev/null @@ -1,14 +0,0 @@ -import { TimestampProvider } from '../types'; - -interface DateTimestampProvider extends TimestampProvider { - delegate: TimestampProvider | undefined; -} - -export const dateTimestampProvider: DateTimestampProvider = { - now() { - // Use the variable rather than `this` so that the function can be called - // without being bound to the provider. - return (dateTimestampProvider.delegate || Date).now(); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/immediateProvider.ts b/node_modules/rxjs/src/internal/scheduler/immediateProvider.ts deleted file mode 100644 index d70fbf3..0000000 --- a/node_modules/rxjs/src/internal/scheduler/immediateProvider.ts +++ /dev/null @@ -1,31 +0,0 @@ -import { Immediate } from '../util/Immediate'; -import type { TimerHandle } from './timerHandle'; -const { setImmediate, clearImmediate } = Immediate; - -type SetImmediateFunction = (handler: () => void, ...args: any[]) => TimerHandle; -type ClearImmediateFunction = (handle: TimerHandle) => void; - -interface ImmediateProvider { - setImmediate: SetImmediateFunction; - clearImmediate: ClearImmediateFunction; - delegate: - | { - setImmediate: SetImmediateFunction; - clearImmediate: ClearImmediateFunction; - } - | undefined; -} - -export const immediateProvider: ImmediateProvider = { - // When accessing the delegate, use the variable rather than `this` so that - // the functions can be called without being bound to the provider. - setImmediate(...args) { - const { delegate } = immediateProvider; - return (delegate?.setImmediate || setImmediate)(...args); - }, - clearImmediate(handle) { - const { delegate } = immediateProvider; - return (delegate?.clearImmediate || clearImmediate)(handle as any); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/intervalProvider.ts b/node_modules/rxjs/src/internal/scheduler/intervalProvider.ts deleted file mode 100644 index 032317d..0000000 --- a/node_modules/rxjs/src/internal/scheduler/intervalProvider.ts +++ /dev/null @@ -1,31 +0,0 @@ -import type { TimerHandle } from './timerHandle'; -type SetIntervalFunction = (handler: () => void, timeout?: number, ...args: any[]) => TimerHandle; -type ClearIntervalFunction = (handle: TimerHandle) => void; - -interface IntervalProvider { - setInterval: SetIntervalFunction; - clearInterval: ClearIntervalFunction; - delegate: - | { - setInterval: SetIntervalFunction; - clearInterval: ClearIntervalFunction; - } - | undefined; -} - -export const intervalProvider: IntervalProvider = { - // When accessing the delegate, use the variable rather than `this` so that - // the functions can be called without being bound to the provider. - setInterval(handler: () => void, timeout?: number, ...args) { - const { delegate } = intervalProvider; - if (delegate?.setInterval) { - return delegate.setInterval(handler, timeout, ...args); - } - return setInterval(handler, timeout, ...args); - }, - clearInterval(handle) { - const { delegate } = intervalProvider; - return (delegate?.clearInterval || clearInterval)(handle as any); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/performanceTimestampProvider.ts b/node_modules/rxjs/src/internal/scheduler/performanceTimestampProvider.ts deleted file mode 100644 index 873e71b..0000000 --- a/node_modules/rxjs/src/internal/scheduler/performanceTimestampProvider.ts +++ /dev/null @@ -1,14 +0,0 @@ -import { TimestampProvider } from '../types'; - -interface PerformanceTimestampProvider extends TimestampProvider { - delegate: TimestampProvider | undefined; -} - -export const performanceTimestampProvider: PerformanceTimestampProvider = { - now() { - // Use the variable rather than `this` so that the function can be called - // without being bound to the provider. - return (performanceTimestampProvider.delegate || performance).now(); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/queue.ts b/node_modules/rxjs/src/internal/scheduler/queue.ts deleted file mode 100644 index df4e216..0000000 --- a/node_modules/rxjs/src/internal/scheduler/queue.ts +++ /dev/null @@ -1,72 +0,0 @@ -import { QueueAction } from './QueueAction'; -import { QueueScheduler } from './QueueScheduler'; - -/** - * - * Queue Scheduler - * - * <span class="informal">Put every next task on a queue, instead of executing it immediately</span> - * - * `queue` scheduler, when used with delay, behaves the same as {@link asyncScheduler} scheduler. - * - * When used without delay, it schedules given task synchronously - executes it right when - * it is scheduled. However when called recursively, that is when inside the scheduled task, - * another task is scheduled with queue scheduler, instead of executing immediately as well, - * that task will be put on a queue and wait for current one to finish. - * - * This means that when you execute task with `queue` scheduler, you are sure it will end - * before any other task scheduled with that scheduler will start. - * - * ## Examples - * Schedule recursively first, then do something - * ```ts - * import { queueScheduler } from 'rxjs'; - * - * queueScheduler.schedule(() => { - * queueScheduler.schedule(() => console.log('second')); // will not happen now, but will be put on a queue - * - * console.log('first'); - * }); - * - * // Logs: - * // "first" - * // "second" - * ``` - * - * Reschedule itself recursively - * ```ts - * import { queueScheduler } from 'rxjs'; - * - * queueScheduler.schedule(function(state) { - * if (state !== 0) { - * console.log('before', state); - * this.schedule(state - 1); // `this` references currently executing Action, - * // which we reschedule with new state - * console.log('after', state); - * } - * }, 0, 3); - * - * // In scheduler that runs recursively, you would expect: - * // "before", 3 - * // "before", 2 - * // "before", 1 - * // "after", 1 - * // "after", 2 - * // "after", 3 - * - * // But with queue it logs: - * // "before", 3 - * // "after", 3 - * // "before", 2 - * // "after", 2 - * // "before", 1 - * // "after", 1 - * ``` - */ - -export const queueScheduler = new QueueScheduler(QueueAction); - -/** - * @deprecated Renamed to {@link queueScheduler}. Will be removed in v8. - */ -export const queue = queueScheduler; diff --git a/node_modules/rxjs/src/internal/scheduler/timeoutProvider.ts b/node_modules/rxjs/src/internal/scheduler/timeoutProvider.ts deleted file mode 100644 index 205e016..0000000 --- a/node_modules/rxjs/src/internal/scheduler/timeoutProvider.ts +++ /dev/null @@ -1,31 +0,0 @@ -import type { TimerHandle } from './timerHandle'; -type SetTimeoutFunction = (handler: () => void, timeout?: number, ...args: any[]) => TimerHandle; -type ClearTimeoutFunction = (handle: TimerHandle) => void; - -interface TimeoutProvider { - setTimeout: SetTimeoutFunction; - clearTimeout: ClearTimeoutFunction; - delegate: - | { - setTimeout: SetTimeoutFunction; - clearTimeout: ClearTimeoutFunction; - } - | undefined; -} - -export const timeoutProvider: TimeoutProvider = { - // When accessing the delegate, use the variable rather than `this` so that - // the functions can be called without being bound to the provider. - setTimeout(handler: () => void, timeout?: number, ...args) { - const { delegate } = timeoutProvider; - if (delegate?.setTimeout) { - return delegate.setTimeout(handler, timeout, ...args); - } - return setTimeout(handler, timeout, ...args); - }, - clearTimeout(handle) { - const { delegate } = timeoutProvider; - return (delegate?.clearTimeout || clearTimeout)(handle as any); - }, - delegate: undefined, -}; diff --git a/node_modules/rxjs/src/internal/scheduler/timerHandle.ts b/node_modules/rxjs/src/internal/scheduler/timerHandle.ts deleted file mode 100644 index 99c0098..0000000 --- a/node_modules/rxjs/src/internal/scheduler/timerHandle.ts +++ /dev/null @@ -1 +0,0 @@ -export type TimerHandle = number | ReturnType<typeof setTimeout>; diff --git a/node_modules/rxjs/src/internal/symbol/iterator.ts b/node_modules/rxjs/src/internal/symbol/iterator.ts deleted file mode 100644 index 75098ef..0000000 --- a/node_modules/rxjs/src/internal/symbol/iterator.ts +++ /dev/null @@ -1,9 +0,0 @@ -export function getSymbolIterator(): symbol { - if (typeof Symbol !== 'function' || !Symbol.iterator) { - return '@@iterator' as any; - } - - return Symbol.iterator; -} - -export const iterator = getSymbolIterator(); diff --git a/node_modules/rxjs/src/internal/symbol/observable.ts b/node_modules/rxjs/src/internal/symbol/observable.ts deleted file mode 100644 index b133245..0000000 --- a/node_modules/rxjs/src/internal/symbol/observable.ts +++ /dev/null @@ -1,7 +0,0 @@ -/** - * Symbol.observable or a string "@@observable". Used for interop - * - * @deprecated We will no longer be exporting this symbol in upcoming versions of RxJS. - * Instead polyfill and use Symbol.observable directly *or* use https://www.npmjs.com/package/symbol-observable - */ -export const observable: string | symbol = (() => (typeof Symbol === 'function' && Symbol.observable) || '@@observable')(); diff --git a/node_modules/rxjs/src/internal/testing/ColdObservable.ts b/node_modules/rxjs/src/internal/testing/ColdObservable.ts deleted file mode 100644 index 40cbe49..0000000 --- a/node_modules/rxjs/src/internal/testing/ColdObservable.ts +++ /dev/null @@ -1,52 +0,0 @@ -import { Observable } from '../Observable'; -import { Subscription } from '../Subscription'; -import { Scheduler } from '../Scheduler'; -import { TestMessage } from './TestMessage'; -import { SubscriptionLog } from './SubscriptionLog'; -import { SubscriptionLoggable } from './SubscriptionLoggable'; -import { applyMixins } from '../util/applyMixins'; -import { Subscriber } from '../Subscriber'; -import { observeNotification } from '../Notification'; - -export class ColdObservable<T> extends Observable<T> implements SubscriptionLoggable { - public subscriptions: SubscriptionLog[] = []; - scheduler: Scheduler; - // @ts-ignore: Property has no initializer and is not definitely assigned - logSubscribedFrame: () => number; - // @ts-ignore: Property has no initializer and is not definitely assigned - logUnsubscribedFrame: (index: number) => void; - - constructor(public messages: TestMessage[], scheduler: Scheduler) { - super(function (this: Observable<T>, subscriber: Subscriber<any>) { - const observable: ColdObservable<T> = this as any; - const index = observable.logSubscribedFrame(); - const subscription = new Subscription(); - subscription.add( - new Subscription(() => { - observable.logUnsubscribedFrame(index); - }) - ); - observable.scheduleMessages(subscriber); - return subscription; - }); - this.scheduler = scheduler; - } - - scheduleMessages(subscriber: Subscriber<any>) { - const messagesLength = this.messages.length; - for (let i = 0; i < messagesLength; i++) { - const message = this.messages[i]; - subscriber.add( - this.scheduler.schedule( - (state) => { - const { message: { notification }, subscriber: destination } = state!; - observeNotification(notification, destination); - }, - message.frame, - { message, subscriber } - ) - ); - } - } -} -applyMixins(ColdObservable, [SubscriptionLoggable]); diff --git a/node_modules/rxjs/src/internal/testing/HotObservable.ts b/node_modules/rxjs/src/internal/testing/HotObservable.ts deleted file mode 100644 index c151480..0000000 --- a/node_modules/rxjs/src/internal/testing/HotObservable.ts +++ /dev/null @@ -1,53 +0,0 @@ -import { Subject } from '../Subject'; -import { Subscriber } from '../Subscriber'; -import { Subscription } from '../Subscription'; -import { Scheduler } from '../Scheduler'; -import { TestMessage } from './TestMessage'; -import { SubscriptionLog } from './SubscriptionLog'; -import { SubscriptionLoggable } from './SubscriptionLoggable'; -import { applyMixins } from '../util/applyMixins'; -import { observeNotification } from '../Notification'; - -export class HotObservable<T> extends Subject<T> implements SubscriptionLoggable { - public subscriptions: SubscriptionLog[] = []; - scheduler: Scheduler; - // @ts-ignore: Property has no initializer and is not definitely assigned - logSubscribedFrame: () => number; - // @ts-ignore: Property has no initializer and is not definitely assigned - logUnsubscribedFrame: (index: number) => void; - - constructor(public messages: TestMessage[], scheduler: Scheduler) { - super(); - this.scheduler = scheduler; - } - - /** @internal */ - protected _subscribe(subscriber: Subscriber<any>): Subscription { - const subject: HotObservable<T> = this; - const index = subject.logSubscribedFrame(); - const subscription = new Subscription(); - subscription.add( - new Subscription(() => { - subject.logUnsubscribedFrame(index); - }) - ); - subscription.add(super._subscribe(subscriber)); - return subscription; - } - - setup() { - const subject = this; - const messagesLength = subject.messages.length; - /* tslint:disable:no-var-keyword */ - for (let i = 0; i < messagesLength; i++) { - (() => { - const { notification, frame } = subject.messages[i]; - /* tslint:enable */ - subject.scheduler.schedule(() => { - observeNotification(notification, subject); - }, frame); - })(); - } - } -} -applyMixins(HotObservable, [SubscriptionLoggable]); diff --git a/node_modules/rxjs/src/internal/testing/SubscriptionLog.ts b/node_modules/rxjs/src/internal/testing/SubscriptionLog.ts deleted file mode 100644 index 367a6d9..0000000 --- a/node_modules/rxjs/src/internal/testing/SubscriptionLog.ts +++ /dev/null @@ -1,5 +0,0 @@ -export class SubscriptionLog { - constructor(public subscribedFrame: number, - public unsubscribedFrame: number = Infinity) { - } -}
\ No newline at end of file diff --git a/node_modules/rxjs/src/internal/testing/SubscriptionLoggable.ts b/node_modules/rxjs/src/internal/testing/SubscriptionLoggable.ts deleted file mode 100644 index e8def04..0000000 --- a/node_modules/rxjs/src/internal/testing/SubscriptionLoggable.ts +++ /dev/null @@ -1,22 +0,0 @@ -import { Scheduler } from '../Scheduler'; -import { SubscriptionLog } from './SubscriptionLog'; - -export class SubscriptionLoggable { - public subscriptions: SubscriptionLog[] = []; - // @ts-ignore: Property has no initializer and is not definitely assigned - scheduler: Scheduler; - - logSubscribedFrame(): number { - this.subscriptions.push(new SubscriptionLog(this.scheduler.now())); - return this.subscriptions.length - 1; - } - - logUnsubscribedFrame(index: number) { - const subscriptionLogs = this.subscriptions; - const oldSubscriptionLog = subscriptionLogs[index]; - subscriptionLogs[index] = new SubscriptionLog( - oldSubscriptionLog.subscribedFrame, - this.scheduler.now() - ); - } -} diff --git a/node_modules/rxjs/src/internal/testing/TestMessage.ts b/node_modules/rxjs/src/internal/testing/TestMessage.ts deleted file mode 100644 index 918b477..0000000 --- a/node_modules/rxjs/src/internal/testing/TestMessage.ts +++ /dev/null @@ -1,7 +0,0 @@ -import { ObservableNotification } from '../types'; - -export interface TestMessage { - frame: number; - notification: ObservableNotification<any>; - isGhost?: boolean; -} diff --git a/node_modules/rxjs/src/internal/testing/TestScheduler.ts b/node_modules/rxjs/src/internal/testing/TestScheduler.ts deleted file mode 100644 index 0045166..0000000 --- a/node_modules/rxjs/src/internal/testing/TestScheduler.ts +++ /dev/null @@ -1,690 +0,0 @@ -import { Observable } from '../Observable'; -import { ColdObservable } from './ColdObservable'; -import { HotObservable } from './HotObservable'; -import { TestMessage } from './TestMessage'; -import { SubscriptionLog } from './SubscriptionLog'; -import { Subscription } from '../Subscription'; -import { VirtualTimeScheduler, VirtualAction } from '../scheduler/VirtualTimeScheduler'; -import { ObservableNotification } from '../types'; -import { COMPLETE_NOTIFICATION, errorNotification, nextNotification } from '../NotificationFactories'; -import { dateTimestampProvider } from '../scheduler/dateTimestampProvider'; -import { performanceTimestampProvider } from '../scheduler/performanceTimestampProvider'; -import { animationFrameProvider } from '../scheduler/animationFrameProvider'; -import type { TimerHandle } from '../scheduler/timerHandle'; -import { immediateProvider } from '../scheduler/immediateProvider'; -import { intervalProvider } from '../scheduler/intervalProvider'; -import { timeoutProvider } from '../scheduler/timeoutProvider'; - -const defaultMaxFrame: number = 750; - -export interface RunHelpers { - cold: typeof TestScheduler.prototype.createColdObservable; - hot: typeof TestScheduler.prototype.createHotObservable; - flush: typeof TestScheduler.prototype.flush; - time: typeof TestScheduler.prototype.createTime; - expectObservable: typeof TestScheduler.prototype.expectObservable; - expectSubscriptions: typeof TestScheduler.prototype.expectSubscriptions; - animate: (marbles: string) => void; -} - -interface FlushableTest { - ready: boolean; - actual?: any[]; - expected?: any[]; -} - -export type observableToBeFn = (marbles: string, values?: any, errorValue?: any) => void; -export type subscriptionLogsToBeFn = (marbles: string | string[]) => void; - -export class TestScheduler extends VirtualTimeScheduler { - /** - * The number of virtual time units each character in a marble diagram represents. If - * the test scheduler is being used in "run mode", via the `run` method, this is temporarily - * set to `1` for the duration of the `run` block, then set back to whatever value it was. - */ - static frameTimeFactor = 10; - - /** - * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. - */ - public readonly hotObservables: HotObservable<any>[] = []; - - /** - * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. - */ - public readonly coldObservables: ColdObservable<any>[] = []; - - /** - * Test meta data to be processed during `flush()` - */ - private flushTests: FlushableTest[] = []; - - /** - * Indicates whether the TestScheduler instance is operating in "run mode", - * meaning it's processing a call to `run()` - */ - private runMode = false; - - /** - * - * @param assertDeepEqual A function to set up your assertion for your test harness - */ - constructor(public assertDeepEqual: (actual: any, expected: any) => boolean | void) { - super(VirtualAction, defaultMaxFrame); - } - - createTime(marbles: string): number { - const indexOf = this.runMode ? marbles.trim().indexOf('|') : marbles.indexOf('|'); - if (indexOf === -1) { - throw new Error('marble diagram for time should have a completion marker "|"'); - } - return indexOf * TestScheduler.frameTimeFactor; - } - - /** - * @param marbles A diagram in the marble DSL. Letters map to keys in `values` if provided. - * @param values Values to use for the letters in `marbles`. If omitted, the letters themselves are used. - * @param error The error to use for the `#` marble (if present). - */ - createColdObservable<T = string>(marbles: string, values?: { [marble: string]: T }, error?: any): ColdObservable<T> { - if (marbles.indexOf('^') !== -1) { - throw new Error('cold observable cannot have subscription offset "^"'); - } - if (marbles.indexOf('!') !== -1) { - throw new Error('cold observable cannot have unsubscription marker "!"'); - } - const messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode); - const cold = new ColdObservable<T>(messages, this); - this.coldObservables.push(cold); - return cold; - } - - /** - * @param marbles A diagram in the marble DSL. Letters map to keys in `values` if provided. - * @param values Values to use for the letters in `marbles`. If omitted, the letters themselves are used. - * @param error The error to use for the `#` marble (if present). - */ - createHotObservable<T = string>(marbles: string, values?: { [marble: string]: T }, error?: any): HotObservable<T> { - if (marbles.indexOf('!') !== -1) { - throw new Error('hot observable cannot have unsubscription marker "!"'); - } - const messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode); - const subject = new HotObservable<T>(messages, this); - this.hotObservables.push(subject); - return subject; - } - - private materializeInnerObservable(observable: Observable<any>, outerFrame: number): TestMessage[] { - const messages: TestMessage[] = []; - observable.subscribe({ - next: (value) => { - messages.push({ frame: this.frame - outerFrame, notification: nextNotification(value) }); - }, - error: (error) => { - messages.push({ frame: this.frame - outerFrame, notification: errorNotification(error) }); - }, - complete: () => { - messages.push({ frame: this.frame - outerFrame, notification: COMPLETE_NOTIFICATION }); - }, - }); - return messages; - } - - expectObservable<T>(observable: Observable<T>, subscriptionMarbles: string | null = null) { - const actual: TestMessage[] = []; - const flushTest: FlushableTest = { actual, ready: false }; - const subscriptionParsed = TestScheduler.parseMarblesAsSubscriptions(subscriptionMarbles, this.runMode); - const subscriptionFrame = subscriptionParsed.subscribedFrame === Infinity ? 0 : subscriptionParsed.subscribedFrame; - const unsubscriptionFrame = subscriptionParsed.unsubscribedFrame; - let subscription: Subscription; - - this.schedule(() => { - subscription = observable.subscribe({ - next: (x) => { - // Support Observable-of-Observables - const value = x instanceof Observable ? this.materializeInnerObservable(x, this.frame) : x; - actual.push({ frame: this.frame, notification: nextNotification(value) }); - }, - error: (error) => { - actual.push({ frame: this.frame, notification: errorNotification(error) }); - }, - complete: () => { - actual.push({ frame: this.frame, notification: COMPLETE_NOTIFICATION }); - }, - }); - }, subscriptionFrame); - - if (unsubscriptionFrame !== Infinity) { - this.schedule(() => subscription.unsubscribe(), unsubscriptionFrame); - } - - this.flushTests.push(flushTest); - const { runMode } = this; - - return { - toBe(marbles: string, values?: any, errorValue?: any) { - flushTest.ready = true; - flushTest.expected = TestScheduler.parseMarbles(marbles, values, errorValue, true, runMode); - }, - toEqual: (other: Observable<T>) => { - flushTest.ready = true; - flushTest.expected = []; - this.schedule(() => { - subscription = other.subscribe({ - next: (x) => { - // Support Observable-of-Observables - const value = x instanceof Observable ? this.materializeInnerObservable(x, this.frame) : x; - flushTest.expected!.push({ frame: this.frame, notification: nextNotification(value) }); - }, - error: (error) => { - flushTest.expected!.push({ frame: this.frame, notification: errorNotification(error) }); - }, - complete: () => { - flushTest.expected!.push({ frame: this.frame, notification: COMPLETE_NOTIFICATION }); - }, - }); - }, subscriptionFrame); - }, - }; - } - - expectSubscriptions(actualSubscriptionLogs: SubscriptionLog[]): { toBe: subscriptionLogsToBeFn } { - const flushTest: FlushableTest = { actual: actualSubscriptionLogs, ready: false }; - this.flushTests.push(flushTest); - const { runMode } = this; - return { - toBe(marblesOrMarblesArray: string | string[]) { - const marblesArray: string[] = typeof marblesOrMarblesArray === 'string' ? [marblesOrMarblesArray] : marblesOrMarblesArray; - flushTest.ready = true; - flushTest.expected = marblesArray - .map((marbles) => TestScheduler.parseMarblesAsSubscriptions(marbles, runMode)) - .filter((marbles) => marbles.subscribedFrame !== Infinity); - }, - }; - } - - flush() { - const hotObservables = this.hotObservables; - while (hotObservables.length > 0) { - hotObservables.shift()!.setup(); - } - - super.flush(); - - this.flushTests = this.flushTests.filter((test) => { - if (test.ready) { - this.assertDeepEqual(test.actual, test.expected); - return false; - } - return true; - }); - } - - static parseMarblesAsSubscriptions(marbles: string | null, runMode = false): SubscriptionLog { - if (typeof marbles !== 'string') { - return new SubscriptionLog(Infinity); - } - // Spreading the marbles into an array leverages ES2015's support for emoji - // characters when iterating strings. - const characters = [...marbles]; - const len = characters.length; - let groupStart = -1; - let subscriptionFrame = Infinity; - let unsubscriptionFrame = Infinity; - let frame = 0; - - for (let i = 0; i < len; i++) { - let nextFrame = frame; - const advanceFrameBy = (count: number) => { - nextFrame += count * this.frameTimeFactor; - }; - const c = characters[i]; - switch (c) { - case ' ': - // Whitespace no longer advances time - if (!runMode) { - advanceFrameBy(1); - } - break; - case '-': - advanceFrameBy(1); - break; - case '(': - groupStart = frame; - advanceFrameBy(1); - break; - case ')': - groupStart = -1; - advanceFrameBy(1); - break; - case '^': - if (subscriptionFrame !== Infinity) { - throw new Error("found a second subscription point '^' in a " + 'subscription marble diagram. There can only be one.'); - } - subscriptionFrame = groupStart > -1 ? groupStart : frame; - advanceFrameBy(1); - break; - case '!': - if (unsubscriptionFrame !== Infinity) { - throw new Error("found a second unsubscription point '!' in a " + 'subscription marble diagram. There can only be one.'); - } - unsubscriptionFrame = groupStart > -1 ? groupStart : frame; - break; - default: - // time progression syntax - if (runMode && c.match(/^[0-9]$/)) { - // Time progression must be preceded by at least one space - // if it's not at the beginning of the diagram - if (i === 0 || characters[i - 1] === ' ') { - const buffer = characters.slice(i).join(''); - const match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /); - if (match) { - i += match[0].length - 1; - const duration = parseFloat(match[1]); - const unit = match[2]; - let durationInMs: number; - - switch (unit) { - case 'ms': - durationInMs = duration; - break; - case 's': - durationInMs = duration * 1000; - break; - case 'm': - durationInMs = duration * 1000 * 60; - break; - default: - break; - } - - advanceFrameBy(durationInMs! / this.frameTimeFactor); - break; - } - } - } - - throw new Error("there can only be '^' and '!' markers in a " + "subscription marble diagram. Found instead '" + c + "'."); - } - - frame = nextFrame; - } - - if (unsubscriptionFrame < 0) { - return new SubscriptionLog(subscriptionFrame); - } else { - return new SubscriptionLog(subscriptionFrame, unsubscriptionFrame); - } - } - - static parseMarbles( - marbles: string, - values?: any, - errorValue?: any, - materializeInnerObservables: boolean = false, - runMode = false - ): TestMessage[] { - if (marbles.indexOf('!') !== -1) { - throw new Error('conventional marble diagrams cannot have the ' + 'unsubscription marker "!"'); - } - // Spreading the marbles into an array leverages ES2015's support for emoji - // characters when iterating strings. - const characters = [...marbles]; - const len = characters.length; - const testMessages: TestMessage[] = []; - const subIndex = runMode ? marbles.replace(/^[ ]+/, '').indexOf('^') : marbles.indexOf('^'); - let frame = subIndex === -1 ? 0 : subIndex * -this.frameTimeFactor; - const getValue = - typeof values !== 'object' - ? (x: any) => x - : (x: any) => { - // Support Observable-of-Observables - if (materializeInnerObservables && values[x] instanceof ColdObservable) { - return values[x].messages; - } - return values[x]; - }; - let groupStart = -1; - - for (let i = 0; i < len; i++) { - let nextFrame = frame; - const advanceFrameBy = (count: number) => { - nextFrame += count * this.frameTimeFactor; - }; - - let notification: ObservableNotification<any> | undefined; - const c = characters[i]; - switch (c) { - case ' ': - // Whitespace no longer advances time - if (!runMode) { - advanceFrameBy(1); - } - break; - case '-': - advanceFrameBy(1); - break; - case '(': - groupStart = frame; - advanceFrameBy(1); - break; - case ')': - groupStart = -1; - advanceFrameBy(1); - break; - case '|': - notification = COMPLETE_NOTIFICATION; - advanceFrameBy(1); - break; - case '^': - advanceFrameBy(1); - break; - case '#': - notification = errorNotification(errorValue || 'error'); - advanceFrameBy(1); - break; - default: - // Might be time progression syntax, or a value literal - if (runMode && c.match(/^[0-9]$/)) { - // Time progression must be preceded by at least one space - // if it's not at the beginning of the diagram - if (i === 0 || characters[i - 1] === ' ') { - const buffer = characters.slice(i).join(''); - const match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /); - if (match) { - i += match[0].length - 1; - const duration = parseFloat(match[1]); - const unit = match[2]; - let durationInMs: number; - - switch (unit) { - case 'ms': - durationInMs = duration; - break; - case 's': - durationInMs = duration * 1000; - break; - case 'm': - durationInMs = duration * 1000 * 60; - break; - default: - break; - } - - advanceFrameBy(durationInMs! / this.frameTimeFactor); - break; - } - } - } - - notification = nextNotification(getValue(c)); - advanceFrameBy(1); - break; - } - - if (notification) { - testMessages.push({ frame: groupStart > -1 ? groupStart : frame, notification }); - } - - frame = nextFrame; - } - return testMessages; - } - - private createAnimator() { - if (!this.runMode) { - throw new Error('animate() must only be used in run mode'); - } - - // The TestScheduler assigns a delegate to the provider that's used for - // requestAnimationFrame (rAF). The delegate works in conjunction with the - // animate run helper to coordinate the invocation of any rAF callbacks, - // that are effected within tests, with the animation frames specified by - // the test's author - in the marbles that are passed to the animate run - // helper. This allows the test's author to write deterministic tests and - // gives the author full control over when - or if - animation frames are - // 'painted'. - - let lastHandle = 0; - let map: Map<number, FrameRequestCallback> | undefined; - - const delegate = { - requestAnimationFrame(callback: FrameRequestCallback) { - if (!map) { - throw new Error('animate() was not called within run()'); - } - const handle = ++lastHandle; - map.set(handle, callback); - return handle; - }, - cancelAnimationFrame(handle: number) { - if (!map) { - throw new Error('animate() was not called within run()'); - } - map.delete(handle); - }, - }; - - const animate = (marbles: string) => { - if (map) { - throw new Error('animate() must not be called more than once within run()'); - } - if (/[|#]/.test(marbles)) { - throw new Error('animate() must not complete or error'); - } - map = new Map<number, FrameRequestCallback>(); - const messages = TestScheduler.parseMarbles(marbles, undefined, undefined, undefined, true); - for (const message of messages) { - this.schedule(() => { - const now = this.now(); - // Capture the callbacks within the queue and clear the queue - // before enumerating the callbacks, as callbacks might - // reschedule themselves. (And, yeah, we're using a Map to represent - // the queue, but the values are guaranteed to be returned in - // insertion order, so it's all good. Trust me, I've read the docs.) - const callbacks = Array.from(map!.values()); - map!.clear(); - for (const callback of callbacks) { - callback(now); - } - }, message.frame); - } - }; - - return { animate, delegate }; - } - - private createDelegates() { - // When in run mode, the TestScheduler provides alternate implementations - // of set/clearImmediate and set/clearInterval. These implementations are - // consumed by the scheduler implementations via the providers. This is - // done to effect deterministic asap and async scheduler behavior so that - // all of the schedulers are testable in 'run mode'. Prior to v7, - // delegation occurred at the scheduler level. That is, the asap and - // animation frame schedulers were identical in behavior to the async - // scheduler. Now, when in run mode, asap actions are prioritized over - // async actions and animation frame actions are coordinated using the - // animate run helper. - - let lastHandle = 0; - const scheduleLookup = new Map< - TimerHandle, - { - due: number; - duration: number; - handle: TimerHandle; - handler: () => void; - subscription: Subscription; - type: 'immediate' | 'interval' | 'timeout'; - } - >(); - - const run = () => { - // Whenever a scheduled run is executed, it must run a single immediate - // or interval action - with immediate actions being prioritized over - // interval and timeout actions. - const now = this.now(); - const scheduledRecords = Array.from(scheduleLookup.values()); - const scheduledRecordsDue = scheduledRecords.filter(({ due }) => due <= now); - const dueImmediates = scheduledRecordsDue.filter(({ type }) => type === 'immediate'); - if (dueImmediates.length > 0) { - const { handle, handler } = dueImmediates[0]; - scheduleLookup.delete(handle); - handler(); - return; - } - const dueIntervals = scheduledRecordsDue.filter(({ type }) => type === 'interval'); - if (dueIntervals.length > 0) { - const firstDueInterval = dueIntervals[0]; - const { duration, handler } = firstDueInterval; - firstDueInterval.due = now + duration; - // The interval delegate must behave like setInterval, so run needs to - // be rescheduled. This will continue until the clearInterval delegate - // unsubscribes and deletes the handle from the map. - firstDueInterval.subscription = this.schedule(run, duration); - handler(); - return; - } - const dueTimeouts = scheduledRecordsDue.filter(({ type }) => type === 'timeout'); - if (dueTimeouts.length > 0) { - const { handle, handler } = dueTimeouts[0]; - scheduleLookup.delete(handle); - handler(); - return; - } - throw new Error('Expected a due immediate or interval'); - }; - - // The following objects are the delegates that replace conventional - // runtime implementations with TestScheduler implementations. - // - // The immediate delegate is depended upon by the asapScheduler. - // - // The interval delegate is depended upon by the asyncScheduler. - // - // The timeout delegate is not depended upon by any scheduler, but it's - // included here because the onUnhandledError and onStoppedNotification - // configuration points use setTimeout to avoid producer interference. It's - // inclusion allows for the testing of these configuration points. - - const immediate = { - setImmediate: (handler: () => void) => { - const handle = ++lastHandle; - scheduleLookup.set(handle, { - due: this.now(), - duration: 0, - handle, - handler, - subscription: this.schedule(run, 0), - type: 'immediate', - }); - return handle; - }, - clearImmediate: (handle: TimerHandle) => { - const value = scheduleLookup.get(handle); - if (value) { - value.subscription.unsubscribe(); - scheduleLookup.delete(handle); - } - }, - }; - - const interval = { - setInterval: (handler: () => void, duration = 0) => { - const handle = ++lastHandle; - scheduleLookup.set(handle, { - due: this.now() + duration, - duration, - handle, - handler, - subscription: this.schedule(run, duration), - type: 'interval', - }); - return handle; - }, - clearInterval: (handle: TimerHandle) => { - const value = scheduleLookup.get(handle); - if (value) { - value.subscription.unsubscribe(); - scheduleLookup.delete(handle); - } - }, - }; - - const timeout = { - setTimeout: (handler: () => void, duration = 0) => { - const handle = ++lastHandle; - scheduleLookup.set(handle, { - due: this.now() + duration, - duration, - handle, - handler, - subscription: this.schedule(run, duration), - type: 'timeout', - }); - return handle; - }, - clearTimeout: (handle: TimerHandle) => { - const value = scheduleLookup.get(handle); - if (value) { - value.subscription.unsubscribe(); - scheduleLookup.delete(handle); - } - }, - }; - - return { immediate, interval, timeout }; - } - - /** - * The `run` method performs the test in 'run mode' - in which schedulers - * used within the test automatically delegate to the `TestScheduler`. That - * is, in 'run mode' there is no need to explicitly pass a `TestScheduler` - * instance to observable creators or operators. - * - * @see {@link /guide/testing/marble-testing} - */ - run<T>(callback: (helpers: RunHelpers) => T): T { - const prevFrameTimeFactor = TestScheduler.frameTimeFactor; - const prevMaxFrames = this.maxFrames; - - TestScheduler.frameTimeFactor = 1; - this.maxFrames = Infinity; - this.runMode = true; - - const animator = this.createAnimator(); - const delegates = this.createDelegates(); - - animationFrameProvider.delegate = animator.delegate; - dateTimestampProvider.delegate = this; - immediateProvider.delegate = delegates.immediate; - intervalProvider.delegate = delegates.interval; - timeoutProvider.delegate = delegates.timeout; - performanceTimestampProvider.delegate = this; - - const helpers: RunHelpers = { - cold: this.createColdObservable.bind(this), - hot: this.createHotObservable.bind(this), - flush: this.flush.bind(this), - time: this.createTime.bind(this), - expectObservable: this.expectObservable.bind(this), - expectSubscriptions: this.expectSubscriptions.bind(this), - animate: animator.animate, - }; - try { - const ret = callback(helpers); - this.flush(); - return ret; - } finally { - TestScheduler.frameTimeFactor = prevFrameTimeFactor; - this.maxFrames = prevMaxFrames; - this.runMode = false; - animationFrameProvider.delegate = undefined; - dateTimestampProvider.delegate = undefined; - immediateProvider.delegate = undefined; - intervalProvider.delegate = undefined; - timeoutProvider.delegate = undefined; - performanceTimestampProvider.delegate = undefined; - } - } -} diff --git a/node_modules/rxjs/src/internal/types.ts b/node_modules/rxjs/src/internal/types.ts deleted file mode 100644 index b72eab3..0000000 --- a/node_modules/rxjs/src/internal/types.ts +++ /dev/null @@ -1,371 +0,0 @@ -// https://github.com/microsoft/TypeScript/issues/40462#issuecomment-689879308 -/// <reference lib="esnext.asynciterable" /> - -import { Observable } from './Observable'; -import { Subscription } from './Subscription'; - -/** - * Note: This will add Symbol.observable globally for all TypeScript users, - * however, we are no longer polyfilling Symbol.observable - */ -declare global { - interface SymbolConstructor { - readonly observable: symbol; - } -} - -/* OPERATOR INTERFACES */ - -/** - * A function type interface that describes a function that accepts one parameter `T` - * and returns another parameter `R`. - * - * Usually used to describe {@link OperatorFunction} - it always takes a single - * parameter (the source Observable) and returns another Observable. - */ -export interface UnaryFunction<T, R> { - (source: T): R; -} - -export interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {} - -export type FactoryOrValue<T> = T | (() => T); - -/** - * A function type interface that describes a function that accepts and returns a parameter of the same type. - * - * Used to describe {@link OperatorFunction} with the only one type: `OperatorFunction<T, T>`. - * - */ -export interface MonoTypeOperatorFunction<T> extends OperatorFunction<T, T> {} - -/** - * A value and the time at which it was emitted. - * - * Emitted by the `timestamp` operator - * - * @see {@link timestamp} - */ -export interface Timestamp<T> { - value: T; - /** - * The timestamp. By default, this is in epoch milliseconds. - * Could vary based on the timestamp provider passed to the operator. - */ - timestamp: number; -} - -/** - * A value emitted and the amount of time since the last value was emitted. - * - * Emitted by the `timeInterval` operator. - * - * @see {@link timeInterval} - */ -export interface TimeInterval<T> { - value: T; - - /** - * The amount of time between this value's emission and the previous value's emission. - * If this is the first emitted value, then it will be the amount of time since subscription - * started. - */ - interval: number; -} - -/* SUBSCRIPTION INTERFACES */ - -export interface Unsubscribable { - unsubscribe(): void; -} - -export type TeardownLogic = Subscription | Unsubscribable | (() => void) | void; - -export interface SubscriptionLike extends Unsubscribable { - unsubscribe(): void; - readonly closed: boolean; -} - -/** - * @deprecated Do not use. Most likely you want to use `ObservableInput`. Will be removed in v8. - */ -export type SubscribableOrPromise<T> = Subscribable<T> | Subscribable<never> | PromiseLike<T> | InteropObservable<T>; - -/** OBSERVABLE INTERFACES */ - -export interface Subscribable<T> { - subscribe(observer: Partial<Observer<T>>): Unsubscribable; -} - -/** - * Valid types that can be converted to observables. - */ -export type ObservableInput<T> = - | Observable<T> - | InteropObservable<T> - | AsyncIterable<T> - | PromiseLike<T> - | ArrayLike<T> - | Iterable<T> - | ReadableStreamLike<T>; - -/** - * @deprecated Renamed to {@link InteropObservable }. Will be removed in v8. - */ -export type ObservableLike<T> = InteropObservable<T>; - -/** - * An object that implements the `Symbol.observable` interface. - */ -export interface InteropObservable<T> { - [Symbol.observable]: () => Subscribable<T>; -} - -/* NOTIFICATIONS */ - -/** - * A notification representing a "next" from an observable. - * Can be used with {@link dematerialize}. - */ -export interface NextNotification<T> { - /** The kind of notification. Always "N" */ - kind: 'N'; - /** The value of the notification. */ - value: T; -} - -/** - * A notification representing an "error" from an observable. - * Can be used with {@link dematerialize}. - */ -export interface ErrorNotification { - /** The kind of notification. Always "E" */ - kind: 'E'; - error: any; -} - -/** - * A notification representing a "completion" from an observable. - * Can be used with {@link dematerialize}. - */ -export interface CompleteNotification { - kind: 'C'; -} - -/** - * Valid observable notification types. - */ -export type ObservableNotification<T> = NextNotification<T> | ErrorNotification | CompleteNotification; - -/* OBSERVER INTERFACES */ - -export interface NextObserver<T> { - closed?: boolean; - next: (value: T) => void; - error?: (err: any) => void; - complete?: () => void; -} - -export interface ErrorObserver<T> { - closed?: boolean; - next?: (value: T) => void; - error: (err: any) => void; - complete?: () => void; -} - -export interface CompletionObserver<T> { - closed?: boolean; - next?: (value: T) => void; - error?: (err: any) => void; - complete: () => void; -} - -export type PartialObserver<T> = NextObserver<T> | ErrorObserver<T> | CompletionObserver<T>; - -/** - * An object interface that defines a set of callback functions a user can use to get - * notified of any set of {@link Observable} - * {@link guide/glossary-and-semantics#notification notification} events. - * - * For more info, please refer to {@link guide/observer this guide}. - */ -export interface Observer<T> { - /** - * A callback function that gets called by the producer during the subscription when - * the producer "has" the `value`. It won't be called if `error` or `complete` callback - * functions have been called, nor after the consumer has unsubscribed. - * - * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}. - */ - next: (value: T) => void; - /** - * A callback function that gets called by the producer if and when it encountered a - * problem of any kind. The errored value will be provided through the `err` parameter. - * This callback can't be called more than one time, it can't be called if the - * `complete` callback function have been called previously, nor it can't be called if - * the consumer has unsubscribed. - * - * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}. - */ - error: (err: any) => void; - /** - * A callback function that gets called by the producer if and when it has no more - * values to provide (by calling `next` callback function). This means that no error - * has happened. This callback can't be called more than one time, it can't be called - * if the `error` callback function have been called previously, nor it can't be called - * if the consumer has unsubscribed. - * - * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}. - */ - complete: () => void; -} - -export interface SubjectLike<T> extends Observer<T>, Subscribable<T> {} - -/* SCHEDULER INTERFACES */ - -export interface SchedulerLike extends TimestampProvider { - schedule<T>(work: (this: SchedulerAction<T>, state: T) => void, delay: number, state: T): Subscription; - schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay: number, state?: T): Subscription; - schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription; -} - -export interface SchedulerAction<T> extends Subscription { - schedule(state?: T, delay?: number): Subscription; -} - -/** - * This is a type that provides a method to allow RxJS to create a numeric timestamp - */ -export interface TimestampProvider { - /** - * Returns a timestamp as a number. - * - * This is used by types like `ReplaySubject` or operators like `timestamp` to calculate - * the amount of time passed between events. - */ - now(): number; -} - -/** - * Extracts the type from an `ObservableInput<any>`. If you have - * `O extends ObservableInput<any>` and you pass in `Observable<number>`, or - * `Promise<number>`, etc, it will type as `number`. - */ -export type ObservedValueOf<O> = O extends ObservableInput<infer T> ? T : never; - -/** - * Extracts a union of element types from an `ObservableInput<any>[]`. - * If you have `O extends ObservableInput<any>[]` and you pass in - * `Observable<string>[]` or `Promise<string>[]` you would get - * back a type of `string`. - * If you pass in `[Observable<string>, Observable<number>]` you would - * get back a type of `string | number`. - */ -export type ObservedValueUnionFromArray<X> = X extends Array<ObservableInput<infer T>> ? T : never; - -/** - * @deprecated Renamed to {@link ObservedValueUnionFromArray}. Will be removed in v8. - */ -export type ObservedValuesFromArray<X> = ObservedValueUnionFromArray<X>; - -/** - * Extracts a tuple of element types from an `ObservableInput<any>[]`. - * If you have `O extends ObservableInput<any>[]` and you pass in - * `[Observable<string>, Observable<number>]` you would get back a type - * of `[string, number]`. - */ -export type ObservedValueTupleFromArray<X> = { [K in keyof X]: ObservedValueOf<X[K]> }; - -/** - * Used to infer types from arguments to functions like {@link forkJoin}. - * So that you can have `forkJoin([Observable<A>, PromiseLike<B>]): Observable<[A, B]>` - * et al. - */ -export type ObservableInputTuple<T> = { - [K in keyof T]: ObservableInput<T[K]>; -}; - -/** - * Constructs a new tuple with the specified type at the head. - * If you declare `Cons<A, [B, C]>` you will get back `[A, B, C]`. - */ -export type Cons<X, Y extends readonly any[]> = ((arg: X, ...rest: Y) => any) extends (...args: infer U) => any ? U : never; - -/** - * Extracts the head of a tuple. - * If you declare `Head<[A, B, C]>` you will get back `A`. - */ -export type Head<X extends readonly any[]> = ((...args: X) => any) extends (arg: infer U, ...rest: any[]) => any ? U : never; - -/** - * Extracts the tail of a tuple. - * If you declare `Tail<[A, B, C]>` you will get back `[B, C]`. - */ -export type Tail<X extends readonly any[]> = ((...args: X) => any) extends (arg: any, ...rest: infer U) => any ? U : never; - -/** - * Extracts the generic value from an Array type. - * If you have `T extends Array<any>`, and pass a `string[]` to it, - * `ValueFromArray<T>` will return the actual type of `string`. - */ -export type ValueFromArray<A extends readonly unknown[]> = A extends Array<infer T> ? T : never; - -/** - * Gets the value type from an {@link ObservableNotification}, if possible. - */ -export type ValueFromNotification<T> = T extends { kind: 'N' | 'E' | 'C' } - ? T extends NextNotification<any> - ? T extends { value: infer V } - ? V - : undefined - : never - : never; - -/** - * A simple type to represent a gamut of "falsy" values... with a notable exception: - * `NaN` is "falsy" however, it is not and cannot be typed via TypeScript. See - * comments here: https://github.com/microsoft/TypeScript/issues/28682#issuecomment-707142417 - */ -export type Falsy = null | undefined | false | 0 | -0 | 0n | ''; - -export type TruthyTypesOf<T> = T extends Falsy ? never : T; - -// We shouldn't rely on this type definition being available globally yet since it's -// not necessarily available in every TS environment. -interface ReadableStreamDefaultReaderLike<T> { - // HACK: As of TS 4.2.2, The provided types for the iterator results of a `ReadableStreamDefaultReader` - // are significantly different enough from `IteratorResult` as to cause compilation errors. - // The type at the time is `ReadableStreamDefaultReadResult`. - read(): PromiseLike< - | { - done: false; - value: T; - } - | { done: true; value?: undefined } - >; - releaseLock(): void; -} - -/** - * The base signature RxJS will look for to identify and use - * a [ReadableStream](https://streams.spec.whatwg.org/#rs-class) - * as an {@link ObservableInput} source. - */ -export interface ReadableStreamLike<T> { - getReader(): ReadableStreamDefaultReaderLike<T>; -} - -/** - * An observable with a `connect` method that is used to create a subscription - * to an underlying source, connecting it with all consumers via a multicast. - */ -export interface Connectable<T> extends Observable<T> { - /** - * (Idempotent) Calling this method will connect the underlying source observable to all subscribed consumers - * through an underlying {@link Subject}. - * @returns A subscription, that when unsubscribed, will "disconnect" the source from the connector subject, - * severing notifications to all consumers. - */ - connect(): Subscription; -} diff --git a/node_modules/rxjs/src/internal/umd.ts b/node_modules/rxjs/src/internal/umd.ts deleted file mode 100644 index e81c574..0000000 --- a/node_modules/rxjs/src/internal/umd.ts +++ /dev/null @@ -1,26 +0,0 @@ -/* - NOTE: This is the global export file for rxjs v6 and higher. - */ - -/* rxjs */ -export * from '../index'; - -/* rxjs.operators */ -import * as _operators from '../operators/index'; -export const operators = _operators; - -/* rxjs.testing */ -import * as _testing from '../testing/index'; -export const testing = _testing; - -/* rxjs.ajax */ -import * as _ajax from '../ajax/index'; -export const ajax = _ajax; - -/* rxjs.webSocket */ -import * as _webSocket from '../webSocket/index'; -export const webSocket = _webSocket; - -/* rxjs.fetch */ -import * as _fetch from '../fetch/index'; -export const fetch = _fetch; diff --git a/node_modules/rxjs/src/internal/util/ArgumentOutOfRangeError.ts b/node_modules/rxjs/src/internal/util/ArgumentOutOfRangeError.ts deleted file mode 100644 index 9a89d76..0000000 --- a/node_modules/rxjs/src/internal/util/ArgumentOutOfRangeError.ts +++ /dev/null @@ -1,28 +0,0 @@ -import { createErrorClass } from './createErrorClass'; - -export interface ArgumentOutOfRangeError extends Error {} - -export interface ArgumentOutOfRangeErrorCtor { - /** - * @deprecated Internal implementation detail. Do not construct error instances. - * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269 - */ - new (): ArgumentOutOfRangeError; -} - -/** - * An error thrown when an element was queried at a certain index of an - * Observable, but no such index or position exists in that sequence. - * - * @see {@link elementAt} - * @see {@link take} - * @see {@link takeLast} - */ -export const ArgumentOutOfRangeError: ArgumentOutOfRangeErrorCtor = createErrorClass( - (_super) => - function ArgumentOutOfRangeErrorImpl(this: any) { - _super(this); - this.name = 'ArgumentOutOfRangeError'; - this.message = 'argument out of range'; - } -); diff --git a/node_modules/rxjs/src/internal/util/EmptyError.ts b/node_modules/rxjs/src/internal/util/EmptyError.ts deleted file mode 100644 index eb2c5e3..0000000 --- a/node_modules/rxjs/src/internal/util/EmptyError.ts +++ /dev/null @@ -1,30 +0,0 @@ -import { createErrorClass } from './createErrorClass'; - -export interface EmptyError extends Error {} - -export interface EmptyErrorCtor { - /** - * @deprecated Internal implementation detail. Do not construct error instances. - * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269 - */ - new (): EmptyError; -} - -/** - * An error thrown when an Observable or a sequence was queried but has no - * elements. - * - * @see {@link first} - * @see {@link last} - * @see {@link single} - * @see {@link firstValueFrom} - * @see {@link lastValueFrom} - */ -export const EmptyError: EmptyErrorCtor = createErrorClass( - (_super) => - function EmptyErrorImpl(this: any) { - _super(this); - this.name = 'EmptyError'; - this.message = 'no elements in sequence'; - } -); diff --git a/node_modules/rxjs/src/internal/util/Immediate.ts b/node_modules/rxjs/src/internal/util/Immediate.ts deleted file mode 100644 index f01f546..0000000 --- a/node_modules/rxjs/src/internal/util/Immediate.ts +++ /dev/null @@ -1,45 +0,0 @@ -let nextHandle = 1; -// The promise needs to be created lazily otherwise it won't be patched by Zones -let resolved: Promise<any>; -const activeHandles: { [key: number]: any } = {}; - -/** - * Finds the handle in the list of active handles, and removes it. - * Returns `true` if found, `false` otherwise. Used both to clear - * Immediate scheduled tasks, and to identify if a task should be scheduled. - */ -function findAndClearHandle(handle: number): boolean { - if (handle in activeHandles) { - delete activeHandles[handle]; - return true; - } - return false; -} - -/** - * Helper functions to schedule and unschedule microtasks. - */ -export const Immediate = { - setImmediate(cb: () => void): number { - const handle = nextHandle++; - activeHandles[handle] = true; - if (!resolved) { - resolved = Promise.resolve(); - } - resolved.then(() => findAndClearHandle(handle) && cb()); - return handle; - }, - - clearImmediate(handle: number): void { - findAndClearHandle(handle); - }, -}; - -/** - * Used for internal testing purposes only. Do not export from library. - */ -export const TestTools = { - pending() { - return Object.keys(activeHandles).length; - } -}; diff --git a/node_modules/rxjs/src/internal/util/NotFoundError.ts b/node_modules/rxjs/src/internal/util/NotFoundError.ts deleted file mode 100644 index ecd213f..0000000 --- a/node_modules/rxjs/src/internal/util/NotFoundError.ts +++ /dev/null @@ -1,26 +0,0 @@ -import { createErrorClass } from './createErrorClass'; - -export interface NotFoundError extends Error {} - -export interface NotFoundErrorCtor { - /** - * @deprecated Internal implementation detail. Do not construct error instances. - * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269 - */ - new (message: string): NotFoundError; -} - -/** - * An error thrown when a value or values are missing from an - * observable sequence. - * - * @see {@link operators/single} - */ -export const NotFoundError: NotFoundErrorCtor = createErrorClass( - (_super) => - function NotFoundErrorImpl(this: any, message: string) { - _super(this); - this.name = 'NotFoundError'; - this.message = message; - } -); diff --git a/node_modules/rxjs/src/internal/util/ObjectUnsubscribedError.ts b/node_modules/rxjs/src/internal/util/ObjectUnsubscribedError.ts deleted file mode 100644 index 5e833f9..0000000 --- a/node_modules/rxjs/src/internal/util/ObjectUnsubscribedError.ts +++ /dev/null @@ -1,29 +0,0 @@ -import { createErrorClass } from './createErrorClass'; - -export interface ObjectUnsubscribedError extends Error {} - -export interface ObjectUnsubscribedErrorCtor { - /** - * @deprecated Internal implementation detail. Do not construct error instances. - * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269 - */ - new (): ObjectUnsubscribedError; -} - -/** - * An error thrown when an action is invalid because the object has been - * unsubscribed. - * - * @see {@link Subject} - * @see {@link BehaviorSubject} - * - * @class ObjectUnsubscribedError - */ -export const ObjectUnsubscribedError: ObjectUnsubscribedErrorCtor = createErrorClass( - (_super) => - function ObjectUnsubscribedErrorImpl(this: any) { - _super(this); - this.name = 'ObjectUnsubscribedError'; - this.message = 'object unsubscribed'; - } -); diff --git a/node_modules/rxjs/src/internal/util/SequenceError.ts b/node_modules/rxjs/src/internal/util/SequenceError.ts deleted file mode 100644 index 06483d0..0000000 --- a/node_modules/rxjs/src/internal/util/SequenceError.ts +++ /dev/null @@ -1,26 +0,0 @@ -import { createErrorClass } from './createErrorClass'; - -export interface SequenceError extends Error {} - -export interface SequenceErrorCtor { - /** - * @deprecated Internal implementation detail. Do not construct error instances. - * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269 - */ - new (message: string): SequenceError; -} - -/** - * An error thrown when something is wrong with the sequence of - * values arriving on the observable. - * - * @see {@link operators/single} - */ -export const SequenceError: SequenceErrorCtor = createErrorClass( - (_super) => - function SequenceErrorImpl(this: any, message: string) { - _super(this); - this.name = 'SequenceError'; - this.message = message; - } -); diff --git a/node_modules/rxjs/src/internal/util/UnsubscriptionError.ts b/node_modules/rxjs/src/internal/util/UnsubscriptionError.ts deleted file mode 100644 index cd7d09f..0000000 --- a/node_modules/rxjs/src/internal/util/UnsubscriptionError.ts +++ /dev/null @@ -1,30 +0,0 @@ -import { createErrorClass } from './createErrorClass'; - -export interface UnsubscriptionError extends Error { - readonly errors: any[]; -} - -export interface UnsubscriptionErrorCtor { - /** - * @deprecated Internal implementation detail. Do not construct error instances. - * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269 - */ - new (errors: any[]): UnsubscriptionError; -} - -/** - * An error thrown when one or more errors have occurred during the - * `unsubscribe` of a {@link Subscription}. - */ -export const UnsubscriptionError: UnsubscriptionErrorCtor = createErrorClass( - (_super) => - function UnsubscriptionErrorImpl(this: any, errors: (Error | string)[]) { - _super(this); - this.message = errors - ? `${errors.length} errors occurred during unsubscription: -${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n ')}` - : ''; - this.name = 'UnsubscriptionError'; - this.errors = errors; - } -); diff --git a/node_modules/rxjs/src/internal/util/applyMixins.ts b/node_modules/rxjs/src/internal/util/applyMixins.ts deleted file mode 100644 index 7c1ed24..0000000 --- a/node_modules/rxjs/src/internal/util/applyMixins.ts +++ /dev/null @@ -1,10 +0,0 @@ -export function applyMixins(derivedCtor: any, baseCtors: any[]) { - for (let i = 0, len = baseCtors.length; i < len; i++) { - const baseCtor = baseCtors[i]; - const propertyKeys = Object.getOwnPropertyNames(baseCtor.prototype); - for (let j = 0, len2 = propertyKeys.length; j < len2; j++) { - const name = propertyKeys[j]; - derivedCtor.prototype[name] = baseCtor.prototype[name]; - } - } -}
\ No newline at end of file diff --git a/node_modules/rxjs/src/internal/util/args.ts b/node_modules/rxjs/src/internal/util/args.ts deleted file mode 100644 index 0ce104b..0000000 --- a/node_modules/rxjs/src/internal/util/args.ts +++ /dev/null @@ -1,19 +0,0 @@ -import { SchedulerLike } from '../types'; -import { isFunction } from './isFunction'; -import { isScheduler } from './isScheduler'; - -function last<T>(arr: T[]): T | undefined { - return arr[arr.length - 1]; -} - -export function popResultSelector(args: any[]): ((...args: unknown[]) => unknown) | undefined { - return isFunction(last(args)) ? args.pop() : undefined; -} - -export function popScheduler(args: any[]): SchedulerLike | undefined { - return isScheduler(last(args)) ? args.pop() : undefined; -} - -export function popNumber(args: any[], defaultValue: number): number { - return typeof last(args) === 'number' ? args.pop()! : defaultValue; -} diff --git a/node_modules/rxjs/src/internal/util/argsArgArrayOrObject.ts b/node_modules/rxjs/src/internal/util/argsArgArrayOrObject.ts deleted file mode 100644 index 483bef9..0000000 --- a/node_modules/rxjs/src/internal/util/argsArgArrayOrObject.ts +++ /dev/null @@ -1,30 +0,0 @@ -const { isArray } = Array; -const { getPrototypeOf, prototype: objectProto, keys: getKeys } = Object; - -/** - * Used in functions where either a list of arguments, a single array of arguments, or a - * dictionary of arguments can be returned. Returns an object with an `args` property with - * the arguments in an array, if it is a dictionary, it will also return the `keys` in another - * property. - */ -export function argsArgArrayOrObject<T, O extends Record<string, T>>(args: T[] | [O] | [T[]]): { args: T[]; keys: string[] | null } { - if (args.length === 1) { - const first = args[0]; - if (isArray(first)) { - return { args: first, keys: null }; - } - if (isPOJO(first)) { - const keys = getKeys(first); - return { - args: keys.map((key) => first[key]), - keys, - }; - } - } - - return { args: args as T[], keys: null }; -} - -function isPOJO(obj: any): obj is object { - return obj && typeof obj === 'object' && getPrototypeOf(obj) === objectProto; -} diff --git a/node_modules/rxjs/src/internal/util/argsOrArgArray.ts b/node_modules/rxjs/src/internal/util/argsOrArgArray.ts deleted file mode 100644 index b0096ce..0000000 --- a/node_modules/rxjs/src/internal/util/argsOrArgArray.ts +++ /dev/null @@ -1,9 +0,0 @@ -const { isArray } = Array; - -/** - * Used in operators and functions that accept either a list of arguments, or an array of arguments - * as a single argument. - */ -export function argsOrArgArray<T>(args: (T | T[])[]): T[] { - return args.length === 1 && isArray(args[0]) ? args[0] : (args as T[]); -} diff --git a/node_modules/rxjs/src/internal/util/arrRemove.ts b/node_modules/rxjs/src/internal/util/arrRemove.ts deleted file mode 100644 index 51a76cd..0000000 --- a/node_modules/rxjs/src/internal/util/arrRemove.ts +++ /dev/null @@ -1,11 +0,0 @@ -/** - * Removes an item from an array, mutating it. - * @param arr The array to remove the item from - * @param item The item to remove - */ -export function arrRemove<T>(arr: T[] | undefined | null, item: T) { - if (arr) { - const index = arr.indexOf(item); - 0 <= index && arr.splice(index, 1); - } -} diff --git a/node_modules/rxjs/src/internal/util/createErrorClass.ts b/node_modules/rxjs/src/internal/util/createErrorClass.ts deleted file mode 100644 index e354fd3..0000000 --- a/node_modules/rxjs/src/internal/util/createErrorClass.ts +++ /dev/null @@ -1,20 +0,0 @@ -/** - * Used to create Error subclasses until the community moves away from ES5. - * - * This is because compiling from TypeScript down to ES5 has issues with subclassing Errors - * as well as other built-in types: https://github.com/Microsoft/TypeScript/issues/12123 - * - * @param createImpl A factory function to create the actual constructor implementation. The returned - * function should be a named function that calls `_super` internally. - */ -export function createErrorClass<T>(createImpl: (_super: any) => any): T { - const _super = (instance: any) => { - Error.call(instance); - instance.stack = new Error().stack; - }; - - const ctorFunc = createImpl(_super); - ctorFunc.prototype = Object.create(Error.prototype); - ctorFunc.prototype.constructor = ctorFunc; - return ctorFunc; -} diff --git a/node_modules/rxjs/src/internal/util/createObject.ts b/node_modules/rxjs/src/internal/util/createObject.ts deleted file mode 100644 index 0f79f92..0000000 --- a/node_modules/rxjs/src/internal/util/createObject.ts +++ /dev/null @@ -1,3 +0,0 @@ -export function createObject(keys: string[], values: any[]) { - return keys.reduce((result, key, i) => ((result[key] = values[i]), result), {} as any); -} diff --git a/node_modules/rxjs/src/internal/util/errorContext.ts b/node_modules/rxjs/src/internal/util/errorContext.ts deleted file mode 100644 index 6c4ffb1..0000000 --- a/node_modules/rxjs/src/internal/util/errorContext.ts +++ /dev/null @@ -1,42 +0,0 @@ -import { config } from '../config'; - -let context: { errorThrown: boolean; error: any } | null = null; - -/** - * Handles dealing with errors for super-gross mode. Creates a context, in which - * any synchronously thrown errors will be passed to {@link captureError}. Which - * will record the error such that it will be rethrown after the call back is complete. - * TODO: Remove in v8 - * @param cb An immediately executed function. - */ -export function errorContext(cb: () => void) { - if (config.useDeprecatedSynchronousErrorHandling) { - const isRoot = !context; - if (isRoot) { - context = { errorThrown: false, error: null }; - } - cb(); - if (isRoot) { - const { errorThrown, error } = context!; - context = null; - if (errorThrown) { - throw error; - } - } - } else { - // This is the general non-deprecated path for everyone that - // isn't crazy enough to use super-gross mode (useDeprecatedSynchronousErrorHandling) - cb(); - } -} - -/** - * Captures errors only in super-gross mode. - * @param err the error to capture - */ -export function captureError(err: any) { - if (config.useDeprecatedSynchronousErrorHandling && context) { - context.errorThrown = true; - context.error = err; - } -} diff --git a/node_modules/rxjs/src/internal/util/executeSchedule.ts b/node_modules/rxjs/src/internal/util/executeSchedule.ts deleted file mode 100644 index 1bcb990..0000000 --- a/node_modules/rxjs/src/internal/util/executeSchedule.ts +++ /dev/null @@ -1,44 +0,0 @@ -import { Subscription } from '../Subscription'; -import { SchedulerAction, SchedulerLike } from '../types'; - -export function executeSchedule( - parentSubscription: Subscription, - scheduler: SchedulerLike, - work: () => void, - delay: number, - repeat: true -): void; -export function executeSchedule( - parentSubscription: Subscription, - scheduler: SchedulerLike, - work: () => void, - delay?: number, - repeat?: false -): Subscription; - -export function executeSchedule( - parentSubscription: Subscription, - scheduler: SchedulerLike, - work: () => void, - delay = 0, - repeat = false -): Subscription | void { - const scheduleSubscription = scheduler.schedule(function (this: SchedulerAction<any>) { - work(); - if (repeat) { - parentSubscription.add(this.schedule(null, delay)); - } else { - this.unsubscribe(); - } - }, delay); - - parentSubscription.add(scheduleSubscription); - - if (!repeat) { - // Because user-land scheduler implementations are unlikely to properly reuse - // Actions for repeat scheduling, we can't trust that the returned subscription - // will control repeat subscription scenarios. So we're trying to avoid using them - // incorrectly within this library. - return scheduleSubscription; - } -} diff --git a/node_modules/rxjs/src/internal/util/identity.ts b/node_modules/rxjs/src/internal/util/identity.ts deleted file mode 100644 index 0b07958..0000000 --- a/node_modules/rxjs/src/internal/util/identity.ts +++ /dev/null @@ -1,45 +0,0 @@ -/** - * This function takes one parameter and just returns it. Simply put, - * this is like `<T>(x: T): T => x`. - * - * ## Examples - * - * This is useful in some cases when using things like `mergeMap` - * - * ```ts - * import { interval, take, map, range, mergeMap, identity } from 'rxjs'; - * - * const source$ = interval(1000).pipe(take(5)); - * - * const result$ = source$.pipe( - * map(i => range(i)), - * mergeMap(identity) // same as mergeMap(x => x) - * ); - * - * result$.subscribe({ - * next: console.log - * }); - * ``` - * - * Or when you want to selectively apply an operator - * - * ```ts - * import { interval, take, identity } from 'rxjs'; - * - * const shouldLimit = () => Math.random() < 0.5; - * - * const source$ = interval(1000); - * - * const result$ = source$.pipe(shouldLimit() ? take(5) : identity); - * - * result$.subscribe({ - * next: console.log - * }); - * ``` - * - * @param x Any value that is returned by this function - * @returns The value passed as the first parameter to this function - */ -export function identity<T>(x: T): T { - return x; -} diff --git a/node_modules/rxjs/src/internal/util/isArrayLike.ts b/node_modules/rxjs/src/internal/util/isArrayLike.ts deleted file mode 100644 index 6f634d4..0000000 --- a/node_modules/rxjs/src/internal/util/isArrayLike.ts +++ /dev/null @@ -1 +0,0 @@ -export const isArrayLike = (<T>(x: any): x is ArrayLike<T> => x && typeof x.length === 'number' && typeof x !== 'function');
\ No newline at end of file diff --git a/node_modules/rxjs/src/internal/util/isAsyncIterable.ts b/node_modules/rxjs/src/internal/util/isAsyncIterable.ts deleted file mode 100644 index d419dc3..0000000 --- a/node_modules/rxjs/src/internal/util/isAsyncIterable.ts +++ /dev/null @@ -1,5 +0,0 @@ -import { isFunction } from './isFunction'; - -export function isAsyncIterable<T>(obj: any): obj is AsyncIterable<T> { - return Symbol.asyncIterator && isFunction(obj?.[Symbol.asyncIterator]); -} diff --git a/node_modules/rxjs/src/internal/util/isDate.ts b/node_modules/rxjs/src/internal/util/isDate.ts deleted file mode 100644 index ed09ffb..0000000 --- a/node_modules/rxjs/src/internal/util/isDate.ts +++ /dev/null @@ -1,10 +0,0 @@ -/** - * Checks to see if a value is not only a `Date` object, - * but a *valid* `Date` object that can be converted to a - * number. For example, `new Date('blah')` is indeed an - * `instanceof Date`, however it cannot be converted to a - * number. - */ -export function isValidDate(value: any): value is Date { - return value instanceof Date && !isNaN(value as any); -} diff --git a/node_modules/rxjs/src/internal/util/isFunction.ts b/node_modules/rxjs/src/internal/util/isFunction.ts deleted file mode 100644 index 2715f07..0000000 --- a/node_modules/rxjs/src/internal/util/isFunction.ts +++ /dev/null @@ -1,7 +0,0 @@ -/** - * Returns true if the object is a function. - * @param value The value to check - */ -export function isFunction(value: any): value is (...args: any[]) => any { - return typeof value === 'function'; -} diff --git a/node_modules/rxjs/src/internal/util/isInteropObservable.ts b/node_modules/rxjs/src/internal/util/isInteropObservable.ts deleted file mode 100644 index e709b8a..0000000 --- a/node_modules/rxjs/src/internal/util/isInteropObservable.ts +++ /dev/null @@ -1,8 +0,0 @@ -import { InteropObservable } from '../types'; -import { observable as Symbol_observable } from '../symbol/observable'; -import { isFunction } from './isFunction'; - -/** Identifies an input as being Observable (but not necessary an Rx Observable) */ -export function isInteropObservable(input: any): input is InteropObservable<any> { - return isFunction(input[Symbol_observable]); -} diff --git a/node_modules/rxjs/src/internal/util/isIterable.ts b/node_modules/rxjs/src/internal/util/isIterable.ts deleted file mode 100644 index 9b492b3..0000000 --- a/node_modules/rxjs/src/internal/util/isIterable.ts +++ /dev/null @@ -1,7 +0,0 @@ -import { iterator as Symbol_iterator } from '../symbol/iterator'; -import { isFunction } from './isFunction'; - -/** Identifies an input as being an Iterable */ -export function isIterable(input: any): input is Iterable<any> { - return isFunction(input?.[Symbol_iterator]); -} diff --git a/node_modules/rxjs/src/internal/util/isObservable.ts b/node_modules/rxjs/src/internal/util/isObservable.ts deleted file mode 100644 index 8df8f32..0000000 --- a/node_modules/rxjs/src/internal/util/isObservable.ts +++ /dev/null @@ -1,13 +0,0 @@ -/** prettier */ -import { Observable } from '../Observable'; -import { isFunction } from './isFunction'; - -/** - * Tests to see if the object is an RxJS {@link Observable} - * @param obj the object to test - */ -export function isObservable(obj: any): obj is Observable<unknown> { - // The !! is to ensure that this publicly exposed function returns - // `false` if something like `null` or `0` is passed. - return !!obj && (obj instanceof Observable || (isFunction(obj.lift) && isFunction(obj.subscribe))); -} diff --git a/node_modules/rxjs/src/internal/util/isPromise.ts b/node_modules/rxjs/src/internal/util/isPromise.ts deleted file mode 100644 index 0baef64..0000000 --- a/node_modules/rxjs/src/internal/util/isPromise.ts +++ /dev/null @@ -1,9 +0,0 @@ -import { isFunction } from "./isFunction"; - -/** - * Tests to see if the object is "thennable". - * @param value the object to test - */ -export function isPromise(value: any): value is PromiseLike<any> { - return isFunction(value?.then); -} diff --git a/node_modules/rxjs/src/internal/util/isReadableStreamLike.ts b/node_modules/rxjs/src/internal/util/isReadableStreamLike.ts deleted file mode 100644 index 87b9c15..0000000 --- a/node_modules/rxjs/src/internal/util/isReadableStreamLike.ts +++ /dev/null @@ -1,23 +0,0 @@ -import { ReadableStreamLike } from '../types'; -import { isFunction } from './isFunction'; - -export async function* readableStreamLikeToAsyncGenerator<T>(readableStream: ReadableStreamLike<T>): AsyncGenerator<T> { - const reader = readableStream.getReader(); - try { - while (true) { - const { value, done } = await reader.read(); - if (done) { - return; - } - yield value!; - } - } finally { - reader.releaseLock(); - } -} - -export function isReadableStreamLike<T>(obj: any): obj is ReadableStreamLike<T> { - // We don't want to use instanceof checks because they would return - // false for instances from another Realm, like an <iframe>. - return isFunction(obj?.getReader); -} diff --git a/node_modules/rxjs/src/internal/util/isScheduler.ts b/node_modules/rxjs/src/internal/util/isScheduler.ts deleted file mode 100644 index f81ee08..0000000 --- a/node_modules/rxjs/src/internal/util/isScheduler.ts +++ /dev/null @@ -1,6 +0,0 @@ -import { SchedulerLike } from '../types'; -import { isFunction } from './isFunction'; - -export function isScheduler(value: any): value is SchedulerLike { - return value && isFunction(value.schedule); -} diff --git a/node_modules/rxjs/src/internal/util/lift.ts b/node_modules/rxjs/src/internal/util/lift.ts deleted file mode 100644 index e841ec3..0000000 --- a/node_modules/rxjs/src/internal/util/lift.ts +++ /dev/null @@ -1,32 +0,0 @@ -import { Observable } from '../Observable'; -import { Subscriber } from '../Subscriber'; -import { OperatorFunction } from '../types'; -import { isFunction } from './isFunction'; - -/** - * Used to determine if an object is an Observable with a lift function. - */ -export function hasLift(source: any): source is { lift: InstanceType<typeof Observable>['lift'] } { - return isFunction(source?.lift); -} - -/** - * Creates an `OperatorFunction`. Used to define operators throughout the library in a concise way. - * @param init The logic to connect the liftedSource to the subscriber at the moment of subscription. - */ -export function operate<T, R>( - init: (liftedSource: Observable<T>, subscriber: Subscriber<R>) => (() => void) | void -): OperatorFunction<T, R> { - return (source: Observable<T>) => { - if (hasLift(source)) { - return source.lift(function (this: Subscriber<R>, liftedSource: Observable<T>) { - try { - return init(liftedSource, this); - } catch (err) { - this.error(err); - } - }); - } - throw new TypeError('Unable to lift unknown Observable type'); - }; -} diff --git a/node_modules/rxjs/src/internal/util/mapOneOrManyArgs.ts b/node_modules/rxjs/src/internal/util/mapOneOrManyArgs.ts deleted file mode 100644 index ded1420..0000000 --- a/node_modules/rxjs/src/internal/util/mapOneOrManyArgs.ts +++ /dev/null @@ -1,16 +0,0 @@ -import { OperatorFunction } from "../types"; -import { map } from "../operators/map"; - -const { isArray } = Array; - -function callOrApply<T, R>(fn: ((...values: T[]) => R), args: T|T[]): R { - return isArray(args) ? fn(...args) : fn(args); -} - -/** - * Used in several -- mostly deprecated -- situations where we need to - * apply a list of arguments or a single argument to a result selector. - */ -export function mapOneOrManyArgs<T, R>(fn: ((...values: T[]) => R)): OperatorFunction<T|T[], R> { - return map(args => callOrApply(fn, args)) -}
\ No newline at end of file diff --git a/node_modules/rxjs/src/internal/util/noop.ts b/node_modules/rxjs/src/internal/util/noop.ts deleted file mode 100644 index fc857f2..0000000 --- a/node_modules/rxjs/src/internal/util/noop.ts +++ /dev/null @@ -1,2 +0,0 @@ -/* tslint:disable:no-empty */ -export function noop() { } diff --git a/node_modules/rxjs/src/internal/util/not.ts b/node_modules/rxjs/src/internal/util/not.ts deleted file mode 100644 index 5e5d7e2..0000000 --- a/node_modules/rxjs/src/internal/util/not.ts +++ /dev/null @@ -1,3 +0,0 @@ -export function not<T>(pred: (value: T, index: number) => boolean, thisArg: any): (value: T, index: number) => boolean { - return (value: T, index: number) => !pred.call(thisArg, value, index); -}
\ No newline at end of file diff --git a/node_modules/rxjs/src/internal/util/pipe.ts b/node_modules/rxjs/src/internal/util/pipe.ts deleted file mode 100644 index ff69acc..0000000 --- a/node_modules/rxjs/src/internal/util/pipe.ts +++ /dev/null @@ -1,95 +0,0 @@ -import { identity } from './identity'; -import { UnaryFunction } from '../types'; - -export function pipe(): typeof identity; -export function pipe<T, A>(fn1: UnaryFunction<T, A>): UnaryFunction<T, A>; -export function pipe<T, A, B>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>): UnaryFunction<T, B>; -export function pipe<T, A, B, C>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>): UnaryFunction<T, C>; -export function pipe<T, A, B, C, D>( - fn1: UnaryFunction<T, A>, - fn2: UnaryFunction<A, B>, - fn3: UnaryFunction<B, C>, - fn4: UnaryFunction<C, D> -): UnaryFunction<T, D>; -export function pipe<T, A, B, C, D, E>( - fn1: UnaryFunction<T, A>, - fn2: UnaryFunction<A, B>, - fn3: UnaryFunction<B, C>, - fn4: UnaryFunction<C, D>, - fn5: UnaryFunction<D, E> -): UnaryFunction<T, E>; -export function pipe<T, A, B, C, D, E, F>( - fn1: UnaryFunction<T, A>, - fn2: UnaryFunction<A, B>, - fn3: UnaryFunction<B, C>, - fn4: UnaryFunction<C, D>, - fn5: UnaryFunction<D, E>, - fn6: UnaryFunction<E, F> -): UnaryFunction<T, F>; -export function pipe<T, A, B, C, D, E, F, G>( - fn1: UnaryFunction<T, A>, - fn2: UnaryFunction<A, B>, - fn3: UnaryFunction<B, C>, - fn4: UnaryFunction<C, D>, - fn5: UnaryFunction<D, E>, - fn6: UnaryFunction<E, F>, - fn7: UnaryFunction<F, G> -): UnaryFunction<T, G>; -export function pipe<T, A, B, C, D, E, F, G, H>( - fn1: UnaryFunction<T, A>, - fn2: UnaryFunction<A, B>, - fn3: UnaryFunction<B, C>, - fn4: UnaryFunction<C, D>, - fn5: UnaryFunction<D, E>, - fn6: UnaryFunction<E, F>, - fn7: UnaryFunction<F, G>, - fn8: UnaryFunction<G, H> -): UnaryFunction<T, H>; -export function pipe<T, A, B, C, D, E, F, G, H, I>( - fn1: UnaryFunction<T, A>, - fn2: UnaryFunction<A, B>, - fn3: UnaryFunction<B, C>, - fn4: UnaryFunction<C, D>, - fn5: UnaryFunction<D, E>, - fn6: UnaryFunction<E, F>, - fn7: UnaryFunction<F, G>, - fn8: UnaryFunction<G, H>, - fn9: UnaryFunction<H, I> -): UnaryFunction<T, I>; -export function pipe<T, A, B, C, D, E, F, G, H, I>( - fn1: UnaryFunction<T, A>, - fn2: UnaryFunction<A, B>, - fn3: UnaryFunction<B, C>, - fn4: UnaryFunction<C, D>, - fn5: UnaryFunction<D, E>, - fn6: UnaryFunction<E, F>, - fn7: UnaryFunction<F, G>, - fn8: UnaryFunction<G, H>, - fn9: UnaryFunction<H, I>, - ...fns: UnaryFunction<any, any>[] -): UnaryFunction<T, unknown>; - -/** - * pipe() can be called on one or more functions, each of which can take one argument ("UnaryFunction") - * and uses it to return a value. - * It returns a function that takes one argument, passes it to the first UnaryFunction, and then - * passes the result to the next one, passes that result to the next one, and so on. - */ -export function pipe(...fns: Array<UnaryFunction<any, any>>): UnaryFunction<any, any> { - return pipeFromArray(fns); -} - -/** @internal */ -export function pipeFromArray<T, R>(fns: Array<UnaryFunction<T, R>>): UnaryFunction<T, R> { - if (fns.length === 0) { - return identity as UnaryFunction<any, any>; - } - - if (fns.length === 1) { - return fns[0]; - } - - return function piped(input: T): R { - return fns.reduce((prev: any, fn: UnaryFunction<T, R>) => fn(prev), input as any); - }; -} diff --git a/node_modules/rxjs/src/internal/util/reportUnhandledError.ts b/node_modules/rxjs/src/internal/util/reportUnhandledError.ts deleted file mode 100644 index d996956..0000000 --- a/node_modules/rxjs/src/internal/util/reportUnhandledError.ts +++ /dev/null @@ -1,24 +0,0 @@ -import { config } from '../config'; -import { timeoutProvider } from '../scheduler/timeoutProvider'; - -/** - * Handles an error on another job either with the user-configured {@link onUnhandledError}, - * or by throwing it on that new job so it can be picked up by `window.onerror`, `process.on('error')`, etc. - * - * This should be called whenever there is an error that is out-of-band with the subscription - * or when an error hits a terminal boundary of the subscription and no error handler was provided. - * - * @param err the error to report - */ -export function reportUnhandledError(err: any) { - timeoutProvider.setTimeout(() => { - const { onUnhandledError } = config; - if (onUnhandledError) { - // Execute the user-configured error handler. - onUnhandledError(err); - } else { - // Throw so it is picked up by the runtime's uncaught error mechanism. - throw err; - } - }); -} diff --git a/node_modules/rxjs/src/internal/util/subscribeToArray.ts b/node_modules/rxjs/src/internal/util/subscribeToArray.ts deleted file mode 100644 index 0ca5294..0000000 --- a/node_modules/rxjs/src/internal/util/subscribeToArray.ts +++ /dev/null @@ -1,12 +0,0 @@ -import { Subscriber } from '../Subscriber'; - -/** - * Subscribes to an ArrayLike with a subscriber - * @param array The array or array-like to subscribe to - */ -export const subscribeToArray = <T>(array: ArrayLike<T>) => (subscriber: Subscriber<T>) => { - for (let i = 0, len = array.length; i < len && !subscriber.closed; i++) { - subscriber.next(array[i]); - } - subscriber.complete(); -}; diff --git a/node_modules/rxjs/src/internal/util/throwUnobservableError.ts b/node_modules/rxjs/src/internal/util/throwUnobservableError.ts deleted file mode 100644 index 6a5e88b..0000000 --- a/node_modules/rxjs/src/internal/util/throwUnobservableError.ts +++ /dev/null @@ -1,12 +0,0 @@ -/** - * Creates the TypeError to throw if an invalid object is passed to `from` or `scheduled`. - * @param input The object that was passed. - */ -export function createInvalidObservableTypeError(input: any) { - // TODO: We should create error codes that can be looked up, so this can be less verbose. - return new TypeError( - `You provided ${ - input !== null && typeof input === 'object' ? 'an invalid object' : `'${input}'` - } where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.` - ); -} diff --git a/node_modules/rxjs/src/internal/util/workarounds.ts b/node_modules/rxjs/src/internal/util/workarounds.ts deleted file mode 100644 index 00c01b8..0000000 --- a/node_modules/rxjs/src/internal/util/workarounds.ts +++ /dev/null @@ -1,7 +0,0 @@ -// Instead of using any - or another less-than-ideal type - to workaround a -// TypeScript problem or bug, create a type alias and use that instead. -// Wherever possible, use a TypeScript issue number in the type - something -// like TS_18757 - or use a descriptive name and leave a detailed comment -// alongside the type alias. - -export {} diff --git a/node_modules/rxjs/src/operators/index.ts b/node_modules/rxjs/src/operators/index.ts deleted file mode 100644 index 5b19019..0000000 --- a/node_modules/rxjs/src/operators/index.ts +++ /dev/null @@ -1,114 +0,0 @@ -/* Operator exports */ -export { audit } from '../internal/operators/audit'; -export { auditTime } from '../internal/operators/auditTime'; -export { buffer } from '../internal/operators/buffer'; -export { bufferCount } from '../internal/operators/bufferCount'; -export { bufferTime } from '../internal/operators/bufferTime'; -export { bufferToggle } from '../internal/operators/bufferToggle'; -export { bufferWhen } from '../internal/operators/bufferWhen'; -export { catchError } from '../internal/operators/catchError'; -export { combineAll } from '../internal/operators/combineAll'; -export { combineLatestAll } from '../internal/operators/combineLatestAll'; -export { combineLatest } from '../internal/operators/combineLatest'; -export { combineLatestWith } from '../internal/operators/combineLatestWith'; -export { concat } from '../internal/operators/concat'; -export { concatAll } from '../internal/operators/concatAll'; -export { concatMap } from '../internal/operators/concatMap'; -export { concatMapTo } from '../internal/operators/concatMapTo'; -export { concatWith } from '../internal/operators/concatWith'; -export { connect, ConnectConfig } from '../internal/operators/connect'; -export { count } from '../internal/operators/count'; -export { debounce } from '../internal/operators/debounce'; -export { debounceTime } from '../internal/operators/debounceTime'; -export { defaultIfEmpty } from '../internal/operators/defaultIfEmpty'; -export { delay } from '../internal/operators/delay'; -export { delayWhen } from '../internal/operators/delayWhen'; -export { dematerialize } from '../internal/operators/dematerialize'; -export { distinct } from '../internal/operators/distinct'; -export { distinctUntilChanged } from '../internal/operators/distinctUntilChanged'; -export { distinctUntilKeyChanged } from '../internal/operators/distinctUntilKeyChanged'; -export { elementAt } from '../internal/operators/elementAt'; -export { endWith } from '../internal/operators/endWith'; -export { every } from '../internal/operators/every'; -export { exhaust } from '../internal/operators/exhaust'; -export { exhaustAll } from '../internal/operators/exhaustAll'; -export { exhaustMap } from '../internal/operators/exhaustMap'; -export { expand } from '../internal/operators/expand'; -export { filter } from '../internal/operators/filter'; -export { finalize } from '../internal/operators/finalize'; -export { find } from '../internal/operators/find'; -export { findIndex } from '../internal/operators/findIndex'; -export { first } from '../internal/operators/first'; -export { groupBy, BasicGroupByOptions, GroupByOptionsWithElement } from '../internal/operators/groupBy'; -export { ignoreElements } from '../internal/operators/ignoreElements'; -export { isEmpty } from '../internal/operators/isEmpty'; -export { last } from '../internal/operators/last'; -export { map } from '../internal/operators/map'; -export { mapTo } from '../internal/operators/mapTo'; -export { materialize } from '../internal/operators/materialize'; -export { max } from '../internal/operators/max'; -export { merge } from '../internal/operators/merge'; -export { mergeAll } from '../internal/operators/mergeAll'; -export { flatMap } from '../internal/operators/flatMap'; -export { mergeMap } from '../internal/operators/mergeMap'; -export { mergeMapTo } from '../internal/operators/mergeMapTo'; -export { mergeScan } from '../internal/operators/mergeScan'; -export { mergeWith } from '../internal/operators/mergeWith'; -export { min } from '../internal/operators/min'; -export { multicast } from '../internal/operators/multicast'; -export { observeOn } from '../internal/operators/observeOn'; -export { onErrorResumeNext } from '../internal/operators/onErrorResumeNextWith'; -export { pairwise } from '../internal/operators/pairwise'; -export { partition } from '../internal/operators/partition'; -export { pluck } from '../internal/operators/pluck'; -export { publish } from '../internal/operators/publish'; -export { publishBehavior } from '../internal/operators/publishBehavior'; -export { publishLast } from '../internal/operators/publishLast'; -export { publishReplay } from '../internal/operators/publishReplay'; -export { race } from '../internal/operators/race'; -export { raceWith } from '../internal/operators/raceWith'; -export { reduce } from '../internal/operators/reduce'; -export { repeat, RepeatConfig } from '../internal/operators/repeat'; -export { repeatWhen } from '../internal/operators/repeatWhen'; -export { retry, RetryConfig } from '../internal/operators/retry'; -export { retryWhen } from '../internal/operators/retryWhen'; -export { refCount } from '../internal/operators/refCount'; -export { sample } from '../internal/operators/sample'; -export { sampleTime } from '../internal/operators/sampleTime'; -export { scan } from '../internal/operators/scan'; -export { sequenceEqual } from '../internal/operators/sequenceEqual'; -export { share, ShareConfig } from '../internal/operators/share'; -export { shareReplay, ShareReplayConfig } from '../internal/operators/shareReplay'; -export { single } from '../internal/operators/single'; -export { skip } from '../internal/operators/skip'; -export { skipLast } from '../internal/operators/skipLast'; -export { skipUntil } from '../internal/operators/skipUntil'; -export { skipWhile } from '../internal/operators/skipWhile'; -export { startWith } from '../internal/operators/startWith'; -export { subscribeOn } from '../internal/operators/subscribeOn'; -export { switchAll } from '../internal/operators/switchAll'; -export { switchMap } from '../internal/operators/switchMap'; -export { switchMapTo } from '../internal/operators/switchMapTo'; -export { switchScan } from '../internal/operators/switchScan'; -export { take } from '../internal/operators/take'; -export { takeLast } from '../internal/operators/takeLast'; -export { takeUntil } from '../internal/operators/takeUntil'; -export { takeWhile } from '../internal/operators/takeWhile'; -export { tap, TapObserver } from '../internal/operators/tap'; -export { throttle, ThrottleConfig } from '../internal/operators/throttle'; -export { throttleTime } from '../internal/operators/throttleTime'; -export { throwIfEmpty } from '../internal/operators/throwIfEmpty'; -export { timeInterval } from '../internal/operators/timeInterval'; -export { timeout, TimeoutConfig, TimeoutInfo } from '../internal/operators/timeout'; -export { timeoutWith } from '../internal/operators/timeoutWith'; -export { timestamp } from '../internal/operators/timestamp'; -export { toArray } from '../internal/operators/toArray'; -export { window } from '../internal/operators/window'; -export { windowCount } from '../internal/operators/windowCount'; -export { windowTime } from '../internal/operators/windowTime'; -export { windowToggle } from '../internal/operators/windowToggle'; -export { windowWhen } from '../internal/operators/windowWhen'; -export { withLatestFrom } from '../internal/operators/withLatestFrom'; -export { zip } from '../internal/operators/zip'; -export { zipAll } from '../internal/operators/zipAll'; -export { zipWith } from '../internal/operators/zipWith'; diff --git a/node_modules/rxjs/src/testing/index.ts b/node_modules/rxjs/src/testing/index.ts deleted file mode 100644 index d861e35..0000000 --- a/node_modules/rxjs/src/testing/index.ts +++ /dev/null @@ -1 +0,0 @@ -export { TestScheduler, RunHelpers } from '../internal/testing/TestScheduler'; diff --git a/node_modules/rxjs/src/tsconfig.base.json b/node_modules/rxjs/src/tsconfig.base.json deleted file mode 100644 index c2f45b2..0000000 --- a/node_modules/rxjs/src/tsconfig.base.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "extends": "../tsconfig.json", - "compilerOptions": { - "noEmit": false, - "baseUrl": ".", - "paths": { - "rxjs": ["./"], - "rxjs/*": ["./*"] - } - }, - "include": ["./**/*.ts"] -} diff --git a/node_modules/rxjs/src/tsconfig.cjs.json b/node_modules/rxjs/src/tsconfig.cjs.json deleted file mode 100644 index 4baf02b..0000000 --- a/node_modules/rxjs/src/tsconfig.cjs.json +++ /dev/null @@ -1,10 +0,0 @@ -{ - "extends": "./tsconfig.base.json", - "compilerOptions": { - "module": "commonjs", - "target": "es5", - "downlevelIteration": true, - "outDir": "../dist/cjs" - }, - "exclude": ["./internal/umd.ts"] -} diff --git a/node_modules/rxjs/src/tsconfig.cjs.spec.json b/node_modules/rxjs/src/tsconfig.cjs.spec.json deleted file mode 100644 index 8f9276c..0000000 --- a/node_modules/rxjs/src/tsconfig.cjs.spec.json +++ /dev/null @@ -1,10 +0,0 @@ -{ - "extends": "./tsconfig.cjs.json", - /** - * this is pseudo config for test case's relative path resolution to `../src`, runs - * cjs config once more instead of manual copying to utilize incremental build. - */ - "compilerOptions": { - "outDir": "../dist/src" - } -} diff --git a/node_modules/rxjs/src/tsconfig.esm.json b/node_modules/rxjs/src/tsconfig.esm.json deleted file mode 100644 index 459ac2a..0000000 --- a/node_modules/rxjs/src/tsconfig.esm.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "extends": "./tsconfig.base.json", - "compilerOptions": { - "module": "esnext", - "importHelpers": true, - "target": "es2015", - "outDir": "../dist/esm" - } -} diff --git a/node_modules/rxjs/src/tsconfig.esm5.json b/node_modules/rxjs/src/tsconfig.esm5.json deleted file mode 100644 index aa4ffa3..0000000 --- a/node_modules/rxjs/src/tsconfig.esm5.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "extends": "./tsconfig.base.json", - "compilerOptions": { - "module": "esnext", - "importHelpers": true, - "target": "es5", - "downlevelIteration": true, - "outDir": "../dist/esm5" - }, - "exclude": ["./internal/umd.ts"] -} diff --git a/node_modules/rxjs/src/tsconfig.esm5.rollup.json b/node_modules/rxjs/src/tsconfig.esm5.rollup.json deleted file mode 100644 index 968fd8a..0000000 --- a/node_modules/rxjs/src/tsconfig.esm5.rollup.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "extends": "./tsconfig.esm5.json", - "compilerOptions": { - "outDir": "../dist/esm5_for_rollup", - "noEmitHelpers": true - }, - "exclude": [] -} diff --git a/node_modules/rxjs/src/tsconfig.types.json b/node_modules/rxjs/src/tsconfig.types.json deleted file mode 100644 index 1566fbd..0000000 --- a/node_modules/rxjs/src/tsconfig.types.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "extends": "./tsconfig.esm.json", - "compilerOptions": { - "composite": true, - "module": "es2015", - "target": "esnext", - "removeComments": false, - "declaration": true, - "declarationMap": true, - "declarationDir": "../dist/types", - "emitDeclarationOnly": true - }, - "exclude": ["./internal/umd.ts"] -} diff --git a/node_modules/rxjs/src/tsconfig.types.spec.json b/node_modules/rxjs/src/tsconfig.types.spec.json deleted file mode 100644 index 7766b1f..0000000 --- a/node_modules/rxjs/src/tsconfig.types.spec.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "extends": "./tsconfig.types.json", - "compilerOptions": { - "declarationDir": "../dist/types_spec", - "stripInternal": false - } -} diff --git a/node_modules/rxjs/src/webSocket/index.ts b/node_modules/rxjs/src/webSocket/index.ts deleted file mode 100644 index 833d950..0000000 --- a/node_modules/rxjs/src/webSocket/index.ts +++ /dev/null @@ -1,2 +0,0 @@ -export { webSocket as webSocket } from '../internal/observable/dom/webSocket'; -export { WebSocketSubject, WebSocketSubjectConfig } from '../internal/observable/dom/WebSocketSubject'; |