Alternative for removeAllListeners

[Haroenv]

I currently have an implementation using events and util.inherit (in the browser, so the npm versions), and would like to use mitt instead, however, I can't seem to figure out what I should use instead of removeAllListeners.

I guess I could keep a map of listeners myself, but that seems like duplicating what mitt does in the first place.

So far I have:

function DerivedHelper(mainHelper, fn) {
  this._emitter = mitt();
}

/**
 * Invoke all handlers for the given type.
 * If present, `"*"` handlers are invoked after type-matched handlers.
 *
 * @param {String} type The event type to invoke
 * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
 * @memberOf mitt
 */
DerivedHelper.prototype.emit = function(type, data) {
  this._emitter.emit(type, data);
};

/**
 * Register an event handler for the given type.
 *
 * @param  {String} type Type of event to listen for, or `"*"` for all events
 * @param  {Function} handler Function to call in response to given event
 */
DerivedHelper.prototype.on = function(type, cb) {
  this._emitter.on(type, cb);
};

/**
 * Remove an event handler for the given type.
 *
 * @param  {String} type Type of event to unregister `handler` from, or `"*"`
 * @param  {Function} handler Handler function to remove
 */
DerivedHelper.prototype.off = function(type, cb) {
  this._emitter.off(type, cb);
};

/**
 * Detach this helper from the main helper
 * @return {undefined}
 * @throws Error if the derived helper is already detached
 */
DerivedHelper.prototype.detach = function() {
  // TODO: find a replacement for this
  this.removeAllListeners();
};

Thanks!

[Haroenv]

before this used to be:

var util = require('util');
var events = require('events');

function DerivedHelper(mainHelper, fn) {
}

util.inherits(DerivedHelper, events.EventEmitter);

/**
 * Detach this helper from the main helper
 * @return {undefined}
 * @throws Error if the derived helper is already detached
 */
DerivedHelper.prototype.detach = function() {
  this.removeAllListeners();
};

[developit]

Hiya @Haroenv! Sorry for the slow response.
mitt() accepts an object listener mapping as an argument, which you can keep a reference to and clear using delete later on.

Here's a few implementations.

1. Function Composition

import mitt from 'mitt';

function EventEmitter() {
  const events = Object.create(null);
  const emitter = mitt(events);
  emitter.removeAllListeners = () => {
    for (let i in events) delete events[i];
  };
  return emitter;
}

2. ES5 class version

import mitt from 'mitt';

function EventEmitter() {
  this._events = Object.create(null);
  Object.assign(this, mitt(this._events));
}
EventEmitter.prototype.removeAllListeners = function() {
  for (let i in this._events) delete this._events[i];
};

3. Pure ES Classes version

import Mitt from 'mitt';

class EventEmitter extends Mitt {
  constructor() {
    const events = Object.create(null);
    super(events);
    this._events = events;
  }
  removeAllListeners() {
    for (let i in this._events) delete this._events[i];
  }
}

I'd recommend going with Option #3 if you're also patching in methods like addListener and removeListener.

[Haroenv]

This looks really cool, thanks! I'll compare later if this is smaller or not than the current events package which we use now. It likely is, but it might be better to fork and avoid the extra wrapper functions.

I'll let you know when I next work on this. In the mean time I'll close this issue, since this very likely solves the issue!