listenerCount() and Emittery.listenerAdded event not working as expected

[AuHau]

If I have the following snippet

emitter.on(Emittery.listenerAdded, () => {
  console.log('Count: ', emitter.listenerCount('helloEvent'))
})

emitter.on('helloEvent', () => {})
emitter.on('helloEvent', () => {})

Then I get printed:

Count: 2
Count: 2

While I would expect:

Count: 1
Count: 2

[sindresorhus]

// @Richienb

[Richienb]

@sindresorhus The problem involves the asynchronous nature of promises. They are only executed during idle time which is why sindresorhus/make-synchronous#3 is impossible (since synchronously sleeping is not counted as idle). However, before idle time is reached, all of the synchronous emitter.on calls are made before these promises:

emittery/index.js

Lines 256 to 268 in 1afed6a

	await resolvedPromise;
	await Promise.all([
	...staticListeners.map(async listener => {
	if (listeners.has(listener)) {
	return listener(eventData);
	}
	}),
	...staticAnyListeners.map(async listener => {
	if (anyListeners.has(listener)) {
	return listener(eventName, eventData);
	}
	})
	]);

get a chance to start calling the callback defined in emitter.on(Emitter.listenerAdded). As expected, these proof-of-concept changes within .emit() fix the problem at hand:

-               await resolvedPromise;
-               await Promise.all([
-                       ...staticListeners.map(async listener => {
-                               if (listeners.has(listener)) {
-                                       return listener(eventData);
-                               }
-                       }),
-                       ...staticAnyListeners.map(async listener => {
-                               if (anyListeners.has(listener)) {
-                                       return listener(eventName, eventData);
-                               }
-                       })
-               ]);
+               staticListeners.map(listener => {
+                       if (listeners.has(listener)) {
+                               return listener(eventData);
+                       }
+               });
+               staticAnyListeners.map(listener => {
+                       if (anyListeners.has(listener)) {
+                               return listener(eventName, eventData);
+                       }
+               });

This means that the scope of this problem actually extends to any code using .emit():

const Emittery = require('.');

const emitter = new Emittery();

emitter.on('unicorn', () => {
	console.count(`Event received`);
});

emitter.emit('unicorn');
console.count('Event sent');

emitter.emit('unicorn');
console.count('Event sent');

The above code outputs:

Event sent: 1
Event sent: 2
Event received: 1
Event received: 2

Instead of:

Event received: 1
Event sent: 1
Event received: 2
Event sent: 2

[Richienb]

After some additional investigation, it appears that the only way to fix this problem is to wait for .emit to resolve by awaiting it here:

emittery/index.js

Line 207 in 1afed6a

this.emit(listenerAdded, {eventName, listener});

and here:

emittery/index.js

Line 223 in 1afed6a

this.emit(listenerRemoved, {eventName, listener});

However, this will require us to make .on() and .off() return promises.

[sindresorhus]

However, this will require us to make .on() and .off() return promises.

Is there really no other way?

[Richienb]

🤷‍♂️

[Richienb]

Is there really no other way?

I guess the only other way is to make .emit a synchronous function.