feat: sync mitt (#2677)

src/utils/mitt.ts

@@ -2,32 +2,37 @@
  * copy to https://github.com/developit/mitt
  * Expand clear method
  */
-
 export type EventType = string | symbol;
 
 // An event handler can take an optional event argument
 // and should not return a value
-export type Handler<T = any> = (event?: T) => void;
+export type Handler<T = unknown> = (event: T) => void;
-export type WildcardHandler = (type: EventType, event?: any) => void;
+export type WildcardHandler<T = Record<string, unknown>> = (
+  type: keyof T,
+  event: T[keyof T],
+) => void;
 
 // An array of all currently registered event handlers for a type
-export type EventHandlerList = Array<Handler>;
+export type EventHandlerList<T = unknown> = Array<Handler<T>>;
-export type WildCardEventHandlerList = Array<WildcardHandler>;
+export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
 
 // A map of event types and their corresponding event handlers.
-export type EventHandlerMap = Map<EventType, EventHandlerList | WildCardEventHandlerList>;
+export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
+  keyof Events | '*',
+  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>
+>;
 
-export interface Emitter {
+export interface Emitter<Events extends Record<EventType, unknown>> {
-  all: EventHandlerMap;
+  all: EventHandlerMap<Events>;
 
-  on<T = any>(type: EventType, handler: Handler<T>): void;
+  on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
-  on(type: '*', handler: WildcardHandler): void;
+  on(type: '*', handler: WildcardHandler<Events>): void;
 
-  off<T = any>(type: EventType, handler: Handler<T>): void;
+  off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
-  off(type: '*', handler: WildcardHandler): void;
+  off(type: '*', handler: WildcardHandler<Events>): void;
 
-  emit<T = any>(type: EventType, event?: T): void;
+  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
-  emit(type: '*', event?: any): void;
+  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
   clear(): void;
 }
 
@@ -36,7 +41,10 @@ export interface Emitter {
  * @name mitt
  * @returns {Mitt}
  */
-export default function mitt(all?: EventHandlerMap): Emitter {
+export function mitt<Events extends Record<EventType, unknown>>(
+  all?: EventHandlerMap<Events>,
+): Emitter<Events> {
+  type GenericEventHandler = Handler<Events[keyof Events]> | WildcardHandler<Events>;
   all = all || new Map();
 
   return {
@@ -47,48 +55,61 @@ export default function mitt(all?: EventHandlerMap): Emitter {
 
     /**
      * Register an event handler for the given type.
-     * @param {string|symbol} type Type of event to listen for, or `"*"` for all events
+     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
      * @param {Function} handler Function to call in response to given event
      * @memberOf mitt
      */
-    on<T = any>(type: EventType, handler: Handler<T>) {
+    on<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {
-      const handlers = all?.get(type);
+      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
-      const added = handlers && handlers.push(handler);
+      if (handlers) {
-      if (!added) {
+        handlers.push(handler);
-        all?.set(type, [handler]);
+      } else {
+        all!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);
       }
     },
 
     /**
      * Remove an event handler for the given type.
-     * @param {string|symbol} type Type of event to unregister `handler` from, or `"*"`
+     * If `handler` is omitted, all handlers of the given type are removed.
-     * @param {Function} handler Handler function to remove
+     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
+     * @param {Function} [handler] Handler function to remove
      * @memberOf mitt
      */
-    off<T = any>(type: EventType, handler: Handler<T>) {
+    off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {
-      const handlers = all?.get(type);
+      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
       if (handlers) {
-        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        if (handler) {
+          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        } else {
+          all!.set(type, []);
+        }
       }
     },
 
     /**
      * Invoke all handlers for the given type.
-     * If present, `"*"` handlers are invoked after type-matched handlers.
+     * If present, `'*'` handlers are invoked after type-matched handlers.
      *
-     * Note: Manually firing "*" handlers is not supported.
+     * Note: Manually firing '*' handlers is not supported.
      *
      * @param {string|symbol} type The event type to invoke
      * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
      * @memberOf mitt
      */
-    emit<T = any>(type: EventType, evt: T) {
+    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {
-      ((all?.get(type) || []) as EventHandlerList).slice().map((handler) => {
+      let handlers = all!.get(type);
-        handler(evt);
+      if (handlers) {
-      });
+        (handlers as EventHandlerList<Events[keyof Events]>).slice().forEach((handler) => {
-      ((all?.get('*') || []) as WildCardEventHandlerList).slice().map((handler) => {
+          handler(evt as Events[Key]);
-        handler(type, evt);
+        });
-      });
+      }
+
+      handlers = all!.get('*');
+      if (handlers) {
+        (handlers as WildCardEventHandlerList<Events>).slice().forEach((handler) => {
+          handler(type, evt as Events[Key]);
+        });
+      }
     },
 
     /**