lib: add aborted() utility function

doc/api/util.md

@@ -1989,6 +1989,38 @@ const channel = new MessageChannel();
 channel.port2.postMessage(signal, [signal]);
 ```
 
+## `util.aborted(signal, resource)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+* `signal` {AbortSignal}
+* `resource` {any} Any non-null entity
+* Returns: {Promise}
+
+Listens to abort event on the provided `signal` and returns a promise which is
+resolved if an abort event is triggered. The function is dependent on the `resource`
+entity and will be resolved only if the `resource` is not removed
+from memory, when `resource` goes out of memory the
+promise shall remain pending and any event listeners attached to the `signal`
+will be removed.
+
+```js
+const { aborted } = require('util');
+
+const ac = new AbortController();
+const dependent = {};
+
+aborted(ac.signal, dependent).then(() => {
+  // Do something when the abort event is triggered.
+});
+
+doSomething(dependent, ac.signal); // Can trigger the abort event
+```
+
 ## `util.types`
 
 <!-- YAML

lib/internal/abort_controller.js

@@ -13,6 +13,7 @@ const {
   Symbol,
   SymbolToStringTag,
   WeakRef,
+  PromiseResolve,
 } = primordials;
 
 const {
@@ -22,11 +23,13 @@ const {
   kTrustEvent,
   kNewListener,
   kRemoveListener,
+  kWeakHandler,
 } = require('internal/event_target');
 const {
   customInspectSymbol,
   kEnumerableProperty,
   kEmptyObject,
+  createDeferredPromise,
 } = require('internal/util');
 const { inspect } = require('internal/util/inspect');
 const {
@@ -39,6 +42,8 @@ const {
 
 const {
   validateUint32,
+  validateAbortSignal: abortSignalValidator,
+  validateObject,
 } = require('internal/validators');
 
 const {
@@ -357,6 +362,21 @@ function transferableAbortController() {
   return AbortController[kMakeTransferable]();
 }
 
+/**
+ * @param {AbortSignal} signal
+ * @param {any} resource
+ * @returns {Promise<void>}
+ */
+async function aborted(signal, resource) {
+  abortSignalValidator(signal, 'signal');
+  validateObject(resource, 'resource', { nullable: false, allowFunction: true, allowArray: true });
+  if (signal.aborted)
+    return PromiseResolve();
+  const abortPromise = createDeferredPromise();
+  signal.addEventListener('abort', abortPromise.resolve, { [kWeakHandler]: resource, once: true });
+  return abortPromise.promise;
+}
+
 ObjectDefineProperties(AbortController.prototype, {
   signal: kEnumerableProperty,
   abort: kEnumerableProperty,
@@ -377,4 +397,5 @@ module.exports = {
   ClonedAbortSignal,
   transferableAbortSignal,
   transferableAbortController,
+  aborted,
 };

lib/util.js

@@ -393,6 +393,9 @@ module.exports = {
   get transferableAbortController() {
     return lazyAbortController().transferableAbortController;
   },
+  get aborted() {
+    return lazyAbortController().aborted;
+  },
   types
 };
 

test/parallel/test-aborted-util.js

@@ -0,0 +1,44 @@
+// Flags: --expose-gc
+'use strict';
+
+const common = require('../common');
+const { aborted } = require('util');
+const assert = require('assert');
+const { getEventListeners } = require('events');
+
+{
+  // Test aborted works when provided a resource
+  const ac = new AbortController();
+  aborted(ac.signal, {}).then(common.mustCall());
+  ac.abort();
+  assert.strictEqual(ac.signal.aborted, true);
+  assert.strictEqual(getEventListeners(ac.signal, 'abort').length, 0);
+}
+
+{
+  // Test aborted with gc cleanup
+  const ac = new AbortController();
+  aborted(ac.signal, {}).then(common.mustNotCall());
+  setImmediate(() => {
+    global.gc();
+    ac.abort();
+    assert.strictEqual(ac.signal.aborted, true);
+    assert.strictEqual(getEventListeners(ac.signal, 'abort').length, 0);
+  });
+}
+
+{
+  // Fails with error if not provided abort signal
+  const sig = new EventTarget();
+  assert.rejects(aborted(sig, {}), {
+    name: 'TypeError',
+  });
+}
+
+{
+  // Fails if not provided a resource
+  const ac = new AbortController();
+  assert.rejects(aborted(ac.signal, null), {
+    name: 'TypeError',
+  });
+}