@adonisjs/events 10.1.0-next.1 → 10.1.0-next.3

package/build/emitter-Bpdlo50r.js

@@ -0,0 +1,250 @@
+import "node:module";
+import is from "@sindresorhus/is";
+import Emittery from "emittery";
+import { moduleCaller, moduleImporter } from "@adonisjs/fold";
+import { debuglog } from "node:util";
+import string from "@poppinss/utils/string";
+import { AssertionError } from "node:assert";
+import diagnostics_channel from "node:diagnostics_channel";
+var __defProp = Object.defineProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var debug_default = debuglog("adonisjs:events");
+var EventsBuffer = class {
+	#events = [];
+	add(event, data) {
+		this.#events.push({
+			event,
+			data
+		});
+	}
+	all() {
+		return this.#events;
+	}
+	size() {
+		return this.#events.length;
+	}
+	exists(event, finder) {
+		return !!this.find(event, finder);
+	}
+	find(event, finder) {
+		return this.#events.find((bufferedEvent) => {
+			if (!finder) return bufferedEvent.event === event;
+			return bufferedEvent.event === event && finder(bufferedEvent);
+		}) || null;
+	}
+	assertEmitted(event, finder) {
+		if (!this.exists(event, finder)) throw new AssertionError({
+			message: is.class(event) ? `Expected "[class ${event.name}]" event to be emitted` : `Expected "${String(event)}" event to be emitted`,
+			expected: true,
+			actual: false,
+			operator: "strictEqual",
+			stackStartFn: this.assertEmitted
+		});
+	}
+	assertEmittedCount(event, count) {
+		const actual = this.all().filter((bufferedEvent) => bufferedEvent.event === event).length;
+		if (actual !== count) throw new AssertionError({
+			message: `Expected "${is.class(event) ? `[class ${event.name}]` : String(event)}" event to be emitted "${count}" ${string.pluralize("time", count)}, instead it was emitted "${actual}" ${string.pluralize("time", actual)}`,
+			actual,
+			expected: count
+		});
+	}
+	assertNotEmitted(event, finder) {
+		if (this.exists(event, finder)) throw new AssertionError({
+			message: is.class(event) ? `Unexpected "[class ${event.name}]" event was emitted` : `Unexpected "${String(event)}" event was emitted`,
+			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}" ${string.pluralize("event", eventsSize)}`,
+			expected: 0,
+			actual: eventsSize,
+			operator: "strictEqual",
+			stackStartFn: this.assertNoneEmitted
+		}, { showDiff: true }));
+	}
+	flush() {
+		this.#events = [];
+	}
+};
+var tracing_channels_exports = /* @__PURE__ */ __export({ eventDispatch: () => eventDispatch });
+const eventDispatch = diagnostics_channel.tracingChannel("adonisjs.event.dispatch");
+var Emitter = class {
+	#eventsClassSymbols = /* @__PURE__ */ new Map();
+	#eventsListeners = /* @__PURE__ */ new Map();
+	#transport = new Emittery();
+	#eventsBuffer;
+	#eventsToFake = /* @__PURE__ */ new Set();
+	#errorHandler;
+	#app;
+	get eventsListeners() {
+		return this.#eventsListeners;
+	}
+	constructor(app) {
+		this.#app = app;
+	}
+	#isConstructor(value) {
+		return is.class(value);
+	}
+	#getEventClassSymbol(event) {
+		if (!this.#eventsClassSymbols.has(event)) this.#eventsClassSymbols.set(event, Symbol(event.name));
+		return this.#eventsClassSymbols.get(event);
+	}
+	#resolveEvent(event) {
+		if (this.#isConstructor(event)) return this.#getEventClassSymbol(event);
+		return event;
+	}
+	#getEventListeners(event) {
+		if (!this.#eventsListeners.has(event)) this.#eventsListeners.set(event, /* @__PURE__ */ new Map());
+		return this.#eventsListeners.get(event);
+	}
+	#normalizeEventListener(listener) {
+		if (typeof listener === "string") {
+			const parts = listener.split(".");
+			const method = parts.length === 1 ? "handle" : parts.pop();
+			const moduleRefId = parts.join(".");
+			return moduleImporter(() => this.#app.import(moduleRefId), method).toCallable(this.#app.container);
+		}
+		if (Array.isArray(listener)) {
+			const listenerModule = listener[0];
+			const method = listener[1] || "handle";
+			if (this.#isConstructor(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;
+	}
+	listen(event, listeners) {
+		listeners.forEach((listener) => this.on(event, [listener, "handle"]));
+	}
+	on(event, listener) {
+		if (debug_default.enabled) debug_default("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);
+	}
+	listenIf(condition, event, listener) {
+		if (!condition || typeof condition === "function" && !condition()) return () => {};
+		return this.on(event, listener);
+	}
+	once(event, listener) {
+		if (debug_default.enabled) debug_default("registering one time event listener, event: %O, listener: %O", event, listener);
+		const normalizedEvent = this.#resolveEvent(event);
+		const normalizedListener = this.#normalizeEventListener(listener);
+		const off = this.#transport.on(normalizedEvent, async (data) => {
+			off();
+			debug_default("removing one time event listener, event: %O", event);
+			await normalizedListener(data);
+		});
+	}
+	onAny(listener) {
+		return this.#transport.onAny(listener);
+	}
+	async emit(event, data) {
+		if (this.#eventsToFake.has(event) || this.#eventsToFake.has("*")) {
+			debug_default("faking emit. event: %O, data: %O", event, data);
+			this.#eventsBuffer.add(event, data);
+			return;
+		}
+		try {
+			const normalizedEvent = this.#resolveEvent(event);
+			await eventDispatch.tracePromise(this.#transport.emit, eventDispatch.hasSubscribers ? {
+				event,
+				data
+			} : void 0, this.#transport, normalizedEvent, data);
+		} catch (error) {
+			if (this.#errorHandler) this.#errorHandler(event, error, data);
+			else throw error;
+		}
+	}
+	async emitSerial(event, data) {
+		if (this.#eventsToFake.has(event) || this.#eventsToFake.has("*")) {
+			debug_default("faking emit. event: %O, data: %O", event, data);
+			this.#eventsBuffer.add(event, data);
+			return;
+		}
+		try {
+			const normalizedEvent = this.#resolveEvent(event);
+			await eventDispatch.tracePromise(this.#transport.emitSerial, eventDispatch.hasSubscribers ? {
+				event,
+				data
+			} : void 0, this.#transport, normalizedEvent, data);
+		} catch (error) {
+			if (this.#errorHandler) this.#errorHandler(event, error, data);
+			else throw error;
+		}
+	}
+	off(event, listener) {
+		if (debug_default.enabled) debug_default("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);
+	}
+	offAny(listener) {
+		this.#transport.offAny(listener);
+		return this;
+	}
+	clearListener(event, listener) {
+		return this.off(event, listener);
+	}
+	clearListeners(event) {
+		debug_default("clearing all listeners for event %O", event);
+		this.#transport.clearListeners(this.#resolveEvent(event));
+		this.#eventsListeners.delete(event);
+	}
+	clearAllListeners() {
+		debug_default("clearing all event listeners");
+		this.#transport.clearListeners();
+		this.#eventsListeners.clear();
+	}
+	listenerCount(event) {
+		return this.#transport.listenerCount(event ? this.#resolveEvent(event) : void 0);
+	}
+	hasListeners(event) {
+		return this.listenerCount(event) > 0;
+	}
+	fake(events) {
+		this.restore();
+		this.#eventsBuffer = new EventsBuffer();
+		if (!events) {
+			debug_default("faking all events");
+			this.#eventsToFake.add("*");
+		} else {
+			debug_default("faking events: %O", events);
+			events.forEach((event) => this.#eventsToFake.add(event));
+		}
+		return this.#eventsBuffer;
+	}
+	restore() {
+		debug_default("restoring existing fakes");
+		this.#eventsToFake.clear();
+		this.#eventsBuffer?.flush();
+		this.#eventsBuffer = void 0;
+	}
+};
+export { tracing_channels_exports as n, Emitter as t };

package/build/factories/emitter.d.ts

@@ -1,5 +1,5 @@
 import type { Application } from '@adonisjs/application';
-import { Emitter } from '../src/emitter.js';
+import { Emitter } from '../src/emitter.ts';
 /**
  * Emitter factory is used to create an instance of emitter
  * for testing

package/build/factories/main.d.ts

@@ -1 +1 @@
-export { EmitterFactory } from './emitter.js';
+export { EmitterFactory } from './emitter.ts';

package/build/factories/main.js

@@ -1,16 +1,7 @@
-import {
-  Emitter
-} from "../chunk-X4QBBFBR.js";
-
-// factories/emitter.ts
+import { t as Emitter } from "../emitter-Bpdlo50r.js";
 var EmitterFactory = class {
-  /**
-   * Create emitter instance
-   */
-  create(app) {
-    return new Emitter(app);
-  }
-};
-export {
-  EmitterFactory
+	create(app) {
+		return new Emitter(app);
+	}
 };
+export { EmitterFactory };

package/build/index.d.ts

@@ -1,3 +1,3 @@
-export { Emitter } from './src/emitter.js';
-export { BaseEvent } from './src/base_event.js';
+export { Emitter } from './src/emitter.ts';
+export { BaseEvent } from './src/base_event.ts';
 export * as tracingChannels from './src/tracing_channels.ts';

package/build/index.js

@@ -1,38 +1,14 @@
-import {
-  Emitter,
-  tracing_channels_exports
-} from "./chunk-X4QBBFBR.js";
-
-// src/base_event.ts
+import { n as tracing_channels_exports, t as Emitter } from "./emitter-Bpdlo50r.js";
 import { RuntimeException } from "@poppinss/utils/exception";
 var BaseEvent = class {
-  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));
-  }
-};
-export {
-  BaseEvent,
-  Emitter,
-  tracing_channels_exports as tracingChannels
+	constructor(..._) {}
+	static emitter;
+	static useEmitter(emitter) {
+		this.emitter = emitter;
+	}
+	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));
+	}
 };
+export { BaseEvent, Emitter, tracing_channels_exports as tracingChannels };

package/build/src/base_event.d.ts

@@ -1,9 +1,14 @@
-import type { Emitter } from './emitter.js';
+import type { Emitter } from './emitter.ts';
 /**
  * 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 {
+    /**
+     * Base event constructor
+     *
+     * @param _ - Any constructor arguments (unused)
+     */
     constructor(..._: any[]);
     /**
      * The emitter to use for dispatching events
@@ -11,11 +16,16 @@ export declare class BaseEvent {
     static emitter?: Emitter<any>;
     /**
      * Specify the emitter instance to use for dispatching events
+     *
+     * @param emitter - The emitter instance to use
      */
     static useEmitter(emitter: Emitter<any>): void;
     /**
      * Dispatch the current class as an event. The method takes the arguments
      * accepted by the class constructor.
+     *
+     * @param args - Constructor arguments for the event instance
+     * @throws RuntimeException if no emitter is configured
      */
     static dispatch<T extends typeof BaseEvent>(this: T, ...args: ConstructorParameters<T>): Promise<void>;
 }

package/build/src/debug.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("util").DebugLogger;
+declare const _default: import("node:util").DebugLogger;
 export default _default;

package/build/src/emitter.d.ts

@@ -1,8 +1,8 @@
 import type { Application } from '@adonisjs/application';
 import { type UnsubscribeFunction } from 'emittery';
 import { type LazyImport, type Constructor } from '@poppinss/utils/types';
-import { EventsBuffer } from './events_buffer.js';
-import type { Listener, EmitterLike, ListenerMethod, AllowedEventTypes, ListenerClassWithHandleMethod } from './types.js';
+import { EventsBuffer } from './events_buffer.ts';
+import type { Listener, EmitterLike, ListenerMethod, AllowedEventTypes, ListenerClassWithHandleMethod } from './types.ts';
 /**
  * Event emitter is built on top of emittery with support class based
  * events and listeners
@@ -16,37 +16,65 @@ export declare class Emitter<EventsList extends Record<string | symbol | number,
      *
      * The listeners map key is the original binding listener
      * and the value is a callback function.
+     *
+     * @returns The events listeners map
      */
     get eventsListeners(): Map<AllowedEventTypes, Map<Listener<any, Constructor<any>>, ListenerMethod<any>>>;
+    /**
+     * Creates a new Emitter instance
+     *
+     * @param app - The AdonisJS application instance
+     */
     constructor(app: Application<any>);
     /**
      * Register a global error handler
+     *
+     * @param callback - The error handler callback
+     * @returns The emitter instance for method chaining
      */
     onError(callback: (event: keyof EventsList | Constructor<any>, error: any, data: any) => void): 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.
+     *
+     * @param event - The event class to listen for
+     * @param listeners - Array of listener classes with handle methods
      */
     listen<Event extends Constructor<any>>(event: Event, listeners: (ListenerClassWithHandleMethod<InstanceType<Event>> | LazyImport<ListenerClassWithHandleMethod<InstanceType<Event>>>)[]): void;
     /**
      * Listen for an event. The method returns the unsubscribe function.
+     *
+     * @param event - The event to listen for
+     * @param listener - The listener to register
+     * @returns The unsubscribe function
      */
     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;
     /**
      * Listen for an event depending on a condition
+     *
+     * @param condition - The condition to check before listening
+     * @param event - The event to listen for
+     * @param listener - The listener to register
+     * @returns The unsubscribe function
      */
     listenIf<Event extends Constructor<any>, ListenerClass extends Constructor<any>>(condition: boolean | (() => boolean), event: Event, listener: Listener<InstanceType<Event>, ListenerClass>): UnsubscribeFunction;
     listenIf<Name extends keyof EventsList, ListenerClass extends Constructor<any>>(condition: boolean | (() => boolean), event: Name, listener: Listener<EventsList[Name], ListenerClass>): UnsubscribeFunction;
     /**
      * Listen for an event only once
+     *
+     * @param event - The event to listen for
+     * @param listener - The listener to register
      */
     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;
     /**
      * Attach a listener to listen for all the events. Wildcard listeners
      * can only be defined as inline callbacks.
+     *
+     * @param listener - The wildcard listener callback
+     * @returns The unsubscribe function
      */
     onAny(listener: (event: AllowedEventTypes, data: any) => any | Promise<any>): UnsubscribeFunction;
     /**
@@ -54,6 +82,9 @@ export declare class Emitter<EventsList extends Record<string | symbol | number,
      * in parallel.
      *
      * You can await this method to wait for events listeners to finish
+     *
+     * @param event - The event to emit
+     * @param data - The data to pass to listeners
      */
     emit<Event extends Constructor<any>>(event: Event, data: InstanceType<Event>): Promise<void>;
     emit<Name extends keyof EventsList>(event: Name, data: EventsList[Name]): Promise<void>;
@@ -62,25 +93,37 @@ export declare class Emitter<EventsList extends Record<string | symbol | number,
      * in the same sequence as they are registered.
      *
      * You can await this method to wait for events listeners to finish
+     *
+     * @param event - The event to emit
+     * @param data - The data to pass to listeners
      */
     emitSerial<Event extends Constructor<any>>(event: Event, data: InstanceType<Event>): Promise<void>;
     emitSerial<Name extends keyof EventsList>(event: Name, data: EventsList[Name]): Promise<void>;
     /**
      * Remove a specific listener for an event
+     *
+     * @param event - The event to remove listener from
+     * @param listener - The listener to remove
      */
     off(event: keyof EventsList | Constructor<any>, listener: Listener<any, Constructor<any>>): void;
     /**
      * Remove a specific listener listening for all the events
+     *
+     * @param listener - The wildcard listener to remove
+     * @returns The emitter instance for method chaining
      */
     offAny(listener: (event: keyof EventsList | Constructor<any>, data: any) => any | Promise<any>): this;
     /**
      * Remove a specific listener for an event
      *
-     * @alias "off"
+     * @param event - The event to remove listener from
+     * @param listener - The listener to remove
      */
     clearListener(event: keyof EventsList | Constructor<any>, listener: Listener<any, Constructor<any>>): void;
     /**
      * Clear all listeners for a specific event
+     *
+     * @param event - The event to clear listeners for
      */
     clearListeners(event: keyof EventsList | Constructor<any>): void;
     /**
@@ -89,10 +132,16 @@ export declare class Emitter<EventsList extends Record<string | symbol | number,
     clearAllListeners(): void;
     /**
      * Get count of listeners for a given event or all the events
+     *
+     * @param event - The event to count listeners for (optional)
+     * @returns The number of listeners
      */
     listenerCount(event?: keyof EventsList | Constructor<any>): number;
     /**
      * Find if an event has one or more listeners
+     *
+     * @param event - The event to check listeners for (optional)
+     * @returns True if the event has listeners
      */
     hasListeners(event?: keyof EventsList | Constructor<any>): boolean;
     /**
@@ -104,6 +153,9 @@ export declare class Emitter<EventsList extends Record<string | symbol | number,
      *
      * Calling this method one than once drops the existing fakes and
      * creates new one.
+     *
+     * @param events - Array of events to fake (optional, defaults to all events)
+     * @returns The events buffer for assertions
      */
     fake(events?: (keyof EventsList | Constructor<any>)[]): EventsBuffer<EventsList>;
     /**

package/build/src/events_buffer.d.ts

@@ -1,5 +1,5 @@
 import { type Constructor } from '@poppinss/utils/types';
-import type { AllowedEventTypes, BufferedEvent, BufferedEventsList } from './types.js';
+import type { AllowedEventTypes, BufferedEvent, BufferedEventsList } from './types.ts';
 /**
  * Callback function to narrow down an event from
  * the events buffer list
@@ -12,38 +12,67 @@ export declare class EventsBuffer<EventsList extends Record<string | symbol | nu
     #private;
     /**
      * Track emitted event
+     *
+     * @param event - The event that was emitted
+     * @param data - The data passed with the event
      */
     add<Name extends AllowedEventTypes>(event: Name, data: any): void;
     /**
      * Get all the emitted events
+     *
+     * @returns Array of all buffered events
      */
     all(): BufferedEventsList<EventsList>[];
     /**
      * Returns the size of captured events
+     *
+     * @returns The number of captured events
      */
     size(): number;
     /**
      * Find if an event was emitted
+     *
+     * @param event - The event to check for
+     * @param finder - Optional callback to filter specific event instances
+     * @returns True if the event was emitted
      */
     exists<Event extends keyof EventsList | Constructor<any>>(event: Event, finder?: EventFinderCallback<EventsList, Event>): boolean;
     /**
      * Find a specific event
+     *
+     * @param event - The event to find
+     * @param finder - Optional callback to filter specific event instances
+     * @returns The found event or null
      */
     find<Event extends keyof EventsList | Constructor<any>>(event: Event, finder?: EventFinderCallback<EventsList, Event>): (Event extends keyof EventsList ? BufferedEvent<Event, EventsList[Event]> : Event extends Constructor<infer A> ? BufferedEvent<Event, A> : never) | null;
     /**
      * Assert a given event has been emitted
+     *
+     * @param event - The event to assert was emitted
+     * @param finder - Optional callback to filter specific event instances
+     * @throws AssertionError if the event was not emitted
      */
     assertEmitted<Event extends keyof EventsList | Constructor<any>>(event: Event, finder?: EventFinderCallback<EventsList, Event>): void;
     /**
      * Assert number of times an event has been emitted
+     *
+     * @param event - The event to check emission count for
+     * @param count - The expected number of emissions
+     * @throws AssertionError if the count doesn't match
      */
     assertEmittedCount<Event extends keyof EventsList | Constructor<any>>(event: Event, count: number): void;
     /**
      * Assert a given event has been not been emitted
+     *
+     * @param event - The event to assert was not emitted
+     * @param finder - Optional callback to filter specific event instances
+     * @throws AssertionError if the event was emitted
      */
     assertNotEmitted<Event extends keyof EventsList | Constructor<any>>(event: Event, finder?: EventFinderCallback<EventsList, Event>): void;
     /**
-     * Assert a given event has been not been emitted
+     * Assert no events have been emitted
+     *
+     * @throws AssertionError if any events were emitted
      */
     assertNoneEmitted(): void;
     /**

package/build/src/tracing_channels.d.ts

@@ -3,4 +3,4 @@ import { type EventDispatchData } from './types.ts';
 /**
  * Traces event.emit method calls
  */
-export declare const eventDispatch: diagnostics_channel.TracingChannel<"adonisjs:event.dispatch", EventDispatchData>;
+export declare const eventDispatch: diagnostics_channel.TracingChannel<"adonisjs.event.dispatch", EventDispatchData>;

package/build/src/types.d.ts

@@ -5,13 +5,18 @@ import { type LazyImport, type Constructor } from '@poppinss/utils/types';
 export type AllowedEventTypes = string | symbol | number | Constructor<any>;
 /**
  * Data structure for a buffered event
+ *
+ * @template Event - The event type
+ * @template Data - The data type
  */
 export type BufferedEvent<Event, Data> = {
     event: Event;
     data: Data;
 };
 /**
- * Event list item inside bufferred items
+ * Event list item inside buffered items
+ *
+ * @template EventsList - The events list type
  */
 export type BufferedEventsList<EventsList> = {
     [Name in keyof EventsList]: BufferedEvent<Name, EventsList[Name]>;
@@ -20,21 +25,30 @@ export type BufferedEventsList<EventsList> = {
  * Representation of listener method on the listener class. The
  * spread args can type hint dependencies and container will
  * resolve them
+ *
+ * @template Data - The event data type
  */
 export type ListenerMethod<Data> = (data: Data, ...args: any[]) => any | Promise<any>;
 /**
  * The event listener defined as an inline callback
+ *
+ * @template Data - The event data type
  */
 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.
+ *
+ * @template Listener - The listener class constructor
+ * @template Data - The event data type
  */
 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
+ *
+ * @template Data - The event data type
  */
 export type ListenerClassWithHandleMethod<Data> = Constructor<{
     handle: ListenerMethod<Data>;
@@ -42,11 +56,16 @@ export type ListenerClassWithHandleMethod<Data> = Constructor<{
 /**
  * The event listener defined as an inline callback, string
  * listener class reference or a lazily imported listener
+ *
+ * @template Data - The event data type
+ * @template ListenerClass - The listener class constructor
  */
 export type Listener<Data, ListenerClass extends Constructor<any>> = ListenerFn<Data> | string | [LazyImport<ListenerClass> | ListenerClass, GetListenersMethods<ListenerClass, Data>?];
 /**
  * The EmitterLike interface exposes a less strict API to accept
  * emitter as an argument to emit events.
+ *
+ * @template EventsList - The events list type
  */
 export interface EmitterLike<EventsList extends Record<string | symbol | number, any>> {
     /**
@@ -54,6 +73,10 @@ export interface EmitterLike<EventsList extends Record<string | symbol | number,
      * in parallel.
      *
      * You can await this method to wait for events listeners to finish
+     *
+     * @param event - The event to emit
+     * @param data - The data to pass to listeners
+     * @returns Promise that resolves when all listeners finish
      */
     emit<Event extends Constructor<any>>(event: Event, data: InstanceType<Event>): Promise<void>;
     emit<Name extends keyof EventsList>(event: Name, data: EventsList[Name]): Promise<void>;
@@ -62,15 +85,25 @@ export interface EmitterLike<EventsList extends Record<string | symbol | number,
      * in the same sequence as they are registered.
      *
      * You can await this method to wait for events listeners to finish
+     *
+     * @param event - The event to emit
+     * @param data - The data to pass to listeners
+     * @returns Promise that resolves when all listeners finish
      */
     emitSerial<Event extends Constructor<any>>(event: Event, data: InstanceType<Event>): Promise<void>;
     emitSerial<Name extends keyof EventsList>(event: Name, data: EventsList[Name]): Promise<void>;
     /**
-     * Find if an event has one or more listeners
+     * Get count of listeners for a given event or all the events
+     *
+     * @param event - The event to count listeners for (optional)
+     * @returns The number of listeners
      */
     listenerCount(event?: keyof EventsList | Constructor<any>): number;
     /**
-     * Get count of listeners for a given event or all the events
+     * Find if an event has one or more listeners
+     *
+     * @param event - The event to check listeners for (optional)
+     * @returns True if the event has listeners
      */
     hasListeners(event?: keyof EventsList | Constructor<any>): boolean;
 }

package/build/src/types.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/events",
   "description": "An implementation of the event emitter built on top of emittery",
-  "version": "10.1.0-next.1",
+  "version": "10.1.0-next.3",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -28,7 +28,7 @@
     "typecheck": "tsc --noEmit",
     "precompile": "npm run lint && npm run clean",
     "clean": "del-cli build",
-    "compile": "tsup-node && tsc --emitDeclarationOnly --declaration",
+    "compile": "tsdown && tsc --emitDeclarationOnly --declaration",
     "build": "npm run compile",
     "version": "npm run build",
     "prepublishOnly": "npm run build",
@@ -36,36 +36,36 @@
     "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts"
   },
   "devDependencies": {
-    "@adonisjs/application": "^9.0.0-next.2",
-    "@adonisjs/config": "^5.0.3",
-    "@adonisjs/eslint-config": "^3.0.0-next.0",
-    "@adonisjs/fold": "^11.0.0-next.0",
+    "@adonisjs/application": "^9.0.0-next.12",
+    "@adonisjs/config": "^6.1.0-next.0",
+    "@adonisjs/eslint-config": "^3.0.0-next.5",
+    "@adonisjs/fold": "^11.0.0-next.3",
     "@adonisjs/prettier-config": "^1.4.5",
-    "@adonisjs/tsconfig": "^2.0.0-next.0",
-    "@japa/assert": "^4.1.1",
-    "@japa/expect-type": "^2.0.3",
-    "@japa/file-system": "^2.3.2",
-    "@japa/runner": "^4.3.0",
-    "@poppinss/ts-exec": "^1.4.0",
-    "@release-it/conventional-changelog": "^10.0.1",
-    "@types/node": "^24.1.0",
+    "@adonisjs/tsconfig": "^2.0.0-next.3",
+    "@japa/assert": "^4.2.0",
+    "@japa/expect-type": "^2.0.4",
+    "@japa/file-system": "^3.0.0",
+    "@japa/runner": "^5.0.0",
+    "@poppinss/ts-exec": "^1.4.1",
+    "@release-it/conventional-changelog": "^10.0.3",
+    "@types/node": "^25.0.2",
     "c8": "^10.1.3",
-    "cross-env": "^10.0.0",
-    "del-cli": "^6.0.0",
-    "eslint": "^9.32.0",
-    "prettier": "^3.6.2",
-    "release-it": "^19.0.4",
-    "tsup": "^8.5.0",
-    "typescript": "^5.8.3"
+    "cross-env": "^10.1.0",
+    "del-cli": "^7.0.0",
+    "eslint": "^9.39.2",
+    "prettier": "^3.7.4",
+    "release-it": "^19.1.0",
+    "tsdown": "^0.17.4",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@poppinss/utils": "^7.0.0-next.3",
-    "@sindresorhus/is": "^7.0.2",
+    "@poppinss/utils": "^7.0.0-next.4",
+    "@sindresorhus/is": "^7.1.1",
     "emittery": "^1.2.0"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^9.0.0-next.2",
-    "@adonisjs/fold": "^11.0.0-next.0"
+    "@adonisjs/application": "^9.0.0-next.4",
+    "@adonisjs/fold": "^11.0.0-next.2"
   },
   "homepage": "https://github.com/adonisjs/events#readme",
   "repository": {
@@ -85,7 +85,7 @@
     "access": "public",
     "provenance": true
   },
-  "tsup": {
+  "tsdown": {
     "entry": [
       "./index.ts",
       "./src/types.ts",
@@ -94,8 +94,11 @@
     "outDir": "./build",
     "clean": true,
     "format": "esm",
+    "minify": "dce-only",
+    "fixedExtension": false,
     "dts": false,
-    "sourcemap": false,
+    "treeshake": false,
+    "sourcemaps": false,
     "target": "esnext"
   },
   "release-it": {

package/build/chunk-X4QBBFBR.js

@@ -1,464 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/tracing_channels.ts
-var tracing_channels_exports = {};
-__export(tracing_channels_exports, {
-  eventDispatch: () => eventDispatch
-});
-import diagnostics_channel from "diagnostics_channel";
-var eventDispatch = diagnostics_channel.tracingChannel("adonisjs:event.dispatch");
-
-// src/emitter.ts
-import is2 from "@sindresorhus/is";
-import Emittery from "emittery";
-import { moduleCaller, moduleImporter } from "@adonisjs/fold";
-
-// src/debug.ts
-import { debuglog } from "util";
-var debug_default = debuglog("adonisjs:events");
-
-// src/events_buffer.ts
-import is from "@sindresorhus/is";
-import string from "@poppinss/utils/string";
-import { AssertionError } from "assert";
-var EventsBuffer = class {
-  /**
-   * Buffered events
-   */
-  #events = [];
-  /**
-   * Track emitted event
-   */
-  add(event, data) {
-    this.#events.push({ event, 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, finder) {
-    return !!this.find(event, finder);
-  }
-  /**
-   * Find a specific event
-   */
-  find(event, finder) {
-    return this.#events.find((bufferedEvent) => {
-      if (!finder) {
-        return bufferedEvent.event === event;
-      }
-      return bufferedEvent.event === event && finder(bufferedEvent);
-    }) || null;
-  }
-  /**
-   * Assert a given event has been emitted
-   */
-  assertEmitted(event, finder) {
-    const hasEvent = this.exists(event, finder);
-    if (!hasEvent) {
-      const message = is.class(event) ? `Expected "[class ${event.name}]" event to be emitted` : `Expected "${String(event)}" event to be emitted`;
-      throw new AssertionError({
-        message,
-        expected: true,
-        actual: false,
-        operator: "strictEqual",
-        stackStartFn: this.assertEmitted
-      });
-    }
-  }
-  /**
-   * Assert number of times an event has been emitted
-   */
-  assertEmittedCount(event, count) {
-    const actual = this.all().filter((bufferedEvent) => bufferedEvent.event === event).length;
-    if (actual !== count) {
-      const eventName = is.class(event) ? `[class ${event.name}]` : String(event);
-      throw new AssertionError({
-        message: `Expected "${eventName}" event to be emitted "${count}" ${string.pluralize(
-          "time",
-          count
-        )}, instead it was emitted "${actual}" ${string.pluralize("time", actual)}`,
-        actual,
-        expected: count
-      });
-    }
-  }
-  /**
-   * Assert a given event has been not been emitted
-   */
-  assertNotEmitted(event, finder) {
-    const hasEvent = this.exists(event, finder);
-    if (hasEvent) {
-      const isClass = is.class(event);
-      const message = isClass ? `Unexpected "[class ${event.name}]" event was emitted` : `Unexpected "${String(event)}" event was emitted`;
-      throw new AssertionError({
-        message,
-        expected: false,
-        actual: true,
-        operator: "strictEqual",
-        stackStartFn: this.assertNotEmitted
-      });
-    }
-  }
-  /**
-   * Assert a given event has been not been emitted
-   */
-  assertNoneEmitted() {
-    const eventsSize = this.size();
-    if (eventsSize > 0) {
-      throw new AssertionError(
-        Object.assign(
-          {
-            message: `Expected zero events to be emitted. Instead received "${eventsSize}" ${string.pluralize(
-              "event",
-              eventsSize
-            )}`,
-            expected: 0,
-            actual: eventsSize,
-            operator: "strictEqual",
-            stackStartFn: this.assertNoneEmitted
-          },
-          {
-            showDiff: true
-          }
-        )
-      );
-    }
-  }
-  /**
-   * Flush events collected within memory
-   */
-  flush() {
-    this.#events = [];
-  }
-};
-
-// src/emitter.ts
-var Emitter = class {
-  /**
-   * Event classes to symbols mapping. We need symbols as emittery
-   * does not support class based event names
-   */
-  #eventsClassSymbols = /* @__PURE__ */ new Map();
-  /**
-   * A collection of events and their listeners. We do not track listeners
-   * listening for events only once
-   */
-  #eventsListeners = /* @__PURE__ */ 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 = /* @__PURE__ */ 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;
-  }
-  /**
-   * Check if the value is a constructor and narrow down its types
-   */
-  #isConstructor(value) {
-    return is2.class(value);
-  }
-  /**
-   * 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 (this.#isConstructor(event)) {
-      return this.#getEventClassSymbol(event);
-    }
-    return event;
-  }
-  /**
-   * Returns the event listeners map
-   */
-  #getEventListeners(event) {
-    if (!this.#eventsListeners.has(event)) {
-      this.#eventsListeners.set(event, /* @__PURE__ */ new Map());
-    }
-    return this.#eventsListeners.get(event);
-  }
-  /**
-   * Normalizes the event listener to a function that can be passed to
-   * emittery.
-   */
-  #normalizeEventListener(listener) {
-    if (typeof listener === "string") {
-      const parts = listener.split(".");
-      const method = parts.length === 1 ? "handle" : parts.pop();
-      const moduleRefId = parts.join(".");
-      return moduleImporter(() => this.#app.import(moduleRefId), method).toCallable(
-        this.#app.container
-      );
-    }
-    if (Array.isArray(listener)) {
-      const listenerModule = listener[0];
-      const method = listener[1] || "handle";
-      if (this.#isConstructor(listenerModule)) {
-        return moduleCaller(listenerModule, method).toCallable(this.#app.container);
-      }
-      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_default.enabled) {
-      debug_default("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);
-  }
-  listenIf(condition, event, listener) {
-    if (!condition || typeof condition === "function" && !condition()) {
-      return () => {
-      };
-    }
-    return this.on(event, listener);
-  }
-  once(event, listener) {
-    if (debug_default.enabled) {
-      debug_default("registering one time event listener, event: %O, listener: %O", event, listener);
-    }
-    const normalizedEvent = this.#resolveEvent(event);
-    const normalizedListener = this.#normalizeEventListener(listener);
-    const off = this.#transport.on(normalizedEvent, async (data) => {
-      off();
-      debug_default("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) {
-    if (this.#eventsToFake.has(event) || this.#eventsToFake.has("*")) {
-      debug_default("faking emit. event: %O, data: %O", event, data);
-      this.#eventsBuffer.add(event, data);
-      return;
-    }
-    try {
-      const normalizedEvent = this.#resolveEvent(event);
-      await eventDispatch.tracePromise(
-        this.#transport.emit,
-        {
-          event,
-          data
-        },
-        this.#transport,
-        normalizedEvent,
-        data
-      );
-    } catch (error) {
-      if (this.#errorHandler) {
-        this.#errorHandler(event, error, data);
-      } else {
-        throw error;
-      }
-    }
-  }
-  async emitSerial(event, data) {
-    if (this.#eventsToFake.has(event) || this.#eventsToFake.has("*")) {
-      debug_default("faking emit. event: %O, data: %O", event, data);
-      this.#eventsBuffer.add(event, data);
-      return;
-    }
-    try {
-      const normalizedEvent = this.#resolveEvent(event);
-      await eventDispatch.tracePromise(
-        this.#transport.emitSerial,
-        {
-          event,
-          data
-        },
-        this.#transport,
-        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_default.enabled) {
-      debug_default("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_default("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_default("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) : void 0);
-  }
-  /**
-   * 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_default("faking all events");
-      this.#eventsToFake.add("*");
-    } else {
-      debug_default("faking events: %O", events);
-      events.forEach((event) => this.#eventsToFake.add(event));
-    }
-    return this.#eventsBuffer;
-  }
-  /**
-   * Restore fakes
-   */
-  restore() {
-    debug_default("restoring existing fakes");
-    this.#eventsToFake.clear();
-    this.#eventsBuffer?.flush();
-    this.#eventsBuffer = void 0;
-  }
-};
-
-export {
-  tracing_channels_exports,
-  Emitter
-};