events: match dispatch state on synthesized abort event

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

Author: lazerg

doc/api/events.md

@@ -1883,6 +1883,10 @@ added:
  - v20.5.0
  - v18.18.0
 changes:
+ - version: REPLACEME
+   pr-url: https://github.com/nodejs/node/pull/65640
+   description: When the signal is already aborted, the listener now receives an
+                `abort` event and disposing cancels the pending call.
  - version:
    - v24.0.0
    - v22.16.0
@@ -1908,6 +1912,9 @@ not prevent the listener from running.
 
 Returns a disposable so that it may be unsubscribed from more easily.
 
+If `signal` is already aborted, the listener is called with an `abort` event in a
+microtask. Disposing before that microtask runs cancels the call.
+
 ```cjs
 const { addAbortListener } = require('node:events');
 

lib/internal/event_target.js

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

lib/internal/events/abort_listener.js

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

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

@@ -35,22 +35,21 @@ describe('events.addAbortListener', () => {
 
   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);
-      }),
-    );
+    const { promise, resolve } = Promise.withResolvers();
+    events.addAbortListener(signal, (e) => resolve([e, e?.currentTarget]));
 
-    await new Promise(queueMicrotask);
+    const [event, currentTarget] = await promise;
+    assert.strictEqual(event.type, 'abort');
+    assert.strictEqual(event.target, signal);
+    assert.strictEqual(event.isTrusted, true);
+    assert.strictEqual(currentTarget, signal);
   });
 
   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);
+    await new Promise(setImmediate);
   });
 
   it('should execute the listener even when event propagation stopped', () => {