Basic - EventEmitter

emitter.ts

import * as EventEmitter3 from 'eventemitter3'
import * as pEvent from 'p-event'

export class Emitter<Names extends string = string, Data = any> extends EventEmitter3<Names, Data> {
	get events() {
		return this._events
	}

	hasListener(listener: EventEmitter3.Listener<Data>, context?: any, once?: boolean) {
		let names = Object.keys(this.events)
		let i: number,
			len = names.length
		for (i = 0; i < len; i++) {
			let name = names[i]
			let events = this.events[name] as EventEmitter3.Event<Data>[]
			if (!Array.isArray(events)) events = [events]
			let ii: number,
				lenn = events.length
			for (ii = 0; ii < lenn; ii++) {
				let event = events[ii]
				if (arguments.length == 1) {
					if (listener == event.fn) {
						return true
					}
				} else if (arguments.length == 2) {
					if (listener == event.fn && context == event.context) {
						return true
					}
				} else if (arguments.length == 3) {
					if (listener == event.fn && context == event.context && once == event.once) {
						return true
					}
				}
			}
		}
		return false
	}

	isListening<Name extends Names>(name: Name, listener: EventEmitter3.Listener<Data>) {
		let listeners = this.listeners(name)
		let i: number,
			len = listeners.length
		for (i = 0; i < len; i++) {
			if (listener == listeners[i]) return true
		}
		return false
	}

	offListener<Name extends Names>(listener: EventEmitter3.Listener<Data>, context?: any, once?: boolean) {
		this.eventNames().forEach(name => {
			this.listeners(name).forEach(fn => {
				this.off(name, listener, context, once)
			})
		})
		return this
	}

	offContext<Name extends Names>(name: Name, context: any, once?: boolean) {
		this.listeners(name).forEach(fn => {
			this.off(name, fn, context, once)
		})
		return this
	}

	offAll<Name extends Names>(name?: Name) {
		return this.removeAllListeners(name)
	}

	toPromise<Name extends Names>(name: Name) {
		return pEvent(this, name, { multiArgs: true })
	}
}

eventemitter3.d.ts

declare module 'eventemitter3' {
	namespace EventEmitter3 {
		type Listener<Data = any> = (...args: Data[]) => void
		interface Event<Data = any> {
			fn: Listener<Data>
			context: any
			once: boolean
		}
	}

	class EventEmitter3<Names extends string = string, Data = any> {
		static prefixed: string | boolean
		_events: { [name: string]: EventEmitter3.Event<Data> | EventEmitter3.Event<Data>[] }
		_eventsCount: number
		eventNames<Name extends Names>(): Name[]
		listeners<Name extends Names>(name: Name): EventEmitter3.Listener<Data>[]
		listenerCount<Name extends Names>(name: Name): number
		emit<Name extends Names>(name: Name, ...args: Data[]): void
		on<Name extends Names>(
			name: Name,
			listener: EventEmitter3.Listener<Data>,
			context?: any
		): this
		addListener<Name extends Names>(
			name: Name,
			listener: EventEmitter3.Listener<Data>,
			context?: any
		): this
		once<Name extends Names>(
			name: Name,
			listener: EventEmitter3.Listener<Data>,
			context?: any
		): this
		removeListener<Name extends Names>(
			name: Name,
			listener?: EventEmitter3.Listener<Data>,
			context?: any,
			once?: boolean
		): this
		off<Name extends Names>(
			name: Name,
			listener?: EventEmitter3.Listener<Data>,
			context?: any,
			once?: boolean
		): this
		removeAllListeners<Name extends Names>(name?: Name): this
	}

	export = EventEmitter3
}