Use native EventTarget instead of EventEmitter

.github/workflows/main.yml

@@ -10,8 +10,7 @@ jobs:
       fail-fast: false
       matrix:
         node-version:
-          - 20
-          - 18
+          - 25
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4

package.json

@@ -12,7 +12,7 @@
 	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=18"
+		"node": ">=25"
 	},
 	"scripts": {
 		"build": "del-cli dist && tsc",

source/index.ts

@@ -1,4 +1,3 @@
-import {EventEmitter} from 'eventemitter3';
 import pTimeout, {TimeoutError} from 'p-timeout';
 import {type Queue, type RunFunction} from './queue.js';
 import PriorityQueue from './priority-queue.js';
@@ -13,7 +12,7 @@ type EventName = 'active' | 'idle' | 'empty' | 'add' | 'next' | 'completed' | 'e
 /**
 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, unicorn/prefer-event-target
+export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsType> = PriorityQueue, EnqueueOptionsType extends QueueAddOptions = QueueAddOptions> extends EventTarget { // eslint-disable-line @typescript-eslint/naming-convention
 	readonly #carryoverConcurrencyCount: boolean;
 
 	readonly #isIntervalIgnored: boolean;
@@ -99,7 +98,7 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 	#next(): void {
 		this.#pending--;
 		this.#tryToStartAnother();
-		this.emit('next');
+		this.dispatchEvent(new Event('next'));
 	}
 
 	#onResumeInterval(): void {
@@ -145,10 +144,10 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 
 			this.#intervalId = undefined;
 
-			this.emit('empty');
+			this.dispatchEvent(new Event('empty'));
 
 			if (this.#pending === 0) {
-				this.emit('idle');
+				this.dispatchEvent(new Event('idle'));
 			}
 
 			return false;
@@ -162,7 +161,7 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 					return false;
 				}
 
-				this.emit('active');
+				this.dispatchEvent(new Event('active'));
 				job();
 
 				if (canInitializeInterval) {
@@ -306,21 +305,21 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 
 					const result = await operation;
 					resolve(result);
-					this.emit('completed', result);
+					this.dispatchEvent(new CustomEvent('completed', {detail: result}));
 				} catch (error: unknown) {
 					if (error instanceof TimeoutError && !options.throwOnTimeout) {
 						resolve();
 						return;
 					}
 
 					reject(error);
-					this.emit('error', error);
+					this.dispatchEvent(new ErrorEvent('error', {error}));
 				} finally {
 					this.#next();
 				}
 			}, options);
 
-			this.emit('add');
+			this.dispatchEvent(new Event('add'));
 
 			this.#tryToStartAnother();
 		});
@@ -425,11 +424,11 @@ export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsT
 					return;
 				}
 
-				this.off(event, listener);
+				this.removeEventListener(event, listener);
 				resolve();
 			};
 
-			this.on(event, listener);
+			this.addEventListener(event, listener);
 		});
 	}
 

test/test.ts

@@ -1,5 +1,4 @@
 /* eslint-disable no-new */
-import EventEmitter from 'eventemitter3';
 import test from 'ava';
 import delay from 'delay';
 import inRange from 'in-range';
@@ -833,15 +832,15 @@ test('clear interval on pause', async t => {
 
 test('should be an event emitter', t => {
 	const queue = new PQueue();
-	t.true(queue instanceof EventEmitter);
+	t.true(queue instanceof EventTarget);
 });
 
 test('should emit active event per item', async t => {
 	const items = [0, 1, 2, 3, 4];
 	const queue = new PQueue();
 
 	let eventCount = 0;
-	queue.on('active', () => {
+	queue.addEventListener('active', () => {
 		eventCount++;
 	});
 
@@ -858,7 +857,7 @@ test('should emit idle event when idle', async t => {
 	const queue = new PQueue({concurrency: 1});
 
 	let timesCalled = 0;
-	queue.on('idle', () => {
+	queue.addEventListener('idle', () => {
 		timesCalled++;
 	});
 
@@ -897,7 +896,7 @@ test('should emit empty event when empty', async t => {
 	const queue = new PQueue({concurrency: 1});
 
 	let timesCalled = 0;
-	queue.on('empty', () => {
+	queue.addEventListener('empty', () => {
 		timesCalled++;
 	});
 
@@ -929,7 +928,7 @@ test('should emit add event when adding task', async t => {
 	const queue = new PQueue({concurrency: 1});
 
 	let timesCalled = 0;
-	queue.on('add', () => {
+	queue.addEventListener('add', () => {
 		timesCalled++;
 	});
 
@@ -973,7 +972,7 @@ test('should emit next event when completing task', async t => {
 	const queue = new PQueue({concurrency: 1});
 
 	let timesCalled = 0;
-	queue.on('next', () => {
+	queue.addEventListener('next', () => {
 		timesCalled++;
 	});
 
@@ -1018,10 +1017,10 @@ test('should emit completed / error events', async t => {
 
 	let errorEvents = 0;
 	let completedEvents = 0;
-	queue.on('error', () => {
+	queue.addEventListener('error', () => {
 		errorEvents++;
 	});
-	queue.on('completed', () => {
+	queue.addEventListener('completed', () => {
 		completedEvents++;
 	});