From 54417bdfbfcdfe07742e39a60583549586569f0c Mon Sep 17 00:00:00 2001
From: Ferit <frtcm11@gmail.com>
Date: Sun, 1 Nov 2026 23:01:38 +0200
Subject: [PATCH] Support interface event maps

---
 src/index.ts                   |  8 +++++---
 test/test-types-compilation.ts | 15 +++++++++++++++
 2 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/index.ts b/src/index.ts
index 17672aa..0bdae47 100644
--- a/src/index.ts
+++ b/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 =
diff --git a/test/test-types-compilation.ts b/test/test-types-compilation.ts
index 476e631..0817241 100644
--- a/test/test-types-compilation.ts
+++ b/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 }>();