There's an issue I overlooked when initially authoring this.
Currently, the return type is EventEmitter.

This works fine in most cases, but when extending EventEmitter, the type should be this, otherwise chained calls may fail in TypeScript.

A fix should be implemented shortly.

  if (arr.indexOf(listener) !== -1) {
    arr.splice(arr.indexOf(listener), 1);
    this.emit("removeListener", eventName, listener);
    if (arr.length === 0) {
      this.events.delete(eventName);
    }
  }

indexOf(listener) is called twice

by checking (arr.length === 1) before we splice we can avoid arr.splice entirely if delete the thing anyway

Also not sure if it is possible with your implementation to remove a listener added with .once()

Currently .listeners(eventName) works as an alias for .rawListeners(eventName)

When used after calling .once() or.prependOnceListener, this may cause some issues.

Now that the repository has been moved to the "denolibs" org, the name "deno_event_emitter" is redundant. "event_emitter" seems to make more sense.

Fix is on the way.

Hey,
Not really an issue but I would like to share with you: ts-evt.
For now, it is a node module but I was thinking about porting it to Deno.
It is very different from EventEmitter but much powerfull in many ways.
I think a new runtime is an opportunity for changing the rules.

I would love to have your feedback.
Feel free to delete the issue if you find it inappropriate.

The example creates a subclass and then uses a chainable method. Neither of those idead are necessary to use the EventEmitter and obscure its elegance.

I suggest these changes, but I know this subjective so feel free to ignore all of this and close it if you like.

import EventEmitter from 'https://raw.github.com/ozjd/deno_event_emitter/master/mod.ts';

const emitter = new EventEmitter()

emitter.on('event', payload => {
  console.log('event', payload)
})

emitter.emit('event', 'hello world!')
emitter.emit('event', 'hello, again, world!')

And then also give an example of using it as a subclass:

class Collection extends EventEmitter {
  items: object[]

  public constructor() {
    super() 
  }

  public add(item:object) {
    this.items.push(item)
    this.emit('added', item)
  }
}

const c = new Collection()

c.on('added', item => console.log('added', item))

c.add('A')
c.add('B')

... to remove all listeners from all events if eventName is not specified.

tbd in #6

If you attempt to compile the example in the README with a tsconfing where compilerOptions.strict is true, the following compilation errors occur:

error TS7053: Element implicitly has an 'any' type because expression of type '"listener"' can't be used to index type 'Function'.
  Property 'listener' does not exist on type 'Function'.

► https://deno.land/x/event_emitter/lib/mod.ts:104:31

104       unwrappedListeners[i] = arr[i]["listener"] || arr[i];
                                  ~~~~~~~~~~~~~~~~~~

error TS2339: Property 'listener' does not exist on type '(...args: any[]) => void'.

► https://deno.land/x/event_emitter/lib/mod.ts:153:13

153     wrapped.listener = listener;
                ~~~~~~~~

error TS2345: Argument of type 'string | symbol | undefined' is not assignable to parameter of type 'string | symbol'.    Type 'undefined' is not assignable to type 'string | symbol'.

► https://deno.land/x/event_emitter/lib/mod.ts:178:25

178     if (this.events.has(eventName)) {
                            ~~~~~~~~~

error TS2345: Argument of type 'string | symbol | undefined' is not assignable to parameter of type 'string | symbol'.    Type 'undefined' is not assignable to type 'string | symbol'.

► https://deno.land/x/event_emitter/lib/mod.ts:179:42

179       const listeners = (this.events.get(eventName) as Function[]).slice(); // Create a copy; We use it AFTER it's deleted.
                                             ~~~~~~~~~

error TS2345: Argument of type 'string | symbol | undefined' is not assignable to parameter of type 'string | symbol'.    Type 'undefined' is not assignable to type 'string | symbol'.

► https://deno.land/x/event_emitter/lib/mod.ts:180:26

180       this.events.delete(eventName);
                             ~~~~~~~~~


Found 5 errors.

I created this EventEmitter to be able to quickly port some of my NodeJS code to Deno, as well as having a simpler interface than what was available at the time.

Deno now has some node-compatible libraries such as https://deno.land/std/node/events.ts

This, coupled with the fact that I'm no longer using Deno (this may change in the future) leads me to question if it's worthwhile to keep this project? If anyone's interested in taking it over ( @Balou9 ? ) I'd be interested in hearing from you.