@adonisjs/events 8.4.9-0 → 8.4.9-2

package/LICENSE.md

@@ -1,6 +1,6 @@
 # The MIT License
 
-Copyright (c) 2023 AdonisJS Framework
+Copyright (c) 2023 Harminder Virk
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/build/{test_factories → factories}/emitter.d.ts

@@ -3,3 +3,4 @@ import { Emitter } from '../src/emitter.js';
 export declare class EmitterFactory {
     create(app: Application<any>): Emitter<Record<string | number | symbol, any>>;
 }
+//# sourceMappingURL=emitter.d.ts.map

package/build/factories/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../factories/emitter.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAM3C,qBAAa,cAAc;IAIzB,MAAM,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC;CAG7B"}

package/build/{test_factories → factories}/main.d.ts

@@ -1 +1,2 @@
 export { EmitterFactory } from './emitter.js';
+//# sourceMappingURL=main.d.ts.map

package/build/factories/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../factories/main.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA"}

package/build/index.d.ts

@@ -1,2 +1,3 @@
 export { Emitter } from './src/emitter.js';
 export { BaseEvent } from './src/base_event.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA"}

package/build/src/base_event.d.ts

@@ -1,7 +1,8 @@
-import { Emitter } from './emitter.js';
+import type { Emitter } from './emitter.js';
 export declare class BaseEvent {
     constructor(..._: any[]);
     static emitter?: Emitter<any>;
     static useEmitter(emitter: Emitter<any>): void;
     static dispatch<T extends typeof BaseEvent>(this: T, ...args: ConstructorParameters<T>): Promise<void>;
 }
+//# sourceMappingURL=base_event.d.ts.map

package/build/src/base_event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_event.d.ts","sourceRoot":"","sources":["../../src/base_event.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAM3C,qBAAa,SAAS;gBACR,GAAG,CAAC,EAAE,GAAG,EAAE;IAKvB,MAAM,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;IAK7B,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC;WAQ1B,QAAQ,CAAC,CAAC,SAAS,OAAO,SAAS,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC;CAS7F"}

package/build/src/base_event.js

@@ -7,7 +7,7 @@ export class BaseEvent {
     }
     static async dispatch(...args) {
         if (!this.emitter) {
-            throw new RuntimeException(`Cannot dispatch "${this.name}" event. Make sure to pass emitter to the base event for dispatch method to work`);
+            throw new RuntimeException(`Cannot dispatch "${this.name}" event. Make sure to pass emitter to the "BaseEvent" class for dispatch method to work`);
         }
         return this.emitter.emit(this, new this(...args));
     }

package/build/src/debug.d.ts

@@ -1,3 +1,4 @@
 /// <reference types="node" resolution-mode="require"/>
 declare const _default: import("util").DebugLogger;
 export default _default;
+//# sourceMappingURL=debug.d.ts.map

package/build/src/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/debug.ts"],"names":[],"mappings":";;AAUA,wBAA0C"}

package/build/src/emitter.d.ts

@@ -8,10 +8,10 @@ export declare class Emitter<EventsList extends Record<string | symbol | number,
     constructor(app: Application<any>);
     onError(callback: (event: keyof EventsList | Constructor<any>, error: any, data: any) => void): this;
     listen<Event extends Constructor<any>>(event: Event, listeners: (ListenerClassWithHandleMethod<InstanceType<Event>> | LazyImport<ListenerClassWithHandleMethod<InstanceType<Event>>>)[]): void;
-    on<Event extends Constructor<any>, ListenerClass extends Constructor<any>>(event: Event, listener: Listener<InstanceType<Event>, ListenerClass>): UnsubscribeFunction;
-    on<Name extends keyof EventsList, ListenerClass extends Constructor<any>>(event: Name, listener: Listener<EventsList[Name], ListenerClass>): UnsubscribeFunction;
-    once<Event extends Constructor<any>, ListenerClass extends Constructor<any>>(event: Event, listener: Listener<InstanceType<Event>, ListenerClass>): void;
-    once<Name extends keyof EventsList, ListenerClass extends Constructor<any>>(event: Name, listener: Listener<EventsList[Name], ListenerClass>): void;
+    on<Event extends Constructor, ListenerClass extends Constructor>(event: Event, listener: Listener<InstanceType<Event>, ListenerClass>): UnsubscribeFunction;
+    on<Name extends keyof EventsList, ListenerClass extends Constructor>(event: Name, listener: Listener<EventsList[Name], ListenerClass>): UnsubscribeFunction;
+    once<Event extends Constructor, ListenerClass extends Constructor>(event: Event, listener: Listener<InstanceType<Event>, ListenerClass>): void;
+    once<Name extends keyof EventsList, ListenerClass extends Constructor>(event: Name, listener: Listener<EventsList[Name], ListenerClass>): void;
     onAny(listener: (event: AllowedEventTypes, data: any) => any | Promise<any>): UnsubscribeFunction;
     emit<Event extends Constructor<any>>(event: Event, data: InstanceType<Event>): Promise<void>;
     emit<Name extends keyof EventsList>(event: Name, data: EventsList[Name]): Promise<void>;
@@ -25,3 +25,4 @@ export declare class Emitter<EventsList extends Record<string | symbol | number,
     fake(events?: (keyof EventsList | Constructor<any>)[]): EventsBuffer<EventsList>;
     restore(): void;
 }
+//# sourceMappingURL=emitter.d.ts.map

package/build/src/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../src/emitter.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAiB,EAAE,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAI7D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EACV,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,6BAA6B,EAC9B,MAAM,YAAY,CAAA;AAMnB,qBAAa,OAAO,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC;;IAmD3E,IAAI,eAAe,sFAElB;gBAEW,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC;IA6FjC,OAAO,CACL,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,GACpF,IAAI;IAUP,MAAM,CAAC,KAAK,SAAS,WAAW,CAAC,GAAG,CAAC,EACnC,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,CACP,6BAA6B,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,GAClD,UAAU,CAAC,6BAA6B,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CACjE,EAAE;IAQL,EAAE,CAAC,KAAK,SAAS,WAAW,EAAE,aAAa,SAAS,WAAW,EAC7D,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,GACrD,mBAAmB;IACtB,EAAE,CAAC,IAAI,SAAS,MAAM,UAAU,EAAE,aAAa,SAAS,WAAW,EACjE,KAAK,EAAE,IAAI,EACX,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,GAClD,mBAAmB;IAmBtB,IAAI,CAAC,KAAK,SAAS,WAAW,EAAE,aAAa,SAAS,WAAW,EAC/D,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,GACrD,IAAI;IACP,IAAI,CAAC,IAAI,SAAS,MAAM,UAAU,EAAE,aAAa,SAAS,WAAW,EACnE,KAAK,EAAE,IAAI,EACX,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,GAClD,IAAI;IA2BP,KAAK,CACH,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,IAAI,EAAE,GAAG,KAAK,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,GACpE,mBAAmB;IAUhB,IAAI,CAAC,KAAK,SAAS,WAAW,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAC5F,IAAI,CAAC,IAAI,SAAS,MAAM,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B7F,GAAG,CAAC,KAAK,EAAE,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI;IAoBhG,MAAM,CACJ,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,GAAG,KAAK,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,GACtF,IAAI;IAUP,aAAa,CACX,KAAK,EAAE,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,EAC1C,QAAQ,EAAE,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,GACxC,IAAI;IAOP,cAAc,CAAC,KAAK,EAAE,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC;IASzD,iBAAiB;IASjB,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,MAAM;IAOlE,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,GAAG,OAAO;IAclE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,YAAY,CAAC,UAAU,CAAC;IAkBhF,OAAO;CAMR"}

package/build/src/events_buffer.d.ts

@@ -4,8 +4,12 @@ export declare class EventsBuffer<EventsList extends Record<string | symbol | nu
     add<Name extends AllowedEventTypes>(event: Name, data: any): void;
     all(): BufferedEventsList<EventsList>[];
     size(): number;
-    exists<Event extends keyof EventsList | Constructor<any>>(finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)): boolean;
-    filter(finder: keyof EventsList | Constructor<any> | ((event: BufferedEventsList<EventsList>) => boolean)): BufferedEventsList<EventsList>[];
-    find<Event extends keyof EventsList | Constructor<any>>(finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)): (Event extends keyof EventsList ? BufferedEvent<Event, EventsList[Event]> : Event extends Constructor<infer A> ? BufferedEvent<Event, A> : BufferedEventsList<EventsList>) | null;
+    exists<Event extends keyof EventsList | Constructor>(finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)): boolean;
+    filter(finder: keyof EventsList | Constructor | ((event: BufferedEventsList<EventsList>) => boolean)): BufferedEventsList<EventsList>[];
+    find<Event extends keyof EventsList | Constructor>(finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)): (Event extends keyof EventsList ? BufferedEvent<Event, EventsList[Event]> : Event extends Constructor<infer A> ? BufferedEvent<Event, A> : BufferedEventsList<EventsList>) | null;
+    assertEmitted<Event extends keyof EventsList | Constructor>(finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)): void;
+    assertNotEmitted<Event extends keyof EventsList | Constructor<any>>(finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)): void;
+    assertNoneEmitted(): void;
     flush(): void;
 }
+//# sourceMappingURL=events_buffer.d.ts.map

package/build/src/events_buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events_buffer.d.ts","sourceRoot":"","sources":["../../src/events_buffer.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAKnG,qBAAa,YAAY,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC;;IAShF,GAAG,CAAC,IAAI,SAAS,iBAAiB,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAOjE,GAAG;IAOH,IAAI;IAOJ,MAAM,CAAC,KAAK,SAAS,MAAM,UAAU,GAAG,WAAW,EACjD,MAAM,EAAE,KAAK,GAAG,CAAC,CAAC,KAAK,EAAE,kBAAkB,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,GACnE,OAAO;IAOV,MAAM,CACJ,MAAM,EAAE,MAAM,UAAU,GAAG,WAAW,GAAG,CAAC,CAAC,KAAK,EAAE,kBAAkB,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,GAC5F,kBAAkB,CAAC,UAAU,CAAC,EAAE;IAWnC,IAAI,CAAC,KAAK,SAAS,MAAM,UAAU,GAAG,WAAW,EAC/C,MAAM,EAAE,KAAK,GAAG,CAAC,CAAC,KAAK,EAAE,kBAAkB,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,GAElE,CAAC,KAAK,SAAS,MAAM,UAAU,GAC3B,aAAa,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,GACvC,KAAK,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,GAClC,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,GACvB,kBAAkB,CAAC,UAAU,CAAC,CAAC,GACnC,IAAI;IAWR,aAAa,CAAC,KAAK,SAAS,MAAM,UAAU,GAAG,WAAW,EACxD,MAAM,EAAE,KAAK,GAAG,CAAC,CAAC,KAAK,EAAE,kBAAkB,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,GACnE,IAAI;IAyBP,gBAAgB,CAAC,KAAK,SAAS,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,EAChE,MAAM,EAAE,KAAK,GAAG,CAAC,CAAC,KAAK,EAAE,kBAAkB,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,GACnE,IAAI;IAyBP,iBAAiB,IAAI,IAAI;IAuBzB,KAAK;CAGN"}

package/build/src/events_buffer.js

@@ -1,4 +1,5 @@
 import is from '@sindresorhus/is';
+import { AssertionError } from 'node:assert';
 export class EventsBuffer {
     #events = [];
     add(event, data) {
@@ -25,6 +26,56 @@ export class EventsBuffer {
         }
         return (this.#events.find((event) => event.event === finder) || null);
     }
+    assertEmitted(finder) {
+        const hasEvent = this.exists(finder);
+        if (!hasEvent) {
+            const isClass = is.class_(finder);
+            const message = typeof finder === 'function' && !isClass
+                ? `Expected callback to find an emitted event`
+                : isClass
+                    ? `Expected "${finder.name}" event to be emitted`
+                    : `Expected "${String(finder)}" event to be emitted`;
+            throw new AssertionError({
+                message: message,
+                expected: true,
+                actual: false,
+                operator: 'strictEqual',
+                stackStartFn: this.assertEmitted,
+            });
+        }
+    }
+    assertNotEmitted(finder) {
+        const hasEvent = this.exists(finder);
+        if (hasEvent) {
+            const isClass = is.class_(finder);
+            const message = typeof finder === 'function' && !isClass
+                ? `Expected callback to not find any event`
+                : isClass
+                    ? `Expected "${finder.name}" event to be not emitted`
+                    : `Expected "${String(finder)}" event to be not emitted`;
+            throw new AssertionError({
+                message: message,
+                expected: false,
+                actual: true,
+                operator: 'strictEqual',
+                stackStartFn: this.assertNotEmitted,
+            });
+        }
+    }
+    assertNoneEmitted() {
+        const eventsSize = this.size();
+        if (eventsSize > 0) {
+            throw new AssertionError(Object.assign({
+                message: `Expected zero events to be emitted. Instead received "${eventsSize}" event(s)`,
+                expected: 0,
+                actual: eventsSize,
+                operator: 'strictEqual',
+                stackStartFn: this.assertNoneEmitted,
+            }, {
+                showDiff: true,
+            }));
+        }
+    }
     flush() {
         this.#events = [];
     }

package/build/src/types.d.ts

@@ -1,5 +1,5 @@
-export type AllowedEventTypes = string | symbol | number | Constructor<any>;
-export type Constructor<T> = new (...args: any[]) => T;
+export type AllowedEventTypes = string | symbol | number | Constructor;
+export type Constructor<T = unknown> = new (...args: any[]) => T;
 export type LazyImport<DefaultExport> = () => Promise<{
     default: DefaultExport;
 }>;
@@ -18,4 +18,5 @@ export type GetListenersMethods<Listener extends Constructor<any>, Data> = {
 export type ListenerClassWithHandleMethod<Data> = Constructor<{
     handle: ListenerMethod<Data>;
 }>;
-export type Listener<Data, ListenerClass extends Constructor<any>> = ListenerFn<Data> | string | [LazyImport<ListenerClass> | ListenerClass, GetListenersMethods<ListenerClass, Data>?];
+export type Listener<Data, ListenerClass extends Constructor> = ListenerFn<Data> | string | [LazyImport<ListenerClass> | ListenerClass, GetListenersMethods<ListenerClass, Data>?];
+//# sourceMappingURL=types.d.ts.map

package/build/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,WAAW,CAAA;AAKtE,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAA;AAKhE,MAAM,MAAM,UAAU,CAAC,aAAa,IAAI,MAAM,OAAO,CAAC;IAAE,OAAO,EAAE,aAAa,CAAA;CAAE,CAAC,CAAA;AAKjF,MAAM,MAAM,aAAa,CAAC,KAAK,EAAE,IAAI,IAAI;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAA;AAKrE,MAAM,MAAM,kBAAkB,CAAC,UAAU,IACrC;KACG,IAAI,IAAI,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;CAClE,CAAC,MAAM,UAAU,CAAC,GACnB,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;AAOxC,MAAM,MAAM,cAAc,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAA;AAKrF,MAAM,MAAM,UAAU,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,IAAI,KAAK,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAA;AAMjE,MAAM,MAAM,mBAAmB,CAAC,QAAQ,SAAS,WAAW,CAAC,GAAG,CAAC,EAAE,IAAI,IAAI;KACxE,CAAC,IAAI,MAAM,YAAY,CAAC,QAAQ,CAAC,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,cAAc,CAAC,IAAI,CAAC,GACvF,CAAC,GACD,KAAK;CACV,CAAC,MAAM,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAA;AAK/B,MAAM,MAAM,6BAA6B,CAAC,IAAI,IAAI,WAAW,CAAC;IAC5D,MAAM,EAAE,cAAc,CAAC,IAAI,CAAC,CAAA;CAC7B,CAAC,CAAA;AAMF,MAAM,MAAM,QAAQ,CAAC,IAAI,EAAE,aAAa,SAAS,WAAW,IACxD,UAAU,CAAC,IAAI,CAAC,GAChB,MAAM,GACN,CAAC,UAAU,CAAC,aAAa,CAAC,GAAG,aAAa,EAAE,mBAAmB,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAAC,CAAA"}

package/factories/emitter.ts

@@ -0,0 +1,24 @@
+/*
+ * @adonisjs/events
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { Application } from '@adonisjs/application'
+import { Emitter } from '../src/emitter.js'
+
+/**
+ * Emitter factory is used to create an instance of emitter
+ * for testing
+ */
+export class EmitterFactory {
+  /**
+   * Create emitter instance
+   */
+  create(app: Application<any>) {
+    return new Emitter(app)
+  }
+}

package/factories/main.ts

@@ -0,0 +1,10 @@
+/*
+ * @adonisjs/events
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export { EmitterFactory } from './emitter.js'

package/index.ts

@@ -0,0 +1,11 @@
+/*
+ * @adonisjs/events
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export { Emitter } from './src/emitter.js'
+export { BaseEvent } from './src/base_event.js'

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@adonisjs/events",
-  "version": "8.4.9-0",
+  "version": "8.4.9-2",
   "description": "An implementation of the event emitter built on top of emittery",
   "main": "build/index.js",
   "type": "module",
   "files": [
+    "src",
+    "factories",
+    "index.ts",
     "build/src",
-    "build/test_factories",
+    "build/factories",
     "build/index.d.ts",
+    "build/index.d.ts.map",
     "build/index.js"
   ],
   "imports": {
@@ -15,7 +19,7 @@
   },
   "exports": {
     ".": "./build/index.js",
-    "./factories": "./build/test_factories/main.js",
+    "./factories": "./build/factories/main.js",
     "./types": "./build/src/types.js"
   },
   "scripts": {
@@ -39,12 +43,9 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^7.1.2-0",
-    "@adonisjs/config": "^4.2.1-0",
-    "@adonisjs/env": "^4.2.0-0",
-    "@adonisjs/fold": "^9.9.3-0",
-    "@adonisjs/logger": "^5.4.2-0",
-    "@commitlint/cli": "^17.4.4",
+    "@adonisjs/application": "^7.1.2-3",
+    "@adonisjs/fold": "^9.9.3-4",
+    "@commitlint/cli": "^17.5.0",
     "@commitlint/config-conventional": "^17.4.4",
     "@japa/assert": "^1.4.1",
     "@japa/expect-type": "^1.0.3",
@@ -52,30 +53,30 @@
     "@japa/run-failed-tests": "^1.1.1",
     "@japa/runner": "^2.5.1",
     "@japa/spec-reporter": "^1.3.3",
-    "@poppinss/dev-utils": "^2.0.1",
-    "@swc/core": "^1.3.37",
-    "@types/node": "^18.14.6",
+    "@swc/core": "^1.3.42",
+    "@types/node": "^18.15.9",
     "c8": "^7.13.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
-    "eslint": "^8.35.0",
-    "eslint-config-prettier": "^8.6.0",
+    "eslint": "^8.36.0",
+    "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-adonis": "^3.0.3",
     "eslint-plugin-prettier": "^4.2.1",
-    "github-label-sync": "^2.0.1",
+    "github-label-sync": "^2.3.1",
     "husky": "^8.0.3",
-    "np": "^7.6.3",
-    "prettier": "^2.8.4",
+    "np": "^7.6.4",
+    "prettier": "^2.8.7",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.5"
+    "typescript": "^5.0.2"
   },
   "dependencies": {
+    "@poppinss/utils": "^6.5.0-1",
     "@sindresorhus/is": "^5.3.0",
     "emittery": "^1.0.1"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^7.1.2-0",
-    "@adonisjs/fold": "^9.9.3-0"
+    "@adonisjs/application": "^7.1.2-3",
+    "@adonisjs/fold": "^9.9.3-4"
   },
   "repository": {
     "type": "git",

package/src/base_event.ts

@@ -0,0 +1,45 @@
+/*
+ * @adonisjs/events
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { RuntimeException } from '@poppinss/utils'
+import type { Emitter } from './emitter.js'
+
+/**
+ * Base event adds ability to a class to act as an event. You can emit the
+ * event by calling "Event.dispatch" method.
+ */
+export class BaseEvent {
+  constructor(..._: any[]) {}
+
+  /**
+   * The emitter to use for dispatching events
+   */
+  static emitter?: Emitter<any>
+
+  /**
+   * Specify the emitter instance to use for dispatching events
+   */
+  static useEmitter(emitter: Emitter<any>) {
+    this.emitter = emitter
+  }
+
+  /**
+   * Dispatch the current class as an event. The method takes the arguments
+   * accepted by the class constructor.
+   */
+  static async dispatch<T extends typeof BaseEvent>(this: T, ...args: ConstructorParameters<T>) {
+    if (!this.emitter) {
+      throw new RuntimeException(
+        `Cannot dispatch "${this.name}" event. Make sure to pass emitter to the "BaseEvent" class for dispatch method to work`
+      )
+    }
+
+    return this.emitter.emit<T>(this, new this(...args) as InstanceType<T>)
+  }
+}

package/src/debug.ts

@@ -0,0 +1,11 @@
+/*
+ * @adonisjs/events
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { debuglog } from 'node:util'
+export default debuglog('adonisjs:events')

package/src/emitter.ts

@@ -0,0 +1,407 @@
+/*
+ * @adonisjs/events
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import is from '@sindresorhus/is'
+import type { Application } from '@adonisjs/application'
+import Emittery, { type UnsubscribeFunction } from 'emittery'
+import { moduleExpression, moduleCaller, moduleImporter } from '@adonisjs/fold'
+
+import debug from './debug.js'
+import { EventsBuffer } from './events_buffer.js'
+import type {
+  Listener,
+  LazyImport,
+  Constructor,
+  ListenerMethod,
+  AllowedEventTypes,
+  ListenerClassWithHandleMethod,
+} from './types.js'
+
+/**
+ * Event emitter is built on top of emittery with support class based
+ * events and listeners
+ */
+export class Emitter<EventsList extends Record<string | symbol | number, any>> {
+  /**
+   * Event classes to symbols mapping. We need symbols as emittery
+   * does not support class based event names
+   */
+  #eventsClassSymbols: Map<Constructor<any>, symbol> = new Map()
+
+  /**
+   * A collection of events and their listeners. We do not track listeners
+   * listening for events only once
+   */
+  #eventsListeners: Map<
+    AllowedEventTypes,
+    Map<Listener<any, Constructor<any>>, ListenerMethod<any>>
+  > = new Map()
+
+  /**
+   * Underlying transport to emit events
+   */
+  #transport = new Emittery()
+
+  /**
+   * Events buffer. The events are collected inside an in-memory
+   * buffer during fakes
+   */
+  #eventsBuffer?: EventsBuffer<EventsList>
+
+  /**
+   * A set of events to fake
+   */
+  #eventsToFake: Set<AllowedEventTypes | '*'> = new Set()
+
+  /**
+   * Error handler to catch all errors thrown by listeners
+   */
+  #errorHandler?: (event: keyof EventsList | Constructor<any>, error: any, data: any) => void
+
+  /**
+   * Reference to AdonisJS application, we need the application root
+   * and container reference from it.
+   */
+  #app: Application<any>
+
+  /**
+   * Returns a map of events and their registered listeners. The
+   * map key is the event name and the value is another map
+   * of listeners.
+   *
+   * The listeners map key is the original binding listener
+   * and the value is a callback function.
+   */
+  get eventsListeners() {
+    return this.#eventsListeners
+  }
+
+  constructor(app: Application<any>) {
+    this.#app = app
+  }
+
+  /**
+   * Returns the symbol for a class based event.
+   */
+  #getEventClassSymbol(event: Constructor<any>): symbol {
+    if (!this.#eventsClassSymbols.has(event)) {
+      this.#eventsClassSymbols.set(event, Symbol(event.name))
+    }
+
+    return this.#eventsClassSymbols.get(event)!
+  }
+
+  /**
+   * Normalizes the event to emittery supported data types. The class
+   * constructors are cached against a unique symbol.
+   */
+  #resolveEvent(event: AllowedEventTypes): string | symbol | number {
+    if (is.class_(event)) {
+      return this.#getEventClassSymbol(event)
+    }
+
+    return event
+  }
+
+  /**
+   * Returns the event listeners map
+   */
+  #getEventListeners(event: AllowedEventTypes) {
+    if (!this.#eventsListeners.has(event)) {
+      this.#eventsListeners.set(event, new Map())
+    }
+
+    return this.#eventsListeners.get(event)!
+  }
+
+  /**
+   * Normalizes the event listener to a function that can be passed to
+   * emittery.
+   */
+  #normalizeEventListener(listener: Listener<any, Constructor>): ListenerMethod<any> {
+    /**
+     * Parse string based listener
+     */
+    if (typeof listener === 'string') {
+      return moduleExpression(listener, this.#app.appRoot).toCallable(this.#app.container)
+    }
+
+    /**
+     * Parse array based listener with the listener reference
+     * or lazily imported listener class
+     */
+    if (Array.isArray(listener)) {
+      const listenerModule = listener[0]
+      const method = listener[1] || 'handle'
+
+      /**
+       * Class reference
+       */
+      if (is.class_(listenerModule)) {
+        return moduleCaller(listenerModule, method).toCallable(this.#app.container)
+      }
+
+      /**
+       * Lazily loaded module
+       */
+      return moduleImporter(listenerModule, method).toCallable(this.#app.container)
+    }
+
+    return listener
+  }
+
+  /**
+   * Resolves the event listener either from the cache or normalizes
+   * it and stores it inside the cache
+   */
+  #resolveEventListener(
+    event: AllowedEventTypes,
+    listener: Listener<any, Constructor>
+  ): ListenerMethod<any> {
+    const eventListeners = this.#getEventListeners(event)
+    if (!eventListeners.has(listener)) {
+      eventListeners.set(listener, this.#normalizeEventListener(listener))
+    }
+
+    return eventListeners.get(listener)!
+  }
+
+  /**
+   * Register a global error handler
+   */
+  onError(
+    callback: (event: keyof EventsList | Constructor<any>, error: any, data: any) => void
+  ): this {
+    this.#errorHandler = callback
+    return this
+  }
+
+  /**
+   * Bind multiple listeners to listen for a single event. The listen
+   * method is a convenience helper to be used with class based
+   * events and listeners.
+   */
+  listen<Event extends Constructor<any>>(
+    event: Event,
+    listeners: (
+      | ListenerClassWithHandleMethod<InstanceType<Event>>
+      | LazyImport<ListenerClassWithHandleMethod<InstanceType<Event>>>
+    )[]
+  ) {
+    listeners.forEach((listener) => this.on(event, [listener, 'handle']))
+  }
+
+  /**
+   * Listen for an event. The method returns the unsubscribe function.
+   */
+  on<Event extends Constructor, ListenerClass extends Constructor>(
+    event: Event,
+    listener: Listener<InstanceType<Event>, ListenerClass>
+  ): UnsubscribeFunction
+  on<Name extends keyof EventsList, ListenerClass extends Constructor>(
+    event: Name,
+    listener: Listener<EventsList[Name], ListenerClass>
+  ): UnsubscribeFunction
+  on<Event extends AllowedEventTypes>(
+    event: Event,
+    listener: Listener<any, Constructor>
+  ): UnsubscribeFunction {
+    if (debug.enabled) {
+      debug('registering event listener, event: %O, listener: %O', event, listener)
+    }
+
+    const normalizedEvent = this.#resolveEvent(event)
+    const normalizedListener = this.#resolveEventListener(event, listener)
+
+    this.#transport.on(normalizedEvent, normalizedListener)
+    return () => this.off(event, listener)
+  }
+
+  /**
+   * Listen for an event only once
+   */
+  once<Event extends Constructor, ListenerClass extends Constructor>(
+    event: Event,
+    listener: Listener<InstanceType<Event>, ListenerClass>
+  ): void
+  once<Name extends keyof EventsList, ListenerClass extends Constructor>(
+    event: Name,
+    listener: Listener<EventsList[Name], ListenerClass>
+  ): void
+  once<Event extends AllowedEventTypes>(event: Event, listener: Listener<any, Constructor>): void {
+    if (debug.enabled) {
+      debug('registering one time event listener, event: %O, listener: %O', event, listener)
+    }
+
+    const normalizedEvent = this.#resolveEvent(event)
+    const normalizedListener = this.#normalizeEventListener(listener)
+
+    /**
+     * Listening for an event and unsubscribing right after the event is emitted.
+     * Internally emittery does the same thing, but they do not await the
+     * handler. Therefore, the "once" listeners will finish after the
+     * "emit" call. This behavior is not inline with the "on" event
+     * listeners.
+     */
+    const off = this.#transport.on(normalizedEvent, async (data) => {
+      off()
+      debug('removing one time event listener, event: %O', event)
+      await normalizedListener(data)
+    })
+  }
+
+  /**
+   * Attach a listener to listen for all the events. Wildcard listeners
+   * can only be defined as inline callbacks.
+   */
+  onAny(
+    listener: (event: AllowedEventTypes, data: any) => any | Promise<any>
+  ): UnsubscribeFunction {
+    return this.#transport.onAny(listener)
+  }
+
+  /**
+   * Emit event. The event listeners will be called asynchronously
+   * in parallel.
+   *
+   * You can await this method to wait for events listeners to finish
+   */
+  async emit<Event extends Constructor<any>>(event: Event, data: InstanceType<Event>): Promise<void>
+  async emit<Name extends keyof EventsList>(event: Name, data: EventsList[Name]): Promise<void>
+  async emit<Event extends AllowedEventTypes>(event: Event, data: any): Promise<void> {
+    /**
+     * Entertain fakes if exists
+     */
+    if (this.#eventsToFake.has(event) || this.#eventsToFake.has('*')) {
+      debug('faking emit. event: %O, data: %O', event, data)
+      this.#eventsBuffer!.add(event, data)
+      return
+    }
+
+    try {
+      const normalizedEvent = this.#resolveEvent(event)
+      await this.#transport.emit(normalizedEvent, data)
+    } catch (error) {
+      if (this.#errorHandler) {
+        this.#errorHandler(event, error, data)
+      } else {
+        throw error
+      }
+    }
+  }
+
+  /**
+   * Remove a specific listener for an event
+   */
+  off(event: keyof EventsList | Constructor<any>, listener: Listener<any, Constructor<any>>): void {
+    if (debug.enabled) {
+      debug('removing listener, event: %O, listener: %O', event, listener)
+    }
+
+    const normalizedEvent = this.#resolveEvent(event)
+    const listeners = this.#getEventListeners(event)
+    const normalizedListener = listeners.get(listener)
+
+    if (!normalizedListener) {
+      return
+    }
+
+    listeners.delete(listener)
+    this.#transport.off(normalizedEvent, normalizedListener)
+  }
+
+  /**
+   * Remove a specific listener listening for all the events
+   */
+  offAny(
+    listener: (event: keyof EventsList | Constructor<any>, data: any) => any | Promise<any>
+  ): this {
+    this.#transport.offAny(listener)
+    return this
+  }
+
+  /**
+   * Remove a specific listener for an event
+   *
+   * @alias "off"
+   */
+  clearListener(
+    event: keyof EventsList | Constructor<any>,
+    listener: Listener<any, Constructor<any>>
+  ): void {
+    return this.off(event, listener)
+  }
+
+  /**
+   * Clear all listeners for a specific event
+   */
+  clearListeners(event: keyof EventsList | Constructor<any>) {
+    debug('clearing all listeners for event %O', event)
+    this.#transport.clearListeners(this.#resolveEvent(event))
+    this.#eventsListeners.delete(event)
+  }
+
+  /**
+   * Clear all listeners for all the events
+   */
+  clearAllListeners() {
+    debug('clearing all event listeners')
+    this.#transport.clearListeners()
+    this.#eventsListeners.clear()
+  }
+
+  /**
+   * Get count of listeners for a given event or all the events
+   */
+  listenerCount(event?: keyof EventsList | Constructor<any>): number {
+    return this.#transport.listenerCount(event ? this.#resolveEvent(event) : undefined)
+  }
+
+  /**
+   * Find if an event has one or more listeners
+   */
+  hasListeners(event?: keyof EventsList | Constructor<any>): boolean {
+    return this.listenerCount(event) > 0
+  }
+
+  /**
+   * Fake one or more events. The listeners for faked events will
+   * not be invoked.
+   *
+   * The return value is an events buffer that collects all the
+   * events within memory.
+   *
+   * Calling this method one than once drops the existing fakes and
+   * creates new one.
+   */
+  fake(events?: (keyof EventsList | Constructor<any>)[]): EventsBuffer<EventsList> {
+    this.restore()
+    this.#eventsBuffer = new EventsBuffer<EventsList>()
+
+    if (!events) {
+      debug('faking all events')
+      this.#eventsToFake.add('*')
+    } else {
+      debug('faking events: %O', events)
+      events.forEach((event) => this.#eventsToFake.add(event))
+    }
+
+    return this.#eventsBuffer
+  }
+
+  /**
+   * Restore fakes
+   */
+  restore() {
+    debug('restoring existing fakes')
+    this.#eventsToFake.clear()
+    this.#eventsBuffer?.flush()
+    this.#eventsBuffer = undefined
+  }
+}

package/src/events_buffer.ts

@@ -0,0 +1,168 @@
+/*
+ * @adonisjs/events
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import is from '@sindresorhus/is'
+import { AssertionError } from 'node:assert'
+import type { AllowedEventTypes, BufferedEvent, BufferedEventsList, Constructor } from './types.js'
+
+/**
+ * Exposes API to filter, find events from the events buffer.
+ */
+export class EventsBuffer<EventsList extends Record<string | symbol | number, any>> {
+  /**
+   * Buffered events
+   */
+  #events: BufferedEventsList<EventsList>[] = []
+
+  /**
+   * Track emitted event
+   */
+  add<Name extends AllowedEventTypes>(event: Name, data: any): void {
+    this.#events.push({ event: event as any, data })
+  }
+
+  /**
+   * Get all the emitted events
+   */
+  all() {
+    return this.#events
+  }
+
+  /**
+   * Returns the size of captured events
+   */
+  size() {
+    return this.#events.length
+  }
+
+  /**
+   * Find if an event was emitted
+   */
+  exists<Event extends keyof EventsList | Constructor>(
+    finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)
+  ): boolean {
+    return !!this.find(finder)
+  }
+
+  /**
+   * Get selected events
+   */
+  filter(
+    finder: keyof EventsList | Constructor | ((event: BufferedEventsList<EventsList>) => boolean)
+  ): BufferedEventsList<EventsList>[] {
+    if (typeof finder === 'function' && !is.class_(finder)) {
+      return this.#events.filter(finder)
+    }
+
+    return this.#events.filter((event) => event.event === finder)
+  }
+
+  /**
+   * Find a specific event
+   */
+  find<Event extends keyof EventsList | Constructor>(
+    finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)
+  ):
+    | (Event extends keyof EventsList
+        ? BufferedEvent<Event, EventsList[Event]>
+        : Event extends Constructor<infer A>
+        ? BufferedEvent<Event, A>
+        : BufferedEventsList<EventsList>)
+    | null {
+    if (typeof finder === 'function' && !is.class_(finder)) {
+      return (this.#events.find(finder) || null) as any
+    }
+
+    return (this.#events.find((event) => event.event === finder) || null) as any
+  }
+
+  /**
+   * Assert a given event has been emitted
+   */
+  assertEmitted<Event extends keyof EventsList | Constructor>(
+    finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)
+  ): void {
+    const hasEvent = this.exists(finder)
+
+    if (!hasEvent) {
+      const isClass = is.class_(finder)
+      const message =
+        typeof finder === 'function' && !isClass
+          ? `Expected callback to find an emitted event`
+          : isClass
+          ? `Expected "${finder.name}" event to be emitted`
+          : `Expected "${String(finder)}" event to be emitted`
+
+      throw new AssertionError({
+        message: message,
+        expected: true,
+        actual: false,
+        operator: 'strictEqual',
+        stackStartFn: this.assertEmitted,
+      })
+    }
+  }
+
+  /**
+   * Assert a given event has been not been emitted
+   */
+  assertNotEmitted<Event extends keyof EventsList | Constructor<any>>(
+    finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)
+  ): void {
+    const hasEvent = this.exists(finder)
+
+    if (hasEvent) {
+      const isClass = is.class_(finder)
+      const message =
+        typeof finder === 'function' && !isClass
+          ? `Expected callback to not find any event`
+          : isClass
+          ? `Expected "${finder.name}" event to be not emitted`
+          : `Expected "${String(finder)}" event to be not emitted`
+
+      throw new AssertionError({
+        message: message,
+        expected: false,
+        actual: true,
+        operator: 'strictEqual',
+        stackStartFn: this.assertNotEmitted,
+      })
+    }
+  }
+
+  /**
+   * Assert a given event has been not been emitted
+   */
+  assertNoneEmitted(): void {
+    const eventsSize = this.size()
+    if (eventsSize > 0) {
+      throw new AssertionError(
+        Object.assign(
+          {
+            message: `Expected zero events to be emitted. Instead received "${eventsSize}" event(s)`,
+            expected: 0,
+            actual: eventsSize,
+            operator: 'strictEqual',
+            stackStartFn: this.assertNoneEmitted,
+          },
+          {
+            showDiff: true,
+          }
+        )
+      )
+    }
+  }
+
+  /**
+   * Flush events collected within memory
+   */
+  flush() {
+    this.#events = []
+  }
+}

package/src/types.ts

@@ -0,0 +1,75 @@
+/*
+ * @adonisjs/events
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * Data types for event name
+ */
+export type AllowedEventTypes = string | symbol | number | Constructor
+
+/**
+ * Class constructor type
+ */
+export type Constructor<T = unknown> = new (...args: any[]) => T
+
+/**
+ * A function that lazily imports a middleware
+ */
+export type LazyImport<DefaultExport> = () => Promise<{ default: DefaultExport }>
+
+/**
+ * Data structure for a buffered event
+ */
+export type BufferedEvent<Event, Data> = { event: Event; data: Data }
+
+/**
+ * Event list item inside bufferred items
+ */
+export type BufferedEventsList<EventsList> =
+  | {
+      [Name in keyof EventsList]: BufferedEvent<Name, EventsList[Name]>
+    }[keyof EventsList]
+  | BufferedEvent<Constructor<any>, any>
+
+/**
+ * Representation of listener method on the listener class. The
+ * spread args can type hint dependencies and container will
+ * resolve them
+ */
+export type ListenerMethod<Data> = (data: Data, ...args: any[]) => any | Promise<any>
+
+/**
+ * The event listener defined as an inline callback
+ */
+export type ListenerFn<Data> = (data: Data) => any | Promise<any>
+
+/**
+ * Returns a union of methods from a listener that accepts
+ * the event data as the first argument.
+ */
+export type GetListenersMethods<Listener extends Constructor<any>, Data> = {
+  [K in keyof InstanceType<Listener>]: InstanceType<Listener>[K] extends ListenerMethod<Data>
+    ? K
+    : never
+}[keyof InstanceType<Listener>]
+
+/**
+ * Representation of listener class with handle method
+ */
+export type ListenerClassWithHandleMethod<Data> = Constructor<{
+  handle: ListenerMethod<Data>
+}>
+
+/**
+ * The event listener defined as an inline callback, string
+ * listener class reference or a lazily imported listener
+ */
+export type Listener<Data, ListenerClass extends Constructor> =
+  | ListenerFn<Data>
+  | string
+  | [LazyImport<ListenerClass> | ListenerClass, GetListenersMethods<ListenerClass, Data>?]