lambda-live-debugger 1.12.3 → 1.12.4

package/node_modules/rxjs/src/internal/scheduler/AsyncAction.ts

@@ -1,150 +0,0 @@
-import { Action } from './Action';
-import { SchedulerAction } from '../types';
-import { Subscription } from '../Subscription';
-import { AsyncScheduler } from './AsyncScheduler';
-import { intervalProvider } from './intervalProvider';
-import { arrRemove } from '../util/arrRemove';
-import { TimerHandle } from './timerHandle';
-
-export class AsyncAction<T> extends Action<T> {
-  public id: TimerHandle | undefined;
-  public state?: T;
-  // @ts-ignore: Property has no initializer and is not definitely assigned
-  public delay: number;
-  protected pending: boolean = false;
-
-  constructor(protected scheduler: AsyncScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) {
-    super(scheduler, work);
-  }
-
-  public schedule(state?: T, delay: number = 0): Subscription {
-    if (this.closed) {
-      return this;
-    }
-
-    // Always replace the current state with the new state.
-    this.state = state;
-
-    const id = this.id;
-    const scheduler = this.scheduler;
-
-    //
-    // Important implementation note:
-    //
-    // Actions only execute once by default, unless rescheduled from within the
-    // scheduled callback. This allows us to implement single and repeat
-    // actions via the same code path, without adding API surface area, as well
-    // as mimic traditional recursion but across asynchronous boundaries.
-    //
-    // However, JS runtimes and timers distinguish between intervals achieved by
-    // serial `setTimeout` calls vs. a single `setInterval` call. An interval of
-    // serial `setTimeout` calls can be individually delayed, which delays
-    // scheduling the next `setTimeout`, and so on. `setInterval` attempts to
-    // guarantee the interval callback will be invoked more precisely to the
-    // interval period, regardless of load.
-    //
-    // Therefore, we use `setInterval` to schedule single and repeat actions.
-    // If the action reschedules itself with the same delay, the interval is not
-    // canceled. If the action doesn't reschedule, or reschedules with a
-    // different delay, the interval will be canceled after scheduled callback
-    // execution.
-    //
-    if (id != null) {
-      this.id = this.recycleAsyncId(scheduler, id, delay);
-    }
-
-    // Set the pending flag indicating that this action has been scheduled, or
-    // has recursively rescheduled itself.
-    this.pending = true;
-
-    this.delay = delay;
-    // If this action has already an async Id, don't request a new one.
-    this.id = this.id ?? this.requestAsyncId(scheduler, this.id, delay);
-
-    return this;
-  }
-
-  protected requestAsyncId(scheduler: AsyncScheduler, _id?: TimerHandle, delay: number = 0): TimerHandle {
-    return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
-  }
-
-  protected recycleAsyncId(_scheduler: AsyncScheduler, id?: TimerHandle, delay: number | null = 0): TimerHandle | undefined {
-    // If this action is rescheduled with the same delay time, don't clear the interval id.
-    if (delay != null && this.delay === delay && this.pending === false) {
-      return id;
-    }
-    // Otherwise, if the action's delay time is different from the current delay,
-    // or the action has been rescheduled before it's executed, clear the interval id
-    if (id != null) {
-      intervalProvider.clearInterval(id);
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Immediately executes this action and the `work` it contains.
-   */
-  public execute(state: T, delay: number): any {
-    if (this.closed) {
-      return new Error('executing a cancelled action');
-    }
-
-    this.pending = false;
-    const error = this._execute(state, delay);
-    if (error) {
-      return error;
-    } else if (this.pending === false && this.id != null) {
-      // Dequeue if the action didn't reschedule itself. Don't call
-      // unsubscribe(), because the action could reschedule later.
-      // For example:
-      // ```
-      // scheduler.schedule(function doWork(counter) {
-      //   /* ... I'm a busy worker bee ... */
-      //   var originalAction = this;
-      //   /* wait 100ms before rescheduling the action */
-      //   setTimeout(function () {
-      //     originalAction.schedule(counter + 1);
-      //   }, 100);
-      // }, 1000);
-      // ```
-      this.id = this.recycleAsyncId(this.scheduler, this.id, null);
-    }
-  }
-
-  protected _execute(state: T, _delay: number): any {
-    let errored: boolean = false;
-    let errorValue: any;
-    try {
-      this.work(state);
-    } catch (e) {
-      errored = true;
-      // HACK: Since code elsewhere is relying on the "truthiness" of the
-      // return here, we can't have it return "" or 0 or false.
-      // TODO: Clean this up when we refactor schedulers mid-version-8 or so.
-      errorValue = e ? e : new Error('Scheduled action threw falsy error');
-    }
-    if (errored) {
-      this.unsubscribe();
-      return errorValue;
-    }
-  }
-
-  unsubscribe() {
-    if (!this.closed) {
-      const { id, scheduler } = this;
-      const { actions } = scheduler;
-
-      this.work = this.state = this.scheduler = null!;
-      this.pending = false;
-
-      arrRemove(actions, this);
-      if (id != null) {
-        this.id = this.recycleAsyncId(scheduler, id, null);
-      }
-
-      this.delay = null!;
-      super.unsubscribe();
-    }
-  }
-}

package/node_modules/rxjs/src/internal/scheduler/AsyncScheduler.ts

@@ -1,52 +0,0 @@
-import { Scheduler } from '../Scheduler';
-import { Action } from './Action';
-import { AsyncAction } from './AsyncAction';
-import { TimerHandle } from './timerHandle';
-
-export class AsyncScheduler extends Scheduler {
-  public actions: Array<AsyncAction<any>> = [];
-  /**
-   * A flag to indicate whether the Scheduler is currently executing a batch of
-   * queued actions.
-   * @internal
-   */
-  public _active: boolean = false;
-  /**
-   * An internal ID used to track the latest asynchronous task such as those
-   * coming from `setTimeout`, `setInterval`, `requestAnimationFrame`, and
-   * others.
-   * @internal
-   */
-  public _scheduled: TimerHandle | undefined;
-
-  constructor(SchedulerAction: typeof Action, now: () => number = Scheduler.now) {
-    super(SchedulerAction, now);
-  }
-
-  public flush(action: AsyncAction<any>): void {
-    const { actions } = this;
-
-    if (this._active) {
-      actions.push(action);
-      return;
-    }
-
-    let error: any;
-    this._active = true;
-
-    do {
-      if ((error = action.execute(action.state, action.delay))) {
-        break;
-      }
-    } while ((action = actions.shift()!)); // exhaust the scheduler queue
-
-    this._active = false;
-
-    if (error) {
-      while ((action = actions.shift()!)) {
-        action.unsubscribe();
-      }
-      throw error;
-    }
-  }
-}

package/node_modules/rxjs/src/internal/scheduler/QueueAction.ts

@@ -1,44 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { Subscription } from '../Subscription';
-import { QueueScheduler } from './QueueScheduler';
-import { SchedulerAction } from '../types';
-import { TimerHandle } from './timerHandle';
-
-export class QueueAction<T> extends AsyncAction<T> {
-  constructor(protected scheduler: QueueScheduler, protected work: (this: SchedulerAction<T>, state?: T) => void) {
-    super(scheduler, work);
-  }
-
-  public schedule(state?: T, delay: number = 0): Subscription {
-    if (delay > 0) {
-      return super.schedule(state, delay);
-    }
-    this.delay = delay;
-    this.state = state;
-    this.scheduler.flush(this);
-    return this;
-  }
-
-  public execute(state: T, delay: number): any {
-    return delay > 0 || this.closed ? super.execute(state, delay) : this._execute(state, delay);
-  }
-
-  protected requestAsyncId(scheduler: QueueScheduler, id?: TimerHandle, delay: number = 0): TimerHandle {
-    // If delay exists and is greater than 0, or if the delay is null (the
-    // action wasn't rescheduled) but was originally scheduled as an async
-    // action, then recycle as an async action.
-
-    if ((delay != null && delay > 0) || (delay == null && this.delay > 0)) {
-      return super.requestAsyncId(scheduler, id, delay);
-    }
-
-    // Otherwise flush the scheduler starting with this action.
-    scheduler.flush(this);
-
-    // HACK: In the past, this was returning `void`. However, `void` isn't a valid
-    // `TimerHandle`, and generally the return value here isn't really used. So the
-    // compromise is to return `0` which is both "falsy" and a valid `TimerHandle`,
-    // as opposed to refactoring every other instanceo of `requestAsyncId`.
-    return 0;
-  }
-}

package/node_modules/rxjs/src/internal/scheduler/QueueScheduler.ts

@@ -1,4 +0,0 @@
-import { AsyncScheduler } from './AsyncScheduler';
-
-export class QueueScheduler extends AsyncScheduler {
-}

package/node_modules/rxjs/src/internal/scheduler/VirtualTimeScheduler.ts

@@ -1,128 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { Subscription } from '../Subscription';
-import { AsyncScheduler } from './AsyncScheduler';
-import { SchedulerAction } from '../types';
-import { TimerHandle } from './timerHandle';
-
-export class VirtualTimeScheduler extends AsyncScheduler {
-  /** @deprecated Not used in VirtualTimeScheduler directly. Will be removed in v8. */
-  static frameTimeFactor = 10;
-
-  /**
-   * The current frame for the state of the virtual scheduler instance. The difference
-   * between two "frames" is synonymous with the passage of "virtual time units". So if
-   * you record `scheduler.frame` to be `1`, then later, observe `scheduler.frame` to be at `11`,
-   * that means `10` virtual time units have passed.
-   */
-  public frame: number = 0;
-
-  /**
-   * Used internally to examine the current virtual action index being processed.
-   * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
-   */
-  public index: number = -1;
-
-  /**
-   * This creates an instance of a `VirtualTimeScheduler`. Experts only. The signature of
-   * this constructor is likely to change in the long run.
-   *
-   * @param schedulerActionCtor The type of Action to initialize when initializing actions during scheduling.
-   * @param maxFrames The maximum number of frames to process before stopping. Used to prevent endless flush cycles.
-   */
-  constructor(schedulerActionCtor: typeof AsyncAction = VirtualAction as any, public maxFrames: number = Infinity) {
-    super(schedulerActionCtor, () => this.frame);
-  }
-
-  /**
-   * Prompt the Scheduler to execute all of its queued actions, therefore
-   * clearing its queue.
-   */
-  public flush(): void {
-    const { actions, maxFrames } = this;
-    let error: any;
-    let action: AsyncAction<any> | undefined;
-
-    while ((action = actions[0]) && action.delay <= maxFrames) {
-      actions.shift();
-      this.frame = action.delay;
-
-      if ((error = action.execute(action.state, action.delay))) {
-        break;
-      }
-    }
-
-    if (error) {
-      while ((action = actions.shift())) {
-        action.unsubscribe();
-      }
-      throw error;
-    }
-  }
-}
-
-export class VirtualAction<T> extends AsyncAction<T> {
-  protected active: boolean = true;
-
-  constructor(
-    protected scheduler: VirtualTimeScheduler,
-    protected work: (this: SchedulerAction<T>, state?: T) => void,
-    protected index: number = (scheduler.index += 1)
-  ) {
-    super(scheduler, work);
-    this.index = scheduler.index = index;
-  }
-
-  public schedule(state?: T, delay: number = 0): Subscription {
-    if (Number.isFinite(delay)) {
-      if (!this.id) {
-        return super.schedule(state, delay);
-      }
-      this.active = false;
-      // If an action is rescheduled, we save allocations by mutating its state,
-      // pushing it to the end of the scheduler queue, and recycling the action.
-      // But since the VirtualTimeScheduler is used for testing, VirtualActions
-      // must be immutable so they can be inspected later.
-      const action = new VirtualAction(this.scheduler, this.work);
-      this.add(action);
-      return action.schedule(state, delay);
-    } else {
-      // If someone schedules something with Infinity, it'll never happen. So we
-      // don't even schedule it.
-      return Subscription.EMPTY;
-    }
-  }
-
-  protected requestAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay: number = 0): TimerHandle {
-    this.delay = scheduler.frame + delay;
-    const { actions } = scheduler;
-    actions.push(this);
-    (actions as Array<VirtualAction<T>>).sort(VirtualAction.sortActions);
-    return 1;
-  }
-
-  protected recycleAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay: number = 0): TimerHandle | undefined {
-    return undefined;
-  }
-
-  protected _execute(state: T, delay: number): any {
-    if (this.active === true) {
-      return super._execute(state, delay);
-    }
-  }
-
-  private static sortActions<T>(a: VirtualAction<T>, b: VirtualAction<T>) {
-    if (a.delay === b.delay) {
-      if (a.index === b.index) {
-        return 0;
-      } else if (a.index > b.index) {
-        return 1;
-      } else {
-        return -1;
-      }
-    } else if (a.delay > b.delay) {
-      return 1;
-    } else {
-      return -1;
-    }
-  }
-}

package/node_modules/rxjs/src/internal/scheduler/animationFrame.ts

@@ -1,41 +0,0 @@
-import { AnimationFrameAction } from './AnimationFrameAction';
-import { AnimationFrameScheduler } from './AnimationFrameScheduler';
-
-/**
- *
- * Animation Frame Scheduler
- *
- * <span class="informal">Perform task when `window.requestAnimationFrame` would fire</span>
- *
- * When `animationFrame` scheduler is used with delay, it will fall back to {@link asyncScheduler} scheduler
- * behaviour.
- *
- * Without delay, `animationFrame` scheduler can be used to create smooth browser animations.
- * It makes sure scheduled task will happen just before next browser content repaint,
- * thus performing animations as efficiently as possible.
- *
- * ## Example
- * Schedule div height animation
- * ```ts
- * // html: <div style="background: #0ff;"></div>
- * import { animationFrameScheduler } from 'rxjs';
- *
- * const div = document.querySelector('div');
- *
- * animationFrameScheduler.schedule(function(height) {
- *   div.style.height = height + "px";
- *
- *   this.schedule(height + 1);  // `this` references currently executing Action,
- *                               // which we reschedule with new state
- * }, 0, 0);
- *
- * // You will see a div element growing in height
- * ```
- */
-
-export const animationFrameScheduler = new AnimationFrameScheduler(AnimationFrameAction);
-
-/**
- * @deprecated Renamed to {@link animationFrameScheduler}. Will be removed in v8.
- */
-export const animationFrame = animationFrameScheduler;

package/node_modules/rxjs/src/internal/scheduler/animationFrameProvider.ts

@@ -1,44 +0,0 @@
-import { Subscription } from '../Subscription';
-
-interface AnimationFrameProvider {
-  schedule(callback: FrameRequestCallback): Subscription;
-  requestAnimationFrame: typeof requestAnimationFrame;
-  cancelAnimationFrame: typeof cancelAnimationFrame;
-  delegate:
-    | {
-        requestAnimationFrame: typeof requestAnimationFrame;
-        cancelAnimationFrame: typeof cancelAnimationFrame;
-      }
-    | undefined;
-}
-
-export const animationFrameProvider: AnimationFrameProvider = {
-  // When accessing the delegate, use the variable rather than `this` so that
-  // the functions can be called without being bound to the provider.
-  schedule(callback) {
-    let request = requestAnimationFrame;
-    let cancel: typeof cancelAnimationFrame | undefined = cancelAnimationFrame;
-    const { delegate } = animationFrameProvider;
-    if (delegate) {
-      request = delegate.requestAnimationFrame;
-      cancel = delegate.cancelAnimationFrame;
-    }
-    const handle = request((timestamp) => {
-      // Clear the cancel function. The request has been fulfilled, so
-      // attempting to cancel the request upon unsubscription would be
-      // pointless.
-      cancel = undefined;
-      callback(timestamp);
-    });
-    return new Subscription(() => cancel?.(handle));
-  },
-  requestAnimationFrame(...args) {
-    const { delegate } = animationFrameProvider;
-    return (delegate?.requestAnimationFrame || requestAnimationFrame)(...args);
-  },
-  cancelAnimationFrame(...args) {
-    const { delegate } = animationFrameProvider;
-    return (delegate?.cancelAnimationFrame || cancelAnimationFrame)(...args);
-  },
-  delegate: undefined,
-};

package/node_modules/rxjs/src/internal/scheduler/asap.ts

@@ -1,44 +0,0 @@
-import { AsapAction } from './AsapAction';
-import { AsapScheduler } from './AsapScheduler';
-
-/**
- *
- * Asap Scheduler
- *
- * <span class="informal">Perform task as fast as it can be performed asynchronously</span>
- *
- * `asap` scheduler behaves the same as {@link asyncScheduler} scheduler when you use it to delay task
- * in time. If however you set delay to `0`, `asap` will wait for current synchronously executing
- * code to end and then it will try to execute given task as fast as possible.
- *
- * `asap` scheduler will do its best to minimize time between end of currently executing code
- * and start of scheduled task. This makes it best candidate for performing so called "deferring".
- * Traditionally this was achieved by calling `setTimeout(deferredTask, 0)`, but that technique involves
- * some (although minimal) unwanted delay.
- *
- * Note that using `asap` scheduler does not necessarily mean that your task will be first to process
- * after currently executing code. In particular, if some task was also scheduled with `asap` before,
- * that task will execute first. That being said, if you need to schedule task asynchronously, but
- * as soon as possible, `asap` scheduler is your best bet.
- *
- * ## Example
- * Compare async and asap scheduler<
- * ```ts
- * import { asapScheduler, asyncScheduler } from 'rxjs';
- *
- * asyncScheduler.schedule(() => console.log('async')); // scheduling 'async' first...
- * asapScheduler.schedule(() => console.log('asap'));
- *
- * // Logs:
- * // "asap"
- * // "async"
- * // ... but 'asap' goes first!
- * ```
- */
-
-export const asapScheduler = new AsapScheduler(AsapAction);
-
-/**
- * @deprecated Renamed to {@link asapScheduler}. Will be removed in v8.
- */
-export const asap = asapScheduler;

package/node_modules/rxjs/src/internal/scheduler/async.ts

@@ -1,56 +0,0 @@
-import { AsyncAction } from './AsyncAction';
-import { AsyncScheduler } from './AsyncScheduler';
-
-/**
- *
- * Async Scheduler
- *
- * <span class="informal">Schedule task as if you used setTimeout(task, duration)</span>
- *
- * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript
- * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating
- * in intervals.
- *
- * If you just want to "defer" task, that is to perform it right after currently
- * executing synchronous code ends (commonly achieved by `setTimeout(deferredTask, 0)`),
- * better choice will be the {@link asapScheduler} scheduler.
- *
- * ## Examples
- * Use async scheduler to delay task
- * ```ts
- * import { asyncScheduler } from 'rxjs';
- *
- * const task = () => console.log('it works!');
- *
- * asyncScheduler.schedule(task, 2000);
- *
- * // After 2 seconds logs:
- * // "it works!"
- * ```
- *
- * Use async scheduler to repeat task in intervals
- * ```ts
- * import { asyncScheduler } from 'rxjs';
- *
- * function task(state) {
- *   console.log(state);
- *   this.schedule(state + 1, 1000); // `this` references currently executing Action,
- *                                   // which we reschedule with new state and delay
- * }
- *
- * asyncScheduler.schedule(task, 3000, 0);
- *
- * // Logs:
- * // 0 after 3s
- * // 1 after 4s
- * // 2 after 5s
- * // 3 after 6s
- * ```
- */
-
-export const asyncScheduler = new AsyncScheduler(AsyncAction);
-
-/**
- * @deprecated Renamed to {@link asyncScheduler}. Will be removed in v8.
- */
-export const async = asyncScheduler;

package/node_modules/rxjs/src/internal/scheduler/dateTimestampProvider.ts

@@ -1,14 +0,0 @@
-import { TimestampProvider } from '../types';
-
-interface DateTimestampProvider extends TimestampProvider {
-  delegate: TimestampProvider | undefined;
-}
-
-export const dateTimestampProvider: DateTimestampProvider = {
-  now() {
-    // Use the variable rather than `this` so that the function can be called
-    // without being bound to the provider.
-    return (dateTimestampProvider.delegate || Date).now();
-  },
-  delegate: undefined,
-};

package/node_modules/rxjs/src/internal/scheduler/immediateProvider.ts

@@ -1,31 +0,0 @@
-import { Immediate } from '../util/Immediate';
-import type { TimerHandle } from './timerHandle';
-const { setImmediate, clearImmediate } = Immediate;
-
-type SetImmediateFunction = (handler: () => void, ...args: any[]) => TimerHandle;
-type ClearImmediateFunction = (handle: TimerHandle) => void;
-
-interface ImmediateProvider {
-  setImmediate: SetImmediateFunction;
-  clearImmediate: ClearImmediateFunction;
-  delegate:
-    | {
-        setImmediate: SetImmediateFunction;
-        clearImmediate: ClearImmediateFunction;
-      }
-    | undefined;
-}
-
-export const immediateProvider: ImmediateProvider = {
-  // When accessing the delegate, use the variable rather than `this` so that
-  // the functions can be called without being bound to the provider.
-  setImmediate(...args) {
-    const { delegate } = immediateProvider;
-    return (delegate?.setImmediate || setImmediate)(...args);
-  },
-  clearImmediate(handle) {
-    const { delegate } = immediateProvider;
-    return (delegate?.clearImmediate || clearImmediate)(handle as any);
-  },
-  delegate: undefined,
-};

package/node_modules/rxjs/src/internal/scheduler/intervalProvider.ts

@@ -1,31 +0,0 @@
-import type { TimerHandle } from './timerHandle';
-type SetIntervalFunction = (handler: () => void, timeout?: number, ...args: any[]) => TimerHandle;
-type ClearIntervalFunction = (handle: TimerHandle) => void;
-
-interface IntervalProvider {
-  setInterval: SetIntervalFunction;
-  clearInterval: ClearIntervalFunction;
-  delegate:
-    | {
-        setInterval: SetIntervalFunction;
-        clearInterval: ClearIntervalFunction;
-      }
-    | undefined;
-}
-
-export const intervalProvider: IntervalProvider = {
-  // When accessing the delegate, use the variable rather than `this` so that
-  // the functions can be called without being bound to the provider.
-  setInterval(handler: () => void, timeout?: number, ...args) {
-    const { delegate } = intervalProvider;
-    if (delegate?.setInterval) {
-      return delegate.setInterval(handler, timeout, ...args);
-    }
-    return setInterval(handler, timeout, ...args);
-  },
-  clearInterval(handle) {
-    const { delegate } = intervalProvider;
-    return (delegate?.clearInterval || clearInterval)(handle as any);
-  },
-  delegate: undefined,
-};

package/node_modules/rxjs/src/internal/scheduler/performanceTimestampProvider.ts

@@ -1,14 +0,0 @@
-import { TimestampProvider } from '../types';
-
-interface PerformanceTimestampProvider extends TimestampProvider {
-  delegate: TimestampProvider | undefined;
-}
-
-export const performanceTimestampProvider: PerformanceTimestampProvider = {
-  now() {
-    // Use the variable rather than `this` so that the function can be called
-    // without being bound to the provider.
-    return (performanceTimestampProvider.delegate || performance).now();
-  },
-  delegate: undefined,
-};