es6/utils/Events.js

export default class Events {
  /**
 * the wildcard `*` event
 *
 * @type       {string} "*"
 */
  static get wildcard () {
    return '*'
  }

  /**
 * adds namespaced event handlers to `process.on("message")`
 * 
 * @function namespace
 * @param    {Object}   evtMap  a key, value dictionary of namespaces
 * @param    {Any}      ctx     the `this` to apply with a namespace, useful for prototype process listeners
 * 
 * @example
 * 
 *  process.on('message', 
 *    namespace({
 *        job: this.run
 *      }, this)
 *   )
 */
  static namespace (evtMap, ctx) {
    const allEvents = Object.keys(evtMap)
    
    return function namespacedEventHandler (data) {
      let handler
      
      const evt = typeof data === 'object' ? Object.keys(data)[0] : Events.wildcard
      
      if ( !( handler = evtMap[ evt ]) ) return
      
      const dataToEmit =  evt === Events.wildcard ? data : data[evt]
      
      if ( ctx ) return handler.call( ctx, dataToEmit )
      
      handler( dataToEmit )
    }
  }

    /**
   * generates an evented method name from an event
   * 
   * @function methodName
   * @param    {String}  evt
   * @return   {String} 
   */

  static methodName (evt) {
    return `emit${evt[0].toUpperCase()}${evt.slice(1)}`
  }

    /**
   * extends a prototype with an Event Dictionary
   * @function methodize
   */

  static methodize (klass, dict) {
    Object.keys(dict).forEach( evt => {
      klass.prototype[ Events.methodName(evt) ] = function _emitter (data) {
        this.emit( dict[evt], data )
        return this
      }
    })
  }
}