Move EventEmitter polyfill from metacom

README.md

@@ -287,6 +287,26 @@ console.log({ size, bytes });
 |     mb |     6 | megabyte  |
 |     kb |     3 | kilobyte  |
 
+## Class `EnevtEmitter`
+
+- `getMaxListeners(): number`
+- `listenerCount(name: string): number`
+- `on(name: string, fn: Function)`
+- `once(name: string, fn: Function)`
+- `emit(name: string, ...args: Array<unknown>)`
+- `remove(name: string, fn: Function)`
+- `clear(name: string)`
+
+## `EnevtEmitter` utilities
+
+- `once(emitter: EventEmitter, name: string): Promise<unknown>`
+
+```js
+const ee = new metautil.EventEmitter();
+setTimeout(() => ee.emit('name3', 'value'), 100);
+const result = await metautil.once(ee, 'name3');
+```
+
 ## License & Contributors
 
 Copyright (c) 2017-2023 [Metarhia contributors](https://github.com/metarhia/metautil/graphs/contributors).

dist.js

@@ -5,6 +5,7 @@ module.exports = {
   ...require('./lib/async.js'),
   ...require('./lib/datetime.js'),
   ...require('./lib/error.js'),
+  ...require('./lib/events.js'),
   ...require('./lib/http.js'),
   ...require('./lib/objects.js'),
   ...require('./lib/pool.js'),

lib/events.js

@@ -0,0 +1,69 @@
+'use strict';
+
+class EventEmitter {
+  constructor() {
+    this.events = new Map();
+    this.maxListenersCount = 10;
+  }
+
+  getMaxListeners() {
+    return this.maxListenersCount;
+  }
+
+  listenerCount(name) {
+    const event = this.events.get(name);
+    if (event) return event.size;
+    return 0;
+  }
+
+  on(name, fn) {
+    const event = this.events.get(name);
+    if (event) {
+      event.add(fn);
+      const tooManyListeners = event.size > this.maxListenersCount;
+      if (tooManyListeners) {
+        const name = 'MaxListenersExceededWarning';
+        const warn = 'Possible EventEmitter memory leak detected';
+        const max = `Current maxListenersCount is ${this.maxListenersCount}`;
+        const hint = 'Hint: avoid adding listeners in loops';
+        console.warn(`${name}: ${warn}. ${max}. ${hint}`);
+      }
+    } else {
+      this.events.set(name, new Set([fn]));
+    }
+  }
+
+  once(name, fn) {
+    const dispose = (...args) => {
+      this.remove(name, dispose);
+      return void fn(...args);
+    };
+    this.on(name, dispose);
+  }
+
+  emit(name, ...args) {
+    const event = this.events.get(name);
+    if (!event) return;
+    for (const fn of event.values()) {
+      fn(...args);
+    }
+  }
+
+  remove(name, fn) {
+    const event = this.events.get(name);
+    if (!event) return;
+    event.delete(fn);
+  }
+
+  clear(name) {
+    if (!name) return void this.events.clear();
+    this.events.delete(name);
+  }
+}
+
+const once = (emitter, name) =>
+  new Promise((resolve) => {
+    emitter.once(name, resolve);
+  });
+
+module.exports = { EventEmitter, once };

metautil.d.ts

@@ -1,4 +1,3 @@
-import { EventEmitter } from 'node:events';
 import { IncomingMessage } from 'node:http';
 import { ScryptOptions, X509Certificate } from 'node:crypto';
 
@@ -260,3 +259,18 @@ export function collect(
   keys: Array<string>,
   options?: CollectorOptions,
 ): Collector;
+
+// Submodule: Events
+
+export class EventEmitter {
+  constructor();
+  getMaxListeners(): number;
+  listenerCount(name: string): number;
+  on(name: string, fn: Function): void;
+  once(name: string, fn: Function): void;
+  emit(name: string, ...args: Array<unknown>): void;
+  remove(name: string, fn: Function): void;
+  clear(name: string): void;
+}
+
+export function once(emitter: EventEmitter, name: string): Promise<unknown>;

metautil.js

@@ -7,6 +7,7 @@ module.exports = {
   ...require('./lib/crypto.js'),
   ...require('./lib/datetime.js'),
   ...require('./lib/error.js'),
+  ...require('./lib/events.js'),
   ...require('./lib/fs.js'),
   ...require('./lib/http.js'),
   ...require('./lib/network.js'),

test/events.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const metatests = require('metatests');
+const metautil = require('..');
+
+metatests.test('EventEmitter', async (test) => {
+  const ee = new metautil.EventEmitter();
+
+  test.strictSame(ee.getMaxListeners(), 10);
+  test.assert(ee.events instanceof Map);
+
+  let onCount = 0;
+  let onceCount = 0;
+
+  ee.on('name1', (data) => {
+    test.strictSame(data, 'value');
+    onCount++;
+  });
+
+  ee.once('name1', (data) => {
+    test.strictSame(data, 'value');
+    onceCount++;
+  });
+
+  ee.emit('name1', 'value');
+  ee.emit('name1', 'value');
+
+  test.strictSame(onCount, 2);
+  test.strictSame(onceCount, 1);
+
+  test.strictSame(ee.listenerCount('name1'), 1);
+  test.strictSame(ee.listenerCount('name2'), 0);
+
+  let count = 0;
+  const fn = () => {
+    count++;
+  };
+  ee.on('name1', fn);
+  ee.emit('name1', 'value');
+  test.strictSame(count, 1);
+
+  test.strictSame(ee.listenerCount('name1'), 2);
+  ee.remove('name1', fn);
+  test.strictSame(ee.listenerCount('name1'), 1);
+
+  ee.emit('name1', 'value');
+  test.strictSame(count, 1);
+
+  ee.clear('name1');
+  test.strictSame(ee.listenerCount('name1'), 0);
+
+  setTimeout(() => {
+    ee.emit('name3', 'value');
+  }, 50);
+
+  const result = await metautil.once(ee, 'name3');
+  test.strictSame(result, 'value');
+
+  ee.clear();
+  test.strictSame(ee.listenerCount('name3'), 0);
+
+  test.end();
+});