events: fix addAbortListener for aborted signals

Signed-off-by: Lazizbek Ergashev <lazerg2@gmail.com>

Author: lazerg

lib/internal/event_target.js

@@ -1243,6 +1243,7 @@ module.exports = {
   kTrustEvent,
   kRemoveListener,
   kEvents,
+  kTarget,
   kWeakHandler,
   kResistStopPropagation,
   isEventTarget,

lib/internal/events/abort_listener.js

@@ -17,6 +17,9 @@ const {
 let queueMicrotask;
 let kResistStopPropagation;
 let abortListenerOptions;
+let Event;
+let kTarget;
+let kTrustEvent;
 
 /**
  * @param {AbortSignal} signal
@@ -33,7 +36,19 @@ function addAbortListener(signal, listener) {
   let removeEventListener;
   if (signal.aborted) {
     queueMicrotask ??= require('internal/process/task_queues').queueMicrotask;
-    queueMicrotask(() => listener());
+    if (Event === undefined) {
+      ({ Event, kTarget, kTrustEvent } = require('internal/event_target'));
+    }
+    let disposed = false;
+    queueMicrotask(() => {
+      if (disposed) return;
+      const event = new Event('abort', { [kTrustEvent]: true });
+      event[kTarget] = signal;
+      listener(event);
+    });
+    removeEventListener = () => {
+      disposed = true;
+    };
   } else {
     kResistStopPropagation ??= require('internal/event_target').kResistStopPropagation;
     abortListenerOptions ??= ObjectFreeze({ __proto__: null, once: true, [kResistStopPropagation]: true });

test/parallel/test-events-add-abort-listener.mjs

@@ -33,6 +33,26 @@ describe('events.addAbortListener', () => {
     assert.strictEqual(typeof disposable[Symbol.dispose], 'function');
   });
 
+  it('should pass an abort event to the listener for aborted runners', async () => {
+    const signal = AbortSignal.abort();
+    events.addAbortListener(
+      signal,
+      common.mustCall((e) => {
+        assert.strictEqual(e.type, 'abort');
+        assert.strictEqual(e.target, signal);
+      }),
+    );
+
+    await new Promise(queueMicrotask);
+  });
+
+  it('should not execute the listener for aborted runners when disposed', async () => {
+    const disposable = events.addAbortListener(AbortSignal.abort(), common.mustNotCall());
+    disposable[Symbol.dispose]();
+
+    await new Promise(queueMicrotask);
+  });
+
   it('should execute the listener even when event propagation stopped', () => {
     const controller = new AbortController();
     const { signal } = controller;