@adonisjs/events 8.4.9-5 → 9.0.0-0

package/package.json

@@ -1,14 +1,11 @@
 {
   "name": "@adonisjs/events",
-  "version": "8.4.9-5",
+  "version": "9.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/factories",
-    "build/index.d.ts",
-    "build/index.js"
+    "build"
   ],
   "imports": {
     "#listeners/*": "./tests/app/listeners/*.js"
@@ -26,7 +23,7 @@
     "test": "cross-env NODE_DEBUG=adonisjs:events c8 npm run quick:test",
     "clean": "del-cli build",
     "typecheck": "tsc --noEmit",
-    "compile": "npm run lint && npm run clean && tsc",
+    "compile": "npm run lint && npm run clean && tsup-node",
     "build": "npm run compile",
     "release": "np",
     "version": "npm run build",
@@ -43,38 +40,39 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^7.1.2-15",
+    "@adonisjs/application": "^8.0.0-0",
     "@adonisjs/eslint-config": "^1.1.8",
-    "@adonisjs/fold": "^9.9.3-8",
+    "@adonisjs/fold": "^9.9.3-10",
     "@adonisjs/prettier-config": "^1.1.8",
     "@adonisjs/tsconfig": "^1.1.8",
-    "@commitlint/cli": "^17.7.1",
-    "@commitlint/config-conventional": "^17.7.0",
-    "@japa/assert": "^2.0.0-1",
-    "@japa/expect-type": "^2.0.0-0",
-    "@japa/file-system": "^2.0.0-1",
-    "@japa/runner": "^3.0.0-3",
-    "@swc/core": "^1.3.78",
-    "@types/node": "^20.5.3",
+    "@commitlint/cli": "^17.8.0",
+    "@commitlint/config-conventional": "^17.8.0",
+    "@japa/assert": "^2.0.0",
+    "@japa/expect-type": "^2.0.0",
+    "@japa/file-system": "^2.0.0",
+    "@japa/runner": "^3.0.2",
+    "@swc/core": "1.3.82",
+    "@types/node": "^20.8.6",
     "c8": "^8.0.1",
     "cross-env": "^7.0.3",
-    "del-cli": "^5.0.0",
-    "eslint": "^8.47.0",
+    "del-cli": "^5.1.0",
+    "eslint": "^8.51.0",
     "github-label-sync": "^2.3.1",
     "husky": "^8.0.3",
     "np": "^8.0.4",
-    "prettier": "^3.0.0",
+    "prettier": "^3.0.3",
     "ts-node": "^10.9.1",
-    "typescript": "^5.1.6"
+    "tsup": "^7.2.0",
+    "typescript": "^5.2.2"
   },
   "dependencies": {
-    "@poppinss/utils": "^6.5.0-5",
-    "@sindresorhus/is": "^6.0.0",
+    "@poppinss/utils": "^6.5.0",
+    "@sindresorhus/is": "^6.0.1",
     "emittery": "^1.0.1"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^7.1.2-15",
-    "@adonisjs/fold": "^9.9.3-8"
+    "@adonisjs/application": "^8.0.0-0",
+    "@adonisjs/fold": "^9.9.3-10"
   },
   "repository": {
     "type": "git",
@@ -111,5 +109,17 @@
   "eslintConfig": {
     "extends": "@adonisjs/eslint-config/package"
   },
-  "prettier": "@adonisjs/prettier-config"
+  "prettier": "@adonisjs/prettier-config",
+  "tsup": {
+    "entry": [
+      "./index.ts",
+      "./src/types.ts",
+      "./factories/main.ts"
+    ],
+    "outDir": "./build",
+    "clean": true,
+    "format": "esm",
+    "dts": true,
+    "target": "esnext"
+  }
 }

package/build/factories/emitter.d.ts

@@ -1,12 +0,0 @@
-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 declare class EmitterFactory {
-    /**
-     * Create emitter instance
-     */
-    create(app: Application<any>): Emitter<Record<string | number | symbol, any>>;
-}

package/build/factories/emitter.js

@@ -1,21 +0,0 @@
-/*
- * @adonisjs/events
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-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) {
-        return new Emitter(app);
-    }
-}

package/build/src/base_event.d.ts

@@ -1,21 +0,0 @@
-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 declare 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>): void;
-    /**
-     * Dispatch the current class as an event. The method takes the arguments
-     * accepted by the class constructor.
-     */
-    static dispatch<T extends typeof BaseEvent>(this: T, ...args: ConstructorParameters<T>): Promise<void>;
-}

package/build/src/base_event.js

@@ -1,36 +0,0 @@
-/*
- * @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';
-/**
- * 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(..._) { }
-    /**
-     * The emitter to use for dispatching events
-     */
-    static emitter;
-    /**
-     * Specify the emitter instance to use for dispatching events
-     */
-    static useEmitter(emitter) {
-        this.emitter = emitter;
-    }
-    /**
-     * Dispatch the current class as an event. The method takes the arguments
-     * accepted by the class constructor.
-     */
-    static async dispatch(...args) {
-        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(this, new this(...args));
-    }
-}

package/build/src/debug.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-declare const _default: import("util").DebugLogger;
-export default _default;

package/build/src/debug.js

@@ -1,10 +0,0 @@
-/*
- * @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/build/src/emitter.js

@@ -1,320 +0,0 @@
-/*
- * @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 Emittery from 'emittery';
-import { moduleExpression, moduleCaller, moduleImporter } from '@adonisjs/fold';
-import debug from './debug.js';
-import { EventsBuffer } from './events_buffer.js';
-/**
- * Event emitter is built on top of emittery with support class based
- * events and listeners
- */
-export class Emitter {
-    /**
-     * Event classes to symbols mapping. We need symbols as emittery
-     * does not support class based event names
-     */
-    #eventsClassSymbols = new Map();
-    /**
-     * A collection of events and their listeners. We do not track listeners
-     * listening for events only once
-     */
-    #eventsListeners = new Map();
-    /**
-     * Underlying transport to emit events
-     */
-    #transport = new Emittery();
-    /**
-     * Events buffer. The events are collected inside an in-memory
-     * buffer during fakes
-     */
-    #eventsBuffer;
-    /**
-     * A set of events to fake
-     */
-    #eventsToFake = new Set();
-    /**
-     * Error handler to catch all errors thrown by listeners
-     */
-    #errorHandler;
-    /**
-     * Reference to AdonisJS application, we need the application root
-     * and container reference from it.
-     */
-    #app;
-    /**
-     * 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) {
-        this.#app = app;
-    }
-    /**
-     * Returns the symbol for a class based event.
-     */
-    #getEventClassSymbol(event) {
-        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) {
-        if (is.class_(event)) {
-            return this.#getEventClassSymbol(event);
-        }
-        return event;
-    }
-    /**
-     * Returns the event listeners map
-     */
-    #getEventListeners(event) {
-        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) {
-        /**
-         * Parse string based listener
-         */
-        if (typeof listener === 'string') {
-            return moduleExpression(listener, this.#app.appRoot.toString()).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, listener) {
-        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) {
-        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, listeners) {
-        listeners.forEach((listener) => this.on(event, [listener, 'handle']));
-    }
-    on(event, listener) {
-        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);
-    }
-    once(event, listener) {
-        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) {
-        return this.#transport.onAny(listener);
-    }
-    async emit(event, data) {
-        /**
-         * 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;
-            }
-        }
-    }
-    async emitSerial(event, data) {
-        /**
-         * 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.emitSerial(normalizedEvent, data);
-        }
-        catch (error) {
-            if (this.#errorHandler) {
-                this.#errorHandler(event, error, data);
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    /**
-     * Remove a specific listener for an event
-     */
-    off(event, listener) {
-        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) {
-        this.#transport.offAny(listener);
-        return this;
-    }
-    /**
-     * Remove a specific listener for an event
-     *
-     * @alias "off"
-     */
-    clearListener(event, listener) {
-        return this.off(event, listener);
-    }
-    /**
-     * Clear all listeners for a specific event
-     */
-    clearListeners(event) {
-        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) {
-        return this.#transport.listenerCount(event ? this.#resolveEvent(event) : undefined);
-    }
-    /**
-     * Find if an event has one or more listeners
-     */
-    hasListeners(event) {
-        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) {
-        this.restore();
-        this.#eventsBuffer = new EventsBuffer();
-        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/build/src/events_buffer.d.ts

@@ -1,47 +0,0 @@
-import type { AllowedEventTypes, BufferedEvent, BufferedEventsList, Constructor } from './types.js';
-/**
- * Exposes API to filter, find events from the events buffer.
- */
-export declare class EventsBuffer<EventsList extends Record<string | symbol | number, any>> {
-    #private;
-    /**
-     * Track emitted event
-     */
-    add<Name extends AllowedEventTypes>(event: Name, data: any): void;
-    /**
-     * Get all the emitted events
-     */
-    all(): BufferedEventsList<EventsList>[];
-    /**
-     * Returns the size of captured events
-     */
-    size(): number;
-    /**
-     * Find if an event was emitted
-     */
-    exists<Event extends keyof EventsList | Constructor>(finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)): boolean;
-    /**
-     * Get selected events
-     */
-    filter(finder: keyof EventsList | Constructor | ((event: BufferedEventsList<EventsList>) => boolean)): BufferedEventsList<EventsList>[];
-    /**
-     * 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;
-    /**
-     * Assert a given event has been emitted
-     */
-    assertEmitted<Event extends keyof EventsList | Constructor>(finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)): void;
-    /**
-     * Assert a given event has been not been emitted
-     */
-    assertNotEmitted<Event extends keyof EventsList | Constructor<any>>(finder: Event | ((event: BufferedEventsList<EventsList>) => boolean)): void;
-    /**
-     * Assert a given event has been not been emitted
-     */
-    assertNoneEmitted(): void;
-    /**
-     * Flush events collected within memory
-     */
-    flush(): void;
-}