Class IdleScheduler

packages/core/src/defer/idle_scheduler.ts:53–157

 * options (including no options) are batched together.
 */
export class IdleScheduler implements OnDestroy {
  // Serialize options rather than using the object reference to ensure
  // that different IdleRequestOptions references with the same values
  // are batched into the same bucket.
  private readonly buckets = new Map<string, IdleBucket>();

  // Lookup from callback to its bucket key.
  private readonly callbackBucket = new Map<VoidFunction, string>();
  private readonly applicationRef = inject(ApplicationRef);

  private readonly ngZone = inject(NgZone);
  private readonly idleService = inject(IDLE_SERVICE);

  add(callback: VoidFunction, options?: IdleRequestOptions) {
    const key = getIdleRequestKey(options);
    this.callbackBucket.set(callback, key);

    let bucket = this.buckets.get(key);
    if (bucket == null) {
      bucket = {idleId: null, queue: new Set()};
      this.buckets.set(key, bucket);
    }
    bucket.queue.add(callback);
    this.scheduleBucket(bucket, options);
  }

  remove(callback: VoidFunction) {
    const key = this.callbackBucket.get(callback);
    if (key === undefined) return;

    this.callbackBucket.delete(callback);

    const bucket = this.buckets.get(key);
    if (!bucket) return;

    bucket.queue.delete(callback);

    // If the last callback in this bucket was removed, cancel the
    // idle callback - cancel it.
    if (bucket.queue.size === 0) {
      this.cancelBucket(bucket);
      this.buckets.delete(key);
    }
  }

  private scheduleBucket(bucket: IdleBucket, options?: IdleRequestOptions) {
    if (bucket.idleId !== null) {
      return;
    }

    const key = getIdleRequestKey(options);
    const callback = (deadline?: IdleDeadline) => {
      this.cancelBucket(bucket);

      for (const cb of bucket.queue) {
        cb();
        // _tick here is an optimized change detection check and is safe to call here.
        // We also account for the time it takes to run change detection