lambda-live-debugger 1.12.2 → 1.12.4

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

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

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

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

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

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

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

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

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

@@ -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.png)
- *
- * `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();
-        }
-      )
-    );
-  };
-}

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

@@ -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.png)
- *
- * `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'));
-}

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

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

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

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