lambda-live-debugger 1.12.2 → 1.12.4

package/node_modules/rxjs/src/internal/operators/catchError.ts

@@ -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>
- *
- * ![](catch.png)
- *
- * 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);
-    }
-  });
-}

package/node_modules/rxjs/src/internal/operators/combineAll.ts

@@ -1,6 +0,0 @@
-import { combineLatestAll } from './combineLatestAll';
-
-/**
- * @deprecated Renamed to {@link combineLatestAll}. Will be removed in v8.
- */
-export const combineAll = combineLatestAll;

package/node_modules/rxjs/src/internal/operators/combineLatest.ts

@@ -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);
-      });
-}

package/node_modules/rxjs/src/internal/operators/combineLatestAll.ts

@@ -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);
-}

package/node_modules/rxjs/src/internal/operators/combineLatestWith.ts

@@ -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);
-}

package/node_modules/rxjs/src/internal/operators/concat.ts

@@ -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);
-  });
-}

package/node_modules/rxjs/src/internal/operators/concatAll.ts

@@ -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>
- *
- * ![](concatAll.svg)
- *
- * 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);
-}

package/node_modules/rxjs/src/internal/operators/concatMap.ts

@@ -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>
- *
- * ![](concatMap.png)
- *
- * 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);
-}

package/node_modules/rxjs/src/internal/operators/concatMapTo.ts

@@ -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>
- *
- * ![](concatMapTo.png)
- *
- * 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);
-}

package/node_modules/rxjs/src/internal/operators/concatWith.ts

@@ -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);
-}