Allow changing intervalCap later

readme.md

@@ -112,6 +112,8 @@ Minimum: `1`
 
 The max number of runs in the given interval of time.
 
+Can be changed later by setting `queue.intervalCap`. If changed in the middle of a running interval, the new cap applies immediately. If the new cap is lower than the used cap, the "debt" is not carried over into the next interval.
+
 ##### interval
 
 Type: `number`\

source/index.ts

@@ -16,11 +16,9 @@ Promise queue with concurrency control.
 export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsType> = PriorityQueue, EnqueueOptionsType extends QueueAddOptions = QueueAddOptions> extends EventEmitter<EventName> { // eslint-disable-line @typescript-eslint/naming-convention
 	readonly #carryoverConcurrencyCount: boolean;
 
-	readonly #isIntervalIgnored: boolean;
-
 	#intervalCount = 0;
 
-	readonly #intervalCap: number;
+	#intervalCap: number;
 
 	#rateLimitedInInterval = false;
 	#rateLimitFlushScheduled = false;
@@ -58,6 +56,12 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 	*/
 	timeout?: number;
 
+	static #assertValidIntervalCap(value: unknown): asserts value is number {
+		if (!(typeof value === 'number' && value >= 1)) {
+			throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${value?.toString() ?? ''}\` (${typeof value})`);
+		}
+	}
+
 	constructor(options?: Options<QueueType, EnqueueOptionsType>) {
 		super();
 
@@ -72,16 +76,13 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 			...options,
 		} as Options<QueueType, EnqueueOptionsType>;
 
-		if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {
-			throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ''}\` (${typeof options.intervalCap})`);
-		}
+		PQueue.#assertValidIntervalCap(options.intervalCap);
 
 		if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
 			throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ''}\` (${typeof options.interval})`);
 		}
 
 		this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount!;
-		this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
 		this.#intervalCap = options.intervalCap;
 		this.#interval = options.interval;
 		this.#queue = new options.queueClass!();
@@ -98,6 +99,25 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 		this.#setupRateLimitTracking();
 	}
 
+	get #isIntervalIgnored(): boolean {
+		return this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0;
+	}
+
+	get intervalCap(): number {
+		return this.#intervalCap;
+	}
+
+	set intervalCap(value: number) {
+		if (value === this.#intervalCap) {
+			return;
+		}
+
+		PQueue.#assertValidIntervalCap(value);
+
+		this.#intervalCap = value;
+		this.#processQueue();
+	}
+
 	get #doesIntervalAllowAnother(): boolean {
 		return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
 	}

source/options.ts

@@ -34,6 +34,8 @@ export type Options<QueueType extends Queue<RunFunction, QueueOptions>, QueueOpt
 	/**
 	The max number of runs in the given interval of time.
 
+	Can be changed later by setting `queue.intervalCap`. If changed in the middle of a running interval, the new cap applies immediately. If the new cap is lower than the used cap, the "debt" is not carried over into the next interval.
+
 	Minimum: `1`.
 
 	@default Infinity

test-d/index.test-d.ts

@@ -4,3 +4,6 @@ import PQueue from '../source/index.js';
 const queue = new PQueue();
 
 expectType<Promise<string>>(queue.add(async () => '🦄'));
+
+expectType<number>(queue.intervalCap);
+queue.intervalCap = 5;