fix: drop any in abort controller

Signed-off-by: ferhat elmas <elmas.ferhat@gmail.com>

Author: ferhatelmas

src/internal/concurrency/async-abort-controller.ts

@@ -2,31 +2,44 @@
  * This special AbortController is used to wait for all the abort handlers to finish before resolving the promise.
  */
 export class AsyncAbortController extends AbortController {
-  protected promises: Promise<any>[] = []
+  protected promises: Promise<unknown>[] = []
   protected _nextGroup?: AsyncAbortController
 
   constructor() {
     super()
 
-    const originalEventListener = this.signal.addEventListener
+    const originalEventListener = this.signal.addEventListener.bind(this.signal)
 
     // Patch event addEventListener to keep track of listeners and their promises
-    this.signal.addEventListener = (type: string, listener: any, options: any) => {
+    this.signal.addEventListener = (
+      type: string,
+      listener: EventListenerOrEventListenerObject | null,
+      options?: boolean | AddEventListenerOptions
+    ) => {
+      if (!listener) {
+        return
+      }
+
       if (type !== 'abort') {
-        return originalEventListener.call(this.signal, type, listener, options)
+        return originalEventListener(type, listener, options)
       }
 
-      let resolving: undefined | (() => Promise<void>) = undefined
+      let resolving: ((event: Event) => Promise<void>) | undefined
       const promise = new Promise<void>((resolve, reject) => {
-        resolving = async (): Promise<void> => {
-          return Promise.resolve()
-            .then(() => listener())
-            .then(() => {
+        resolving = (event: Event): Promise<void> => {
+          try {
+            const result =
+              typeof listener === 'function'
+                ? listener.call(this.signal, event)
+                : listener.handleEvent(event)
+
+            return Promise.resolve(result).then(() => {
               resolve()
-            })
-            .catch((error) => {
-              reject(error)
-            })
+            }, reject)
+          } catch (error) {
+            reject(error)
+            return Promise.resolve()
+          }
         }
       })
       this.promises.push(promise)
@@ -35,7 +48,7 @@ export class AsyncAbortController extends AbortController {
         throw new Error('resolve is undefined')
       }
 
-      return originalEventListener.call(this.signal, type, resolving, options)
+      return originalEventListener(type, resolving as EventListener, options)
     }
   }
 

src/test/async-abort-controller.test.ts

@@ -69,4 +69,71 @@ describe('AsyncAbortController', () => {
 
     expect(order).toEqual(['root:start', 'root:end', 'child', 'grandchild'])
   })
+
+  it('forwards the real abort event to function listeners with the signal as context', async () => {
+    const controller = new AsyncAbortController()
+    const seen: {
+      target: EventTarget | null
+      currentTarget: EventTarget | null
+      context: unknown
+    } = {
+      target: null,
+      currentTarget: null,
+      context: undefined,
+    }
+
+    controller.signal.addEventListener('abort', function (event) {
+      seen.target = event.target
+      seen.currentTarget = event.currentTarget
+      seen.context = this
+    })
+
+    await controller.abortAsync()
+
+    expect(seen.target).toBe(controller.signal)
+    expect(seen.currentTarget).toBe(controller.signal)
+    expect(seen.context).toBe(controller.signal)
+  })
+
+  it('waits for handleEvent listeners before aborting nested groups', async () => {
+    const controller = new AsyncAbortController()
+    const childGroup = controller.nextGroup
+    const order: string[] = []
+    let releaseRootAbort!: () => void
+    const rootAbortDone = new Promise<void>((resolve) => {
+      releaseRootAbort = resolve
+    })
+    const listener = {
+      target: null as EventTarget | null,
+      async handleEvent(event: Event) {
+        this.target = event.target
+        order.push('root:start')
+        await rootAbortDone
+        order.push('root:end')
+      },
+    }
+
+    controller.signal.addEventListener('abort', listener)
+    childGroup.signal.addEventListener('abort', () => {
+      order.push('child')
+    })
+
+    const abortPromise = controller.abortAsync()
+
+    await Promise.resolve()
+    expect(order).toEqual(['root:start'])
+
+    releaseRootAbort()
+    await abortPromise
+
+    expect(listener.target).toBe(controller.signal)
+    expect(order).toEqual(['root:start', 'root:end', 'child'])
+  })
+
+  it('ignores null abort listeners', async () => {
+    const controller = new AsyncAbortController()
+
+    expect(() => controller.signal.addEventListener('abort', null)).not.toThrow()
+    await expect(controller.abortAsync()).resolves.toBeUndefined()
+  })
 })