Suggestion

🔍 Search Terms

EventEmitter, extends, generics, nodejs, typescript, keyof, Objects, interface, constraints

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals. (I'm pretty sure)

⭐ Suggestion

Extends doesn't constrain the generic type, it just expects the type to have at least those qualities. I'd like to ensure that only the expected types are allowed. This is useful for things like a typed event emitter that loop over the keys of a generic. As it stands now, I have to get a bit ugly which may open up possible errors.

Having a constrainedby keyword or something similar would allow only generic types or child classes to be subclasses rather than extensions. This would allow child classes to still be considered children of their parents but more strict. However, extensions of the constrained child may try to override the parent so that still needs to be checked.

interface KeyListener {
  [key: string]: Array<0|1>
}

// No errors
class TypedEmitter<C constrainedby KeyListener> extends EventEmitter {
  on<T extends keyof C>(
    event: T, listener: (...args: C[T])=>void
  ){
    super.on(event, listener);
    return this
  }
}

const zero = Symbol("0");
const badInstance = new TypedEmitter<{ [zero]: [0,0,0,0], 1: [1,1,1,1] }>()
/*
    Error, The generic C in TypedEmitter<C> is constrained by KeyListener, only specified keys are allowed
    - [key: string]: Array<0|1>
    Found Bad Keys
    - [symbol("0")]: [0,0,0,0]
    - 1: [1,1,1,1]

*/


interface BadChildInterface constrainedby KeyListener {
  [zero]: [0,0,0,0],
  1: [1,1,1,1] 
  /*
    Error, BadChildInterface is constrained by KeyListener, only specified keys are allowed
    - [key: string]: Array<0|1>
    Found Bad Keys
    - [symbol("0")]: [0,0,0,0]
    - 1: [1,1,1,1]
  */
}

📃 Motivating Example

Playground link with relevant code

Overloading can get absurd

Certianly not DRY

💻 Use Cases

EventEmitters, can't think of much else. But with how common event emitters are, this would be pretty great

Anything that loops over a keyof for type definition