@adonisjs/events 9.0.0-0 → 9.0.0-1

package/build/{chunk-VVJERWW5.js → chunk-57BRCCSN.js}

@@ -10,6 +10,7 @@ var debug_default = debuglog("adonisjs:events");
 // src/events_buffer.ts
 import is from "@sindresorhus/is";
 import { AssertionError } from "node:assert";
+import string from "@poppinss/utils/string";
 var EventsBuffer = class {
   /**
    * Buffered events
@@ -36,35 +37,27 @@ var EventsBuffer = class {
   /**
    * Find if an event was emitted
    */
-  exists(finder) {
-    return !!this.find(finder);
-  }
-  /**
-   * Get selected events
-   */
-  filter(finder) {
-    if (typeof finder === "function" && !is.class(finder)) {
-      return this.#events.filter(finder);
-    }
-    return this.#events.filter((event) => event.event === finder);
+  exists(event, finder) {
+    return !!this.find(event, finder);
   }
   /**
    * Find a specific event
    */
-  find(finder) {
-    if (typeof finder === "function" && !is.class(finder)) {
-      return this.#events.find(finder) || null;
-    }
-    return this.#events.find((event) => event.event === finder) || 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
    */
-  assertEmitted(finder) {
-    const hasEvent = this.exists(finder);
+  assertEmitted(event, finder) {
+    const hasEvent = this.exists(event, finder);
     if (!hasEvent) {
-      const isClass = is.class(finder);
-      const message = typeof finder === "function" && !isClass ? `Expected callback to find an emitted event` : isClass ? `Expected "${finder.name}" event to be emitted` : `Expected "${String(finder)}" event to be emitted`;
+      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,
@@ -74,14 +67,31 @@ var EventsBuffer = class {
       });
     }
   }
+  /**
+   * 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(finder) {
-    const hasEvent = this.exists(finder);
+  assertNotEmitted(event, finder) {
+    const hasEvent = this.exists(event, finder);
     if (hasEvent) {
-      const isClass = is.class(finder);
-      const message = typeof finder === "function" && !isClass ? `Expected callback to not find any event` : isClass ? `Expected "${finder.name}" event to be not emitted` : `Expected "${String(finder)}" event to be not emitted`;
+      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,
@@ -100,7 +110,10 @@ var EventsBuffer = class {
       throw new AssertionError(
         Object.assign(
           {
-            message: `Expected zero events to be emitted. Instead received "${eventsSize}" event(s)`,
+            message: `Expected zero events to be emitted. Instead received "${eventsSize}" ${string.pluralize(
+              "event",
+              eventsSize
+            )}`,
             expected: 0,
             actual: eventsSize,
             operator: "strictEqual",
@@ -400,3 +413,4 @@ var Emitter = class {
 export {
   Emitter
 };
+//# sourceMappingURL=chunk-57BRCCSN.js.map

package/build/chunk-57BRCCSN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/emitter.ts","../src/debug.ts","../src/events_buffer.ts"],"sourcesContent":["/*\n * @adonisjs/events\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport is from '@sindresorhus/is'\nimport type { Application } from '@adonisjs/application'\nimport Emittery, { type UnsubscribeFunction } from 'emittery'\nimport { moduleExpression, moduleCaller, moduleImporter } from '@adonisjs/fold'\n\nimport debug from './debug.js'\nimport { EventsBuffer } from './events_buffer.js'\nimport type {\n  Listener,\n  LazyImport,\n  Constructor,\n  ListenerMethod,\n  AllowedEventTypes,\n  ListenerClassWithHandleMethod,\n} from './types.js'\n\n/**\n * Event emitter is built on top of emittery with support class based\n * events and listeners\n */\nexport class Emitter<EventsList extends Record<string | symbol | number, any>> {\n  /**\n   * Event classes to symbols mapping. We need symbols as emittery\n   * does not support class based event names\n   */\n  #eventsClassSymbols: Map<Constructor<any>, symbol> = new Map()\n\n  /**\n   * A collection of events and their listeners. We do not track listeners\n   * listening for events only once\n   */\n  #eventsListeners: Map<\n    AllowedEventTypes,\n    Map<Listener<any, Constructor<any>>, ListenerMethod<any>>\n  > = new Map()\n\n  /**\n   * Underlying transport to emit events\n   */\n  #transport = new Emittery()\n\n  /**\n   * Events buffer. The events are collected inside an in-memory\n   * buffer during fakes\n   */\n  #eventsBuffer?: EventsBuffer<EventsList>\n\n  /**\n   * A set of events to fake\n   */\n  #eventsToFake: Set<AllowedEventTypes | '*'> = new Set()\n\n  /**\n   * Error handler to catch all errors thrown by listeners\n   */\n  #errorHandler?: (event: keyof EventsList | Constructor<any>, error: any, data: any) => void\n\n  /**\n   * Reference to AdonisJS application, we need the application root\n   * and container reference from it.\n   */\n  #app: Application<any>\n\n  /**\n   * Returns a map of events and their registered listeners. The\n   * map key is the event name and the value is another map\n   * of listeners.\n   *\n   * The listeners map key is the original binding listener\n   * and the value is a callback function.\n   */\n  get eventsListeners() {\n    return this.#eventsListeners\n  }\n\n  constructor(app: Application<any>) {\n    this.#app = app\n  }\n\n  /**\n   * Returns the symbol for a class based event.\n   */\n  #getEventClassSymbol(event: Constructor<any>): symbol {\n    if (!this.#eventsClassSymbols.has(event)) {\n      this.#eventsClassSymbols.set(event, Symbol(event.name))\n    }\n\n    return this.#eventsClassSymbols.get(event)!\n  }\n\n  /**\n   * Normalizes the event to emittery supported data types. The class\n   * constructors are cached against a unique symbol.\n   */\n  #resolveEvent(event: AllowedEventTypes): string | symbol | number {\n    if (is.class(event)) {\n      return this.#getEventClassSymbol(event)\n    }\n\n    return event\n  }\n\n  /**\n   * Returns the event listeners map\n   */\n  #getEventListeners(event: AllowedEventTypes) {\n    if (!this.#eventsListeners.has(event)) {\n      this.#eventsListeners.set(event, new Map())\n    }\n\n    return this.#eventsListeners.get(event)!\n  }\n\n  /**\n   * Normalizes the event listener to a function that can be passed to\n   * emittery.\n   */\n  #normalizeEventListener(listener: Listener<any, Constructor>): ListenerMethod<any> {\n    /**\n     * Parse string based listener\n     */\n    if (typeof listener === 'string') {\n      return moduleExpression(listener, this.#app.appRoot.toString()).toCallable(\n        this.#app.container\n      )\n    }\n\n    /**\n     * Parse array based listener with the listener reference\n     * or lazily imported listener class\n     */\n    if (Array.isArray(listener)) {\n      const listenerModule = listener[0]\n      const method = listener[1] || 'handle'\n\n      /**\n       * Class reference\n       */\n      if (is.class(listenerModule)) {\n        return moduleCaller(listenerModule, method).toCallable(this.#app.container)\n      }\n\n      /**\n       * Lazily loaded module\n       */\n      return moduleImporter(listenerModule, method).toCallable(this.#app.container)\n    }\n\n    return listener\n  }\n\n  /**\n   * Resolves the event listener either from the cache or normalizes\n   * it and stores it inside the cache\n   */\n  #resolveEventListener(\n    event: AllowedEventTypes,\n    listener: Listener<any, Constructor>\n  ): ListenerMethod<any> {\n    const eventListeners = this.#getEventListeners(event)\n    if (!eventListeners.has(listener)) {\n      eventListeners.set(listener, this.#normalizeEventListener(listener))\n    }\n\n    return eventListeners.get(listener)!\n  }\n\n  /**\n   * Register a global error handler\n   */\n  onError(\n    callback: (event: keyof EventsList | Constructor<any>, error: any, data: any) => void\n  ): this {\n    this.#errorHandler = callback\n    return this\n  }\n\n  /**\n   * Bind multiple listeners to listen for a single event. The listen\n   * method is a convenience helper to be used with class based\n   * events and listeners.\n   */\n  listen<Event extends Constructor<any>>(\n    event: Event,\n    listeners: (\n      | ListenerClassWithHandleMethod<InstanceType<Event>>\n      | LazyImport<ListenerClassWithHandleMethod<InstanceType<Event>>>\n    )[]\n  ) {\n    listeners.forEach((listener) => this.on(event, [listener, 'handle']))\n  }\n\n  /**\n   * Listen for an event. The method returns the unsubscribe function.\n   */\n  on<Event extends Constructor, ListenerClass extends Constructor>(\n    event: Event,\n    listener: Listener<InstanceType<Event>, ListenerClass>\n  ): UnsubscribeFunction\n  on<Name extends keyof EventsList, ListenerClass extends Constructor>(\n    event: Name,\n    listener: Listener<EventsList[Name], ListenerClass>\n  ): UnsubscribeFunction\n  on<Event extends AllowedEventTypes>(\n    event: Event,\n    listener: Listener<any, Constructor>\n  ): UnsubscribeFunction {\n    if (debug.enabled) {\n      debug('registering event listener, event: %O, listener: %O', event, listener)\n    }\n\n    const normalizedEvent = this.#resolveEvent(event)\n    const normalizedListener = this.#resolveEventListener(event, listener)\n\n    this.#transport.on(normalizedEvent, normalizedListener)\n    return () => this.off(event, listener)\n  }\n\n  /**\n   * Listen for an event only once\n   */\n  once<Event extends Constructor, ListenerClass extends Constructor>(\n    event: Event,\n    listener: Listener<InstanceType<Event>, ListenerClass>\n  ): void\n  once<Name extends keyof EventsList, ListenerClass extends Constructor>(\n    event: Name,\n    listener: Listener<EventsList[Name], ListenerClass>\n  ): void\n  once<Event extends AllowedEventTypes>(event: Event, listener: Listener<any, Constructor>): void {\n    if (debug.enabled) {\n      debug('registering one time event listener, event: %O, listener: %O', event, listener)\n    }\n\n    const normalizedEvent = this.#resolveEvent(event)\n    const normalizedListener = this.#normalizeEventListener(listener)\n\n    /**\n     * Listening for an event and unsubscribing right after the event is emitted.\n     * Internally emittery does the same thing, but they do not await the\n     * handler. Therefore, the \"once\" listeners will finish after the\n     * \"emit\" call. This behavior is not inline with the \"on\" event\n     * listeners.\n     */\n    const off = this.#transport.on(normalizedEvent, async (data) => {\n      off()\n      debug('removing one time event listener, event: %O', event)\n      await normalizedListener(data)\n    })\n  }\n\n  /**\n   * Attach a listener to listen for all the events. Wildcard listeners\n   * can only be defined as inline callbacks.\n   */\n  onAny(\n    listener: (event: AllowedEventTypes, data: any) => any | Promise<any>\n  ): UnsubscribeFunction {\n    return this.#transport.onAny(listener)\n  }\n\n  /**\n   * Emit event. The event listeners will be called asynchronously\n   * in parallel.\n   *\n   * You can await this method to wait for events listeners to finish\n   */\n  async emit<Event extends Constructor<any>>(event: Event, data: InstanceType<Event>): Promise<void>\n  async emit<Name extends keyof EventsList>(event: Name, data: EventsList[Name]): Promise<void>\n  async emit<Event extends AllowedEventTypes>(event: Event, data: any): Promise<void> {\n    /**\n     * Entertain fakes if exists\n     */\n    if (this.#eventsToFake.has(event) || this.#eventsToFake.has('*')) {\n      debug('faking emit. event: %O, data: %O', event, data)\n      this.#eventsBuffer!.add(event, data)\n      return\n    }\n\n    try {\n      const normalizedEvent = this.#resolveEvent(event)\n      await this.#transport.emit(normalizedEvent, data)\n    } catch (error) {\n      if (this.#errorHandler) {\n        this.#errorHandler(event, error, data)\n      } else {\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Emit events serially. The event listeners will be called asynchronously\n   * in the same sequence as they are registered.\n   *\n   * You can await this method to wait for events listeners to finish\n   */\n  async emitSerial<Event extends Constructor<any>>(\n    event: Event,\n    data: InstanceType<Event>\n  ): Promise<void>\n  async emitSerial<Name extends keyof EventsList>(\n    event: Name,\n    data: EventsList[Name]\n  ): Promise<void>\n  async emitSerial<Event extends AllowedEventTypes>(event: Event, data: any): Promise<void> {\n    /**\n     * Entertain fakes if exists\n     */\n    if (this.#eventsToFake.has(event) || this.#eventsToFake.has('*')) {\n      debug('faking emit. event: %O, data: %O', event, data)\n      this.#eventsBuffer!.add(event, data)\n      return\n    }\n\n    try {\n      const normalizedEvent = this.#resolveEvent(event)\n      await this.#transport.emitSerial(normalizedEvent, data)\n    } catch (error) {\n      if (this.#errorHandler) {\n        this.#errorHandler(event, error, data)\n      } else {\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Remove a specific listener for an event\n   */\n  off(event: keyof EventsList | Constructor<any>, listener: Listener<any, Constructor<any>>): void {\n    if (debug.enabled) {\n      debug('removing listener, event: %O, listener: %O', event, listener)\n    }\n\n    const normalizedEvent = this.#resolveEvent(event)\n    const listeners = this.#getEventListeners(event)\n    const normalizedListener = listeners.get(listener)\n\n    if (!normalizedListener) {\n      return\n    }\n\n    listeners.delete(listener)\n    this.#transport.off(normalizedEvent, normalizedListener)\n  }\n\n  /**\n   * Remove a specific listener listening for all the events\n   */\n  offAny(\n    listener: (event: keyof EventsList | Constructor<any>, data: any) => any | Promise<any>\n  ): this {\n    this.#transport.offAny(listener)\n    return this\n  }\n\n  /**\n   * Remove a specific listener for an event\n   *\n   * @alias \"off\"\n   */\n  clearListener(\n    event: keyof EventsList | Constructor<any>,\n    listener: Listener<any, Constructor<any>>\n  ): void {\n    return this.off(event, listener)\n  }\n\n  /**\n   * Clear all listeners for a specific event\n   */\n  clearListeners(event: keyof EventsList | Constructor<any>) {\n    debug('clearing all listeners for event %O', event)\n    this.#transport.clearListeners(this.#resolveEvent(event))\n    this.#eventsListeners.delete(event)\n  }\n\n  /**\n   * Clear all listeners for all the events\n   */\n  clearAllListeners() {\n    debug('clearing all event listeners')\n    this.#transport.clearListeners()\n    this.#eventsListeners.clear()\n  }\n\n  /**\n   * Get count of listeners for a given event or all the events\n   */\n  listenerCount(event?: keyof EventsList | Constructor<any>): number {\n    return this.#transport.listenerCount(event ? this.#resolveEvent(event) : undefined)\n  }\n\n  /**\n   * Find if an event has one or more listeners\n   */\n  hasListeners(event?: keyof EventsList | Constructor<any>): boolean {\n    return this.listenerCount(event) > 0\n  }\n\n  /**\n   * Fake one or more events. The listeners for faked events will\n   * not be invoked.\n   *\n   * The return value is an events buffer that collects all the\n   * events within memory.\n   *\n   * Calling this method one than once drops the existing fakes and\n   * creates new one.\n   */\n  fake(events?: (keyof EventsList | Constructor<any>)[]): EventsBuffer<EventsList> {\n    this.restore()\n    this.#eventsBuffer = new EventsBuffer<EventsList>()\n\n    if (!events) {\n      debug('faking all events')\n      this.#eventsToFake.add('*')\n    } else {\n      debug('faking events: %O', events)\n      events.forEach((event) => this.#eventsToFake.add(event))\n    }\n\n    return this.#eventsBuffer\n  }\n\n  /**\n   * Restore fakes\n   */\n  restore() {\n    debug('restoring existing fakes')\n    this.#eventsToFake.clear()\n    this.#eventsBuffer?.flush()\n    this.#eventsBuffer = undefined\n  }\n}\n","/*\n * @adonisjs/events\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport { debuglog } from 'node:util'\nexport default debuglog('adonisjs:events')\n","/*\n * @adonisjs/events\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport is from '@sindresorhus/is'\nimport { AssertionError } from 'node:assert'\nimport type { AllowedEventTypes, BufferedEvent, BufferedEventsList, Constructor } from './types.js'\nimport string from '@poppinss/utils/string'\n\n/**\n * Callback function to narrow down an event from\n * the events buffer list\n */\ntype EventFinderCallback<\n  EventsList extends Record<string | symbol | number, any>,\n  Event extends keyof EventsList | Constructor,\n> = (\n  event: Event extends keyof EventsList\n    ? BufferedEvent<Event, EventsList[Event]>\n    : Event extends Constructor<infer A>\n      ? BufferedEvent<Event, A>\n      : never\n) => boolean\n\n/**\n * Exposes API to filter, find events from the events buffer.\n */\nexport class EventsBuffer<EventsList extends Record<string | symbol | number, any>> {\n  /**\n   * Buffered events\n   */\n  #events: BufferedEventsList<EventsList>[] = []\n\n  /**\n   * Track emitted event\n   */\n  add<Name extends AllowedEventTypes>(event: Name, data: any): void {\n    this.#events.push({ event: event as any, data })\n  }\n\n  /**\n   * Get all the emitted events\n   */\n  all() {\n    return this.#events\n  }\n\n  /**\n   * Returns the size of captured events\n   */\n  size() {\n    return this.#events.length\n  }\n\n  /**\n   * Find if an event was emitted\n   */\n  exists<Event extends keyof EventsList | Constructor>(\n    event: Event,\n    finder?: EventFinderCallback<EventsList, Event>\n  ): boolean {\n    return !!this.find(event, finder)\n  }\n\n  /**\n   * Find a specific event\n   */\n  find<Event extends keyof EventsList | Constructor>(\n    event: Event,\n    finder?: EventFinderCallback<EventsList, Event>\n  ):\n    | (Event extends keyof EventsList\n        ? BufferedEvent<Event, EventsList[Event]>\n        : Event extends Constructor<infer A>\n          ? BufferedEvent<Event, A>\n          : never)\n    | null {\n    return (this.#events.find((bufferedEvent) => {\n      if (!finder) {\n        return bufferedEvent.event === event\n      }\n\n      return (\n        bufferedEvent.event === event &&\n        finder(bufferedEvent as Parameters<EventFinderCallback<EventsList, Event>>[0])\n      )\n    }) || null) as any\n  }\n\n  /**\n   * Assert a given event has been emitted\n   */\n  assertEmitted<Event extends keyof EventsList | Constructor>(\n    event: Event,\n    finder?: EventFinderCallback<EventsList, Event>\n  ): void {\n    const hasEvent = this.exists(event, finder)\n\n    if (!hasEvent) {\n      const message = is.class(event)\n        ? `Expected \"[class ${event.name}]\" event to be emitted`\n        : `Expected \"${String(event)}\" event to be emitted`\n\n      throw new AssertionError({\n        message: message,\n        expected: true,\n        actual: false,\n        operator: 'strictEqual',\n        stackStartFn: this.assertEmitted,\n      })\n    }\n  }\n\n  /**\n   * Assert number of times an event has been emitted\n   */\n  assertEmittedCount<Event extends keyof EventsList | Constructor>(\n    event: Event,\n    count: number\n  ): void {\n    const actual = this.all().filter((bufferedEvent) => bufferedEvent.event === event).length\n\n    if (actual !== count) {\n      const eventName = is.class(event) ? `[class ${event.name}]` : String(event)\n      throw new AssertionError({\n        message: `Expected \"${eventName}\" event to be emitted \"${count}\" ${string.pluralize(\n          'time',\n          count\n        )}, instead it was emitted \"${actual}\" ${string.pluralize('time', actual)}`,\n        actual,\n        expected: count,\n      })\n    }\n  }\n\n  /**\n   * Assert a given event has been not been emitted\n   */\n  assertNotEmitted<Event extends keyof EventsList | Constructor<any>>(\n    event: Event,\n    finder?: EventFinderCallback<EventsList, Event>\n  ): void {\n    const hasEvent = this.exists(event, finder)\n\n    if (hasEvent) {\n      const isClass = is.class(event)\n      const message = isClass\n        ? `Unexpected \"[class ${event.name}]\" event was emitted`\n        : `Unexpected \"${String(event)}\" event was emitted`\n\n      throw new AssertionError({\n        message: message,\n        expected: false,\n        actual: true,\n        operator: 'strictEqual',\n        stackStartFn: this.assertNotEmitted,\n      })\n    }\n  }\n\n  /**\n   * Assert a given event has been not been emitted\n   */\n  assertNoneEmitted(): void {\n    const eventsSize = this.size()\n    if (eventsSize > 0) {\n      throw new AssertionError(\n        Object.assign(\n          {\n            message: `Expected zero events to be emitted. Instead received \"${eventsSize}\" ${string.pluralize(\n              'event',\n              eventsSize\n            )}`,\n            expected: 0,\n            actual: eventsSize,\n            operator: 'strictEqual',\n            stackStartFn: this.assertNoneEmitted,\n          },\n          {\n            showDiff: true,\n          }\n        )\n      )\n    }\n  }\n\n  /**\n   * Flush events collected within memory\n   */\n  flush() {\n    this.#events = []\n  }\n}\n"],"mappings":"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","names":["is","is"]}

package/build/factories/emitter.d.ts

@@ -0,0 +1,12 @@
+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/main.d.ts

@@ -1,17 +1 @@
-import { Application } from '@adonisjs/application';
-import { E as Emitter } from '../emitter-253440aa.js';
-import 'emittery';
-import '../src/types.js';
-
-/**
- * Emitter factory is used to create an instance of emitter
- * for testing
- */
-declare class EmitterFactory {
-    /**
-     * Create emitter instance
-     */
-    create(app: Application<any>): Emitter<Record<string | number | symbol, any>>;
-}
-
-export { EmitterFactory };
+export { EmitterFactory } from './emitter.js';

package/build/factories/main.js

@@ -1,6 +1,6 @@
 import {
   Emitter
-} from "../chunk-VVJERWW5.js";
+} from "../chunk-57BRCCSN.js";
 
 // factories/emitter.ts
 var EmitterFactory = class {
@@ -14,3 +14,4 @@ var EmitterFactory = class {
 export {
   EmitterFactory
 };
+//# sourceMappingURL=main.js.map

package/build/factories/main.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../factories/emitter.ts"],"sourcesContent":["/*\n * @adonisjs/events\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport type { Application } from '@adonisjs/application'\nimport { Emitter } from '../src/emitter.js'\n\n/**\n * Emitter factory is used to create an instance of emitter\n * for testing\n */\nexport class EmitterFactory {\n  /**\n   * Create emitter instance\n   */\n  create(app: Application<any>) {\n    return new Emitter(app)\n  }\n}\n"],"mappings":";;;;;AAgBO,IAAM,iBAAN,MAAqB;AAAA;AAAA;AAAA;AAAA,EAI1B,OAAO,KAAuB;AAC5B,WAAO,IAAI,QAAQ,GAAG;AAAA,EACxB;AACF;","names":[]}

package/build/index.d.ts

@@ -1,27 +1,2 @@
-import { E as Emitter } from './emitter-253440aa.js';
-import '@adonisjs/application';
-import 'emittery';
-import './src/types.js';
-
-/**
- * Base event adds ability to a class to act as an event. You can emit the
- * event by calling "Event.dispatch" method.
- */
-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>;
-}
-
-export { BaseEvent, Emitter };
+export { Emitter } from './src/emitter.js';
+export { BaseEvent } from './src/base_event.js';

package/build/index.js

@@ -1,6 +1,6 @@
 import {
   Emitter
-} from "./chunk-VVJERWW5.js";
+} from "./chunk-57BRCCSN.js";
 
 // src/base_event.ts
 import { RuntimeException } from "@poppinss/utils";
@@ -34,3 +34,4 @@ export {
   BaseEvent,
   Emitter
 };
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/base_event.ts"],"sourcesContent":["/*\n * @adonisjs/events\n *\n * (c) AdonisJS\n *\n * For the full copyright and license information, please view the LICENSE\n * file that was distributed with this source code.\n */\n\nimport { RuntimeException } from '@poppinss/utils'\nimport type { Emitter } from './emitter.js'\n\n/**\n * Base event adds ability to a class to act as an event. You can emit the\n * event by calling \"Event.dispatch\" method.\n */\nexport class BaseEvent {\n  constructor(..._: any[]) {}\n\n  /**\n   * The emitter to use for dispatching events\n   */\n  static emitter?: Emitter<any>\n\n  /**\n   * Specify the emitter instance to use for dispatching events\n   */\n  static useEmitter(emitter: Emitter<any>) {\n    this.emitter = emitter\n  }\n\n  /**\n   * Dispatch the current class as an event. The method takes the arguments\n   * accepted by the class constructor.\n   */\n  static async dispatch<T extends typeof BaseEvent>(this: T, ...args: ConstructorParameters<T>) {\n    if (!this.emitter) {\n      throw new RuntimeException(\n        `Cannot dispatch \"${this.name}\" event. Make sure to pass emitter to the \"BaseEvent\" class for dispatch method to work`\n      )\n    }\n\n    return this.emitter.emit<T>(this, new this(...args) as InstanceType<T>)\n  }\n}\n"],"mappings":";;;;;AASA,SAAS,wBAAwB;AAO1B,IAAM,YAAN,MAAgB;AAAA,EACrB,eAAe,GAAU;AAAA,EAAC;AAAA;AAAA;AAAA;AAAA,EAK1B,OAAO;AAAA;AAAA;AAAA;AAAA,EAKP,OAAO,WAAW,SAAuB;AACvC,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,aAAa,YAAiD,MAAgC;AAC5F,QAAI,CAAC,KAAK,SAAS;AACjB,YAAM,IAAI;AAAA,QACR,oBAAoB,KAAK,IAAI;AAAA,MAC/B;AAAA,IACF;AAEA,WAAO,KAAK,QAAQ,KAAQ,MAAM,IAAI,KAAK,GAAG,IAAI,CAAoB;AAAA,EACxE;AACF;","names":[]}

package/build/src/base_event.d.ts

@@ -0,0 +1,21 @@
+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/debug.d.ts

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

package/build/{emitter-253440aa.d.ts → src/emitter.d.ts}

@@ -1,59 +1,12 @@
-import { Application } from '@adonisjs/application';
-import { UnsubscribeFunction } from 'emittery';
-import { AllowedEventTypes, BufferedEventsList, Constructor, BufferedEvent, Listener, ListenerMethod, ListenerClassWithHandleMethod, LazyImport } from './src/types.js';
-
-/**
- * Exposes API to filter, find events from the events buffer.
- */
-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;
-}
-
+import type { Application } from '@adonisjs/application';
+import { type UnsubscribeFunction } from 'emittery';
+import { EventsBuffer } from './events_buffer.js';
+import type { Listener, LazyImport, Constructor, ListenerMethod, AllowedEventTypes, ListenerClassWithHandleMethod } from './types.js';
 /**
  * Event emitter is built on top of emittery with support class based
  * events and listeners
  */
-declare class Emitter<EventsList extends Record<string | symbol | number, any>> {
+export declare class Emitter<EventsList extends Record<string | symbol | number, any>> {
     #private;
     /**
      * Returns a map of events and their registered listeners. The
@@ -152,5 +105,3 @@ declare class Emitter<EventsList extends Record<string | symbol | number, any>>
      */
     restore(): void;
 }
-
-export { Emitter as E };

package/build/src/events_buffer.d.ts

@@ -0,0 +1,53 @@
+import type { AllowedEventTypes, BufferedEvent, BufferedEventsList, Constructor } from './types.js';
+/**
+ * Callback function to narrow down an event from
+ * the events buffer list
+ */
+type EventFinderCallback<EventsList extends Record<string | symbol | number, any>, Event extends keyof EventsList | Constructor> = (event: Event extends keyof EventsList ? BufferedEvent<Event, EventsList[Event]> : Event extends Constructor<infer A> ? BufferedEvent<Event, A> : never) => boolean;
+/**
+ * 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>(event: Event, finder?: EventFinderCallback<EventsList, Event>): boolean;
+    /**
+     * Find a specific event
+     */
+    find<Event extends keyof EventsList | Constructor>(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
+     */
+    assertEmitted<Event extends keyof EventsList | Constructor>(event: Event, finder?: EventFinderCallback<EventsList, Event>): void;
+    /**
+     * Assert number of times an event has been emitted
+     */
+    assertEmittedCount<Event extends keyof EventsList | Constructor>(event: Event, count: number): void;
+    /**
+     * Assert a given event has been not been emitted
+     */
+    assertNotEmitted<Event extends keyof EventsList | Constructor<any>>(event: Event, finder?: EventFinderCallback<EventsList, Event>): void;
+    /**
+     * Assert a given event has been not been emitted
+     */
+    assertNoneEmitted(): void;
+    /**
+     * Flush events collected within memory
+     */
+    flush(): void;
+}
+export {};

package/build/src/types.d.ts

@@ -1,28 +1,28 @@
 /**
  * Data types for event name
  */
-type AllowedEventTypes = string | symbol | number | Constructor;
+export type AllowedEventTypes = string | symbol | number | Constructor;
 /**
  * Class constructor type
  */
-type Constructor<T = unknown> = new (...args: any[]) => T;
+export type Constructor<T = unknown> = new (...args: any[]) => T;
 /**
  * A function that lazily imports a middleware
  */
-type LazyImport<DefaultExport> = () => Promise<{
+export type LazyImport<DefaultExport> = () => Promise<{
     default: DefaultExport;
 }>;
 /**
  * Data structure for a buffered event
  */
-type BufferedEvent<Event, Data> = {
+export type BufferedEvent<Event, Data> = {
     event: Event;
     data: Data;
 };
 /**
  * Event list item inside bufferred items
  */
-type BufferedEventsList<EventsList> = {
+export type BufferedEventsList<EventsList> = {
     [Name in keyof EventsList]: BufferedEvent<Name, EventsList[Name]>;
 }[keyof EventsList] | BufferedEvent<Constructor<any>, any>;
 /**
@@ -30,28 +30,26 @@ type BufferedEventsList<EventsList> = {
  * spread args can type hint dependencies and container will
  * resolve them
  */
-type ListenerMethod<Data> = (data: Data, ...args: any[]) => any | Promise<any>;
+export type ListenerMethod<Data> = (data: Data, ...args: any[]) => any | Promise<any>;
 /**
  * The event listener defined as an inline callback
  */
-type ListenerFn<Data> = (data: Data) => any | Promise<any>;
+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.
  */
-type GetListenersMethods<Listener extends Constructor<any>, Data> = {
+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
  */
-type ListenerClassWithHandleMethod<Data> = Constructor<{
+export type ListenerClassWithHandleMethod<Data> = Constructor<{
     handle: ListenerMethod<Data>;
 }>;
 /**
  * The event listener defined as an inline callback, string
  * listener class reference or a lazily imported listener
  */
-type Listener<Data, ListenerClass extends Constructor> = ListenerFn<Data> | string | [LazyImport<ListenerClass> | ListenerClass, GetListenersMethods<ListenerClass, Data>?];
-
-export { AllowedEventTypes, BufferedEvent, BufferedEventsList, Constructor, GetListenersMethods, LazyImport, Listener, ListenerClassWithHandleMethod, ListenerFn, ListenerMethod };
+export type Listener<Data, ListenerClass extends Constructor> = ListenerFn<Data> | string | [LazyImport<ListenerClass> | ListenerClass, GetListenersMethods<ListenerClass, Data>?];

package/build/src/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/build/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@adonisjs/events",
-  "version": "9.0.0-0",
+  "version": "9.0.0-1",
   "description": "An implementation of the event emitter built on top of emittery",
   "main": "build/index.js",
   "type": "module",
   "files": [
-    "build"
+    "build",
+    "!build/bin",
+    "!build/tests"
   ],
   "imports": {
     "#listeners/*": "./tests/app/listeners/*.js"
@@ -23,7 +25,8 @@
     "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 && tsup-node",
+    "precompile": "npm run lint && npm run clean",
+    "compile": "tsup-node && tsc --emitDeclarationOnly --declaration",
     "build": "npm run compile",
     "release": "np",
     "version": "npm run build",
@@ -31,7 +34,7 @@
     "prepublishOnly": "npm run build",
     "lint": "eslint . --ext=.ts",
     "sync-labels": "github-label-sync --labels .github/labels.json adonisjs/events",
-    "quick:test": "node --loader=ts-node/esm --experimental-import-meta-resolve bin/test.ts"
+    "quick:test": "node --loader=ts-node/esm --experimental-import-meta-resolve --enable-source-maps bin/test.ts"
   },
   "keywords": [
     "emitter",
@@ -40,39 +43,39 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@adonisjs/application": "^8.0.0-0",
-    "@adonisjs/eslint-config": "^1.1.8",
-    "@adonisjs/fold": "^9.9.3-10",
-    "@adonisjs/prettier-config": "^1.1.8",
-    "@adonisjs/tsconfig": "^1.1.8",
-    "@commitlint/cli": "^17.8.0",
-    "@commitlint/config-conventional": "^17.8.0",
-    "@japa/assert": "^2.0.0",
+    "@adonisjs/application": "^8.0.0-2",
+    "@adonisjs/eslint-config": "^1.1.9",
+    "@adonisjs/fold": "^9.9.3-11",
+    "@adonisjs/prettier-config": "^1.1.9",
+    "@adonisjs/tsconfig": "^1.1.9",
+    "@commitlint/cli": "^18.4.3",
+    "@commitlint/config-conventional": "^18.4.3",
+    "@japa/assert": "^2.0.1",
     "@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",
+    "@japa/file-system": "^2.0.1",
+    "@japa/runner": "^3.1.0",
+    "@swc/core": "^1.3.99",
+    "@types/node": "^20.9.4",
     "c8": "^8.0.1",
     "cross-env": "^7.0.3",
     "del-cli": "^5.1.0",
-    "eslint": "^8.51.0",
+    "eslint": "^8.54.0",
     "github-label-sync": "^2.3.1",
     "husky": "^8.0.3",
     "np": "^8.0.4",
-    "prettier": "^3.0.3",
+    "prettier": "^3.1.0",
     "ts-node": "^10.9.1",
-    "tsup": "^7.2.0",
-    "typescript": "^5.2.2"
+    "tsup": "^8.0.1",
+    "typescript": "5.2.2"
   },
   "dependencies": {
-    "@poppinss/utils": "^6.5.0",
-    "@sindresorhus/is": "^6.0.1",
+    "@poppinss/utils": "^6.5.1",
+    "@sindresorhus/is": "^6.1.0",
     "emittery": "^1.0.1"
   },
   "peerDependencies": {
-    "@adonisjs/application": "^8.0.0-0",
-    "@adonisjs/fold": "^9.9.3-10"
+    "@adonisjs/application": "^8.0.0-2",
+    "@adonisjs/fold": "^9.9.3-11"
   },
   "repository": {
     "type": "git",
@@ -119,7 +122,8 @@
     "outDir": "./build",
     "clean": true,
     "format": "esm",
-    "dts": true,
+    "dts": false,
+    "sourcemap": true,
     "target": "esnext"
   }
 }