lambda-live-debugger 1.12.3 → 1.12.4

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

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

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

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

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

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

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

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

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

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

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

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

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

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