@adonisjs/events 7.2.1 → 8.0.0-0

package/README.md

@@ -1,41 +1,25 @@
-<div align="center">
-  <img src="https://res.cloudinary.com/adonisjs/image/upload/q_100/v1558612869/adonis-readme_zscycu.jpg" width="600px">
-</div>
+# @adonisjs/events
 
 <br />
 
-<div align="center">
-  <h3>AdonisJS Event Emitter</h3>
-  <p>Asynchronous Event Emitter built on top of <a href="https://github.com/sindresorhus/emittery">emittery</a> with first class for <strong>typed events</strong> and ability to <strong>trap events during tests</strong>.</p>
-</div>
+[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url] [![synk-image]][synk-url]
 
-<br />
+## 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.
 
-<div align="center">
+## Official Documentation
+The documentation is available on the [AdonisJS website](https://docs.adonisjs.com/guides/events)
 
-[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url] [![synk-image]][synk-url]
+## Contributing
+One of the primary goals of AdonisJS is to have a vibrant community of users and contributors who believes in the principles of the framework.
+
+We encourage you to read the [contribution guide](https://github.com/adonisjs/.github/blob/main/docs/CONTRIBUTING.md) before contributing to the framework.
+
+## Code of Conduct
+In order to ensure that the AdonisJS community is welcoming to all, please review and abide by the [Code of Conduct](https://github.com/adonisjs/.github/blob/main/docs/CODE_OF_CONDUCT.md).
 
-</div>
-
-<div align="center">
-  <h3>
-    <a href="https://adonisjs.com">
-      Website
-    </a>
-    <span> | </span>
-    <a href="https://docs.adonisjs.com/guides/events">
-      Guides
-    </a>
-    <span> | </span>
-    <a href="CONTRIBUTING.md">
-      Contributing
-    </a>
-  </h3>
-</div>
-
-<div align="center">
-  <sub>Built with ❤︎ by <a href="https://twitter.com/AmanVirk1">Harminder Virk</a>
-</div>
+## 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-url]: https://github.com/adonisjs/events/actions/workflows/test.yml "Github action"

package/build/index.d.ts

@@ -0,0 +1 @@
+export { Emitter } from './src/emitter.js';

package/build/index.js

@@ -0,0 +1 @@
+export { Emitter } from './src/emitter.js';

package/build/src/emitter.d.ts

@@ -0,0 +1,21 @@
+import { EventsBuffer } from './events_buffer.js';
+import type { EventsListItem } from './types.js';
+import { type Application } from '@adonisjs/application';
+export declare class Emitter<EventsList extends Record<string | symbol | number, any>> {
+    #private;
+    constructor(app: Application);
+    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;
+    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;
+    clearAllListeners(): void;
+    listenerCount<Name extends keyof EventsList>(event?: Name): number;
+    hasListeners<Name extends keyof EventsList>(event?: Name): boolean;
+    fake(events?: (keyof EventsList)[]): EventsBuffer<EventsList>;
+    restore(): void;
+}

package/build/src/emitter.js

@@ -0,0 +1,125 @@
+import Emittery from 'emittery';
+import { EventsBuffer } from './events_buffer.js';
+import { moduleExpression } from '@adonisjs/application';
+export class Emitter {
+    #transport = new Emittery();
+    #eventsBuffer;
+    #eventsToFake = new Set();
+    #errorHandler;
+    #moduleListeners = new Map();
+    #app;
+    constructor(app) {
+        this.#app = app;
+    }
+    #createModuleListener(importExpression) {
+        return moduleExpression(importExpression, this.#app.appRoot).toCallable(this.#app.container);
+    }
+    #getSetModuleListener(importExpression) {
+        if (!this.#moduleListeners.has(importExpression)) {
+            this.#moduleListeners.set(importExpression, this.#createModuleListener(importExpression));
+        }
+        return this.#moduleListeners.get(importExpression);
+    }
+    onError(callback) {
+        this.#errorHandler = callback;
+        return this;
+    }
+    on(event, handler) {
+        if (typeof handler === 'string') {
+            this.#transport.on(event, this.#getSetModuleListener(handler));
+            return this;
+        }
+        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 off = this.#transport.on(event, async (data) => {
+            off();
+            await handler(data);
+        });
+        return this;
+    }
+    onAny(handler) {
+        if (typeof handler === 'string') {
+            this.#transport.onAny(this.#getSetModuleListener(handler));
+            return this;
+        }
+        this.#transport.onAny(handler);
+        return this;
+    }
+    async emit(event, data) {
+        if (this.#eventsToFake.has(event) || this.#eventsToFake.has('*')) {
+            this.#eventsBuffer.events.push({ name: event, data });
+            return;
+        }
+        try {
+            await this.#transport.emit(event, data);
+        }
+        catch (error) {
+            if (this.#errorHandler) {
+                this.#errorHandler(event, error, data);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    off(event, handler) {
+        if (typeof handler === 'string') {
+            if (this.#moduleListeners.has(handler)) {
+                this.#transport.off(event, this.#moduleListeners.get(handler));
+            }
+            return this;
+        }
+        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;
+        }
+        this.#transport.offAny(handler);
+        return this;
+    }
+    clearListener(event, handler) {
+        return this.off(event, handler);
+    }
+    clearListeners(event) {
+        this.#transport.clearListeners(event);
+    }
+    clearAllListeners() {
+        this.#transport.clearListeners();
+    }
+    listenerCount(event) {
+        return this.#transport.listenerCount(event);
+    }
+    hasListeners(event) {
+        return this.listenerCount(event) > 0;
+    }
+    fake(events) {
+        this.restore();
+        this.#eventsBuffer = new EventsBuffer();
+        if (!events) {
+            this.#eventsToFake.add('*');
+        }
+        else {
+            events.forEach((event) => this.#eventsToFake.add(event));
+        }
+        return this.#eventsBuffer;
+    }
+    restore() {
+        this.#eventsToFake.clear();
+        this.#eventsBuffer?.flush();
+        this.#eventsBuffer = undefined;
+    }
+}

package/build/src/events_buffer.d.ts

@@ -0,0 +1,10 @@
+import type { BufferedEventsListItem } from './types.js';
+export declare class EventsBuffer<EventsList extends Record<string | symbol | number, any>> {
+    events: BufferedEventsListItem<EventsList>[];
+    all(): BufferedEventsListItem<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;
+    flush(): void;
+}

package/build/src/events_buffer.js

@@ -0,0 +1,27 @@
+export class EventsBuffer {
+    events = [];
+    all() {
+        return this.events;
+    }
+    size() {
+        return this.events.length;
+    }
+    exists(finder) {
+        return !!this.find(finder);
+    }
+    filter(finder) {
+        if (typeof finder === 'function') {
+            return this.events.filter(finder);
+        }
+        return this.events.filter((event) => event.name === finder);
+    }
+    find(finder) {
+        if (typeof finder === 'function') {
+            return this.events.find(finder) || null;
+        }
+        return this.events.find((event) => event.name === finder) || null;
+    }
+    flush() {
+        this.events = [];
+    }
+}

package/build/src/types.d.ts

@@ -0,0 +1,9 @@
+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];

package/build/src/types.js

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

package/package.json

@@ -1,29 +1,34 @@
 {
   "name": "@adonisjs/events",
-  "version": "7.2.1",
-  "description": "Event emitter with asynchronous events",
-  "main": "build/providers/EventProvider.js",
+  "version": "8.0.0-0",
+  "description": "An implementation of the event emitter built on top of emittery",
+  "main": "build/index.js",
+  "type": "module",
   "files": [
     "build/src",
-    "build/providers",
-    "build/adonis-typings",
-    "build/standalone.d.ts",
-    "build/standalone.js"
+    "build/index.d.ts",
+    "build/index.js"
   ],
+  "imports": {
+    "#listeners/*": "./tests/app/listeners/*.js"
+  },
+  "exports": {
+    ".": "./build/index.js",
+    "./types": "./build/src/types.js"
+  },
   "scripts": {
-    "mrm": "mrm --preset=@adonisjs/mrm-preset",
     "pretest": "npm run lint",
-    "test": "node -r @adonisjs/require-ts/build/register bin/test.ts",
+    "test": "c8 npm run vscode:test",
     "clean": "del-cli build",
     "compile": "npm run lint && npm run clean && tsc",
     "build": "npm run compile",
-    "commit": "git-cz",
-    "release": "np --message=\"chore(release): %s\"",
+    "release": "np",
     "version": "npm run build",
     "format": "prettier --write .",
     "prepublishOnly": "npm run build",
     "lint": "eslint . --ext=.ts",
-    "sync-labels": "github-label-sync --labels ./node_modules/@adonisjs/mrm-preset/gh-labels.json adonisjs/events"
+    "sync-labels": "github-label-sync --labels .github/labels.json adonisjs/events",
+    "vscode:test": "node --loader=ts-node/esm --experimental-import-meta-resolve bin/test.ts"
   },
   "keywords": [
     "emitter",
@@ -32,55 +37,37 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^5.1.5",
-    "@adonisjs/mrm-preset": "^5.0.2",
-    "@adonisjs/require-ts": "^2.0.7",
-    "@japa/assert": "^1.2.3",
-    "@japa/run-failed-tests": "^1.0.3",
-    "@japa/runner": "^2.0.6",
-    "@japa/spec-reporter": "^1.1.7",
+    "@adonisjs/application": "^6.0.3-0",
+    "@commitlint/cli": "^17.2.0",
+    "@commitlint/config-conventional": "^17.2.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",
-    "@types/node": "^17.0.8",
-    "commitizen": "^4.2.4",
-    "cz-conventional-changelog": "^3.3.0",
-    "del-cli": "^4.0.1",
-    "eslint": "^8.7.0",
+    "@swc/core": "^1.3.18",
+    "@types/fs-extra": "^9.0.13",
+    "@types/node": "^18.11.9",
+    "c8": "^7.12.0",
+    "del-cli": "^5.0.0",
+    "eslint": "^8.28.0",
     "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-adonis": "^2.1.0",
-    "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-adonis": "^3.0.3",
+    "eslint-plugin-prettier": "^4.2.1",
+    "fs-extra": "^10.1.0",
     "github-label-sync": "^2.0.1",
-    "husky": "^7.0.1",
-    "mrm": "^4.0.0",
-    "np": "^7.5.0",
-    "prettier": "^2.3.2",
-    "typescript": "^4.3.5"
-  },
-  "nyc": {
-    "exclude": [
-      "test"
-    ],
-    "extension": [
-      ".ts"
-    ]
-  },
-  "config": {
-    "commitizen": {
-      "path": "cz-conventional-changelog"
-    }
-  },
-  "np": {
-    "contents": ".",
-    "anyBranch": false
+    "husky": "^8.0.2",
+    "np": "^7.6.2",
+    "prettier": "^2.7.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.3"
   },
   "dependencies": {
-    "emittery": "^0.10.0"
+    "emittery": "^1.0.1"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^5.0.0"
-  },
-  "directories": {
-    "doc": "docs",
-    "test": "test"
+    "@adonisjs/application": "^6.0.1-0"
   },
   "repository": {
     "type": "git",
@@ -90,23 +77,6 @@
     "url": "https://github.com/adonisjs/events/issues"
   },
   "homepage": "https://github.com/adonisjs/events#readme",
-  "publishConfig": {
-    "access": "public",
-    "tag": "latest"
-  },
-  "mrmConfig": {
-    "core": true,
-    "license": "MIT",
-    "services": [
-      "github-actions"
-    ],
-    "minNodeVersion": "14.15.4",
-    "probotApps": [
-      "stale",
-      "lock"
-    ],
-    "runGhActionsOnWindows": false
-  },
   "eslintConfig": {
     "extends": [
       "plugin:adonis/typescriptPackage",
@@ -136,5 +106,29 @@
     "bracketSpacing": true,
     "arrowParens": "always",
     "printWidth": 100
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "np": {
+    "message": "chore(release): %s",
+    "tag": "next",
+    "branch": "main",
+    "anyBranch": false
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html"
+    ],
+    "exclude": [
+      "tests/**"
+    ]
   }
 }

package/build/adonis-typings/container.d.ts

@@ -1,6 +0,0 @@
-declare module '@ioc:Adonis/Core/Application' {
-    import { EmitterContract } from '@ioc:Adonis/Core/Event';
-    interface ContainerBindings {
-        'Adonis/Core/Event': EmitterContract;
-    }
-}

package/build/adonis-typings/container.js

@@ -1,8 +0,0 @@
-/*
- * @adonisjs/events
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */

package/build/adonis-typings/events.d.ts

@@ -1,207 +0,0 @@
-declare module '@ioc:Adonis/Core/Event' {
-    /**
-     * Returns the data type for a given key
-     */
-    export type DataForEvent<K extends string> = K extends keyof EventsList ? EventsList[K] : any;
-    /**
-     * Shape of event handler
-     */
-    export type EventHandler<T extends any = any> = (data: T) => Promise<void> | void;
-    /**
-     * Shape of catch all events handler
-     */
-    export type AnyHandler = (event: keyof EventsList, data: {
-        [P in keyof EventsList]: EventsList[P];
-    }[keyof EventsList]) => Promise<void> | void;
-    /**
-     * Shape of event trap handler
-     */
-    export type TrapHandler<T extends any = any> = EventHandler<T>;
-    /**
-     * The error handler for handling events when an emit call fails
-     */
-    export type ErrorHandler = (event: string, error: any, data: any) => void;
-    /**
-     * Shape of trap all events handler
-     */
-    export type TrapAllHandler = AnyHandler;
-    /**
-     * The shape of emitter transport. This has to be same as
-     * `emittery`.
-     */
-    export interface EmitterTransportContract {
-        on(event: string, handler: EventHandler): any;
-        once(event: string): Promise<any>;
-        onAny(handler: (event: any, data: any) => Promise<void> | void): any;
-        emit(event: string, data: any): Promise<any>;
-        off(event: string, handler: EventHandler): any;
-        offAny(handler: (event: any, data: any) => Promise<void> | void): any;
-        off(event: string, handler: EventHandler): any;
-        clearListeners(event?: string): any;
-        listenerCount(event?: string): number;
-    }
-    /**
-     * Fake emitter to be used for finding and asserting
-     * faked events
-     */
-    export interface FakeEmitterContract {
-        /**
-         * Returns all the emitted events
-         */
-        all(): {
-            name: string;
-            data: any;
-        }[];
-        /**
-         * Find if the event exists
-         */
-        exists<K extends keyof EventsList>(event: K): boolean;
-        exists(event: string): boolean;
-        exists<Events extends Record<string, any> = EventsList>(matchCallback: (event: {
-            [K in keyof Events]: {
-                name: K;
-                data: Events[K];
-            };
-        }[keyof Events]) => boolean): boolean;
-        /**
-         * Find an event
-         */
-        find<K extends keyof EventsList>(event: K): {
-            name: K;
-            data: DataForEvent<K>;
-        } | null;
-        find(event: string): {
-            name: string;
-            data: any;
-        };
-        find<Events extends Record<string, any> = EventsList>(matchCallback: (event: {
-            [K in keyof Events]: {
-                name: K;
-                data: Events[K];
-            };
-        }[keyof Events]) => boolean): {
-            [K in keyof Events]: {
-                name: K;
-                data: Events[K];
-            };
-        }[keyof Events] | null;
-        /**
-         * Find multiple events
-         */
-        filter<K extends keyof EventsList>(event: K): {
-            name: K;
-            data: DataForEvent<K>;
-        }[];
-        filter(event: string): {
-            name: string;
-            data: any;
-        }[];
-        filter<Events extends Record<string, any> = EventsList>(matchCallback: (event: {
-            [K in keyof Events]: {
-                name: K;
-                data: Events[K];
-            };
-        }[keyof Events]) => boolean): {
-            [K in keyof Events]: {
-                name: K;
-                data: Events[K];
-            };
-        }[keyof Events][];
-        /**
-         * Get number of events emitted
-         */
-        size(): number;
-    }
-    /**
-     * Shape of Event emitter
-     */
-    export interface EmitterContract {
-        transport: EmitterTransportContract;
-        /**
-         * Fake the upcoming events
-         */
-        fake<K extends keyof EventsList>(events?: K[] | string[]): FakeEmitterContract;
-        /**
-         * Define a custom error handler
-         */
-        onError(handler: ErrorHandler): this;
-        /**
-         * Define a custom IoC Container base namespace for resolving
-         * the listener bindings.
-         */
-        namespace(namespace: string): this;
-        /**
-         * Listen for an event
-         */
-        on<K extends keyof EventsList>(event: K, handler: EventHandler<EventsList[K]> | string): this;
-        on<K extends string>(event: K, handler: EventHandler<DataForEvent<K>> | string): this;
-        /**
-         * Listen for an event only once
-         */
-        once<K extends keyof EventsList>(event: K, handler: EventHandler<EventsList[K]> | string): this;
-        once<K extends string>(event: K, handler: EventHandler<DataForEvent<K>> | string): this;
-        /**
-         * Listen for all events
-         */
-        onAny(handler: AnyHandler | string): this;
-        /**
-         * Emit an event
-         */
-        emit<K extends keyof EventsList>(event: K, data: EventsList[K]): Promise<void>;
-        emit<K extends string>(event: K, data: DataForEvent<K>): Promise<void>;
-        /**
-         * Remove event listener
-         */
-        off<K extends keyof EventsList>(event: K, handler: EventHandler | string): void;
-        off<K extends string>(event: K, handler: EventHandler | string): void;
-        /**
-         * Remove event listener listening for all events
-         */
-        offAny(handler: AnyHandler | string): void;
-        /**
-         * Clear a given listener for a given event
-         */
-        clearListener<K extends keyof EventsList>(event: K, handler: EventHandler | string): void;
-        clearListener<K extends string>(event: K, handler: EventHandler | string): void;
-        /**
-         * Clear all listeners for a given event
-         */
-        clearListeners<K extends keyof EventsList>(event: K): void;
-        clearListeners<K extends string>(event: K): void;
-        /**
-         * Clear all listeners for all events
-         */
-        clearAllListeners(): void;
-        /**
-         * Returns count of listeners listening for a given event
-         */
-        listenerCount<K extends keyof EventsList>(event?: K): number;
-        listenerCount<K extends string>(event?: K): number;
-        /**
-         * Returns true when an event has one or more listeners
-         */
-        hasListeners<K extends keyof EventsList>(event?: K): boolean;
-        hasListeners<K extends string>(event?: K): boolean;
-        /**
-         * Trap a specific event. The event listener won't be executed during
-         * the trap. Call [[this.restore]] to remove traps
-         */
-        trap<K extends keyof EventsList>(event: K, handler: TrapHandler<EventsList[K]>): this;
-        trap<K extends string>(event: K, handler: TrapHandler<DataForEvent<K>>): this;
-        /**
-         * Trap all the events, which are not trapped using the [[this.trap]] method
-         */
-        trapAll(handler: AnyHandler): this;
-        /**
-         * Restore traps
-         */
-        restore(): void;
-    }
-    /**
-     * An interface to define typed events
-     */
-    export interface EventsList {
-    }
-    const Event: EmitterContract;
-    export default Event;
-}

package/build/adonis-typings/events.js

@@ -1,8 +0,0 @@
-/*
- * @adonisjs/events
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */