@adonisjs/events 8.1.4-0 → 8.2.0-0

package/README.md

@@ -5,7 +5,7 @@
 [![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url] [![synk-image]][synk-url]
 
 ## Introduction
-AdonisJS events is an implementation of the event emitter built on top of [emittery](https://github.com/sindresorhus/emittery). Alongside defining event listeners as inline callbacks, you can also bind modules to events and register event subscribers.
+AdonisJS events is an implementation of the event emitter built on top of [emittery](https://github.com/sindresorhus/emittery). Alongside defining event listeners as inline callbacks, you can also bind modules to events and define events as classes.
 
 ## Official Documentation
 The documentation is available on the [AdonisJS website](https://docs.adonisjs.com/guides/events)
@@ -21,7 +21,7 @@ In order to ensure that the AdonisJS community is welcoming to all, please revie
 ## License
 AdonisJS events is open-sourced software licensed under the [MIT license](LICENSE.md).
 
-[gh-workflow-image]: https://img.shields.io/github/workflow/status/adonisjs/events/test?style=for-the-badge
+[gh-workflow-image]: https://img.shields.io/github/actions/workflow/status/adonisjs/events/test.yml?style=for-the-badge
 [gh-workflow-url]: https://github.com/adonisjs/events/actions/workflows/test.yml "Github action"
 
 [typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript

package/build/src/emitter.d.ts

@@ -1,21 +1,26 @@
-import { type Application } from '@adonisjs/application';
-import type { EventsListItem } from './types.js';
+import type { Application } from '@adonisjs/application';
+import { type UnsubscribeFunction } from 'emittery';
 import { EventsBuffer } from './events_buffer.js';
+import type { Listener, Constructor, ListenerMethod, AllowedEventTypes } from './types.js';
 export declare class Emitter<EventsList extends Record<string | symbol | number, any>> {
     #private;
+    get eventsListeners(): Map<AllowedEventTypes, Map<Listener<any, Constructor<any>>, ListenerMethod<any>>>;
     constructor(app: Application<any, any>);
-    onError(callback: (event: keyof EventsList, error: any, data: any) => void): this;
-    on<Name extends keyof EventsList>(event: Name, handler: string | ((data: EventsList[Name]) => any | Promise<any>)): this;
-    once<Name extends keyof EventsList>(event: Name, handler: string | ((data: EventsList[Name]) => any | Promise<any>)): this;
-    onAny(handler: string | ((event: keyof EventsList, data: EventsListItem<EventsList>) => any | Promise<any>)): this;
+    onError(callback: (event: keyof EventsList | Constructor<any>, error: any, data: any) => void): this;
+    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;
+    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>;
-    off<Name extends keyof EventsList>(event: Name, handler: string | ((data: EventsList[Name]) => any | Promise<any>)): this;
-    offAny(handler: string | ((event: keyof EventsList, data: EventsListItem<EventsList>) => any | Promise<any>)): this;
-    clearListener<Name extends keyof EventsList>(event: Name, handler: string | ((data: EventsList[Name]) => any | Promise<any>)): this;
-    clearListeners(event: keyof EventsList): void;
+    off(event: keyof EventsList | Constructor<any>, listener: Listener<any, Constructor<any>>): void;
+    offAny(listener: (event: keyof EventsList | Constructor<any>, data: any) => any | Promise<any>): this;
+    clearListener(event: keyof EventsList | Constructor<any>, listener: Listener<any, Constructor<any>>): void;
+    clearListeners(event: keyof EventsList | Constructor<any>): void;
     clearAllListeners(): void;
-    listenerCount<Name extends keyof EventsList>(event?: Name): number;
-    hasListeners<Name extends keyof EventsList>(event?: Name): boolean;
-    fake(events?: (keyof EventsList)[]): EventsBuffer<EventsList>;
+    listenerCount(event?: keyof EventsList | Constructor<any>): number;
+    hasListeners(event?: keyof EventsList | Constructor<any>): boolean;
+    fake(events?: (keyof EventsList | Constructor<any>)[]): EventsBuffer<EventsList>;
     restore(): void;
 }

package/build/src/emitter.js

@@ -1,68 +1,98 @@
+import is from '@adonisjs/application/helpers/is';
 import Emittery from 'emittery';
-import { moduleExpression } from '@adonisjs/fold';
+import { moduleExpression, moduleCaller, moduleImporter } from '@adonisjs/fold';
 import debug from './debug.js';
 import { EventsBuffer } from './events_buffer.js';
 export class Emitter {
+    #eventsClassSymbols = new Map();
+    #eventsListeners = new Map();
     #transport = new Emittery();
     #eventsBuffer;
     #eventsToFake = new Set();
     #errorHandler;
-    #moduleListeners = new Map();
     #app;
+    get eventsListeners() {
+        return this.#eventsListeners;
+    }
     constructor(app) {
         this.#app = app;
     }
-    #createModuleListener(importExpression) {
-        return moduleExpression(importExpression, this.#app.appRoot).toCallable(this.#app.container);
+    #getEventClassSymbol(event) {
+        if (!this.#eventsClassSymbols.has(event)) {
+            this.#eventsClassSymbols.set(event, Symbol(event.name));
+        }
+        return this.#eventsClassSymbols.get(event);
+    }
+    #resolveEvent(event) {
+        if (is.class_(event)) {
+            return this.#getEventClassSymbol(event);
+        }
+        return event;
     }
-    #getSetModuleListener(importExpression) {
-        if (!this.#moduleListeners.has(importExpression)) {
-            this.#moduleListeners.set(importExpression, this.#createModuleListener(importExpression));
+    #getEventListeners(event) {
+        if (!this.#eventsListeners.has(event)) {
+            this.#eventsListeners.set(event, new Map());
         }
-        return this.#moduleListeners.get(importExpression);
+        return this.#eventsListeners.get(event);
+    }
+    #normalizeEventListener(listener) {
+        if (typeof listener === 'string') {
+            return moduleExpression(listener, this.#app.appRoot).toCallable(this.#app.container);
+        }
+        if (Array.isArray(listener)) {
+            const listenerModule = listener[0];
+            const method = listener[1] || 'handle';
+            if (is.class_(listenerModule)) {
+                return moduleCaller(listenerModule, method).toCallable(this.#app.container);
+            }
+            return moduleImporter(listenerModule, method).toCallable(this.#app.container);
+        }
+        return listener;
+    }
+    #resolveEventListener(event, listener) {
+        const eventListeners = this.#getEventListeners(event);
+        if (!eventListeners.has(listener)) {
+            eventListeners.set(listener, this.#normalizeEventListener(listener));
+        }
+        return eventListeners.get(listener);
     }
     onError(callback) {
         this.#errorHandler = callback;
         return this;
     }
-    on(event, handler) {
-        if (typeof handler === 'string') {
-            this.#transport.on(event, this.#getSetModuleListener(handler));
-            return this;
+    on(event, listener) {
+        if (debug.enabled) {
+            debug('registering event listener, event: %O, listener: %O', event, listener);
         }
-        this.#transport.on(event, handler);
-        return this;
-    }
-    once(event, handler) {
-        if (typeof handler === 'string') {
-            const off = this.#transport.on(event, async (data) => {
-                off();
-                await this.#createModuleListener(handler)(data);
-            });
-            return this;
+        const normalizedEvent = this.#resolveEvent(event);
+        const normalizedListener = this.#resolveEventListener(event, listener);
+        this.#transport.on(normalizedEvent, normalizedListener);
+        return () => this.off(event, listener);
+    }
+    once(event, listener) {
+        if (debug.enabled) {
+            debug('registering one time event listener, event: %O, listener: %O', event, listener);
         }
-        const off = this.#transport.on(event, async (data) => {
+        const normalizedEvent = this.#resolveEvent(event);
+        const normalizedListener = this.#normalizeEventListener(listener);
+        const off = this.#transport.on(normalizedEvent, async (data) => {
             off();
-            await handler(data);
+            debug('removing one time event listener, event: %O', event);
+            await normalizedListener(data);
         });
-        return this;
     }
-    onAny(handler) {
-        if (typeof handler === 'string') {
-            this.#transport.onAny(this.#getSetModuleListener(handler));
-            return this;
-        }
-        this.#transport.onAny(handler);
-        return this;
+    onAny(listener) {
+        return this.#transport.onAny(listener);
     }
     async emit(event, data) {
         if (this.#eventsToFake.has(event) || this.#eventsToFake.has('*')) {
-            debug('faking emit. event: "%s", data: %O', event, data);
-            this.#eventsBuffer.events.push({ name: event, data });
+            debug('faking emit. event: %O, data: %O', event, data);
+            this.#eventsBuffer.add(event, data);
             return;
         }
         try {
-            await this.#transport.emit(event, data);
+            const normalizedEvent = this.#resolveEvent(event);
+            await this.#transport.emit(normalizedEvent, data);
         }
         catch (error) {
             if (this.#errorHandler) {
@@ -73,37 +103,38 @@ export class Emitter {
             }
         }
     }
-    off(event, handler) {
-        if (typeof handler === 'string') {
-            if (this.#moduleListeners.has(handler)) {
-                this.#transport.off(event, this.#moduleListeners.get(handler));
-            }
-            return this;
+    off(event, listener) {
+        if (debug.enabled) {
+            debug('removing listener, event: %O, listener: %O', event, listener);
         }
-        this.#transport.off(event, handler);
-        return this;
-    }
-    offAny(handler) {
-        if (typeof handler === 'string') {
-            if (this.#moduleListeners.has(handler)) {
-                this.#transport.offAny(this.#moduleListeners.get(handler));
-            }
-            return this;
+        const normalizedEvent = this.#resolveEvent(event);
+        const listeners = this.#getEventListeners(event);
+        const normalizedListener = listeners.get(listener);
+        if (!normalizedListener) {
+            return;
         }
-        this.#transport.offAny(handler);
+        listeners.delete(listener);
+        this.#transport.off(normalizedEvent, normalizedListener);
+    }
+    offAny(listener) {
+        this.#transport.offAny(listener);
         return this;
     }
-    clearListener(event, handler) {
-        return this.off(event, handler);
+    clearListener(event, listener) {
+        return this.off(event, listener);
     }
     clearListeners(event) {
-        this.#transport.clearListeners(event);
+        debug('clearing all listeners for event %O', event);
+        this.#transport.clearListeners(this.#resolveEvent(event));
+        this.#eventsListeners.delete(event);
     }
     clearAllListeners() {
+        debug('clearing all event listeners');
         this.#transport.clearListeners();
+        this.#eventsListeners.clear();
     }
     listenerCount(event) {
-        return this.#transport.listenerCount(event);
+        return this.#transport.listenerCount(event ? this.#resolveEvent(event) : undefined);
     }
     hasListeners(event) {
         return this.listenerCount(event) > 0;

package/build/src/events_buffer.d.ts

@@ -1,10 +1,11 @@
-import type { BufferedEventsListItem } from './types.js';
+import type { AllowedEventTypes, BufferedEvent, BufferedEventsList, Constructor } from './types.js';
 export declare class EventsBuffer<EventsList extends Record<string | symbol | number, any>> {
-    events: BufferedEventsListItem<EventsList>[];
-    all(): BufferedEventsListItem<EventsList>[];
+    #private;
+    add<Name extends AllowedEventTypes>(event: Name, data: any): void;
+    all(): BufferedEventsList<EventsList>[];
     size(): number;
-    exists(finder: keyof EventsList | ((event: BufferedEventsListItem<EventsList>) => boolean)): boolean;
-    filter(finder: keyof EventsList | ((event: BufferedEventsListItem<EventsList>) => boolean)): BufferedEventsListItem<EventsList>[];
-    find(finder: keyof EventsList | ((event: BufferedEventsListItem<EventsList>) => boolean)): BufferedEventsListItem<EventsList> | null;
+    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;
     flush(): void;
 }

package/build/src/events_buffer.js

@@ -1,27 +1,31 @@
+import is from '@adonisjs/application/helpers/is';
 export class EventsBuffer {
-    events = [];
+    #events = [];
+    add(event, data) {
+        this.#events.push({ event: event, data });
+    }
     all() {
-        return this.events;
+        return this.#events;
     }
     size() {
-        return this.events.length;
+        return this.#events.length;
     }
     exists(finder) {
         return !!this.find(finder);
     }
     filter(finder) {
-        if (typeof finder === 'function') {
-            return this.events.filter(finder);
+        if (typeof finder === 'function' && !is.class_(finder)) {
+            return this.#events.filter(finder);
         }
-        return this.events.filter((event) => event.name === finder);
+        return this.#events.filter((event) => event.event === finder);
     }
     find(finder) {
-        if (typeof finder === 'function') {
-            return this.events.find(finder) || null;
+        if (typeof finder === 'function' && !is.class_(finder)) {
+            return (this.#events.find(finder) || null);
         }
-        return this.events.find((event) => event.name === finder) || null;
+        return (this.#events.find((event) => event.event === finder) || null);
     }
     flush() {
-        this.events = [];
+        this.#events = [];
     }
 }

package/build/src/types.d.ts

@@ -1,9 +1,18 @@
-export type BufferedEventsListItem<EventsList> = {
-    [Name in keyof EventsList]: {
-        name: Name;
-        data: EventsList[Name];
-    };
-}[keyof EventsList];
-export type EventsListItem<EventsList> = {
-    [Name in keyof EventsList]: EventsList[Name];
-}[keyof EventsList];
+export type AllowedEventTypes = string | symbol | number | Constructor<any>;
+export type Constructor<T> = new (...args: any[]) => T;
+export type LazyImport<DefaultExport> = () => Promise<{
+    default: DefaultExport;
+}>;
+export type BufferedEvent<Event, Data> = {
+    event: Event;
+    data: Data;
+};
+export type BufferedEventsList<EventsList> = {
+    [Name in keyof EventsList]: BufferedEvent<Name, EventsList[Name]>;
+}[keyof EventsList] | BufferedEvent<Constructor<any>, any>;
+export type ListenerMethod<Data> = (data: Data, ...args: any[]) => any | Promise<any>;
+export type ListenerFn<Data> = (data: Data) => any | Promise<any>;
+export type GetListenersMethods<Listener extends Constructor<any>, Data> = {
+    [K in keyof InstanceType<Listener>]: InstanceType<Listener>[K] extends ListenerMethod<Data> ? K : never;
+}[keyof InstanceType<Listener>];
+export type Listener<Data, ListenerClass extends Constructor<any>> = ListenerFn<Data> | string | [LazyImport<ListenerClass> | ListenerClass, GetListenersMethods<ListenerClass, Data>?];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/events",
-  "version": "8.1.4-0",
+  "version": "8.2.0-0",
   "description": "An implementation of the event emitter built on top of emittery",
   "main": "build/index.js",
   "type": "module",
@@ -37,33 +37,33 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^6.4.0-0",
-    "@adonisjs/config": "^4.1.2-0",
-    "@adonisjs/env": "^4.1.1-0",
-    "@adonisjs/fold": "^9.8.0-0",
-    "@adonisjs/logger": "^5.1.0-0",
-    "@commitlint/cli": "^17.3.0",
-    "@commitlint/config-conventional": "^17.3.0",
+    "@adonisjs/application": "^6.5.1-0",
+    "@adonisjs/config": "^4.1.3-0",
+    "@adonisjs/env": "^4.1.2-0",
+    "@adonisjs/fold": "^9.9.0-0",
+    "@adonisjs/logger": "^5.1.1-0",
+    "@commitlint/cli": "^17.4.0",
+    "@commitlint/config-conventional": "^17.4.0",
     "@japa/assert": "^1.3.6",
     "@japa/expect-type": "^1.0.2",
     "@japa/run-failed-tests": "^1.1.0",
     "@japa/runner": "^2.2.2",
     "@japa/spec-reporter": "^1.3.2",
     "@poppinss/dev-utils": "^2.0.1",
-    "@swc/core": "^1.3.22",
+    "@swc/core": "^1.3.24",
     "@types/fs-extra": "^9.0.13",
-    "@types/node": "^18.11.15",
+    "@types/node": "^18.11.18",
     "c8": "^7.12.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
-    "eslint": "^8.29.0",
-    "eslint-config-prettier": "^8.3.0",
+    "eslint": "^8.31.0",
+    "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-adonis": "^3.0.3",
     "eslint-plugin-prettier": "^4.2.1",
     "fs-extra": "^11.1.0",
     "github-label-sync": "^2.0.1",
-    "husky": "^8.0.2",
-    "np": "^7.6.2",
+    "husky": "^8.0.3",
+    "np": "^7.6.3",
     "prettier": "^2.8.1",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.4"
@@ -72,8 +72,8 @@
     "emittery": "^1.0.1"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^6.4.0-0",
-    "@adonisjs/fold": "^9.8.0-0"
+    "@adonisjs/application": "^6.5.1-0",
+    "@adonisjs/fold": "^9.9.0-0"
   },
   "repository": {
     "type": "git",