https://github.com/developit/mitt

    1. // @flow
    2. // An event handler can take an optional event argument
    3. // and should not return a value
    4. type EventHandler = (event?: any) => void;
    5. type WildCardEventHandler = (type: string, event?: any) => void
    7. // An array of all currently registered event handlers for a type
    8.   type EventHandlerList = Array<EventHandler>;
    9. type WildCardEventHandlerList = Array<WildCardEventHandler>;
    10. // A map of event types and their corresponding event handlers.
    11. type EventHandlerMap = {
    12.   '*'?: WildCardEventHandlerList,
    13.   [type: string]: EventHandlerList,
    14. };
    16. /** Mitt: Tiny (~200b) functional event emitter / pubsub.
    17.  *  @name mitt
    18.  *  @returns {Mitt}
    19.  */
    20. export default function mitt(all: EventHandlerMap) {
    21.   all = all || Object.create(null);
    23.   return {
    24.     /**
    25.      * Register an event handler for the given type.
    26.      *
    27.      * @param  {String} type    Type of event to listen for, or `"*"` for all events
    28.      * @param  {Function} handler Function to call in response to given event
    29.      * @memberOf mitt
    30.      */
    31.     on(type: string, handler: EventHandler) {
    32.       (all[type] || (all[type] = [])).push(handler);
    33.     },
    35.     /**
    36.      * Remove an event handler for the given type.
    37.      *
    38.      * @param  {String} type    Type of event to unregister `handler` from, or `"*"`
    39.      * @param  {Function} handler Handler function to remove
    40.      * @memberOf mitt
    41.      */
    42.     off(type: string, handler: EventHandler) {
    43.       if (all[type]) {
    44.         all[type].splice(all[type].indexOf(handler) >>> 0, 1);
    45.       }
    46.     },
    48.     /**
    49.      * Invoke all handlers for the given type.
    50.      * If present, `"*"` handlers are invoked after type-matched handlers.
    51.      *
    52.      * Note: Manually firing "*" handlers is not supported.
    53.      *
    54.      * @param {String} type  The event type to invoke
    55.      * @param {Any} [evt]  Any value (object is recommended and powerful), passed to each handler
    56.      * @memberOf mitt
    57.      */
    58.     emit(type: string, evt: any) {
    59.       (all[type] || []).slice().map((handler) => { handler(evt); });
    60.       (all['*'] || []).slice().map((handler) => { handler(type, evt); });
    61.     }
    62.   };
    63. }
    1. /** Mitt: Tiny (~200b) functional event emitter / pubsub.
    2.  *  @name mitt
    3.  *  @returns {Mitt}
    4.  */
    5. function mitt (all) {
    6.   all = all || Object.create(null)
    7.   return {
    8.     on (type, handler) {
    9.       if (!all[type]) {
    10.         all[type] = []
    11.       }
    12.       all[type].push(handler)
    13.     },
    14.     off (type, handler) {
    15.       if (all[type]) {
    16.         // x >>> 0本质上就是保证x有意义（为数字类型），
    17.         // 且为正整数，在有效的数组范围内（0 ～ 0xFFFFFFFF），
    18.         // 且在无意义的情况下缺省值为0。
    19.         // -1 >>> 0 === 4294967295
    20.         all[type].splice(all[type].indexOf(handler) >>> 0, 1)
    21.       }
    22.     },
    23.     emit (type, evt) {
    24.       (all[type] || []).slice().map(function (handler) {
    25.         handler(evt)
    26.       });
    27.       // 以“*”为名称的事件监听器会在任何事件触发后一起触发
    28.       (all['*'] || []).slice().map(function (handler) {
    29.         handler(type, evt)
    30.       })
    31.     }
    32.   }
    33. }