@irrelon/emitter 5.0.0 → 5.0.2

package/src/Emitter.ts

@@ -2,7 +2,7 @@
  The MIT License (MIT)
 
  Copyright (c) 2014 Irrelon Software Limited
- http://www.irrelon.com
+ https://www.irrelon.com
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
@@ -25,12 +25,13 @@
  Source: https://github.com/irrelon/emitter
 
  Changelog:
+ 	Version 5.0.2:
+ 		Removed some unnecessary code, updated to be in step with version
+ 		that is being used in the new version of Isogenic Game Engine.
+ 	Version 5.0.1:
+ 		Further TypeScript updates.
  	Version 5.0.0:
- 		Added typescript types, switched from mocha to jest for test
- 		running.
- 		Breaking change. When using makeEmitter, prototypeMode is now
- 		false by default. Simply pass makeEmitter(SomeClass.prototype)
- 		instead of makeEmitter(SomeClass) to modify a prototype.
+ 		Added TypeScript and prettier, removed babel etc
  	Version 4.0.1:
  		Updated library to use new ES6 functionality making Overload()
  		less useful so it can be removed as a dependency.
@@ -83,83 +84,62 @@
 	Version 1.0.0:
 		First commit
  */
-export interface InternalEventListenersType {
-	[eventName: string|symbol]: InternalEventListenersByIdType
+export enum EventReturnFlag {
+	none,
+	cancel
 }
 
-export interface InternalEventListenersByIdType {
-	[idName: string|symbol]: Array<EventListenerType>
-}
-
-export type EventListenerType = (...rest: any[]) => any;
-
-export interface InternalEventEmittersType {
-	[eventName: string|symbol]: Array<EventEmitterType>
-}
-
-export interface EventEmitterType {
-	id: string|symbol
-	args: any
+export type EventListenerCallback = (...args: any[]) => any | Promise<any>;
+export interface EventStaticEmitterObject {
+	id: string;
+	args: any[];
 }
 
 /**
- * @class Emitter
- * @constructor
+ * Creates a new class with the capability to emit events.
  */
 export class Emitter {
-	private _emitting: boolean;
-	private _noEmitDefer: boolean;
-	private _listeners: InternalEventListenersType
-	private _emitters: InternalEventEmittersType
-	private _eventRemovalQueue: Array<(...rest: any[]) => any>;
-	private _deferTimeout: any;
-
-	constructor (obj?: any) {
-		this._noEmitDefer = false;
-		this._emitting = false;
-		this._listeners = {};
-		this._emitters = {};
-		this._eventRemovalQueue = [];
-
-		if (obj !== undefined) {
-			return makeEmitter(obj);
-		}
-	}
+	_eventsEmitting: boolean = false;
+	_eventRemovalQueue: any[] = [];
+	_eventListeners?: Record<string, Record<string, EventListenerCallback[]>>;
+	_eventStaticEmitters: Record<string, EventStaticEmitterObject[]> = {};
+	_eventsAllowDefer: boolean = false;
+	_eventsDeferTimeouts: Record<any, number> = {};
 
 	/**
 	 * Attach an event listener to the passed event only if the passed
-	 * id matches the document id for the event being fired.
-	 * @memberOf Emitter
-	 * @method on
-	 * @param {String} event The name of the event to listen for.
-	 * @param {*} id The document id to match against.
-	 * @param {Function} listener The method to call when the event is fired.
+	 * id matches the id for the event being fired.
+	 * @param {string} eventName The name of the event to listen for.
+	 * @param {string} id The id to match against.
+	 * @param {function} listener The method to call when the event is fired.
 	 * @returns {Emitter} The emitter instance.
 	 */
-	_on (event: string|symbol, id: string|symbol, listener: (...rest: any[]) => any) {
-		const generateEmitterTimeout = (emitter: EventEmitterType) => {
+	_on (eventName: string, id: string, listener: EventListenerCallback) {
+		const generateTimeout = (emitter: EventStaticEmitterObject) => {
 			setTimeout(() => {
-				listener.apply(this, emitter.args);
+				listener(...emitter.args);
 			}, 1);
 		};
 
-		this._listeners = this._listeners || {};
-		this._listeners[event] = this._listeners[event] || {};
-		this._listeners[event][id] = this._listeners[event][id] || [];
-		this._listeners[event][id].push(listener);
+		this._eventListeners = this._eventListeners || {};
+		this._eventListeners[eventName] = this._eventListeners[eventName] || {};
+		this._eventListeners[eventName][id] = this._eventListeners[eventName][id] || [];
+		this._eventListeners[eventName][id].push(listener);
 
 		// Check for any static emitters, and fire the event if any exist
-		if (!this._emitters || !this._emitters[event] || !this._emitters[event].length) return this;
+		if (!this._eventStaticEmitters || !this._eventStaticEmitters[eventName] || !this._eventStaticEmitters[eventName].length) return this;
 
 		// Emit events for each emitter
-		this._emitters[event].forEach((emitter: EventEmitterType) => {
+		for (let i = 0; i < this._eventStaticEmitters[eventName].length; i++) {
+			const emitter = this._eventStaticEmitters[eventName][i];
+
 			if (id === "*" || emitter.id === id) {
 				// Call the listener out of process so that any code that expects a listener
 				// to be called at some point in the future rather than immediately on registration
 				// will not fail
-				generateEmitterTimeout(emitter);
+				generateTimeout(emitter);
 			}
-		});
+		}
 
 		return this;
 	}
@@ -167,213 +147,248 @@ export class Emitter {
 	/**
 	 * Attach an event listener to the passed event only if the passed
 	 * id matches the document id for the event being fired.
-	 * @memberOf Emitter
-	 * @method once
-	 * @param {String} event The name of the event to listen for.
-	 * @param {*} id The document id to match against.
+	 * @param {String} eventName The name of the event to listen for.
+	 * @param {*} id The id to match against.
 	 * @param {Function} listener The method to call when the event is fired.
 	 * @returns {Emitter} The emitter instance.
 	 */
-	_once (event:string|symbol, id:string|symbol, listener: EventListenerType) {
+	_once (eventName: string, id: string, listener: EventListenerCallback) {
 		let fired = false;
 
-		const internalCallback = (...rest: any[]) => {
+		const internalCallback = (...args: any[]) => {
 			if (fired) return;
 
 			fired = true;
-			this.off(event, id, internalCallback);
-			listener(...rest);
+			this.off(eventName, id, internalCallback);
+			listener(...args);
 		};
 
-		return this.on(event, id, internalCallback);
+		return this.on(eventName, id, internalCallback);
 	}
 
 	/**
 	 * Cancels an event listener based on an event name, id and listener function.
-	 * @memberOf Emitter
-	 * @method off
-	 * @param {String} event The event to cancel listener for.
+	 * @param {String} eventName The event to cancel listener for.
 	 * @param {String} id The ID of the event to cancel listening for.
 	 * @param {Function} listener The event listener function used in the on()
 	 * or once() call to cancel.
 	 * @returns {Emitter} The emitter instance.
 	 */
-	_off (event: string|symbol, id: string|symbol, listener?: EventListenerType) {
-		if (this._emitting) {
+	_off (eventName: string, id: string, listener?: EventListenerCallback): this {
+		// If the event name doesn't have any listeners, exit early
+		if (!this._eventListeners || !this._eventListeners[eventName] || !this._eventListeners[eventName][id]) return this;
+
+		// If we are emitting events at the moment, don't remove this listener
+		// until the process has completed, so we queue for removal instead
+		if (this._eventsEmitting) {
 			this._eventRemovalQueue = this._eventRemovalQueue || [];
 			this._eventRemovalQueue.push(() => {
-				this.off(event, id, listener);
+				this.off(eventName, id, listener);
 			});
 
 			return this;
 		}
 
-		if (!this._listeners || !this._listeners[event] || !this._listeners[event][id]) return this;
-
-		if (id && !listener) {
+		// Check if we have no specific listener... in this case
+		// we want to remove all listeners for an id
+		if (!listener) {
 			if (id === "*") {
-				delete this._listeners[event];
+				// The id is "all" and no listener was provided so delete all
+				// event listeners for this event name
+				delete this._eventListeners[eventName];
 				return this;
 			}
 
-			// No listener provided, delete all listeners
-			delete this._listeners[event][id];
+			// No listener provided, delete all listeners for this id
+			delete this._eventListeners[eventName][id];
 			return this;
 		}
 
-		if (!listener) return this;
-
-		const arr = this._listeners[event][id] || [];
+		const arr = this._eventListeners[eventName][id] || [];
 		const index = arr.indexOf(listener);
 
 		if (index > -1) {
 			arr.splice(index, 1);
 		}
+
+		return this;
 	}
 
 	/**
 	 * Attach an event listener to the passed event only if the passed
 	 * id matches the document id for the event being fired.
-	 * @memberOf Emitter
-	 * @method on
-	 * @param {String} event The name of the event to listen for.
-	 * @param {*} id The document id to match against.
+	 * @param {String} eventName The name of the event to listen for.
+	 * @param {*} id The id to match against.
 	 * @param {Function} listener The method to call when the event is fired.
 	 * @returns {Emitter} The emitter instance.
 	 */
-	on (event: string|symbol, id: string|symbol, listener: EventListenerType): any;
-	on (event: string|symbol, listener: (...rest: any[]) => any): any;
-	on (event: string|symbol, ...rest: any[]) {
+	on (eventName: string, id: string, listener: EventListenerCallback): this;
+	on (eventName: string, listener: EventListenerCallback): this;
+	on (eventName: string, ...rest: any[]): this {
 		const restTypes = rest.map((arg) => typeof arg);
 
 		if (restTypes[0] === "function") {
-			return this._on.call(this, event, "*", rest[0]);
+			return this._on(eventName, "*", rest[0]);
 		}
 
-		return this._on.call(this, event, rest[0], rest[1]);
+		return this._on(eventName, rest[0], rest[1]);
 	}
 
 	/**
 	 * Attach an event listener to the passed event only if the passed
 	 * id matches the document id for the event being fired.
-	 * @memberOf Emitter
-	 * @method once
-	 * @param {String} event The name of the event to listen for.
-	 * @param {*} id The document id to match against.
-	 * @param {Function} listener The method to call when the event is fired.
+	 * @param {String} eventName The name of the event to listen for.
+	 * @param id The id to match against.
+	 * @param listener
 	 * @returns {Emitter} The emitter instance.
 	 */
-	once (event: string, id: string|symbol, listener: EventListenerType): any;
-	once (event: string, listener: (...rest: any[]) => any): any;
-	once (event: string, ...rest: any[]) {
+	once (eventName: string, id: string, listener: EventListenerCallback): this;
+	once (eventName: string, listener: EventListenerCallback): this;
+	once (eventName: string, ...rest: any[]): this {
 		const restTypes = rest.map((arg) => typeof arg);
 
 		if (restTypes[0] === "function") {
-			return this._once.call(this, event, "*", rest[0]);
+			return this._once(eventName, "*", rest[0]);
 		}
 
-		return this._once.call(this, event, rest[0], rest[1]);
+		return this._once(eventName, rest[0], rest[1]);
 	}
 
 	/**
-	 * Attach an event listener to the passed event only if the passed
-	 * id matches the document id for the event being fired.
-	 * @memberOf Emitter
-	 * @method once
-	 * @param {String} event The name of the event to listen for.
-	 * @param {*} id The document id to match against.
+	 * Overwrites any previous event listeners so that if the event fires, only
+	 * the listener you pass will be called. If you pass an id along with the
+	 * listener, only listeners for the id will be overwritten. This is similar
+	 * to calling `.off(eventName)` then `on(eventName, listener)` since
+	 * `off(eventName)` will cancel any previous event listeners for the passed
+	 * event name.
+	 * @param {String} eventName The name of the event to listen for.
+	 * @param {*} id The id to match against.
 	 * @param {Function} listener The method to call when the event is fired.
 	 * @returns {Emitter} The emitter instance.
 	 */
-	one (event: string, id: string|symbol, listener: EventListenerType): any;
-	one (event: string, listener: (...rest: any[]) => any): any;
-	one (event: string, ...rest: any[]) {
+	overwrite (eventName: string, id: string, listener: EventListenerCallback): this;
+	overwrite (eventName: string, listener: EventListenerCallback): this;
+	overwrite (eventName: string, ...rest: any[]) {
 		const restTypes = rest.map((arg) => typeof arg);
 
 		if (restTypes[0] === "function") {
-			this.off(event);
-			return this._on.call(this, event, "*", rest[0]);
+			this.off(eventName);
+			return this._on(eventName, "*", rest[0]);
 		}
 
-		this.off(event, rest[0]);
-		return this._on.call(this, event, rest[0], rest[1]);
+		this.off(eventName, rest[0]);
+		return this._on(eventName, rest[0], rest[1]);
 	}
 
 	/**
 	 * Cancels an event listener based on an event name, id and listener function.
-	 * @memberOf Emitter
-	 * @method off
-	 * @param event The event to cancel listener for.
-	 * @param id The ID of the event to cancel listening for.
-	 * @param listener The event listener function used in the on()
+	 * @param {String} eventName The event to cancel listener for.
+	 * @param {String} id The ID of the event to cancel listening for.
+	 * @param {Function} listener The event listener function used in the on()
 	 * or once() call to cancel.
 	 * @returns {Emitter} The emitter instance.
 	 */
-	off (event: string|symbol, id: string|symbol, listener?: EventListenerType): any;
-	off (event: string|symbol, listener: (...rest: any[]) => any): any;
-	off (event: string|symbol): any;
-	off (event: string|symbol, ...rest: any[]) {
+	off (eventName: string, id: string, listener?: EventListenerCallback): this;
+	off (eventName: string, listener?: EventListenerCallback): this;
+	off (eventName: string): this;
+	off (eventName: string, ...rest: any[]) {
 		if (rest.length === 0) {
-			// Only event was provided
-			return this._off.call(this, event, "*");
+			// Only event was provided, use * as the id to mean "any without"
+			// a specific id
+			return this._off(eventName, "*");
 		}
 
 		const restTypes = rest.map((arg) => typeof arg);
 
 		if (restTypes[0] === "function") {
-			return this._off.call(this, event, "*", rest[0]);
+			// The first arg after the event name was a function (listener)
+			// so remove listening for events for this specific listener
+			return this._off(eventName, "*", rest[0]);
 		}
 
-		return this._off.call(this, event, rest[0], rest[1]);
+		// Both id and listener were provided, remove for the specific id
+		return this._off(eventName, rest[0], rest[1]);
 	}
 
 	/**
-	 * Handles emitting events, is an internal method not called directly.
-	 * @param {String} event The name of the event to emit.
-	 * @param {*} data The data to emit with the event.
-	 * @returns {Emitter} The emitter instance.
-	 * @private
+	 * Emit an event by name.
+	 * @param {Object} eventName The name of the event to emit.
+	 * @param {...any} data The arguments to send to any listening methods.
+	 * If you are sending multiple arguments, separate them with a comma so
+	 * that they are received by the function as separate arguments.
+	 * @return {number}
+	 * @example #Emit an Event
+	 *     // Emit the event named "hello"
+	 *     myEntity.emit('hello');
+	 * @example #Emit an Event With Data Object
+	 *     // Emit the event named "hello"
+	 *     myEntity.emit('hello', {moo: true});
+	 * @example #Emit an Event With Multiple Data Values
+	 *     // Emit the event named "hello"
+	 *     myEntity.emit('hello', {moo: true}, 'someString');
+	 * @example #Listen for Event Data
+	 *     // Set a listener to listen for the data (multiple values emitted
+	 *     // from an event are passed as function arguments)
+	 *     myEntity.on('hello', function (arg1, arg2) {
+	 *         console.log(arg1, arg2);
+	 *     }
+	 *
+	 *     // Emit the event named "hello"
+	 *     myEntity.emit('hello', 'data1', 'data2');
+	 *
+	 *     // The console output is:
+	 *     //    data1, data2
 	 */
-	emit (event: string|symbol, ...data: any[]) {
+	async emit (eventName: string, ...data: any[]): Promise<EventReturnFlag> {
+		if (!this._eventListeners) {
+			return EventReturnFlag.none;
+		}
+
 		const id = "*";
-		this._listeners = this._listeners || {};
-		this._emitting = true;
 
-		if (this._listeners[event] && this._listeners[event][id]) {
+		let returnFlag: EventReturnFlag = EventReturnFlag.none;
+		this._eventsEmitting = true;
+
+		if (this._eventListeners[eventName] && this._eventListeners[eventName][id]) {
 			// Handle global emit
-			const arr = this._listeners[event][id];
-			const arrCount = arr.length;
+			const arr = this._eventListeners[eventName][id];
 
-			for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
-				// Check we have a function to execute
-				const tmpFunc = arr[arrIndex];
+			const promiseArr = arr.map((tmpFunc) => {
+				if (typeof tmpFunc !== "function") return;
+				return tmpFunc(...data);
+			});
 
-				if (typeof tmpFunc === "function") {
-					tmpFunc.call(this, ...data);
-				}
+			const result = (await Promise.all(promiseArr)).find((tmpResult) => tmpResult !== EventReturnFlag.none);
+
+			if (result) {
+				returnFlag = EventReturnFlag.cancel;
 			}
 		}
 
-		this._emitting = false;
+		this._eventsEmitting = false;
 		this._processRemovalQueue();
 
-		return this;
+		return returnFlag;
 	}
 
-	emitId (event: string|symbol, id: string|symbol, ...data: any[]) {
-		this._listeners = this._listeners || {};
-		this._emitting = true;
+	emitId (eventName: string, id: string, ...data: any[]): EventReturnFlag {
+		if (!this._eventListeners) {
+			return EventReturnFlag.none;
+		}
+
+		this._eventListeners = this._eventListeners || {};
+		this._eventsEmitting = true;
 
-		if (!this._listeners || !this._listeners[event]) {
-			this._emitting = false;
+		if (!this._eventListeners[eventName]) {
+			this._eventsEmitting = false;
 			this._processRemovalQueue();
 
-			return this;
+			return EventReturnFlag.none;
 		}
 
 		// Handle id emit
-		if (this._listeners[event][id]) {
-			const arr = this._listeners[event][id];
+		if (this._eventListeners[eventName][id]) {
+			const arr = this._eventListeners[eventName][id];
 			const arrCount = arr.length;
 
 			for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
@@ -387,8 +402,8 @@ export class Emitter {
 		}
 
 		// Handle global emit
-		if (this._listeners[event]["*"]) {
-			const arr = this._listeners[event]["*"];
+		if (this._eventListeners[eventName]["*"]) {
+			const arr = this._eventListeners[eventName]["*"];
 			const arrCount = arr.length;
 
 			for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
@@ -401,86 +416,144 @@ export class Emitter {
 			}
 		}
 
-		this._emitting = false;
+		this._eventsEmitting = false;
 		this._processRemovalQueue();
 
-		return this;
+		return EventReturnFlag.none;
 	}
 
 	/**
-	 * Creates a static event emitter that is emitted whenever an
-	 * event listener is created with the same name.
-	 * @param {String} event The name of the event to emit.
-	 * @param {*} data The data to emit with the event.
+	 * Creates a persistent emitter record that will fire a listener if
+	 * one is added for this event after the emitStatic() call has been
+	 * made.
+	 * @param {String} eventName The name of the event to emit.
+	 * @param {...any} data Optional arguments to emit with the event.
 	 * @returns {Emitter} The emitter instance.
+	 * @private
 	 */
-	emitStatic (event: string|symbol, ...data: any[]) {
-		this._emitters = this._emitters || {};
-		this._emitters[event] = this._emitters[event] || [];
-		this._emitters[event].push({
+	emitStatic (eventName: string, ...data: any[]) {
+		const id = "*";
+		this._eventListeners = this._eventListeners || {};
+		this._eventsEmitting = true;
+
+		if (this._eventListeners[eventName] && this._eventListeners[eventName][id]) {
+			// Handle global emit
+			const arr = this._eventListeners[eventName][id];
+			const arrCount = arr.length;
+
+			for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+				// Check we have a function to execute
+				const tmpFunc = arr[arrIndex];
+
+				if (typeof tmpFunc === "function") {
+					tmpFunc.call(this, ...data);
+				}
+			}
+		}
+
+		this._eventsEmitting = false;
+
+		this._eventStaticEmitters = this._eventStaticEmitters || {};
+		this._eventStaticEmitters[eventName] = this._eventStaticEmitters[eventName] || [];
+		this._eventStaticEmitters[eventName].push({
 			"id": "*",
 			"args": data
 		});
 
-		this.emit(event, ...data);
-
 		this._processRemovalQueue();
 
 		return this;
 	}
 
 	/**
-	 * Creates a static event emitter that is emitted whenever an
-	 * event listener is created with the same name and id.
-	 * @param {String} event The name of the event to emit.
+	 * Creates a persistent emitter record that will fire a listener if
+	 * one is added for this event after the emitStatic() call has been
+	 * made.
+	 * @param {String} eventName The name of the event to emit.
 	 * @param {String} id The id of the event to emit.
-	 * @param {*} data The data to emit with the event.
+	 * @param {...any} data Optional arguments to emit with the event.
 	 * @returns {Emitter} The emitter instance.
+	 * @private
 	 */
-	emitStaticId (event: string|symbol, id: string|symbol, ...data: any[]) {
-		if (!id) throw new Error("Missing id from emitStaticId call!");
+	emitStaticId (eventName: string, id: string, ...data: any[]) {
+		if (!id) throw new Error("Missing id from emitId call!");
+
+		this._eventListeners = this._eventListeners || {};
+		this._eventsEmitting = true;
+
+		if (this._eventListeners[eventName]) {
+			// Handle id emit
+			if (this._eventListeners[eventName][id]) {
+				const arr = this._eventListeners[eventName][id];
+				const arrCount = arr.length;
 
-		this._emitters = this._emitters || {};
-		this._emitters[event] = this._emitters[event] || [];
-		this._emitters[event].push({
+				for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+					// Check we have a function to execute
+					const tmpFunc = arr[arrIndex];
+
+					if (typeof tmpFunc === "function") {
+						tmpFunc.call(this, ...data);
+					}
+				}
+			}
+
+			// Handle global emit
+			if (this._eventListeners[eventName]["*"]) {
+				const arr = this._eventListeners[eventName]["*"];
+				const arrCount = arr.length;
+
+				for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
+					// Check we have a function to execute
+					const tmpFunc = arr[arrIndex];
+
+					if (typeof tmpFunc === "function") {
+						tmpFunc.call(this, ...data);
+					}
+				}
+			}
+		}
+
+		this._eventsEmitting = false;
+
+		this._eventStaticEmitters = this._eventStaticEmitters || {};
+		this._eventStaticEmitters[eventName] = this._eventStaticEmitters[eventName] || [];
+		this._eventStaticEmitters[eventName].push({
 			id,
 			"args": data
 		});
 
-		this.emitId(event, id, ...data);
+		this._processRemovalQueue();
 
 		return this;
 	}
 
 	/**
 	 * Handles removing emitters, is an internal method not called directly.
-	 * @param {String} event The event to remove static emitter for.
+	 * @param {String} eventName The event to remove static emitter for.
 	 * @returns {Emitter} The emitter instance.
 	 * @private
 	 */
-	cancelStatic (event: string|symbol) {
-		this._emitters = this._emitters || {};
-		this._emitters[event] = [];
+	cancelStatic (eventName: string) {
+		this._eventStaticEmitters = this._eventStaticEmitters || {};
+		this._eventStaticEmitters[eventName] = [];
 
 		return this;
 	}
 
 	/**
 	 * Checks if an event has any event listeners or not.
-	 * @memberOf Emitter
-	 * @method willEmit
-	 * @param {String} event The name of the event to check for.
+	 * @param {String} eventName The name of the event to check for.
 	 * @returns {boolean} True if one or more event listeners are registered for
 	 * the event. False if none are found.
 	 */
-	willEmit (event: string|symbol) {
+	willEmit (eventName: string) {
 		const id = "*";
 
-		if (!this._listeners || !this._listeners[event]) {
+		if (!this._eventListeners || !this._eventListeners[eventName]) {
 			return false;
 		}
 
-		const arr = this._listeners[event][id];
+		const arr = this._eventListeners[eventName][id];
 		const arrCount = arr.length;
 
 		for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
@@ -497,21 +570,19 @@ export class Emitter {
 
 	/**
 	 * Checks if an event has any event listeners or not based on the passed id.
-	 * @memberOf Emitter
-	 * @method willEmitId
-	 * @param {String} event The name of the event to check for.
+	 * @param {String} eventName The name of the event to check for.
 	 * @param {String} id The event ID to check for.
 	 * @returns {boolean} True if one or more event listeners are registered for
 	 * the event. False if none are found.
 	 */
-	willEmitId (event: string|symbol, id: string|symbol) {
-		if (!this._listeners || !this._listeners[event]) {
+	willEmitId (eventName: string, id: string) {
+		if (!this._eventListeners || !this._eventListeners[eventName]) {
 			return false;
 		}
 
 		// Handle id emit
-		if (this._listeners[event][id]) {
-			const arr = this._listeners[event][id];
+		if (this._eventListeners[eventName][id]) {
+			const arr = this._eventListeners[eventName][id];
 			const arrCount = arr.length;
 
 			for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
@@ -525,8 +596,8 @@ export class Emitter {
 		}
 
 		// Handle global emit
-		if (this._listeners[event]["*"]) {
-			const arr = this._listeners[event]["*"];
+		if (this._eventListeners[eventName]["*"]) {
+			const arr = this._eventListeners[eventName]["*"];
 			const arrCount = arr.length;
 
 			for (let arrIndex = 0; arrIndex < arrCount; arrIndex++) {
@@ -546,32 +617,29 @@ export class Emitter {
 	 * Queues an event to be fired. This has automatic de-bouncing so that any
 	 * events of the same type that occur within 100 milliseconds of a previous
 	 * one will all be wrapped into a single emit rather than emitting tons of
-	 * events for the same eventName. Only the data from the last de-bounced event
-	 * will be emitted.
-	 * @memberOf Emitter
-	 * @method deferEmit
+	 * events for lots of chained inserts etc. Only the data from the last
+	 * de-bounced event will be emitted.
 	 * @param {String} eventName The name of the event to emit.
-	 * @param {*=} data Optional data to emit with the event.
+	 * @param {...any} data Optional arguments to emit with the event.
 	 * @returns {Emitter} The emitter instance.
 	 */
-	deferEmit (eventName: string|symbol, ...data: any[]) {
-		if (this._noEmitDefer) {
-			this.emit(eventName, ...data);
-			return this;
-		}
+	deferEmit (eventName: string, ...data: any[]) {
+		if (!this._eventsAllowDefer) {
+			// Check for an existing timeout
+			this._eventsDeferTimeouts = this._eventsDeferTimeouts || {};
 
-		// Check for an existing timeout
-		this._deferTimeout = this._deferTimeout || {};
+			if (this._eventsDeferTimeouts[eventName]) {
+				clearTimeout(this._eventsDeferTimeouts[eventName]);
+			}
 
-		if (this._deferTimeout[eventName]) {
-			clearTimeout(this._deferTimeout[eventName]);
+			// Set a timeout
+			this._eventsDeferTimeouts[eventName] = setTimeout(() => {
+				this.emit.call(this, eventName, ...data);
+			}, 1) as unknown as number;
+		} else {
+			this.emit.call(this, eventName, ...data);
 		}
 
-		// Set a timeout
-		this._deferTimeout[eventName] = setTimeout(() => {
-			this.emit(eventName, ...data);
-		}, 100);
-
 		return this;
 	}
 
@@ -583,7 +651,6 @@ export class Emitter {
 	 * the emitter is running through them. This method is called after the
 	 * event emitter is finished processing.
 	 * @private
-	 * @returns {undefined}
 	 */
 	_processRemovalQueue () {
 		if (!this._eventRemovalQueue || !this._eventRemovalQueue.length) {
@@ -600,26 +667,10 @@ export class Emitter {
 	}
 }
 
-/**
- * Makes the passed class or object into an emitter by modifying either the
- * prototype or the actual object to include event emitter methods.
- * @param obj The object / function / class to add event methods to.
- * If none is provided a new object will be created. This allows you to use
- * new Emitter() to generate an event emitter that is not tied to any other
- * object or class.
- * @param prototypeMode Defaults to true. Set to true to add emitter
- * methods to the the passed object"s prototype property e.g. obj.prototype.on
- * = emitter.on. Set to false to add emitter methods the object directly e.g.
- * obj.on = emitter.on.
- * @returns {Object} The newly augmented object.
- */
-type MakeEmitter = {
-	(obj: Record<string, unknown>|boolean|undefined, prototypeMode: boolean): any,
-	(obj: boolean): any,
-	(obj: undefined): any
-}
-
-export const makeEmitter: MakeEmitter = (obj: Record<string, unknown>|boolean|undefined, prototypeMode = false) => {
+export function makeEmitter(obj: new (...args: any[]) => any, prototypeMode: boolean): Emitter;
+export function makeEmitter(obj: boolean): Emitter;
+export function makeEmitter(obj: Record<string, unknown>, prototypeMode: boolean): Emitter;
+export function makeEmitter (obj: any, prototypeMode?: any) {
 	let operateOnObject;
 
 	if (obj === undefined && prototypeMode === undefined) {
@@ -633,27 +684,26 @@ export const makeEmitter: MakeEmitter = (obj: Record<string, unknown>|boolean|un
 	}
 
 	if (prototypeMode === undefined) {
-		prototypeMode = false;
+		prototypeMode = true;
 	}
 
 	if (typeof obj !== "object" && typeof obj !== "function") {
-		throw new Error("Cannot operate on passed value, it is not an object, function or class!");
+		throw new Error("Cannot operate on a non-object / non-function passed as first argument!");
 	}
 
 	if (prototypeMode) {
 		if (obj.prototype === undefined) {
-			throw new Error("Cannot modify prototype of passed object, it has no prototype property!");
+			throw new Error("Cannot modify prototype of passed object, it has no prototype property! Was it instantiated with the new operator correctly?");
 		}
 
-		operateOnObject = obj.prototype as Record<string, unknown>;
+		operateOnObject = obj.prototype;
 	} else {
 		operateOnObject = obj;
 	}
 
-	// Convert the object to have eventing capability
+	// Convert the object prototype to have eventing capability
 	operateOnObject.on = Emitter.prototype.on;
 	operateOnObject.off = Emitter.prototype.off;
-	operateOnObject.one = Emitter.prototype.one;
 	operateOnObject.once = Emitter.prototype.once;
 	operateOnObject.emit = Emitter.prototype.emit;
 	operateOnObject.emitId = Emitter.prototype.emitId;
@@ -664,9 +714,6 @@ export const makeEmitter: MakeEmitter = (obj: Record<string, unknown>|boolean|un
 	operateOnObject.willEmit = Emitter.prototype.willEmit;
 	operateOnObject.willEmitId = Emitter.prototype.willEmitId;
 	operateOnObject._processRemovalQueue = Emitter.prototype._processRemovalQueue;
-	operateOnObject._on = Emitter.prototype._on;
-	operateOnObject._off = Emitter.prototype._off;
-	operateOnObject._once = Emitter.prototype._once;
 
 	return obj;
-};
+}