@irrelon/emitter 6.0.1 → 6.1.0

package/src/Emitter.ts

@@ -107,51 +107,57 @@ export type AnyFunction<ReturnType = any> = (...args: any[]) => ReturnType;
 export type AnyConstructor = new (...args: any[]) => any;
 
 export enum ListenerReturnFlag {
-	none = "!+_NONE",
-	cancel = "!+_CANCEL"
+    none = "!+_NONE",
+    cancel = "!+_CANCEL"
 }
 
 export type EventListenerCallback<EventCallbackFunctionSignature extends AnyFunction = AnyFunction> = (
-	...args: Parameters<EventCallbackFunctionSignature>
+    ...args: Parameters<EventCallbackFunctionSignature>
 ) => ReturnType<EventCallbackFunctionSignature>;
 
 export interface EventStaticEmitterObject<EventCallbackFunctionSignature extends AnyFunction = AnyFunction> {
-	id: string;
-	args: Parameters<EventCallbackFunctionSignature>;
+    id: string;
+    args: Parameters<EventCallbackFunctionSignature>;
 }
 
 export interface EmitterAnyEventsInterface {
-	[key: string]: AnyFunction;
+    [key: string]: AnyFunction;
 }
 
 export type EmitterEventsInterface<T> = {
-	[K in keyof T]: T[K];
+    [K in keyof T]: T[K];
 };
 
+interface WithStar {
+    "*"?: (eventName: string, ...args: any[]) => void;
+}
+
+export type EmitterEventsWithStar<T> = EmitterEventsInterface<T> & WithStar;
+
 /**
  * Creates a new class with the capability to emit events.
  */
-export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterface> = EmitterAnyEventsInterface> {
+export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterface> = EmitterAnyEventsInterface> {
 	_eventsEmitting: boolean = false;
 	_eventRemovalQueue: any[] = [];
 	_eventListeners?: {
-		[EventName in keyof EventsInterface]?: Record<string, EventListenerCallback<EventsInterface[EventName]>[]>;
-	} = {};
+        [EventName in keyof EventsInterface]?: Record<string, EventListenerCallback<EventsInterface[EventName]>[]>;
+    } = {};
 	_eventStaticEmitters: {
-		[EventName in keyof EventsInterface]?: EventStaticEmitterObject<EventsInterface[EventName]>[];
-	} = {};
+        [EventName in keyof EventsInterface]?: EventStaticEmitterObject<EventsInterface[EventName]>[];
+    } = {};
 	_eventsAllowDefer: boolean = false;
 	_eventsDeferTimeouts: Record<any, number> = {};
 
 	/**
-	 * Attach an event listener to the passed event only if the passed
-	 * id matches the id for the event being fired.
-	 * @param eventName The name of the event to listen for.
-	 * @param id The id to match against.
-	 * @param listener The method to call when the event is fired.
-	 * @returns The emitter instance.
-	 */
-	_on<EventName extends keyof EventsInterface>(
+     * Attach an event listener to the passed event only if the passed
+     * id matches the id for the event being fired.
+     * @param eventName The name of the event to listen for.
+     * @param id The id to match against.
+     * @param listener The method to call when the event is fired.
+     * @returns The emitter instance.
+     */
+	_on<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		id: string,
 		listener: EventListenerCallback<EventsInterface[EventName]>
@@ -170,8 +176,8 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 		// Check for any static emitters, and fire the event if any exist
 		if (
 			!this._eventStaticEmitters ||
-			!this._eventStaticEmitters[eventName] ||
-			!this._eventStaticEmitters[eventName]!.length
+            !this._eventStaticEmitters[eventName] ||
+            !this._eventStaticEmitters[eventName]!.length
 		)
 			return this;
 
@@ -191,14 +197,14 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Attach an event listener to the passed event only if the passed
-	 * id matches the document id for the event being fired.
-	 * @param eventName The name of the event to listen for.
-	 * @param id The id to match against.
-	 * @param listener The method to call when the event is fired.
-	 * @returns The emitter instance.
-	 */
-	_once<EventName extends keyof EventsInterface>(
+     * Attach an event listener to the passed event only if the passed
+     * id matches the document id for the event being fired.
+     * @param eventName The name of the event to listen for.
+     * @param id The id to match against.
+     * @param listener The method to call when the event is fired.
+     * @returns The emitter instance.
+     */
+	_once<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		id: string,
 		listener: EventListenerCallback<EventsInterface[EventName]>
@@ -222,14 +228,14 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Cancels an event listener based on an event name, id and listener function.
-	 * @param eventName 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()
-	 * or once() call to cancel.
-	 * @returns The emitter instance.
-	 */
-	_off<EventName extends keyof EventsInterface>(
+     * Cancels an event listener based on an event name, id and listener function.
+     * @param eventName 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()
+     * or once() call to cancel.
+     * @returns The emitter instance.
+     */
+	_off<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		id: string,
 		listener?: EventListenerCallback<EventsInterface[EventName]>
@@ -275,23 +281,31 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Attach an event listener to the passed event only if the passed
-	 * id matches the document id for the event being fired.
-	 * @param eventName The name of the event to listen for.
-	 * @param id The id to match against.
-	 * @param listener The method to call when the event is fired.
-	 * @returns The emitter instance.
-	 */
-	on<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		id: string,
-		listener: EventListenerCallback<EventsInterface[EventName]>
-	): this;
+     * Creates an event listener that listens for any and all events
+     * emitted.
+     */
+	onAny (listener: EventListenerCallback) {
+		this.on("*", listener);
+	}
+
+	/**
+     * Attach an event listener to the passed event only if the passed
+     * id matches the document id for the event being fired.
+     * @param eventName The name of the event to listen for.
+     * @param id The id to match against.
+     * @param listener The method to call when the event is fired.
+     * @returns The emitter instance.
+     */
 	on<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		listener: EventListenerCallback<EventsInterface[EventName]>
-	): this;
+        eventName: EventName,
+        id: string,
+        listener: EventListenerCallback<EventsInterface[EventName]>
+    ): this;
 	on<EventName extends keyof EventsInterface>(
+        eventName: EventName,
+        listener: EventListenerCallback<EventsInterface[EventName]>
+    ): this;
+	on<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		idOrListener: string | EventListenerCallback<EventsInterface[EventName]>,
 		listener?: EventListenerCallback<EventsInterface[EventName]>
@@ -304,23 +318,23 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Attach an event listener to the passed event only if the passed
-	 * id matches the document id for the event being fired.
-	 * @param eventName The name of the event to listen for.
-	 * @param id The id to match against.
-	 * @param listener
-	 * @returns The emitter instance.
-	 */
+     * Attach an event listener to the passed event only if the passed
+     * id matches the document id for the event being fired.
+     * @param eventName The name of the event to listen for.
+     * @param id The id to match against.
+     * @param listener
+     * @returns The emitter instance.
+     */
 	once<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		id: string,
-		listener: EventListenerCallback<EventsInterface[EventName]>
-	): this;
+        eventName: EventName,
+        id: string,
+        listener: EventListenerCallback<EventsInterface[EventName]>
+    ): this;
 	once<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		listener: EventListenerCallback<EventsInterface[EventName]>
-	): this;
-	once<EventName extends keyof EventsInterface>(eventName: EventName, ...rest: any[]): this {
+        eventName: EventName,
+        listener: EventListenerCallback<EventsInterface[EventName]>
+    ): this;
+	once<EventName extends keyof EventsInterface> (eventName: EventName, ...rest: any[]): this {
 		const restTypes = rest.map((arg) => typeof arg);
 
 		if (restTypes[0] === "function") {
@@ -331,27 +345,27 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * 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 eventName The name of the event to listen for.
-	 * @param id The id to match against.
-	 * @param listener The method to call when the event is fired.
-	 * @returns The emitter instance.
-	 */
+     * 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 eventName The name of the event to listen for.
+     * @param id The id to match against.
+     * @param listener The method to call when the event is fired.
+     * @returns The emitter instance.
+     */
 	overwrite<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		id: string,
-		listener: EventListenerCallback<EventsInterface[EventName]>
-	): this;
+        eventName: EventName,
+        id: string,
+        listener: EventListenerCallback<EventsInterface[EventName]>
+    ): this;
 	overwrite<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		listener: EventListenerCallback<EventsInterface[EventName]>
-	): this;
-	overwrite<EventName extends keyof EventsInterface>(eventName: EventName, ...rest: any[]) {
+        eventName: EventName,
+        listener: EventListenerCallback<EventsInterface[EventName]>
+    ): this;
+	overwrite<EventName extends keyof EventsInterface> (eventName: EventName, ...rest: any[]) {
 		const restTypes = rest.map((arg) => typeof arg);
 
 		if (restTypes[0] === "function") {
@@ -364,24 +378,32 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Cancels an event listener based on an event name, id and listener function.
-	 * @param eventName 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()
-	 * or once() call to cancel.
-	 * @returns The emitter instance.
-	 */
+     * Removes an event listener that listens for any and all events
+     * emitted.
+     */
+	offAny (listener: EventListenerCallback) {
+		this.off("*", listener);
+	}
+
+	/**
+     * Cancels an event listener based on an event name, id and listener function.
+     * @param eventName 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()
+     * or once() call to cancel.
+     * @returns The emitter instance.
+     */
 	off<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		id: string,
-		listener?: EventListenerCallback<EventsInterface[EventName]>
-	): this;
+        eventName: EventName,
+        id: string,
+        listener?: EventListenerCallback<EventsInterface[EventName]>
+    ): this;
 	off<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		listener?: EventListenerCallback<EventsInterface[EventName]>
-	): this;
+        eventName: EventName,
+        listener?: EventListenerCallback<EventsInterface[EventName]>
+    ): this;
 	off<EventName extends keyof EventsInterface>(eventName: EventName): this;
-	off<EventName extends keyof EventsInterface>(eventName: EventName, ...rest: any[]) {
+	off<EventName extends keyof EventsInterface> (eventName: EventName, ...rest: any[]) {
 		if (rest.length === 0) {
 			// Only event was provided, use * as the id to mean "any without"
 			// a specific id
@@ -400,14 +422,14 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 		return this._off(eventName, rest[0], rest[1]);
 	}
 
-	_emitToSingleListener<EventName extends keyof EventsInterface>(
+	_emitToSingleListener<EventName extends keyof EventsInterface> (
 		listener: EventListenerCallback<EventsInterface[EventName]>,
 		data: Parameters<EventsInterface[EventName]>
 	): ReturnType<EventsInterface[EventName]> | ListenerReturnFlag {
 		return listener(...data);
 	}
 
-	_emitToArrayOfListeners<EventName extends keyof EventsInterface>(
+	_emitToArrayOfListeners<EventName extends keyof EventsInterface> (
 		arr: EventListenerCallback<EventsInterface[EventName]>[],
 		data: Parameters<EventsInterface[EventName]>
 	): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[] {
@@ -435,49 +457,49 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Call an event listener by name. The `rpc()` function differs from `emit()` in
-	 * that it will only call and return data from the first event listener for the
-	 * event rather than all event listeners. If you have more than one event listener
-	 * assigned to the event, all others except the first will be ignored and will
-	 * not receive the event.
-	 * @param eventName The name of the event to call the listener for.
-	 * @param {...any} data The arguments to send to the listening method.
-	 * 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 #Call the Event Listener
-	 *     // Emit the event named "hello"
-	 *     myEntity.emit('hello');
-	 * @example #Call the Event Listener With Data Object
-	 *     // Emit the event named "hello"
-	 *     myEntity.emit('hello', {moo: true});
-	 * @example #Call the Event Listener With Multiple Data Values
-	 *     // Emit the event named "hello"
-	 *     myEntity.emit('hello', {moo: true}, 'someString');
-	 * @example #Register the Listener 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("Arguments:", arg1, arg2);
-	 *         return "foo";
-	 *     }
-	 *
-	 *     // Emit the event named "hello"
-	 *     const result = myEntity.emit('hello', 'data1', 'data2');
-	 *	   console.log("Result:", result);
-	 *
-	 *     // The console output is:
-	 *     //   Arguments: data1 data2
-	 *     //	Result: "foo"
-	 */
-	rpc<EventName extends keyof EventsInterface>(
+     * Call an event listener by name. The `rpc()` function differs from `emit()` in
+     * that it will only call and return data from the first event listener for the
+     * event rather than all event listeners. If you have more than one event listener
+     * assigned to the event, all others except the first will be ignored and will
+     * not receive the event.
+     * @param eventName The name of the event to call the listener for.
+     * @param {...any} data The arguments to send to the listening method.
+     * 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 #Call the Event Listener
+     *     // Emit the event named "hello"
+     *     myEntity.emit('hello');
+     * @example #Call the Event Listener With Data Object
+     *     // Emit the event named "hello"
+     *     myEntity.emit('hello', {moo: true});
+     * @example #Call the Event Listener With Multiple Data Values
+     *     // Emit the event named "hello"
+     *     myEntity.emit('hello', {moo: true}, 'someString');
+     * @example #Register the Listener 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("Arguments:", arg1, arg2);
+     *         return "foo";
+     *     }
+     *
+     *     // Emit the event named "hello"
+     *     const result = myEntity.emit('hello', 'data1', 'data2');
+     *       console.log("Result:", result);
+     *
+     *     // The console output is:
+     *     //   Arguments: data1 data2
+     *     //	Result: "foo"
+     */
+	rpc<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		...data: Parameters<EventsInterface[EventName]>
 	): ReturnType<EventsInterface[EventName]> | ListenerReturnFlag {
 		return this.rpcId<EventName>(eventName, "*", ...data);
 	}
 
-	rpcId<EventName extends keyof EventsInterface>(
+	rpcId<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		id: string,
 		...data: Parameters<EventsInterface[EventName]>
@@ -494,26 +516,18 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 			const arr = this._eventListeners[eventName]![id];
 			emitterResult = this._emitToSingleListener<EventName>(arr[0], data);
 		} else if (id !== "*" && this._eventListeners[eventName]!["*"]) {
-			// Handle global emit if the id passed wasn't already a global (*) id
+			// Handle wildcard emit if the id passed wasn't already a wildcard (*) id
 			const arr = this._eventListeners[eventName]!["*"];
 			emitterResult = this._emitToSingleListener<EventName>(arr[0], data);
 		} else {
 			if (id === "*") {
 				throw new Error(
-					`Cannot make an rpc call to event "${
-						eventName as string
-					}" without at least one event listener and none were found, register a listener via on("${
-						eventName as string
-					}", () => { ...some listener code })`
+					`Cannot make an rpc call to event "${eventName as string}" without at least one event listener and none were found, register a listener via on("${eventName as string}", () => { ...some listener code })`
 				);
 			}
 
 			throw new Error(
-				`Cannot make an rpc call to event "${
-					eventName as string
-				}" and id "${id}" without at least one event listener and none were found, register a listener via on("${
-					eventName as string
-				}", "${id}", () => { ...some listener code })`
+				`Cannot make an rpc call to event "${eventName as string}" and id "${id}" without at least one event listener and none were found, register a listener via on("${eventName as string}", "${id}", () => { ...some listener code })`
 			);
 		}
 
@@ -524,68 +538,80 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Emit an event by name.
-	 * @param 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("Arguments:", arg1, arg2);
-	 *         return "foo";
-	 *     }
-	 *
-	 *     // Emit the event named "hello"
-	 *     // The result is returned as an array of all return values
-	 *     // from all the listeners for the event
-	 *     const result = myEntity.emit('hello', 'data1', 'data2');
-	 * 	   console.log("Result:", result);
-	 *
-	 *     // The console output is:
-	 *     //   Arguments: data1 data2
-	 *     //	Result: ["foo"]
-	 */
-	emit<EventName extends keyof EventsInterface>(
+     * Emit an event by name.
+     * @param 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("Arguments:", arg1, arg2);
+     *         return "foo";
+     *     }
+     *
+     *     // Emit the event named "hello"
+     *     // The result is returned as an array of all return values
+     *     // from all the listeners for the event
+     *     const result = myEntity.emit('hello', 'data1', 'data2');
+     *       console.log("Result:", result);
+     *
+     *     // The console output is:
+     *     //   Arguments: data1 data2
+     *     //	Result: ["foo"]
+     */
+	emit<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		...data: Parameters<EventsInterface[EventName]>
 	): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[] {
 		return this.emitId<EventName>(eventName, "*", ...data);
 	}
 
-	emitId<EventName extends keyof EventsInterface>(
+	emitId<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		id: string,
 		...data: Parameters<EventsInterface[EventName]>
 	): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[] {
-		if (!this._eventListeners || !this._eventListeners[eventName]) {
+		if (!this._eventListeners || (!this._eventListeners[eventName] && !this._eventListeners["*"])) {
 			return [];
 		}
 
 		let emitterResult: (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[] = [];
 		this._eventsEmitting = true;
 
-		// Handle id emit
-		if (this._eventListeners[eventName]![id]) {
-			const arr = this._eventListeners[eventName]![id];
-			emitterResult = emitterResult.concat(this._emitToArrayOfListeners<EventName>(arr, data));
+		if (this._eventListeners[eventName]) {
+			// Handle id emit
+			if (this._eventListeners[eventName]![id]) {
+				const arr = this._eventListeners[eventName]![id];
+				emitterResult = emitterResult.concat(this._emitToArrayOfListeners<EventName>(arr, data));
+			}
+
+			// Handle id wildcard emit if the id passed wasn't already a wildcard (*) id
+			if (id !== "*" && this._eventListeners[eventName]!["*"]) {
+				const arr = this._eventListeners[eventName]!["*"];
+				emitterResult = emitterResult.concat(this._emitToArrayOfListeners<EventName>(arr, data));
+			}
 		}
 
-		// Handle global emit if the id passed wasn't already a global (*) id
-		if (id !== "*" && this._eventListeners[eventName]!["*"]) {
-			const arr = this._eventListeners[eventName]!["*"];
-			emitterResult = emitterResult.concat(this._emitToArrayOfListeners<EventName>(arr, data));
+		if (this._eventListeners["*"]) {
+			const arr = this._eventListeners["*"]!["*"];
+			emitterResult = emitterResult.concat(
+				this._emitToArrayOfListeners<EventName>(
+                    arr as EventListenerCallback<EventsInterface[EventName]>[],
+                    [eventName, ...data] as Parameters<EventsInterface[EventName]>
+				)
+			);
 		}
 
 		this._eventsEmitting = false;
@@ -595,15 +621,15 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * 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 eventName The name of the event to emit.
-	 * @param {...any} data Optional arguments to emit with the event.
-	 * @returns The emitter instance.
-	 * @private
-	 */
-	emitStatic<EventName extends keyof EventsInterface>(
+     * 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 eventName The name of the event to emit.
+     * @param {...any} data Optional arguments to emit with the event.
+     * @returns The emitter instance.
+     * @private
+     */
+	emitStatic<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		...data: Parameters<EventsInterface[EventName]>
 	) {
@@ -612,7 +638,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 		this._eventsEmitting = true;
 
 		if (this._eventListeners[eventName] && this._eventListeners[eventName]![id]) {
-			// Handle global emit
+			// Handle id wildcard emit
 			const arr = this._eventListeners[eventName]![id];
 			const arrCount = arr.length;
 
@@ -630,27 +656,27 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 
 		this._eventStaticEmitters = this._eventStaticEmitters || {};
 		this._eventStaticEmitters[eventName] = this._eventStaticEmitters[eventName] || [];
-		this._eventStaticEmitters[eventName]!.push({
-			id: "*",
-			args: data
-		});
+        this._eventStaticEmitters[eventName]!.push({
+        	id: "*",
+        	args: data
+        });
 
-		this._processRemovalQueue();
+        this._processRemovalQueue();
 
-		return this;
+        return this;
 	}
 
 	/**
-	 * 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 eventName The name of the event to emit.
-	 * @param id The id of the event to emit.
-	 * @param {...any} data Optional arguments to emit with the event.
-	 * @returns The emitter instance.
-	 * @private
-	 */
-	emitStaticId<EventName extends keyof EventsInterface>(
+     * 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 eventName The name of the event to emit.
+     * @param id The id of the event to emit.
+     * @param {...any} data Optional arguments to emit with the event.
+     * @returns The emitter instance.
+     * @private
+     */
+	emitStaticId<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		id: string,
 		...data: Parameters<EventsInterface[EventName]>
@@ -676,7 +702,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 				}
 			}
 
-			// Handle global emit
+			// Handle wildcard emit
 			if (this._eventListeners[eventName]!["*"]) {
 				const arr = this._eventListeners[eventName]!["*"];
 				const arrCount = arr.length;
@@ -696,23 +722,23 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 
 		this._eventStaticEmitters = this._eventStaticEmitters || {};
 		this._eventStaticEmitters[eventName] = this._eventStaticEmitters[eventName] || [];
-		this._eventStaticEmitters[eventName]!.push({
-			id,
-			args: data
-		});
+        this._eventStaticEmitters[eventName]!.push({
+        	id,
+        	args: data
+        });
 
-		this._processRemovalQueue();
+        this._processRemovalQueue();
 
-		return this;
+        return this;
 	}
 
 	/**
-	 * Handles removing emitters, is an internal method not called directly.
-	 * @param eventName The event to remove static emitter for.
-	 * @returns The emitter instance.
-	 * @private
-	 */
-	cancelStatic<EventName extends keyof EventsInterface>(eventName: EventName) {
+     * Handles removing emitters, is an internal method not called directly.
+     * @param eventName The event to remove static emitter for.
+     * @returns The emitter instance.
+     * @private
+     */
+	cancelStatic<EventName extends keyof EventsInterface> (eventName: EventName) {
 		this._eventStaticEmitters = this._eventStaticEmitters || {};
 		this._eventStaticEmitters[eventName] = [];
 
@@ -720,12 +746,12 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Checks if an event has any event listeners or not.
-	 * @param eventName The name of the event to check for.
-	 * @returns True if one or more event listeners are registered for
-	 * the event. False if none are found.
-	 */
-	willEmit<EventName extends keyof EventsInterface>(eventName: EventName) {
+     * Checks if an event has any event listeners or not.
+     * @param eventName The name of the event to check for.
+     * @returns True if one or more event listeners are registered for
+     * the event. False if none are found.
+     */
+	willEmit<EventName extends keyof EventsInterface> (eventName: EventName) {
 		const id = "*";
 
 		if (!this._eventListeners || !this._eventListeners[eventName]) {
@@ -748,13 +774,13 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Checks if an event has any event listeners or not based on the passed id.
-	 * @param eventName The name of the event to check for.
-	 * @param id The event ID to check for.
-	 * @returns True if one or more event listeners are registered for
-	 * the event. False if none are found.
-	 */
-	willEmitId<EventName extends keyof EventsInterface>(eventName: EventName, id: string) {
+     * Checks if an event has any event listeners or not based on the passed id.
+     * @param eventName The name of the event to check for.
+     * @param id The event ID to check for.
+     * @returns True if one or more event listeners are registered for
+     * the event. False if none are found.
+     */
+	willEmitId<EventName extends keyof EventsInterface> (eventName: EventName, id: string) {
 		if (!this._eventListeners || !this._eventListeners[eventName]) {
 			return false;
 		}
@@ -774,7 +800,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 			}
 		}
 
-		// Handle global emit
+		// Handle wildcard emit
 		if (this._eventListeners[eventName]!["*"]) {
 			const arr = this._eventListeners[eventName]!["*"];
 			const arrCount = arr.length;
@@ -793,16 +819,16 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * 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 lots of chained inserts etc. Only the data from the last
-	 * de-bounced event will be emitted.
-	 * @param eventName The name of the event to emit.
-	 * @param {...any} data Optional arguments to emit with the event.
-	 * @returns The emitter instance.
-	 */
-	deferEmit<EventName extends keyof EventsInterface>(
+     * 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 lots of chained inserts etc. Only the data from the last
+     * de-bounced event will be emitted.
+     * @param eventName The name of the event to emit.
+     * @param {...any} data Optional arguments to emit with the event.
+     * @returns The emitter instance.
+     */
+	deferEmit<EventName extends keyof EventsInterface> (
 		eventName: EventName,
 		...data: Parameters<EventsInterface[EventName]>
 	) {
@@ -826,24 +852,24 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	}
 
 	/**
-	 * Returns true if the result from an emit() call passed as the first
-	 * argument contains a cancellation flag.
-	 * @param resultArr
-	 */
-	didCancel(resultArr: (unknown | ListenerReturnFlag)[]) {
+     * Returns true if the result from an emit() call passed as the first
+     * argument contains a cancellation flag.
+     * @param resultArr
+     */
+	didCancel (resultArr: (unknown | ListenerReturnFlag)[]) {
 		return resultArr.findIndex((result) => result === ListenerReturnFlag.cancel) > -1;
 	}
 
 	/**
-	 * If events are cleared with the off() method while the event emitter is
-	 * actively processing any events then the off() calls get added to a
-	 * queue to be executed after the event emitter is finished. This stops
-	 * errors that might occur by potentially mutating the event listener array
-	 * while the emitter is running through them. This method is called after
-	 * the event emitter is finished processing.
-	 * @private
-	 */
-	_processRemovalQueue() {
+     * If events are cleared with the off() method while the event emitter is
+     * actively processing any events then the off() calls get added to a
+     * queue to be executed after the event emitter is finished. This stops
+     * errors that might occur by potentially mutating the event listener array
+     * while the emitter is running through them. This method is called after
+     * the event emitter is finished processing.
+     * @private
+     */
+	_processRemovalQueue () {
 		if (!this._eventRemovalQueue || !this._eventRemovalQueue.length) {
 			return;
 		}
@@ -861,7 +887,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 export function makeEmitter(obj: AnyConstructor, 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) {
+export function makeEmitter (obj: any, prototypeMode?: any) {
 	let operateOnObject;
 
 	if (obj === undefined && prototypeMode === undefined) {
@@ -896,7 +922,9 @@ export function makeEmitter(obj: any, prototypeMode?: any) {
 
 	// Convert the object prototype to have eventing capability
 	operateOnObject.on = Emitter.prototype.on;
+	operateOnObject.onAny = Emitter.prototype.onAny;
 	operateOnObject.off = Emitter.prototype.off;
+	operateOnObject.offAny = Emitter.prototype.offAny;
 	operateOnObject.once = Emitter.prototype.once;
 	operateOnObject.emit = Emitter.prototype.emit;
 	operateOnObject.emitId = Emitter.prototype.emitId;