Method enqueue

lib/compilation-queue.ts:76–120

(job: Job<Result>, options?: EnqueueOptions)

    }

    enqueue<Result>(job: Job<Result>, options?: EnqueueOptions): PromiseLike<Result> {
        const enqueueAsyncId = executionAsyncId();
        const enqueuedAt = Date.now();

        // If we're asked to enqueue a job when we're already in a async queued job context, just run it.
        // This prevents a deadlock.
        if (this._running.has(enqueueAsyncId)) return job();
        queueEnqueued.inc();
        return this._queue.add(
            () => {
                const dequeuedAt = Date.now();
                queueDequeued.inc();
                if (options?.abandonIfStale && dequeuedAt > enqueuedAt + this._staleAfterMs) {
                    queueCompleted.inc();
                    queueStale.inc();
                    const queueTimeSecs = (dequeuedAt - enqueuedAt) / 1000;
                    const limitSecs = this._staleAfterMs / 1000;
                    throw new Error(
                        `Compilation was in the queue too long (${queueTimeSecs.toFixed(1)}s > ${limitSecs.toFixed(
                            1,
                        )}s)`,
                    );
                }
                const jobAsyncId = executionAsyncId();
                if (this._running.has(jobAsyncId)) {
                    throw new Error('somehow we entered the context twice');
                }
                try {
                    this._running.add(jobAsyncId);
                    const result = job();
                    // Count completion when the job settles (even by rejection), not when it
                    // merely returns its promise. Deliberately not awaited here: a job that
                    // never settles must not hold _running (and so status().busy) forever.
                    Promise.resolve(result).then(
                        () => queueCompleted.inc(),
                        () => queueCompleted.inc(),
                    );
                    return result;
                } finally {
                    this._running.delete(jobAsyncId);
                }
            },
            {priority: options?.highPriority ? 100 : 0},
        );
    }

    status(): {busy: boolean; pending: number; size: number} {
        const pending = this._queue.pending;