@irrelon/emitter 6.1.0 → 6.2.1

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
  */
@@ -107,61 +130,66 @@ 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>
-) => ReturnType<EventCallbackFunctionSignature>;
+export type EventListenerCallback<EventCallbackFunctionSignature extends AnyFunction = AnyFunction> = (...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 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 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> = {};
+	_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
-     * 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]>
-	) {
+	 * 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]>) {
 		const generateTimeout = (emitter: EventStaticEmitterObject<EventsInterface[EventName]>) => {
 			setTimeout(() => {
 				listener(...emitter.args);
@@ -174,12 +202,7 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 		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++) {
@@ -197,24 +220,18 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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]>
-	) {
+	 * 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]>) {
 		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;
@@ -228,21 +245,16 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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 {
+	 * 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 {
 		// 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
@@ -281,35 +293,24 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * Creates an event listener that listens for any and all events
-     * emitted.
-     */
+	 * 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,
-        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 {
+	 * 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;
+	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]>);
 		}
@@ -318,22 +319,15 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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;
-	once<EventName extends keyof EventsInterface>(
-        eventName: EventName,
-        listener: EventListenerCallback<EventsInterface[EventName]>
-    ): this;
+	 * 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;
+	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);
 
@@ -345,26 +339,19 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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;
-	overwrite<EventName extends keyof EventsInterface>(
-        eventName: EventName,
-        listener: EventListenerCallback<EventsInterface[EventName]>
-    ): this;
+	 * 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;
+	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);
 
@@ -378,31 +365,24 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * Removes an event listener that listens for any and all events
-     * emitted.
-     */
+	 * 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;
-	off<EventName extends keyof EventsInterface>(
-        eventName: EventName,
-        listener?: EventListenerCallback<EventsInterface[EventName]>
-    ): this;
-	off<EventName extends keyof EventsInterface>(eventName: EventName): this;
+	 * 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;
+	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"
@@ -457,53 +437,63 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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 {
+	 * 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
+	 * 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> (
-		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");
 		}
@@ -538,51 +528,54 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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)[] {
+	 * 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 {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');
+	 * @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)[] {
+		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)[] {
+	/**
+	 * 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 [];
 		}
@@ -606,12 +599,7 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 
 		if (this._eventListeners["*"]) {
 			const arr = this._eventListeners["*"]!["*"];
-			emitterResult = emitterResult.concat(
-				this._emitToArrayOfListeners<EventName>(
-                    arr as EventListenerCallback<EventsInterface[EventName]>[],
-                    [eventName, ...data] as Parameters<EventsInterface[EventName]>
-				)
-			);
+			emitterResult = emitterResult.concat(this._emitToArrayOfListeners<EventName>(arr as EventListenerCallback<EventsInterface[EventName]>[], [eventName, ...data] as Parameters<EventsInterface[EventName]>));
 		}
 
 		this._eventsEmitting = false;
@@ -621,18 +609,17 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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]>
-	) {
+	 * 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]>) {
 		const id = "*";
 		this._eventListeners = this._eventListeners || {};
 		this._eventsEmitting = true;
@@ -656,31 +643,27 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 
 		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> (
-		eventName: EventName,
-		id: string,
-		...data: Parameters<EventsInterface[EventName]>
-	) {
+	 * 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]>) {
 		if (!id) throw new Error("Missing id from emitId call!");
 
 		this._eventListeners = this._eventListeners || {};
@@ -722,22 +705,22 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 
 		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
-     */
+	 * 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] = [];
@@ -746,11 +729,11 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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.
-     */
+	 * 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 = "*";
 
@@ -774,12 +757,12 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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.
-     */
+	 * 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;
@@ -819,19 +802,16 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * 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]>
-	) {
+	 * 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]>) {
 		if (!this._eventsAllowDefer) {
 			// Check for an existing timeout
 			this._eventsDeferTimeouts = this._eventsDeferTimeouts || {};
@@ -852,23 +832,23 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 
 	/**
-     * Returns true if the result from an emit() call passed as the first
-     * argument contains a cancellation flag.
-     * @param resultArr
-     */
+	 * 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
-     */
+	 * 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;
@@ -884,10 +864,10 @@ export class Emitter<EventsInterface extends EmitterEventsWithStar<EventsInterfa
 	}
 }
 
-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) {
@@ -910,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;
@@ -937,4 +915,4 @@ export function makeEmitter (obj: any, prototypeMode?: any) {
 	operateOnObject._processRemovalQueue = Emitter.prototype._processRemovalQueue;
 
 	return obj;
-}
+}