lambda-live-debugger 1.12.2 → 1.12.4

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

@@ -1,55 +0,0 @@
-import { asyncScheduler } from '../scheduler/async';
-import { audit } from './audit';
-import { timer } from '../observable/timer';
-import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
-
-/**
- * Ignores source values for `duration` milliseconds, then emits the most recent
- * value from the source Observable, then repeats this process.
- *
- * <span class="informal">When it sees a source value, it ignores that plus
- * the next ones for `duration` milliseconds, and then it emits the most recent
- * value from the source.</span>
- *
- * ![](auditTime.png)
- *
- * `auditTime` is similar to `throttleTime`, but emits the last value from the
- * silenced time window, instead of the first value. `auditTime` emits the most
- * recent value from the source Observable on the output Observable as soon as
- * its internal timer becomes disabled, and ignores source values while the
- * timer is enabled. Initially, the timer is disabled. As soon as the first
- * source value arrives, the timer is enabled. After `duration` milliseconds (or
- * the time unit determined internally by the optional `scheduler`) has passed,
- * the timer is disabled, then the most recent source value is emitted on the
- * output Observable, and this process repeats for the next source value.
- * Optionally takes a {@link SchedulerLike} for managing timers.
- *
- * ## Example
- *
- * Emit clicks at a rate of at most one click per second
- *
- * ```ts
- * import { fromEvent, auditTime } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const result = clicks.pipe(auditTime(1000));
- * result.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link audit}
- * @see {@link debounceTime}
- * @see {@link delay}
- * @see {@link sampleTime}
- * @see {@link throttleTime}
- *
- * @param duration Time to wait before emitting the most recent source value,
- * measured in milliseconds or the time unit determined internally by the
- * optional `scheduler`.
- * @param scheduler The {@link SchedulerLike} to use for managing the timers
- * that handle the rate-limiting behavior.
- * @return A function that returns an Observable that performs rate-limiting of
- * emissions from the source Observable.
- */
-export function auditTime<T>(duration: number, scheduler: SchedulerLike = asyncScheduler): MonoTypeOperatorFunction<T> {
-  return audit(() => timer(duration, scheduler));
-}

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

@@ -1,81 +0,0 @@
-import { OperatorFunction, ObservableInput } from '../types';
-import { operate } from '../util/lift';
-import { noop } from '../util/noop';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { innerFrom } from '../observable/innerFrom';
-
-/**
- * Buffers the source Observable values until `closingNotifier` emits.
- *
- * <span class="informal">Collects values from the past as an array, and emits
- * that array only when another Observable emits.</span>
- *
- * ![](buffer.png)
- *
- * Buffers the incoming Observable values until the given `closingNotifier`
- * `ObservableInput` (that internally gets converted to an Observable)
- * emits a value, at which point it emits the buffer on the output
- * Observable and starts a new buffer internally, awaiting the next time
- * `closingNotifier` emits.
- *
- * ## Example
- *
- * On every click, emit array of most recent interval events
- *
- * ```ts
- * import { fromEvent, interval, buffer } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const intervalEvents = interval(1000);
- * const buffered = intervalEvents.pipe(buffer(clicks));
- * buffered.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link bufferCount}
- * @see {@link bufferTime}
- * @see {@link bufferToggle}
- * @see {@link bufferWhen}
- * @see {@link window}
- *
- * @param closingNotifier An `ObservableInput` that signals the
- * buffer to be emitted on the output Observable.
- * @return A function that returns an Observable of buffers, which are arrays
- * of values.
- */
-export function buffer<T>(closingNotifier: ObservableInput<any>): OperatorFunction<T, T[]> {
-  return operate((source, subscriber) => {
-    // The current buffered values.
-    let currentBuffer: T[] = [];
-
-    // Subscribe to our source.
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => currentBuffer.push(value),
-        () => {
-          subscriber.next(currentBuffer);
-          subscriber.complete();
-        }
-      )
-    );
-
-    // Subscribe to the closing notifier.
-    innerFrom(closingNotifier).subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        () => {
-          // Start a new buffer and emit the previous one.
-          const b = currentBuffer;
-          currentBuffer = [];
-          subscriber.next(b);
-        },
-        noop
-      )
-    );
-
-    return () => {
-      // Ensure buffered values are released on finalization.
-      currentBuffer = null!;
-    };
-  });
-}

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

@@ -1,120 +0,0 @@
-import { OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { arrRemove } from '../util/arrRemove';
-
-/**
- * Buffers the source Observable values until the size hits the maximum
- * `bufferSize` given.
- *
- * <span class="informal">Collects values from the past as an array, and emits
- * that array only when its size reaches `bufferSize`.</span>
- *
- * ![](bufferCount.png)
- *
- * Buffers a number of values from the source Observable by `bufferSize` then
- * emits the buffer and clears it, and starts a new buffer each
- * `startBufferEvery` values. If `startBufferEvery` is not provided or is
- * `null`, then new buffers are started immediately at the start of the source
- * and when each buffer closes and is emitted.
- *
- * ## Examples
- *
- * Emit the last two click events as an array
- *
- * ```ts
- * import { fromEvent, bufferCount } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const buffered = clicks.pipe(bufferCount(2));
- * buffered.subscribe(x => console.log(x));
- * ```
- *
- * On every click, emit the last two click events as an array
- *
- * ```ts
- * import { fromEvent, bufferCount } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const buffered = clicks.pipe(bufferCount(2, 1));
- * buffered.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link buffer}
- * @see {@link bufferTime}
- * @see {@link bufferToggle}
- * @see {@link bufferWhen}
- * @see {@link pairwise}
- * @see {@link windowCount}
- *
- * @param bufferSize The maximum size of the buffer emitted.
- * @param startBufferEvery Interval at which to start a new buffer.
- * For example if `startBufferEvery` is `2`, then a new buffer will be started
- * on every other value from the source. A new buffer is started at the
- * beginning of the source by default.
- * @return A function that returns an Observable of arrays of buffered values.
- */
-export function bufferCount<T>(bufferSize: number, startBufferEvery: number | null = null): OperatorFunction<T, T[]> {
-  // If no `startBufferEvery` value was supplied, then we're
-  // opening and closing on the bufferSize itself.
-  startBufferEvery = startBufferEvery ?? bufferSize;
-
-  return operate((source, subscriber) => {
-    let buffers: T[][] = [];
-    let count = 0;
-
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => {
-          let toEmit: T[][] | null = null;
-
-          // Check to see if we need to start a buffer.
-          // This will start one at the first value, and then
-          // a new one every N after that.
-          if (count++ % startBufferEvery! === 0) {
-            buffers.push([]);
-          }
-
-          // Push our value into our active buffers.
-          for (const buffer of buffers) {
-            buffer.push(value);
-            // Check to see if we're over the bufferSize
-            // if we are, record it so we can emit it later.
-            // If we emitted it now and removed it, it would
-            // mutate the `buffers` array while we're looping
-            // over it.
-            if (bufferSize <= buffer.length) {
-              toEmit = toEmit ?? [];
-              toEmit.push(buffer);
-            }
-          }
-
-          if (toEmit) {
-            // We have found some buffers that are over the
-            // `bufferSize`. Emit them, and remove them from our
-            // buffers list.
-            for (const buffer of toEmit) {
-              arrRemove(buffers, buffer);
-              subscriber.next(buffer);
-            }
-          }
-        },
-        () => {
-          // When the source completes, emit all of our
-          // active buffers.
-          for (const buffer of buffers) {
-            subscriber.next(buffer);
-          }
-          subscriber.complete();
-        },
-        // Pass all errors through to consumer.
-        undefined,
-        () => {
-          // Clean up our memory when we finalize
-          buffers = null!;
-        }
-      )
-    );
-  });
-}

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

@@ -1,165 +0,0 @@
-import { Subscription } from '../Subscription';
-import { OperatorFunction, SchedulerLike } from '../types';
-import { operate } from '../util/lift';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { arrRemove } from '../util/arrRemove';
-import { asyncScheduler } from '../scheduler/async';
-import { popScheduler } from '../util/args';
-import { executeSchedule } from '../util/executeSchedule';
-
-export function bufferTime<T>(bufferTimeSpan: number, scheduler?: SchedulerLike): OperatorFunction<T, T[]>;
-export function bufferTime<T>(
-  bufferTimeSpan: number,
-  bufferCreationInterval: number | null | undefined,
-  scheduler?: SchedulerLike
-): OperatorFunction<T, T[]>;
-export function bufferTime<T>(
-  bufferTimeSpan: number,
-  bufferCreationInterval: number | null | undefined,
-  maxBufferSize: number,
-  scheduler?: SchedulerLike
-): OperatorFunction<T, T[]>;
-
-/**
- * Buffers the source Observable values for a specific time period.
- *
- * <span class="informal">Collects values from the past as an array, and emits
- * those arrays periodically in time.</span>
- *
- * ![](bufferTime.png)
- *
- * Buffers values from the source for a specific time duration `bufferTimeSpan`.
- * Unless the optional argument `bufferCreationInterval` is given, it emits and
- * resets the buffer every `bufferTimeSpan` milliseconds. If
- * `bufferCreationInterval` is given, this operator opens the buffer every
- * `bufferCreationInterval` milliseconds and closes (emits and resets) the
- * buffer every `bufferTimeSpan` milliseconds. When the optional argument
- * `maxBufferSize` is specified, the buffer will be closed either after
- * `bufferTimeSpan` milliseconds or when it contains `maxBufferSize` elements.
- *
- * ## Examples
- *
- * Every second, emit an array of the recent click events
- *
- * ```ts
- * import { fromEvent, bufferTime } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const buffered = clicks.pipe(bufferTime(1000));
- * buffered.subscribe(x => console.log(x));
- * ```
- *
- * Every 5 seconds, emit the click events from the next 2 seconds
- *
- * ```ts
- * import { fromEvent, bufferTime } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const buffered = clicks.pipe(bufferTime(2000, 5000));
- * buffered.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link buffer}
- * @see {@link bufferCount}
- * @see {@link bufferToggle}
- * @see {@link bufferWhen}
- * @see {@link windowTime}
- *
- * @param bufferTimeSpan The amount of time to fill each buffer array.
- * @param otherArgs Other configuration arguments such as:
- * - `bufferCreationInterval` - the interval at which to start new buffers;
- * - `maxBufferSize` - the maximum buffer size;
- * - `scheduler` - the scheduler on which to schedule the intervals that determine buffer boundaries.
- * @return A function that returns an Observable of arrays of buffered values.
- */
-export function bufferTime<T>(bufferTimeSpan: number, ...otherArgs: any[]): OperatorFunction<T, T[]> {
-  const scheduler = popScheduler(otherArgs) ?? asyncScheduler;
-  const bufferCreationInterval = (otherArgs[0] as number) ?? null;
-  const maxBufferSize = (otherArgs[1] as number) || Infinity;
-
-  return operate((source, subscriber) => {
-    // The active buffers, their related subscriptions, and removal functions.
-    let bufferRecords: { buffer: T[]; subs: Subscription }[] | null = [];
-    // If true, it means that every time we emit a buffer, we want to start a new buffer
-    // this is only really used for when *just* the buffer time span is passed.
-    let restartOnEmit = false;
-
-    /**
-     * Does the work of emitting the buffer from the record, ensuring that the
-     * record is removed before the emission so reentrant code (from some custom scheduling, perhaps)
-     * does not alter the buffer. Also checks to see if a new buffer needs to be started
-     * after the emit.
-     */
-    const emit = (record: { buffer: T[]; subs: Subscription }) => {
-      const { buffer, subs } = record;
-      subs.unsubscribe();
-      arrRemove(bufferRecords, record);
-      subscriber.next(buffer);
-      restartOnEmit && startBuffer();
-    };
-
-    /**
-     * Called every time we start a new buffer. This does
-     * the work of scheduling a job at the requested bufferTimeSpan
-     * that will emit the buffer (if it's not unsubscribed before then).
-     */
-    const startBuffer = () => {
-      if (bufferRecords) {
-        const subs = new Subscription();
-        subscriber.add(subs);
-        const buffer: T[] = [];
-        const record = {
-          buffer,
-          subs,
-        };
-        bufferRecords.push(record);
-        executeSchedule(subs, scheduler, () => emit(record), bufferTimeSpan);
-      }
-    };
-
-    if (bufferCreationInterval !== null && bufferCreationInterval >= 0) {
-      // The user passed both a bufferTimeSpan (required), and a creation interval
-      // That means we need to start new buffers on the interval, and those buffers need
-      // to wait the required time span before emitting.
-      executeSchedule(subscriber, scheduler, startBuffer, bufferCreationInterval, true);
-    } else {
-      restartOnEmit = true;
-    }
-
-    startBuffer();
-
-    const bufferTimeSubscriber = createOperatorSubscriber(
-      subscriber,
-      (value: T) => {
-        // Copy the records, so if we need to remove one we
-        // don't mutate the array. It's hard, but not impossible to
-        // set up a buffer time that could mutate the array and
-        // cause issues here.
-        const recordsCopy = bufferRecords!.slice();
-        for (const record of recordsCopy) {
-          // Loop over all buffers and
-          const { buffer } = record;
-          buffer.push(value);
-          // If the buffer is over the max size, we need to emit it.
-          maxBufferSize <= buffer.length && emit(record);
-        }
-      },
-      () => {
-        // The source completed, emit all of the active
-        // buffers we have before we complete.
-        while (bufferRecords?.length) {
-          subscriber.next(bufferRecords.shift()!.buffer);
-        }
-        bufferTimeSubscriber?.unsubscribe();
-        subscriber.complete();
-        subscriber.unsubscribe();
-      },
-      // Pass all errors through to consumer.
-      undefined,
-      // Clean up
-      () => (bufferRecords = null)
-    );
-
-    source.subscribe(bufferTimeSubscriber);
-  });
-}

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

@@ -1,102 +0,0 @@
-import { Subscription } from '../Subscription';
-import { OperatorFunction, ObservableInput } from '../types';
-import { operate } from '../util/lift';
-import { innerFrom } from '../observable/innerFrom';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { noop } from '../util/noop';
-import { arrRemove } from '../util/arrRemove';
-
-/**
- * Buffers the source Observable values starting from an emission from
- * `openings` and ending when the output of `closingSelector` emits.
- *
- * <span class="informal">Collects values from the past as an array. Starts
- * collecting only when `opening` emits, and calls the `closingSelector`
- * function to get an Observable that tells when to close the buffer.</span>
- *
- * ![](bufferToggle.png)
- *
- * Buffers values from the source by opening the buffer via signals from an
- * Observable provided to `openings`, and closing and sending the buffers when
- * a Subscribable or Promise returned by the `closingSelector` function emits.
- *
- * ## Example
- *
- * Every other second, emit the click events from the next 500ms
- *
- * ```ts
- * import { fromEvent, interval, bufferToggle, EMPTY } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const openings = interval(1000);
- * const buffered = clicks.pipe(bufferToggle(openings, i =>
- *   i % 2 ? interval(500) : EMPTY
- * ));
- * buffered.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link buffer}
- * @see {@link bufferCount}
- * @see {@link bufferTime}
- * @see {@link bufferWhen}
- * @see {@link windowToggle}
- *
- * @param openings A Subscribable or Promise of notifications to start new
- * buffers.
- * @param closingSelector A function that takes
- * the value emitted by the `openings` observable and returns a Subscribable or Promise,
- * which, when it emits, signals that the associated buffer should be emitted
- * and cleared.
- * @return A function that returns an Observable of arrays of buffered values.
- */
-export function bufferToggle<T, O>(
-  openings: ObservableInput<O>,
-  closingSelector: (value: O) => ObservableInput<any>
-): OperatorFunction<T, T[]> {
-  return operate((source, subscriber) => {
-    const buffers: T[][] = [];
-
-    // Subscribe to the openings notifier first
-    innerFrom(openings).subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (openValue) => {
-          const buffer: T[] = [];
-          buffers.push(buffer);
-          // We use this composite subscription, so that
-          // when the closing notifier emits, we can tear it down.
-          const closingSubscription = new Subscription();
-
-          const emitBuffer = () => {
-            arrRemove(buffers, buffer);
-            subscriber.next(buffer);
-            closingSubscription.unsubscribe();
-          };
-
-          // The line below will add the subscription to the parent subscriber *and* the closing subscription.
-          closingSubscription.add(innerFrom(closingSelector(openValue)).subscribe(createOperatorSubscriber(subscriber, emitBuffer, noop)));
-        },
-        noop
-      )
-    );
-
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        (value) => {
-          // Value from our source. Add it to all pending buffers.
-          for (const buffer of buffers) {
-            buffer.push(value);
-          }
-        },
-        () => {
-          // Source complete. Emit all pending buffers.
-          while (buffers.length > 0) {
-            subscriber.next(buffers.shift()!);
-          }
-          subscriber.complete();
-        }
-      )
-    );
-  });
-}

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

@@ -1,94 +0,0 @@
-import { Subscriber } from '../Subscriber';
-import { ObservableInput, OperatorFunction } from '../types';
-import { operate } from '../util/lift';
-import { noop } from '../util/noop';
-import { createOperatorSubscriber } from './OperatorSubscriber';
-import { innerFrom } from '../observable/innerFrom';
-
-/**
- * Buffers the source Observable values, using a factory function of closing
- * Observables to determine when to close, emit, and reset the buffer.
- *
- * <span class="informal">Collects values from the past as an array. When it
- * starts collecting values, it calls a function that returns an Observable that
- * tells when to close the buffer and restart collecting.</span>
- *
- * ![](bufferWhen.svg)
- *
- * Opens a buffer immediately, then closes the buffer when the observable
- * returned by calling `closingSelector` function emits a value. When it closes
- * the buffer, it immediately opens a new buffer and repeats the process.
- *
- * ## Example
- *
- * Emit an array of the last clicks every [1-5] random seconds
- *
- * ```ts
- * import { fromEvent, bufferWhen, interval } from 'rxjs';
- *
- * const clicks = fromEvent(document, 'click');
- * const buffered = clicks.pipe(
- *   bufferWhen(() => interval(1000 + Math.random() * 4000))
- * );
- * buffered.subscribe(x => console.log(x));
- * ```
- *
- * @see {@link buffer}
- * @see {@link bufferCount}
- * @see {@link bufferTime}
- * @see {@link bufferToggle}
- * @see {@link windowWhen}
- *
- * @param closingSelector A function that takes no arguments and returns an
- * Observable that signals buffer closure.
- * @return A function that returns an Observable of arrays of buffered values.
- */
-export function bufferWhen<T>(closingSelector: () => ObservableInput<any>): OperatorFunction<T, T[]> {
-  return operate((source, subscriber) => {
-    // The buffer we keep and emit.
-    let buffer: T[] | null = null;
-    // A reference to the subscriber used to subscribe to
-    // the closing notifier. We need to hold this so we can
-    // end the subscription after the first notification.
-    let closingSubscriber: Subscriber<T> | null = null;
-
-    // Ends the previous closing notifier subscription, so it
-    // terminates after the first emission, then emits
-    // the current buffer  if there is one, starts a new buffer, and starts a
-    // new closing notifier.
-    const openBuffer = () => {
-      // Make sure to finalize the closing subscription, we only cared
-      // about one notification.
-      closingSubscriber?.unsubscribe();
-      // emit the buffer if we have one, and start a new buffer.
-      const b = buffer;
-      buffer = [];
-      b && subscriber.next(b);
-
-      // Get a new closing notifier and subscribe to it.
-      innerFrom(closingSelector()).subscribe((closingSubscriber = createOperatorSubscriber(subscriber, openBuffer, noop)));
-    };
-
-    // Start the first buffer.
-    openBuffer();
-
-    // Subscribe to our source.
-    source.subscribe(
-      createOperatorSubscriber(
-        subscriber,
-        // Add every new value to the current buffer.
-        (value) => buffer?.push(value),
-        // When we complete, emit the buffer if we have one,
-        // then complete the result.
-        () => {
-          buffer && subscriber.next(buffer);
-          subscriber.complete();
-        },
-        // Pass all errors through to consumer.
-        undefined,
-        // Release memory on finalization
-        () => (buffer = closingSubscriber = null!)
-      )
-    );
-  });
-}