@irrelon/emitter 6.0.1 → 6.2.0

package/src/Emitter.ts

@@ -25,9 +25,31 @@
  Source: https://github.com/irrelon/emitter
 
  Changelog:
- 	Version 6.0.0: Updated to allow event listeners to return data to
- 		the caller of the emit() function, e.g.
- 			`const results = emitter.emit("myEventName");`
+ 	Version 6.2.0:
+ 		Added ability to emit events via both our emitter and via
+ 		`window.dispatchEvent()` so that applications that don't have
+ 		access to an event emitter instance can still listen for events
+ 		when emitted by our emitter. This option can be switched on or
+ 		off via the `dispatchWindowEventsEnabled()` function. The default
+ 		is `false` (off).
+
+ 		Added the ability to set a prefix to events which are emitted
+ 		via the window.dispatchEvent() method. For example, if you set
+ 		the prefix to "myCompany.myApp.myEmitterName" then emit an event
+ 		via emit() called "myEvent", the dispatched event name on the
+ 		window object will be "myCompany.myApp.myEmitterName.myEvent".
+ 		Event names using standard Emitter functions are unaffected.
+ 		For instance, you would still listen for `myEvent` via
+ 		`emitter.on("myEvent", ...)` and emit it via
+ 		`emitter.emit("myEvent", ...)`.
+ 	Version 6.1.0:
+ 		Added `onAny()` and `offAny()` methods which are analogous to
+ 		`on("*")` and `off("*")`.
+ 	Version 6.0.0:
+ 		Updated to allow event listeners to return data to the caller of
+ 		the emit() function, e.g.
+
+ 		`const results = emitter.emit("myEventName");`
 
  		The results are an array of all return values from any listener
  		functions that were called by the event "myEventName". This is
@@ -37,9 +59,10 @@
  		Listeners that return `ListenerReturnFlag.cancel` will cancel
  		the event call to any further listeners for that one event
  		emit.
- 	Version 5.0.3 and 5.0.4: Updated to allow specifying an events type
- 		to the Emitter to allow complete type safety when registering
- 		listeners and emitting events.
+ 	Version 5.0.3 and 5.0.4:
+ 		Updated to allow specifying an events type to the Emitter to
+ 		allow complete type safety when registering listeners and emitting
+ 		events.
 
  		Updated the build and package to split between delivery of CJS
  		and ESM module types so that this package can be eiter imported
@@ -99,7 +122,7 @@
  	Version 1.0.1:
  		Added ability to extend any object with eventing capability
  		Added AMD / Require.js support
-		 Added Node.js support
+		Added Node.js support
 	Version 1.0.0:
 		First commit
  */
@@ -111,9 +134,7 @@ export enum ListenerReturnFlag {
 	cancel = "!+_CANCEL"
 }
 
-export type EventListenerCallback<EventCallbackFunctionSignature extends AnyFunction = AnyFunction> = (
-	...args: Parameters<EventCallbackFunctionSignature>
-) => ReturnType<EventCallbackFunctionSignature>;
+export type EventListenerCallback<EventCallbackFunctionSignature extends AnyFunction = AnyFunction> = (...args: Parameters<EventCallbackFunctionSignature>) => ReturnType<EventCallbackFunctionSignature>;
 
 export interface EventStaticEmitterObject<EventCallbackFunctionSignature extends AnyFunction = AnyFunction> {
 	id: string;
@@ -128,10 +149,16 @@ export type EmitterEventsInterface<T> = {
 	[K in keyof T]: T[K];
 };
 
+export interface WithStar {
+	"*"?: (eventName: string, ...args: any[]) => void;
+}
+
+export type EmitterEventsWithStar<T> = EmitterEventsInterface<T> & WithStar;
+
 /**
- * Creates a new class with the capability to emit events.
+ * Creates a new class with the ability 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?: {
@@ -142,6 +169,17 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	} = {};
 	_eventsAllowDefer: boolean = false;
 	_eventsDeferTimeouts: Record<any, number> = {};
+	_dispatchWindowEventsEnabled: boolean = false;
+	_dispatchPrefix?: string;
+
+	constructor (dispatchPrefix?: string, shouldDispatchWindowEvents: boolean = false) {
+		this._dispatchPrefix = dispatchPrefix;
+		this._dispatchWindowEventsEnabled = shouldDispatchWindowEvents;
+	}
+
+	dispatchWindowEventsEnabled (shouldDispatchWindowEvents: boolean) {
+		this._dispatchWindowEventsEnabled = shouldDispatchWindowEvents;
+	}
 
 	/**
 	 * Attach an event listener to the passed event only if the passed
@@ -151,11 +189,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @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]>
-	) {
+	_on<EventName extends keyof EventsInterface> (eventName: EventName, id: string, listener: EventListenerCallback<EventsInterface[EventName]>) {
 		const generateTimeout = (emitter: EventStaticEmitterObject<EventsInterface[EventName]>) => {
 			setTimeout(() => {
 				listener(...emitter.args);
@@ -168,12 +202,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 		nonNullableEventListeners[id].push(listener);
 
 		// Check for any static emitters, and fire the event if any exist
-		if (
-			!this._eventStaticEmitters ||
-			!this._eventStaticEmitters[eventName] ||
-			!this._eventStaticEmitters[eventName]!.length
-		)
-			return this;
+		if (!this._eventStaticEmitters || !this._eventStaticEmitters[eventName] || !this._eventStaticEmitters[eventName]!.length) return this;
 
 		// Emit events for each emitter
 		for (let i = 0; i < this._eventStaticEmitters[eventName]!.length; i++) {
@@ -198,17 +227,11 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @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]>
-	) {
+	_once<EventName extends keyof EventsInterface> (eventName: EventName, id: string, listener: EventListenerCallback<EventsInterface[EventName]>) {
 		let fired = false;
 		let originalReturnData: ReturnType<EventsInterface[EventName]>;
 
-		const internalCallback: EventListenerCallback<EventsInterface[EventName]> = (
-			...args: Parameters<EventsInterface[EventName]>
-		): ReturnType<EventsInterface[EventName]> => {
+		const internalCallback: EventListenerCallback<EventsInterface[EventName]> = (...args: Parameters<EventsInterface[EventName]>): ReturnType<EventsInterface[EventName]> => {
 			if (fired) return originalReturnData;
 
 			fired = true;
@@ -229,14 +252,9 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * or once() call to cancel.
 	 * @returns The emitter instance.
 	 */
-	_off<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		id: string,
-		listener?: EventListenerCallback<EventsInterface[EventName]>
-	): this {
+	_off<EventName extends keyof EventsInterface> (eventName: EventName, id: string, listener?: EventListenerCallback<EventsInterface[EventName]>): 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 (!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
@@ -274,6 +292,14 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 		return 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.
@@ -282,20 +308,9 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @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;
-	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]>
-	): this {
+	on<EventName extends keyof EventsInterface> (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]>): this {
 		if (typeof idOrListener === "string") {
 			return this._on(eventName, idOrListener, listener as EventListenerCallback<EventsInterface[EventName]>);
 		}
@@ -311,16 +326,9 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @param listener
 	 * @returns The emitter instance.
 	 */
-	once<EventName extends keyof EventsInterface>(
-		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 {
+	once<EventName extends keyof EventsInterface> (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 {
 		const restTypes = rest.map((arg) => typeof arg);
 
 		if (restTypes[0] === "function") {
@@ -342,16 +350,9 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @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;
-	overwrite<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		listener: EventListenerCallback<EventsInterface[EventName]>
-	): this;
-	overwrite<EventName extends keyof EventsInterface>(eventName: EventName, ...rest: any[]) {
+	overwrite<EventName extends keyof EventsInterface> (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[]) {
 		const restTypes = rest.map((arg) => typeof arg);
 
 		if (restTypes[0] === "function") {
@@ -363,6 +364,14 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 		return this._on(eventName, rest[0], rest[1]);
 	}
 
+	/**
+	 * 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.
@@ -371,17 +380,10 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * or once() call to cancel.
 	 * @returns The emitter instance.
 	 */
-	off<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		id: string,
-		listener?: EventListenerCallback<EventsInterface[EventName]>
-	): this;
-	off<EventName extends keyof EventsInterface>(
-		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, id: string, listener?: EventListenerCallback<EventsInterface[EventName]>): this;
+	off<EventName extends keyof EventsInterface> (eventName: EventName, listener?: EventListenerCallback<EventsInterface[EventName]>): this;
+	off<EventName extends keyof EventsInterface> (eventName: EventName): this;
+	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 +402,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)[] {
@@ -434,6 +436,23 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 		return resultArr;
 	}
 
+	/**
+	 * Dispatches an event originating in our emitter to the browser's
+	 * window object.
+	 * @param eventName The name of the event to emit. This gets prefixed with the
+	 * dispatch prefix if one is set.
+	 * @param data
+	 */
+	_emitToWindowDispatch<EventName extends keyof EventsInterface> (eventName: EventName, data: any) {
+		if (typeof window === "undefined") return;
+		if (!this._dispatchWindowEventsEnabled) {
+			return;
+		}
+
+		const finalEventName = (this._dispatchPrefix ? `${this._dispatchPrefix}.${eventName as string}` : eventName) as string;
+		window.dispatchEvent(new CustomEvent(finalEventName, { detail: data }));
+	}
+
 	/**
 	 * 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
@@ -464,24 +483,17 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 *
 	 *     // Emit the event named "hello"
 	 *     const result = myEntity.emit('hello', 'data1', 'data2');
-	 *	   console.log("Result:", result);
+	 *       console.log("Result:", result);
 	 *
 	 *     // The console output is:
-	 *     //   Arguments: data1 data2
+	 *     //	Arguments: data1 data2
 	 *     //	Result: "foo"
 	 */
-	rpc<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		...data: Parameters<EventsInterface[EventName]>
-	): ReturnType<EventsInterface[EventName]> | ListenerReturnFlag {
+	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>(
-		eventName: EventName,
-		id: string,
-		...data: Parameters<EventsInterface[EventName]>
-	): ReturnType<EventsInterface[EventName]> | ListenerReturnFlag {
+	rpcId<EventName extends keyof EventsInterface> (eventName: EventName, id: string, ...data: Parameters<EventsInterface[EventName]>): ReturnType<EventsInterface[EventName]> | ListenerReturnFlag {
 		if (!this._eventListeners || !this._eventListeners[eventName]) {
 			throw new Error("Cannot make an rpc call without at least one event listener and none were found");
 		}
@@ -494,26 +506,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 })`
 			);
 		}
 
@@ -529,7 +533,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @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}
+	 * @return {any[]} An array of all return values from all the listeners for the event.
 	 * @example #Emit an Event
 	 *     // Emit the event named "hello"
 	 *     myEntity.emit('hello');
@@ -542,7 +546,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @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) {
+	 *	   myEntity.on('hello', function (arg1, arg2) {
 	 *         console.log("Arguments:", arg1, arg2);
 	 *         return "foo";
 	 *     }
@@ -551,41 +555,51 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 *     // 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);
+	 *       console.log("Result:", result);
 	 *
 	 *     // The console output is:
-	 *     //   Arguments: data1 data2
+	 *     //	Arguments: data1 data2
 	 *     //	Result: ["foo"]
 	 */
-	emit<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		...data: Parameters<EventsInterface[EventName]>
-	): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[] {
+	emit<EventName extends keyof EventsInterface> (eventName: EventName, ...data: Parameters<EventsInterface[EventName]>): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[] {
+		this._emitToWindowDispatch(eventName, data);
 		return this.emitId<EventName>(eventName, "*", ...data);
 	}
 
-	emitId<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		id: string,
-		...data: Parameters<EventsInterface[EventName]>
-	): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[] {
-		if (!this._eventListeners || !this._eventListeners[eventName]) {
+	/**
+	 * Emits an event by name and id.
+	 * @param eventName The name of the event to emit.
+	 * @param id The id 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 {any[]} An array of all return values from all the listeners for the event.
+	 */
+	emitId<EventName extends keyof EventsInterface> (eventName: EventName, id: string, ...data: Parameters<EventsInterface[EventName]>): (ReturnType<EventsInterface[EventName]> | ListenerReturnFlag)[] {
+		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,24 +609,23 @@ 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.
+	 * Creates a persistent event. Once emitStatic() has been called, a
+	 * persistent event is registered. Any existing event listeners will
+	 * be called just like when you call emit(), however, any new
+	 * listeners that are registered for this event via on() will also be
+	 * called as soon as they are added.
 	 * @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]>
-	) {
+	emitStatic<EventName extends keyof EventsInterface> (eventName: EventName, ...data: Parameters<EventsInterface[EventName]>) {
 		const id = "*";
 		this._eventListeners = this._eventListeners || {};
 		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;
 
@@ -650,11 +663,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @returns The emitter instance.
 	 * @private
 	 */
-	emitStaticId<EventName extends keyof EventsInterface>(
-		eventName: EventName,
-		id: string,
-		...data: Parameters<EventsInterface[EventName]>
-	) {
+	emitStaticId<EventName extends keyof EventsInterface> (eventName: EventName, id: string, ...data: Parameters<EventsInterface[EventName]>) {
 		if (!id) throw new Error("Missing id from emitId call!");
 
 		this._eventListeners = this._eventListeners || {};
@@ -676,7 +685,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;
@@ -712,7 +721,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @returns The emitter instance.
 	 * @private
 	 */
-	cancelStatic<EventName extends keyof EventsInterface>(eventName: EventName) {
+	cancelStatic<EventName extends keyof EventsInterface> (eventName: EventName) {
 		this._eventStaticEmitters = this._eventStaticEmitters || {};
 		this._eventStaticEmitters[eventName] = [];
 
@@ -725,7 +734,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @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) {
+	willEmit<EventName extends keyof EventsInterface> (eventName: EventName) {
 		const id = "*";
 
 		if (!this._eventListeners || !this._eventListeners[eventName]) {
@@ -754,7 +763,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @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) {
+	willEmitId<EventName extends keyof EventsInterface> (eventName: EventName, id: string) {
 		if (!this._eventListeners || !this._eventListeners[eventName]) {
 			return false;
 		}
@@ -774,7 +783,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;
@@ -802,10 +811,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * @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]>
-	) {
+	deferEmit<EventName extends keyof EventsInterface> (eventName: EventName, ...data: Parameters<EventsInterface[EventName]>) {
 		if (!this._eventsAllowDefer) {
 			// Check for an existing timeout
 			this._eventsDeferTimeouts = this._eventsDeferTimeouts || {};
@@ -830,7 +836,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * argument contains a cancellation flag.
 	 * @param resultArr
 	 */
-	didCancel(resultArr: (unknown | ListenerReturnFlag)[]) {
+	didCancel (resultArr: (unknown | ListenerReturnFlag)[]) {
 		return resultArr.findIndex((result) => result === ListenerReturnFlag.cancel) > -1;
 	}
 
@@ -843,7 +849,7 @@ export class Emitter<EventsInterface extends EmitterEventsInterface<EventsInterf
 	 * the event emitter is finished processing.
 	 * @private
 	 */
-	_processRemovalQueue() {
+	_processRemovalQueue () {
 		if (!this._eventRemovalQueue || !this._eventRemovalQueue.length) {
 			return;
 		}
@@ -858,10 +864,10 @@ 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<EventsInterface extends EmitterEventsWithStar<EventsInterface> = EmitterAnyEventsInterface> (obj: boolean): Emitter<EventsInterface>;
+export function makeEmitter<EventsInterface extends EmitterEventsWithStar<EventsInterface> = EmitterAnyEventsInterface> (obj: Record<string, unknown>, prototypeMode: boolean): Emitter<EventsInterface>;
+export function makeEmitter<EventsInterface extends EmitterEventsWithStar<EventsInterface> = EmitterAnyEventsInterface> (obj: AnyConstructor): Emitter<EventsInterface>;
+export function makeEmitter<EventsInterface extends EmitterEventsWithStar<EventsInterface> = EmitterAnyEventsInterface> (obj: any, prototypeMode?: any): Emitter<EventsInterface> {
 	let operateOnObject;
 
 	if (obj === undefined && prototypeMode === undefined) {
@@ -884,9 +890,7 @@ export function makeEmitter(obj: any, prototypeMode?: any) {
 
 	if (prototypeMode) {
 		if (obj.prototype === undefined) {
-			throw new Error(
-				"Cannot modify prototype of passed object, it has no prototype property! Was it instantiated with the new operator correctly?"
-			);
+			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;
@@ -896,7 +900,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;
@@ -909,4 +915,4 @@ export function makeEmitter(obj: any, prototypeMode?: any) {
 	operateOnObject._processRemovalQueue = Emitter.prototype._processRemovalQueue;
 
 	return obj;
-}
+}

package/tests/Emitter.test.d.ts

@@ -0,0 +1 @@
+export {};