typescript - Infer class argument type from super call

Question

In my project using discord.js, there is a ClientEvents interface that holds event argument tuple types:

interface ClientEvents {
  ready: [];
  warn: [reason: string]
  message: [message: Message];
  // ...some more events
}

I also have an EventHandler class, which takes a type argument:

abstract class EventHandler<E extends keyof ClientEvents> {

  protected constructor(public eventName: E) {}

  abstract execute(...args: ClientEvents[E]): void;
}

The problem is that I can't extend this class using type inference for E, even if it's explicitly set in the super() call:

// Error: Generic type 'EventHandler<E>' requires 1 type argument(s).
class ReadyHandler extends EventHandler {

  public constructor() {
    super('ready'); // I want to infer the type using this argument
  }

  public execute() {
    // Some more code
  }
}

Is there a way to infer class argument types using the arguments of a super() call?

question from:https://stackoverflow.com/questions/65836052/infer-class-argument-type-from-super-call

Answer 1

No, not easily; inference generally doesn't work that way. You could, of course, write it out:

class ReadyHandler extends EventHandler<"ready"> {    
  public constructor() {  super('ready');  }    
  public execute() {}
}

If you want to avoid that redundancy you could refactor or encapsulate EventHandler so that you give it an actual string of type E and E will be inferred from it. The resulting class will no longer be generic. For example:

function SpecificHandler<E extends keyof ClientEvents>(eventName: E) {
  abstract class SpecificHandler extends EventHandler<E> {
    constructor() { super(eventName) };
  }
  return SpecificHandler;
}

class MessageHandler extends SpecificHandler("message") {
  public execute(msg: Message) {

  }
}

I'm not sure it's worth it, though.

Playground link to code