@adonisjs/events 10.1.0-next.2 → 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/main.js

@@ -1,16 +1,7 @@
-import {
-  Emitter
-} from "../chunk-R74HJGSQ.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.js

@@ -1,48 +1,14 @@
-import {
-  Emitter,
-  tracing_channels_exports
-} from "./chunk-R74HJGSQ.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 {
-  /**
-   * Base event constructor
-   *
-   * @param _ - Any constructor arguments (unused)
-   */
-  constructor(..._) {
-  }
-  /**
-   * The emitter to use for dispatching events
-   */
-  static emitter;
-  /**
-   * Specify the emitter instance to use for dispatching events
-   *
-   * @param emitter - The emitter instance to use
-   */
-  static useEmitter(emitter) {
-    this.emitter = emitter;
-  }
-  /**
-   * 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 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/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

@@ -116,7 +116,6 @@ export declare class Emitter<EventsList extends Record<string | symbol | number,
     /**
      * Remove a specific listener for an event
      *
-     * @alias "off"
      * @param event - The event to remove listener from
      * @param listener - The listener to remove
      */

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.2",
+  "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,31 +36,31 @@
     "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts"
   },
   "devDependencies": {
-    "@adonisjs/application": "^9.0.0-next.4",
-    "@adonisjs/config": "^6.0.0-next.1",
-    "@adonisjs/eslint-config": "^3.0.0-next.1",
-    "@adonisjs/fold": "^11.0.0-next.2",
+    "@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.4.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.1",
-    "@types/node": "^24.3.0",
+    "@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.34.0",
-    "prettier": "^3.6.2",
-    "release-it": "^19.0.4",
-    "tsup": "^8.5.0",
-    "typescript": "^5.9.2"
+    "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": {
@@ -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-R74HJGSQ.js

@@ -1,547 +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
-   *
-   * @param event - The event that was emitted
-   * @param data - The data passed with the event
-   */
-  add(event, data) {
-    this.#events.push({ event, data });
-  }
-  /**
-   * Get all the emitted events
-   *
-   * @returns Array of all buffered events
-   */
-  all() {
-    return this.#events;
-  }
-  /**
-   * Returns the size of captured events
-   *
-   * @returns The number of captured events
-   */
-  size() {
-    return this.#events.length;
-  }
-  /**
-   * 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, finder) {
-    return !!this.find(event, finder);
-  }
-  /**
-   * 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, 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
-   *
-   * @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, 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
-   *
-   * @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, 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
-   *
-   * @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, 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 no events have been emitted
-   *
-   * @throws AssertionError if any events were 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.
-   *
-   * @returns The events listeners map
-   */
-  get eventsListeners() {
-    return this.#eventsListeners;
-  }
-  /**
-   * Creates a new Emitter instance
-   *
-   * @param app - The AdonisJS application instance
-   */
-  constructor(app) {
-    this.#app = app;
-  }
-  /**
-   * Check if the value is a constructor and narrow down its types
-   *
-   * @param value - The value to check
-   * @returns True if the value is a constructor
-   */
-  #isConstructor(value) {
-    return is2.class(value);
-  }
-  /**
-   * Returns the symbol for a class based event.
-   *
-   * @param event - The event class constructor
-   * @returns The symbol for the event class
-   */
-  #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.
-   *
-   * @param event - The event to resolve
-   * @returns The resolved event as string, symbol, or number
-   */
-  #resolveEvent(event) {
-    if (this.#isConstructor(event)) {
-      return this.#getEventClassSymbol(event);
-    }
-    return event;
-  }
-  /**
-   * Returns the event listeners map
-   *
-   * @param event - The event to get listeners for
-   * @returns The listeners map for the event
-   */
-  #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.
-   *
-   * @param listener - The listener to normalize
-   * @returns The normalized listener method
-   */
-  #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
-   *
-   * @param event - The event to resolve listener for
-   * @param listener - The listener to resolve
-   * @returns The resolved listener method
-   */
-  #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
-   *
-   * @param callback - The error handler callback
-   * @returns The emitter instance for method chaining
-   */
-  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.
-   *
-   * @param event - The event class to listen for
-   * @param listeners - Array of listener classes with handle methods
-   */
-  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.
-   *
-   * @param listener - The wildcard listener callback
-   * @returns The unsubscribe function
-   */
-  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;
-      }
-    }
-  }
-  /**
-   * Remove a specific listener for an event
-   *
-   * @param event - The event to remove listener from
-   * @param listener - The listener to remove
-   */
-  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
-   *
-   * @param listener - The wildcard listener to remove
-   * @returns The emitter instance for method chaining
-   */
-  offAny(listener) {
-    this.#transport.offAny(listener);
-    return 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, listener) {
-    return this.off(event, listener);
-  }
-  /**
-   * Clear all listeners for a specific event
-   *
-   * @param event - The event to clear listeners for
-   */
-  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
-   *
-   * @param event - The event to count listeners for (optional)
-   * @returns The number of listeners
-   */
-  listenerCount(event) {
-    return this.#transport.listenerCount(event ? this.#resolveEvent(event) : void 0);
-  }
-  /**
-   * 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) {
-    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.
-   *
-   * @param events - Array of events to fake (optional, defaults to all events)
-   * @returns The events buffer for assertions
-   */
-  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
-};