events: support EventTarget in once

doc/api/events.md

@@ -663,9 +663,13 @@ added: v11.13.0
 
 Creates a `Promise` that is resolved when the `EventEmitter` emits the given
 event or that is rejected when the `EventEmitter` emits `'error'`.
-The `Promise` will resolve with an array of all the arguments emitted to the
+The `Promise` will fulfill with an array of all the arguments emitted to the
 given event.
 
+Note: This method is intentionally generic and works with the web platform
+[EventTarget](WHATWG-EventTarget) interface, which have no special
+`'error'` event semantics and do not listen to the `'error'` event.
+
 ```js
 const { once, EventEmitter } = require('events');
 
@@ -703,4 +707,5 @@ run();
 [`fs.ReadStream`]: fs.html#fs_class_fs_readstream
 [`net.Server`]: net.html#net_class_net_server
 [`process.on('warning')`]: process.html#process_event_warning
+[WHATWG-EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget)
 [stream]: stream.html

lib/events.js

@@ -494,21 +494,31 @@ function once(emitter, name) {
     };
     let errorListener;
 
-    // Adding an error listener is not optional because
-    // if an error is thrown on an event emitter we cannot
-    // guarantee that the actual event we are waiting will
-    // be fired. The result could be a silent way to create
-    // memory or file descriptor leaks, which is something
-    // we should avoid.
-    if (name !== 'error') {
-      errorListener = (err) => {
-        emitter.removeListener(name, eventListener);
-        reject(err);
-      };
-
-      emitter.once('error', errorListener);
-    }
 
-    emitter.once(name, eventListener);
+    if (typeof emitter.once === 'function' &&
+        typeof emitter.removeListener === 'function') {
+        // Adding an error listener is not optional because
+        // if an error is thrown on an event emitter we cannot
+        // guarantee that the actual event we are waiting will
+        // be fired. The result could be a silent way to create
+        // memory or file descriptor leaks, which is something
+        // we should avoid.
+        if (name !== 'error') {
+          errorListener = (err) => {
+            emitter.removeListener(name, eventListener);
+            reject(err);
+          };
+          emitter.once('error', errorListener);
+        }
+      return emitter.once(name, eventListener);
+    }
+    if (typeof emitter.addEventListener === 'function') {
+      return new Promise((resolve) => {
+        // Although EventTarget does not have `error` event semantics like Node
+        // EventEmitters, we do not listen to `error` events here.
+        emitter.addEventListener(name, resolve, { once: true });
+      });
+    }
+    throw new ERR_INVALID_ARG_TYPE('emitter', 'EventEmitter', emitter);
   });
 }

test/parallel/test-events-once.js

@@ -84,10 +84,31 @@ async function onceError() {
   strictEqual(ee.listenerCount('myevent'), 0);
 }
 
+async function onceWithEventTarget() {
+  const emitter = new class EventTargetLike extends EventEmitter {
+    addEventListener = common.mustCall(function (name, listener, options) {
+      if (options.once) {
+        this.once(name, listener);
+      } else {
+        this.on(name, listener);
+      }
+    });
+  };
+  // make sure we don't bind as EventEmitter
+  emitter.addListener = emitter.on = undefined;
+  process.nextTick(() => {
+    emitter.emit('myevent', 42);
+  });
+  const [value] = await once(emitter, 'myevent');
+  strictEqual(value, 42);
+  strictEqual(emitter.listenerCount('myevent'), 0);
+}
+
 Promise.all([
   onceAnEvent(),
   onceAnEventWithTwoArgs(),
   catchesErrors(),
   stopListeningAfterCatchingError(),
-  onceError()
+  onceError(),
+  onceWithEventTarget()
 ]).then(common.mustCall());