Promise based wrapper for socket.once

[panwauu]

For testing purposes, I often wait for a single event using socket.once(...) like in the code below. This code adds a lot of overhead and does not infer the type of the Promise somehow.

const promise = new Promise((resolve) => {
  socket.once(eventName, (data) => { resolve(data) })
})

Instead I would like an interface like this:

const promise = socket.oncePromise(eventName, timeout)

I implemented it this way:

import { io, Socket } from 'socket.io-client'
import { EventNames, ReservedOrUserEventNames } from 'socket.io/dist/typed-events'

type onceCallbackFirstArgument<Ev, E> = Ev extends EventNames<E> ? (E[Ev] extends (...args: any) => void ? Parameters<E[Ev]>[0] : never) : never

class CustomSocket<L, E> extends Socket<L, E> {
  oncePromise<Ev extends ReservedOrUserEventNames<{}, L>>(ev: Ev, timeout?: number): Promise<onceCallbackFirstArgument<Ev, L>> {
    return new Promise((resolve, reject) => {
      let timer: any
      if (timeout != null) {
        timer = setTimeout(() => {
          reject(new Error('timeout!'))
        }, timeout)
      }

      this.once(ev as any, (data: any) => {
        clearTimeout(timer)
        resolve(data)
      })
    })
  }
}

// @ts-ignore
Socket.prototype.emitWithAck = CustomSocket.prototype.emitWithAck

type ListenEvents = {
  test: (data1: number) => void
}
const socket = io() as CustomSocket<ListenEvents, {}>
const promise = socket.oncePromise('test', 1000)
console.log(promise)

It seems to work, but I find the implementation ugly.
Does anyone have a better implementation?
What is the general opinion of a move promise based implementation?

Similar to #4144