Method add

source/index.ts:444–574

(function_: Task<TaskResultType>, options: Partial<EnqueueOptionsType> = {})

	*/
	async add<TaskResultType>(function_: Task<TaskResultType>, options?: Partial<EnqueueOptionsType>): Promise<TaskResultType>;
	async add<TaskResultType>(function_: Task<TaskResultType>, options: Partial<EnqueueOptionsType> = {}): Promise<TaskResultType> {
		// Create a copy to avoid mutating the original options object
		options = {
			timeout: this.timeout,
			...options,
			// Assign unique ID if not provided
			id: options.id ?? (this.#idAssigner++).toString(),
		};

		return new Promise((resolve, reject) => {
			// Create a unique symbol for tracking this task
			const taskSymbol = Symbol(`task-${options.id}`);

			let cleanupQueueAbortHandler = () => undefined;
			const run = async () => {
				// Task is now running — remove the queued-state abort listener
				cleanupQueueAbortHandler();

				this.#pending++;

				// Track this running task
				this.#runningTasks.set(taskSymbol, {
					id: options.id,
					priority: options.priority ?? 0, // Match priority-queue default
					startTime: Date.now(),
					timeout: options.timeout,
				});

				let eventListener: (() => void) | undefined;

				try {
					// Check abort signal - if aborted, need to decrement the counter
					// that was incremented in tryToStartAnother
					try {
						options.signal?.throwIfAborted();
					} catch (error) {
						this.#rollbackIntervalConsumption();

						// Clean up tracking before throwing
						this.#runningTasks.delete(taskSymbol);

						throw error;
					}

					this.#lastExecutionTime = Date.now();

					let operation = function_({signal: options.signal});

					if (options.timeout) {
						operation = pTimeout(Promise.resolve(operation), {
							milliseconds: options.timeout,
							message: `Task timed out after ${options.timeout}ms (queue has ${this.#pending} running, ${this.#queue.size} waiting)`,
						});
					}

					if (options.signal) {
						const {signal} = options;