Allow interface event maps in TypeScript

src/index.ts

@@ -1,5 +1,7 @@
 export type EventType = string | symbol;
 
+type EventMap<Events> = { [Key in keyof Events]: Key extends EventType ? unknown : never };
+
 // An event handler can take an optional event argument
 // and should not return a value
 export type Handler<T = unknown> = (event: T) => void;
@@ -15,12 +17,12 @@ export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<
 >;
 
 // A map of event types and their corresponding event handlers.
-export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
+export type EventHandlerMap<Events extends EventMap<Events>> = Map<
 	keyof Events | '*',
 	EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>
 >;
 
-export interface Emitter<Events extends Record<EventType, unknown>> {
+export interface Emitter<Events extends EventMap<Events>> {
 	all: EventHandlerMap<Events>;
 
 	on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
@@ -43,7 +45,7 @@ export interface Emitter<Events extends Record<EventType, unknown>> {
  * @name mitt
  * @returns {Mitt}
  */
-export default function mitt<Events extends Record<EventType, unknown>>(
+export default function mitt<Events extends EventMap<Events>>(
 	all?: EventHandlerMap<Events>
 ): Emitter<Events> {
 	type GenericEventHandler =

test/test-types-compilation.ts

@@ -76,3 +76,18 @@ const wildcardHandler = (
 	// @ts-expect-error
 	emitter.emit('bar', 'string');
 }
+
+// Interfaces should work as event maps too.
+interface InterfaceEvents {
+	foo: string;
+	bar?: number;
+}
+const interfaceEmitter = mitt<InterfaceEvents>();
+interfaceEmitter.emit('foo', 'value');
+interfaceEmitter.emit('bar');
+// @ts-expect-error
+interfaceEmitter.emit('foo', 1);
+// @ts-expect-error
+interfaceEmitter.emit('missing', 1);
+// @ts-expect-error
+mitt<{ 42: string }>();