evnty 2.0.0 → 2.1.2

package/build/index.cjs

@@ -9,26 +9,26 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    FunctionExt: function() {
-        return FunctionExt;
-    },
     Dismiss: function() {
         return Dismiss;
     },
     Event: function() {
         return Event;
     },
-    merge: function() {
-        return merge;
-    },
-    createInterval: function() {
-        return createInterval;
+    FunctionExt: function() {
+        return FunctionExt;
     },
     createEvent: function() {
         return createEvent;
     },
+    createInterval: function() {
+        return createInterval;
+    },
     default: function() {
         return _default;
+    },
+    merge: function() {
+        return merge;
     }
 });
 class FunctionExt extends Function {
@@ -41,16 +41,24 @@ class Dismiss extends FunctionExt {
     constructor(callback){
         super(callback);
     }
-    async after(task) {
-        await task();
-        await this();
+    pre(callback) {
+        return new Dismiss(async ()=>{
+            await callback();
+            await this();
+        });
     }
-    afterTimes(count) {
-        return async ()=>{
+    post(callback) {
+        return new Dismiss(async ()=>{
+            await this();
+            await callback();
+        });
+    }
+    countdown(count) {
+        return new Dismiss(async ()=>{
             if (!--count) {
                 await this();
             }
-        };
+        });
     }
 }
 const eventEmitter = (listeners, event)=>Promise.all(listeners.map((listener)=>listener(event)));
@@ -62,9 +70,9 @@ class Event extends FunctionExt {
         const fn = (event)=>eventEmitter(listeners, event);
         super(fn);
         this.listeners = listeners;
-        this.dispose = ()=>{
+        this.dispose = async ()=>{
             this.clear();
-            dispose?.();
+            await dispose?.();
         };
     }
     get size() {
@@ -94,12 +102,12 @@ class Event extends FunctionExt {
         };
         return this.on(oneTimeListener);
     }
-    clear() {
-        this.listeners.splice(0);
-    }
     onceAsync() {
         return new Promise((resolve)=>this.once((event)=>resolve(event)));
     }
+    clear() {
+        this.listeners.splice(0);
+    }
     filter(filter) {
         const dispose = this.on(async (event)=>{
             if (filteredEvent.size > 0 && await filter(event)) {
@@ -119,6 +127,9 @@ class Event extends FunctionExt {
         const filteredEvent = new Event(dispose);
         return filteredEvent;
     }
+    firstAsync(filter) {
+        return this.first(filter).onceAsync();
+    }
     map(mapper) {
         const dispose = this.on(async (event)=>{
             if (mappedEvent.size > 0) {

package/build/index.cjs.map

@@ -1 +1 @@
-{"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, R = unknown> {\n  (event: T): MaybePromise<R | void>;\n}\n\nexport interface Dispose {\n  (): void;\n}\n\nexport interface Result<T, E> {\n  ok: boolean;\n  result: T | E;\n}\n\nexport interface Resolver<T, P> {\n  (event: T): Promise<P>;\n}\n\nexport interface FilterFunction<T> {\n  (event: T): MaybePromise<boolean>;\n}\n\nexport interface Predicate<T, P extends T> {\n  (event: T): event is P;\n}\n\nexport type Filter<T, P extends T> = Predicate<T, P> | FilterFunction<T>;\n\nexport interface Mapper<T, R> {\n  (event: T): MaybePromise<R>;\n}\n\nexport interface Reducer<T, R> {\n  (result: R, event: T): MaybePromise<R>;\n}\n\nexport type Listeners<T, R> = 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\n/**\n * @internal\n */\nexport class Dismiss extends FunctionExt {\n  constructor(callback: Unsubscribe) {\n    super(callback);\n  }\n\n  async after(task: Task): Promise<void> {\n    await task();\n    await this();\n  }\n\n  afterTimes(count: number): () => Promise<void> {\n    return async () => {\n      if (!--count) {\n        await this();\n      }\n    };\n  }\n}\n\nconst eventEmitter = <A, R>(listeners: Listeners<A, R>, event: A): Promise<(void | R)[]> => Promise.all(listeners.map((listener) => listener(event)));\n\ntype EventType<T> = T extends undefined ? void : T;\n\nexport interface Event<T = unknown, R = void> {\n  (event?: EventType<T>): Promise<(R | undefined)[]>;\n}\n\nexport type EventParameters<T> = T extends Event<infer P, unknown> ? P : never;\n\nexport type EventResult<T> = T extends Event<unknown, infer R> ? R : never;\n\nexport type AllEventsParameters<T extends Event<unknown, unknown>[]> = { [K in keyof T]: EventParameters<T[K]> }[number];\n\nexport type AllEventsResults<T extends Event<unknown, unknown>[]> = { [K in keyof T]: EventResult<T[K]> }[number];\n\n/**\n * A class representing an anonymous event that can be listened to or triggered.\n *\n * @typeParam T - The tuple of arguments that the event takes.\n * @typeParam R - The return type of the event.\n */\nexport class Event<T, R> extends FunctionExt {\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   * @example\n   * // Create a click event.\n   * const clickEvent = new Event<[x: number, y: number], void>();\n   * clickEvent.on((x, y) => console.log(`Clicked at ${x}, ${y}`));\n   *\n   * @param dispose - A function to call on the event disposal.\n   */\n  constructor(dispose?: Dispose) {\n    const listeners: Listeners<T, R> = [];\n    const fn = (event: T) => eventEmitter(listeners, event);\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 = (event: T) => {\n      this.off(oneTimeListener);\n      return listener(event);\n    };\n    return this.on(oneTimeListener);\n  }\n\n  /**\n   * Removes all listeners from the event.\n   */\n  clear(): void {\n    this.listeners.splice(0);\n  }\n\n  /**\n   * Returns a Promise that resolves with the first emitted by the event arguments.\n   * @returns A Promise that resolves with the first emitted by the event.\n   */\n  onceAsync(): Promise<T> {\n    return new Promise((resolve) => this.once((event) => resolve(event)));\n  }\n\n  /**\n   * Returns a new event that only triggers when the provided filter function returns `true`.\n   * @example\n   * const spacePressEvent = keyboardEvent.filter((key) => key === 'Space');\n   *\n   * @param filter The filter function to apply to the event.\n   * @returns A new event that only triggers when the provided filter function returns `true`.\n   */\n  filter<P extends T>(predicate: Predicate<T, P>): Event<P, R>;\n  filter<P extends T>(filter: FilterFunction<T>): Event<P, R>;\n  filter<P extends T>(filter: Filter<T, P>): Event<P, R> {\n    const dispose = this.on(async (event: T) => {\n      if (filteredEvent.size > 0 && (await filter(event))) {\n        await filteredEvent(event as EventType<P>);\n      }\n    });\n    const filteredEvent = new Event<P, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Returns a new event that will only be triggered once the provided filter function returns `true`.\n   * @example\n   * const escPressEvent = keyboardEvent.first((key) => key === 'Esc');\n   * await escPressEvent.toPromise();\n   *\n   * @param filter - The filter function.\n   * @returns A new event that will only be triggered once the provided filter function returns `true`.\n   */\n  first<P extends T>(predicate: Predicate<T, P>): Event<P, R>;\n  first<P extends T>(filter: FilterFunction<T>): Event<P, R>;\n  first<P extends T>(filter: Filter<T, P>): Event<P, R> {\n    const dispose = this.on(async (event: T) => {\n      if (filteredEvent.size > 0 && (await filter(event))) {\n        await dispose();\n        await filteredEvent(event as EventType<P>);\n      }\n    });\n    const filteredEvent = new Event<P, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Returns a new event that maps the values of this event using the provided mapper function.\n   * @example\n   * const keyPressEvent = keyboardEvent.map((key) => key.toUpperCase()); // ['a'] -> ['A']\n   *\n   * @param mapper A function that maps the values of this event to a new value.\n   * @returns A new event that emits the mapped values.\n   */\n  map<M, MR = R>(mapper: Mapper<T, M>): Event<M, MR> {\n    const dispose = this.on(async (event) => {\n      if (mappedEvent.size > 0) {\n        const value = await mapper(event);\n        await mappedEvent(value as EventType<M>);\n      }\n    });\n    const mappedEvent = new Event<M, MR>(dispose);\n    return mappedEvent;\n  }\n\n  /**\n   * Returns a new event that reduces the emitted values using the provided reducer function.\n   * @example\n   * const sumEvent = numberEvent.reduce((a, b) => a + b, 0);\n   * sumEvent.on((sum) => console.log(sum)); // 1, 3, 6\n   * sumEvent(1);\n   * sumEvent(2);\n   * sumEvent(3);\n   *\n   * @typeParam A The type of the accumulated value.\n   * @typeParam AR The type of the reduced value.\n   * @param {Reducer<T, A>} reducer The reducer function that accumulates the values emitted by this `Event`.\n   * @param {A} init The initial value of the accumulated value.\n   * @returns {Event<[A], AR>} A new `Event` that emits the reduced value.\n   */\n  reduce<A, AR = R>(reducer: Reducer<T, A>, init: A): Event<A, AR> {\n    let value = init;\n    const dispose = this.on(async (event) => {\n      if (reducedEvent.size > 0) {\n        value = await reducer(value, event);\n        await reducedEvent(value as EventType<A>);\n      }\n    });\n    const reducedEvent = new Event<A, AR>(dispose);\n    return reducedEvent;\n  }\n\n  /**\n   * Returns a new debounced event that will not fire until a certain amount of time has passed\n   * since the last time it was triggered.\n   * @example\n   * const debouncedEvent = textInputEvent.debounce(100);\n   * debouncedEvent.on((str) => console.log(str)); // 'test'\n   * event('t');\n   * event('te');\n   * event('tes');\n   * event('test');\n   *\n   * @param interval - The amount of time to wait before firing the debounced event, in milliseconds.\n   * @returns A new debounced event.\n   */\n  debounce(interval: number): Event<T, R> {\n    let timer: ReturnType<typeof setTimeout>;\n    const dispose = this.on((event) => {\n      clearTimeout(timer);\n      timer = setTimeout(() => debouncedEvent(event as EventType<T>), interval);\n    });\n    const debouncedEvent = new Event<T, R>(dispose);\n    return debouncedEvent;\n  }\n}\n\n/**\n * Merges multiple events into a single event.\n * @example\n * const inputEvent = Event.merge(mouseEvent, keyboardEvent);\n *\n * @param events - The events to merge.\n * @returns The merged event.\n */\nexport const merge = <Events extends Event<any, any>[]>(...events: Events): Event<AllEventsParameters<Events>, AllEventsResults<Events>> => {\n  const mergedEvent = new Event<AllEventsParameters<Events>, AllEventsResults<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 * @example\n * const tickEvent = Event.interval(1000);\n * tickEvent.on((tickNumber) => console.log(tickNumber));\n *\n * @param interval - The interval at which to trigger the event.\n * @returns The interval event.\n */\nexport const createInterval = <R = void>(interval: number): Event<number, R> => {\n  let counter = 0;\n  const intervalEvent = new Event<number, R>(() => clearInterval(timerId));\n  const timerId: ReturnType<typeof setInterval> = setInterval(() => intervalEvent(counter++), interval);\n  return intervalEvent;\n};\n\n/**\n * Creates a new event instance.\n *\n * @typeParam T - An array of argument types that the event will accept.\n * @typeParam R - The return type of the event handler function.\n * @returns A new instance of the `Event` class.\n *\n * @example\n * const myEvent = createEvent<[string], number>();\n * myEvent.on((str: string) => str.length);\n * await myEvent('hello'); // [5]\n */\nexport const createEvent = <T, R = void>(): Event<T, R> => new Event<T, R>();\n\nexport default createEvent;\n\n/**\n * A type helper that extracts the event listener type\n *\n * @typeParam E - The event type.\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n\n/**\n * A type helper that extracts the event filter type\n *\n * @typeParam E The event type to filter.\n */\nexport type EventFilter<E> = FilterFunction<EventParameters<E>>;\n\n/**\n * A type helper that extracts the event predicate type\n *\n * @typeParam E The event type to predicate.\n */\nexport type EventPredicate<E, P extends EventParameters<E>> = Predicate<EventParameters<E>, P>;\n\n/**\n * A type helper that extracts the event mapper type\n *\n * @typeParam E The event type to map.\n * @typeParam M The new type to map `E` to.\n */\nexport type EventMapper<E, M> = Mapper<EventParameters<E>, M>;\n\n/**\n * A type helper that extracts the event mapper type\n *\n * @typeParam E The type of event to reduce.\n * @typeParam M The type of reduced event.\n */\nexport type EventReducer<E, R> = Reducer<EventParameters<E>, R>;\n"],"names":["FunctionExt","Dismiss","Event","merge","createInterval","createEvent","Function","constructor","func","Object","setPrototypeOf","prototype","callback","after","task","afterTimes","count","eventEmitter","listeners","event","Promise","all","map","listener","dispose","fn","clear","size","length","lacks","indexOf","has","off","index","splice","on","push","once","oneTimeListener","onceAsync","resolve","filter","filteredEvent","first","mapper","mappedEvent","value","reduce","reducer","init","reducedEvent","debounce","interval","timer","clearTimeout","setTimeout","debouncedEvent","events","mergedEvent","forEach","counter","intervalEvent","clearInterval","timerId","setInterval"],"mappings":";;;;;;;;;;;IAiDsBA,WAAW;eAAXA;;IAkBTC,OAAO;eAAPA;;IAyCAC,KAAK;eAALA;;IAoOAC,KAAK;eAALA;;IAeAC,cAAc;eAAdA;;IAmBAC,WAAW;eAAXA;;IAEb,OAA2B;eAA3B;;;AAnUO,MAAeL,oBAAoBM;IACxCC,YAAYC,IAAc,CAAE;QAC1B,KAAK;QACL,OAAOC,OAAOC,cAAc,CAACF,MAAM,WAAWG,SAAS;IACzD;AACF;AAaO,MAAMV,gBAAgBD;IAC3BO,YAAYK,QAAqB,CAAE;QACjC,KAAK,CAACA;IACR;IAEA,MAAMC,MAAMC,IAAU,EAAiB;QACrC,MAAMA;QACN,MAAM,IAAI;IACZ;IAEAC,WAAWC,KAAa,EAAuB;QAC7C,OAAO;YACL,IAAI,CAAC,EAAEA,OAAO;gBACZ,MAAM,IAAI;YACZ;QACF;IACF;AACF;AAEA,MAAMC,eAAe,CAAOC,WAA4BC,QAAoCC,QAAQC,GAAG,CAACH,UAAUI,GAAG,CAAC,CAACC,WAAaA,SAASJ;AAsBtI,MAAMjB,cAAoBF;IAIvBkB,UAA2B;IAK1BM,QAAiB;IAW1BjB,YAAYiB,OAAiB,CAAE;QAC7B,MAAMN,YAA6B,EAAE;QACrC,MAAMO,KAAK,CAACN,QAAaF,aAAaC,WAAWC;QAEjD,KAAK,CAACM;QACN,IAAI,CAACP,SAAS,GAAGA;QACjB,IAAI,CAACM,OAAO,GAAG;YACb,IAAI,CAACE,KAAK;YACVF;QACF;IACF;IAKA,IAAIG,OAAe;QACjB,OAAO,IAAI,CAACT,SAAS,CAACU,MAAM;IAC9B;IAOAC,MAAMN,QAAwB,EAAW;QACvC,OAAO,IAAI,CAACL,SAAS,CAACY,OAAO,CAACP,cAAc,CAAC;IAC/C;IAOAQ,IAAIR,QAAwB,EAAW;QACrC,OAAO,IAAI,CAACL,SAAS,CAACY,OAAO,CAACP,cAAc,CAAC;IAC/C;IAMAS,IAAIT,QAAwB,EAAQ;QAClC,IAAIU,QAAQ,IAAI,CAACf,SAAS,CAACY,OAAO,CAACP;QACnC,MAAO,CAACU,MAAO;YACb,IAAI,CAACf,SAAS,CAACgB,MAAM,CAACD,OAAO;YAC7BA,QAAQ,IAAI,CAACf,SAAS,CAACY,OAAO,CAACP;QACjC;IACF;IAOAY,GAAGZ,QAAwB,EAAW;QACpC,IAAI,CAACL,SAAS,CAACkB,IAAI,CAACb;QACpB,OAAO,IAAItB,QAAQ,IAAM,IAAI,CAAC+B,GAAG,CAACT;IACpC;IAOAc,KAAKd,QAAwB,EAAW;QACtC,MAAMe,kBAAkB,CAACnB;YACvB,IAAI,CAACa,GAAG,CAACM;YACT,OAAOf,SAASJ;QAClB;QACA,OAAO,IAAI,CAACgB,EAAE,CAACG;IACjB;IAKAZ,QAAc;QACZ,IAAI,CAACR,SAAS,CAACgB,MAAM,CAAC;IACxB;IAMAK,YAAwB;QACtB,OAAO,IAAInB,QAAQ,CAACoB,UAAY,IAAI,CAACH,IAAI,CAAC,CAAClB,QAAUqB,QAAQrB;IAC/D;IAYAsB,OAAoBA,MAAoB,EAAe;QACrD,MAAMjB,UAAU,IAAI,CAACW,EAAE,CAAC,OAAOhB;YAC7B,IAAIuB,cAAcf,IAAI,GAAG,KAAM,MAAMc,OAAOtB,QAAS;gBACnD,MAAMuB,cAAcvB;YACtB;QACF;QACA,MAAMuB,gBAAgB,IAAIxC,MAAYsB;QACtC,OAAOkB;IACT;IAaAC,MAAmBF,MAAoB,EAAe;QACpD,MAAMjB,UAAU,IAAI,CAACW,EAAE,CAAC,OAAOhB;YAC7B,IAAIuB,cAAcf,IAAI,GAAG,KAAM,MAAMc,OAAOtB,QAAS;gBACnD,MAAMK;gBACN,MAAMkB,cAAcvB;YACtB;QACF;QACA,MAAMuB,gBAAgB,IAAIxC,MAAYsB;QACtC,OAAOkB;IACT;IAUApB,IAAesB,MAAoB,EAAgB;QACjD,MAAMpB,UAAU,IAAI,CAACW,EAAE,CAAC,OAAOhB;YAC7B,IAAI0B,YAAYlB,IAAI,GAAG,GAAG;gBACxB,MAAMmB,QAAQ,MAAMF,OAAOzB;gBAC3B,MAAM0B,YAAYC;YACpB;QACF;QACA,MAAMD,cAAc,IAAI3C,MAAasB;QACrC,OAAOqB;IACT;IAiBAE,OAAkBC,OAAsB,EAAEC,IAAO,EAAgB;QAC/D,IAAIH,QAAQG;QACZ,MAAMzB,UAAU,IAAI,CAACW,EAAE,CAAC,OAAOhB;YAC7B,IAAI+B,aAAavB,IAAI,GAAG,GAAG;gBACzBmB,QAAQ,MAAME,QAAQF,OAAO3B;gBAC7B,MAAM+B,aAAaJ;YACrB;QACF;QACA,MAAMI,eAAe,IAAIhD,MAAasB;QACtC,OAAO0B;IACT;IAgBAC,SAASC,QAAgB,EAAe;QACtC,IAAIC;QACJ,MAAM7B,UAAU,IAAI,CAACW,EAAE,CAAC,CAAChB;YACvBmC,aAAaD;YACbA,QAAQE,WAAW,IAAMC,eAAerC,QAAwBiC;QAClE;QACA,MAAMI,iBAAiB,IAAItD,MAAYsB;QACvC,OAAOgC;IACT;AACF;AAUO,MAAMrD,QAAQ,CAAmC,GAAGsD;IACzD,MAAMC,cAAc,IAAIxD;IACxBuD,OAAOE,OAAO,CAAC,CAACxC,QAAUA,MAAMgB,EAAE,CAACuB;IACnC,OAAOA;AACT;AAWO,MAAMtD,iBAAiB,CAAWgD;IACvC,IAAIQ,UAAU;IACd,MAAMC,gBAAgB,IAAI3D,MAAiB,IAAM4D,cAAcC;IAC/D,MAAMA,UAA0CC,YAAY,IAAMH,cAAcD,YAAYR;IAC5F,OAAOS;AACT;AAcO,MAAMxD,cAAc,IAAgC,IAAIH;MAE/D,WAAeG"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;\n\nexport interface Callback<R = void> {\n  (): MaybePromise<R>;\n}\n\nexport interface Listener<T, R = unknown> {\n  (event: T): MaybePromise<R | void>;\n}\n\nexport interface Result<T, E> {\n  ok: boolean;\n  result: T | E;\n}\n\nexport interface FilterFunction<T> {\n  (event: T): MaybePromise<boolean>;\n}\n\nexport interface Predicate<T, P extends T> {\n  (event: T): event is P;\n}\n\nexport type Filter<T, P extends T> = Predicate<T, P> | FilterFunction<T>;\n\nexport interface Mapper<T, R> {\n  (event: T): MaybePromise<R>;\n}\n\nexport interface Reducer<T, R> {\n  (result: R, event: T): MaybePromise<R>;\n}\n\nexport type Listeners<T, R> = 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  (): MaybePromise<void>;\n}\n\n/**\n * @internal\n */\nexport class Dismiss extends FunctionExt {\n  constructor(callback: Callback) {\n    super(callback);\n  }\n\n  pre(callback: Callback): Dismiss {\n    return new Dismiss(async () => {\n      await callback();\n      await this();\n    });\n  }\n\n  post(callback: Callback): Dismiss {\n    return new Dismiss(async () => {\n      await this();\n      await callback();\n    });\n  }\n\n  countdown(count: number): Dismiss {\n    return new Dismiss(async () => {\n      if (!--count) {\n        await this();\n      }\n    });\n  }\n}\n\nconst eventEmitter = <A, R>(listeners: Listeners<A, R>, event: A): Promise<(void | R)[]> => Promise.all(listeners.map((listener) => listener(event)));\n\ntype EventType<T> = T extends undefined ? void : T;\n\nexport interface Event<T = unknown, R = void> {\n  (event?: EventType<T>): Promise<(R | undefined)[]>;\n}\n\nexport type EventParameters<T> = T extends Event<infer P, unknown> ? P : never;\n\nexport type EventResult<T> = T extends Event<unknown, infer R> ? R : never;\n\nexport type AllEventsParameters<T extends Event<unknown, unknown>[]> = { [K in keyof T]: EventParameters<T[K]> }[number];\n\nexport type AllEventsResults<T extends Event<unknown, unknown>[]> = { [K in keyof T]: EventResult<T[K]> }[number];\n\n/**\n * A class representing an anonymous event that can be listened to or triggered.\n *\n * @typeParam T - The tuple of arguments that the event takes.\n * @typeParam R - The return type of the event.\n */\nexport class Event<T, R> extends FunctionExt {\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: Callback;\n\n  /**\n   * Creates a new event.\n   * @example\n   * // Create a click event.\n   * const clickEvent = new Event<[x: number, y: number], void>();\n   * clickEvent.on((x, y) => console.log(`Clicked at ${x}, ${y}`));\n   *\n   * @param dispose - A function to call on the event disposal.\n   */\n  constructor(dispose?: Callback) {\n    const listeners: Listeners<T, R> = [];\n    const fn = (event: T) => eventEmitter(listeners, event);\n\n    super(fn);\n    this.listeners = listeners;\n    this.dispose = async () => {\n      this.clear();\n      await 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 = (event: T) => {\n      this.off(oneTimeListener);\n      return listener(event);\n    };\n    return this.on(oneTimeListener);\n  }\n\n  /**\n   * Returns a Promise that resolves with the first emitted by the event arguments.\n   * @returns A Promise that resolves with the first emitted by the event.\n   */\n  onceAsync(): Promise<T> {\n    return new Promise((resolve) => this.once((event) => resolve(event)));\n  }\n\n  /**\n   * Removes all listeners from the event.\n   */\n  clear(): void {\n    this.listeners.splice(0);\n  }\n\n  /**\n   * Returns a new event that only triggers when the provided filter function returns `true`.\n   * @example\n   * const spacePressEvent = keyboardEvent.filter((key) => key === 'Space');\n   *\n   * @param filter The filter function to apply to the event.\n   * @returns A new event that only triggers when the provided filter function returns `true`.\n   */\n  filter<P extends T>(predicate: Predicate<T, P>): Event<P, R>;\n  filter<P extends T>(filter: FilterFunction<T>): Event<P, R>;\n  filter<P extends T>(filter: Filter<T, P>): Event<P, R> {\n    const dispose = this.on(async (event: T) => {\n      if (filteredEvent.size > 0 && (await filter(event))) {\n        await filteredEvent(event as EventType<P>);\n      }\n    });\n    const filteredEvent = new Event<P, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Returns a new event that will only be triggered once the provided filter function returns `true`.\n   * @example\n   * const escPressEvent = keyboardEvent.first((key) => key === 'Esc');\n   * await escPressEvent.toPromise();\n   *\n   * @param filter - The filter function.\n   * @returns A new event that will only be triggered once the provided filter function returns `true`.\n   */\n  first<P extends T>(predicate: Predicate<T, P>): Event<P, R>;\n  first<P extends T>(filter: FilterFunction<T>): Event<P, R>;\n  first<P extends T>(filter: Filter<T, P>): Event<P, R> {\n    const dispose = this.on(async (event: T) => {\n      if (filteredEvent.size > 0 && (await filter(event))) {\n        await dispose();\n        await filteredEvent(event as EventType<P>);\n      }\n    });\n    const filteredEvent = new Event<P, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Returns a new promise that will be resolved once the provided filter function returns `true`.\n   * @example\n   * const escPressEvent = await keyboardEvent.firstAsync((key) => key === 'Esc');\n   *\n   * @param filter - The filter function.\n   * @returns A new promise that will be resolved once the provided filter function returns `true`.\n   */\n  firstAsync<P extends T>(predicate: Predicate<T, P>): Promise<P>;\n  firstAsync<P extends T>(filter: FilterFunction<T>): Promise<P>;\n  firstAsync<P extends T>(filter: Filter<T, P>): Promise<P> {\n    return this.first<P>(filter).onceAsync();\n  }\n\n  /**\n   * Returns a new event that maps the values of this event using the provided mapper function.\n   * @example\n   * const keyPressEvent = keyboardEvent.map((key) => key.toUpperCase()); // ['a'] -> ['A']\n   *\n   * @param mapper A function that maps the values of this event to a new value.\n   * @returns A new event that emits the mapped values.\n   */\n  map<M, MR = R>(mapper: Mapper<T, M>): Event<M, MR> {\n    const dispose = this.on(async (event) => {\n      if (mappedEvent.size > 0) {\n        const value = await mapper(event);\n        await mappedEvent(value as EventType<M>);\n      }\n    });\n    const mappedEvent = new Event<M, MR>(dispose);\n    return mappedEvent;\n  }\n\n  /**\n   * Returns a new event that reduces the emitted values using the provided reducer function.\n   * @example\n   * const sumEvent = numberEvent.reduce((a, b) => a + b, 0);\n   * sumEvent.on((sum) => console.log(sum)); // 1, 3, 6\n   * sumEvent(1);\n   * sumEvent(2);\n   * sumEvent(3);\n   *\n   * @typeParam A The type of the accumulated value.\n   * @typeParam AR The type of the reduced value.\n   * @param {Reducer<T, A>} reducer The reducer function that accumulates the values emitted by this `Event`.\n   * @param {A} init The initial value of the accumulated value.\n   * @returns {Event<[A], AR>} A new `Event` that emits the reduced value.\n   */\n  reduce<A, AR = R>(reducer: Reducer<T, A>, init: A): Event<A, AR> {\n    let value = init;\n    const dispose = this.on(async (event) => {\n      if (reducedEvent.size > 0) {\n        value = await reducer(value, event);\n        await reducedEvent(value as EventType<A>);\n      }\n    });\n    const reducedEvent = new Event<A, AR>(dispose);\n    return reducedEvent;\n  }\n\n  /**\n   * Returns a new debounced event that will not fire until a certain amount of time has passed\n   * since the last time it was triggered.\n   * @example\n   * const debouncedEvent = textInputEvent.debounce(100);\n   * debouncedEvent.on((str) => console.log(str)); // 'test'\n   * event('t');\n   * event('te');\n   * event('tes');\n   * event('test');\n   *\n   * @param interval - The amount of time to wait before firing the debounced event, in milliseconds.\n   * @returns A new debounced event.\n   */\n  debounce(interval: number): Event<T, R> {\n    let timer: ReturnType<typeof setTimeout>;\n    const dispose = this.on((event) => {\n      clearTimeout(timer);\n      timer = setTimeout(() => debouncedEvent(event as EventType<T>), interval);\n    });\n    const debouncedEvent = new Event<T, R>(dispose);\n    return debouncedEvent;\n  }\n}\n\n/**\n * Merges multiple events into a single event.\n * @example\n * const inputEvent = Event.merge(mouseEvent, keyboardEvent);\n *\n * @param events - The events to merge.\n * @returns The merged event.\n */\nexport const merge = <Events extends Event<any, any>[]>(...events: Events): Event<AllEventsParameters<Events>, AllEventsResults<Events>> => {\n  const mergedEvent = new Event<AllEventsParameters<Events>, AllEventsResults<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 * @example\n * const tickEvent = Event.interval(1000);\n * tickEvent.on((tickNumber) => console.log(tickNumber));\n *\n * @param interval - The interval at which to trigger the event.\n * @returns The interval event.\n */\nexport const createInterval = <R = void>(interval: number): Event<number, R> => {\n  let counter = 0;\n  const intervalEvent = new Event<number, R>(() => clearInterval(timerId));\n  const timerId: ReturnType<typeof setInterval> = setInterval(() => intervalEvent(counter++), interval);\n  return intervalEvent;\n};\n\n/**\n * Creates a new event instance.\n *\n * @typeParam T - An array of argument types that the event will accept.\n * @typeParam R - The return type of the event handler function.\n * @returns A new instance of the `Event` class.\n *\n * @example\n * const myEvent = createEvent<[string], number>();\n * myEvent.on((str: string) => str.length);\n * await myEvent('hello'); // [5]\n */\nexport const createEvent = <T, R = void>(): Event<T, R> => new Event<T, R>();\n\nexport default createEvent;\n\n/**\n * A type helper that extracts the event listener type\n *\n * @typeParam E - The event type.\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n\n/**\n * A type helper that extracts the event filter type\n *\n * @typeParam E The event type to filter.\n */\nexport type EventFilter<E> = FilterFunction<EventParameters<E>>;\n\n/**\n * A type helper that extracts the event predicate type\n *\n * @typeParam E The event type to predicate.\n */\nexport type EventPredicate<E, P extends EventParameters<E>> = Predicate<EventParameters<E>, P>;\n\n/**\n * A type helper that extracts the event mapper type\n *\n * @typeParam E The event type to map.\n * @typeParam M The new type to map `E` to.\n */\nexport type EventMapper<E, M> = Mapper<EventParameters<E>, M>;\n\n/**\n * A type helper that extracts the event mapper type\n *\n * @typeParam E The type of event to reduce.\n * @typeParam M The type of reduced event.\n */\nexport type EventReducer<E, R> = Reducer<EventParameters<E>, R>;\n"],"names":["Dismiss","Event","FunctionExt","createEvent","createInterval","merge","Function","constructor","func","Object","setPrototypeOf","prototype","callback","pre","post","countdown","count","eventEmitter","listeners","event","Promise","all","map","listener","dispose","fn","clear","size","length","lacks","indexOf","has","off","index","splice","on","push","once","oneTimeListener","onceAsync","resolve","filter","filteredEvent","first","firstAsync","mapper","mappedEvent","value","reduce","reducer","init","reducedEvent","debounce","interval","timer","clearTimeout","setTimeout","debouncedEvent","events","mergedEvent","forEach","counter","intervalEvent","clearInterval","timerId","setInterval"],"mappings":"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"}

package/build/index.d.ts

@@ -1,20 +1,14 @@
 export type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;
-export interface Unsubscribe {
-    (): void;
+export interface Callback<R = void> {
+    (): MaybePromise<R>;
 }
 export interface Listener<T, R = unknown> {
     (event: T): MaybePromise<R | void>;
 }
-export interface Dispose {
-    (): void;
-}
 export interface Result<T, E> {
     ok: boolean;
     result: T | E;
 }
-export interface Resolver<T, P> {
-    (event: T): Promise<P>;
-}
 export interface FilterFunction<T> {
     (event: T): MaybePromise<boolean>;
 }
@@ -39,18 +33,16 @@ export declare abstract class FunctionExt extends Function {
     constructor(func: Function);
 }
 export interface Dismiss {
-    (): Promise<void> | void;
-}
-export interface Task {
-    (): MaybePromise<unknown>;
+    (): MaybePromise<void>;
 }
 /**
  * @internal
  */
 export declare class Dismiss extends FunctionExt {
-    constructor(callback: Unsubscribe);
-    after(task: Task): Promise<void>;
-    afterTimes(count: number): () => Promise<void>;
+    constructor(callback: Callback);
+    pre(callback: Callback): Dismiss;
+    post(callback: Callback): Dismiss;
+    countdown(count: number): Dismiss;
 }
 type EventType<T> = T extends undefined ? void : T;
 export interface Event<T = unknown, R = void> {
@@ -78,7 +70,7 @@ export declare class Event<T, R> extends FunctionExt {
     /**
      * A function that disposes of the event and its listeners.
      */
-    readonly dispose: Dispose;
+    readonly dispose: Callback;
     /**
      * Creates a new event.
      * @example
@@ -88,7 +80,7 @@ export declare class Event<T, R> extends FunctionExt {
      *
      * @param dispose - A function to call on the event disposal.
      */
-    constructor(dispose?: Dispose);
+    constructor(dispose?: Callback);
     /**
      * The number of listeners for the event.
      */
@@ -122,15 +114,15 @@ export declare class Event<T, R> extends FunctionExt {
      * @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;
     /**
      * Returns a Promise that resolves with the first emitted by the event arguments.
      * @returns A Promise that resolves with the first emitted by the event.
      */
     onceAsync(): Promise<T>;
+    /**
+     * Removes all listeners from the event.
+     */
+    clear(): void;
     /**
      * Returns a new event that only triggers when the provided filter function returns `true`.
      * @example
@@ -152,6 +144,16 @@ export declare class Event<T, R> extends FunctionExt {
      */
     first<P extends T>(predicate: Predicate<T, P>): Event<P, R>;
     first<P extends T>(filter: FilterFunction<T>): Event<P, R>;
+    /**
+     * Returns a new promise that will be resolved once the provided filter function returns `true`.
+     * @example
+     * const escPressEvent = await keyboardEvent.firstAsync((key) => key === 'Esc');
+     *
+     * @param filter - The filter function.
+     * @returns A new promise that will be resolved once the provided filter function returns `true`.
+     */
+    firstAsync<P extends T>(predicate: Predicate<T, P>): Promise<P>;
+    firstAsync<P extends T>(filter: FilterFunction<T>): Promise<P>;
     /**
      * Returns a new event that maps the values of this event using the provided mapper function.
      * @example

package/build/index.js

@@ -8,16 +8,24 @@ export class Dismiss extends FunctionExt {
     constructor(callback){
         super(callback);
     }
-    async after(task) {
-        await task();
-        await this();
+    pre(callback) {
+        return new Dismiss(async ()=>{
+            await callback();
+            await this();
+        });
+    }
+    post(callback) {
+        return new Dismiss(async ()=>{
+            await this();
+            await callback();
+        });
     }
-    afterTimes(count) {
-        return async ()=>{
+    countdown(count) {
+        return new Dismiss(async ()=>{
             if (!--count) {
                 await this();
             }
-        };
+        });
     }
 }
 const eventEmitter = (listeners, event)=>Promise.all(listeners.map((listener)=>listener(event)));
@@ -29,9 +37,9 @@ export class Event extends FunctionExt {
         const fn = (event)=>eventEmitter(listeners, event);
         super(fn);
         this.listeners = listeners;
-        this.dispose = ()=>{
+        this.dispose = async ()=>{
             this.clear();
-            dispose?.();
+            await dispose?.();
         };
     }
     get size() {
@@ -61,12 +69,12 @@ export class Event extends FunctionExt {
         };
         return this.on(oneTimeListener);
     }
-    clear() {
-        this.listeners.splice(0);
-    }
     onceAsync() {
         return new Promise((resolve)=>this.once((event)=>resolve(event)));
     }
+    clear() {
+        this.listeners.splice(0);
+    }
     filter(filter) {
         const dispose = this.on(async (event)=>{
             if (filteredEvent.size > 0 && await filter(event)) {
@@ -86,6 +94,9 @@ export class Event extends FunctionExt {
         const filteredEvent = new Event(dispose);
         return filteredEvent;
     }
+    firstAsync(filter) {
+        return this.first(filter).onceAsync();
+    }
     map(mapper) {
         const dispose = this.on(async (event)=>{
             if (mappedEvent.size > 0) {

package/build/index.js.map

@@ -1 +1 @@
-{"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, R = unknown> {\n  (event: T): MaybePromise<R | void>;\n}\n\nexport interface Dispose {\n  (): void;\n}\n\nexport interface Result<T, E> {\n  ok: boolean;\n  result: T | E;\n}\n\nexport interface Resolver<T, P> {\n  (event: T): Promise<P>;\n}\n\nexport interface FilterFunction<T> {\n  (event: T): MaybePromise<boolean>;\n}\n\nexport interface Predicate<T, P extends T> {\n  (event: T): event is P;\n}\n\nexport type Filter<T, P extends T> = Predicate<T, P> | FilterFunction<T>;\n\nexport interface Mapper<T, R> {\n  (event: T): MaybePromise<R>;\n}\n\nexport interface Reducer<T, R> {\n  (result: R, event: T): MaybePromise<R>;\n}\n\nexport type Listeners<T, R> = 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\n/**\n * @internal\n */\nexport class Dismiss extends FunctionExt {\n  constructor(callback: Unsubscribe) {\n    super(callback);\n  }\n\n  async after(task: Task): Promise<void> {\n    await task();\n    await this();\n  }\n\n  afterTimes(count: number): () => Promise<void> {\n    return async () => {\n      if (!--count) {\n        await this();\n      }\n    };\n  }\n}\n\nconst eventEmitter = <A, R>(listeners: Listeners<A, R>, event: A): Promise<(void | R)[]> => Promise.all(listeners.map((listener) => listener(event)));\n\ntype EventType<T> = T extends undefined ? void : T;\n\nexport interface Event<T = unknown, R = void> {\n  (event?: EventType<T>): Promise<(R | undefined)[]>;\n}\n\nexport type EventParameters<T> = T extends Event<infer P, unknown> ? P : never;\n\nexport type EventResult<T> = T extends Event<unknown, infer R> ? R : never;\n\nexport type AllEventsParameters<T extends Event<unknown, unknown>[]> = { [K in keyof T]: EventParameters<T[K]> }[number];\n\nexport type AllEventsResults<T extends Event<unknown, unknown>[]> = { [K in keyof T]: EventResult<T[K]> }[number];\n\n/**\n * A class representing an anonymous event that can be listened to or triggered.\n *\n * @typeParam T - The tuple of arguments that the event takes.\n * @typeParam R - The return type of the event.\n */\nexport class Event<T, R> extends FunctionExt {\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   * @example\n   * // Create a click event.\n   * const clickEvent = new Event<[x: number, y: number], void>();\n   * clickEvent.on((x, y) => console.log(`Clicked at ${x}, ${y}`));\n   *\n   * @param dispose - A function to call on the event disposal.\n   */\n  constructor(dispose?: Dispose) {\n    const listeners: Listeners<T, R> = [];\n    const fn = (event: T) => eventEmitter(listeners, event);\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 = (event: T) => {\n      this.off(oneTimeListener);\n      return listener(event);\n    };\n    return this.on(oneTimeListener);\n  }\n\n  /**\n   * Removes all listeners from the event.\n   */\n  clear(): void {\n    this.listeners.splice(0);\n  }\n\n  /**\n   * Returns a Promise that resolves with the first emitted by the event arguments.\n   * @returns A Promise that resolves with the first emitted by the event.\n   */\n  onceAsync(): Promise<T> {\n    return new Promise((resolve) => this.once((event) => resolve(event)));\n  }\n\n  /**\n   * Returns a new event that only triggers when the provided filter function returns `true`.\n   * @example\n   * const spacePressEvent = keyboardEvent.filter((key) => key === 'Space');\n   *\n   * @param filter The filter function to apply to the event.\n   * @returns A new event that only triggers when the provided filter function returns `true`.\n   */\n  filter<P extends T>(predicate: Predicate<T, P>): Event<P, R>;\n  filter<P extends T>(filter: FilterFunction<T>): Event<P, R>;\n  filter<P extends T>(filter: Filter<T, P>): Event<P, R> {\n    const dispose = this.on(async (event: T) => {\n      if (filteredEvent.size > 0 && (await filter(event))) {\n        await filteredEvent(event as EventType<P>);\n      }\n    });\n    const filteredEvent = new Event<P, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Returns a new event that will only be triggered once the provided filter function returns `true`.\n   * @example\n   * const escPressEvent = keyboardEvent.first((key) => key === 'Esc');\n   * await escPressEvent.toPromise();\n   *\n   * @param filter - The filter function.\n   * @returns A new event that will only be triggered once the provided filter function returns `true`.\n   */\n  first<P extends T>(predicate: Predicate<T, P>): Event<P, R>;\n  first<P extends T>(filter: FilterFunction<T>): Event<P, R>;\n  first<P extends T>(filter: Filter<T, P>): Event<P, R> {\n    const dispose = this.on(async (event: T) => {\n      if (filteredEvent.size > 0 && (await filter(event))) {\n        await dispose();\n        await filteredEvent(event as EventType<P>);\n      }\n    });\n    const filteredEvent = new Event<P, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Returns a new event that maps the values of this event using the provided mapper function.\n   * @example\n   * const keyPressEvent = keyboardEvent.map((key) => key.toUpperCase()); // ['a'] -> ['A']\n   *\n   * @param mapper A function that maps the values of this event to a new value.\n   * @returns A new event that emits the mapped values.\n   */\n  map<M, MR = R>(mapper: Mapper<T, M>): Event<M, MR> {\n    const dispose = this.on(async (event) => {\n      if (mappedEvent.size > 0) {\n        const value = await mapper(event);\n        await mappedEvent(value as EventType<M>);\n      }\n    });\n    const mappedEvent = new Event<M, MR>(dispose);\n    return mappedEvent;\n  }\n\n  /**\n   * Returns a new event that reduces the emitted values using the provided reducer function.\n   * @example\n   * const sumEvent = numberEvent.reduce((a, b) => a + b, 0);\n   * sumEvent.on((sum) => console.log(sum)); // 1, 3, 6\n   * sumEvent(1);\n   * sumEvent(2);\n   * sumEvent(3);\n   *\n   * @typeParam A The type of the accumulated value.\n   * @typeParam AR The type of the reduced value.\n   * @param {Reducer<T, A>} reducer The reducer function that accumulates the values emitted by this `Event`.\n   * @param {A} init The initial value of the accumulated value.\n   * @returns {Event<[A], AR>} A new `Event` that emits the reduced value.\n   */\n  reduce<A, AR = R>(reducer: Reducer<T, A>, init: A): Event<A, AR> {\n    let value = init;\n    const dispose = this.on(async (event) => {\n      if (reducedEvent.size > 0) {\n        value = await reducer(value, event);\n        await reducedEvent(value as EventType<A>);\n      }\n    });\n    const reducedEvent = new Event<A, AR>(dispose);\n    return reducedEvent;\n  }\n\n  /**\n   * Returns a new debounced event that will not fire until a certain amount of time has passed\n   * since the last time it was triggered.\n   * @example\n   * const debouncedEvent = textInputEvent.debounce(100);\n   * debouncedEvent.on((str) => console.log(str)); // 'test'\n   * event('t');\n   * event('te');\n   * event('tes');\n   * event('test');\n   *\n   * @param interval - The amount of time to wait before firing the debounced event, in milliseconds.\n   * @returns A new debounced event.\n   */\n  debounce(interval: number): Event<T, R> {\n    let timer: ReturnType<typeof setTimeout>;\n    const dispose = this.on((event) => {\n      clearTimeout(timer);\n      timer = setTimeout(() => debouncedEvent(event as EventType<T>), interval);\n    });\n    const debouncedEvent = new Event<T, R>(dispose);\n    return debouncedEvent;\n  }\n}\n\n/**\n * Merges multiple events into a single event.\n * @example\n * const inputEvent = Event.merge(mouseEvent, keyboardEvent);\n *\n * @param events - The events to merge.\n * @returns The merged event.\n */\nexport const merge = <Events extends Event<any, any>[]>(...events: Events): Event<AllEventsParameters<Events>, AllEventsResults<Events>> => {\n  const mergedEvent = new Event<AllEventsParameters<Events>, AllEventsResults<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 * @example\n * const tickEvent = Event.interval(1000);\n * tickEvent.on((tickNumber) => console.log(tickNumber));\n *\n * @param interval - The interval at which to trigger the event.\n * @returns The interval event.\n */\nexport const createInterval = <R = void>(interval: number): Event<number, R> => {\n  let counter = 0;\n  const intervalEvent = new Event<number, R>(() => clearInterval(timerId));\n  const timerId: ReturnType<typeof setInterval> = setInterval(() => intervalEvent(counter++), interval);\n  return intervalEvent;\n};\n\n/**\n * Creates a new event instance.\n *\n * @typeParam T - An array of argument types that the event will accept.\n * @typeParam R - The return type of the event handler function.\n * @returns A new instance of the `Event` class.\n *\n * @example\n * const myEvent = createEvent<[string], number>();\n * myEvent.on((str: string) => str.length);\n * await myEvent('hello'); // [5]\n */\nexport const createEvent = <T, R = void>(): Event<T, R> => new Event<T, R>();\n\nexport default createEvent;\n\n/**\n * A type helper that extracts the event listener type\n *\n * @typeParam E - The event type.\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n\n/**\n * A type helper that extracts the event filter type\n *\n * @typeParam E The event type to filter.\n */\nexport type EventFilter<E> = FilterFunction<EventParameters<E>>;\n\n/**\n * A type helper that extracts the event predicate type\n *\n * @typeParam E The event type to predicate.\n */\nexport type EventPredicate<E, P extends EventParameters<E>> = Predicate<EventParameters<E>, P>;\n\n/**\n * A type helper that extracts the event mapper type\n *\n * @typeParam E The event type to map.\n * @typeParam M The new type to map `E` to.\n */\nexport type EventMapper<E, M> = Mapper<EventParameters<E>, M>;\n\n/**\n * A type helper that extracts the event mapper type\n *\n * @typeParam E The type of event to reduce.\n * @typeParam M The type of reduced event.\n */\nexport type EventReducer<E, R> = Reducer<EventParameters<E>, R>;\n"],"names":["FunctionExt","Function","constructor","func","Object","setPrototypeOf","prototype","Dismiss","callback","after","task","afterTimes","count","eventEmitter","listeners","event","Promise","all","map","listener","Event","dispose","fn","clear","size","length","lacks","indexOf","has","off","index","splice","on","push","once","oneTimeListener","onceAsync","resolve","filter","filteredEvent","first","mapper","mappedEvent","value","reduce","reducer","init","reducedEvent","debounce","interval","timer","clearTimeout","setTimeout","debouncedEvent","merge","events","mergedEvent","forEach","createInterval","counter","intervalEvent","clearInterval","timerId","setInterval","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 Callback<R = void> {\n  (): MaybePromise<R>;\n}\n\nexport interface Listener<T, R = unknown> {\n  (event: T): MaybePromise<R | void>;\n}\n\nexport interface Result<T, E> {\n  ok: boolean;\n  result: T | E;\n}\n\nexport interface FilterFunction<T> {\n  (event: T): MaybePromise<boolean>;\n}\n\nexport interface Predicate<T, P extends T> {\n  (event: T): event is P;\n}\n\nexport type Filter<T, P extends T> = Predicate<T, P> | FilterFunction<T>;\n\nexport interface Mapper<T, R> {\n  (event: T): MaybePromise<R>;\n}\n\nexport interface Reducer<T, R> {\n  (result: R, event: T): MaybePromise<R>;\n}\n\nexport type Listeners<T, R> = 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  (): MaybePromise<void>;\n}\n\n/**\n * @internal\n */\nexport class Dismiss extends FunctionExt {\n  constructor(callback: Callback) {\n    super(callback);\n  }\n\n  pre(callback: Callback): Dismiss {\n    return new Dismiss(async () => {\n      await callback();\n      await this();\n    });\n  }\n\n  post(callback: Callback): Dismiss {\n    return new Dismiss(async () => {\n      await this();\n      await callback();\n    });\n  }\n\n  countdown(count: number): Dismiss {\n    return new Dismiss(async () => {\n      if (!--count) {\n        await this();\n      }\n    });\n  }\n}\n\nconst eventEmitter = <A, R>(listeners: Listeners<A, R>, event: A): Promise<(void | R)[]> => Promise.all(listeners.map((listener) => listener(event)));\n\ntype EventType<T> = T extends undefined ? void : T;\n\nexport interface Event<T = unknown, R = void> {\n  (event?: EventType<T>): Promise<(R | undefined)[]>;\n}\n\nexport type EventParameters<T> = T extends Event<infer P, unknown> ? P : never;\n\nexport type EventResult<T> = T extends Event<unknown, infer R> ? R : never;\n\nexport type AllEventsParameters<T extends Event<unknown, unknown>[]> = { [K in keyof T]: EventParameters<T[K]> }[number];\n\nexport type AllEventsResults<T extends Event<unknown, unknown>[]> = { [K in keyof T]: EventResult<T[K]> }[number];\n\n/**\n * A class representing an anonymous event that can be listened to or triggered.\n *\n * @typeParam T - The tuple of arguments that the event takes.\n * @typeParam R - The return type of the event.\n */\nexport class Event<T, R> extends FunctionExt {\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: Callback;\n\n  /**\n   * Creates a new event.\n   * @example\n   * // Create a click event.\n   * const clickEvent = new Event<[x: number, y: number], void>();\n   * clickEvent.on((x, y) => console.log(`Clicked at ${x}, ${y}`));\n   *\n   * @param dispose - A function to call on the event disposal.\n   */\n  constructor(dispose?: Callback) {\n    const listeners: Listeners<T, R> = [];\n    const fn = (event: T) => eventEmitter(listeners, event);\n\n    super(fn);\n    this.listeners = listeners;\n    this.dispose = async () => {\n      this.clear();\n      await 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 = (event: T) => {\n      this.off(oneTimeListener);\n      return listener(event);\n    };\n    return this.on(oneTimeListener);\n  }\n\n  /**\n   * Returns a Promise that resolves with the first emitted by the event arguments.\n   * @returns A Promise that resolves with the first emitted by the event.\n   */\n  onceAsync(): Promise<T> {\n    return new Promise((resolve) => this.once((event) => resolve(event)));\n  }\n\n  /**\n   * Removes all listeners from the event.\n   */\n  clear(): void {\n    this.listeners.splice(0);\n  }\n\n  /**\n   * Returns a new event that only triggers when the provided filter function returns `true`.\n   * @example\n   * const spacePressEvent = keyboardEvent.filter((key) => key === 'Space');\n   *\n   * @param filter The filter function to apply to the event.\n   * @returns A new event that only triggers when the provided filter function returns `true`.\n   */\n  filter<P extends T>(predicate: Predicate<T, P>): Event<P, R>;\n  filter<P extends T>(filter: FilterFunction<T>): Event<P, R>;\n  filter<P extends T>(filter: Filter<T, P>): Event<P, R> {\n    const dispose = this.on(async (event: T) => {\n      if (filteredEvent.size > 0 && (await filter(event))) {\n        await filteredEvent(event as EventType<P>);\n      }\n    });\n    const filteredEvent = new Event<P, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Returns a new event that will only be triggered once the provided filter function returns `true`.\n   * @example\n   * const escPressEvent = keyboardEvent.first((key) => key === 'Esc');\n   * await escPressEvent.toPromise();\n   *\n   * @param filter - The filter function.\n   * @returns A new event that will only be triggered once the provided filter function returns `true`.\n   */\n  first<P extends T>(predicate: Predicate<T, P>): Event<P, R>;\n  first<P extends T>(filter: FilterFunction<T>): Event<P, R>;\n  first<P extends T>(filter: Filter<T, P>): Event<P, R> {\n    const dispose = this.on(async (event: T) => {\n      if (filteredEvent.size > 0 && (await filter(event))) {\n        await dispose();\n        await filteredEvent(event as EventType<P>);\n      }\n    });\n    const filteredEvent = new Event<P, R>(dispose);\n    return filteredEvent;\n  }\n\n  /**\n   * Returns a new promise that will be resolved once the provided filter function returns `true`.\n   * @example\n   * const escPressEvent = await keyboardEvent.firstAsync((key) => key === 'Esc');\n   *\n   * @param filter - The filter function.\n   * @returns A new promise that will be resolved once the provided filter function returns `true`.\n   */\n  firstAsync<P extends T>(predicate: Predicate<T, P>): Promise<P>;\n  firstAsync<P extends T>(filter: FilterFunction<T>): Promise<P>;\n  firstAsync<P extends T>(filter: Filter<T, P>): Promise<P> {\n    return this.first<P>(filter).onceAsync();\n  }\n\n  /**\n   * Returns a new event that maps the values of this event using the provided mapper function.\n   * @example\n   * const keyPressEvent = keyboardEvent.map((key) => key.toUpperCase()); // ['a'] -> ['A']\n   *\n   * @param mapper A function that maps the values of this event to a new value.\n   * @returns A new event that emits the mapped values.\n   */\n  map<M, MR = R>(mapper: Mapper<T, M>): Event<M, MR> {\n    const dispose = this.on(async (event) => {\n      if (mappedEvent.size > 0) {\n        const value = await mapper(event);\n        await mappedEvent(value as EventType<M>);\n      }\n    });\n    const mappedEvent = new Event<M, MR>(dispose);\n    return mappedEvent;\n  }\n\n  /**\n   * Returns a new event that reduces the emitted values using the provided reducer function.\n   * @example\n   * const sumEvent = numberEvent.reduce((a, b) => a + b, 0);\n   * sumEvent.on((sum) => console.log(sum)); // 1, 3, 6\n   * sumEvent(1);\n   * sumEvent(2);\n   * sumEvent(3);\n   *\n   * @typeParam A The type of the accumulated value.\n   * @typeParam AR The type of the reduced value.\n   * @param {Reducer<T, A>} reducer The reducer function that accumulates the values emitted by this `Event`.\n   * @param {A} init The initial value of the accumulated value.\n   * @returns {Event<[A], AR>} A new `Event` that emits the reduced value.\n   */\n  reduce<A, AR = R>(reducer: Reducer<T, A>, init: A): Event<A, AR> {\n    let value = init;\n    const dispose = this.on(async (event) => {\n      if (reducedEvent.size > 0) {\n        value = await reducer(value, event);\n        await reducedEvent(value as EventType<A>);\n      }\n    });\n    const reducedEvent = new Event<A, AR>(dispose);\n    return reducedEvent;\n  }\n\n  /**\n   * Returns a new debounced event that will not fire until a certain amount of time has passed\n   * since the last time it was triggered.\n   * @example\n   * const debouncedEvent = textInputEvent.debounce(100);\n   * debouncedEvent.on((str) => console.log(str)); // 'test'\n   * event('t');\n   * event('te');\n   * event('tes');\n   * event('test');\n   *\n   * @param interval - The amount of time to wait before firing the debounced event, in milliseconds.\n   * @returns A new debounced event.\n   */\n  debounce(interval: number): Event<T, R> {\n    let timer: ReturnType<typeof setTimeout>;\n    const dispose = this.on((event) => {\n      clearTimeout(timer);\n      timer = setTimeout(() => debouncedEvent(event as EventType<T>), interval);\n    });\n    const debouncedEvent = new Event<T, R>(dispose);\n    return debouncedEvent;\n  }\n}\n\n/**\n * Merges multiple events into a single event.\n * @example\n * const inputEvent = Event.merge(mouseEvent, keyboardEvent);\n *\n * @param events - The events to merge.\n * @returns The merged event.\n */\nexport const merge = <Events extends Event<any, any>[]>(...events: Events): Event<AllEventsParameters<Events>, AllEventsResults<Events>> => {\n  const mergedEvent = new Event<AllEventsParameters<Events>, AllEventsResults<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 * @example\n * const tickEvent = Event.interval(1000);\n * tickEvent.on((tickNumber) => console.log(tickNumber));\n *\n * @param interval - The interval at which to trigger the event.\n * @returns The interval event.\n */\nexport const createInterval = <R = void>(interval: number): Event<number, R> => {\n  let counter = 0;\n  const intervalEvent = new Event<number, R>(() => clearInterval(timerId));\n  const timerId: ReturnType<typeof setInterval> = setInterval(() => intervalEvent(counter++), interval);\n  return intervalEvent;\n};\n\n/**\n * Creates a new event instance.\n *\n * @typeParam T - An array of argument types that the event will accept.\n * @typeParam R - The return type of the event handler function.\n * @returns A new instance of the `Event` class.\n *\n * @example\n * const myEvent = createEvent<[string], number>();\n * myEvent.on((str: string) => str.length);\n * await myEvent('hello'); // [5]\n */\nexport const createEvent = <T, R = void>(): Event<T, R> => new Event<T, R>();\n\nexport default createEvent;\n\n/**\n * A type helper that extracts the event listener type\n *\n * @typeParam E - The event type.\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n\n/**\n * A type helper that extracts the event filter type\n *\n * @typeParam E The event type to filter.\n */\nexport type EventFilter<E> = FilterFunction<EventParameters<E>>;\n\n/**\n * A type helper that extracts the event predicate type\n *\n * @typeParam E The event type to predicate.\n */\nexport type EventPredicate<E, P extends EventParameters<E>> = Predicate<EventParameters<E>, P>;\n\n/**\n * A type helper that extracts the event mapper type\n *\n * @typeParam E The event type to map.\n * @typeParam M The new type to map `E` to.\n */\nexport type EventMapper<E, M> = Mapper<EventParameters<E>, M>;\n\n/**\n * A type helper that extracts the event mapper type\n *\n * @typeParam E The type of event to reduce.\n * @typeParam M The type of reduced event.\n */\nexport type EventReducer<E, R> = Reducer<EventParameters<E>, R>;\n"],"names":["FunctionExt","Function","constructor","func","Object","setPrototypeOf","prototype","Dismiss","callback","pre","post","countdown","count","eventEmitter","listeners","event","Promise","all","map","listener","Event","dispose","fn","clear","size","length","lacks","indexOf","has","off","index","splice","on","push","once","oneTimeListener","onceAsync","resolve","filter","filteredEvent","first","firstAsync","mapper","mappedEvent","value","reduce","reducer","init","reducedEvent","debounce","interval","timer","clearTimeout","setTimeout","debouncedEvent","merge","events","mergedEvent","forEach","createInterval","counter","intervalEvent","clearInterval","timerId","setInterval","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 reactive anonymous event library",
-  "version": "2.0.0",
+  "version": "2.1.2",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
@@ -16,13 +16,6 @@
     "src/__tests__/example.js"
   ],
   "sideEffects": false,
-  "scripts": {
-    "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
-    "test": "jest",
-    "test:build": "node src/__tests__/index.cjs && node src/__tests__/index.mjs",
-    "lint": "eslint src",
-    "prepare": "husky install"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/3axap4eHko/evnty.git"
@@ -58,18 +51,24 @@
   "devDependencies": {
     "@swc/jest": "^0.2.29",
     "@types/jest": "^29.5.5",
-    "@types/node": "^20.7.0",
-    "@typescript-eslint/eslint-plugin": "^6.7.3",
-    "@typescript-eslint/parser": "^6.7.3",
-    "eslint": "^8.50.0",
+    "@types/node": "^20.8.6",
+    "@typescript-eslint/eslint-plugin": "^6.8.0",
+    "@typescript-eslint/parser": "^6.8.0",
+    "eslint": "^8.51.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-import": "^2.28.1",
-    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-prettier": "^5.0.1",
     "husky": "^8.0.3",
     "inop": "^0.4.2",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",
-    "typescript": "^5.0.4"
+    "typescript": "^5.2.2"
+  },
+  "scripts": {
+    "build": "rm -rf build && inop src build -i __tests__ -i *.tmp.ts && tsc --declaration --emitDeclarationOnly",
+    "test": "jest",
+    "test:build": "node src/__tests__/index.cjs && node src/__tests__/index.mjs",
+    "lint": "eslint src"
   }
-}
+}

package/src/index.ts

@@ -1,26 +1,18 @@
 export type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;
 
-export interface Unsubscribe {
-  (): void;
+export interface Callback<R = void> {
+  (): MaybePromise<R>;
 }
 
 export interface Listener<T, R = unknown> {
   (event: T): MaybePromise<R | void>;
 }
 
-export interface Dispose {
-  (): void;
-}
-
 export interface Result<T, E> {
   ok: boolean;
   result: T | E;
 }
 
-export interface Resolver<T, P> {
-  (event: T): Promise<P>;
-}
-
 export interface FilterFunction<T> {
   (event: T): MaybePromise<boolean>;
 }
@@ -55,32 +47,37 @@ export abstract class FunctionExt extends Function {
 }
 
 export interface Dismiss {
-  (): Promise<void> | void;
-}
-
-export interface Task {
-  (): MaybePromise<unknown>;
+  (): MaybePromise<void>;
 }
 
 /**
  * @internal
  */
 export class Dismiss extends FunctionExt {
-  constructor(callback: Unsubscribe) {
+  constructor(callback: Callback) {
     super(callback);
   }
 
-  async after(task: Task): Promise<void> {
-    await task();
-    await this();
+  pre(callback: Callback): Dismiss {
+    return new Dismiss(async () => {
+      await callback();
+      await this();
+    });
   }
 
-  afterTimes(count: number): () => Promise<void> {
-    return async () => {
+  post(callback: Callback): Dismiss {
+    return new Dismiss(async () => {
+      await this();
+      await callback();
+    });
+  }
+
+  countdown(count: number): Dismiss {
+    return new Dismiss(async () => {
       if (!--count) {
         await this();
       }
-    };
+    });
   }
 }
 
@@ -115,7 +112,7 @@ export class Event<T, R> extends FunctionExt {
   /**
    * A function that disposes of the event and its listeners.
    */
-  readonly dispose: Dispose;
+  readonly dispose: Callback;
 
   /**
    * Creates a new event.
@@ -126,15 +123,15 @@ export class Event<T, R> extends FunctionExt {
    *
    * @param dispose - A function to call on the event disposal.
    */
-  constructor(dispose?: Dispose) {
+  constructor(dispose?: Callback) {
     const listeners: Listeners<T, R> = [];
     const fn = (event: T) => eventEmitter(listeners, event);
 
     super(fn);
     this.listeners = listeners;
-    this.dispose = () => {
+    this.dispose = async () => {
       this.clear();
-      dispose?.();
+      await dispose?.();
     };
   }
 
@@ -198,13 +195,6 @@ export class Event<T, R> extends FunctionExt {
     return this.on(oneTimeListener);
   }
 
-  /**
-   * Removes all listeners from the event.
-   */
-  clear(): void {
-    this.listeners.splice(0);
-  }
-
   /**
    * Returns a Promise that resolves with the first emitted by the event arguments.
    * @returns A Promise that resolves with the first emitted by the event.
@@ -213,6 +203,13 @@ export class Event<T, R> extends FunctionExt {
     return new Promise((resolve) => this.once((event) => resolve(event)));
   }
 
+  /**
+   * Removes all listeners from the event.
+   */
+  clear(): void {
+    this.listeners.splice(0);
+  }
+
   /**
    * Returns a new event that only triggers when the provided filter function returns `true`.
    * @example
@@ -255,6 +252,20 @@ export class Event<T, R> extends FunctionExt {
     return filteredEvent;
   }
 
+  /**
+   * Returns a new promise that will be resolved once the provided filter function returns `true`.
+   * @example
+   * const escPressEvent = await keyboardEvent.firstAsync((key) => key === 'Esc');
+   *
+   * @param filter - The filter function.
+   * @returns A new promise that will be resolved once the provided filter function returns `true`.
+   */
+  firstAsync<P extends T>(predicate: Predicate<T, P>): Promise<P>;
+  firstAsync<P extends T>(filter: FilterFunction<T>): Promise<P>;
+  firstAsync<P extends T>(filter: Filter<T, P>): Promise<P> {
+    return this.first<P>(filter).onceAsync();
+  }
+
   /**
    * Returns a new event that maps the values of this event using the provided mapper function.
    * @example

package/src/__tests__/index.ts

@@ -1,383 +0,0 @@
-import createEvent, { merge, createInterval, Event, Dismiss, FunctionExt, EventHandler, FilterFunction, Predicate } from '../index';
-
-describe('Anonymous Event test suite', () => {
-  test('FunctionExt extends from Function', () => {
-    expect(FunctionExt.prototype).toBeInstanceOf(Function);
-  });
-
-  test('Dismiss extends from FunctionExt', () => {
-    expect(Dismiss.prototype).toBeInstanceOf(FunctionExt);
-  });
-
-  test('Event extends from FunctionExt', () => {
-    expect(Event.prototype).toBeInstanceOf(FunctionExt);
-  });
-
-  it('Should be instantiable', () => {
-    expect(() => new Event()).not.toThrow();
-  });
-
-  it('Should be instantiable', () => {
-    expect(() => createEvent<[number]>()).not.toThrow();
-  });
-
-  it('Should be instantiable', () => {
-    expect(() => createEvent<[string], string>()).not.toThrow();
-  });
-
-  it('Should call parent constructor', () => {
-    const EventOriginal = Object.getPrototypeOf(Event);
-    const EventMock = jest.fn();
-
-    Object.setPrototypeOf(Event, EventMock);
-
-    expect(() => new Event()).not.toThrow();
-    expect(EventMock).toHaveBeenCalled();
-
-    Object.setPrototypeOf(Event, EventOriginal);
-  });
-
-  it('Should be callable', () => {
-    const event = new Event();
-    expect(() => event()).not.toThrow();
-  });
-
-  it('Should check event existence', () => {
-    const event = new Event();
-    const listener: EventHandler<typeof event> = jest.fn();
-    event.on(listener);
-    expect(event.has(listener)).toEqual(true);
-    event.off(listener);
-    expect(event.lacks(listener)).toEqual(true);
-  });
-
-  it('Should add event listener', async () => {
-    const event = new Event();
-    const listener = jest.fn();
-    event.on(listener);
-    await event('test');
-    expect(event.size).toEqual(1);
-    expect(listener).toHaveBeenCalledWith('test');
-  });
-
-  it('Should remove existing event listener', async () => {
-    const event = new Event();
-    const listener = jest.fn();
-    event.on(listener);
-    event.off(listener);
-    await event('test');
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  it('Should remove all existing event listeners', async () => {
-    const event = new Event();
-    const listener = jest.fn();
-    event.on(listener);
-    event.on(listener);
-    event.off(listener);
-    await event('test');
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  it('Should not remove other event listeners', async () => {
-    const event = new Event();
-    const listener = jest.fn();
-    event.on(listener);
-    event.off(jest.fn());
-    await event('test');
-    expect(listener).toHaveBeenCalled();
-  });
-
-  it('Should unsubscribe event', async () => {
-    const event = new Event();
-    const listener = jest.fn();
-    const unsubscribe = event.on(listener);
-    unsubscribe();
-    await event('test');
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  it('Should add one time event listener', async () => {
-    const event = new Event();
-    const listener = jest.fn();
-    event.once(listener);
-    await event('test');
-    await event('test');
-    expect(listener).toHaveBeenCalledTimes(1);
-  });
-
-  it('Should clear all events', async () => {
-    const event = new Event();
-    const listener = jest.fn();
-    event.on(listener);
-
-    event.clear();
-    expect(event.size).toEqual(0);
-
-    await event('test');
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  it('Should return event promise', async () => {
-    const listener = jest.fn();
-    const event = new Event();
-    event.on(listener);
-    expect(listener).not.toBeCalled();
-    const promise = event.onceAsync();
-    await event('test');
-    const result = await promise;
-    expect(result).toEqual('test');
-    expect(listener).toBeCalledWith('test');
-  });
-
-  it('Should create predicated and filtered events', async () => {
-    const listener = jest.fn();
-
-    type ClickEvent = { x: number; y: number; button: number };
-    type LeftClickEvent = ClickEvent & { button: 1 };
-
-    const clickEvent = createEvent<ClickEvent>();
-    const leftClickPredicate: Predicate<ClickEvent, LeftClickEvent> = (mouseClickEvent): mouseClickEvent is LeftClickEvent => mouseClickEvent.button === 1;
-    const leftClickPredicatedEvent = clickEvent.filter(leftClickPredicate);
-    leftClickPredicatedEvent.on(listener);
-    leftClickPredicatedEvent({ x: 1, y: 1, button: 1 });
-
-    const leftClickFiltered: FilterFunction<ClickEvent> = ({ button }) => button === 1;
-    const leftClickFilteredEvent = clickEvent.filter<LeftClickEvent>(leftClickFiltered);
-    leftClickFilteredEvent.on(listener);
-    leftClickFilteredEvent({ x: 1, y: 1, button: 1 });
-
-    await clickEvent({ x: 1, y: 1, button: 1 });
-    await clickEvent({ x: 1, y: 1, button: 2 });
-
-    expect(listener).toHaveBeenCalledTimes(4);
-    expect(listener).not.toHaveBeenCalledWith({ x: 1, y: 1, button: 2 });
-  });
-
-  it('Should create predicated event', async () => {
-    type TestEvent = { name: string; value: number };
-    const listener = jest.fn();
-
-    const predicate = (event: TestEvent): event is TestEvent & { name: 'two' } => event.name === 'two';
-    const predicateMock = jest.fn(predicate);
-    const event = new Event<TestEvent>();
-    const predicatedEvent = event.filter(predicateMock as unknown as typeof predicate);
-    expect(event.size).toEqual(1);
-
-    predicatedEvent.on(listener);
-    expect(predicatedEvent.size).toEqual(1);
-
-    await event({ name: 'one', value: 1 });
-    await event({ name: 'two', value: 2 });
-    await event({ name: 'three', value: 3 });
-
-    expect(predicateMock).toHaveBeenCalledTimes(3);
-    expect(predicateMock).toHaveBeenNthCalledWith(1, { name: 'one', value: 1 });
-    expect(predicateMock).toHaveBeenNthCalledWith(2, { name: 'two', value: 2 });
-    expect(predicateMock).toHaveBeenNthCalledWith(3, { name: 'three', value: 3 });
-
-    expect(listener).toHaveBeenCalledTimes(1);
-    expect(listener).toHaveBeenCalledWith({ name: 'two', value: 2 });
-  });
-
-  it('Should create filtered event', async () => {
-    type TestEvent = { name: string; value: number };
-    const listener = jest.fn();
-    const filter = (event: TestEvent) => event.name === 'two';
-    const filterMock = jest.fn(filter);
-    const event = new Event<TestEvent>();
-    const filteredEvent = event.filter(filterMock as unknown as typeof filter);
-    expect(event.size).toEqual(1);
-
-    filteredEvent.on(listener);
-    expect(filteredEvent.size).toEqual(1);
-
-    await event({ name: 'one', value: 1 });
-    await event({ name: 'two', value: 2 });
-    await event({ name: 'three', value: 3 });
-
-    expect(filterMock).toHaveBeenCalledTimes(3);
-    expect(filterMock).toHaveBeenNthCalledWith(1, { name: 'one', value: 1 });
-    expect(filterMock).toHaveBeenNthCalledWith(2, { name: 'two', value: 2 });
-    expect(filterMock).toHaveBeenNthCalledWith(3, { name: 'three', value: 3 });
-
-    expect(listener).toHaveBeenCalledTimes(1);
-    expect(listener).toHaveBeenCalledWith({ name: 'two', value: 2 });
-  });
-
-  it('Should create one time filtered event', async () => {
-    type TestEvent = { name: string; value: number };
-
-    const predicate = (event: TestEvent): event is TestEvent & { name: 'two' } => event.name === 'two';
-    const predicateMock = jest.fn(predicate);
-    const listener = jest.fn();
-
-    const event = new Event<TestEvent>();
-    const filteredEvent = event.first(predicateMock as unknown as typeof predicate);
-    expect(event.size).toEqual(1);
-
-    filteredEvent.on(listener);
-    expect(filteredEvent.size).toEqual(1);
-
-    await event({ name: 'one', value: 1 });
-    await event({ name: 'two', value: 2 });
-    await event({ name: 'three', value: 3 });
-
-    expect(listener).toHaveBeenCalledTimes(1);
-    expect(listener).toHaveBeenCalledWith({ name: 'two', value: 2 });
-
-    expect(predicateMock).toHaveBeenCalledTimes(2);
-    expect(predicateMock).toHaveBeenNthCalledWith(1, { name: 'one', value: 1 });
-    expect(predicateMock).toHaveBeenNthCalledWith(2, { name: 'two', value: 2 });
-  });
-
-  it('Should create mapped event', async () => {
-    const listener = jest.fn();
-    const mapper = jest.fn((value) => value * 2);
-
-    const event = new Event();
-    const mappedEvent = event.map(mapper);
-    expect(event.size).toEqual(1);
-    await event(1);
-
-    mappedEvent.on(listener);
-    expect(mappedEvent.size).toEqual(1);
-
-    await event(1);
-    await event(2);
-    await event(3);
-
-    expect(mapper).toHaveBeenCalledTimes(3);
-    expect(mapper).toHaveBeenNthCalledWith(1, 1);
-    expect(mapper).toHaveBeenNthCalledWith(2, 2);
-    expect(mapper).toHaveBeenNthCalledWith(3, 3);
-
-    expect(listener).toHaveBeenCalledTimes(3);
-    expect(listener).toHaveBeenCalledWith(2);
-    expect(listener).toHaveBeenCalledWith(4);
-    expect(listener).toHaveBeenCalledWith(6);
-  });
-
-  it('Should create reduced event', async () => {
-    const listener = jest.fn();
-    const reducer = jest.fn((result, value) => result + value);
-
-    const event = new Event();
-    const reducedEvent = event.reduce(reducer, 0);
-    expect(event.size).toEqual(1);
-    await event(1);
-
-    reducedEvent.on(listener);
-    expect(reducedEvent.size).toEqual(1);
-
-    await event(1);
-    await event(2);
-    await event(3);
-
-    expect(reducer).toHaveBeenCalledTimes(3);
-    expect(reducer).toHaveBeenNthCalledWith(1, 0, 1);
-    expect(reducer).toHaveBeenNthCalledWith(2, 0 + 1, 2);
-    expect(reducer).toHaveBeenNthCalledWith(3, 0 + 1 + 2, 3);
-
-    expect(listener).toHaveBeenCalledTimes(3);
-    expect(listener).toHaveBeenCalledWith(1);
-    expect(listener).toHaveBeenCalledWith(3);
-    expect(listener).toHaveBeenCalledWith(6);
-  });
-
-  it('Should merge multiple events', async () => {
-    const listener = jest.fn();
-
-    const event1 = new Event<string, number>();
-    const event2 = new Event<number, boolean>();
-    const event3 = new Event<boolean, string>();
-    const mergedEvent = merge(event1, event2, event3);
-
-    mergedEvent.on(listener);
-
-    await event1('a');
-    await event2(1);
-    await event3(true);
-    await mergedEvent('b');
-    await mergedEvent(2);
-    await mergedEvent(false);
-
-    expect(listener).toHaveBeenCalledTimes(6);
-    expect(listener).toHaveBeenNthCalledWith(1, 'a');
-    expect(listener).toHaveBeenNthCalledWith(2, 1);
-    expect(listener).toHaveBeenNthCalledWith(3, true);
-    expect(listener).toHaveBeenNthCalledWith(4, 'b');
-    expect(listener).toHaveBeenNthCalledWith(5, 2);
-    expect(listener).toHaveBeenNthCalledWith(6, false);
-  });
-
-  it('Should create interval events', async () => {
-    const listener = jest.fn();
-    const event = createInterval(10);
-    event.on(listener);
-    await event.onceAsync();
-    expect(listener).toBeCalledWith(0);
-    event.dispose();
-    const result = await Promise.race([new Promise((resolve) => setTimeout(resolve, 100, null)), event.onceAsync()]);
-    expect(result).toEqual(null);
-  });
-
-  it('Should dismiss event listener', async () => {
-    const listener = jest.fn();
-    const event = createInterval(10);
-    event.on(listener);
-    await event.onceAsync();
-    expect(listener).toBeCalledWith(0);
-    event.dispose();
-    const result = await Promise.race([new Promise(process.nextTick).then(Boolean), event.onceAsync()]);
-    expect(result).toEqual(true);
-  });
-
-  it('Should dismiss event after task finished', async () => {
-    const listener = jest.fn();
-    const event = new Event();
-    const dismiss = event.on(listener);
-    await event();
-    expect(listener).toHaveBeenCalledTimes(1);
-    const nextTick = new Promise(process.nextTick);
-    dismiss.after(() => nextTick);
-    await nextTick;
-    await event();
-    expect(listener).toHaveBeenCalledTimes(1);
-  });
-
-  it('Should dismiss event after certain events', async () => {
-    const listener = jest.fn();
-    const event = new Event();
-    const dismiss = event.on(listener);
-    const timesCallback = dismiss.afterTimes(2);
-    await event();
-    await timesCallback();
-    await event();
-    await timesCallback();
-    await event();
-    await timesCallback();
-    await event();
-    expect(listener).toHaveBeenCalledTimes(2);
-  });
-
-  it('Should return listeners values', async () => {
-    const event = new Event<string, number | string>();
-    event.on(() => 1);
-    event.on(() => 'test');
-    event.on(() => {});
-    const result = (await event('test')) satisfies (number | string | void)[];
-    expect(result).toEqual([1, 'test', undefined]);
-  });
-
-  it('Should debounce events', async () => {
-    const listener = jest.fn();
-    const event = new Event<string, number | string>();
-    const debouncedEvent = event.debounce(10);
-    debouncedEvent.on(listener);
-    await event('test1');
-    await event('test2');
-    await debouncedEvent.onceAsync();
-    expect(listener).toBeCalledTimes(1);
-  });
-});