evnty 1.2.5 → 1.3.0

package/README.md

@@ -57,67 +57,38 @@ Using npm:
 npm install evnty
 ```
 
-## Interface
-
-```typescript
-type Unsubscribe = () => void;
-type Listener = (...args: any[]) => void;
-type Dispose = () => void;
-type Filter = (...args: any[]) => boolean;
-type Mapper = <T = any>(...args: any[]) => T;
-type Reducer = <T = any>(value: any, ...args: any[]) => T;
-
-class Dismiss {
-  async after(process: () => MaybePromise<any>): Promise<void>;
-  afterTimes(count: number): () => void;
-}
-
-class Event {
-  // Merges multiple events
-  static merge(...events: Event[]): Event;
-  // Emits event by interval
-  static interval(interval: number): Event;
-
-  readonly size: Number;
-
-  constructor(dispose?: Dispose);
-  lacks(listener: Listener): boolean;
-  has(listener: Listener): boolean;
-  off(listener: Listener): void;
-  on(listener: Listener): Dismiss;
-  once(listener: Listener): Dismiss;
-  clear(): void;
-  toPromise(): Promise<any[]>;
-  filter(filter: Filter): Event;
-  map(mapper: Mapper): Event;
-  reduce(reducer: Reducer, init: any): Event;
-  dispose(): Dispose;
-}
-```
-
-## Usage
+## Examples
 
 ```js
-import event, { once } from 'evnty';
+import createEvent, { Event, once } from 'evnty';
 
-const handleClick = ({ button }) => console.log('Clicked button is', button);
-const clickEvent = event();
+// Creates a click event
+type Click = { button: string };
+const clickEvent = createEvent<[Click]>();
+const handleClick = ({ button }: Click) => console.log('Clicked button is', button);
 const unsubscribeClick = clickEvent.on(handleClick);
 
-const keyPressEvent = event();
-const handleKeyPress = ({ key }) => console.log('Key pressed', key);
+// Creates a key press event
+type KeyPress = { key: string };
+const keyPressEvent = createEvent<[KeyPress]>();
+const handleKeyPress = ({ key }: KeyPress) => console.log('Key pressed', key);
 const unsubscribeKeyPress = keyPressEvent.on(handleKeyPress);
 
-const handleInput = ({ button, key }) => {};
+// Merges click and key press events into input event
+type Input = Click | KeyPress;
+const handleInput = (input: Input) => console.log('Input', input);;
 const inputEvent = Event.merge(clickEvent, keyPressEvent);
 inputEvent.on(handleInput);
 
+// Filters a click event to only include left-click events.
 const handleLeftClick = () => console.log('Left button is clicked');
 const leftClickEvent = clickEvent.filter(({ button }) => button === 'left');
 leftClickEvent.on(handleLeftClick);
 
-setTimeout(() => keyPressEvent, 100, 'Enter');
-await once(keyPressEvent);
+// Will press Enter after one second
+setTimeout(keyPressEvent, 1000, { key: 'Enter' });
+// Waits once the first Enter key press event occurs
+await once(keyPressEvent.first(({ key }) => key === 'Enter'));
 
 keyPressEvent({ key: 'W' });
 keyPressEvent({ key: 'A' });
@@ -128,9 +99,14 @@ clickEvent({ button: 'right' });
 clickEvent({ button: 'left' });
 clickEvent({ button: 'middle' });
 
+// Unsubscribe click listener
 unsubscribeClick();
-unsubscribeKeyPress.after(() => once(keyPressEvent));
+// It does not log anything because of click listener is unsubscribed
 leftClickEvent.off(handleLeftClick);
+
+// Unsubscribe key press listener once first Esc key press occur
+unsubscribeKeyPress.after(() => once(keyPressEvent.first(({ key }) => key === 'Esc')));
+// Press Esc to unsubscribe key press listener
 keyPressEvent({ key: 'Esc' });
 ```
 

package/build/index.cjs

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    FunctionExt: function() {
+        return FunctionExt;
+    },
     Dismiss: function() {
         return Dismiss;
     },
@@ -18,8 +21,11 @@ _export(exports, {
     once: function() {
         return once;
     },
-    default: function() {
+    createEvent: function() {
         return createEvent;
+    },
+    default: function() {
+        return _default;
     }
 });
 class FunctionExt extends Function {
@@ -29,11 +35,11 @@ class FunctionExt extends Function {
     }
 }
 class Dismiss extends FunctionExt {
-    constructor(dismiss){
-        super(dismiss);
+    constructor(callback){
+        super(callback);
     }
-    async after(process) {
-        await process();
+    async after(task) {
+        await task();
         this();
     }
     afterTimes(count) {
@@ -113,6 +119,16 @@ class Event extends FunctionExt {
         const filteredEvent = new Event(dispose);
         return filteredEvent;
     }
+    first(filter) {
+        const dispose = this.on(async (...args)=>{
+            if (filteredEvent.size > 0 && await filter(...args)) {
+                dispose();
+                await filteredEvent(...args);
+            }
+        });
+        const filteredEvent = new Event(dispose);
+        return filteredEvent;
+    }
     map(mapper) {
         const dispose = this.on(async (...args)=>{
             if (mappedEvent.size > 0) {
@@ -138,8 +154,9 @@ class Event extends FunctionExt {
 const once = (event)=>{
     return new Promise((resolve)=>event.once((...args)=>resolve(args)));
 };
-function createEvent() {
+const createEvent = ()=>{
     return new Event();
-}
+};
+const _default = createEvent;
 
 //# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;\n\nexport interface Unsubscribe {\n  (): void;\n}\n\nexport interface Listener<T extends unknown[], R> {\n  (...args: T): MaybePromise<R | void>;\n}\n\nexport interface Dispose {\n  (): void;\n}\n\nexport interface Filter<T extends unknown[]> {\n  (...args: T): MaybePromise<boolean>;\n}\n\nexport interface Mapper<T extends unknown[], R> {\n  (...args: T): R;\n}\n\nexport interface Reducer<T extends unknown[], R> {\n  (value: R, ...args: T): R;\n}\n\nexport type Listeners<T extends unknown[], R> = Listener<T, R>[];\n\nclass FunctionExt extends Function {\n  constructor(func: Function) {\n    super();\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\nexport interface Dismiss {\n  (): Promise<void> | void;\n}\n\nexport class Dismiss extends FunctionExt {\n  constructor(dismiss: Unsubscribe) {\n    super(dismiss);\n  }\n  async after(process: () => MaybePromise<unknown>) {\n    await process();\n    this();\n  }\n  afterTimes(count: number) {\n    return () => {\n      if (!--count) {\n        this();\n      }\n    };\n  }\n}\n\nconst eventEmitter = async <A extends unknown[], R>(listeners: Listeners<A, R>, ...args: A) => {\n  return Promise.all(listeners.map((listener) => listener(...args)));\n};\n\nexport interface Event<T extends unknown[], R> {\n  (...args: T): Promise<(R | undefined)[]>;\n}\n\ntype UnpackParameters<T> = T extends Event<infer P, unknown> ? P : never;\ntype UnpackReturn<T> = T extends Event<unknown[], infer R> ? R : never;\ntype UnpackAllParameters<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackParameters<T[K]> }[number];\ntype UnpackAllReturn<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackReturn<T[K]> }[number];\n\nexport class Event<T extends unknown[], R = void> extends FunctionExt {\n  static merge<Events extends Event<any[], any>[]>(...events: Events) {\n    const mergedEvent = new Event<UnpackAllParameters<Events>, UnpackAllReturn<Events>>();\n    events.forEach((event) => event.on(mergedEvent));\n    return mergedEvent;\n  }\n\n  static interval(interval: number) {\n    let counter = 0;\n    const intervalEvent = new Event<[number], void>(() => clearInterval(timerId));\n    const timerId: NodeJS.Timeout = setInterval(() => intervalEvent(counter++), interval);\n    return intervalEvent;\n  }\n\n  private listeners: Listeners<T, R>;\n  readonly dispose: Dispose;\n\n  constructor(dispose?: Dispose) {\n    const listeners: Listeners<T, R> = [];\n    const fn = (...args: T) => eventEmitter(listeners, ...args);\n\n    super(fn);\n    this.listeners = listeners;\n    this.dispose = () => {\n      this.clear();\n      dispose?.();\n    };\n  }\n\n  get size(): number {\n    return this.listeners.length;\n  }\n\n  lacks(listener: Listener<T, R>): boolean {\n    return this.listeners.indexOf(listener) === -1;\n  }\n\n  has(listener: Listener<T, R>): boolean {\n    return this.listeners.indexOf(listener) !== -1;\n  }\n\n  off(listener: Listener<T, R>): void {\n    let index = this.listeners.indexOf(listener);\n    while (~index) {\n      this.listeners.splice(index, 1);\n      index = this.listeners.indexOf(listener);\n    }\n  }\n\n  on(listener: Listener<T, R>): Dismiss {\n    this.listeners.push(listener);\n    return new Dismiss(() => this.off(listener));\n  }\n\n  once(listener: Listener<T, R>): Dismiss {\n    const oneTimeListener = (...args: T) => {\n      this.off(oneTimeListener);\n      return listener(...args);\n    };\n    return this.on(oneTimeListener);\n  }\n\n  clear() {\n    this.listeners.splice(0);\n  }\n\n  toPromise(): Promise<T> {\n    return new Promise((resolve) => this.once((...args) => resolve(args)));\n  }\n\n  filter(filter: Filter<T>) {\n    const dispose = this.on(async (...args) => {\n      if (filteredEvent.size > 0 && (await filter(...args))) {\n        await filteredEvent(...args);\n      }\n    });\n    const filteredEvent = new Event<T, R>(dispose);\n    return filteredEvent;\n  }\n\n  map<R>(mapper: Mapper<T, R>) {\n    const dispose = this.on(async (...args) => {\n      if (mappedEvent.size > 0) {\n        const value = await mapper(...args);\n        mappedEvent(value);\n      }\n    });\n    const mappedEvent = new Event(dispose);\n    return mappedEvent;\n  }\n\n  reduce<R>(reducer: Reducer<T, R>, init: R) {\n    let value = init;\n    const dispose = this.on(async (...args) => {\n      if (reducedEvent.size > 0) {\n        value = await reducer(value, ...args);\n        reducedEvent(value);\n      }\n    });\n    const reducedEvent = new Event(dispose);\n    return reducedEvent;\n  }\n}\n\nexport const once = <T extends unknown[], R = void>(event: Event<T, R>): Promise<T> => {\n  return new Promise((resolve) => event.once((...args) => resolve(args)));\n};\n\nexport default function createEvent<T extends unknown[], R = void>() {\n  return new Event<T, R>();\n}\n"],"names":["Dismiss","Event","once","createEvent","FunctionExt","Function","constructor","func","Object","setPrototypeOf","prototype","dismiss","after","process","afterTimes","count","eventEmitter","listeners","args","Promise","all","map","listener","merge","events","mergedEvent","forEach","event","on","interval","counter","intervalEvent","clearInterval","timerId","setInterval","dispose","fn","clear","size","length","lacks","indexOf","has","off","index","splice","push","oneTimeListener","toPromise","resolve","filter","filteredEvent","mapper","mappedEvent","value","reduce","reducer","init","reducedEvent"],"mappings":"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"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;\n\nexport interface Unsubscribe {\n  (): void;\n}\n\nexport interface Listener<T extends unknown[], R = unknown> {\n  (...args: T): MaybePromise<R | void>;\n}\n\nexport interface Dispose {\n  (): void;\n}\n\nexport interface Filter<T extends unknown[]> {\n  (...args: T): MaybePromise<boolean>;\n}\n\nexport interface Mapper<T extends unknown[], R = unknown> {\n  (...args: T): R;\n}\n\nexport interface Reducer<T extends unknown[], R = unknown> {\n  (value: R, ...args: T): R;\n}\n\nexport type Listeners<T extends unknown[], R = unknown> = Listener<T, R>[];\n\n/**\n * An abstract class that extends the built-in Function class. It allows instances of the class\n * to be called as functions. When an instance of FunctionExt is called as a function, it will\n * call the function passed to its constructor with the same arguments.\n * @internal\n */\nexport abstract class FunctionExt extends Function {\n  constructor(func: Function) {\n    super();\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\nexport interface Dismiss {\n  (): Promise<void> | void;\n}\n\nexport interface Task {\n  (): MaybePromise<unknown>;\n}\n\nexport class Dismiss extends FunctionExt {\n  constructor(callback: Unsubscribe) {\n    super(callback);\n  }\n\n  async after(task: Task) {\n    await task();\n    this();\n  }\n\n  afterTimes(count: number) {\n    return () => {\n      if (!--count) {\n        this();\n      }\n    };\n  }\n}\n\nconst eventEmitter = async <A extends unknown[], R>(listeners: Listeners<A, R>, ...args: A) => {\n  return Promise.all(listeners.map((listener) => listener(...args)));\n};\n\nexport interface Event<T extends unknown[], R> {\n  (...args: T): Promise<(R | undefined)[]>;\n}\n\ntype UnpackParameters<T> = T extends Event<infer P, unknown> ? P : never;\n\ntype UnpackReturn<T> = T extends Event<unknown[], infer R> ? R : never;\n\ntype UnpackAllParameters<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackParameters<T[K]> }[number];\n\ntype UnpackAllReturn<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackReturn<T[K]> }[number];\n\n/**\n * A class representing an anonymous event that can be listened to or triggered.\n * @example\n * // Create a click event.\n * const clickEvent = new Event<[x: number, y: number], void>();\n *\n * @template T - The tuple of arguments that the event takes.\n * @template R - The return type of the event.\n */\nexport class Event<T extends unknown[], R = void> extends FunctionExt {\n  /**\n   * Merges multiple events into a single event.\n   * @param events - The events to merge.\n   * @returns The merged event.\n   */\n  static merge<Events extends Event<any[], any>[]>(...events: Events) {\n    const mergedEvent = new Event<UnpackAllParameters<Events>, UnpackAllReturn<Events>>();\n    events.forEach((event) => event.on(mergedEvent));\n    return mergedEvent;\n  }\n\n  /**\n   * Creates an event that triggers at a specified interval.\n   * @param interval - The interval at which to trigger the event.\n   * @returns The interval event.\n   */\n  static interval(interval: number) {\n    let counter = 0;\n    const intervalEvent = new Event<[number], void>(() => clearInterval(timerId));\n    const timerId: NodeJS.Timeout = setInterval(() => intervalEvent(counter++), interval);\n    return intervalEvent;\n  }\n\n  /**\n   * The array of listeners for the event.\n   */\n  private listeners: Listeners<T, R>;\n\n  /**\n   * A function that disposes of the event and its listeners.\n   */\n  readonly dispose: Dispose;\n\n  /**\n   * Creates a new event.\n   * @param dispose - A function to dispose of the event and its listeners.\n   */\n  constructor(dispose?: Dispose) {\n    const listeners: Listeners<T, R> = [];\n    const fn = (...args: T) => eventEmitter(listeners, ...args);\n\n    super(fn);\n    this.listeners = listeners;\n    this.dispose = () => {\n      this.clear();\n      dispose?.();\n    };\n  }\n\n  /**\n   * The number of listeners for the event.\n   */\n  get size(): number {\n    return this.listeners.length;\n  }\n\n  /**\n   * Checks if a listener is not registered for the event.\n   * @param listener - The listener to check.\n   * @returns `true` if the listener is not registered, `false` otherwise.\n   */\n  lacks(listener: Listener<T, R>): boolean {\n    return this.listeners.indexOf(listener) === -1;\n  }\n\n  /**\n   * Checks if a listener is registered for the event.\n   * @param listener - The listener to check.\n   * @returns `true` if the listener is registered, `false` otherwise.\n   */\n  has(listener: Listener<T, R>): boolean {\n    return this.listeners.indexOf(listener) !== -1;\n  }\n\n  /**\n   * Removes a listener from the event.\n   * @param listener - The listener to remove.\n   */\n  off(listener: Listener<T, R>): void {\n    let index = this.listeners.indexOf(listener);\n    while (~index) {\n      this.listeners.splice(index, 1);\n      index = this.listeners.indexOf(listener);\n    }\n  }\n\n  /**\n   * Adds a listener to the event.\n   * @param listener - The listener to add.\n   * @returns An object that can be used to remove the listener.\n   */\n  on(listener: Listener<T, R>): Dismiss {\n    this.listeners.push(listener);\n    return new Dismiss(() => this.off(listener));\n  }\n\n  /**\n   * Adds a listener to the event that will only be called once.\n   * @param listener - The listener to add.\n   * @returns An object that can be used to remove the listener.\n   */\n  once(listener: Listener<T, R>): Dismiss {\n    const oneTimeListener = (...args: T) => {\n      this.off(oneTimeListener);\n      return listener(...args);\n    };\n    return this.on(oneTimeListener);\n  }\n\n  /**\n   * Removes all listeners from the event.\n   */\n  clear() {\n    this.listeners.splice(0);\n  }\n\n  /**\n   * Converts the event to a promise that resolves with the event arguments.\n   * @returns A promise that resolves with the event arguments.\n   */\n  toPromise(): Promise<T> {\n    return new Promise((resolve) => this.once((...args) => resolve(args)));\n  }\n\n  /**\n   * Creates a new event that only triggers if the filter function returns `true`.\n   * @param filter - The filter function.\n   * @returns The filtered event.\n   */\n  filter(filter: Filter<T>) {\n    const dispose = this.on(async (...args) => {\n      if (filteredEvent.size > 0 && (await filter(...args))) {\n        await filteredEvent(...args);\n      }\n    });\n    const filteredEvent = new Event<T, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Creates a new event that only triggers once if the filter function returns `true`.\n   * @param filter - The filter function.\n   * @returns The filtered event.\n   */\n  first(filter: Filter<T>) {\n    const dispose = this.on(async (...args) => {\n      if (filteredEvent.size > 0 && (await filter(...args))) {\n        dispose();\n        await filteredEvent(...args);\n      }\n    });\n    const filteredEvent = new Event<T, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Creates a new event that maps the event arguments to a new value.\n   * @param mapper - The mapper function.\n   * @returns The mapped event.\n   */\n  map<M, MR = unknown>(mapper: Mapper<T, M>) {\n    const dispose = this.on(async (...args) => {\n      if (mappedEvent.size > 0) {\n        const value = await mapper(...args);\n        mappedEvent(value);\n      }\n    });\n    const mappedEvent = new Event<[M], MR>(dispose);\n    return mappedEvent;\n  }\n\n  /**\n   * Creates a new event that reduces the event arguments to a single value.\n   * @param reducer - The reducer function.\n   * @param init - The initial value for the reducer.\n   * @returns The reduced event.\n   */\n  reduce<A, AR = unknown>(reducer: Reducer<T, A>, init: A) {\n    let value = init;\n    const dispose = this.on(async (...args) => {\n      if (reducedEvent.size > 0) {\n        value = await reducer(value, ...args);\n        reducedEvent(value);\n      }\n    });\n    const reducedEvent = new Event<[A], AR>(dispose);\n    return reducedEvent;\n  }\n}\n\n/**\n * Returns a promise that resolves with the arguments passed to the first invocation of the given event.\n * @param event The event to listen for.\n * @returns A promise that resolves with the arguments passed to the first invocation of the given event.\n */\nexport const once = <T extends unknown[], R = void>(event: Event<T, R>): Promise<T> => {\n  return new Promise((resolve) => event.once((...args) => resolve(args)));\n};\n\n/**\n * Creates a new instance of the Event class.\n * @returns {Event<T, R>} A new instance of the Event class.\n * @template T The type of the arguments passed to the event.\n * @template R The return type of the event.\n */\nexport const createEvent = <T extends unknown[], R = void>(): Event<T, R> => {\n  return new Event<T, R>();\n};\n\nexport default createEvent;\n\n/**\n * A type helper that extracts the event listener type\n *\n * @template E - The event object type.\n * @template T - The event type extracted from the event object.\n * @template R - The result type returned by the event handler function.\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n"],"names":["FunctionExt","Dismiss","Event","once","createEvent","Function","constructor","func","Object","setPrototypeOf","prototype","callback","after","task","afterTimes","count","eventEmitter","listeners","args","Promise","all","map","listener","merge","events","mergedEvent","forEach","event","on","interval","counter","intervalEvent","clearInterval","timerId","setInterval","dispose","fn","clear","size","length","lacks","indexOf","has","off","index","splice","push","oneTimeListener","toPromise","resolve","filter","filteredEvent","first","mapper","mappedEvent","value","reduce","reducer","init","reducedEvent"],"mappings":"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"}

package/build/index.d.ts

@@ -1,8 +1,8 @@
-type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;
+export type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;
 export interface Unsubscribe {
     (): void;
 }
-export interface Listener<T extends unknown[], R> {
+export interface Listener<T extends unknown[], R = unknown> {
     (...args: T): MaybePromise<R | void>;
 }
 export interface Dispose {
@@ -11,22 +11,31 @@ export interface Dispose {
 export interface Filter<T extends unknown[]> {
     (...args: T): MaybePromise<boolean>;
 }
-export interface Mapper<T extends unknown[], R> {
+export interface Mapper<T extends unknown[], R = unknown> {
     (...args: T): R;
 }
-export interface Reducer<T extends unknown[], R> {
+export interface Reducer<T extends unknown[], R = unknown> {
     (value: R, ...args: T): R;
 }
-export type Listeners<T extends unknown[], R> = Listener<T, R>[];
-declare class FunctionExt extends Function {
+export type Listeners<T extends unknown[], R = unknown> = Listener<T, R>[];
+/**
+ * An abstract class that extends the built-in Function class. It allows instances of the class
+ * to be called as functions. When an instance of FunctionExt is called as a function, it will
+ * call the function passed to its constructor with the same arguments.
+ * @internal
+ */
+export declare abstract class FunctionExt extends Function {
     constructor(func: Function);
 }
 export interface Dismiss {
     (): Promise<void> | void;
 }
+export interface Task {
+    (): MaybePromise<unknown>;
+}
 export declare class Dismiss extends FunctionExt {
-    constructor(dismiss: Unsubscribe);
-    after(process: () => MaybePromise<unknown>): Promise<void>;
+    constructor(callback: Unsubscribe);
+    after(task: Task): Promise<void>;
     afterTimes(count: number): () => void;
 }
 export interface Event<T extends unknown[], R> {
@@ -40,24 +49,128 @@ type UnpackAllParameters<T extends Event<unknown[], unknown>[]> = {
 type UnpackAllReturn<T extends Event<unknown[], unknown>[]> = {
     [K in keyof T]: UnpackReturn<T[K]>;
 }[number];
+/**
+ * A class representing an anonymous event that can be listened to or triggered.
+ * @example
+ * // Create a click event.
+ * const clickEvent = new Event<[x: number, y: number], void>();
+ *
+ * @template T - The tuple of arguments that the event takes.
+ * @template R - The return type of the event.
+ */
 export declare class Event<T extends unknown[], R = void> extends FunctionExt {
+    /**
+     * Merges multiple events into a single event.
+     * @param events - The events to merge.
+     * @returns The merged event.
+     */
     static merge<Events extends Event<any[], any>[]>(...events: Events): Event<UnpackAllParameters<Events>, UnpackAllReturn<Events>>;
+    /**
+     * Creates an event that triggers at a specified interval.
+     * @param interval - The interval at which to trigger the event.
+     * @returns The interval event.
+     */
     static interval(interval: number): Event<[number], void>;
+    /**
+     * The array of listeners for the event.
+     */
     private listeners;
+    /**
+     * A function that disposes of the event and its listeners.
+     */
     readonly dispose: Dispose;
+    /**
+     * Creates a new event.
+     * @param dispose - A function to dispose of the event and its listeners.
+     */
     constructor(dispose?: Dispose);
+    /**
+     * The number of listeners for the event.
+     */
     get size(): number;
+    /**
+     * Checks if a listener is not registered for the event.
+     * @param listener - The listener to check.
+     * @returns `true` if the listener is not registered, `false` otherwise.
+     */
     lacks(listener: Listener<T, R>): boolean;
+    /**
+     * Checks if a listener is registered for the event.
+     * @param listener - The listener to check.
+     * @returns `true` if the listener is registered, `false` otherwise.
+     */
     has(listener: Listener<T, R>): boolean;
+    /**
+     * Removes a listener from the event.
+     * @param listener - The listener to remove.
+     */
     off(listener: Listener<T, R>): void;
+    /**
+     * Adds a listener to the event.
+     * @param listener - The listener to add.
+     * @returns An object that can be used to remove the listener.
+     */
     on(listener: Listener<T, R>): Dismiss;
+    /**
+     * Adds a listener to the event that will only be called once.
+     * @param listener - The listener to add.
+     * @returns An object that can be used to remove the listener.
+     */
     once(listener: Listener<T, R>): Dismiss;
+    /**
+     * Removes all listeners from the event.
+     */
     clear(): void;
+    /**
+     * Converts the event to a promise that resolves with the event arguments.
+     * @returns A promise that resolves with the event arguments.
+     */
     toPromise(): Promise<T>;
+    /**
+     * Creates a new event that only triggers if the filter function returns `true`.
+     * @param filter - The filter function.
+     * @returns The filtered event.
+     */
     filter(filter: Filter<T>): Event<T, R>;
-    map<R>(mapper: Mapper<T, R>): Event<unknown[], void>;
-    reduce<R>(reducer: Reducer<T, R>, init: R): Event<unknown[], void>;
+    /**
+     * Creates a new event that only triggers once if the filter function returns `true`.
+     * @param filter - The filter function.
+     * @returns The filtered event.
+     */
+    first(filter: Filter<T>): Event<T, R>;
+    /**
+     * Creates a new event that maps the event arguments to a new value.
+     * @param mapper - The mapper function.
+     * @returns The mapped event.
+     */
+    map<M, MR = unknown>(mapper: Mapper<T, M>): Event<[M], MR>;
+    /**
+     * Creates a new event that reduces the event arguments to a single value.
+     * @param reducer - The reducer function.
+     * @param init - The initial value for the reducer.
+     * @returns The reduced event.
+     */
+    reduce<A, AR = unknown>(reducer: Reducer<T, A>, init: A): Event<[A], AR>;
 }
+/**
+ * Returns a promise that resolves with the arguments passed to the first invocation of the given event.
+ * @param event The event to listen for.
+ * @returns A promise that resolves with the arguments passed to the first invocation of the given event.
+ */
 export declare const once: <T extends unknown[], R = void>(event: Event<T, R>) => Promise<T>;
-export default function createEvent<T extends unknown[], R = void>(): Event<T, R>;
-export {};
+/**
+ * Creates a new instance of the Event class.
+ * @returns {Event<T, R>} A new instance of the Event class.
+ * @template T The type of the arguments passed to the event.
+ * @template R The return type of the event.
+ */
+export declare const createEvent: <T extends unknown[], R = void>() => Event<T, R>;
+export default createEvent;
+/**
+ * A type helper that extracts the event listener type
+ *
+ * @template E - The event object type.
+ * @template T - The event type extracted from the event object.
+ * @template R - The result type returned by the event handler function.
+ */
+export type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;

package/build/index.js

@@ -1,15 +1,15 @@
-class FunctionExt extends Function {
+export class FunctionExt extends Function {
     constructor(func){
         super();
         return Object.setPrototypeOf(func, new.target.prototype);
     }
 }
 export class Dismiss extends FunctionExt {
-    constructor(dismiss){
-        super(dismiss);
+    constructor(callback){
+        super(callback);
     }
-    async after(process) {
-        await process();
+    async after(task) {
+        await task();
         this();
     }
     afterTimes(count) {
@@ -89,6 +89,16 @@ export class Event extends FunctionExt {
         const filteredEvent = new Event(dispose);
         return filteredEvent;
     }
+    first(filter) {
+        const dispose = this.on(async (...args)=>{
+            if (filteredEvent.size > 0 && await filter(...args)) {
+                dispose();
+                await filteredEvent(...args);
+            }
+        });
+        const filteredEvent = new Event(dispose);
+        return filteredEvent;
+    }
     map(mapper) {
         const dispose = this.on(async (...args)=>{
             if (mappedEvent.size > 0) {
@@ -114,8 +124,9 @@ export class Event extends FunctionExt {
 export const once = (event)=>{
     return new Promise((resolve)=>event.once((...args)=>resolve(args)));
 };
-export default function createEvent() {
+export const createEvent = ()=>{
     return new Event();
-}
+};
+export default createEvent;
 
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;\n\nexport interface Unsubscribe {\n  (): void;\n}\n\nexport interface Listener<T extends unknown[], R> {\n  (...args: T): MaybePromise<R | void>;\n}\n\nexport interface Dispose {\n  (): void;\n}\n\nexport interface Filter<T extends unknown[]> {\n  (...args: T): MaybePromise<boolean>;\n}\n\nexport interface Mapper<T extends unknown[], R> {\n  (...args: T): R;\n}\n\nexport interface Reducer<T extends unknown[], R> {\n  (value: R, ...args: T): R;\n}\n\nexport type Listeners<T extends unknown[], R> = Listener<T, R>[];\n\nclass FunctionExt extends Function {\n  constructor(func: Function) {\n    super();\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\nexport interface Dismiss {\n  (): Promise<void> | void;\n}\n\nexport class Dismiss extends FunctionExt {\n  constructor(dismiss: Unsubscribe) {\n    super(dismiss);\n  }\n  async after(process: () => MaybePromise<unknown>) {\n    await process();\n    this();\n  }\n  afterTimes(count: number) {\n    return () => {\n      if (!--count) {\n        this();\n      }\n    };\n  }\n}\n\nconst eventEmitter = async <A extends unknown[], R>(listeners: Listeners<A, R>, ...args: A) => {\n  return Promise.all(listeners.map((listener) => listener(...args)));\n};\n\nexport interface Event<T extends unknown[], R> {\n  (...args: T): Promise<(R | undefined)[]>;\n}\n\ntype UnpackParameters<T> = T extends Event<infer P, unknown> ? P : never;\ntype UnpackReturn<T> = T extends Event<unknown[], infer R> ? R : never;\ntype UnpackAllParameters<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackParameters<T[K]> }[number];\ntype UnpackAllReturn<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackReturn<T[K]> }[number];\n\nexport class Event<T extends unknown[], R = void> extends FunctionExt {\n  static merge<Events extends Event<any[], any>[]>(...events: Events) {\n    const mergedEvent = new Event<UnpackAllParameters<Events>, UnpackAllReturn<Events>>();\n    events.forEach((event) => event.on(mergedEvent));\n    return mergedEvent;\n  }\n\n  static interval(interval: number) {\n    let counter = 0;\n    const intervalEvent = new Event<[number], void>(() => clearInterval(timerId));\n    const timerId: NodeJS.Timeout = setInterval(() => intervalEvent(counter++), interval);\n    return intervalEvent;\n  }\n\n  private listeners: Listeners<T, R>;\n  readonly dispose: Dispose;\n\n  constructor(dispose?: Dispose) {\n    const listeners: Listeners<T, R> = [];\n    const fn = (...args: T) => eventEmitter(listeners, ...args);\n\n    super(fn);\n    this.listeners = listeners;\n    this.dispose = () => {\n      this.clear();\n      dispose?.();\n    };\n  }\n\n  get size(): number {\n    return this.listeners.length;\n  }\n\n  lacks(listener: Listener<T, R>): boolean {\n    return this.listeners.indexOf(listener) === -1;\n  }\n\n  has(listener: Listener<T, R>): boolean {\n    return this.listeners.indexOf(listener) !== -1;\n  }\n\n  off(listener: Listener<T, R>): void {\n    let index = this.listeners.indexOf(listener);\n    while (~index) {\n      this.listeners.splice(index, 1);\n      index = this.listeners.indexOf(listener);\n    }\n  }\n\n  on(listener: Listener<T, R>): Dismiss {\n    this.listeners.push(listener);\n    return new Dismiss(() => this.off(listener));\n  }\n\n  once(listener: Listener<T, R>): Dismiss {\n    const oneTimeListener = (...args: T) => {\n      this.off(oneTimeListener);\n      return listener(...args);\n    };\n    return this.on(oneTimeListener);\n  }\n\n  clear() {\n    this.listeners.splice(0);\n  }\n\n  toPromise(): Promise<T> {\n    return new Promise((resolve) => this.once((...args) => resolve(args)));\n  }\n\n  filter(filter: Filter<T>) {\n    const dispose = this.on(async (...args) => {\n      if (filteredEvent.size > 0 && (await filter(...args))) {\n        await filteredEvent(...args);\n      }\n    });\n    const filteredEvent = new Event<T, R>(dispose);\n    return filteredEvent;\n  }\n\n  map<R>(mapper: Mapper<T, R>) {\n    const dispose = this.on(async (...args) => {\n      if (mappedEvent.size > 0) {\n        const value = await mapper(...args);\n        mappedEvent(value);\n      }\n    });\n    const mappedEvent = new Event(dispose);\n    return mappedEvent;\n  }\n\n  reduce<R>(reducer: Reducer<T, R>, init: R) {\n    let value = init;\n    const dispose = this.on(async (...args) => {\n      if (reducedEvent.size > 0) {\n        value = await reducer(value, ...args);\n        reducedEvent(value);\n      }\n    });\n    const reducedEvent = new Event(dispose);\n    return reducedEvent;\n  }\n}\n\nexport const once = <T extends unknown[], R = void>(event: Event<T, R>): Promise<T> => {\n  return new Promise((resolve) => event.once((...args) => resolve(args)));\n};\n\nexport default function createEvent<T extends unknown[], R = void>() {\n  return new Event<T, R>();\n}\n"],"names":["FunctionExt","Function","constructor","func","Object","setPrototypeOf","prototype","Dismiss","dismiss","after","process","afterTimes","count","eventEmitter","listeners","args","Promise","all","map","listener","Event","merge","events","mergedEvent","forEach","event","on","interval","counter","intervalEvent","clearInterval","timerId","setInterval","dispose","fn","clear","size","length","lacks","indexOf","has","off","index","splice","push","once","oneTimeListener","toPromise","resolve","filter","filteredEvent","mapper","mappedEvent","value","reduce","reducer","init","reducedEvent","createEvent"],"mappings":"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"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;\n\nexport interface Unsubscribe {\n  (): void;\n}\n\nexport interface Listener<T extends unknown[], R = unknown> {\n  (...args: T): MaybePromise<R | void>;\n}\n\nexport interface Dispose {\n  (): void;\n}\n\nexport interface Filter<T extends unknown[]> {\n  (...args: T): MaybePromise<boolean>;\n}\n\nexport interface Mapper<T extends unknown[], R = unknown> {\n  (...args: T): R;\n}\n\nexport interface Reducer<T extends unknown[], R = unknown> {\n  (value: R, ...args: T): R;\n}\n\nexport type Listeners<T extends unknown[], R = unknown> = Listener<T, R>[];\n\n/**\n * An abstract class that extends the built-in Function class. It allows instances of the class\n * to be called as functions. When an instance of FunctionExt is called as a function, it will\n * call the function passed to its constructor with the same arguments.\n * @internal\n */\nexport abstract class FunctionExt extends Function {\n  constructor(func: Function) {\n    super();\n    return Object.setPrototypeOf(func, new.target.prototype);\n  }\n}\n\nexport interface Dismiss {\n  (): Promise<void> | void;\n}\n\nexport interface Task {\n  (): MaybePromise<unknown>;\n}\n\nexport class Dismiss extends FunctionExt {\n  constructor(callback: Unsubscribe) {\n    super(callback);\n  }\n\n  async after(task: Task) {\n    await task();\n    this();\n  }\n\n  afterTimes(count: number) {\n    return () => {\n      if (!--count) {\n        this();\n      }\n    };\n  }\n}\n\nconst eventEmitter = async <A extends unknown[], R>(listeners: Listeners<A, R>, ...args: A) => {\n  return Promise.all(listeners.map((listener) => listener(...args)));\n};\n\nexport interface Event<T extends unknown[], R> {\n  (...args: T): Promise<(R | undefined)[]>;\n}\n\ntype UnpackParameters<T> = T extends Event<infer P, unknown> ? P : never;\n\ntype UnpackReturn<T> = T extends Event<unknown[], infer R> ? R : never;\n\ntype UnpackAllParameters<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackParameters<T[K]> }[number];\n\ntype UnpackAllReturn<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackReturn<T[K]> }[number];\n\n/**\n * A class representing an anonymous event that can be listened to or triggered.\n * @example\n * // Create a click event.\n * const clickEvent = new Event<[x: number, y: number], void>();\n *\n * @template T - The tuple of arguments that the event takes.\n * @template R - The return type of the event.\n */\nexport class Event<T extends unknown[], R = void> extends FunctionExt {\n  /**\n   * Merges multiple events into a single event.\n   * @param events - The events to merge.\n   * @returns The merged event.\n   */\n  static merge<Events extends Event<any[], any>[]>(...events: Events) {\n    const mergedEvent = new Event<UnpackAllParameters<Events>, UnpackAllReturn<Events>>();\n    events.forEach((event) => event.on(mergedEvent));\n    return mergedEvent;\n  }\n\n  /**\n   * Creates an event that triggers at a specified interval.\n   * @param interval - The interval at which to trigger the event.\n   * @returns The interval event.\n   */\n  static interval(interval: number) {\n    let counter = 0;\n    const intervalEvent = new Event<[number], void>(() => clearInterval(timerId));\n    const timerId: NodeJS.Timeout = setInterval(() => intervalEvent(counter++), interval);\n    return intervalEvent;\n  }\n\n  /**\n   * The array of listeners for the event.\n   */\n  private listeners: Listeners<T, R>;\n\n  /**\n   * A function that disposes of the event and its listeners.\n   */\n  readonly dispose: Dispose;\n\n  /**\n   * Creates a new event.\n   * @param dispose - A function to dispose of the event and its listeners.\n   */\n  constructor(dispose?: Dispose) {\n    const listeners: Listeners<T, R> = [];\n    const fn = (...args: T) => eventEmitter(listeners, ...args);\n\n    super(fn);\n    this.listeners = listeners;\n    this.dispose = () => {\n      this.clear();\n      dispose?.();\n    };\n  }\n\n  /**\n   * The number of listeners for the event.\n   */\n  get size(): number {\n    return this.listeners.length;\n  }\n\n  /**\n   * Checks if a listener is not registered for the event.\n   * @param listener - The listener to check.\n   * @returns `true` if the listener is not registered, `false` otherwise.\n   */\n  lacks(listener: Listener<T, R>): boolean {\n    return this.listeners.indexOf(listener) === -1;\n  }\n\n  /**\n   * Checks if a listener is registered for the event.\n   * @param listener - The listener to check.\n   * @returns `true` if the listener is registered, `false` otherwise.\n   */\n  has(listener: Listener<T, R>): boolean {\n    return this.listeners.indexOf(listener) !== -1;\n  }\n\n  /**\n   * Removes a listener from the event.\n   * @param listener - The listener to remove.\n   */\n  off(listener: Listener<T, R>): void {\n    let index = this.listeners.indexOf(listener);\n    while (~index) {\n      this.listeners.splice(index, 1);\n      index = this.listeners.indexOf(listener);\n    }\n  }\n\n  /**\n   * Adds a listener to the event.\n   * @param listener - The listener to add.\n   * @returns An object that can be used to remove the listener.\n   */\n  on(listener: Listener<T, R>): Dismiss {\n    this.listeners.push(listener);\n    return new Dismiss(() => this.off(listener));\n  }\n\n  /**\n   * Adds a listener to the event that will only be called once.\n   * @param listener - The listener to add.\n   * @returns An object that can be used to remove the listener.\n   */\n  once(listener: Listener<T, R>): Dismiss {\n    const oneTimeListener = (...args: T) => {\n      this.off(oneTimeListener);\n      return listener(...args);\n    };\n    return this.on(oneTimeListener);\n  }\n\n  /**\n   * Removes all listeners from the event.\n   */\n  clear() {\n    this.listeners.splice(0);\n  }\n\n  /**\n   * Converts the event to a promise that resolves with the event arguments.\n   * @returns A promise that resolves with the event arguments.\n   */\n  toPromise(): Promise<T> {\n    return new Promise((resolve) => this.once((...args) => resolve(args)));\n  }\n\n  /**\n   * Creates a new event that only triggers if the filter function returns `true`.\n   * @param filter - The filter function.\n   * @returns The filtered event.\n   */\n  filter(filter: Filter<T>) {\n    const dispose = this.on(async (...args) => {\n      if (filteredEvent.size > 0 && (await filter(...args))) {\n        await filteredEvent(...args);\n      }\n    });\n    const filteredEvent = new Event<T, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Creates a new event that only triggers once if the filter function returns `true`.\n   * @param filter - The filter function.\n   * @returns The filtered event.\n   */\n  first(filter: Filter<T>) {\n    const dispose = this.on(async (...args) => {\n      if (filteredEvent.size > 0 && (await filter(...args))) {\n        dispose();\n        await filteredEvent(...args);\n      }\n    });\n    const filteredEvent = new Event<T, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Creates a new event that maps the event arguments to a new value.\n   * @param mapper - The mapper function.\n   * @returns The mapped event.\n   */\n  map<M, MR = unknown>(mapper: Mapper<T, M>) {\n    const dispose = this.on(async (...args) => {\n      if (mappedEvent.size > 0) {\n        const value = await mapper(...args);\n        mappedEvent(value);\n      }\n    });\n    const mappedEvent = new Event<[M], MR>(dispose);\n    return mappedEvent;\n  }\n\n  /**\n   * Creates a new event that reduces the event arguments to a single value.\n   * @param reducer - The reducer function.\n   * @param init - The initial value for the reducer.\n   * @returns The reduced event.\n   */\n  reduce<A, AR = unknown>(reducer: Reducer<T, A>, init: A) {\n    let value = init;\n    const dispose = this.on(async (...args) => {\n      if (reducedEvent.size > 0) {\n        value = await reducer(value, ...args);\n        reducedEvent(value);\n      }\n    });\n    const reducedEvent = new Event<[A], AR>(dispose);\n    return reducedEvent;\n  }\n}\n\n/**\n * Returns a promise that resolves with the arguments passed to the first invocation of the given event.\n * @param event The event to listen for.\n * @returns A promise that resolves with the arguments passed to the first invocation of the given event.\n */\nexport const once = <T extends unknown[], R = void>(event: Event<T, R>): Promise<T> => {\n  return new Promise((resolve) => event.once((...args) => resolve(args)));\n};\n\n/**\n * Creates a new instance of the Event class.\n * @returns {Event<T, R>} A new instance of the Event class.\n * @template T The type of the arguments passed to the event.\n * @template R The return type of the event.\n */\nexport const createEvent = <T extends unknown[], R = void>(): Event<T, R> => {\n  return new Event<T, R>();\n};\n\nexport default createEvent;\n\n/**\n * A type helper that extracts the event listener type\n *\n * @template E - The event object type.\n * @template T - The event type extracted from the event object.\n * @template R - The result type returned by the event handler function.\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n"],"names":["FunctionExt","Function","constructor","func","Object","setPrototypeOf","prototype","Dismiss","callback","after","task","afterTimes","count","eventEmitter","listeners","args","Promise","all","map","listener","Event","merge","events","mergedEvent","forEach","event","on","interval","counter","intervalEvent","clearInterval","timerId","setInterval","dispose","fn","clear","size","length","lacks","indexOf","has","off","index","splice","push","once","oneTimeListener","toPromise","resolve","filter","filteredEvent","first","mapper","mappedEvent","value","reduce","reducer","init","reducedEvent","createEvent"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "evnty",
   "description": "0-Deps, simple, fast, for browser and node js anonymous event library",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
@@ -32,7 +32,9 @@
     "events",
     "emit",
     "emitter",
-    "anonymous"
+    "anonymous",
+    "flow",
+    "event-driven"
   ],
   "funding": "https://github.com/sponsors/3axap4eHko",
   "author": {

package/src/index.ts

@@ -1,10 +1,10 @@
-type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;
+export type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;
 
 export interface Unsubscribe {
   (): void;
 }
 
-export interface Listener<T extends unknown[], R> {
+export interface Listener<T extends unknown[], R = unknown> {
   (...args: T): MaybePromise<R | void>;
 }
 
@@ -16,17 +16,23 @@ export interface Filter<T extends unknown[]> {
   (...args: T): MaybePromise<boolean>;
 }
 
-export interface Mapper<T extends unknown[], R> {
+export interface Mapper<T extends unknown[], R = unknown> {
   (...args: T): R;
 }
 
-export interface Reducer<T extends unknown[], R> {
+export interface Reducer<T extends unknown[], R = unknown> {
   (value: R, ...args: T): R;
 }
 
-export type Listeners<T extends unknown[], R> = Listener<T, R>[];
+export type Listeners<T extends unknown[], R = unknown> = Listener<T, R>[];
 
-class FunctionExt extends Function {
+/**
+ * An abstract class that extends the built-in Function class. It allows instances of the class
+ * to be called as functions. When an instance of FunctionExt is called as a function, it will
+ * call the function passed to its constructor with the same arguments.
+ * @internal
+ */
+export abstract class FunctionExt extends Function {
   constructor(func: Function) {
     super();
     return Object.setPrototypeOf(func, new.target.prototype);
@@ -37,14 +43,20 @@ export interface Dismiss {
   (): Promise<void> | void;
 }
 
+export interface Task {
+  (): MaybePromise<unknown>;
+}
+
 export class Dismiss extends FunctionExt {
-  constructor(dismiss: Unsubscribe) {
-    super(dismiss);
+  constructor(callback: Unsubscribe) {
+    super(callback);
   }
-  async after(process: () => MaybePromise<unknown>) {
-    await process();
+
+  async after(task: Task) {
+    await task();
     this();
   }
+
   afterTimes(count: number) {
     return () => {
       if (!--count) {
@@ -63,17 +75,39 @@ export interface Event<T extends unknown[], R> {
 }
 
 type UnpackParameters<T> = T extends Event<infer P, unknown> ? P : never;
+
 type UnpackReturn<T> = T extends Event<unknown[], infer R> ? R : never;
+
 type UnpackAllParameters<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackParameters<T[K]> }[number];
+
 type UnpackAllReturn<T extends Event<unknown[], unknown>[]> = { [K in keyof T]: UnpackReturn<T[K]> }[number];
 
+/**
+ * A class representing an anonymous event that can be listened to or triggered.
+ * @example
+ * // Create a click event.
+ * const clickEvent = new Event<[x: number, y: number], void>();
+ *
+ * @template T - The tuple of arguments that the event takes.
+ * @template R - The return type of the event.
+ */
 export class Event<T extends unknown[], R = void> extends FunctionExt {
+  /**
+   * Merges multiple events into a single event.
+   * @param events - The events to merge.
+   * @returns The merged event.
+   */
   static merge<Events extends Event<any[], any>[]>(...events: Events) {
     const mergedEvent = new Event<UnpackAllParameters<Events>, UnpackAllReturn<Events>>();
     events.forEach((event) => event.on(mergedEvent));
     return mergedEvent;
   }
 
+  /**
+   * Creates an event that triggers at a specified interval.
+   * @param interval - The interval at which to trigger the event.
+   * @returns The interval event.
+   */
   static interval(interval: number) {
     let counter = 0;
     const intervalEvent = new Event<[number], void>(() => clearInterval(timerId));
@@ -81,9 +115,20 @@ export class Event<T extends unknown[], R = void> extends FunctionExt {
     return intervalEvent;
   }
 
+  /**
+   * The array of listeners for the event.
+   */
   private listeners: Listeners<T, R>;
+
+  /**
+   * A function that disposes of the event and its listeners.
+   */
   readonly dispose: Dispose;
 
+  /**
+   * Creates a new event.
+   * @param dispose - A function to dispose of the event and its listeners.
+   */
   constructor(dispose?: Dispose) {
     const listeners: Listeners<T, R> = [];
     const fn = (...args: T) => eventEmitter(listeners, ...args);
@@ -96,18 +141,35 @@ export class Event<T extends unknown[], R = void> extends FunctionExt {
     };
   }
 
+  /**
+   * The number of listeners for the event.
+   */
   get size(): number {
     return this.listeners.length;
   }
 
+  /**
+   * Checks if a listener is not registered for the event.
+   * @param listener - The listener to check.
+   * @returns `true` if the listener is not registered, `false` otherwise.
+   */
   lacks(listener: Listener<T, R>): boolean {
     return this.listeners.indexOf(listener) === -1;
   }
 
+  /**
+   * Checks if a listener is registered for the event.
+   * @param listener - The listener to check.
+   * @returns `true` if the listener is registered, `false` otherwise.
+   */
   has(listener: Listener<T, R>): boolean {
     return this.listeners.indexOf(listener) !== -1;
   }
 
+  /**
+   * Removes a listener from the event.
+   * @param listener - The listener to remove.
+   */
   off(listener: Listener<T, R>): void {
     let index = this.listeners.indexOf(listener);
     while (~index) {
@@ -116,11 +178,21 @@ export class Event<T extends unknown[], R = void> extends FunctionExt {
     }
   }
 
+  /**
+   * Adds a listener to the event.
+   * @param listener - The listener to add.
+   * @returns An object that can be used to remove the listener.
+   */
   on(listener: Listener<T, R>): Dismiss {
     this.listeners.push(listener);
     return new Dismiss(() => this.off(listener));
   }
 
+  /**
+   * Adds a listener to the event that will only be called once.
+   * @param listener - The listener to add.
+   * @returns An object that can be used to remove the listener.
+   */
   once(listener: Listener<T, R>): Dismiss {
     const oneTimeListener = (...args: T) => {
       this.off(oneTimeListener);
@@ -129,14 +201,26 @@ export class Event<T extends unknown[], R = void> extends FunctionExt {
     return this.on(oneTimeListener);
   }
 
+  /**
+   * Removes all listeners from the event.
+   */
   clear() {
     this.listeners.splice(0);
   }
 
+  /**
+   * Converts the event to a promise that resolves with the event arguments.
+   * @returns A promise that resolves with the event arguments.
+   */
   toPromise(): Promise<T> {
     return new Promise((resolve) => this.once((...args) => resolve(args)));
   }
 
+  /**
+   * Creates a new event that only triggers if the filter function returns `true`.
+   * @param filter - The filter function.
+   * @returns The filtered event.
+   */
   filter(filter: Filter<T>) {
     const dispose = this.on(async (...args) => {
       if (filteredEvent.size > 0 && (await filter(...args))) {
@@ -147,18 +231,45 @@ export class Event<T extends unknown[], R = void> extends FunctionExt {
     return filteredEvent;
   }
 
-  map<R>(mapper: Mapper<T, R>) {
+  /**
+   * Creates a new event that only triggers once if the filter function returns `true`.
+   * @param filter - The filter function.
+   * @returns The filtered event.
+   */
+  first(filter: Filter<T>) {
+    const dispose = this.on(async (...args) => {
+      if (filteredEvent.size > 0 && (await filter(...args))) {
+        dispose();
+        await filteredEvent(...args);
+      }
+    });
+    const filteredEvent = new Event<T, R>(dispose);
+    return filteredEvent;
+  }
+
+  /**
+   * Creates a new event that maps the event arguments to a new value.
+   * @param mapper - The mapper function.
+   * @returns The mapped event.
+   */
+  map<M, MR = unknown>(mapper: Mapper<T, M>) {
     const dispose = this.on(async (...args) => {
       if (mappedEvent.size > 0) {
         const value = await mapper(...args);
         mappedEvent(value);
       }
     });
-    const mappedEvent = new Event(dispose);
+    const mappedEvent = new Event<[M], MR>(dispose);
     return mappedEvent;
   }
 
-  reduce<R>(reducer: Reducer<T, R>, init: R) {
+  /**
+   * Creates a new event that reduces the event arguments to a single value.
+   * @param reducer - The reducer function.
+   * @param init - The initial value for the reducer.
+   * @returns The reduced event.
+   */
+  reduce<A, AR = unknown>(reducer: Reducer<T, A>, init: A) {
     let value = init;
     const dispose = this.on(async (...args) => {
       if (reducedEvent.size > 0) {
@@ -166,15 +277,37 @@ export class Event<T extends unknown[], R = void> extends FunctionExt {
         reducedEvent(value);
       }
     });
-    const reducedEvent = new Event(dispose);
+    const reducedEvent = new Event<[A], AR>(dispose);
     return reducedEvent;
   }
 }
 
+/**
+ * Returns a promise that resolves with the arguments passed to the first invocation of the given event.
+ * @param event The event to listen for.
+ * @returns A promise that resolves with the arguments passed to the first invocation of the given event.
+ */
 export const once = <T extends unknown[], R = void>(event: Event<T, R>): Promise<T> => {
   return new Promise((resolve) => event.once((...args) => resolve(args)));
 };
 
-export default function createEvent<T extends unknown[], R = void>() {
+/**
+ * Creates a new instance of the Event class.
+ * @returns {Event<T, R>} A new instance of the Event class.
+ * @template T The type of the arguments passed to the event.
+ * @template R The return type of the event.
+ */
+export const createEvent = <T extends unknown[], R = void>(): Event<T, R> => {
   return new Event<T, R>();
-}
+};
+
+export default createEvent;
+
+/**
+ * A type helper that extracts the event listener type
+ *
+ * @template E - The event object type.
+ * @template T - The event type extracted from the event object.
+ * @template R - The result type returned by the event handler function.
+ */
+export type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;