lambda-live-debugger 1.12.2 → 1.12.4

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

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

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

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

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

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

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

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

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

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

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

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

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

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